namei.c 7.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386
  1. /*
  2. * linux/fs/ufs/namei.c
  3. *
  4. * Migration to usage of "page cache" on May 2006 by
  5. * Evgeniy Dushistov <dushistov@mail.ru> based on ext2 code base.
  6. *
  7. * Copyright (C) 1998
  8. * Daniel Pirkl <daniel.pirkl@email.cz>
  9. * Charles University, Faculty of Mathematics and Physics
  10. *
  11. * from
  12. *
  13. * linux/fs/ext2/namei.c
  14. *
  15. * Copyright (C) 1992, 1993, 1994, 1995
  16. * Remy Card (card@masi.ibp.fr)
  17. * Laboratoire MASI - Institut Blaise Pascal
  18. * Universite Pierre et Marie Curie (Paris VI)
  19. *
  20. * from
  21. *
  22. * linux/fs/minix/namei.c
  23. *
  24. * Copyright (C) 1991, 1992 Linus Torvalds
  25. *
  26. * Big-endian to little-endian byte-swapping/bitmaps by
  27. * David S. Miller (davem@caip.rutgers.edu), 1995
  28. */
  29. #include <linux/time.h>
  30. #include <linux/fs.h>
  31. #include <linux/smp_lock.h>
  32. #include <linux/quotaops.h>
  33. #include "ufs_fs.h"
  34. #include "ufs.h"
  35. #include "util.h"
  36. static inline int ufs_add_nondir(struct dentry *dentry, struct inode *inode)
  37. {
  38. int err = ufs_add_link(dentry, inode);
  39. if (!err) {
  40. d_instantiate(dentry, inode);
  41. return 0;
  42. }
  43. inode_dec_link_count(inode);
  44. iput(inode);
  45. return err;
  46. }
  47. static struct dentry *ufs_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd)
  48. {
  49. struct inode * inode = NULL;
  50. ino_t ino;
  51. if (dentry->d_name.len > UFS_MAXNAMLEN)
  52. return ERR_PTR(-ENAMETOOLONG);
  53. lock_kernel();
  54. ino = ufs_inode_by_name(dir, &dentry->d_name);
  55. if (ino) {
  56. inode = ufs_iget(dir->i_sb, ino);
  57. if (IS_ERR(inode)) {
  58. unlock_kernel();
  59. return ERR_CAST(inode);
  60. }
  61. }
  62. unlock_kernel();
  63. d_add(dentry, inode);
  64. return NULL;
  65. }
  66. /*
  67. * By the time this is called, we already have created
  68. * the directory cache entry for the new file, but it
  69. * is so far negative - it has no inode.
  70. *
  71. * If the create succeeds, we fill in the inode information
  72. * with d_instantiate().
  73. */
  74. static int ufs_create (struct inode * dir, struct dentry * dentry, int mode,
  75. struct nameidata *nd)
  76. {
  77. struct inode *inode;
  78. int err;
  79. UFSD("BEGIN\n");
  80. dquot_initialize(dir);
  81. inode = ufs_new_inode(dir, mode);
  82. err = PTR_ERR(inode);
  83. if (!IS_ERR(inode)) {
  84. inode->i_op = &ufs_file_inode_operations;
  85. inode->i_fop = &ufs_file_operations;
  86. inode->i_mapping->a_ops = &ufs_aops;
  87. mark_inode_dirty(inode);
  88. lock_kernel();
  89. err = ufs_add_nondir(dentry, inode);
  90. unlock_kernel();
  91. }
  92. UFSD("END: err=%d\n", err);
  93. return err;
  94. }
  95. static int ufs_mknod (struct inode * dir, struct dentry *dentry, int mode, dev_t rdev)
  96. {
  97. struct inode *inode;
  98. int err;
  99. if (!old_valid_dev(rdev))
  100. return -EINVAL;
  101. dquot_initialize(dir);
  102. inode = ufs_new_inode(dir, mode);
  103. err = PTR_ERR(inode);
  104. if (!IS_ERR(inode)) {
  105. init_special_inode(inode, mode, rdev);
  106. ufs_set_inode_dev(inode->i_sb, UFS_I(inode), rdev);
  107. mark_inode_dirty(inode);
  108. lock_kernel();
  109. err = ufs_add_nondir(dentry, inode);
  110. unlock_kernel();
  111. }
  112. return err;
  113. }
  114. static int ufs_symlink (struct inode * dir, struct dentry * dentry,
  115. const char * symname)
  116. {
  117. struct super_block * sb = dir->i_sb;
  118. int err = -ENAMETOOLONG;
  119. unsigned l = strlen(symname)+1;
  120. struct inode * inode;
  121. if (l > sb->s_blocksize)
  122. goto out_notlocked;
  123. dquot_initialize(dir);
  124. lock_kernel();
  125. inode = ufs_new_inode(dir, S_IFLNK | S_IRWXUGO);
  126. err = PTR_ERR(inode);
  127. if (IS_ERR(inode))
  128. goto out;
  129. if (l > UFS_SB(sb)->s_uspi->s_maxsymlinklen) {
  130. /* slow symlink */
  131. inode->i_op = &ufs_symlink_inode_operations;
  132. inode->i_mapping->a_ops = &ufs_aops;
  133. err = page_symlink(inode, symname, l);
  134. if (err)
  135. goto out_fail;
  136. } else {
  137. /* fast symlink */
  138. inode->i_op = &ufs_fast_symlink_inode_operations;
  139. memcpy(UFS_I(inode)->i_u1.i_symlink, symname, l);
  140. inode->i_size = l-1;
  141. }
  142. mark_inode_dirty(inode);
  143. err = ufs_add_nondir(dentry, inode);
  144. out:
  145. unlock_kernel();
  146. out_notlocked:
  147. return err;
  148. out_fail:
  149. inode_dec_link_count(inode);
  150. iput(inode);
  151. goto out;
  152. }
  153. static int ufs_link (struct dentry * old_dentry, struct inode * dir,
  154. struct dentry *dentry)
  155. {
  156. struct inode *inode = old_dentry->d_inode;
  157. int error;
  158. lock_kernel();
  159. if (inode->i_nlink >= UFS_LINK_MAX) {
  160. unlock_kernel();
  161. return -EMLINK;
  162. }
  163. dquot_initialize(dir);
  164. inode->i_ctime = CURRENT_TIME_SEC;
  165. inode_inc_link_count(inode);
  166. atomic_inc(&inode->i_count);
  167. error = ufs_add_nondir(dentry, inode);
  168. unlock_kernel();
  169. return error;
  170. }
  171. static int ufs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
  172. {
  173. struct inode * inode;
  174. int err = -EMLINK;
  175. if (dir->i_nlink >= UFS_LINK_MAX)
  176. goto out;
  177. dquot_initialize(dir);
  178. lock_kernel();
  179. inode_inc_link_count(dir);
  180. inode = ufs_new_inode(dir, S_IFDIR|mode);
  181. err = PTR_ERR(inode);
  182. if (IS_ERR(inode))
  183. goto out_dir;
  184. inode->i_op = &ufs_dir_inode_operations;
  185. inode->i_fop = &ufs_dir_operations;
  186. inode->i_mapping->a_ops = &ufs_aops;
  187. inode_inc_link_count(inode);
  188. err = ufs_make_empty(inode, dir);
  189. if (err)
  190. goto out_fail;
  191. err = ufs_add_link(dentry, inode);
  192. if (err)
  193. goto out_fail;
  194. unlock_kernel();
  195. d_instantiate(dentry, inode);
  196. out:
  197. return err;
  198. out_fail:
  199. inode_dec_link_count(inode);
  200. inode_dec_link_count(inode);
  201. iput (inode);
  202. out_dir:
  203. inode_dec_link_count(dir);
  204. unlock_kernel();
  205. goto out;
  206. }
  207. static int ufs_unlink(struct inode *dir, struct dentry *dentry)
  208. {
  209. struct inode * inode = dentry->d_inode;
  210. struct ufs_dir_entry *de;
  211. struct page *page;
  212. int err = -ENOENT;
  213. dquot_initialize(dir);
  214. de = ufs_find_entry(dir, &dentry->d_name, &page);
  215. if (!de)
  216. goto out;
  217. err = ufs_delete_entry(dir, de, page);
  218. if (err)
  219. goto out;
  220. inode->i_ctime = dir->i_ctime;
  221. inode_dec_link_count(inode);
  222. err = 0;
  223. out:
  224. return err;
  225. }
  226. static int ufs_rmdir (struct inode * dir, struct dentry *dentry)
  227. {
  228. struct inode * inode = dentry->d_inode;
  229. int err= -ENOTEMPTY;
  230. lock_kernel();
  231. if (ufs_empty_dir (inode)) {
  232. err = ufs_unlink(dir, dentry);
  233. if (!err) {
  234. inode->i_size = 0;
  235. inode_dec_link_count(inode);
  236. inode_dec_link_count(dir);
  237. }
  238. }
  239. unlock_kernel();
  240. return err;
  241. }
  242. static int ufs_rename(struct inode *old_dir, struct dentry *old_dentry,
  243. struct inode *new_dir, struct dentry *new_dentry)
  244. {
  245. struct inode *old_inode = old_dentry->d_inode;
  246. struct inode *new_inode = new_dentry->d_inode;
  247. struct page *dir_page = NULL;
  248. struct ufs_dir_entry * dir_de = NULL;
  249. struct page *old_page;
  250. struct ufs_dir_entry *old_de;
  251. int err = -ENOENT;
  252. dquot_initialize(old_dir);
  253. dquot_initialize(new_dir);
  254. old_de = ufs_find_entry(old_dir, &old_dentry->d_name, &old_page);
  255. if (!old_de)
  256. goto out;
  257. if (S_ISDIR(old_inode->i_mode)) {
  258. err = -EIO;
  259. dir_de = ufs_dotdot(old_inode, &dir_page);
  260. if (!dir_de)
  261. goto out_old;
  262. }
  263. if (new_inode) {
  264. struct page *new_page;
  265. struct ufs_dir_entry *new_de;
  266. err = -ENOTEMPTY;
  267. if (dir_de && !ufs_empty_dir(new_inode))
  268. goto out_dir;
  269. err = -ENOENT;
  270. new_de = ufs_find_entry(new_dir, &new_dentry->d_name, &new_page);
  271. if (!new_de)
  272. goto out_dir;
  273. inode_inc_link_count(old_inode);
  274. ufs_set_link(new_dir, new_de, new_page, old_inode);
  275. new_inode->i_ctime = CURRENT_TIME_SEC;
  276. if (dir_de)
  277. drop_nlink(new_inode);
  278. inode_dec_link_count(new_inode);
  279. } else {
  280. if (dir_de) {
  281. err = -EMLINK;
  282. if (new_dir->i_nlink >= UFS_LINK_MAX)
  283. goto out_dir;
  284. }
  285. inode_inc_link_count(old_inode);
  286. err = ufs_add_link(new_dentry, old_inode);
  287. if (err) {
  288. inode_dec_link_count(old_inode);
  289. goto out_dir;
  290. }
  291. if (dir_de)
  292. inode_inc_link_count(new_dir);
  293. }
  294. /*
  295. * Like most other Unix systems, set the ctime for inodes on a
  296. * rename.
  297. * inode_dec_link_count() will mark the inode dirty.
  298. */
  299. old_inode->i_ctime = CURRENT_TIME_SEC;
  300. ufs_delete_entry(old_dir, old_de, old_page);
  301. inode_dec_link_count(old_inode);
  302. if (dir_de) {
  303. ufs_set_link(old_inode, dir_de, dir_page, new_dir);
  304. inode_dec_link_count(old_dir);
  305. }
  306. return 0;
  307. out_dir:
  308. if (dir_de) {
  309. kunmap(dir_page);
  310. page_cache_release(dir_page);
  311. }
  312. out_old:
  313. kunmap(old_page);
  314. page_cache_release(old_page);
  315. out:
  316. return err;
  317. }
  318. const struct inode_operations ufs_dir_inode_operations = {
  319. .create = ufs_create,
  320. .lookup = ufs_lookup,
  321. .link = ufs_link,
  322. .unlink = ufs_unlink,
  323. .symlink = ufs_symlink,
  324. .mkdir = ufs_mkdir,
  325. .rmdir = ufs_rmdir,
  326. .mknod = ufs_mknod,
  327. .rename = ufs_rename,
  328. };