dir.c 8.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * linux/fs/sysv/dir.c
  4. *
  5. * minix/dir.c
  6. * Copyright (C) 1991, 1992 Linus Torvalds
  7. *
  8. * coh/dir.c
  9. * Copyright (C) 1993 Pascal Haible, Bruno Haible
  10. *
  11. * sysv/dir.c
  12. * Copyright (C) 1993 Bruno Haible
  13. *
  14. * SystemV/Coherent directory handling functions
  15. */
  16. #include <linux/pagemap.h>
  17. #include <linux/highmem.h>
  18. #include <linux/swap.h>
  19. #include "sysv.h"
  20. static int sysv_readdir(struct file *, struct dir_context *);
  21. const struct file_operations sysv_dir_operations = {
  22. .llseek = generic_file_llseek,
  23. .read = generic_read_dir,
  24. .iterate_shared = sysv_readdir,
  25. .fsync = generic_file_fsync,
  26. };
  27. static inline void dir_put_page(struct page *page)
  28. {
  29. kunmap(page);
  30. put_page(page);
  31. }
  32. static int dir_commit_chunk(struct page *page, loff_t pos, unsigned len)
  33. {
  34. struct address_space *mapping = page->mapping;
  35. struct inode *dir = mapping->host;
  36. int err = 0;
  37. block_write_end(NULL, mapping, pos, len, len, page, NULL);
  38. if (pos+len > dir->i_size) {
  39. i_size_write(dir, pos+len);
  40. mark_inode_dirty(dir);
  41. }
  42. if (IS_DIRSYNC(dir))
  43. err = write_one_page(page);
  44. else
  45. unlock_page(page);
  46. return err;
  47. }
  48. static struct page * dir_get_page(struct inode *dir, unsigned long n)
  49. {
  50. struct address_space *mapping = dir->i_mapping;
  51. struct page *page = read_mapping_page(mapping, n, NULL);
  52. if (!IS_ERR(page))
  53. kmap(page);
  54. return page;
  55. }
  56. static int sysv_readdir(struct file *file, struct dir_context *ctx)
  57. {
  58. unsigned long pos = ctx->pos;
  59. struct inode *inode = file_inode(file);
  60. struct super_block *sb = inode->i_sb;
  61. unsigned long npages = dir_pages(inode);
  62. unsigned offset;
  63. unsigned long n;
  64. ctx->pos = pos = (pos + SYSV_DIRSIZE-1) & ~(SYSV_DIRSIZE-1);
  65. if (pos >= inode->i_size)
  66. return 0;
  67. offset = pos & ~PAGE_MASK;
  68. n = pos >> PAGE_SHIFT;
  69. for ( ; n < npages; n++, offset = 0) {
  70. char *kaddr, *limit;
  71. struct sysv_dir_entry *de;
  72. struct page *page = dir_get_page(inode, n);
  73. if (IS_ERR(page))
  74. continue;
  75. kaddr = (char *)page_address(page);
  76. de = (struct sysv_dir_entry *)(kaddr+offset);
  77. limit = kaddr + PAGE_SIZE - SYSV_DIRSIZE;
  78. for ( ;(char*)de <= limit; de++, ctx->pos += sizeof(*de)) {
  79. char *name = de->name;
  80. if (!de->inode)
  81. continue;
  82. if (!dir_emit(ctx, name, strnlen(name,SYSV_NAMELEN),
  83. fs16_to_cpu(SYSV_SB(sb), de->inode),
  84. DT_UNKNOWN)) {
  85. dir_put_page(page);
  86. return 0;
  87. }
  88. }
  89. dir_put_page(page);
  90. }
  91. return 0;
  92. }
  93. /* compare strings: name[0..len-1] (not zero-terminated) and
  94. * buffer[0..] (filled with zeroes up to buffer[0..maxlen-1])
  95. */
  96. static inline int namecompare(int len, int maxlen,
  97. const char * name, const char * buffer)
  98. {
  99. if (len < maxlen && buffer[len])
  100. return 0;
  101. return !memcmp(name, buffer, len);
  102. }
  103. /*
  104. * sysv_find_entry()
  105. *
  106. * finds an entry in the specified directory with the wanted name. It
  107. * returns the cache buffer in which the entry was found, and the entry
  108. * itself (as a parameter - res_dir). It does NOT read the inode of the
  109. * entry - you'll have to do that yourself if you want to.
  110. */
  111. struct sysv_dir_entry *sysv_find_entry(struct dentry *dentry, struct page **res_page)
  112. {
  113. const char * name = dentry->d_name.name;
  114. int namelen = dentry->d_name.len;
  115. struct inode * dir = d_inode(dentry->d_parent);
  116. unsigned long start, n;
  117. unsigned long npages = dir_pages(dir);
  118. struct page *page = NULL;
  119. struct sysv_dir_entry *de;
  120. *res_page = NULL;
  121. start = SYSV_I(dir)->i_dir_start_lookup;
  122. if (start >= npages)
  123. start = 0;
  124. n = start;
  125. do {
  126. char *kaddr;
  127. page = dir_get_page(dir, n);
  128. if (!IS_ERR(page)) {
  129. kaddr = (char*)page_address(page);
  130. de = (struct sysv_dir_entry *) kaddr;
  131. kaddr += PAGE_SIZE - SYSV_DIRSIZE;
  132. for ( ; (char *) de <= kaddr ; de++) {
  133. if (!de->inode)
  134. continue;
  135. if (namecompare(namelen, SYSV_NAMELEN,
  136. name, de->name))
  137. goto found;
  138. }
  139. dir_put_page(page);
  140. }
  141. if (++n >= npages)
  142. n = 0;
  143. } while (n != start);
  144. return NULL;
  145. found:
  146. SYSV_I(dir)->i_dir_start_lookup = n;
  147. *res_page = page;
  148. return de;
  149. }
  150. int sysv_add_link(struct dentry *dentry, struct inode *inode)
  151. {
  152. struct inode *dir = d_inode(dentry->d_parent);
  153. const char * name = dentry->d_name.name;
  154. int namelen = dentry->d_name.len;
  155. struct page *page = NULL;
  156. struct sysv_dir_entry * de;
  157. unsigned long npages = dir_pages(dir);
  158. unsigned long n;
  159. char *kaddr;
  160. loff_t pos;
  161. int err;
  162. /* We take care of directory expansion in the same loop */
  163. for (n = 0; n <= npages; n++) {
  164. page = dir_get_page(dir, n);
  165. err = PTR_ERR(page);
  166. if (IS_ERR(page))
  167. goto out;
  168. kaddr = (char*)page_address(page);
  169. de = (struct sysv_dir_entry *)kaddr;
  170. kaddr += PAGE_SIZE - SYSV_DIRSIZE;
  171. while ((char *)de <= kaddr) {
  172. if (!de->inode)
  173. goto got_it;
  174. err = -EEXIST;
  175. if (namecompare(namelen, SYSV_NAMELEN, name, de->name))
  176. goto out_page;
  177. de++;
  178. }
  179. dir_put_page(page);
  180. }
  181. BUG();
  182. return -EINVAL;
  183. got_it:
  184. pos = page_offset(page) +
  185. (char*)de - (char*)page_address(page);
  186. lock_page(page);
  187. err = sysv_prepare_chunk(page, pos, SYSV_DIRSIZE);
  188. if (err)
  189. goto out_unlock;
  190. memcpy (de->name, name, namelen);
  191. memset (de->name + namelen, 0, SYSV_DIRSIZE - namelen - 2);
  192. de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino);
  193. err = dir_commit_chunk(page, pos, SYSV_DIRSIZE);
  194. dir->i_mtime = dir->i_ctime = current_time(dir);
  195. mark_inode_dirty(dir);
  196. out_page:
  197. dir_put_page(page);
  198. out:
  199. return err;
  200. out_unlock:
  201. unlock_page(page);
  202. goto out_page;
  203. }
  204. int sysv_delete_entry(struct sysv_dir_entry *de, struct page *page)
  205. {
  206. struct inode *inode = page->mapping->host;
  207. char *kaddr = (char*)page_address(page);
  208. loff_t pos = page_offset(page) + (char *)de - kaddr;
  209. int err;
  210. lock_page(page);
  211. err = sysv_prepare_chunk(page, pos, SYSV_DIRSIZE);
  212. BUG_ON(err);
  213. de->inode = 0;
  214. err = dir_commit_chunk(page, pos, SYSV_DIRSIZE);
  215. dir_put_page(page);
  216. inode->i_ctime = inode->i_mtime = current_time(inode);
  217. mark_inode_dirty(inode);
  218. return err;
  219. }
  220. int sysv_make_empty(struct inode *inode, struct inode *dir)
  221. {
  222. struct page *page = grab_cache_page(inode->i_mapping, 0);
  223. struct sysv_dir_entry * de;
  224. char *base;
  225. int err;
  226. if (!page)
  227. return -ENOMEM;
  228. err = sysv_prepare_chunk(page, 0, 2 * SYSV_DIRSIZE);
  229. if (err) {
  230. unlock_page(page);
  231. goto fail;
  232. }
  233. kmap(page);
  234. base = (char*)page_address(page);
  235. memset(base, 0, PAGE_SIZE);
  236. de = (struct sysv_dir_entry *) base;
  237. de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino);
  238. strcpy(de->name,".");
  239. de++;
  240. de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), dir->i_ino);
  241. strcpy(de->name,"..");
  242. kunmap(page);
  243. err = dir_commit_chunk(page, 0, 2 * SYSV_DIRSIZE);
  244. fail:
  245. put_page(page);
  246. return err;
  247. }
  248. /*
  249. * routine to check that the specified directory is empty (for rmdir)
  250. */
  251. int sysv_empty_dir(struct inode * inode)
  252. {
  253. struct super_block *sb = inode->i_sb;
  254. struct page *page = NULL;
  255. unsigned long i, npages = dir_pages(inode);
  256. for (i = 0; i < npages; i++) {
  257. char *kaddr;
  258. struct sysv_dir_entry * de;
  259. page = dir_get_page(inode, i);
  260. if (IS_ERR(page))
  261. continue;
  262. kaddr = (char *)page_address(page);
  263. de = (struct sysv_dir_entry *)kaddr;
  264. kaddr += PAGE_SIZE-SYSV_DIRSIZE;
  265. for ( ;(char *)de <= kaddr; de++) {
  266. if (!de->inode)
  267. continue;
  268. /* check for . and .. */
  269. if (de->name[0] != '.')
  270. goto not_empty;
  271. if (!de->name[1]) {
  272. if (de->inode == cpu_to_fs16(SYSV_SB(sb),
  273. inode->i_ino))
  274. continue;
  275. goto not_empty;
  276. }
  277. if (de->name[1] != '.' || de->name[2])
  278. goto not_empty;
  279. }
  280. dir_put_page(page);
  281. }
  282. return 1;
  283. not_empty:
  284. dir_put_page(page);
  285. return 0;
  286. }
  287. /* Releases the page */
  288. void sysv_set_link(struct sysv_dir_entry *de, struct page *page,
  289. struct inode *inode)
  290. {
  291. struct inode *dir = page->mapping->host;
  292. loff_t pos = page_offset(page) +
  293. (char *)de-(char*)page_address(page);
  294. int err;
  295. lock_page(page);
  296. err = sysv_prepare_chunk(page, pos, SYSV_DIRSIZE);
  297. BUG_ON(err);
  298. de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino);
  299. err = dir_commit_chunk(page, pos, SYSV_DIRSIZE);
  300. dir_put_page(page);
  301. dir->i_mtime = dir->i_ctime = current_time(dir);
  302. mark_inode_dirty(dir);
  303. }
  304. struct sysv_dir_entry * sysv_dotdot (struct inode *dir, struct page **p)
  305. {
  306. struct page *page = dir_get_page(dir, 0);
  307. struct sysv_dir_entry *de = NULL;
  308. if (!IS_ERR(page)) {
  309. de = (struct sysv_dir_entry*) page_address(page) + 1;
  310. *p = page;
  311. }
  312. return de;
  313. }
  314. ino_t sysv_inode_by_name(struct dentry *dentry)
  315. {
  316. struct page *page;
  317. struct sysv_dir_entry *de = sysv_find_entry (dentry, &page);
  318. ino_t res = 0;
  319. if (de) {
  320. res = fs16_to_cpu(SYSV_SB(dentry->d_sb), de->inode);
  321. dir_put_page(page);
  322. }
  323. return res;
  324. }