namei.c 33 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * fs/f2fs/namei.c
  4. *
  5. * Copyright (c) 2012 Samsung Electronics Co., Ltd.
  6. * http://www.samsung.com/
  7. */
  8. #include <linux/fs.h>
  9. #include <linux/f2fs_fs.h>
  10. #include <linux/pagemap.h>
  11. #include <linux/sched.h>
  12. #include <linux/ctype.h>
  13. #include <linux/random.h>
  14. #include <linux/dcache.h>
  15. #include <linux/namei.h>
  16. #include <linux/quotaops.h>
  17. #include "f2fs.h"
  18. #include "node.h"
  19. #include "segment.h"
  20. #include "xattr.h"
  21. #include "acl.h"
  22. #include <trace/events/f2fs.h>
  23. static inline bool is_extension_exist(const unsigned char *s, const char *sub,
  24. bool tmp_ext)
  25. {
  26. size_t slen = strlen(s);
  27. size_t sublen = strlen(sub);
  28. int i;
  29. if (sublen == 1 && *sub == '*')
  30. return true;
  31. /*
  32. * filename format of multimedia file should be defined as:
  33. * "filename + '.' + extension + (optional: '.' + temp extension)".
  34. */
  35. if (slen < sublen + 2)
  36. return false;
  37. if (!tmp_ext) {
  38. /* file has no temp extension */
  39. if (s[slen - sublen - 1] != '.')
  40. return false;
  41. return !strncasecmp(s + slen - sublen, sub, sublen);
  42. }
  43. for (i = 1; i < slen - sublen; i++) {
  44. if (s[i] != '.')
  45. continue;
  46. if (!strncasecmp(s + i + 1, sub, sublen))
  47. return true;
  48. }
  49. return false;
  50. }
  51. int f2fs_update_extension_list(struct f2fs_sb_info *sbi, const char *name,
  52. bool hot, bool set)
  53. {
  54. __u8 (*extlist)[F2FS_EXTENSION_LEN] = sbi->raw_super->extension_list;
  55. int cold_count = le32_to_cpu(sbi->raw_super->extension_count);
  56. int hot_count = sbi->raw_super->hot_ext_count;
  57. int total_count = cold_count + hot_count;
  58. int start, count;
  59. int i;
  60. if (set) {
  61. if (total_count == F2FS_MAX_EXTENSION)
  62. return -EINVAL;
  63. } else {
  64. if (!hot && !cold_count)
  65. return -EINVAL;
  66. if (hot && !hot_count)
  67. return -EINVAL;
  68. }
  69. if (hot) {
  70. start = cold_count;
  71. count = total_count;
  72. } else {
  73. start = 0;
  74. count = cold_count;
  75. }
  76. for (i = start; i < count; i++) {
  77. if (strcmp(name, extlist[i]))
  78. continue;
  79. if (set)
  80. return -EINVAL;
  81. memcpy(extlist[i], extlist[i + 1],
  82. F2FS_EXTENSION_LEN * (total_count - i - 1));
  83. memset(extlist[total_count - 1], 0, F2FS_EXTENSION_LEN);
  84. if (hot)
  85. sbi->raw_super->hot_ext_count = hot_count - 1;
  86. else
  87. sbi->raw_super->extension_count =
  88. cpu_to_le32(cold_count - 1);
  89. return 0;
  90. }
  91. if (!set)
  92. return -EINVAL;
  93. if (hot) {
  94. memcpy(extlist[count], name, strlen(name));
  95. sbi->raw_super->hot_ext_count = hot_count + 1;
  96. } else {
  97. char buf[F2FS_MAX_EXTENSION][F2FS_EXTENSION_LEN];
  98. memcpy(buf, &extlist[cold_count],
  99. F2FS_EXTENSION_LEN * hot_count);
  100. memset(extlist[cold_count], 0, F2FS_EXTENSION_LEN);
  101. memcpy(extlist[cold_count], name, strlen(name));
  102. memcpy(&extlist[cold_count + 1], buf,
  103. F2FS_EXTENSION_LEN * hot_count);
  104. sbi->raw_super->extension_count = cpu_to_le32(cold_count + 1);
  105. }
  106. return 0;
  107. }
  108. static void set_compress_new_inode(struct f2fs_sb_info *sbi, struct inode *dir,
  109. struct inode *inode, const unsigned char *name)
  110. {
  111. __u8 (*extlist)[F2FS_EXTENSION_LEN] = sbi->raw_super->extension_list;
  112. unsigned char (*noext)[F2FS_EXTENSION_LEN] =
  113. F2FS_OPTION(sbi).noextensions;
  114. unsigned char (*ext)[F2FS_EXTENSION_LEN] = F2FS_OPTION(sbi).extensions;
  115. unsigned char ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
  116. unsigned char noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
  117. int i, cold_count, hot_count;
  118. if (!f2fs_sb_has_compression(sbi))
  119. return;
  120. if (S_ISDIR(inode->i_mode))
  121. goto inherit_comp;
  122. /* This name comes only from normal files. */
  123. if (!name)
  124. return;
  125. /* Don't compress hot files. */
  126. f2fs_down_read(&sbi->sb_lock);
  127. cold_count = le32_to_cpu(sbi->raw_super->extension_count);
  128. hot_count = sbi->raw_super->hot_ext_count;
  129. for (i = cold_count; i < cold_count + hot_count; i++)
  130. if (is_extension_exist(name, extlist[i], false))
  131. break;
  132. f2fs_up_read(&sbi->sb_lock);
  133. if (i < (cold_count + hot_count))
  134. return;
  135. /* Don't compress unallowed extension. */
  136. for (i = 0; i < noext_cnt; i++)
  137. if (is_extension_exist(name, noext[i], false))
  138. return;
  139. /* Compress wanting extension. */
  140. for (i = 0; i < ext_cnt; i++) {
  141. if (is_extension_exist(name, ext[i], false)) {
  142. set_compress_context(inode);
  143. return;
  144. }
  145. }
  146. inherit_comp:
  147. /* Inherit the {no-}compression flag in directory */
  148. if (F2FS_I(dir)->i_flags & F2FS_NOCOMP_FL) {
  149. F2FS_I(inode)->i_flags |= F2FS_NOCOMP_FL;
  150. f2fs_mark_inode_dirty_sync(inode, true);
  151. } else if (F2FS_I(dir)->i_flags & F2FS_COMPR_FL) {
  152. set_compress_context(inode);
  153. }
  154. }
  155. /*
  156. * Set file's temperature for hot/cold data separation
  157. */
  158. static void set_file_temperature(struct f2fs_sb_info *sbi, struct inode *inode,
  159. const unsigned char *name)
  160. {
  161. __u8 (*extlist)[F2FS_EXTENSION_LEN] = sbi->raw_super->extension_list;
  162. int i, cold_count, hot_count;
  163. f2fs_down_read(&sbi->sb_lock);
  164. cold_count = le32_to_cpu(sbi->raw_super->extension_count);
  165. hot_count = sbi->raw_super->hot_ext_count;
  166. for (i = 0; i < cold_count + hot_count; i++)
  167. if (is_extension_exist(name, extlist[i], true))
  168. break;
  169. f2fs_up_read(&sbi->sb_lock);
  170. if (i == cold_count + hot_count)
  171. return;
  172. if (i < cold_count)
  173. file_set_cold(inode);
  174. else
  175. file_set_hot(inode);
  176. }
  177. static struct inode *f2fs_new_inode(struct user_namespace *mnt_userns,
  178. struct inode *dir, umode_t mode,
  179. const char *name)
  180. {
  181. struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
  182. nid_t ino;
  183. struct inode *inode;
  184. bool nid_free = false;
  185. bool encrypt = false;
  186. int xattr_size = 0;
  187. int err;
  188. inode = new_inode(dir->i_sb);
  189. if (!inode)
  190. return ERR_PTR(-ENOMEM);
  191. if (!f2fs_alloc_nid(sbi, &ino)) {
  192. err = -ENOSPC;
  193. goto fail;
  194. }
  195. nid_free = true;
  196. inode_init_owner(mnt_userns, inode, dir, mode);
  197. inode->i_ino = ino;
  198. inode->i_blocks = 0;
  199. inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
  200. F2FS_I(inode)->i_crtime = inode->i_mtime;
  201. inode->i_generation = get_random_u32();
  202. if (S_ISDIR(inode->i_mode))
  203. F2FS_I(inode)->i_current_depth = 1;
  204. err = insert_inode_locked(inode);
  205. if (err) {
  206. err = -EINVAL;
  207. goto fail;
  208. }
  209. if (f2fs_sb_has_project_quota(sbi) &&
  210. (F2FS_I(dir)->i_flags & F2FS_PROJINHERIT_FL))
  211. F2FS_I(inode)->i_projid = F2FS_I(dir)->i_projid;
  212. else
  213. F2FS_I(inode)->i_projid = make_kprojid(mnt_userns,
  214. F2FS_DEF_PROJID);
  215. err = fscrypt_prepare_new_inode(dir, inode, &encrypt);
  216. if (err)
  217. goto fail_drop;
  218. err = f2fs_dquot_initialize(inode);
  219. if (err)
  220. goto fail_drop;
  221. set_inode_flag(inode, FI_NEW_INODE);
  222. if (encrypt)
  223. f2fs_set_encrypted_inode(inode);
  224. if (f2fs_sb_has_extra_attr(sbi)) {
  225. set_inode_flag(inode, FI_EXTRA_ATTR);
  226. F2FS_I(inode)->i_extra_isize = F2FS_TOTAL_EXTRA_ATTR_SIZE;
  227. }
  228. if (test_opt(sbi, INLINE_XATTR))
  229. set_inode_flag(inode, FI_INLINE_XATTR);
  230. if (f2fs_may_inline_dentry(inode))
  231. set_inode_flag(inode, FI_INLINE_DENTRY);
  232. if (f2fs_sb_has_flexible_inline_xattr(sbi)) {
  233. f2fs_bug_on(sbi, !f2fs_has_extra_attr(inode));
  234. if (f2fs_has_inline_xattr(inode))
  235. xattr_size = F2FS_OPTION(sbi).inline_xattr_size;
  236. /* Otherwise, will be 0 */
  237. } else if (f2fs_has_inline_xattr(inode) ||
  238. f2fs_has_inline_dentry(inode)) {
  239. xattr_size = DEFAULT_INLINE_XATTR_ADDRS;
  240. }
  241. F2FS_I(inode)->i_inline_xattr_size = xattr_size;
  242. F2FS_I(inode)->i_flags =
  243. f2fs_mask_flags(mode, F2FS_I(dir)->i_flags & F2FS_FL_INHERITED);
  244. if (S_ISDIR(inode->i_mode))
  245. F2FS_I(inode)->i_flags |= F2FS_INDEX_FL;
  246. if (F2FS_I(inode)->i_flags & F2FS_PROJINHERIT_FL)
  247. set_inode_flag(inode, FI_PROJ_INHERIT);
  248. /* Check compression first. */
  249. set_compress_new_inode(sbi, dir, inode, name);
  250. /* Should enable inline_data after compression set */
  251. if (test_opt(sbi, INLINE_DATA) && f2fs_may_inline_data(inode))
  252. set_inode_flag(inode, FI_INLINE_DATA);
  253. if (name && !test_opt(sbi, DISABLE_EXT_IDENTIFY))
  254. set_file_temperature(sbi, inode, name);
  255. stat_inc_inline_xattr(inode);
  256. stat_inc_inline_inode(inode);
  257. stat_inc_inline_dir(inode);
  258. f2fs_set_inode_flags(inode);
  259. f2fs_init_extent_tree(inode);
  260. trace_f2fs_new_inode(inode, 0);
  261. return inode;
  262. fail:
  263. trace_f2fs_new_inode(inode, err);
  264. make_bad_inode(inode);
  265. if (nid_free)
  266. set_inode_flag(inode, FI_FREE_NID);
  267. iput(inode);
  268. return ERR_PTR(err);
  269. fail_drop:
  270. trace_f2fs_new_inode(inode, err);
  271. dquot_drop(inode);
  272. inode->i_flags |= S_NOQUOTA;
  273. if (nid_free)
  274. set_inode_flag(inode, FI_FREE_NID);
  275. clear_nlink(inode);
  276. unlock_new_inode(inode);
  277. iput(inode);
  278. return ERR_PTR(err);
  279. }
  280. static int f2fs_create(struct user_namespace *mnt_userns, struct inode *dir,
  281. struct dentry *dentry, umode_t mode, bool excl)
  282. {
  283. struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
  284. struct inode *inode;
  285. nid_t ino = 0;
  286. int err;
  287. if (unlikely(f2fs_cp_error(sbi)))
  288. return -EIO;
  289. if (!f2fs_is_checkpoint_ready(sbi))
  290. return -ENOSPC;
  291. err = f2fs_dquot_initialize(dir);
  292. if (err)
  293. return err;
  294. inode = f2fs_new_inode(mnt_userns, dir, mode, dentry->d_name.name);
  295. if (IS_ERR(inode))
  296. return PTR_ERR(inode);
  297. inode->i_op = &f2fs_file_inode_operations;
  298. inode->i_fop = &f2fs_file_operations;
  299. inode->i_mapping->a_ops = &f2fs_dblock_aops;
  300. ino = inode->i_ino;
  301. f2fs_lock_op(sbi);
  302. err = f2fs_add_link(dentry, inode);
  303. if (err)
  304. goto out;
  305. f2fs_unlock_op(sbi);
  306. f2fs_alloc_nid_done(sbi, ino);
  307. d_instantiate_new(dentry, inode);
  308. if (IS_DIRSYNC(dir))
  309. f2fs_sync_fs(sbi->sb, 1);
  310. f2fs_balance_fs(sbi, true);
  311. return 0;
  312. out:
  313. f2fs_handle_failed_inode(inode);
  314. return err;
  315. }
  316. static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
  317. struct dentry *dentry)
  318. {
  319. struct inode *inode = d_inode(old_dentry);
  320. struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
  321. int err;
  322. if (unlikely(f2fs_cp_error(sbi)))
  323. return -EIO;
  324. if (!f2fs_is_checkpoint_ready(sbi))
  325. return -ENOSPC;
  326. err = fscrypt_prepare_link(old_dentry, dir, dentry);
  327. if (err)
  328. return err;
  329. if (is_inode_flag_set(dir, FI_PROJ_INHERIT) &&
  330. (!projid_eq(F2FS_I(dir)->i_projid,
  331. F2FS_I(old_dentry->d_inode)->i_projid)))
  332. return -EXDEV;
  333. err = f2fs_dquot_initialize(dir);
  334. if (err)
  335. return err;
  336. f2fs_balance_fs(sbi, true);
  337. inode->i_ctime = current_time(inode);
  338. ihold(inode);
  339. set_inode_flag(inode, FI_INC_LINK);
  340. f2fs_lock_op(sbi);
  341. err = f2fs_add_link(dentry, inode);
  342. if (err)
  343. goto out;
  344. f2fs_unlock_op(sbi);
  345. d_instantiate(dentry, inode);
  346. if (IS_DIRSYNC(dir))
  347. f2fs_sync_fs(sbi->sb, 1);
  348. return 0;
  349. out:
  350. clear_inode_flag(inode, FI_INC_LINK);
  351. iput(inode);
  352. f2fs_unlock_op(sbi);
  353. return err;
  354. }
  355. struct dentry *f2fs_get_parent(struct dentry *child)
  356. {
  357. struct page *page;
  358. unsigned long ino = f2fs_inode_by_name(d_inode(child), &dotdot_name, &page);
  359. if (!ino) {
  360. if (IS_ERR(page))
  361. return ERR_CAST(page);
  362. return ERR_PTR(-ENOENT);
  363. }
  364. return d_obtain_alias(f2fs_iget(child->d_sb, ino));
  365. }
  366. static int __recover_dot_dentries(struct inode *dir, nid_t pino)
  367. {
  368. struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
  369. struct qstr dot = QSTR_INIT(".", 1);
  370. struct qstr dotdot = QSTR_INIT("..", 2);
  371. struct f2fs_dir_entry *de;
  372. struct page *page;
  373. int err = 0;
  374. if (f2fs_readonly(sbi->sb)) {
  375. f2fs_info(sbi, "skip recovering inline_dots inode (ino:%lu, pino:%u) in readonly mountpoint",
  376. dir->i_ino, pino);
  377. return 0;
  378. }
  379. if (!S_ISDIR(dir->i_mode)) {
  380. f2fs_err(sbi, "inconsistent inode status, skip recovering inline_dots inode (ino:%lu, i_mode:%u, pino:%u)",
  381. dir->i_ino, dir->i_mode, pino);
  382. set_sbi_flag(sbi, SBI_NEED_FSCK);
  383. return -ENOTDIR;
  384. }
  385. err = f2fs_dquot_initialize(dir);
  386. if (err)
  387. return err;
  388. f2fs_balance_fs(sbi, true);
  389. f2fs_lock_op(sbi);
  390. de = f2fs_find_entry(dir, &dot, &page);
  391. if (de) {
  392. f2fs_put_page(page, 0);
  393. } else if (IS_ERR(page)) {
  394. err = PTR_ERR(page);
  395. goto out;
  396. } else {
  397. err = f2fs_do_add_link(dir, &dot, NULL, dir->i_ino, S_IFDIR);
  398. if (err)
  399. goto out;
  400. }
  401. de = f2fs_find_entry(dir, &dotdot, &page);
  402. if (de)
  403. f2fs_put_page(page, 0);
  404. else if (IS_ERR(page))
  405. err = PTR_ERR(page);
  406. else
  407. err = f2fs_do_add_link(dir, &dotdot, NULL, pino, S_IFDIR);
  408. out:
  409. if (!err)
  410. clear_inode_flag(dir, FI_INLINE_DOTS);
  411. f2fs_unlock_op(sbi);
  412. return err;
  413. }
  414. static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry,
  415. unsigned int flags)
  416. {
  417. struct inode *inode = NULL;
  418. struct f2fs_dir_entry *de;
  419. struct page *page;
  420. struct dentry *new;
  421. nid_t ino = -1;
  422. int err = 0;
  423. unsigned int root_ino = F2FS_ROOT_INO(F2FS_I_SB(dir));
  424. struct f2fs_filename fname;
  425. trace_f2fs_lookup_start(dir, dentry, flags);
  426. if (dentry->d_name.len > F2FS_NAME_LEN) {
  427. err = -ENAMETOOLONG;
  428. goto out;
  429. }
  430. err = f2fs_prepare_lookup(dir, dentry, &fname);
  431. generic_set_encrypted_ci_d_ops(dentry);
  432. if (err == -ENOENT)
  433. goto out_splice;
  434. if (err)
  435. goto out;
  436. de = __f2fs_find_entry(dir, &fname, &page);
  437. f2fs_free_filename(&fname);
  438. if (!de) {
  439. if (IS_ERR(page)) {
  440. err = PTR_ERR(page);
  441. goto out;
  442. }
  443. err = -ENOENT;
  444. goto out_splice;
  445. }
  446. ino = le32_to_cpu(de->ino);
  447. f2fs_put_page(page, 0);
  448. inode = f2fs_iget(dir->i_sb, ino);
  449. if (IS_ERR(inode)) {
  450. err = PTR_ERR(inode);
  451. goto out;
  452. }
  453. if ((dir->i_ino == root_ino) && f2fs_has_inline_dots(dir)) {
  454. err = __recover_dot_dentries(dir, root_ino);
  455. if (err)
  456. goto out_iput;
  457. }
  458. if (f2fs_has_inline_dots(inode)) {
  459. err = __recover_dot_dentries(inode, dir->i_ino);
  460. if (err)
  461. goto out_iput;
  462. }
  463. if (IS_ENCRYPTED(dir) &&
  464. (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
  465. !fscrypt_has_permitted_context(dir, inode)) {
  466. f2fs_warn(F2FS_I_SB(inode), "Inconsistent encryption contexts: %lu/%lu",
  467. dir->i_ino, inode->i_ino);
  468. err = -EPERM;
  469. goto out_iput;
  470. }
  471. out_splice:
  472. #if IS_ENABLED(CONFIG_UNICODE)
  473. if (!inode && IS_CASEFOLDED(dir)) {
  474. /* Eventually we want to call d_add_ci(dentry, NULL)
  475. * for negative dentries in the encoding case as
  476. * well. For now, prevent the negative dentry
  477. * from being cached.
  478. */
  479. trace_f2fs_lookup_end(dir, dentry, ino, err);
  480. return NULL;
  481. }
  482. #endif
  483. new = d_splice_alias(inode, dentry);
  484. err = PTR_ERR_OR_ZERO(new);
  485. trace_f2fs_lookup_end(dir, dentry, ino, !new ? -ENOENT : err);
  486. return new;
  487. out_iput:
  488. iput(inode);
  489. out:
  490. trace_f2fs_lookup_end(dir, dentry, ino, err);
  491. return ERR_PTR(err);
  492. }
  493. static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
  494. {
  495. struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
  496. struct inode *inode = d_inode(dentry);
  497. struct f2fs_dir_entry *de;
  498. struct page *page;
  499. int err;
  500. trace_f2fs_unlink_enter(dir, dentry);
  501. if (unlikely(f2fs_cp_error(sbi))) {
  502. err = -EIO;
  503. goto fail;
  504. }
  505. err = f2fs_dquot_initialize(dir);
  506. if (err)
  507. goto fail;
  508. err = f2fs_dquot_initialize(inode);
  509. if (err)
  510. goto fail;
  511. de = f2fs_find_entry(dir, &dentry->d_name, &page);
  512. if (!de) {
  513. if (IS_ERR(page))
  514. err = PTR_ERR(page);
  515. goto fail;
  516. }
  517. f2fs_balance_fs(sbi, true);
  518. f2fs_lock_op(sbi);
  519. err = f2fs_acquire_orphan_inode(sbi);
  520. if (err) {
  521. f2fs_unlock_op(sbi);
  522. f2fs_put_page(page, 0);
  523. goto fail;
  524. }
  525. f2fs_delete_entry(de, page, dir, inode);
  526. f2fs_unlock_op(sbi);
  527. #if IS_ENABLED(CONFIG_UNICODE)
  528. /* VFS negative dentries are incompatible with Encoding and
  529. * Case-insensitiveness. Eventually we'll want avoid
  530. * invalidating the dentries here, alongside with returning the
  531. * negative dentries at f2fs_lookup(), when it is better
  532. * supported by the VFS for the CI case.
  533. */
  534. if (IS_CASEFOLDED(dir))
  535. d_invalidate(dentry);
  536. #endif
  537. if (IS_DIRSYNC(dir))
  538. f2fs_sync_fs(sbi->sb, 1);
  539. fail:
  540. trace_f2fs_unlink_exit(inode, err);
  541. return err;
  542. }
  543. static const char *f2fs_get_link(struct dentry *dentry,
  544. struct inode *inode,
  545. struct delayed_call *done)
  546. {
  547. const char *link = page_get_link(dentry, inode, done);
  548. if (!IS_ERR(link) && !*link) {
  549. /* this is broken symlink case */
  550. do_delayed_call(done);
  551. clear_delayed_call(done);
  552. link = ERR_PTR(-ENOENT);
  553. }
  554. return link;
  555. }
  556. static int f2fs_symlink(struct user_namespace *mnt_userns, struct inode *dir,
  557. struct dentry *dentry, const char *symname)
  558. {
  559. struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
  560. struct inode *inode;
  561. size_t len = strlen(symname);
  562. struct fscrypt_str disk_link;
  563. int err;
  564. if (unlikely(f2fs_cp_error(sbi)))
  565. return -EIO;
  566. if (!f2fs_is_checkpoint_ready(sbi))
  567. return -ENOSPC;
  568. err = fscrypt_prepare_symlink(dir, symname, len, dir->i_sb->s_blocksize,
  569. &disk_link);
  570. if (err)
  571. return err;
  572. err = f2fs_dquot_initialize(dir);
  573. if (err)
  574. return err;
  575. inode = f2fs_new_inode(mnt_userns, dir, S_IFLNK | S_IRWXUGO, NULL);
  576. if (IS_ERR(inode))
  577. return PTR_ERR(inode);
  578. if (IS_ENCRYPTED(inode))
  579. inode->i_op = &f2fs_encrypted_symlink_inode_operations;
  580. else
  581. inode->i_op = &f2fs_symlink_inode_operations;
  582. inode_nohighmem(inode);
  583. inode->i_mapping->a_ops = &f2fs_dblock_aops;
  584. f2fs_lock_op(sbi);
  585. err = f2fs_add_link(dentry, inode);
  586. if (err)
  587. goto out_f2fs_handle_failed_inode;
  588. f2fs_unlock_op(sbi);
  589. f2fs_alloc_nid_done(sbi, inode->i_ino);
  590. err = fscrypt_encrypt_symlink(inode, symname, len, &disk_link);
  591. if (err)
  592. goto err_out;
  593. err = page_symlink(inode, disk_link.name, disk_link.len);
  594. err_out:
  595. d_instantiate_new(dentry, inode);
  596. /*
  597. * Let's flush symlink data in order to avoid broken symlink as much as
  598. * possible. Nevertheless, fsyncing is the best way, but there is no
  599. * way to get a file descriptor in order to flush that.
  600. *
  601. * Note that, it needs to do dir->fsync to make this recoverable.
  602. * If the symlink path is stored into inline_data, there is no
  603. * performance regression.
  604. */
  605. if (!err) {
  606. filemap_write_and_wait_range(inode->i_mapping, 0,
  607. disk_link.len - 1);
  608. if (IS_DIRSYNC(dir))
  609. f2fs_sync_fs(sbi->sb, 1);
  610. } else {
  611. f2fs_unlink(dir, dentry);
  612. }
  613. f2fs_balance_fs(sbi, true);
  614. goto out_free_encrypted_link;
  615. out_f2fs_handle_failed_inode:
  616. f2fs_handle_failed_inode(inode);
  617. out_free_encrypted_link:
  618. if (disk_link.name != (unsigned char *)symname)
  619. kfree(disk_link.name);
  620. return err;
  621. }
  622. static int f2fs_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
  623. struct dentry *dentry, umode_t mode)
  624. {
  625. struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
  626. struct inode *inode;
  627. int err;
  628. if (unlikely(f2fs_cp_error(sbi)))
  629. return -EIO;
  630. err = f2fs_dquot_initialize(dir);
  631. if (err)
  632. return err;
  633. inode = f2fs_new_inode(mnt_userns, dir, S_IFDIR | mode, NULL);
  634. if (IS_ERR(inode))
  635. return PTR_ERR(inode);
  636. inode->i_op = &f2fs_dir_inode_operations;
  637. inode->i_fop = &f2fs_dir_operations;
  638. inode->i_mapping->a_ops = &f2fs_dblock_aops;
  639. mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
  640. set_inode_flag(inode, FI_INC_LINK);
  641. f2fs_lock_op(sbi);
  642. err = f2fs_add_link(dentry, inode);
  643. if (err)
  644. goto out_fail;
  645. f2fs_unlock_op(sbi);
  646. f2fs_alloc_nid_done(sbi, inode->i_ino);
  647. d_instantiate_new(dentry, inode);
  648. if (IS_DIRSYNC(dir))
  649. f2fs_sync_fs(sbi->sb, 1);
  650. f2fs_balance_fs(sbi, true);
  651. return 0;
  652. out_fail:
  653. clear_inode_flag(inode, FI_INC_LINK);
  654. f2fs_handle_failed_inode(inode);
  655. return err;
  656. }
  657. static int f2fs_rmdir(struct inode *dir, struct dentry *dentry)
  658. {
  659. struct inode *inode = d_inode(dentry);
  660. if (f2fs_empty_dir(inode))
  661. return f2fs_unlink(dir, dentry);
  662. return -ENOTEMPTY;
  663. }
  664. static int f2fs_mknod(struct user_namespace *mnt_userns, struct inode *dir,
  665. struct dentry *dentry, umode_t mode, dev_t rdev)
  666. {
  667. struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
  668. struct inode *inode;
  669. int err = 0;
  670. if (unlikely(f2fs_cp_error(sbi)))
  671. return -EIO;
  672. if (!f2fs_is_checkpoint_ready(sbi))
  673. return -ENOSPC;
  674. err = f2fs_dquot_initialize(dir);
  675. if (err)
  676. return err;
  677. inode = f2fs_new_inode(mnt_userns, dir, mode, NULL);
  678. if (IS_ERR(inode))
  679. return PTR_ERR(inode);
  680. init_special_inode(inode, inode->i_mode, rdev);
  681. inode->i_op = &f2fs_special_inode_operations;
  682. f2fs_lock_op(sbi);
  683. err = f2fs_add_link(dentry, inode);
  684. if (err)
  685. goto out;
  686. f2fs_unlock_op(sbi);
  687. f2fs_alloc_nid_done(sbi, inode->i_ino);
  688. d_instantiate_new(dentry, inode);
  689. if (IS_DIRSYNC(dir))
  690. f2fs_sync_fs(sbi->sb, 1);
  691. f2fs_balance_fs(sbi, true);
  692. return 0;
  693. out:
  694. f2fs_handle_failed_inode(inode);
  695. return err;
  696. }
  697. static int __f2fs_tmpfile(struct user_namespace *mnt_userns, struct inode *dir,
  698. struct file *file, umode_t mode, bool is_whiteout,
  699. struct inode **new_inode)
  700. {
  701. struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
  702. struct inode *inode;
  703. int err;
  704. err = f2fs_dquot_initialize(dir);
  705. if (err)
  706. return err;
  707. inode = f2fs_new_inode(mnt_userns, dir, mode, NULL);
  708. if (IS_ERR(inode))
  709. return PTR_ERR(inode);
  710. if (is_whiteout) {
  711. init_special_inode(inode, inode->i_mode, WHITEOUT_DEV);
  712. inode->i_op = &f2fs_special_inode_operations;
  713. } else {
  714. inode->i_op = &f2fs_file_inode_operations;
  715. inode->i_fop = &f2fs_file_operations;
  716. inode->i_mapping->a_ops = &f2fs_dblock_aops;
  717. }
  718. f2fs_lock_op(sbi);
  719. err = f2fs_acquire_orphan_inode(sbi);
  720. if (err)
  721. goto out;
  722. err = f2fs_do_tmpfile(inode, dir);
  723. if (err)
  724. goto release_out;
  725. /*
  726. * add this non-linked tmpfile to orphan list, in this way we could
  727. * remove all unused data of tmpfile after abnormal power-off.
  728. */
  729. f2fs_add_orphan_inode(inode);
  730. f2fs_alloc_nid_done(sbi, inode->i_ino);
  731. if (is_whiteout) {
  732. f2fs_i_links_write(inode, false);
  733. spin_lock(&inode->i_lock);
  734. inode->i_state |= I_LINKABLE;
  735. spin_unlock(&inode->i_lock);
  736. } else {
  737. if (file)
  738. d_tmpfile(file, inode);
  739. else
  740. f2fs_i_links_write(inode, false);
  741. }
  742. /* link_count was changed by d_tmpfile as well. */
  743. f2fs_unlock_op(sbi);
  744. unlock_new_inode(inode);
  745. if (new_inode)
  746. *new_inode = inode;
  747. f2fs_balance_fs(sbi, true);
  748. return 0;
  749. release_out:
  750. f2fs_release_orphan_inode(sbi);
  751. out:
  752. f2fs_handle_failed_inode(inode);
  753. return err;
  754. }
  755. static int f2fs_tmpfile(struct user_namespace *mnt_userns, struct inode *dir,
  756. struct file *file, umode_t mode)
  757. {
  758. struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
  759. int err;
  760. if (unlikely(f2fs_cp_error(sbi)))
  761. return -EIO;
  762. if (!f2fs_is_checkpoint_ready(sbi))
  763. return -ENOSPC;
  764. err = __f2fs_tmpfile(mnt_userns, dir, file, mode, false, NULL);
  765. return finish_open_simple(file, err);
  766. }
  767. static int f2fs_create_whiteout(struct user_namespace *mnt_userns,
  768. struct inode *dir, struct inode **whiteout)
  769. {
  770. return __f2fs_tmpfile(mnt_userns, dir, NULL,
  771. S_IFCHR | WHITEOUT_MODE, true, whiteout);
  772. }
  773. int f2fs_get_tmpfile(struct user_namespace *mnt_userns, struct inode *dir,
  774. struct inode **new_inode)
  775. {
  776. return __f2fs_tmpfile(mnt_userns, dir, NULL, S_IFREG, false, new_inode);
  777. }
  778. static int f2fs_rename(struct user_namespace *mnt_userns, struct inode *old_dir,
  779. struct dentry *old_dentry, struct inode *new_dir,
  780. struct dentry *new_dentry, unsigned int flags)
  781. {
  782. struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir);
  783. struct inode *old_inode = d_inode(old_dentry);
  784. struct inode *new_inode = d_inode(new_dentry);
  785. struct inode *whiteout = NULL;
  786. struct page *old_dir_page = NULL;
  787. struct page *old_page, *new_page = NULL;
  788. struct f2fs_dir_entry *old_dir_entry = NULL;
  789. struct f2fs_dir_entry *old_entry;
  790. struct f2fs_dir_entry *new_entry;
  791. int err;
  792. if (unlikely(f2fs_cp_error(sbi)))
  793. return -EIO;
  794. if (!f2fs_is_checkpoint_ready(sbi))
  795. return -ENOSPC;
  796. if (is_inode_flag_set(new_dir, FI_PROJ_INHERIT) &&
  797. (!projid_eq(F2FS_I(new_dir)->i_projid,
  798. F2FS_I(old_dentry->d_inode)->i_projid)))
  799. return -EXDEV;
  800. /*
  801. * If new_inode is null, the below renaming flow will
  802. * add a link in old_dir which can convert inline_dir.
  803. * After then, if we failed to get the entry due to other
  804. * reasons like ENOMEM, we had to remove the new entry.
  805. * Instead of adding such the error handling routine, let's
  806. * simply convert first here.
  807. */
  808. if (old_dir == new_dir && !new_inode) {
  809. err = f2fs_try_convert_inline_dir(old_dir, new_dentry);
  810. if (err)
  811. return err;
  812. }
  813. if (flags & RENAME_WHITEOUT) {
  814. err = f2fs_create_whiteout(mnt_userns, old_dir, &whiteout);
  815. if (err)
  816. return err;
  817. }
  818. err = f2fs_dquot_initialize(old_dir);
  819. if (err)
  820. goto out;
  821. err = f2fs_dquot_initialize(new_dir);
  822. if (err)
  823. goto out;
  824. if (new_inode) {
  825. err = f2fs_dquot_initialize(new_inode);
  826. if (err)
  827. goto out;
  828. }
  829. err = -ENOENT;
  830. old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page);
  831. if (!old_entry) {
  832. if (IS_ERR(old_page))
  833. err = PTR_ERR(old_page);
  834. goto out;
  835. }
  836. if (S_ISDIR(old_inode->i_mode)) {
  837. old_dir_entry = f2fs_parent_dir(old_inode, &old_dir_page);
  838. if (!old_dir_entry) {
  839. if (IS_ERR(old_dir_page))
  840. err = PTR_ERR(old_dir_page);
  841. goto out_old;
  842. }
  843. }
  844. if (new_inode) {
  845. err = -ENOTEMPTY;
  846. if (old_dir_entry && !f2fs_empty_dir(new_inode))
  847. goto out_dir;
  848. err = -ENOENT;
  849. new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name,
  850. &new_page);
  851. if (!new_entry) {
  852. if (IS_ERR(new_page))
  853. err = PTR_ERR(new_page);
  854. goto out_dir;
  855. }
  856. f2fs_balance_fs(sbi, true);
  857. f2fs_lock_op(sbi);
  858. err = f2fs_acquire_orphan_inode(sbi);
  859. if (err)
  860. goto put_out_dir;
  861. f2fs_set_link(new_dir, new_entry, new_page, old_inode);
  862. new_page = NULL;
  863. new_inode->i_ctime = current_time(new_inode);
  864. f2fs_down_write(&F2FS_I(new_inode)->i_sem);
  865. if (old_dir_entry)
  866. f2fs_i_links_write(new_inode, false);
  867. f2fs_i_links_write(new_inode, false);
  868. f2fs_up_write(&F2FS_I(new_inode)->i_sem);
  869. if (!new_inode->i_nlink)
  870. f2fs_add_orphan_inode(new_inode);
  871. else
  872. f2fs_release_orphan_inode(sbi);
  873. } else {
  874. f2fs_balance_fs(sbi, true);
  875. f2fs_lock_op(sbi);
  876. err = f2fs_add_link(new_dentry, old_inode);
  877. if (err) {
  878. f2fs_unlock_op(sbi);
  879. goto out_dir;
  880. }
  881. if (old_dir_entry)
  882. f2fs_i_links_write(new_dir, true);
  883. }
  884. f2fs_down_write(&F2FS_I(old_inode)->i_sem);
  885. if (!old_dir_entry || whiteout)
  886. file_lost_pino(old_inode);
  887. else
  888. /* adjust dir's i_pino to pass fsck check */
  889. f2fs_i_pino_write(old_inode, new_dir->i_ino);
  890. f2fs_up_write(&F2FS_I(old_inode)->i_sem);
  891. old_inode->i_ctime = current_time(old_inode);
  892. f2fs_mark_inode_dirty_sync(old_inode, false);
  893. f2fs_delete_entry(old_entry, old_page, old_dir, NULL);
  894. old_page = NULL;
  895. if (whiteout) {
  896. set_inode_flag(whiteout, FI_INC_LINK);
  897. err = f2fs_add_link(old_dentry, whiteout);
  898. if (err)
  899. goto put_out_dir;
  900. spin_lock(&whiteout->i_lock);
  901. whiteout->i_state &= ~I_LINKABLE;
  902. spin_unlock(&whiteout->i_lock);
  903. iput(whiteout);
  904. }
  905. if (old_dir_entry) {
  906. if (old_dir != new_dir && !whiteout)
  907. f2fs_set_link(old_inode, old_dir_entry,
  908. old_dir_page, new_dir);
  909. else
  910. f2fs_put_page(old_dir_page, 0);
  911. f2fs_i_links_write(old_dir, false);
  912. }
  913. if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT) {
  914. f2fs_add_ino_entry(sbi, new_dir->i_ino, TRANS_DIR_INO);
  915. if (S_ISDIR(old_inode->i_mode))
  916. f2fs_add_ino_entry(sbi, old_inode->i_ino,
  917. TRANS_DIR_INO);
  918. }
  919. f2fs_unlock_op(sbi);
  920. if (IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir))
  921. f2fs_sync_fs(sbi->sb, 1);
  922. f2fs_update_time(sbi, REQ_TIME);
  923. return 0;
  924. put_out_dir:
  925. f2fs_unlock_op(sbi);
  926. f2fs_put_page(new_page, 0);
  927. out_dir:
  928. if (old_dir_entry)
  929. f2fs_put_page(old_dir_page, 0);
  930. out_old:
  931. f2fs_put_page(old_page, 0);
  932. out:
  933. iput(whiteout);
  934. return err;
  935. }
  936. static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
  937. struct inode *new_dir, struct dentry *new_dentry)
  938. {
  939. struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir);
  940. struct inode *old_inode = d_inode(old_dentry);
  941. struct inode *new_inode = d_inode(new_dentry);
  942. struct page *old_dir_page, *new_dir_page;
  943. struct page *old_page, *new_page;
  944. struct f2fs_dir_entry *old_dir_entry = NULL, *new_dir_entry = NULL;
  945. struct f2fs_dir_entry *old_entry, *new_entry;
  946. int old_nlink = 0, new_nlink = 0;
  947. int err;
  948. if (unlikely(f2fs_cp_error(sbi)))
  949. return -EIO;
  950. if (!f2fs_is_checkpoint_ready(sbi))
  951. return -ENOSPC;
  952. if ((is_inode_flag_set(new_dir, FI_PROJ_INHERIT) &&
  953. !projid_eq(F2FS_I(new_dir)->i_projid,
  954. F2FS_I(old_dentry->d_inode)->i_projid)) ||
  955. (is_inode_flag_set(new_dir, FI_PROJ_INHERIT) &&
  956. !projid_eq(F2FS_I(old_dir)->i_projid,
  957. F2FS_I(new_dentry->d_inode)->i_projid)))
  958. return -EXDEV;
  959. err = f2fs_dquot_initialize(old_dir);
  960. if (err)
  961. goto out;
  962. err = f2fs_dquot_initialize(new_dir);
  963. if (err)
  964. goto out;
  965. err = -ENOENT;
  966. old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page);
  967. if (!old_entry) {
  968. if (IS_ERR(old_page))
  969. err = PTR_ERR(old_page);
  970. goto out;
  971. }
  972. new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name, &new_page);
  973. if (!new_entry) {
  974. if (IS_ERR(new_page))
  975. err = PTR_ERR(new_page);
  976. goto out_old;
  977. }
  978. /* prepare for updating ".." directory entry info later */
  979. if (old_dir != new_dir) {
  980. if (S_ISDIR(old_inode->i_mode)) {
  981. old_dir_entry = f2fs_parent_dir(old_inode,
  982. &old_dir_page);
  983. if (!old_dir_entry) {
  984. if (IS_ERR(old_dir_page))
  985. err = PTR_ERR(old_dir_page);
  986. goto out_new;
  987. }
  988. }
  989. if (S_ISDIR(new_inode->i_mode)) {
  990. new_dir_entry = f2fs_parent_dir(new_inode,
  991. &new_dir_page);
  992. if (!new_dir_entry) {
  993. if (IS_ERR(new_dir_page))
  994. err = PTR_ERR(new_dir_page);
  995. goto out_old_dir;
  996. }
  997. }
  998. }
  999. /*
  1000. * If cross rename between file and directory those are not
  1001. * in the same directory, we will inc nlink of file's parent
  1002. * later, so we should check upper boundary of its nlink.
  1003. */
  1004. if ((!old_dir_entry || !new_dir_entry) &&
  1005. old_dir_entry != new_dir_entry) {
  1006. old_nlink = old_dir_entry ? -1 : 1;
  1007. new_nlink = -old_nlink;
  1008. err = -EMLINK;
  1009. if ((old_nlink > 0 && old_dir->i_nlink >= F2FS_LINK_MAX) ||
  1010. (new_nlink > 0 && new_dir->i_nlink >= F2FS_LINK_MAX))
  1011. goto out_new_dir;
  1012. }
  1013. f2fs_balance_fs(sbi, true);
  1014. f2fs_lock_op(sbi);
  1015. /* update ".." directory entry info of old dentry */
  1016. if (old_dir_entry)
  1017. f2fs_set_link(old_inode, old_dir_entry, old_dir_page, new_dir);
  1018. /* update ".." directory entry info of new dentry */
  1019. if (new_dir_entry)
  1020. f2fs_set_link(new_inode, new_dir_entry, new_dir_page, old_dir);
  1021. /* update directory entry info of old dir inode */
  1022. f2fs_set_link(old_dir, old_entry, old_page, new_inode);
  1023. f2fs_down_write(&F2FS_I(old_inode)->i_sem);
  1024. if (!old_dir_entry)
  1025. file_lost_pino(old_inode);
  1026. else
  1027. /* adjust dir's i_pino to pass fsck check */
  1028. f2fs_i_pino_write(old_inode, new_dir->i_ino);
  1029. f2fs_up_write(&F2FS_I(old_inode)->i_sem);
  1030. old_dir->i_ctime = current_time(old_dir);
  1031. if (old_nlink) {
  1032. f2fs_down_write(&F2FS_I(old_dir)->i_sem);
  1033. f2fs_i_links_write(old_dir, old_nlink > 0);
  1034. f2fs_up_write(&F2FS_I(old_dir)->i_sem);
  1035. }
  1036. f2fs_mark_inode_dirty_sync(old_dir, false);
  1037. /* update directory entry info of new dir inode */
  1038. f2fs_set_link(new_dir, new_entry, new_page, old_inode);
  1039. f2fs_down_write(&F2FS_I(new_inode)->i_sem);
  1040. if (!new_dir_entry)
  1041. file_lost_pino(new_inode);
  1042. else
  1043. /* adjust dir's i_pino to pass fsck check */
  1044. f2fs_i_pino_write(new_inode, old_dir->i_ino);
  1045. f2fs_up_write(&F2FS_I(new_inode)->i_sem);
  1046. new_dir->i_ctime = current_time(new_dir);
  1047. if (new_nlink) {
  1048. f2fs_down_write(&F2FS_I(new_dir)->i_sem);
  1049. f2fs_i_links_write(new_dir, new_nlink > 0);
  1050. f2fs_up_write(&F2FS_I(new_dir)->i_sem);
  1051. }
  1052. f2fs_mark_inode_dirty_sync(new_dir, false);
  1053. if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT) {
  1054. f2fs_add_ino_entry(sbi, old_dir->i_ino, TRANS_DIR_INO);
  1055. f2fs_add_ino_entry(sbi, new_dir->i_ino, TRANS_DIR_INO);
  1056. }
  1057. f2fs_unlock_op(sbi);
  1058. if (IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir))
  1059. f2fs_sync_fs(sbi->sb, 1);
  1060. f2fs_update_time(sbi, REQ_TIME);
  1061. return 0;
  1062. out_new_dir:
  1063. if (new_dir_entry) {
  1064. f2fs_put_page(new_dir_page, 0);
  1065. }
  1066. out_old_dir:
  1067. if (old_dir_entry) {
  1068. f2fs_put_page(old_dir_page, 0);
  1069. }
  1070. out_new:
  1071. f2fs_put_page(new_page, 0);
  1072. out_old:
  1073. f2fs_put_page(old_page, 0);
  1074. out:
  1075. return err;
  1076. }
  1077. static int f2fs_rename2(struct user_namespace *mnt_userns,
  1078. struct inode *old_dir, struct dentry *old_dentry,
  1079. struct inode *new_dir, struct dentry *new_dentry,
  1080. unsigned int flags)
  1081. {
  1082. int err;
  1083. if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
  1084. return -EINVAL;
  1085. err = fscrypt_prepare_rename(old_dir, old_dentry, new_dir, new_dentry,
  1086. flags);
  1087. if (err)
  1088. return err;
  1089. if (flags & RENAME_EXCHANGE) {
  1090. return f2fs_cross_rename(old_dir, old_dentry,
  1091. new_dir, new_dentry);
  1092. }
  1093. /*
  1094. * VFS has already handled the new dentry existence case,
  1095. * here, we just deal with "RENAME_NOREPLACE" as regular rename.
  1096. */
  1097. return f2fs_rename(mnt_userns, old_dir, old_dentry,
  1098. new_dir, new_dentry, flags);
  1099. }
  1100. static const char *f2fs_encrypted_get_link(struct dentry *dentry,
  1101. struct inode *inode,
  1102. struct delayed_call *done)
  1103. {
  1104. struct page *page;
  1105. const char *target;
  1106. if (!dentry)
  1107. return ERR_PTR(-ECHILD);
  1108. page = read_mapping_page(inode->i_mapping, 0, NULL);
  1109. if (IS_ERR(page))
  1110. return ERR_CAST(page);
  1111. target = fscrypt_get_symlink(inode, page_address(page),
  1112. inode->i_sb->s_blocksize, done);
  1113. put_page(page);
  1114. return target;
  1115. }
  1116. static int f2fs_encrypted_symlink_getattr(struct user_namespace *mnt_userns,
  1117. const struct path *path,
  1118. struct kstat *stat, u32 request_mask,
  1119. unsigned int query_flags)
  1120. {
  1121. f2fs_getattr(mnt_userns, path, stat, request_mask, query_flags);
  1122. return fscrypt_symlink_getattr(path, stat);
  1123. }
  1124. const struct inode_operations f2fs_encrypted_symlink_inode_operations = {
  1125. .get_link = f2fs_encrypted_get_link,
  1126. .getattr = f2fs_encrypted_symlink_getattr,
  1127. .setattr = f2fs_setattr,
  1128. .listxattr = f2fs_listxattr,
  1129. };
  1130. const struct inode_operations f2fs_dir_inode_operations = {
  1131. .create = f2fs_create,
  1132. .lookup = f2fs_lookup,
  1133. .link = f2fs_link,
  1134. .unlink = f2fs_unlink,
  1135. .symlink = f2fs_symlink,
  1136. .mkdir = f2fs_mkdir,
  1137. .rmdir = f2fs_rmdir,
  1138. .mknod = f2fs_mknod,
  1139. .rename = f2fs_rename2,
  1140. .tmpfile = f2fs_tmpfile,
  1141. .getattr = f2fs_getattr,
  1142. .setattr = f2fs_setattr,
  1143. .get_acl = f2fs_get_acl,
  1144. .set_acl = f2fs_set_acl,
  1145. .listxattr = f2fs_listxattr,
  1146. .fiemap = f2fs_fiemap,
  1147. .fileattr_get = f2fs_fileattr_get,
  1148. .fileattr_set = f2fs_fileattr_set,
  1149. };
  1150. const struct inode_operations f2fs_symlink_inode_operations = {
  1151. .get_link = f2fs_get_link,
  1152. .getattr = f2fs_getattr,
  1153. .setattr = f2fs_setattr,
  1154. .listxattr = f2fs_listxattr,
  1155. };
  1156. const struct inode_operations f2fs_special_inode_operations = {
  1157. .getattr = f2fs_getattr,
  1158. .setattr = f2fs_setattr,
  1159. .get_acl = f2fs_get_acl,
  1160. .set_acl = f2fs_set_acl,
  1161. .listxattr = f2fs_listxattr,
  1162. };