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