dir.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * linux/fs/ufs/ufs_dir.c
  4. *
  5. * Copyright (C) 1996
  6. * Adrian Rodriguez (adrian@franklins-tower.rutgers.edu)
  7. * Laboratory for Computer Science Research Computing Facility
  8. * Rutgers, The State University of New Jersey
  9. *
  10. * swab support by Francois-Rene Rideau <fare@tunes.org> 19970406
  11. *
  12. * 4.4BSD (FreeBSD) support added on February 1st 1998 by
  13. * Niels Kristian Bech Jensen <nkbj@image.dk> partially based
  14. * on code by Martin von Loewis <martin@mira.isdn.cs.tu-berlin.de>.
  15. *
  16. * Migration to usage of "page cache" on May 2006 by
  17. * Evgeniy Dushistov <dushistov@mail.ru> based on ext2 code base.
  18. */
  19. #include <linux/time.h>
  20. #include <linux/fs.h>
  21. #include <linux/swap.h>
  22. #include <linux/iversion.h>
  23. #include "ufs_fs.h"
  24. #include "ufs.h"
  25. #include "swab.h"
  26. #include "util.h"
  27. /*
  28. * NOTE! unlike strncmp, ufs_match returns 1 for success, 0 for failure.
  29. *
  30. * len <= UFS_MAXNAMLEN and de != NULL are guaranteed by caller.
  31. */
  32. static inline int ufs_match(struct super_block *sb, int len,
  33. const unsigned char *name, struct ufs_dir_entry *de)
  34. {
  35. if (len != ufs_get_de_namlen(sb, de))
  36. return 0;
  37. if (!de->d_ino)
  38. return 0;
  39. return !memcmp(name, de->d_name, len);
  40. }
  41. static int ufs_commit_chunk(struct page *page, loff_t pos, unsigned len)
  42. {
  43. struct address_space *mapping = page->mapping;
  44. struct inode *dir = mapping->host;
  45. int err = 0;
  46. inode_inc_iversion(dir);
  47. block_write_end(NULL, mapping, pos, len, len, page, NULL);
  48. if (pos+len > dir->i_size) {
  49. i_size_write(dir, pos+len);
  50. mark_inode_dirty(dir);
  51. }
  52. if (IS_DIRSYNC(dir))
  53. err = write_one_page(page);
  54. else
  55. unlock_page(page);
  56. return err;
  57. }
  58. static inline void ufs_put_page(struct page *page)
  59. {
  60. kunmap(page);
  61. put_page(page);
  62. }
  63. ino_t ufs_inode_by_name(struct inode *dir, const struct qstr *qstr)
  64. {
  65. ino_t res = 0;
  66. struct ufs_dir_entry *de;
  67. struct page *page;
  68. de = ufs_find_entry(dir, qstr, &page);
  69. if (de) {
  70. res = fs32_to_cpu(dir->i_sb, de->d_ino);
  71. ufs_put_page(page);
  72. }
  73. return res;
  74. }
  75. /* Releases the page */
  76. void ufs_set_link(struct inode *dir, struct ufs_dir_entry *de,
  77. struct page *page, struct inode *inode,
  78. bool update_times)
  79. {
  80. loff_t pos = page_offset(page) +
  81. (char *) de - (char *) page_address(page);
  82. unsigned len = fs16_to_cpu(dir->i_sb, de->d_reclen);
  83. int err;
  84. lock_page(page);
  85. err = ufs_prepare_chunk(page, pos, len);
  86. BUG_ON(err);
  87. de->d_ino = cpu_to_fs32(dir->i_sb, inode->i_ino);
  88. ufs_set_de_type(dir->i_sb, de, inode->i_mode);
  89. err = ufs_commit_chunk(page, pos, len);
  90. ufs_put_page(page);
  91. if (update_times)
  92. dir->i_mtime = dir->i_ctime = current_time(dir);
  93. mark_inode_dirty(dir);
  94. }
  95. static bool ufs_check_page(struct page *page)
  96. {
  97. struct inode *dir = page->mapping->host;
  98. struct super_block *sb = dir->i_sb;
  99. char *kaddr = page_address(page);
  100. unsigned offs, rec_len;
  101. unsigned limit = PAGE_SIZE;
  102. const unsigned chunk_mask = UFS_SB(sb)->s_uspi->s_dirblksize - 1;
  103. struct ufs_dir_entry *p;
  104. char *error;
  105. if ((dir->i_size >> PAGE_SHIFT) == page->index) {
  106. limit = dir->i_size & ~PAGE_MASK;
  107. if (limit & chunk_mask)
  108. goto Ebadsize;
  109. if (!limit)
  110. goto out;
  111. }
  112. for (offs = 0; offs <= limit - UFS_DIR_REC_LEN(1); offs += rec_len) {
  113. p = (struct ufs_dir_entry *)(kaddr + offs);
  114. rec_len = fs16_to_cpu(sb, p->d_reclen);
  115. if (rec_len < UFS_DIR_REC_LEN(1))
  116. goto Eshort;
  117. if (rec_len & 3)
  118. goto Ealign;
  119. if (rec_len < UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, p)))
  120. goto Enamelen;
  121. if (((offs + rec_len - 1) ^ offs) & ~chunk_mask)
  122. goto Espan;
  123. if (fs32_to_cpu(sb, p->d_ino) > (UFS_SB(sb)->s_uspi->s_ipg *
  124. UFS_SB(sb)->s_uspi->s_ncg))
  125. goto Einumber;
  126. }
  127. if (offs != limit)
  128. goto Eend;
  129. out:
  130. SetPageChecked(page);
  131. return true;
  132. /* Too bad, we had an error */
  133. Ebadsize:
  134. ufs_error(sb, "ufs_check_page",
  135. "size of directory #%lu is not a multiple of chunk size",
  136. dir->i_ino
  137. );
  138. goto fail;
  139. Eshort:
  140. error = "rec_len is smaller than minimal";
  141. goto bad_entry;
  142. Ealign:
  143. error = "unaligned directory entry";
  144. goto bad_entry;
  145. Enamelen:
  146. error = "rec_len is too small for name_len";
  147. goto bad_entry;
  148. Espan:
  149. error = "directory entry across blocks";
  150. goto bad_entry;
  151. Einumber:
  152. error = "inode out of bounds";
  153. bad_entry:
  154. ufs_error (sb, "ufs_check_page", "bad entry in directory #%lu: %s - "
  155. "offset=%lu, rec_len=%d, name_len=%d",
  156. dir->i_ino, error, (page->index<<PAGE_SHIFT)+offs,
  157. rec_len, ufs_get_de_namlen(sb, p));
  158. goto fail;
  159. Eend:
  160. p = (struct ufs_dir_entry *)(kaddr + offs);
  161. ufs_error(sb, __func__,
  162. "entry in directory #%lu spans the page boundary"
  163. "offset=%lu",
  164. dir->i_ino, (page->index<<PAGE_SHIFT)+offs);
  165. fail:
  166. SetPageError(page);
  167. return false;
  168. }
  169. static struct page *ufs_get_page(struct inode *dir, unsigned long n)
  170. {
  171. struct address_space *mapping = dir->i_mapping;
  172. struct page *page = read_mapping_page(mapping, n, NULL);
  173. if (!IS_ERR(page)) {
  174. kmap(page);
  175. if (unlikely(!PageChecked(page))) {
  176. if (PageError(page) || !ufs_check_page(page))
  177. goto fail;
  178. }
  179. }
  180. return page;
  181. fail:
  182. ufs_put_page(page);
  183. return ERR_PTR(-EIO);
  184. }
  185. /*
  186. * Return the offset into page `page_nr' of the last valid
  187. * byte in that page, plus one.
  188. */
  189. static unsigned
  190. ufs_last_byte(struct inode *inode, unsigned long page_nr)
  191. {
  192. unsigned last_byte = inode->i_size;
  193. last_byte -= page_nr << PAGE_SHIFT;
  194. if (last_byte > PAGE_SIZE)
  195. last_byte = PAGE_SIZE;
  196. return last_byte;
  197. }
  198. static inline struct ufs_dir_entry *
  199. ufs_next_entry(struct super_block *sb, struct ufs_dir_entry *p)
  200. {
  201. return (struct ufs_dir_entry *)((char *)p +
  202. fs16_to_cpu(sb, p->d_reclen));
  203. }
  204. struct ufs_dir_entry *ufs_dotdot(struct inode *dir, struct page **p)
  205. {
  206. struct page *page = ufs_get_page(dir, 0);
  207. struct ufs_dir_entry *de = NULL;
  208. if (!IS_ERR(page)) {
  209. de = ufs_next_entry(dir->i_sb,
  210. (struct ufs_dir_entry *)page_address(page));
  211. *p = page;
  212. }
  213. return de;
  214. }
  215. /*
  216. * ufs_find_entry()
  217. *
  218. * finds an entry in the specified directory with the wanted name. It
  219. * returns the page in which the entry was found, and the entry itself
  220. * (as a parameter - res_dir). Page is returned mapped and unlocked.
  221. * Entry is guaranteed to be valid.
  222. */
  223. struct ufs_dir_entry *ufs_find_entry(struct inode *dir, const struct qstr *qstr,
  224. struct page **res_page)
  225. {
  226. struct super_block *sb = dir->i_sb;
  227. const unsigned char *name = qstr->name;
  228. int namelen = qstr->len;
  229. unsigned reclen = UFS_DIR_REC_LEN(namelen);
  230. unsigned long start, n;
  231. unsigned long npages = dir_pages(dir);
  232. struct page *page = NULL;
  233. struct ufs_inode_info *ui = UFS_I(dir);
  234. struct ufs_dir_entry *de;
  235. UFSD("ENTER, dir_ino %lu, name %s, namlen %u\n", dir->i_ino, name, namelen);
  236. if (npages == 0 || namelen > UFS_MAXNAMLEN)
  237. goto out;
  238. /* OFFSET_CACHE */
  239. *res_page = NULL;
  240. start = ui->i_dir_start_lookup;
  241. if (start >= npages)
  242. start = 0;
  243. n = start;
  244. do {
  245. char *kaddr;
  246. page = ufs_get_page(dir, n);
  247. if (!IS_ERR(page)) {
  248. kaddr = page_address(page);
  249. de = (struct ufs_dir_entry *) kaddr;
  250. kaddr += ufs_last_byte(dir, n) - reclen;
  251. while ((char *) de <= kaddr) {
  252. if (ufs_match(sb, namelen, name, de))
  253. goto found;
  254. de = ufs_next_entry(sb, de);
  255. }
  256. ufs_put_page(page);
  257. }
  258. if (++n >= npages)
  259. n = 0;
  260. } while (n != start);
  261. out:
  262. return NULL;
  263. found:
  264. *res_page = page;
  265. ui->i_dir_start_lookup = n;
  266. return de;
  267. }
  268. /*
  269. * Parent is locked.
  270. */
  271. int ufs_add_link(struct dentry *dentry, struct inode *inode)
  272. {
  273. struct inode *dir = d_inode(dentry->d_parent);
  274. const unsigned char *name = dentry->d_name.name;
  275. int namelen = dentry->d_name.len;
  276. struct super_block *sb = dir->i_sb;
  277. unsigned reclen = UFS_DIR_REC_LEN(namelen);
  278. const unsigned int chunk_size = UFS_SB(sb)->s_uspi->s_dirblksize;
  279. unsigned short rec_len, name_len;
  280. struct page *page = NULL;
  281. struct ufs_dir_entry *de;
  282. unsigned long npages = dir_pages(dir);
  283. unsigned long n;
  284. char *kaddr;
  285. loff_t pos;
  286. int err;
  287. UFSD("ENTER, name %s, namelen %u\n", name, namelen);
  288. /*
  289. * We take care of directory expansion in the same loop.
  290. * This code plays outside i_size, so it locks the page
  291. * to protect that region.
  292. */
  293. for (n = 0; n <= npages; n++) {
  294. char *dir_end;
  295. page = ufs_get_page(dir, n);
  296. err = PTR_ERR(page);
  297. if (IS_ERR(page))
  298. goto out;
  299. lock_page(page);
  300. kaddr = page_address(page);
  301. dir_end = kaddr + ufs_last_byte(dir, n);
  302. de = (struct ufs_dir_entry *)kaddr;
  303. kaddr += PAGE_SIZE - reclen;
  304. while ((char *)de <= kaddr) {
  305. if ((char *)de == dir_end) {
  306. /* We hit i_size */
  307. name_len = 0;
  308. rec_len = chunk_size;
  309. de->d_reclen = cpu_to_fs16(sb, chunk_size);
  310. de->d_ino = 0;
  311. goto got_it;
  312. }
  313. if (de->d_reclen == 0) {
  314. ufs_error(dir->i_sb, __func__,
  315. "zero-length directory entry");
  316. err = -EIO;
  317. goto out_unlock;
  318. }
  319. err = -EEXIST;
  320. if (ufs_match(sb, namelen, name, de))
  321. goto out_unlock;
  322. name_len = UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de));
  323. rec_len = fs16_to_cpu(sb, de->d_reclen);
  324. if (!de->d_ino && rec_len >= reclen)
  325. goto got_it;
  326. if (rec_len >= name_len + reclen)
  327. goto got_it;
  328. de = (struct ufs_dir_entry *) ((char *) de + rec_len);
  329. }
  330. unlock_page(page);
  331. ufs_put_page(page);
  332. }
  333. BUG();
  334. return -EINVAL;
  335. got_it:
  336. pos = page_offset(page) +
  337. (char*)de - (char*)page_address(page);
  338. err = ufs_prepare_chunk(page, pos, rec_len);
  339. if (err)
  340. goto out_unlock;
  341. if (de->d_ino) {
  342. struct ufs_dir_entry *de1 =
  343. (struct ufs_dir_entry *) ((char *) de + name_len);
  344. de1->d_reclen = cpu_to_fs16(sb, rec_len - name_len);
  345. de->d_reclen = cpu_to_fs16(sb, name_len);
  346. de = de1;
  347. }
  348. ufs_set_de_namlen(sb, de, namelen);
  349. memcpy(de->d_name, name, namelen + 1);
  350. de->d_ino = cpu_to_fs32(sb, inode->i_ino);
  351. ufs_set_de_type(sb, de, inode->i_mode);
  352. err = ufs_commit_chunk(page, pos, rec_len);
  353. dir->i_mtime = dir->i_ctime = current_time(dir);
  354. mark_inode_dirty(dir);
  355. /* OFFSET_CACHE */
  356. out_put:
  357. ufs_put_page(page);
  358. out:
  359. return err;
  360. out_unlock:
  361. unlock_page(page);
  362. goto out_put;
  363. }
  364. static inline unsigned
  365. ufs_validate_entry(struct super_block *sb, char *base,
  366. unsigned offset, unsigned mask)
  367. {
  368. struct ufs_dir_entry *de = (struct ufs_dir_entry*)(base + offset);
  369. struct ufs_dir_entry *p = (struct ufs_dir_entry*)(base + (offset&mask));
  370. while ((char*)p < (char*)de)
  371. p = ufs_next_entry(sb, p);
  372. return (char *)p - base;
  373. }
  374. /*
  375. * This is blatantly stolen from ext2fs
  376. */
  377. static int
  378. ufs_readdir(struct file *file, struct dir_context *ctx)
  379. {
  380. loff_t pos = ctx->pos;
  381. struct inode *inode = file_inode(file);
  382. struct super_block *sb = inode->i_sb;
  383. unsigned int offset = pos & ~PAGE_MASK;
  384. unsigned long n = pos >> PAGE_SHIFT;
  385. unsigned long npages = dir_pages(inode);
  386. unsigned chunk_mask = ~(UFS_SB(sb)->s_uspi->s_dirblksize - 1);
  387. bool need_revalidate = !inode_eq_iversion(inode, file->f_version);
  388. unsigned flags = UFS_SB(sb)->s_flags;
  389. UFSD("BEGIN\n");
  390. if (pos > inode->i_size - UFS_DIR_REC_LEN(1))
  391. return 0;
  392. for ( ; n < npages; n++, offset = 0) {
  393. char *kaddr, *limit;
  394. struct ufs_dir_entry *de;
  395. struct page *page = ufs_get_page(inode, n);
  396. if (IS_ERR(page)) {
  397. ufs_error(sb, __func__,
  398. "bad page in #%lu",
  399. inode->i_ino);
  400. ctx->pos += PAGE_SIZE - offset;
  401. return -EIO;
  402. }
  403. kaddr = page_address(page);
  404. if (unlikely(need_revalidate)) {
  405. if (offset) {
  406. offset = ufs_validate_entry(sb, kaddr, offset, chunk_mask);
  407. ctx->pos = (n<<PAGE_SHIFT) + offset;
  408. }
  409. file->f_version = inode_query_iversion(inode);
  410. need_revalidate = false;
  411. }
  412. de = (struct ufs_dir_entry *)(kaddr+offset);
  413. limit = kaddr + ufs_last_byte(inode, n) - UFS_DIR_REC_LEN(1);
  414. for ( ;(char*)de <= limit; de = ufs_next_entry(sb, de)) {
  415. if (de->d_ino) {
  416. unsigned char d_type = DT_UNKNOWN;
  417. UFSD("filldir(%s,%u)\n", de->d_name,
  418. fs32_to_cpu(sb, de->d_ino));
  419. UFSD("namlen %u\n", ufs_get_de_namlen(sb, de));
  420. if ((flags & UFS_DE_MASK) == UFS_DE_44BSD)
  421. d_type = de->d_u.d_44.d_type;
  422. if (!dir_emit(ctx, de->d_name,
  423. ufs_get_de_namlen(sb, de),
  424. fs32_to_cpu(sb, de->d_ino),
  425. d_type)) {
  426. ufs_put_page(page);
  427. return 0;
  428. }
  429. }
  430. ctx->pos += fs16_to_cpu(sb, de->d_reclen);
  431. }
  432. ufs_put_page(page);
  433. }
  434. return 0;
  435. }
  436. /*
  437. * ufs_delete_entry deletes a directory entry by merging it with the
  438. * previous entry.
  439. */
  440. int ufs_delete_entry(struct inode *inode, struct ufs_dir_entry *dir,
  441. struct page * page)
  442. {
  443. struct super_block *sb = inode->i_sb;
  444. char *kaddr = page_address(page);
  445. unsigned from = ((char*)dir - kaddr) & ~(UFS_SB(sb)->s_uspi->s_dirblksize - 1);
  446. unsigned to = ((char*)dir - kaddr) + fs16_to_cpu(sb, dir->d_reclen);
  447. loff_t pos;
  448. struct ufs_dir_entry *pde = NULL;
  449. struct ufs_dir_entry *de = (struct ufs_dir_entry *) (kaddr + from);
  450. int err;
  451. UFSD("ENTER\n");
  452. UFSD("ino %u, reclen %u, namlen %u, name %s\n",
  453. fs32_to_cpu(sb, de->d_ino),
  454. fs16_to_cpu(sb, de->d_reclen),
  455. ufs_get_de_namlen(sb, de), de->d_name);
  456. while ((char*)de < (char*)dir) {
  457. if (de->d_reclen == 0) {
  458. ufs_error(inode->i_sb, __func__,
  459. "zero-length directory entry");
  460. err = -EIO;
  461. goto out;
  462. }
  463. pde = de;
  464. de = ufs_next_entry(sb, de);
  465. }
  466. if (pde)
  467. from = (char*)pde - (char*)page_address(page);
  468. pos = page_offset(page) + from;
  469. lock_page(page);
  470. err = ufs_prepare_chunk(page, pos, to - from);
  471. BUG_ON(err);
  472. if (pde)
  473. pde->d_reclen = cpu_to_fs16(sb, to - from);
  474. dir->d_ino = 0;
  475. err = ufs_commit_chunk(page, pos, to - from);
  476. inode->i_ctime = inode->i_mtime = current_time(inode);
  477. mark_inode_dirty(inode);
  478. out:
  479. ufs_put_page(page);
  480. UFSD("EXIT\n");
  481. return err;
  482. }
  483. int ufs_make_empty(struct inode * inode, struct inode *dir)
  484. {
  485. struct super_block * sb = dir->i_sb;
  486. struct address_space *mapping = inode->i_mapping;
  487. struct page *page = grab_cache_page(mapping, 0);
  488. const unsigned int chunk_size = UFS_SB(sb)->s_uspi->s_dirblksize;
  489. struct ufs_dir_entry * de;
  490. char *base;
  491. int err;
  492. if (!page)
  493. return -ENOMEM;
  494. err = ufs_prepare_chunk(page, 0, chunk_size);
  495. if (err) {
  496. unlock_page(page);
  497. goto fail;
  498. }
  499. kmap(page);
  500. base = (char*)page_address(page);
  501. memset(base, 0, PAGE_SIZE);
  502. de = (struct ufs_dir_entry *) base;
  503. de->d_ino = cpu_to_fs32(sb, inode->i_ino);
  504. ufs_set_de_type(sb, de, inode->i_mode);
  505. ufs_set_de_namlen(sb, de, 1);
  506. de->d_reclen = cpu_to_fs16(sb, UFS_DIR_REC_LEN(1));
  507. strcpy (de->d_name, ".");
  508. de = (struct ufs_dir_entry *)
  509. ((char *)de + fs16_to_cpu(sb, de->d_reclen));
  510. de->d_ino = cpu_to_fs32(sb, dir->i_ino);
  511. ufs_set_de_type(sb, de, dir->i_mode);
  512. de->d_reclen = cpu_to_fs16(sb, chunk_size - UFS_DIR_REC_LEN(1));
  513. ufs_set_de_namlen(sb, de, 2);
  514. strcpy (de->d_name, "..");
  515. kunmap(page);
  516. err = ufs_commit_chunk(page, 0, chunk_size);
  517. fail:
  518. put_page(page);
  519. return err;
  520. }
  521. /*
  522. * routine to check that the specified directory is empty (for rmdir)
  523. */
  524. int ufs_empty_dir(struct inode * inode)
  525. {
  526. struct super_block *sb = inode->i_sb;
  527. struct page *page = NULL;
  528. unsigned long i, npages = dir_pages(inode);
  529. for (i = 0; i < npages; i++) {
  530. char *kaddr;
  531. struct ufs_dir_entry *de;
  532. page = ufs_get_page(inode, i);
  533. if (IS_ERR(page))
  534. continue;
  535. kaddr = page_address(page);
  536. de = (struct ufs_dir_entry *)kaddr;
  537. kaddr += ufs_last_byte(inode, i) - UFS_DIR_REC_LEN(1);
  538. while ((char *)de <= kaddr) {
  539. if (de->d_reclen == 0) {
  540. ufs_error(inode->i_sb, __func__,
  541. "zero-length directory entry: "
  542. "kaddr=%p, de=%p\n", kaddr, de);
  543. goto not_empty;
  544. }
  545. if (de->d_ino) {
  546. u16 namelen=ufs_get_de_namlen(sb, de);
  547. /* check for . and .. */
  548. if (de->d_name[0] != '.')
  549. goto not_empty;
  550. if (namelen > 2)
  551. goto not_empty;
  552. if (namelen < 2) {
  553. if (inode->i_ino !=
  554. fs32_to_cpu(sb, de->d_ino))
  555. goto not_empty;
  556. } else if (de->d_name[1] != '.')
  557. goto not_empty;
  558. }
  559. de = ufs_next_entry(sb, de);
  560. }
  561. ufs_put_page(page);
  562. }
  563. return 1;
  564. not_empty:
  565. ufs_put_page(page);
  566. return 0;
  567. }
  568. const struct file_operations ufs_dir_operations = {
  569. .read = generic_read_dir,
  570. .iterate_shared = ufs_readdir,
  571. .fsync = generic_file_fsync,
  572. .llseek = generic_file_llseek,
  573. };