dir.c 17 KB

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