inline.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * fs/f2fs/inline.c
  4. * Copyright (c) 2013, Intel Corporation
  5. * Authors: Huajun Li <huajun.li@intel.com>
  6. * Haicheng Li <haicheng.li@intel.com>
  7. */
  8. #include <linux/fs.h>
  9. #include <linux/f2fs_fs.h>
  10. #include <linux/fiemap.h>
  11. #include "f2fs.h"
  12. #include "node.h"
  13. #include <trace/events/f2fs.h>
  14. #include <trace/events/android_fs.h>
  15. bool f2fs_may_inline_data(struct inode *inode)
  16. {
  17. if (f2fs_is_atomic_file(inode))
  18. return false;
  19. if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode))
  20. return false;
  21. if (i_size_read(inode) > MAX_INLINE_DATA(inode))
  22. return false;
  23. if (f2fs_post_read_required(inode))
  24. return false;
  25. return true;
  26. }
  27. bool f2fs_may_inline_dentry(struct inode *inode)
  28. {
  29. if (!test_opt(F2FS_I_SB(inode), INLINE_DENTRY))
  30. return false;
  31. if (!S_ISDIR(inode->i_mode))
  32. return false;
  33. return true;
  34. }
  35. void f2fs_do_read_inline_data(struct page *page, struct page *ipage)
  36. {
  37. struct inode *inode = page->mapping->host;
  38. void *src_addr, *dst_addr;
  39. if (PageUptodate(page))
  40. return;
  41. f2fs_bug_on(F2FS_P_SB(page), page->index);
  42. zero_user_segment(page, MAX_INLINE_DATA(inode), PAGE_SIZE);
  43. /* Copy the whole inline data block */
  44. src_addr = inline_data_addr(inode, ipage);
  45. dst_addr = kmap_atomic(page);
  46. memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode));
  47. flush_dcache_page(page);
  48. kunmap_atomic(dst_addr);
  49. if (!PageUptodate(page))
  50. SetPageUptodate(page);
  51. }
  52. void f2fs_truncate_inline_inode(struct inode *inode,
  53. struct page *ipage, u64 from)
  54. {
  55. void *addr;
  56. if (from >= MAX_INLINE_DATA(inode))
  57. return;
  58. addr = inline_data_addr(inode, ipage);
  59. f2fs_wait_on_page_writeback(ipage, NODE, true, true);
  60. memset(addr + from, 0, MAX_INLINE_DATA(inode) - from);
  61. set_page_dirty(ipage);
  62. if (from == 0)
  63. clear_inode_flag(inode, FI_DATA_EXIST);
  64. }
  65. int f2fs_read_inline_data(struct inode *inode, struct page *page)
  66. {
  67. struct page *ipage;
  68. if (trace_android_fs_dataread_start_enabled()) {
  69. char *path, pathbuf[MAX_TRACE_PATHBUF_LEN];
  70. path = android_fstrace_get_pathname(pathbuf,
  71. MAX_TRACE_PATHBUF_LEN,
  72. inode);
  73. trace_android_fs_dataread_start(inode, page_offset(page),
  74. PAGE_SIZE, current->pid,
  75. path, current->comm);
  76. }
  77. ipage = f2fs_get_node_page(F2FS_I_SB(inode), inode->i_ino);
  78. if (IS_ERR(ipage)) {
  79. trace_android_fs_dataread_end(inode, page_offset(page),
  80. PAGE_SIZE);
  81. unlock_page(page);
  82. return PTR_ERR(ipage);
  83. }
  84. if (!f2fs_has_inline_data(inode)) {
  85. f2fs_put_page(ipage, 1);
  86. trace_android_fs_dataread_end(inode, page_offset(page),
  87. PAGE_SIZE);
  88. return -EAGAIN;
  89. }
  90. if (page->index)
  91. zero_user_segment(page, 0, PAGE_SIZE);
  92. else
  93. f2fs_do_read_inline_data(page, ipage);
  94. if (!PageUptodate(page))
  95. SetPageUptodate(page);
  96. f2fs_put_page(ipage, 1);
  97. trace_android_fs_dataread_end(inode, page_offset(page),
  98. PAGE_SIZE);
  99. unlock_page(page);
  100. return 0;
  101. }
  102. int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
  103. {
  104. struct f2fs_io_info fio = {
  105. .sbi = F2FS_I_SB(dn->inode),
  106. .ino = dn->inode->i_ino,
  107. .type = DATA,
  108. .op = REQ_OP_WRITE,
  109. .op_flags = REQ_SYNC | REQ_PRIO,
  110. .page = page,
  111. .encrypted_page = NULL,
  112. .io_type = FS_DATA_IO,
  113. };
  114. struct node_info ni;
  115. int dirty, err;
  116. if (!f2fs_exist_data(dn->inode))
  117. goto clear_out;
  118. err = f2fs_reserve_block(dn, 0);
  119. if (err)
  120. return err;
  121. err = f2fs_get_node_info(fio.sbi, dn->nid, &ni, false);
  122. if (err) {
  123. f2fs_truncate_data_blocks_range(dn, 1);
  124. f2fs_put_dnode(dn);
  125. return err;
  126. }
  127. fio.version = ni.version;
  128. if (unlikely(dn->data_blkaddr != NEW_ADDR)) {
  129. f2fs_put_dnode(dn);
  130. set_sbi_flag(fio.sbi, SBI_NEED_FSCK);
  131. f2fs_warn(fio.sbi, "%s: corrupted inline inode ino=%lx, i_addr[0]:0x%x, run fsck to fix.",
  132. __func__, dn->inode->i_ino, dn->data_blkaddr);
  133. return -EFSCORRUPTED;
  134. }
  135. f2fs_bug_on(F2FS_P_SB(page), PageWriteback(page));
  136. f2fs_do_read_inline_data(page, dn->inode_page);
  137. set_page_dirty(page);
  138. /* clear dirty state */
  139. dirty = clear_page_dirty_for_io(page);
  140. /* write data page to try to make data consistent */
  141. set_page_writeback(page);
  142. ClearPageError(page);
  143. fio.old_blkaddr = dn->data_blkaddr;
  144. set_inode_flag(dn->inode, FI_HOT_DATA);
  145. f2fs_outplace_write_data(dn, &fio);
  146. f2fs_wait_on_page_writeback(page, DATA, true, true);
  147. if (dirty) {
  148. inode_dec_dirty_pages(dn->inode);
  149. f2fs_remove_dirty_inode(dn->inode);
  150. }
  151. /* this converted inline_data should be recovered. */
  152. set_inode_flag(dn->inode, FI_APPEND_WRITE);
  153. /* clear inline data and flag after data writeback */
  154. f2fs_truncate_inline_inode(dn->inode, dn->inode_page, 0);
  155. clear_page_private_inline(dn->inode_page);
  156. clear_out:
  157. stat_dec_inline_inode(dn->inode);
  158. clear_inode_flag(dn->inode, FI_INLINE_DATA);
  159. f2fs_put_dnode(dn);
  160. return 0;
  161. }
  162. int f2fs_convert_inline_inode(struct inode *inode)
  163. {
  164. struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
  165. struct dnode_of_data dn;
  166. struct page *ipage, *page;
  167. int err = 0;
  168. if (!f2fs_has_inline_data(inode) ||
  169. f2fs_hw_is_readonly(sbi) || f2fs_readonly(sbi->sb))
  170. return 0;
  171. err = dquot_initialize(inode);
  172. if (err)
  173. return err;
  174. page = f2fs_grab_cache_page(inode->i_mapping, 0, false);
  175. if (!page)
  176. return -ENOMEM;
  177. f2fs_lock_op(sbi);
  178. ipage = f2fs_get_node_page(sbi, inode->i_ino);
  179. if (IS_ERR(ipage)) {
  180. err = PTR_ERR(ipage);
  181. goto out;
  182. }
  183. set_new_dnode(&dn, inode, ipage, ipage, 0);
  184. if (f2fs_has_inline_data(inode))
  185. err = f2fs_convert_inline_page(&dn, page);
  186. f2fs_put_dnode(&dn);
  187. out:
  188. f2fs_unlock_op(sbi);
  189. f2fs_put_page(page, 1);
  190. if (!err)
  191. f2fs_balance_fs(sbi, dn.node_changed);
  192. return err;
  193. }
  194. int f2fs_write_inline_data(struct inode *inode, struct page *page)
  195. {
  196. void *src_addr, *dst_addr;
  197. struct dnode_of_data dn;
  198. int err;
  199. set_new_dnode(&dn, inode, NULL, NULL, 0);
  200. err = f2fs_get_dnode_of_data(&dn, 0, LOOKUP_NODE);
  201. if (err)
  202. return err;
  203. if (!f2fs_has_inline_data(inode)) {
  204. f2fs_put_dnode(&dn);
  205. return -EAGAIN;
  206. }
  207. f2fs_bug_on(F2FS_I_SB(inode), page->index);
  208. f2fs_wait_on_page_writeback(dn.inode_page, NODE, true, true);
  209. src_addr = kmap_atomic(page);
  210. dst_addr = inline_data_addr(inode, dn.inode_page);
  211. memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode));
  212. kunmap_atomic(src_addr);
  213. set_page_dirty(dn.inode_page);
  214. f2fs_clear_page_cache_dirty_tag(page);
  215. set_inode_flag(inode, FI_APPEND_WRITE);
  216. set_inode_flag(inode, FI_DATA_EXIST);
  217. clear_page_private_inline(dn.inode_page);
  218. f2fs_put_dnode(&dn);
  219. return 0;
  220. }
  221. int f2fs_recover_inline_data(struct inode *inode, struct page *npage)
  222. {
  223. struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
  224. struct f2fs_inode *ri = NULL;
  225. void *src_addr, *dst_addr;
  226. struct page *ipage;
  227. /*
  228. * The inline_data recovery policy is as follows.
  229. * [prev.] [next] of inline_data flag
  230. * o o -> recover inline_data
  231. * o x -> remove inline_data, and then recover data blocks
  232. * x o -> remove data blocks, and then recover inline_data
  233. * x x -> recover data blocks
  234. */
  235. if (IS_INODE(npage))
  236. ri = F2FS_INODE(npage);
  237. if (f2fs_has_inline_data(inode) &&
  238. ri && (ri->i_inline & F2FS_INLINE_DATA)) {
  239. process_inline:
  240. ipage = f2fs_get_node_page(sbi, inode->i_ino);
  241. if (IS_ERR(ipage))
  242. return PTR_ERR(ipage);
  243. f2fs_wait_on_page_writeback(ipage, NODE, true, true);
  244. src_addr = inline_data_addr(inode, npage);
  245. dst_addr = inline_data_addr(inode, ipage);
  246. memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode));
  247. set_inode_flag(inode, FI_INLINE_DATA);
  248. set_inode_flag(inode, FI_DATA_EXIST);
  249. set_page_dirty(ipage);
  250. f2fs_put_page(ipage, 1);
  251. return 1;
  252. }
  253. if (f2fs_has_inline_data(inode)) {
  254. ipage = f2fs_get_node_page(sbi, inode->i_ino);
  255. if (IS_ERR(ipage))
  256. return PTR_ERR(ipage);
  257. f2fs_truncate_inline_inode(inode, ipage, 0);
  258. stat_dec_inline_inode(inode);
  259. clear_inode_flag(inode, FI_INLINE_DATA);
  260. f2fs_put_page(ipage, 1);
  261. } else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) {
  262. int ret;
  263. ret = f2fs_truncate_blocks(inode, 0, false);
  264. if (ret)
  265. return ret;
  266. stat_inc_inline_inode(inode);
  267. goto process_inline;
  268. }
  269. return 0;
  270. }
  271. struct f2fs_dir_entry *f2fs_find_in_inline_dir(struct inode *dir,
  272. const struct f2fs_filename *fname,
  273. struct page **res_page)
  274. {
  275. struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
  276. struct f2fs_dir_entry *de;
  277. struct f2fs_dentry_ptr d;
  278. struct page *ipage;
  279. void *inline_dentry;
  280. ipage = f2fs_get_node_page(sbi, dir->i_ino);
  281. if (IS_ERR(ipage)) {
  282. *res_page = ipage;
  283. return NULL;
  284. }
  285. inline_dentry = inline_data_addr(dir, ipage);
  286. make_dentry_ptr_inline(dir, &d, inline_dentry);
  287. de = f2fs_find_target_dentry(&d, fname, NULL);
  288. unlock_page(ipage);
  289. if (IS_ERR(de)) {
  290. *res_page = ERR_CAST(de);
  291. de = NULL;
  292. }
  293. if (de)
  294. *res_page = ipage;
  295. else
  296. f2fs_put_page(ipage, 0);
  297. return de;
  298. }
  299. int f2fs_make_empty_inline_dir(struct inode *inode, struct inode *parent,
  300. struct page *ipage)
  301. {
  302. struct f2fs_dentry_ptr d;
  303. void *inline_dentry;
  304. inline_dentry = inline_data_addr(inode, ipage);
  305. make_dentry_ptr_inline(inode, &d, inline_dentry);
  306. f2fs_do_make_empty_dir(inode, parent, &d);
  307. set_page_dirty(ipage);
  308. /* update i_size to MAX_INLINE_DATA */
  309. if (i_size_read(inode) < MAX_INLINE_DATA(inode))
  310. f2fs_i_size_write(inode, MAX_INLINE_DATA(inode));
  311. return 0;
  312. }
  313. /*
  314. * NOTE: ipage is grabbed by caller, but if any error occurs, we should
  315. * release ipage in this function.
  316. */
  317. static int f2fs_move_inline_dirents(struct inode *dir, struct page *ipage,
  318. void *inline_dentry)
  319. {
  320. struct page *page;
  321. struct dnode_of_data dn;
  322. struct f2fs_dentry_block *dentry_blk;
  323. struct f2fs_dentry_ptr src, dst;
  324. int err;
  325. page = f2fs_grab_cache_page(dir->i_mapping, 0, true);
  326. if (!page) {
  327. f2fs_put_page(ipage, 1);
  328. return -ENOMEM;
  329. }
  330. set_new_dnode(&dn, dir, ipage, NULL, 0);
  331. err = f2fs_reserve_block(&dn, 0);
  332. if (err)
  333. goto out;
  334. if (unlikely(dn.data_blkaddr != NEW_ADDR)) {
  335. f2fs_put_dnode(&dn);
  336. set_sbi_flag(F2FS_P_SB(page), SBI_NEED_FSCK);
  337. f2fs_warn(F2FS_P_SB(page), "%s: corrupted inline inode ino=%lx, i_addr[0]:0x%x, run fsck to fix.",
  338. __func__, dir->i_ino, dn.data_blkaddr);
  339. err = -EFSCORRUPTED;
  340. goto out;
  341. }
  342. f2fs_wait_on_page_writeback(page, DATA, true, true);
  343. dentry_blk = page_address(page);
  344. make_dentry_ptr_inline(dir, &src, inline_dentry);
  345. make_dentry_ptr_block(dir, &dst, dentry_blk);
  346. /* copy data from inline dentry block to new dentry block */
  347. memcpy(dst.bitmap, src.bitmap, src.nr_bitmap);
  348. memset(dst.bitmap + src.nr_bitmap, 0, dst.nr_bitmap - src.nr_bitmap);
  349. /*
  350. * we do not need to zero out remainder part of dentry and filename
  351. * field, since we have used bitmap for marking the usage status of
  352. * them, besides, we can also ignore copying/zeroing reserved space
  353. * of dentry block, because them haven't been used so far.
  354. */
  355. memcpy(dst.dentry, src.dentry, SIZE_OF_DIR_ENTRY * src.max);
  356. memcpy(dst.filename, src.filename, src.max * F2FS_SLOT_LEN);
  357. if (!PageUptodate(page))
  358. SetPageUptodate(page);
  359. set_page_dirty(page);
  360. /* clear inline dir and flag after data writeback */
  361. f2fs_truncate_inline_inode(dir, ipage, 0);
  362. stat_dec_inline_dir(dir);
  363. clear_inode_flag(dir, FI_INLINE_DENTRY);
  364. /*
  365. * should retrieve reserved space which was used to keep
  366. * inline_dentry's structure for backward compatibility.
  367. */
  368. if (!f2fs_sb_has_flexible_inline_xattr(F2FS_I_SB(dir)) &&
  369. !f2fs_has_inline_xattr(dir))
  370. F2FS_I(dir)->i_inline_xattr_size = 0;
  371. f2fs_i_depth_write(dir, 1);
  372. if (i_size_read(dir) < PAGE_SIZE)
  373. f2fs_i_size_write(dir, PAGE_SIZE);
  374. out:
  375. f2fs_put_page(page, 1);
  376. return err;
  377. }
  378. static int f2fs_add_inline_entries(struct inode *dir, void *inline_dentry)
  379. {
  380. struct f2fs_dentry_ptr d;
  381. unsigned long bit_pos = 0;
  382. int err = 0;
  383. make_dentry_ptr_inline(dir, &d, inline_dentry);
  384. while (bit_pos < d.max) {
  385. struct f2fs_dir_entry *de;
  386. struct f2fs_filename fname;
  387. nid_t ino;
  388. umode_t fake_mode;
  389. if (!test_bit_le(bit_pos, d.bitmap)) {
  390. bit_pos++;
  391. continue;
  392. }
  393. de = &d.dentry[bit_pos];
  394. if (unlikely(!de->name_len)) {
  395. bit_pos++;
  396. continue;
  397. }
  398. /*
  399. * We only need the disk_name and hash to move the dentry.
  400. * We don't need the original or casefolded filenames.
  401. */
  402. memset(&fname, 0, sizeof(fname));
  403. fname.disk_name.name = d.filename[bit_pos];
  404. fname.disk_name.len = le16_to_cpu(de->name_len);
  405. fname.hash = de->hash_code;
  406. ino = le32_to_cpu(de->ino);
  407. fake_mode = f2fs_get_de_type(de) << S_SHIFT;
  408. err = f2fs_add_regular_entry(dir, &fname, NULL, ino, fake_mode);
  409. if (err)
  410. goto punch_dentry_pages;
  411. bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
  412. }
  413. return 0;
  414. punch_dentry_pages:
  415. truncate_inode_pages(&dir->i_data, 0);
  416. f2fs_truncate_blocks(dir, 0, false);
  417. f2fs_remove_dirty_inode(dir);
  418. return err;
  419. }
  420. static int f2fs_move_rehashed_dirents(struct inode *dir, struct page *ipage,
  421. void *inline_dentry)
  422. {
  423. void *backup_dentry;
  424. int err;
  425. backup_dentry = f2fs_kmalloc(F2FS_I_SB(dir),
  426. MAX_INLINE_DATA(dir), GFP_F2FS_ZERO);
  427. if (!backup_dentry) {
  428. f2fs_put_page(ipage, 1);
  429. return -ENOMEM;
  430. }
  431. memcpy(backup_dentry, inline_dentry, MAX_INLINE_DATA(dir));
  432. f2fs_truncate_inline_inode(dir, ipage, 0);
  433. unlock_page(ipage);
  434. err = f2fs_add_inline_entries(dir, backup_dentry);
  435. if (err)
  436. goto recover;
  437. lock_page(ipage);
  438. stat_dec_inline_dir(dir);
  439. clear_inode_flag(dir, FI_INLINE_DENTRY);
  440. /*
  441. * should retrieve reserved space which was used to keep
  442. * inline_dentry's structure for backward compatibility.
  443. */
  444. if (!f2fs_sb_has_flexible_inline_xattr(F2FS_I_SB(dir)) &&
  445. !f2fs_has_inline_xattr(dir))
  446. F2FS_I(dir)->i_inline_xattr_size = 0;
  447. kfree(backup_dentry);
  448. return 0;
  449. recover:
  450. lock_page(ipage);
  451. f2fs_wait_on_page_writeback(ipage, NODE, true, true);
  452. memcpy(inline_dentry, backup_dentry, MAX_INLINE_DATA(dir));
  453. f2fs_i_depth_write(dir, 0);
  454. f2fs_i_size_write(dir, MAX_INLINE_DATA(dir));
  455. set_page_dirty(ipage);
  456. f2fs_put_page(ipage, 1);
  457. kfree(backup_dentry);
  458. return err;
  459. }
  460. static int do_convert_inline_dir(struct inode *dir, struct page *ipage,
  461. void *inline_dentry)
  462. {
  463. if (!F2FS_I(dir)->i_dir_level)
  464. return f2fs_move_inline_dirents(dir, ipage, inline_dentry);
  465. else
  466. return f2fs_move_rehashed_dirents(dir, ipage, inline_dentry);
  467. }
  468. int f2fs_try_convert_inline_dir(struct inode *dir, struct dentry *dentry)
  469. {
  470. struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
  471. struct page *ipage;
  472. struct f2fs_filename fname;
  473. void *inline_dentry = NULL;
  474. int err = 0;
  475. if (!f2fs_has_inline_dentry(dir))
  476. return 0;
  477. f2fs_lock_op(sbi);
  478. err = f2fs_setup_filename(dir, &dentry->d_name, 0, &fname);
  479. if (err)
  480. goto out;
  481. ipage = f2fs_get_node_page(sbi, dir->i_ino);
  482. if (IS_ERR(ipage)) {
  483. err = PTR_ERR(ipage);
  484. goto out_fname;
  485. }
  486. if (f2fs_has_enough_room(dir, ipage, &fname)) {
  487. f2fs_put_page(ipage, 1);
  488. goto out_fname;
  489. }
  490. inline_dentry = inline_data_addr(dir, ipage);
  491. err = do_convert_inline_dir(dir, ipage, inline_dentry);
  492. if (!err)
  493. f2fs_put_page(ipage, 1);
  494. out_fname:
  495. f2fs_free_filename(&fname);
  496. out:
  497. f2fs_unlock_op(sbi);
  498. return err;
  499. }
  500. int f2fs_add_inline_entry(struct inode *dir, const struct f2fs_filename *fname,
  501. struct inode *inode, nid_t ino, umode_t mode)
  502. {
  503. struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
  504. struct page *ipage;
  505. unsigned int bit_pos;
  506. void *inline_dentry = NULL;
  507. struct f2fs_dentry_ptr d;
  508. int slots = GET_DENTRY_SLOTS(fname->disk_name.len);
  509. struct page *page = NULL;
  510. int err = 0;
  511. ipage = f2fs_get_node_page(sbi, dir->i_ino);
  512. if (IS_ERR(ipage))
  513. return PTR_ERR(ipage);
  514. inline_dentry = inline_data_addr(dir, ipage);
  515. make_dentry_ptr_inline(dir, &d, inline_dentry);
  516. bit_pos = f2fs_room_for_filename(d.bitmap, slots, d.max);
  517. if (bit_pos >= d.max) {
  518. err = do_convert_inline_dir(dir, ipage, inline_dentry);
  519. if (err)
  520. return err;
  521. err = -EAGAIN;
  522. goto out;
  523. }
  524. if (inode) {
  525. f2fs_down_write(&F2FS_I(inode)->i_sem);
  526. page = f2fs_init_inode_metadata(inode, dir, fname, ipage);
  527. if (IS_ERR(page)) {
  528. err = PTR_ERR(page);
  529. goto fail;
  530. }
  531. }
  532. f2fs_wait_on_page_writeback(ipage, NODE, true, true);
  533. f2fs_update_dentry(ino, mode, &d, &fname->disk_name, fname->hash,
  534. bit_pos);
  535. set_page_dirty(ipage);
  536. /* we don't need to mark_inode_dirty now */
  537. if (inode) {
  538. f2fs_i_pino_write(inode, dir->i_ino);
  539. /* synchronize inode page's data from inode cache */
  540. if (is_inode_flag_set(inode, FI_NEW_INODE))
  541. f2fs_update_inode(inode, page);
  542. f2fs_put_page(page, 1);
  543. }
  544. f2fs_update_parent_metadata(dir, inode, 0);
  545. fail:
  546. if (inode)
  547. f2fs_up_write(&F2FS_I(inode)->i_sem);
  548. out:
  549. f2fs_put_page(ipage, 1);
  550. return err;
  551. }
  552. void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page,
  553. struct inode *dir, struct inode *inode)
  554. {
  555. struct f2fs_dentry_ptr d;
  556. void *inline_dentry;
  557. int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));
  558. unsigned int bit_pos;
  559. int i;
  560. lock_page(page);
  561. f2fs_wait_on_page_writeback(page, NODE, true, true);
  562. inline_dentry = inline_data_addr(dir, page);
  563. make_dentry_ptr_inline(dir, &d, inline_dentry);
  564. bit_pos = dentry - d.dentry;
  565. for (i = 0; i < slots; i++)
  566. __clear_bit_le(bit_pos + i, d.bitmap);
  567. set_page_dirty(page);
  568. f2fs_put_page(page, 1);
  569. dir->i_ctime = dir->i_mtime = current_time(dir);
  570. f2fs_mark_inode_dirty_sync(dir, false);
  571. if (inode)
  572. f2fs_drop_nlink(dir, inode);
  573. }
  574. bool f2fs_empty_inline_dir(struct inode *dir)
  575. {
  576. struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
  577. struct page *ipage;
  578. unsigned int bit_pos = 2;
  579. void *inline_dentry;
  580. struct f2fs_dentry_ptr d;
  581. ipage = f2fs_get_node_page(sbi, dir->i_ino);
  582. if (IS_ERR(ipage))
  583. return false;
  584. inline_dentry = inline_data_addr(dir, ipage);
  585. make_dentry_ptr_inline(dir, &d, inline_dentry);
  586. bit_pos = find_next_bit_le(d.bitmap, d.max, bit_pos);
  587. f2fs_put_page(ipage, 1);
  588. if (bit_pos < d.max)
  589. return false;
  590. return true;
  591. }
  592. int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx,
  593. struct fscrypt_str *fstr)
  594. {
  595. struct inode *inode = file_inode(file);
  596. struct page *ipage = NULL;
  597. struct f2fs_dentry_ptr d;
  598. void *inline_dentry = NULL;
  599. int err;
  600. make_dentry_ptr_inline(inode, &d, inline_dentry);
  601. if (ctx->pos == d.max)
  602. return 0;
  603. ipage = f2fs_get_node_page(F2FS_I_SB(inode), inode->i_ino);
  604. if (IS_ERR(ipage))
  605. return PTR_ERR(ipage);
  606. /*
  607. * f2fs_readdir was protected by inode.i_rwsem, it is safe to access
  608. * ipage without page's lock held.
  609. */
  610. unlock_page(ipage);
  611. inline_dentry = inline_data_addr(inode, ipage);
  612. make_dentry_ptr_inline(inode, &d, inline_dentry);
  613. err = f2fs_fill_dentries(ctx, &d, 0, fstr);
  614. if (!err)
  615. ctx->pos = d.max;
  616. f2fs_put_page(ipage, 0);
  617. return err < 0 ? err : 0;
  618. }
  619. int f2fs_inline_data_fiemap(struct inode *inode,
  620. struct fiemap_extent_info *fieinfo, __u64 start, __u64 len)
  621. {
  622. __u64 byteaddr, ilen;
  623. __u32 flags = FIEMAP_EXTENT_DATA_INLINE | FIEMAP_EXTENT_NOT_ALIGNED |
  624. FIEMAP_EXTENT_LAST;
  625. struct node_info ni;
  626. struct page *ipage;
  627. int err = 0;
  628. ipage = f2fs_get_node_page(F2FS_I_SB(inode), inode->i_ino);
  629. if (IS_ERR(ipage))
  630. return PTR_ERR(ipage);
  631. if ((S_ISREG(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
  632. !f2fs_has_inline_data(inode)) {
  633. err = -EAGAIN;
  634. goto out;
  635. }
  636. if (S_ISDIR(inode->i_mode) && !f2fs_has_inline_dentry(inode)) {
  637. err = -EAGAIN;
  638. goto out;
  639. }
  640. ilen = min_t(size_t, MAX_INLINE_DATA(inode), i_size_read(inode));
  641. if (start >= ilen)
  642. goto out;
  643. if (start + len < ilen)
  644. ilen = start + len;
  645. ilen -= start;
  646. err = f2fs_get_node_info(F2FS_I_SB(inode), inode->i_ino, &ni, false);
  647. if (err)
  648. goto out;
  649. byteaddr = (__u64)ni.blk_addr << inode->i_sb->s_blocksize_bits;
  650. byteaddr += (char *)inline_data_addr(inode, ipage) -
  651. (char *)F2FS_INODE(ipage);
  652. err = fiemap_fill_next_extent(fieinfo, start, byteaddr, ilen, flags);
  653. trace_f2fs_fiemap(inode, start, byteaddr, ilen, flags, err);
  654. out:
  655. f2fs_put_page(ipage, 1);
  656. return err;
  657. }