namei.c 6.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305
  1. /*
  2. * linux/fs/minix/namei.c
  3. *
  4. * Copyright (C) 1991, 1992 Linus Torvalds
  5. */
  6. #include "minix.h"
  7. static int add_nondir(struct dentry *dentry, struct inode *inode)
  8. {
  9. int err = minix_add_link(dentry, inode);
  10. if (!err) {
  11. d_instantiate(dentry, inode);
  12. return 0;
  13. }
  14. inode_dec_link_count(inode);
  15. iput(inode);
  16. return err;
  17. }
  18. static int minix_hash(struct dentry *dentry, struct qstr *qstr)
  19. {
  20. unsigned long hash;
  21. int i;
  22. const unsigned char *name;
  23. i = minix_sb(dentry->d_inode->i_sb)->s_namelen;
  24. if (i >= qstr->len)
  25. return 0;
  26. /* Truncate the name in place, avoids having to define a compare
  27. function. */
  28. qstr->len = i;
  29. name = qstr->name;
  30. hash = init_name_hash();
  31. while (i--)
  32. hash = partial_name_hash(*name++, hash);
  33. qstr->hash = end_name_hash(hash);
  34. return 0;
  35. }
  36. struct dentry_operations minix_dentry_operations = {
  37. .d_hash = minix_hash,
  38. };
  39. static struct dentry *minix_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd)
  40. {
  41. struct inode * inode = NULL;
  42. ino_t ino;
  43. dentry->d_op = dir->i_sb->s_root->d_op;
  44. if (dentry->d_name.len > minix_sb(dir->i_sb)->s_namelen)
  45. return ERR_PTR(-ENAMETOOLONG);
  46. ino = minix_inode_by_name(dentry);
  47. if (ino) {
  48. inode = iget(dir->i_sb, ino);
  49. if (!inode)
  50. return ERR_PTR(-EACCES);
  51. }
  52. d_add(dentry, inode);
  53. return NULL;
  54. }
  55. static int minix_mknod(struct inode * dir, struct dentry *dentry, int mode, dev_t rdev)
  56. {
  57. int error;
  58. struct inode *inode;
  59. if (!old_valid_dev(rdev))
  60. return -EINVAL;
  61. inode = minix_new_inode(dir, &error);
  62. if (inode) {
  63. inode->i_mode = mode;
  64. minix_set_inode(inode, rdev);
  65. mark_inode_dirty(inode);
  66. error = add_nondir(dentry, inode);
  67. }
  68. return error;
  69. }
  70. static int minix_create(struct inode * dir, struct dentry *dentry, int mode,
  71. struct nameidata *nd)
  72. {
  73. return minix_mknod(dir, dentry, mode, 0);
  74. }
  75. static int minix_symlink(struct inode * dir, struct dentry *dentry,
  76. const char * symname)
  77. {
  78. int err = -ENAMETOOLONG;
  79. int i = strlen(symname)+1;
  80. struct inode * inode;
  81. if (i > dir->i_sb->s_blocksize)
  82. goto out;
  83. inode = minix_new_inode(dir, &err);
  84. if (!inode)
  85. goto out;
  86. inode->i_mode = S_IFLNK | 0777;
  87. minix_set_inode(inode, 0);
  88. err = page_symlink(inode, symname, i);
  89. if (err)
  90. goto out_fail;
  91. err = add_nondir(dentry, inode);
  92. out:
  93. return err;
  94. out_fail:
  95. inode_dec_link_count(inode);
  96. iput(inode);
  97. goto out;
  98. }
  99. static int minix_link(struct dentry * old_dentry, struct inode * dir,
  100. struct dentry *dentry)
  101. {
  102. struct inode *inode = old_dentry->d_inode;
  103. if (inode->i_nlink >= minix_sb(inode->i_sb)->s_link_max)
  104. return -EMLINK;
  105. inode->i_ctime = CURRENT_TIME_SEC;
  106. inode_inc_link_count(inode);
  107. atomic_inc(&inode->i_count);
  108. return add_nondir(dentry, inode);
  109. }
  110. static int minix_mkdir(struct inode * dir, struct dentry *dentry, int mode)
  111. {
  112. struct inode * inode;
  113. int err = -EMLINK;
  114. if (dir->i_nlink >= minix_sb(dir->i_sb)->s_link_max)
  115. goto out;
  116. inode_inc_link_count(dir);
  117. inode = minix_new_inode(dir, &err);
  118. if (!inode)
  119. goto out_dir;
  120. inode->i_mode = S_IFDIR | mode;
  121. if (dir->i_mode & S_ISGID)
  122. inode->i_mode |= S_ISGID;
  123. minix_set_inode(inode, 0);
  124. inode_inc_link_count(inode);
  125. err = minix_make_empty(inode, dir);
  126. if (err)
  127. goto out_fail;
  128. err = minix_add_link(dentry, inode);
  129. if (err)
  130. goto out_fail;
  131. d_instantiate(dentry, inode);
  132. out:
  133. return err;
  134. out_fail:
  135. inode_dec_link_count(inode);
  136. inode_dec_link_count(inode);
  137. iput(inode);
  138. out_dir:
  139. inode_dec_link_count(dir);
  140. goto out;
  141. }
  142. static int minix_unlink(struct inode * dir, struct dentry *dentry)
  143. {
  144. int err = -ENOENT;
  145. struct inode * inode = dentry->d_inode;
  146. struct page * page;
  147. struct minix_dir_entry * de;
  148. de = minix_find_entry(dentry, &page);
  149. if (!de)
  150. goto end_unlink;
  151. err = minix_delete_entry(de, page);
  152. if (err)
  153. goto end_unlink;
  154. inode->i_ctime = dir->i_ctime;
  155. inode_dec_link_count(inode);
  156. end_unlink:
  157. return err;
  158. }
  159. static int minix_rmdir(struct inode * dir, struct dentry *dentry)
  160. {
  161. struct inode * inode = dentry->d_inode;
  162. int err = -ENOTEMPTY;
  163. if (minix_empty_dir(inode)) {
  164. err = minix_unlink(dir, dentry);
  165. if (!err) {
  166. inode_dec_link_count(dir);
  167. inode_dec_link_count(inode);
  168. }
  169. }
  170. return err;
  171. }
  172. static int minix_rename(struct inode * old_dir, struct dentry *old_dentry,
  173. struct inode * new_dir, struct dentry *new_dentry)
  174. {
  175. struct minix_sb_info * info = minix_sb(old_dir->i_sb);
  176. struct inode * old_inode = old_dentry->d_inode;
  177. struct inode * new_inode = new_dentry->d_inode;
  178. struct page * dir_page = NULL;
  179. struct minix_dir_entry * dir_de = NULL;
  180. struct page * old_page;
  181. struct minix_dir_entry * old_de;
  182. int err = -ENOENT;
  183. old_de = minix_find_entry(old_dentry, &old_page);
  184. if (!old_de)
  185. goto out;
  186. if (S_ISDIR(old_inode->i_mode)) {
  187. err = -EIO;
  188. dir_de = minix_dotdot(old_inode, &dir_page);
  189. if (!dir_de)
  190. goto out_old;
  191. }
  192. if (new_inode) {
  193. struct page * new_page;
  194. struct minix_dir_entry * new_de;
  195. err = -ENOTEMPTY;
  196. if (dir_de && !minix_empty_dir(new_inode))
  197. goto out_dir;
  198. err = -ENOENT;
  199. new_de = minix_find_entry(new_dentry, &new_page);
  200. if (!new_de)
  201. goto out_dir;
  202. inode_inc_link_count(old_inode);
  203. minix_set_link(new_de, new_page, old_inode);
  204. new_inode->i_ctime = CURRENT_TIME_SEC;
  205. if (dir_de)
  206. drop_nlink(new_inode);
  207. inode_dec_link_count(new_inode);
  208. } else {
  209. if (dir_de) {
  210. err = -EMLINK;
  211. if (new_dir->i_nlink >= info->s_link_max)
  212. goto out_dir;
  213. }
  214. inode_inc_link_count(old_inode);
  215. err = minix_add_link(new_dentry, old_inode);
  216. if (err) {
  217. inode_dec_link_count(old_inode);
  218. goto out_dir;
  219. }
  220. if (dir_de)
  221. inode_inc_link_count(new_dir);
  222. }
  223. minix_delete_entry(old_de, old_page);
  224. inode_dec_link_count(old_inode);
  225. if (dir_de) {
  226. minix_set_link(dir_de, dir_page, new_dir);
  227. inode_dec_link_count(old_dir);
  228. }
  229. return 0;
  230. out_dir:
  231. if (dir_de) {
  232. kunmap(dir_page);
  233. page_cache_release(dir_page);
  234. }
  235. out_old:
  236. kunmap(old_page);
  237. page_cache_release(old_page);
  238. out:
  239. return err;
  240. }
  241. /*
  242. * directories can handle most operations...
  243. */
  244. const struct inode_operations minix_dir_inode_operations = {
  245. .create = minix_create,
  246. .lookup = minix_lookup,
  247. .link = minix_link,
  248. .unlink = minix_unlink,
  249. .symlink = minix_symlink,
  250. .mkdir = minix_mkdir,
  251. .rmdir = minix_rmdir,
  252. .mknod = minix_mknod,
  253. .rename = minix_rename,
  254. .getattr = minix_getattr,
  255. };