dir.c 11 KB

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