dir.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * dir.c - NILFS directory entry operations
  4. *
  5. * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
  6. *
  7. * Modified for NILFS by Amagai Yoshiji.
  8. */
  9. /*
  10. * linux/fs/ext2/dir.c
  11. *
  12. * Copyright (C) 1992, 1993, 1994, 1995
  13. * Remy Card (card@masi.ibp.fr)
  14. * Laboratoire MASI - Institut Blaise Pascal
  15. * Universite Pierre et Marie Curie (Paris VI)
  16. *
  17. * from
  18. *
  19. * linux/fs/minix/dir.c
  20. *
  21. * Copyright (C) 1991, 1992 Linus Torvalds
  22. *
  23. * ext2 directory handling functions
  24. *
  25. * Big-endian to little-endian byte-swapping/bitmaps by
  26. * David S. Miller (davem@caip.rutgers.edu), 1995
  27. *
  28. * All code that works with directory layout had been switched to pagecache
  29. * and moved here. AV
  30. */
  31. #include <linux/pagemap.h>
  32. #include "nilfs.h"
  33. #include "page.h"
  34. static inline unsigned int nilfs_rec_len_from_disk(__le16 dlen)
  35. {
  36. unsigned int len = le16_to_cpu(dlen);
  37. #if (PAGE_SIZE >= 65536)
  38. if (len == NILFS_MAX_REC_LEN)
  39. return 1 << 16;
  40. #endif
  41. return len;
  42. }
  43. static inline __le16 nilfs_rec_len_to_disk(unsigned int len)
  44. {
  45. #if (PAGE_SIZE >= 65536)
  46. if (len == (1 << 16))
  47. return cpu_to_le16(NILFS_MAX_REC_LEN);
  48. BUG_ON(len > (1 << 16));
  49. #endif
  50. return cpu_to_le16(len);
  51. }
  52. /*
  53. * nilfs uses block-sized chunks. Arguably, sector-sized ones would be
  54. * more robust, but we have what we have
  55. */
  56. static inline unsigned int nilfs_chunk_size(struct inode *inode)
  57. {
  58. return inode->i_sb->s_blocksize;
  59. }
  60. static inline void nilfs_put_page(struct page *page)
  61. {
  62. kunmap(page);
  63. put_page(page);
  64. }
  65. /*
  66. * Return the offset into page `page_nr' of the last valid
  67. * byte in that page, plus one.
  68. */
  69. static unsigned int nilfs_last_byte(struct inode *inode, unsigned long page_nr)
  70. {
  71. unsigned int last_byte = inode->i_size;
  72. last_byte -= page_nr << PAGE_SHIFT;
  73. if (last_byte > PAGE_SIZE)
  74. last_byte = PAGE_SIZE;
  75. return last_byte;
  76. }
  77. static int nilfs_prepare_chunk(struct page *page, unsigned int from,
  78. unsigned int to)
  79. {
  80. loff_t pos = page_offset(page) + from;
  81. return __block_write_begin(page, pos, to - from, nilfs_get_block);
  82. }
  83. static void nilfs_commit_chunk(struct page *page,
  84. struct address_space *mapping,
  85. unsigned int from, unsigned int to)
  86. {
  87. struct inode *dir = mapping->host;
  88. loff_t pos = page_offset(page) + from;
  89. unsigned int len = to - from;
  90. unsigned int nr_dirty, copied;
  91. int err;
  92. nr_dirty = nilfs_page_count_clean_buffers(page, from, to);
  93. copied = block_write_end(NULL, mapping, pos, len, len, page, NULL);
  94. if (pos + copied > dir->i_size)
  95. i_size_write(dir, pos + copied);
  96. if (IS_DIRSYNC(dir))
  97. nilfs_set_transaction_flag(NILFS_TI_SYNC);
  98. err = nilfs_set_file_dirty(dir, nr_dirty);
  99. WARN_ON(err); /* do not happen */
  100. unlock_page(page);
  101. }
  102. static bool nilfs_check_page(struct page *page)
  103. {
  104. struct inode *dir = page->mapping->host;
  105. struct super_block *sb = dir->i_sb;
  106. unsigned int chunk_size = nilfs_chunk_size(dir);
  107. char *kaddr = page_address(page);
  108. unsigned int offs, rec_len;
  109. unsigned int limit = PAGE_SIZE;
  110. struct nilfs_dir_entry *p;
  111. char *error;
  112. if ((dir->i_size >> PAGE_SHIFT) == page->index) {
  113. limit = dir->i_size & ~PAGE_MASK;
  114. if (limit & (chunk_size - 1))
  115. goto Ebadsize;
  116. if (!limit)
  117. goto out;
  118. }
  119. for (offs = 0; offs <= limit - NILFS_DIR_REC_LEN(1); offs += rec_len) {
  120. p = (struct nilfs_dir_entry *)(kaddr + offs);
  121. rec_len = nilfs_rec_len_from_disk(p->rec_len);
  122. if (rec_len < NILFS_DIR_REC_LEN(1))
  123. goto Eshort;
  124. if (rec_len & 3)
  125. goto Ealign;
  126. if (rec_len < NILFS_DIR_REC_LEN(p->name_len))
  127. goto Enamelen;
  128. if (((offs + rec_len - 1) ^ offs) & ~(chunk_size-1))
  129. goto Espan;
  130. }
  131. if (offs != limit)
  132. goto Eend;
  133. out:
  134. SetPageChecked(page);
  135. return true;
  136. /* Too bad, we had an error */
  137. Ebadsize:
  138. nilfs_error(sb,
  139. "size of directory #%lu is not a multiple of chunk size",
  140. dir->i_ino);
  141. goto fail;
  142. Eshort:
  143. error = "rec_len is smaller than minimal";
  144. goto bad_entry;
  145. Ealign:
  146. error = "unaligned directory entry";
  147. goto bad_entry;
  148. Enamelen:
  149. error = "rec_len is too small for name_len";
  150. goto bad_entry;
  151. Espan:
  152. error = "directory entry across blocks";
  153. bad_entry:
  154. nilfs_error(sb,
  155. "bad entry in directory #%lu: %s - offset=%lu, inode=%lu, rec_len=%d, name_len=%d",
  156. dir->i_ino, error, (page->index << PAGE_SHIFT) + offs,
  157. (unsigned long)le64_to_cpu(p->inode),
  158. rec_len, p->name_len);
  159. goto fail;
  160. Eend:
  161. p = (struct nilfs_dir_entry *)(kaddr + offs);
  162. nilfs_error(sb,
  163. "entry in directory #%lu spans the page boundary offset=%lu, inode=%lu",
  164. dir->i_ino, (page->index << PAGE_SHIFT) + offs,
  165. (unsigned long)le64_to_cpu(p->inode));
  166. fail:
  167. SetPageError(page);
  168. return false;
  169. }
  170. static struct page *nilfs_get_page(struct inode *dir, unsigned long n)
  171. {
  172. struct address_space *mapping = dir->i_mapping;
  173. struct page *page = read_mapping_page(mapping, n, NULL);
  174. if (!IS_ERR(page)) {
  175. kmap(page);
  176. if (unlikely(!PageChecked(page))) {
  177. if (PageError(page) || !nilfs_check_page(page))
  178. goto fail;
  179. }
  180. }
  181. return page;
  182. fail:
  183. nilfs_put_page(page);
  184. return ERR_PTR(-EIO);
  185. }
  186. /*
  187. * NOTE! unlike strncmp, nilfs_match returns 1 for success, 0 for failure.
  188. *
  189. * len <= NILFS_NAME_LEN and de != NULL are guaranteed by caller.
  190. */
  191. static int
  192. nilfs_match(int len, const unsigned char *name, struct nilfs_dir_entry *de)
  193. {
  194. if (len != de->name_len)
  195. return 0;
  196. if (!de->inode)
  197. return 0;
  198. return !memcmp(name, de->name, len);
  199. }
  200. /*
  201. * p is at least 6 bytes before the end of page
  202. */
  203. static struct nilfs_dir_entry *nilfs_next_entry(struct nilfs_dir_entry *p)
  204. {
  205. return (struct nilfs_dir_entry *)((char *)p +
  206. nilfs_rec_len_from_disk(p->rec_len));
  207. }
  208. static unsigned char
  209. nilfs_filetype_table[NILFS_FT_MAX] = {
  210. [NILFS_FT_UNKNOWN] = DT_UNKNOWN,
  211. [NILFS_FT_REG_FILE] = DT_REG,
  212. [NILFS_FT_DIR] = DT_DIR,
  213. [NILFS_FT_CHRDEV] = DT_CHR,
  214. [NILFS_FT_BLKDEV] = DT_BLK,
  215. [NILFS_FT_FIFO] = DT_FIFO,
  216. [NILFS_FT_SOCK] = DT_SOCK,
  217. [NILFS_FT_SYMLINK] = DT_LNK,
  218. };
  219. #define S_SHIFT 12
  220. static unsigned char
  221. nilfs_type_by_mode[S_IFMT >> S_SHIFT] = {
  222. [S_IFREG >> S_SHIFT] = NILFS_FT_REG_FILE,
  223. [S_IFDIR >> S_SHIFT] = NILFS_FT_DIR,
  224. [S_IFCHR >> S_SHIFT] = NILFS_FT_CHRDEV,
  225. [S_IFBLK >> S_SHIFT] = NILFS_FT_BLKDEV,
  226. [S_IFIFO >> S_SHIFT] = NILFS_FT_FIFO,
  227. [S_IFSOCK >> S_SHIFT] = NILFS_FT_SOCK,
  228. [S_IFLNK >> S_SHIFT] = NILFS_FT_SYMLINK,
  229. };
  230. static void nilfs_set_de_type(struct nilfs_dir_entry *de, struct inode *inode)
  231. {
  232. umode_t mode = inode->i_mode;
  233. de->file_type = nilfs_type_by_mode[(mode & S_IFMT)>>S_SHIFT];
  234. }
  235. static int nilfs_readdir(struct file *file, struct dir_context *ctx)
  236. {
  237. loff_t pos = ctx->pos;
  238. struct inode *inode = file_inode(file);
  239. struct super_block *sb = inode->i_sb;
  240. unsigned int offset = pos & ~PAGE_MASK;
  241. unsigned long n = pos >> PAGE_SHIFT;
  242. unsigned long npages = dir_pages(inode);
  243. if (pos > inode->i_size - NILFS_DIR_REC_LEN(1))
  244. return 0;
  245. for ( ; n < npages; n++, offset = 0) {
  246. char *kaddr, *limit;
  247. struct nilfs_dir_entry *de;
  248. struct page *page = nilfs_get_page(inode, n);
  249. if (IS_ERR(page)) {
  250. nilfs_error(sb, "bad page in #%lu", inode->i_ino);
  251. ctx->pos += PAGE_SIZE - offset;
  252. return -EIO;
  253. }
  254. kaddr = page_address(page);
  255. de = (struct nilfs_dir_entry *)(kaddr + offset);
  256. limit = kaddr + nilfs_last_byte(inode, n) -
  257. NILFS_DIR_REC_LEN(1);
  258. for ( ; (char *)de <= limit; de = nilfs_next_entry(de)) {
  259. if (de->rec_len == 0) {
  260. nilfs_error(sb, "zero-length directory entry");
  261. nilfs_put_page(page);
  262. return -EIO;
  263. }
  264. if (de->inode) {
  265. unsigned char t;
  266. if (de->file_type < NILFS_FT_MAX)
  267. t = nilfs_filetype_table[de->file_type];
  268. else
  269. t = DT_UNKNOWN;
  270. if (!dir_emit(ctx, de->name, de->name_len,
  271. le64_to_cpu(de->inode), t)) {
  272. nilfs_put_page(page);
  273. return 0;
  274. }
  275. }
  276. ctx->pos += nilfs_rec_len_from_disk(de->rec_len);
  277. }
  278. nilfs_put_page(page);
  279. }
  280. return 0;
  281. }
  282. /*
  283. * nilfs_find_entry()
  284. *
  285. * finds an entry in the specified directory with the wanted name. It
  286. * returns the page in which the entry was found, and the entry itself
  287. * (as a parameter - res_dir). Page is returned mapped and unlocked.
  288. * Entry is guaranteed to be valid.
  289. */
  290. struct nilfs_dir_entry *
  291. nilfs_find_entry(struct inode *dir, const struct qstr *qstr,
  292. struct page **res_page)
  293. {
  294. const unsigned char *name = qstr->name;
  295. int namelen = qstr->len;
  296. unsigned int reclen = NILFS_DIR_REC_LEN(namelen);
  297. unsigned long start, n;
  298. unsigned long npages = dir_pages(dir);
  299. struct page *page = NULL;
  300. struct nilfs_inode_info *ei = NILFS_I(dir);
  301. struct nilfs_dir_entry *de;
  302. if (npages == 0)
  303. goto out;
  304. /* OFFSET_CACHE */
  305. *res_page = NULL;
  306. start = ei->i_dir_start_lookup;
  307. if (start >= npages)
  308. start = 0;
  309. n = start;
  310. do {
  311. char *kaddr;
  312. page = nilfs_get_page(dir, n);
  313. if (!IS_ERR(page)) {
  314. kaddr = page_address(page);
  315. de = (struct nilfs_dir_entry *)kaddr;
  316. kaddr += nilfs_last_byte(dir, n) - reclen;
  317. while ((char *) de <= kaddr) {
  318. if (de->rec_len == 0) {
  319. nilfs_error(dir->i_sb,
  320. "zero-length directory entry");
  321. nilfs_put_page(page);
  322. goto out;
  323. }
  324. if (nilfs_match(namelen, name, de))
  325. goto found;
  326. de = nilfs_next_entry(de);
  327. }
  328. nilfs_put_page(page);
  329. }
  330. if (++n >= npages)
  331. n = 0;
  332. /* next page is past the blocks we've got */
  333. if (unlikely(n > (dir->i_blocks >> (PAGE_SHIFT - 9)))) {
  334. nilfs_error(dir->i_sb,
  335. "dir %lu size %lld exceeds block count %llu",
  336. dir->i_ino, dir->i_size,
  337. (unsigned long long)dir->i_blocks);
  338. goto out;
  339. }
  340. } while (n != start);
  341. out:
  342. return NULL;
  343. found:
  344. *res_page = page;
  345. ei->i_dir_start_lookup = n;
  346. return de;
  347. }
  348. struct nilfs_dir_entry *nilfs_dotdot(struct inode *dir, struct page **p)
  349. {
  350. struct page *page = nilfs_get_page(dir, 0);
  351. struct nilfs_dir_entry *de = NULL;
  352. if (!IS_ERR(page)) {
  353. de = nilfs_next_entry(
  354. (struct nilfs_dir_entry *)page_address(page));
  355. *p = page;
  356. }
  357. return de;
  358. }
  359. ino_t nilfs_inode_by_name(struct inode *dir, const struct qstr *qstr)
  360. {
  361. ino_t res = 0;
  362. struct nilfs_dir_entry *de;
  363. struct page *page;
  364. de = nilfs_find_entry(dir, qstr, &page);
  365. if (de) {
  366. res = le64_to_cpu(de->inode);
  367. kunmap(page);
  368. put_page(page);
  369. }
  370. return res;
  371. }
  372. /* Releases the page */
  373. void nilfs_set_link(struct inode *dir, struct nilfs_dir_entry *de,
  374. struct page *page, struct inode *inode)
  375. {
  376. unsigned int from = (char *)de - (char *)page_address(page);
  377. unsigned int to = from + nilfs_rec_len_from_disk(de->rec_len);
  378. struct address_space *mapping = page->mapping;
  379. int err;
  380. lock_page(page);
  381. err = nilfs_prepare_chunk(page, from, to);
  382. BUG_ON(err);
  383. de->inode = cpu_to_le64(inode->i_ino);
  384. nilfs_set_de_type(de, inode);
  385. nilfs_commit_chunk(page, mapping, from, to);
  386. nilfs_put_page(page);
  387. dir->i_mtime = dir->i_ctime = current_time(dir);
  388. }
  389. /*
  390. * Parent is locked.
  391. */
  392. int nilfs_add_link(struct dentry *dentry, struct inode *inode)
  393. {
  394. struct inode *dir = d_inode(dentry->d_parent);
  395. const unsigned char *name = dentry->d_name.name;
  396. int namelen = dentry->d_name.len;
  397. unsigned int chunk_size = nilfs_chunk_size(dir);
  398. unsigned int reclen = NILFS_DIR_REC_LEN(namelen);
  399. unsigned short rec_len, name_len;
  400. struct page *page = NULL;
  401. struct nilfs_dir_entry *de;
  402. unsigned long npages = dir_pages(dir);
  403. unsigned long n;
  404. char *kaddr;
  405. unsigned int from, to;
  406. int err;
  407. /*
  408. * We take care of directory expansion in the same loop.
  409. * This code plays outside i_size, so it locks the page
  410. * to protect that region.
  411. */
  412. for (n = 0; n <= npages; n++) {
  413. char *dir_end;
  414. page = nilfs_get_page(dir, n);
  415. err = PTR_ERR(page);
  416. if (IS_ERR(page))
  417. goto out;
  418. lock_page(page);
  419. kaddr = page_address(page);
  420. dir_end = kaddr + nilfs_last_byte(dir, n);
  421. de = (struct nilfs_dir_entry *)kaddr;
  422. kaddr += PAGE_SIZE - reclen;
  423. while ((char *)de <= kaddr) {
  424. if ((char *)de == dir_end) {
  425. /* We hit i_size */
  426. name_len = 0;
  427. rec_len = chunk_size;
  428. de->rec_len = nilfs_rec_len_to_disk(chunk_size);
  429. de->inode = 0;
  430. goto got_it;
  431. }
  432. if (de->rec_len == 0) {
  433. nilfs_error(dir->i_sb,
  434. "zero-length directory entry");
  435. err = -EIO;
  436. goto out_unlock;
  437. }
  438. err = -EEXIST;
  439. if (nilfs_match(namelen, name, de))
  440. goto out_unlock;
  441. name_len = NILFS_DIR_REC_LEN(de->name_len);
  442. rec_len = nilfs_rec_len_from_disk(de->rec_len);
  443. if (!de->inode && rec_len >= reclen)
  444. goto got_it;
  445. if (rec_len >= name_len + reclen)
  446. goto got_it;
  447. de = (struct nilfs_dir_entry *)((char *)de + rec_len);
  448. }
  449. unlock_page(page);
  450. nilfs_put_page(page);
  451. }
  452. BUG();
  453. return -EINVAL;
  454. got_it:
  455. from = (char *)de - (char *)page_address(page);
  456. to = from + rec_len;
  457. err = nilfs_prepare_chunk(page, from, to);
  458. if (err)
  459. goto out_unlock;
  460. if (de->inode) {
  461. struct nilfs_dir_entry *de1;
  462. de1 = (struct nilfs_dir_entry *)((char *)de + name_len);
  463. de1->rec_len = nilfs_rec_len_to_disk(rec_len - name_len);
  464. de->rec_len = nilfs_rec_len_to_disk(name_len);
  465. de = de1;
  466. }
  467. de->name_len = namelen;
  468. memcpy(de->name, name, namelen);
  469. de->inode = cpu_to_le64(inode->i_ino);
  470. nilfs_set_de_type(de, inode);
  471. nilfs_commit_chunk(page, page->mapping, from, to);
  472. dir->i_mtime = dir->i_ctime = current_time(dir);
  473. nilfs_mark_inode_dirty(dir);
  474. /* OFFSET_CACHE */
  475. out_put:
  476. nilfs_put_page(page);
  477. out:
  478. return err;
  479. out_unlock:
  480. unlock_page(page);
  481. goto out_put;
  482. }
  483. /*
  484. * nilfs_delete_entry deletes a directory entry by merging it with the
  485. * previous entry. Page is up-to-date. Releases the page.
  486. */
  487. int nilfs_delete_entry(struct nilfs_dir_entry *dir, struct page *page)
  488. {
  489. struct address_space *mapping = page->mapping;
  490. struct inode *inode = mapping->host;
  491. char *kaddr = page_address(page);
  492. unsigned int from, to;
  493. struct nilfs_dir_entry *de, *pde = NULL;
  494. int err;
  495. from = ((char *)dir - kaddr) & ~(nilfs_chunk_size(inode) - 1);
  496. to = ((char *)dir - kaddr) + nilfs_rec_len_from_disk(dir->rec_len);
  497. de = (struct nilfs_dir_entry *)(kaddr + from);
  498. while ((char *)de < (char *)dir) {
  499. if (de->rec_len == 0) {
  500. nilfs_error(inode->i_sb,
  501. "zero-length directory entry");
  502. err = -EIO;
  503. goto out;
  504. }
  505. pde = de;
  506. de = nilfs_next_entry(de);
  507. }
  508. if (pde)
  509. from = (char *)pde - (char *)page_address(page);
  510. lock_page(page);
  511. err = nilfs_prepare_chunk(page, from, to);
  512. BUG_ON(err);
  513. if (pde)
  514. pde->rec_len = nilfs_rec_len_to_disk(to - from);
  515. dir->inode = 0;
  516. nilfs_commit_chunk(page, mapping, from, to);
  517. inode->i_ctime = inode->i_mtime = current_time(inode);
  518. out:
  519. nilfs_put_page(page);
  520. return err;
  521. }
  522. /*
  523. * Set the first fragment of directory.
  524. */
  525. int nilfs_make_empty(struct inode *inode, struct inode *parent)
  526. {
  527. struct address_space *mapping = inode->i_mapping;
  528. struct page *page = grab_cache_page(mapping, 0);
  529. unsigned int chunk_size = nilfs_chunk_size(inode);
  530. struct nilfs_dir_entry *de;
  531. int err;
  532. void *kaddr;
  533. if (!page)
  534. return -ENOMEM;
  535. err = nilfs_prepare_chunk(page, 0, chunk_size);
  536. if (unlikely(err)) {
  537. unlock_page(page);
  538. goto fail;
  539. }
  540. kaddr = kmap_atomic(page);
  541. memset(kaddr, 0, chunk_size);
  542. de = (struct nilfs_dir_entry *)kaddr;
  543. de->name_len = 1;
  544. de->rec_len = nilfs_rec_len_to_disk(NILFS_DIR_REC_LEN(1));
  545. memcpy(de->name, ".\0\0", 4);
  546. de->inode = cpu_to_le64(inode->i_ino);
  547. nilfs_set_de_type(de, inode);
  548. de = (struct nilfs_dir_entry *)(kaddr + NILFS_DIR_REC_LEN(1));
  549. de->name_len = 2;
  550. de->rec_len = nilfs_rec_len_to_disk(chunk_size - NILFS_DIR_REC_LEN(1));
  551. de->inode = cpu_to_le64(parent->i_ino);
  552. memcpy(de->name, "..\0", 4);
  553. nilfs_set_de_type(de, inode);
  554. kunmap_atomic(kaddr);
  555. nilfs_commit_chunk(page, mapping, 0, chunk_size);
  556. fail:
  557. put_page(page);
  558. return err;
  559. }
  560. /*
  561. * routine to check that the specified directory is empty (for rmdir)
  562. */
  563. int nilfs_empty_dir(struct inode *inode)
  564. {
  565. struct page *page = NULL;
  566. unsigned long i, npages = dir_pages(inode);
  567. for (i = 0; i < npages; i++) {
  568. char *kaddr;
  569. struct nilfs_dir_entry *de;
  570. page = nilfs_get_page(inode, i);
  571. if (IS_ERR(page))
  572. continue;
  573. kaddr = page_address(page);
  574. de = (struct nilfs_dir_entry *)kaddr;
  575. kaddr += nilfs_last_byte(inode, i) - NILFS_DIR_REC_LEN(1);
  576. while ((char *)de <= kaddr) {
  577. if (de->rec_len == 0) {
  578. nilfs_error(inode->i_sb,
  579. "zero-length directory entry (kaddr=%p, de=%p)",
  580. kaddr, de);
  581. goto not_empty;
  582. }
  583. if (de->inode != 0) {
  584. /* check for . and .. */
  585. if (de->name[0] != '.')
  586. goto not_empty;
  587. if (de->name_len > 2)
  588. goto not_empty;
  589. if (de->name_len < 2) {
  590. if (de->inode !=
  591. cpu_to_le64(inode->i_ino))
  592. goto not_empty;
  593. } else if (de->name[1] != '.')
  594. goto not_empty;
  595. }
  596. de = nilfs_next_entry(de);
  597. }
  598. nilfs_put_page(page);
  599. }
  600. return 1;
  601. not_empty:
  602. nilfs_put_page(page);
  603. return 0;
  604. }
  605. const struct file_operations nilfs_dir_operations = {
  606. .llseek = generic_file_llseek,
  607. .read = generic_read_dir,
  608. .iterate_shared = nilfs_readdir,
  609. .unlocked_ioctl = nilfs_ioctl,
  610. #ifdef CONFIG_COMPAT
  611. .compat_ioctl = nilfs_compat_ioctl,
  612. #endif /* CONFIG_COMPAT */
  613. .fsync = nilfs_sync_file,
  614. };