namei.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * namei.c - NILFS pathname lookup operations.
  4. *
  5. * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
  6. *
  7. * Modified for NILFS by Amagai Yoshiji and Ryusuke Konishi.
  8. */
  9. /*
  10. * linux/fs/ext2/namei.c
  11. *
  12. * Copyright (C) 1992, 1993, 1994, 1995
  13. * Remy Card (card@masi.ibp.fr)
  14. * Laboratoire MASI - Institut Blaise Pascal
  15. * Universite Pierre et Marie Curie (Paris VI)
  16. *
  17. * from
  18. *
  19. * linux/fs/minix/namei.c
  20. *
  21. * Copyright (C) 1991, 1992 Linus Torvalds
  22. *
  23. * Big-endian to little-endian byte-swapping/bitmaps by
  24. * David S. Miller (davem@caip.rutgers.edu), 1995
  25. */
  26. #include <linux/pagemap.h>
  27. #include "nilfs.h"
  28. #include "export.h"
  29. #define NILFS_FID_SIZE_NON_CONNECTABLE \
  30. (offsetof(struct nilfs_fid, parent_gen) / 4)
  31. #define NILFS_FID_SIZE_CONNECTABLE (sizeof(struct nilfs_fid) / 4)
  32. static inline int nilfs_add_nondir(struct dentry *dentry, struct inode *inode)
  33. {
  34. int err = nilfs_add_link(dentry, inode);
  35. if (!err) {
  36. d_instantiate_new(dentry, inode);
  37. return 0;
  38. }
  39. inode_dec_link_count(inode);
  40. unlock_new_inode(inode);
  41. iput(inode);
  42. return err;
  43. }
  44. /*
  45. * Methods themselves.
  46. */
  47. static struct dentry *
  48. nilfs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
  49. {
  50. struct inode *inode;
  51. ino_t ino;
  52. if (dentry->d_name.len > NILFS_NAME_LEN)
  53. return ERR_PTR(-ENAMETOOLONG);
  54. ino = nilfs_inode_by_name(dir, &dentry->d_name);
  55. inode = ino ? nilfs_iget(dir->i_sb, NILFS_I(dir)->i_root, ino) : NULL;
  56. return d_splice_alias(inode, dentry);
  57. }
  58. /*
  59. * By the time this is called, we already have created
  60. * the directory cache entry for the new file, but it
  61. * is so far negative - it has no inode.
  62. *
  63. * If the create succeeds, we fill in the inode information
  64. * with d_instantiate().
  65. */
  66. static int nilfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
  67. bool excl)
  68. {
  69. struct inode *inode;
  70. struct nilfs_transaction_info ti;
  71. int err;
  72. err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
  73. if (err)
  74. return err;
  75. inode = nilfs_new_inode(dir, mode);
  76. err = PTR_ERR(inode);
  77. if (!IS_ERR(inode)) {
  78. inode->i_op = &nilfs_file_inode_operations;
  79. inode->i_fop = &nilfs_file_operations;
  80. inode->i_mapping->a_ops = &nilfs_aops;
  81. nilfs_mark_inode_dirty(inode);
  82. err = nilfs_add_nondir(dentry, inode);
  83. }
  84. if (!err)
  85. err = nilfs_transaction_commit(dir->i_sb);
  86. else
  87. nilfs_transaction_abort(dir->i_sb);
  88. return err;
  89. }
  90. static int
  91. nilfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
  92. {
  93. struct inode *inode;
  94. struct nilfs_transaction_info ti;
  95. int err;
  96. err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
  97. if (err)
  98. return err;
  99. inode = nilfs_new_inode(dir, mode);
  100. err = PTR_ERR(inode);
  101. if (!IS_ERR(inode)) {
  102. init_special_inode(inode, inode->i_mode, rdev);
  103. nilfs_mark_inode_dirty(inode);
  104. err = nilfs_add_nondir(dentry, inode);
  105. }
  106. if (!err)
  107. err = nilfs_transaction_commit(dir->i_sb);
  108. else
  109. nilfs_transaction_abort(dir->i_sb);
  110. return err;
  111. }
  112. static int nilfs_symlink(struct inode *dir, struct dentry *dentry,
  113. const char *symname)
  114. {
  115. struct nilfs_transaction_info ti;
  116. struct super_block *sb = dir->i_sb;
  117. unsigned int l = strlen(symname) + 1;
  118. struct inode *inode;
  119. int err;
  120. if (l > sb->s_blocksize)
  121. return -ENAMETOOLONG;
  122. err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
  123. if (err)
  124. return err;
  125. inode = nilfs_new_inode(dir, S_IFLNK | 0777);
  126. err = PTR_ERR(inode);
  127. if (IS_ERR(inode))
  128. goto out;
  129. /* slow symlink */
  130. inode->i_op = &nilfs_symlink_inode_operations;
  131. inode_nohighmem(inode);
  132. inode->i_mapping->a_ops = &nilfs_aops;
  133. err = page_symlink(inode, symname, l);
  134. if (err)
  135. goto out_fail;
  136. /* mark_inode_dirty(inode); */
  137. /* page_symlink() do this */
  138. err = nilfs_add_nondir(dentry, inode);
  139. out:
  140. if (!err)
  141. err = nilfs_transaction_commit(dir->i_sb);
  142. else
  143. nilfs_transaction_abort(dir->i_sb);
  144. return err;
  145. out_fail:
  146. drop_nlink(inode);
  147. nilfs_mark_inode_dirty(inode);
  148. unlock_new_inode(inode);
  149. iput(inode);
  150. goto out;
  151. }
  152. static int nilfs_link(struct dentry *old_dentry, struct inode *dir,
  153. struct dentry *dentry)
  154. {
  155. struct inode *inode = d_inode(old_dentry);
  156. struct nilfs_transaction_info ti;
  157. int err;
  158. err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
  159. if (err)
  160. return err;
  161. inode->i_ctime = current_time(inode);
  162. inode_inc_link_count(inode);
  163. ihold(inode);
  164. err = nilfs_add_link(dentry, inode);
  165. if (!err) {
  166. d_instantiate(dentry, inode);
  167. err = nilfs_transaction_commit(dir->i_sb);
  168. } else {
  169. inode_dec_link_count(inode);
  170. iput(inode);
  171. nilfs_transaction_abort(dir->i_sb);
  172. }
  173. return err;
  174. }
  175. static int nilfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
  176. {
  177. struct inode *inode;
  178. struct nilfs_transaction_info ti;
  179. int err;
  180. err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
  181. if (err)
  182. return err;
  183. inc_nlink(dir);
  184. inode = nilfs_new_inode(dir, S_IFDIR | mode);
  185. err = PTR_ERR(inode);
  186. if (IS_ERR(inode))
  187. goto out_dir;
  188. inode->i_op = &nilfs_dir_inode_operations;
  189. inode->i_fop = &nilfs_dir_operations;
  190. inode->i_mapping->a_ops = &nilfs_aops;
  191. inc_nlink(inode);
  192. err = nilfs_make_empty(inode, dir);
  193. if (err)
  194. goto out_fail;
  195. err = nilfs_add_link(dentry, inode);
  196. if (err)
  197. goto out_fail;
  198. nilfs_mark_inode_dirty(inode);
  199. d_instantiate_new(dentry, inode);
  200. out:
  201. if (!err)
  202. err = nilfs_transaction_commit(dir->i_sb);
  203. else
  204. nilfs_transaction_abort(dir->i_sb);
  205. return err;
  206. out_fail:
  207. drop_nlink(inode);
  208. drop_nlink(inode);
  209. nilfs_mark_inode_dirty(inode);
  210. unlock_new_inode(inode);
  211. iput(inode);
  212. out_dir:
  213. drop_nlink(dir);
  214. nilfs_mark_inode_dirty(dir);
  215. goto out;
  216. }
  217. static int nilfs_do_unlink(struct inode *dir, struct dentry *dentry)
  218. {
  219. struct inode *inode;
  220. struct nilfs_dir_entry *de;
  221. struct page *page;
  222. int err;
  223. err = -ENOENT;
  224. de = nilfs_find_entry(dir, &dentry->d_name, &page);
  225. if (!de)
  226. goto out;
  227. inode = d_inode(dentry);
  228. err = -EIO;
  229. if (le64_to_cpu(de->inode) != inode->i_ino)
  230. goto out;
  231. if (!inode->i_nlink) {
  232. nilfs_warn(inode->i_sb,
  233. "deleting nonexistent file (ino=%lu), %d",
  234. inode->i_ino, inode->i_nlink);
  235. set_nlink(inode, 1);
  236. }
  237. err = nilfs_delete_entry(de, page);
  238. if (err)
  239. goto out;
  240. inode->i_ctime = dir->i_ctime;
  241. drop_nlink(inode);
  242. err = 0;
  243. out:
  244. return err;
  245. }
  246. static int nilfs_unlink(struct inode *dir, struct dentry *dentry)
  247. {
  248. struct nilfs_transaction_info ti;
  249. int err;
  250. err = nilfs_transaction_begin(dir->i_sb, &ti, 0);
  251. if (err)
  252. return err;
  253. err = nilfs_do_unlink(dir, dentry);
  254. if (!err) {
  255. nilfs_mark_inode_dirty(dir);
  256. nilfs_mark_inode_dirty(d_inode(dentry));
  257. err = nilfs_transaction_commit(dir->i_sb);
  258. } else
  259. nilfs_transaction_abort(dir->i_sb);
  260. return err;
  261. }
  262. static int nilfs_rmdir(struct inode *dir, struct dentry *dentry)
  263. {
  264. struct inode *inode = d_inode(dentry);
  265. struct nilfs_transaction_info ti;
  266. int err;
  267. err = nilfs_transaction_begin(dir->i_sb, &ti, 0);
  268. if (err)
  269. return err;
  270. err = -ENOTEMPTY;
  271. if (nilfs_empty_dir(inode)) {
  272. err = nilfs_do_unlink(dir, dentry);
  273. if (!err) {
  274. inode->i_size = 0;
  275. drop_nlink(inode);
  276. nilfs_mark_inode_dirty(inode);
  277. drop_nlink(dir);
  278. nilfs_mark_inode_dirty(dir);
  279. }
  280. }
  281. if (!err)
  282. err = nilfs_transaction_commit(dir->i_sb);
  283. else
  284. nilfs_transaction_abort(dir->i_sb);
  285. return err;
  286. }
  287. static int nilfs_rename(struct inode *old_dir, struct dentry *old_dentry,
  288. struct inode *new_dir, struct dentry *new_dentry,
  289. unsigned int flags)
  290. {
  291. struct inode *old_inode = d_inode(old_dentry);
  292. struct inode *new_inode = d_inode(new_dentry);
  293. struct page *dir_page = NULL;
  294. struct nilfs_dir_entry *dir_de = NULL;
  295. struct page *old_page;
  296. struct nilfs_dir_entry *old_de;
  297. struct nilfs_transaction_info ti;
  298. int err;
  299. if (flags & ~RENAME_NOREPLACE)
  300. return -EINVAL;
  301. err = nilfs_transaction_begin(old_dir->i_sb, &ti, 1);
  302. if (unlikely(err))
  303. return err;
  304. err = -ENOENT;
  305. old_de = nilfs_find_entry(old_dir, &old_dentry->d_name, &old_page);
  306. if (!old_de)
  307. goto out;
  308. if (S_ISDIR(old_inode->i_mode)) {
  309. err = -EIO;
  310. dir_de = nilfs_dotdot(old_inode, &dir_page);
  311. if (!dir_de)
  312. goto out_old;
  313. }
  314. if (new_inode) {
  315. struct page *new_page;
  316. struct nilfs_dir_entry *new_de;
  317. err = -ENOTEMPTY;
  318. if (dir_de && !nilfs_empty_dir(new_inode))
  319. goto out_dir;
  320. err = -ENOENT;
  321. new_de = nilfs_find_entry(new_dir, &new_dentry->d_name, &new_page);
  322. if (!new_de)
  323. goto out_dir;
  324. nilfs_set_link(new_dir, new_de, new_page, old_inode);
  325. nilfs_mark_inode_dirty(new_dir);
  326. new_inode->i_ctime = current_time(new_inode);
  327. if (dir_de)
  328. drop_nlink(new_inode);
  329. drop_nlink(new_inode);
  330. nilfs_mark_inode_dirty(new_inode);
  331. } else {
  332. err = nilfs_add_link(new_dentry, old_inode);
  333. if (err)
  334. goto out_dir;
  335. if (dir_de) {
  336. inc_nlink(new_dir);
  337. nilfs_mark_inode_dirty(new_dir);
  338. }
  339. }
  340. /*
  341. * Like most other Unix systems, set the ctime for inodes on a
  342. * rename.
  343. */
  344. old_inode->i_ctime = current_time(old_inode);
  345. nilfs_delete_entry(old_de, old_page);
  346. if (dir_de) {
  347. nilfs_set_link(old_inode, dir_de, dir_page, new_dir);
  348. drop_nlink(old_dir);
  349. }
  350. nilfs_mark_inode_dirty(old_dir);
  351. nilfs_mark_inode_dirty(old_inode);
  352. err = nilfs_transaction_commit(old_dir->i_sb);
  353. return err;
  354. out_dir:
  355. if (dir_de) {
  356. kunmap(dir_page);
  357. put_page(dir_page);
  358. }
  359. out_old:
  360. kunmap(old_page);
  361. put_page(old_page);
  362. out:
  363. nilfs_transaction_abort(old_dir->i_sb);
  364. return err;
  365. }
  366. /*
  367. * Export operations
  368. */
  369. static struct dentry *nilfs_get_parent(struct dentry *child)
  370. {
  371. unsigned long ino;
  372. struct inode *inode;
  373. struct qstr dotdot = QSTR_INIT("..", 2);
  374. struct nilfs_root *root;
  375. ino = nilfs_inode_by_name(d_inode(child), &dotdot);
  376. if (!ino)
  377. return ERR_PTR(-ENOENT);
  378. root = NILFS_I(d_inode(child))->i_root;
  379. inode = nilfs_iget(child->d_sb, root, ino);
  380. if (IS_ERR(inode))
  381. return ERR_CAST(inode);
  382. return d_obtain_alias(inode);
  383. }
  384. static struct dentry *nilfs_get_dentry(struct super_block *sb, u64 cno,
  385. u64 ino, u32 gen)
  386. {
  387. struct nilfs_root *root;
  388. struct inode *inode;
  389. if (ino < NILFS_FIRST_INO(sb) && ino != NILFS_ROOT_INO)
  390. return ERR_PTR(-ESTALE);
  391. root = nilfs_lookup_root(sb->s_fs_info, cno);
  392. if (!root)
  393. return ERR_PTR(-ESTALE);
  394. inode = nilfs_iget(sb, root, ino);
  395. nilfs_put_root(root);
  396. if (IS_ERR(inode))
  397. return ERR_CAST(inode);
  398. if (gen && inode->i_generation != gen) {
  399. iput(inode);
  400. return ERR_PTR(-ESTALE);
  401. }
  402. return d_obtain_alias(inode);
  403. }
  404. static struct dentry *nilfs_fh_to_dentry(struct super_block *sb, struct fid *fh,
  405. int fh_len, int fh_type)
  406. {
  407. struct nilfs_fid *fid = (struct nilfs_fid *)fh;
  408. if (fh_len < NILFS_FID_SIZE_NON_CONNECTABLE ||
  409. (fh_type != FILEID_NILFS_WITH_PARENT &&
  410. fh_type != FILEID_NILFS_WITHOUT_PARENT))
  411. return NULL;
  412. return nilfs_get_dentry(sb, fid->cno, fid->ino, fid->gen);
  413. }
  414. static struct dentry *nilfs_fh_to_parent(struct super_block *sb, struct fid *fh,
  415. int fh_len, int fh_type)
  416. {
  417. struct nilfs_fid *fid = (struct nilfs_fid *)fh;
  418. if (fh_len < NILFS_FID_SIZE_CONNECTABLE ||
  419. fh_type != FILEID_NILFS_WITH_PARENT)
  420. return NULL;
  421. return nilfs_get_dentry(sb, fid->cno, fid->parent_ino, fid->parent_gen);
  422. }
  423. static int nilfs_encode_fh(struct inode *inode, __u32 *fh, int *lenp,
  424. struct inode *parent)
  425. {
  426. struct nilfs_fid *fid = (struct nilfs_fid *)fh;
  427. struct nilfs_root *root = NILFS_I(inode)->i_root;
  428. int type;
  429. if (parent && *lenp < NILFS_FID_SIZE_CONNECTABLE) {
  430. *lenp = NILFS_FID_SIZE_CONNECTABLE;
  431. return FILEID_INVALID;
  432. }
  433. if (*lenp < NILFS_FID_SIZE_NON_CONNECTABLE) {
  434. *lenp = NILFS_FID_SIZE_NON_CONNECTABLE;
  435. return FILEID_INVALID;
  436. }
  437. fid->cno = root->cno;
  438. fid->ino = inode->i_ino;
  439. fid->gen = inode->i_generation;
  440. if (parent) {
  441. fid->parent_ino = parent->i_ino;
  442. fid->parent_gen = parent->i_generation;
  443. type = FILEID_NILFS_WITH_PARENT;
  444. *lenp = NILFS_FID_SIZE_CONNECTABLE;
  445. } else {
  446. type = FILEID_NILFS_WITHOUT_PARENT;
  447. *lenp = NILFS_FID_SIZE_NON_CONNECTABLE;
  448. }
  449. return type;
  450. }
  451. const struct inode_operations nilfs_dir_inode_operations = {
  452. .create = nilfs_create,
  453. .lookup = nilfs_lookup,
  454. .link = nilfs_link,
  455. .unlink = nilfs_unlink,
  456. .symlink = nilfs_symlink,
  457. .mkdir = nilfs_mkdir,
  458. .rmdir = nilfs_rmdir,
  459. .mknod = nilfs_mknod,
  460. .rename = nilfs_rename,
  461. .setattr = nilfs_setattr,
  462. .permission = nilfs_permission,
  463. .fiemap = nilfs_fiemap,
  464. };
  465. const struct inode_operations nilfs_special_inode_operations = {
  466. .setattr = nilfs_setattr,
  467. .permission = nilfs_permission,
  468. };
  469. const struct inode_operations nilfs_symlink_inode_operations = {
  470. .get_link = page_get_link,
  471. .permission = nilfs_permission,
  472. };
  473. const struct export_operations nilfs_export_ops = {
  474. .encode_fh = nilfs_encode_fh,
  475. .fh_to_dentry = nilfs_fh_to_dentry,
  476. .fh_to_parent = nilfs_fh_to_parent,
  477. .get_parent = nilfs_get_parent,
  478. };