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