dir.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468
  1. /*
  2. * linux/fs/minix/dir.c
  3. *
  4. * Copyright (C) 1991, 1992 Linus Torvalds
  5. *
  6. * minix directory handling functions
  7. *
  8. * Updated to filesystem version 3 by Daniel Aragones
  9. */
  10. #include "minix.h"
  11. #include <linux/highmem.h>
  12. #include <linux/smp_lock.h>
  13. typedef struct minix_dir_entry minix_dirent;
  14. typedef struct minix3_dir_entry minix3_dirent;
  15. static int minix_readdir(struct file *, void *, filldir_t);
  16. const struct file_operations minix_dir_operations = {
  17. .read = generic_read_dir,
  18. .readdir = minix_readdir,
  19. .fsync = minix_sync_file,
  20. };
  21. static inline void dir_put_page(struct page *page)
  22. {
  23. kunmap(page);
  24. page_cache_release(page);
  25. }
  26. /*
  27. * Return the offset into page `page_nr' of the last valid
  28. * byte in that page, plus one.
  29. */
  30. static unsigned
  31. minix_last_byte(struct inode *inode, unsigned long page_nr)
  32. {
  33. unsigned last_byte = PAGE_CACHE_SIZE;
  34. if (page_nr == (inode->i_size >> PAGE_CACHE_SHIFT))
  35. last_byte = inode->i_size & (PAGE_CACHE_SIZE - 1);
  36. return last_byte;
  37. }
  38. static inline unsigned long dir_pages(struct inode *inode)
  39. {
  40. return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT;
  41. }
  42. static int dir_commit_chunk(struct page *page, unsigned from, unsigned to)
  43. {
  44. struct inode *dir = (struct inode *)page->mapping->host;
  45. int err = 0;
  46. page->mapping->a_ops->commit_write(NULL, page, from, to);
  47. if (IS_DIRSYNC(dir))
  48. err = write_one_page(page, 1);
  49. else
  50. unlock_page(page);
  51. return err;
  52. }
  53. static struct page * dir_get_page(struct inode *dir, unsigned long n)
  54. {
  55. struct address_space *mapping = dir->i_mapping;
  56. struct page *page = read_mapping_page(mapping, n, NULL);
  57. if (!IS_ERR(page)) {
  58. wait_on_page_locked(page);
  59. kmap(page);
  60. if (!PageUptodate(page))
  61. goto fail;
  62. }
  63. return page;
  64. fail:
  65. dir_put_page(page);
  66. return ERR_PTR(-EIO);
  67. }
  68. static inline void *minix_next_entry(void *de, struct minix_sb_info *sbi)
  69. {
  70. return (void*)((char*)de + sbi->s_dirsize);
  71. }
  72. static int minix_readdir(struct file * filp, void * dirent, filldir_t filldir)
  73. {
  74. unsigned long pos = filp->f_pos;
  75. struct inode *inode = filp->f_path.dentry->d_inode;
  76. struct super_block *sb = inode->i_sb;
  77. unsigned offset = pos & ~PAGE_CACHE_MASK;
  78. unsigned long n = pos >> PAGE_CACHE_SHIFT;
  79. unsigned long npages = dir_pages(inode);
  80. struct minix_sb_info *sbi = minix_sb(sb);
  81. unsigned chunk_size = sbi->s_dirsize;
  82. char *name;
  83. __u32 inumber;
  84. lock_kernel();
  85. pos = (pos + chunk_size-1) & ~(chunk_size-1);
  86. if (pos >= inode->i_size)
  87. goto done;
  88. for ( ; n < npages; n++, offset = 0) {
  89. char *p, *kaddr, *limit;
  90. struct page *page = dir_get_page(inode, n);
  91. if (IS_ERR(page))
  92. continue;
  93. kaddr = (char *)page_address(page);
  94. p = kaddr+offset;
  95. limit = kaddr + minix_last_byte(inode, n) - chunk_size;
  96. for ( ; p <= limit; p = minix_next_entry(p, sbi)) {
  97. if (sbi->s_version == MINIX_V3) {
  98. minix3_dirent *de3 = (minix3_dirent *)p;
  99. name = de3->name;
  100. inumber = de3->inode;
  101. } else {
  102. minix_dirent *de = (minix_dirent *)p;
  103. name = de->name;
  104. inumber = de->inode;
  105. }
  106. if (inumber) {
  107. int over;
  108. unsigned l = strnlen(name, sbi->s_namelen);
  109. offset = p - kaddr;
  110. over = filldir(dirent, name, l,
  111. (n << PAGE_CACHE_SHIFT) | offset,
  112. inumber, DT_UNKNOWN);
  113. if (over) {
  114. dir_put_page(page);
  115. goto done;
  116. }
  117. }
  118. }
  119. dir_put_page(page);
  120. }
  121. done:
  122. filp->f_pos = (n << PAGE_CACHE_SHIFT) | offset;
  123. unlock_kernel();
  124. return 0;
  125. }
  126. static inline int namecompare(int len, int maxlen,
  127. const char * name, const char * buffer)
  128. {
  129. if (len < maxlen && buffer[len])
  130. return 0;
  131. return !memcmp(name, buffer, len);
  132. }
  133. /*
  134. * minix_find_entry()
  135. *
  136. * finds an entry in the specified directory with the wanted name. It
  137. * returns the cache buffer in which the entry was found, and the entry
  138. * itself (as a parameter - res_dir). It does NOT read the inode of the
  139. * entry - you'll have to do that yourself if you want to.
  140. */
  141. minix_dirent *minix_find_entry(struct dentry *dentry, struct page **res_page)
  142. {
  143. const char * name = dentry->d_name.name;
  144. int namelen = dentry->d_name.len;
  145. struct inode * dir = dentry->d_parent->d_inode;
  146. struct super_block * sb = dir->i_sb;
  147. struct minix_sb_info * sbi = minix_sb(sb);
  148. unsigned long n;
  149. unsigned long npages = dir_pages(dir);
  150. struct page *page = NULL;
  151. char *p;
  152. char *namx;
  153. __u32 inumber;
  154. *res_page = NULL;
  155. for (n = 0; n < npages; n++) {
  156. char *kaddr, *limit;
  157. page = dir_get_page(dir, n);
  158. if (IS_ERR(page))
  159. continue;
  160. kaddr = (char*)page_address(page);
  161. limit = kaddr + minix_last_byte(dir, n) - sbi->s_dirsize;
  162. for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) {
  163. if (sbi->s_version == MINIX_V3) {
  164. minix3_dirent *de3 = (minix3_dirent *)p;
  165. namx = de3->name;
  166. inumber = de3->inode;
  167. } else {
  168. minix_dirent *de = (minix_dirent *)p;
  169. namx = de->name;
  170. inumber = de->inode;
  171. }
  172. if (!inumber)
  173. continue;
  174. if (namecompare(namelen, sbi->s_namelen, name, namx))
  175. goto found;
  176. }
  177. dir_put_page(page);
  178. }
  179. return NULL;
  180. found:
  181. *res_page = page;
  182. return (minix_dirent *)p;
  183. }
  184. int minix_add_link(struct dentry *dentry, struct inode *inode)
  185. {
  186. struct inode *dir = dentry->d_parent->d_inode;
  187. const char * name = dentry->d_name.name;
  188. int namelen = dentry->d_name.len;
  189. struct super_block * sb = dir->i_sb;
  190. struct minix_sb_info * sbi = minix_sb(sb);
  191. struct page *page = NULL;
  192. unsigned long npages = dir_pages(dir);
  193. unsigned long n;
  194. char *kaddr, *p;
  195. minix_dirent *de;
  196. minix3_dirent *de3;
  197. unsigned from, to;
  198. int err;
  199. char *namx = NULL;
  200. __u32 inumber;
  201. /*
  202. * We take care of directory expansion in the same loop
  203. * This code plays outside i_size, so it locks the page
  204. * to protect that region.
  205. */
  206. for (n = 0; n <= npages; n++) {
  207. char *limit, *dir_end;
  208. page = dir_get_page(dir, n);
  209. err = PTR_ERR(page);
  210. if (IS_ERR(page))
  211. goto out;
  212. lock_page(page);
  213. kaddr = (char*)page_address(page);
  214. dir_end = kaddr + minix_last_byte(dir, n);
  215. limit = kaddr + PAGE_CACHE_SIZE - sbi->s_dirsize;
  216. for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) {
  217. de = (minix_dirent *)p;
  218. de3 = (minix3_dirent *)p;
  219. if (sbi->s_version == MINIX_V3) {
  220. namx = de3->name;
  221. inumber = de3->inode;
  222. } else {
  223. namx = de->name;
  224. inumber = de->inode;
  225. }
  226. if (p == dir_end) {
  227. /* We hit i_size */
  228. if (sbi->s_version == MINIX_V3)
  229. de3->inode = 0;
  230. else
  231. de->inode = 0;
  232. goto got_it;
  233. }
  234. if (!inumber)
  235. goto got_it;
  236. err = -EEXIST;
  237. if (namecompare(namelen, sbi->s_namelen, name, namx))
  238. goto out_unlock;
  239. }
  240. unlock_page(page);
  241. dir_put_page(page);
  242. }
  243. BUG();
  244. return -EINVAL;
  245. got_it:
  246. from = p - (char*)page_address(page);
  247. to = from + sbi->s_dirsize;
  248. err = page->mapping->a_ops->prepare_write(NULL, page, from, to);
  249. if (err)
  250. goto out_unlock;
  251. memcpy (namx, name, namelen);
  252. if (sbi->s_version == MINIX_V3) {
  253. memset (namx + namelen, 0, sbi->s_dirsize - namelen - 4);
  254. de3->inode = inode->i_ino;
  255. } else {
  256. memset (namx + namelen, 0, sbi->s_dirsize - namelen - 2);
  257. de->inode = inode->i_ino;
  258. }
  259. err = dir_commit_chunk(page, from, to);
  260. dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
  261. mark_inode_dirty(dir);
  262. out_put:
  263. dir_put_page(page);
  264. out:
  265. return err;
  266. out_unlock:
  267. unlock_page(page);
  268. goto out_put;
  269. }
  270. int minix_delete_entry(struct minix_dir_entry *de, struct page *page)
  271. {
  272. struct address_space *mapping = page->mapping;
  273. struct inode *inode = (struct inode*)mapping->host;
  274. char *kaddr = page_address(page);
  275. unsigned from = (char*)de - kaddr;
  276. unsigned to = from + minix_sb(inode->i_sb)->s_dirsize;
  277. int err;
  278. lock_page(page);
  279. err = mapping->a_ops->prepare_write(NULL, page, from, to);
  280. if (err == 0) {
  281. de->inode = 0;
  282. err = dir_commit_chunk(page, from, to);
  283. } else {
  284. unlock_page(page);
  285. }
  286. dir_put_page(page);
  287. inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
  288. mark_inode_dirty(inode);
  289. return err;
  290. }
  291. int minix_make_empty(struct inode *inode, struct inode *dir)
  292. {
  293. struct address_space *mapping = inode->i_mapping;
  294. struct page *page = grab_cache_page(mapping, 0);
  295. struct minix_sb_info *sbi = minix_sb(inode->i_sb);
  296. char *kaddr;
  297. int err;
  298. if (!page)
  299. return -ENOMEM;
  300. err = mapping->a_ops->prepare_write(NULL, page, 0, 2 * sbi->s_dirsize);
  301. if (err) {
  302. unlock_page(page);
  303. goto fail;
  304. }
  305. kaddr = kmap_atomic(page, KM_USER0);
  306. memset(kaddr, 0, PAGE_CACHE_SIZE);
  307. if (sbi->s_version == MINIX_V3) {
  308. minix3_dirent *de3 = (minix3_dirent *)kaddr;
  309. de3->inode = inode->i_ino;
  310. strcpy(de3->name, ".");
  311. de3 = minix_next_entry(de3, sbi);
  312. de3->inode = dir->i_ino;
  313. strcpy(de3->name, "..");
  314. } else {
  315. minix_dirent *de = (minix_dirent *)kaddr;
  316. de->inode = inode->i_ino;
  317. strcpy(de->name, ".");
  318. de = minix_next_entry(de, sbi);
  319. de->inode = dir->i_ino;
  320. strcpy(de->name, "..");
  321. }
  322. kunmap_atomic(kaddr, KM_USER0);
  323. err = dir_commit_chunk(page, 0, 2 * sbi->s_dirsize);
  324. fail:
  325. page_cache_release(page);
  326. return err;
  327. }
  328. /*
  329. * routine to check that the specified directory is empty (for rmdir)
  330. */
  331. int minix_empty_dir(struct inode * inode)
  332. {
  333. struct page *page = NULL;
  334. unsigned long i, npages = dir_pages(inode);
  335. struct minix_sb_info *sbi = minix_sb(inode->i_sb);
  336. char *name;
  337. __u32 inumber;
  338. for (i = 0; i < npages; i++) {
  339. char *p, *kaddr, *limit;
  340. page = dir_get_page(inode, i);
  341. if (IS_ERR(page))
  342. continue;
  343. kaddr = (char *)page_address(page);
  344. limit = kaddr + minix_last_byte(inode, i) - sbi->s_dirsize;
  345. for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) {
  346. if (sbi->s_version == MINIX_V3) {
  347. minix3_dirent *de3 = (minix3_dirent *)p;
  348. name = de3->name;
  349. inumber = de3->inode;
  350. } else {
  351. minix_dirent *de = (minix_dirent *)p;
  352. name = de->name;
  353. inumber = de->inode;
  354. }
  355. if (inumber != 0) {
  356. /* check for . and .. */
  357. if (name[0] != '.')
  358. goto not_empty;
  359. if (!name[1]) {
  360. if (inumber != inode->i_ino)
  361. goto not_empty;
  362. } else if (name[1] != '.')
  363. goto not_empty;
  364. else if (name[2])
  365. goto not_empty;
  366. }
  367. }
  368. dir_put_page(page);
  369. }
  370. return 1;
  371. not_empty:
  372. dir_put_page(page);
  373. return 0;
  374. }
  375. /* Releases the page */
  376. void minix_set_link(struct minix_dir_entry *de, struct page *page,
  377. struct inode *inode)
  378. {
  379. struct inode *dir = (struct inode*)page->mapping->host;
  380. struct minix_sb_info *sbi = minix_sb(dir->i_sb);
  381. unsigned from = (char *)de-(char*)page_address(page);
  382. unsigned to = from + sbi->s_dirsize;
  383. int err;
  384. lock_page(page);
  385. err = page->mapping->a_ops->prepare_write(NULL, page, from, to);
  386. if (err == 0) {
  387. de->inode = inode->i_ino;
  388. err = dir_commit_chunk(page, from, to);
  389. } else {
  390. unlock_page(page);
  391. }
  392. dir_put_page(page);
  393. dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
  394. mark_inode_dirty(dir);
  395. }
  396. struct minix_dir_entry * minix_dotdot (struct inode *dir, struct page **p)
  397. {
  398. struct page *page = dir_get_page(dir, 0);
  399. struct minix_sb_info *sbi = minix_sb(dir->i_sb);
  400. struct minix_dir_entry *de = NULL;
  401. if (!IS_ERR(page)) {
  402. de = minix_next_entry(page_address(page), sbi);
  403. *p = page;
  404. }
  405. return de;
  406. }
  407. ino_t minix_inode_by_name(struct dentry *dentry)
  408. {
  409. struct page *page;
  410. struct minix_dir_entry *de = minix_find_entry(dentry, &page);
  411. ino_t res = 0;
  412. if (de) {
  413. res = de->inode;
  414. dir_put_page(page);
  415. }
  416. return res;
  417. }