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