4 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5 * http://www.samsung.com/
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
12 #include <linux/f2fs_fs.h>
13 #include <linux/stat.h>
14 #include <linux/buffer_head.h>
15 #include <linux/writeback.h>
16 #include <linux/blkdev.h>
17 #include <linux/falloc.h>
18 #include <linux/types.h>
19 #include <linux/compat.h>
20 #include <linux/uaccess.h>
21 #include <linux/mount.h>
22 #include <linux/pagevec.h>
23 #include <linux/uuid.h>
24 #include <linux/file.h>
33 #include <trace/events/f2fs.h>
35 static int f2fs_vm_page_mkwrite(struct vm_area_struct
*vma
,
38 struct page
*page
= vmf
->page
;
39 struct inode
*inode
= file_inode(vma
->vm_file
);
40 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
41 struct dnode_of_data dn
;
44 sb_start_pagefault(inode
->i_sb
);
46 f2fs_bug_on(sbi
, f2fs_has_inline_data(inode
));
48 /* block allocation */
50 set_new_dnode(&dn
, inode
, NULL
, NULL
, 0);
51 err
= f2fs_reserve_block(&dn
, page
->index
);
59 f2fs_balance_fs(sbi
, dn
.node_changed
);
61 file_update_time(vma
->vm_file
);
63 if (unlikely(page
->mapping
!= inode
->i_mapping
||
64 page_offset(page
) > i_size_read(inode
) ||
65 !PageUptodate(page
))) {
72 * check to see if the page is mapped already (no holes)
74 if (PageMappedToDisk(page
))
77 /* page is wholly or partially inside EOF */
78 if (((loff_t
)(page
->index
+ 1) << PAGE_SHIFT
) >
81 offset
= i_size_read(inode
) & ~PAGE_MASK
;
82 zero_user_segment(page
, offset
, PAGE_SIZE
);
85 if (!PageUptodate(page
))
86 SetPageUptodate(page
);
88 trace_f2fs_vm_page_mkwrite(page
, DATA
);
91 f2fs_wait_on_page_writeback(page
, DATA
, false);
93 /* wait for GCed encrypted page writeback */
94 if (f2fs_encrypted_inode(inode
) && S_ISREG(inode
->i_mode
))
95 f2fs_wait_on_encrypted_page_writeback(sbi
, dn
.data_blkaddr
);
97 /* if gced page is attached, don't write to cold segment */
98 clear_cold_data(page
);
100 sb_end_pagefault(inode
->i_sb
);
101 f2fs_update_time(sbi
, REQ_TIME
);
102 return block_page_mkwrite_return(err
);
105 static const struct vm_operations_struct f2fs_file_vm_ops
= {
106 .fault
= filemap_fault
,
107 .map_pages
= filemap_map_pages
,
108 .page_mkwrite
= f2fs_vm_page_mkwrite
,
111 static int get_parent_ino(struct inode
*inode
, nid_t
*pino
)
113 struct dentry
*dentry
;
115 inode
= igrab(inode
);
116 dentry
= d_find_any_alias(inode
);
121 if (update_dent_inode(inode
, inode
, &dentry
->d_name
)) {
126 *pino
= parent_ino(dentry
);
131 static inline bool need_do_checkpoint(struct inode
*inode
)
133 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
134 bool need_cp
= false;
136 if (!S_ISREG(inode
->i_mode
) || inode
->i_nlink
!= 1)
138 else if (is_sbi_flag_set(sbi
, SBI_NEED_CP
))
140 else if (file_enc_name(inode
) && need_dentry_mark(sbi
, inode
->i_ino
))
142 else if (file_wrong_pino(inode
))
144 else if (!space_for_roll_forward(sbi
))
146 else if (!is_checkpointed_node(sbi
, F2FS_I(inode
)->i_pino
))
148 else if (F2FS_I(inode
)->xattr_ver
== cur_cp_version(F2FS_CKPT(sbi
)))
150 else if (test_opt(sbi
, FASTBOOT
))
152 else if (sbi
->active_logs
== 2)
158 static bool need_inode_page_update(struct f2fs_sb_info
*sbi
, nid_t ino
)
160 struct page
*i
= find_get_page(NODE_MAPPING(sbi
), ino
);
162 /* But we need to avoid that there are some inode updates */
163 if ((i
&& PageDirty(i
)) || need_inode_block_update(sbi
, ino
))
169 static void try_to_fix_pino(struct inode
*inode
)
171 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
174 down_write(&fi
->i_sem
);
176 if (file_wrong_pino(inode
) && inode
->i_nlink
== 1 &&
177 get_parent_ino(inode
, &pino
)) {
178 f2fs_i_pino_write(inode
, pino
);
179 file_got_pino(inode
);
181 up_write(&fi
->i_sem
);
184 static int f2fs_do_sync_file(struct file
*file
, loff_t start
, loff_t end
,
185 int datasync
, bool atomic
)
187 struct inode
*inode
= file
->f_mapping
->host
;
188 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
189 nid_t ino
= inode
->i_ino
;
191 bool need_cp
= false;
192 struct writeback_control wbc
= {
193 .sync_mode
= WB_SYNC_ALL
,
194 .nr_to_write
= LONG_MAX
,
198 if (unlikely(f2fs_readonly(inode
->i_sb
)))
201 trace_f2fs_sync_file_enter(inode
);
203 /* if fdatasync is triggered, let's do in-place-update */
204 if (datasync
|| get_dirty_pages(inode
) <= SM_I(sbi
)->min_fsync_blocks
)
205 set_inode_flag(inode
, FI_NEED_IPU
);
206 ret
= filemap_write_and_wait_range(inode
->i_mapping
, start
, end
);
207 clear_inode_flag(inode
, FI_NEED_IPU
);
210 trace_f2fs_sync_file_exit(inode
, need_cp
, datasync
, ret
);
214 /* if the inode is dirty, let's recover all the time */
215 if (!datasync
&& !f2fs_skip_inode_update(inode
)) {
216 f2fs_write_inode(inode
, NULL
);
221 * if there is no written data, don't waste time to write recovery info.
223 if (!is_inode_flag_set(inode
, FI_APPEND_WRITE
) &&
224 !exist_written_data(sbi
, ino
, APPEND_INO
)) {
226 /* it may call write_inode just prior to fsync */
227 if (need_inode_page_update(sbi
, ino
))
230 if (is_inode_flag_set(inode
, FI_UPDATE_WRITE
) ||
231 exist_written_data(sbi
, ino
, UPDATE_INO
))
237 * Both of fdatasync() and fsync() are able to be recovered from
240 down_read(&F2FS_I(inode
)->i_sem
);
241 need_cp
= need_do_checkpoint(inode
);
242 up_read(&F2FS_I(inode
)->i_sem
);
245 /* all the dirty node pages should be flushed for POR */
246 ret
= f2fs_sync_fs(inode
->i_sb
, 1);
249 * We've secured consistency through sync_fs. Following pino
250 * will be used only for fsynced inodes after checkpoint.
252 try_to_fix_pino(inode
);
253 clear_inode_flag(inode
, FI_APPEND_WRITE
);
254 clear_inode_flag(inode
, FI_UPDATE_WRITE
);
258 ret
= fsync_node_pages(sbi
, inode
, &wbc
, atomic
);
262 /* if cp_error was enabled, we should avoid infinite loop */
263 if (unlikely(f2fs_cp_error(sbi
))) {
268 if (need_inode_block_update(sbi
, ino
)) {
269 f2fs_mark_inode_dirty_sync(inode
);
270 f2fs_write_inode(inode
, NULL
);
274 ret
= wait_on_node_pages_writeback(sbi
, ino
);
278 /* once recovery info is written, don't need to tack this */
279 remove_ino_entry(sbi
, ino
, APPEND_INO
);
280 clear_inode_flag(inode
, FI_APPEND_WRITE
);
282 remove_ino_entry(sbi
, ino
, UPDATE_INO
);
283 clear_inode_flag(inode
, FI_UPDATE_WRITE
);
284 ret
= f2fs_issue_flush(sbi
);
285 f2fs_update_time(sbi
, REQ_TIME
);
287 trace_f2fs_sync_file_exit(inode
, need_cp
, datasync
, ret
);
288 f2fs_trace_ios(NULL
, 1);
292 int f2fs_sync_file(struct file
*file
, loff_t start
, loff_t end
, int datasync
)
294 return f2fs_do_sync_file(file
, start
, end
, datasync
, false);
297 static pgoff_t
__get_first_dirty_index(struct address_space
*mapping
,
298 pgoff_t pgofs
, int whence
)
303 if (whence
!= SEEK_DATA
)
306 /* find first dirty page index */
307 pagevec_init(&pvec
, 0);
308 nr_pages
= pagevec_lookup_tag(&pvec
, mapping
, &pgofs
,
309 PAGECACHE_TAG_DIRTY
, 1);
310 pgofs
= nr_pages
? pvec
.pages
[0]->index
: ULONG_MAX
;
311 pagevec_release(&pvec
);
315 static bool __found_offset(block_t blkaddr
, pgoff_t dirty
, pgoff_t pgofs
,
320 if ((blkaddr
== NEW_ADDR
&& dirty
== pgofs
) ||
321 (blkaddr
!= NEW_ADDR
&& blkaddr
!= NULL_ADDR
))
325 if (blkaddr
== NULL_ADDR
)
332 static loff_t
f2fs_seek_block(struct file
*file
, loff_t offset
, int whence
)
334 struct inode
*inode
= file
->f_mapping
->host
;
335 loff_t maxbytes
= inode
->i_sb
->s_maxbytes
;
336 struct dnode_of_data dn
;
337 pgoff_t pgofs
, end_offset
, dirty
;
338 loff_t data_ofs
= offset
;
344 isize
= i_size_read(inode
);
348 /* handle inline data case */
349 if (f2fs_has_inline_data(inode
) || f2fs_has_inline_dentry(inode
)) {
350 if (whence
== SEEK_HOLE
)
355 pgofs
= (pgoff_t
)(offset
>> PAGE_SHIFT
);
357 dirty
= __get_first_dirty_index(inode
->i_mapping
, pgofs
, whence
);
359 for (; data_ofs
< isize
; data_ofs
= (loff_t
)pgofs
<< PAGE_SHIFT
) {
360 set_new_dnode(&dn
, inode
, NULL
, NULL
, 0);
361 err
= get_dnode_of_data(&dn
, pgofs
, LOOKUP_NODE
);
362 if (err
&& err
!= -ENOENT
) {
364 } else if (err
== -ENOENT
) {
365 /* direct node does not exists */
366 if (whence
== SEEK_DATA
) {
367 pgofs
= get_next_page_offset(&dn
, pgofs
);
374 end_offset
= ADDRS_PER_PAGE(dn
.node_page
, inode
);
376 /* find data/hole in dnode block */
377 for (; dn
.ofs_in_node
< end_offset
;
378 dn
.ofs_in_node
++, pgofs
++,
379 data_ofs
= (loff_t
)pgofs
<< PAGE_SHIFT
) {
381 blkaddr
= datablock_addr(dn
.node_page
, dn
.ofs_in_node
);
383 if (__found_offset(blkaddr
, dirty
, pgofs
, whence
)) {
391 if (whence
== SEEK_DATA
)
394 if (whence
== SEEK_HOLE
&& data_ofs
> isize
)
397 return vfs_setpos(file
, data_ofs
, maxbytes
);
403 static loff_t
f2fs_llseek(struct file
*file
, loff_t offset
, int whence
)
405 struct inode
*inode
= file
->f_mapping
->host
;
406 loff_t maxbytes
= inode
->i_sb
->s_maxbytes
;
412 return generic_file_llseek_size(file
, offset
, whence
,
413 maxbytes
, i_size_read(inode
));
418 return f2fs_seek_block(file
, offset
, whence
);
424 static int f2fs_file_mmap(struct file
*file
, struct vm_area_struct
*vma
)
426 struct inode
*inode
= file_inode(file
);
429 if (f2fs_encrypted_inode(inode
)) {
430 err
= fscrypt_get_encryption_info(inode
);
433 if (!f2fs_encrypted_inode(inode
))
437 /* we don't need to use inline_data strictly */
438 err
= f2fs_convert_inline_inode(inode
);
443 vma
->vm_ops
= &f2fs_file_vm_ops
;
447 static int f2fs_file_open(struct inode
*inode
, struct file
*filp
)
449 int ret
= generic_file_open(inode
, filp
);
452 if (!ret
&& f2fs_encrypted_inode(inode
)) {
453 ret
= fscrypt_get_encryption_info(inode
);
456 if (!fscrypt_has_encryption_key(inode
))
459 dir
= dget_parent(file_dentry(filp
));
460 if (f2fs_encrypted_inode(d_inode(dir
)) &&
461 !fscrypt_has_permitted_context(d_inode(dir
), inode
)) {
469 int truncate_data_blocks_range(struct dnode_of_data
*dn
, int count
)
471 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dn
->inode
);
472 struct f2fs_node
*raw_node
;
473 int nr_free
= 0, ofs
= dn
->ofs_in_node
, len
= count
;
476 raw_node
= F2FS_NODE(dn
->node_page
);
477 addr
= blkaddr_in_node(raw_node
) + ofs
;
479 for (; count
> 0; count
--, addr
++, dn
->ofs_in_node
++) {
480 block_t blkaddr
= le32_to_cpu(*addr
);
481 if (blkaddr
== NULL_ADDR
)
484 dn
->data_blkaddr
= NULL_ADDR
;
485 set_data_blkaddr(dn
);
486 invalidate_blocks(sbi
, blkaddr
);
487 if (dn
->ofs_in_node
== 0 && IS_INODE(dn
->node_page
))
488 clear_inode_flag(dn
->inode
, FI_FIRST_BLOCK_WRITTEN
);
495 * once we invalidate valid blkaddr in range [ofs, ofs + count],
496 * we will invalidate all blkaddr in the whole range.
498 fofs
= start_bidx_of_node(ofs_of_node(dn
->node_page
),
500 f2fs_update_extent_cache_range(dn
, fofs
, 0, len
);
501 dec_valid_block_count(sbi
, dn
->inode
, nr_free
);
503 dn
->ofs_in_node
= ofs
;
505 f2fs_update_time(sbi
, REQ_TIME
);
506 trace_f2fs_truncate_data_blocks_range(dn
->inode
, dn
->nid
,
507 dn
->ofs_in_node
, nr_free
);
511 void truncate_data_blocks(struct dnode_of_data
*dn
)
513 truncate_data_blocks_range(dn
, ADDRS_PER_BLOCK
);
516 static int truncate_partial_data_page(struct inode
*inode
, u64 from
,
519 unsigned offset
= from
& (PAGE_SIZE
- 1);
520 pgoff_t index
= from
>> PAGE_SHIFT
;
521 struct address_space
*mapping
= inode
->i_mapping
;
524 if (!offset
&& !cache_only
)
528 page
= f2fs_grab_cache_page(mapping
, index
, false);
529 if (page
&& PageUptodate(page
))
531 f2fs_put_page(page
, 1);
535 page
= get_lock_data_page(inode
, index
, true);
539 f2fs_wait_on_page_writeback(page
, DATA
, true);
540 zero_user(page
, offset
, PAGE_SIZE
- offset
);
541 if (!cache_only
|| !f2fs_encrypted_inode(inode
) ||
542 !S_ISREG(inode
->i_mode
))
543 set_page_dirty(page
);
544 f2fs_put_page(page
, 1);
548 int truncate_blocks(struct inode
*inode
, u64 from
, bool lock
)
550 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
551 unsigned int blocksize
= inode
->i_sb
->s_blocksize
;
552 struct dnode_of_data dn
;
554 int count
= 0, err
= 0;
556 bool truncate_page
= false;
558 trace_f2fs_truncate_blocks_enter(inode
, from
);
560 free_from
= (pgoff_t
)F2FS_BYTES_TO_BLK(from
+ blocksize
- 1);
562 if (free_from
>= sbi
->max_file_blocks
)
568 ipage
= get_node_page(sbi
, inode
->i_ino
);
570 err
= PTR_ERR(ipage
);
574 if (f2fs_has_inline_data(inode
)) {
575 if (truncate_inline_inode(ipage
, from
))
576 set_page_dirty(ipage
);
577 f2fs_put_page(ipage
, 1);
578 truncate_page
= true;
582 set_new_dnode(&dn
, inode
, ipage
, NULL
, 0);
583 err
= get_dnode_of_data(&dn
, free_from
, LOOKUP_NODE_RA
);
590 count
= ADDRS_PER_PAGE(dn
.node_page
, inode
);
592 count
-= dn
.ofs_in_node
;
593 f2fs_bug_on(sbi
, count
< 0);
595 if (dn
.ofs_in_node
|| IS_INODE(dn
.node_page
)) {
596 truncate_data_blocks_range(&dn
, count
);
602 err
= truncate_inode_blocks(inode
, free_from
);
607 /* lastly zero out the first data page */
609 err
= truncate_partial_data_page(inode
, from
, truncate_page
);
611 trace_f2fs_truncate_blocks_exit(inode
, err
);
615 int f2fs_truncate(struct inode
*inode
)
619 if (!(S_ISREG(inode
->i_mode
) || S_ISDIR(inode
->i_mode
) ||
620 S_ISLNK(inode
->i_mode
)))
623 trace_f2fs_truncate(inode
);
625 /* we should check inline_data size */
626 if (!f2fs_may_inline_data(inode
)) {
627 err
= f2fs_convert_inline_inode(inode
);
632 err
= truncate_blocks(inode
, i_size_read(inode
), true);
636 inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
637 f2fs_mark_inode_dirty_sync(inode
);
641 int f2fs_getattr(struct vfsmount
*mnt
,
642 struct dentry
*dentry
, struct kstat
*stat
)
644 struct inode
*inode
= d_inode(dentry
);
645 generic_fillattr(inode
, stat
);
650 #ifdef CONFIG_F2FS_FS_POSIX_ACL
651 static void __setattr_copy(struct inode
*inode
, const struct iattr
*attr
)
653 unsigned int ia_valid
= attr
->ia_valid
;
655 if (ia_valid
& ATTR_UID
)
656 inode
->i_uid
= attr
->ia_uid
;
657 if (ia_valid
& ATTR_GID
)
658 inode
->i_gid
= attr
->ia_gid
;
659 if (ia_valid
& ATTR_ATIME
)
660 inode
->i_atime
= timespec_trunc(attr
->ia_atime
,
661 inode
->i_sb
->s_time_gran
);
662 if (ia_valid
& ATTR_MTIME
)
663 inode
->i_mtime
= timespec_trunc(attr
->ia_mtime
,
664 inode
->i_sb
->s_time_gran
);
665 if (ia_valid
& ATTR_CTIME
)
666 inode
->i_ctime
= timespec_trunc(attr
->ia_ctime
,
667 inode
->i_sb
->s_time_gran
);
668 if (ia_valid
& ATTR_MODE
) {
669 umode_t mode
= attr
->ia_mode
;
671 if (!in_group_p(inode
->i_gid
) && !capable(CAP_FSETID
))
673 set_acl_inode(inode
, mode
);
677 #define __setattr_copy setattr_copy
680 int f2fs_setattr(struct dentry
*dentry
, struct iattr
*attr
)
682 struct inode
*inode
= d_inode(dentry
);
685 err
= inode_change_ok(inode
, attr
);
689 if (attr
->ia_valid
& ATTR_SIZE
) {
690 if (f2fs_encrypted_inode(inode
) &&
691 fscrypt_get_encryption_info(inode
))
694 if (attr
->ia_size
<= i_size_read(inode
)) {
695 truncate_setsize(inode
, attr
->ia_size
);
696 err
= f2fs_truncate(inode
);
699 f2fs_balance_fs(F2FS_I_SB(inode
), true);
702 * do not trim all blocks after i_size if target size is
703 * larger than i_size.
705 truncate_setsize(inode
, attr
->ia_size
);
707 /* should convert inline inode here */
708 if (!f2fs_may_inline_data(inode
)) {
709 err
= f2fs_convert_inline_inode(inode
);
713 inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
717 __setattr_copy(inode
, attr
);
719 if (attr
->ia_valid
& ATTR_MODE
) {
720 err
= posix_acl_chmod(inode
, get_inode_mode(inode
));
721 if (err
|| is_inode_flag_set(inode
, FI_ACL_MODE
)) {
722 inode
->i_mode
= F2FS_I(inode
)->i_acl_mode
;
723 clear_inode_flag(inode
, FI_ACL_MODE
);
727 f2fs_mark_inode_dirty_sync(inode
);
731 const struct inode_operations f2fs_file_inode_operations
= {
732 .getattr
= f2fs_getattr
,
733 .setattr
= f2fs_setattr
,
734 .get_acl
= f2fs_get_acl
,
735 .set_acl
= f2fs_set_acl
,
736 #ifdef CONFIG_F2FS_FS_XATTR
737 .setxattr
= generic_setxattr
,
738 .getxattr
= generic_getxattr
,
739 .listxattr
= f2fs_listxattr
,
740 .removexattr
= generic_removexattr
,
742 .fiemap
= f2fs_fiemap
,
745 static int fill_zero(struct inode
*inode
, pgoff_t index
,
746 loff_t start
, loff_t len
)
748 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
754 f2fs_balance_fs(sbi
, true);
757 page
= get_new_data_page(inode
, NULL
, index
, false);
761 return PTR_ERR(page
);
763 f2fs_wait_on_page_writeback(page
, DATA
, true);
764 zero_user(page
, start
, len
);
765 set_page_dirty(page
);
766 f2fs_put_page(page
, 1);
770 int truncate_hole(struct inode
*inode
, pgoff_t pg_start
, pgoff_t pg_end
)
774 while (pg_start
< pg_end
) {
775 struct dnode_of_data dn
;
776 pgoff_t end_offset
, count
;
778 set_new_dnode(&dn
, inode
, NULL
, NULL
, 0);
779 err
= get_dnode_of_data(&dn
, pg_start
, LOOKUP_NODE
);
781 if (err
== -ENOENT
) {
788 end_offset
= ADDRS_PER_PAGE(dn
.node_page
, inode
);
789 count
= min(end_offset
- dn
.ofs_in_node
, pg_end
- pg_start
);
791 f2fs_bug_on(F2FS_I_SB(inode
), count
== 0 || count
> end_offset
);
793 truncate_data_blocks_range(&dn
, count
);
801 static int punch_hole(struct inode
*inode
, loff_t offset
, loff_t len
)
803 pgoff_t pg_start
, pg_end
;
804 loff_t off_start
, off_end
;
807 ret
= f2fs_convert_inline_inode(inode
);
811 pg_start
= ((unsigned long long) offset
) >> PAGE_SHIFT
;
812 pg_end
= ((unsigned long long) offset
+ len
) >> PAGE_SHIFT
;
814 off_start
= offset
& (PAGE_SIZE
- 1);
815 off_end
= (offset
+ len
) & (PAGE_SIZE
- 1);
817 if (pg_start
== pg_end
) {
818 ret
= fill_zero(inode
, pg_start
, off_start
,
819 off_end
- off_start
);
824 ret
= fill_zero(inode
, pg_start
++, off_start
,
825 PAGE_SIZE
- off_start
);
830 ret
= fill_zero(inode
, pg_end
, 0, off_end
);
835 if (pg_start
< pg_end
) {
836 struct address_space
*mapping
= inode
->i_mapping
;
837 loff_t blk_start
, blk_end
;
838 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
840 f2fs_balance_fs(sbi
, true);
842 blk_start
= (loff_t
)pg_start
<< PAGE_SHIFT
;
843 blk_end
= (loff_t
)pg_end
<< PAGE_SHIFT
;
844 truncate_inode_pages_range(mapping
, blk_start
,
848 ret
= truncate_hole(inode
, pg_start
, pg_end
);
856 static int __read_out_blkaddrs(struct inode
*inode
, block_t
*blkaddr
,
857 int *do_replace
, pgoff_t off
, pgoff_t len
)
859 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
860 struct dnode_of_data dn
;
864 set_new_dnode(&dn
, inode
, NULL
, NULL
, 0);
865 ret
= get_dnode_of_data(&dn
, off
, LOOKUP_NODE_RA
);
866 if (ret
&& ret
!= -ENOENT
) {
868 } else if (ret
== -ENOENT
) {
869 if (dn
.max_level
== 0)
871 done
= min((pgoff_t
)ADDRS_PER_BLOCK
- dn
.ofs_in_node
, len
);
877 done
= min((pgoff_t
)ADDRS_PER_PAGE(dn
.node_page
, inode
) -
878 dn
.ofs_in_node
, len
);
879 for (i
= 0; i
< done
; i
++, blkaddr
++, do_replace
++, dn
.ofs_in_node
++) {
880 *blkaddr
= datablock_addr(dn
.node_page
, dn
.ofs_in_node
);
881 if (!is_checkpointed_data(sbi
, *blkaddr
)) {
883 if (test_opt(sbi
, LFS
)) {
888 /* do not invalidate this block address */
889 f2fs_update_data_blkaddr(&dn
, NULL_ADDR
);
902 static int __roll_back_blkaddrs(struct inode
*inode
, block_t
*blkaddr
,
903 int *do_replace
, pgoff_t off
, int len
)
905 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
906 struct dnode_of_data dn
;
909 for (i
= 0; i
< len
; i
++, do_replace
++, blkaddr
++) {
910 if (*do_replace
== 0)
913 set_new_dnode(&dn
, inode
, NULL
, NULL
, 0);
914 ret
= get_dnode_of_data(&dn
, off
+ i
, LOOKUP_NODE_RA
);
916 dec_valid_block_count(sbi
, inode
, 1);
917 invalidate_blocks(sbi
, *blkaddr
);
919 f2fs_update_data_blkaddr(&dn
, *blkaddr
);
926 static int __clone_blkaddrs(struct inode
*src_inode
, struct inode
*dst_inode
,
927 block_t
*blkaddr
, int *do_replace
,
928 pgoff_t src
, pgoff_t dst
, pgoff_t len
, bool full
)
930 struct f2fs_sb_info
*sbi
= F2FS_I_SB(src_inode
);
935 if (blkaddr
[i
] == NULL_ADDR
&& !full
) {
940 if (do_replace
[i
] || blkaddr
[i
] == NULL_ADDR
) {
941 struct dnode_of_data dn
;
946 set_new_dnode(&dn
, dst_inode
, NULL
, NULL
, 0);
947 ret
= get_dnode_of_data(&dn
, dst
+ i
, ALLOC_NODE
);
951 get_node_info(sbi
, dn
.nid
, &ni
);
953 ADDRS_PER_PAGE(dn
.node_page
, dst_inode
) -
954 dn
.ofs_in_node
, len
- i
);
956 dn
.data_blkaddr
= datablock_addr(dn
.node_page
,
958 truncate_data_blocks_range(&dn
, 1);
961 f2fs_i_blocks_write(src_inode
,
963 f2fs_i_blocks_write(dst_inode
,
965 f2fs_replace_block(sbi
, &dn
, dn
.data_blkaddr
,
966 blkaddr
[i
], ni
.version
, true, false);
972 new_size
= (dst
+ i
) << PAGE_SHIFT
;
973 if (dst_inode
->i_size
< new_size
)
974 f2fs_i_size_write(dst_inode
, new_size
);
975 } while ((do_replace
[i
] || blkaddr
[i
] == NULL_ADDR
) && --ilen
);
979 struct page
*psrc
, *pdst
;
981 psrc
= get_lock_data_page(src_inode
, src
+ i
, true);
983 return PTR_ERR(psrc
);
984 pdst
= get_new_data_page(dst_inode
, NULL
, dst
+ i
,
987 f2fs_put_page(psrc
, 1);
988 return PTR_ERR(pdst
);
990 f2fs_copy_page(psrc
, pdst
);
991 set_page_dirty(pdst
);
992 f2fs_put_page(pdst
, 1);
993 f2fs_put_page(psrc
, 1);
995 ret
= truncate_hole(src_inode
, src
+ i
, src
+ i
+ 1);
1004 static int __exchange_data_block(struct inode
*src_inode
,
1005 struct inode
*dst_inode
, pgoff_t src
, pgoff_t dst
,
1006 pgoff_t len
, bool full
)
1008 block_t
*src_blkaddr
;
1014 olen
= min((pgoff_t
)4 * ADDRS_PER_BLOCK
, len
);
1016 src_blkaddr
= f2fs_kvzalloc(sizeof(block_t
) * olen
, GFP_KERNEL
);
1020 do_replace
= f2fs_kvzalloc(sizeof(int) * olen
, GFP_KERNEL
);
1022 kvfree(src_blkaddr
);
1026 ret
= __read_out_blkaddrs(src_inode
, src_blkaddr
,
1027 do_replace
, src
, olen
);
1031 ret
= __clone_blkaddrs(src_inode
, dst_inode
, src_blkaddr
,
1032 do_replace
, src
, dst
, olen
, full
);
1040 kvfree(src_blkaddr
);
1046 __roll_back_blkaddrs(src_inode
, src_blkaddr
, do_replace
, src
, len
);
1047 kvfree(src_blkaddr
);
1052 static int f2fs_do_collapse(struct inode
*inode
, pgoff_t start
, pgoff_t end
)
1054 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
1055 pgoff_t nrpages
= (i_size_read(inode
) + PAGE_SIZE
- 1) / PAGE_SIZE
;
1058 f2fs_balance_fs(sbi
, true);
1061 f2fs_drop_extent_tree(inode
);
1063 ret
= __exchange_data_block(inode
, inode
, end
, start
, nrpages
- end
, true);
1064 f2fs_unlock_op(sbi
);
1068 static int f2fs_collapse_range(struct inode
*inode
, loff_t offset
, loff_t len
)
1070 pgoff_t pg_start
, pg_end
;
1074 if (offset
+ len
>= i_size_read(inode
))
1077 /* collapse range should be aligned to block size of f2fs. */
1078 if (offset
& (F2FS_BLKSIZE
- 1) || len
& (F2FS_BLKSIZE
- 1))
1081 ret
= f2fs_convert_inline_inode(inode
);
1085 pg_start
= offset
>> PAGE_SHIFT
;
1086 pg_end
= (offset
+ len
) >> PAGE_SHIFT
;
1088 /* write out all dirty pages from offset */
1089 ret
= filemap_write_and_wait_range(inode
->i_mapping
, offset
, LLONG_MAX
);
1093 truncate_pagecache(inode
, offset
);
1095 ret
= f2fs_do_collapse(inode
, pg_start
, pg_end
);
1099 /* write out all moved pages, if possible */
1100 filemap_write_and_wait_range(inode
->i_mapping
, offset
, LLONG_MAX
);
1101 truncate_pagecache(inode
, offset
);
1103 new_size
= i_size_read(inode
) - len
;
1104 truncate_pagecache(inode
, new_size
);
1106 ret
= truncate_blocks(inode
, new_size
, true);
1108 f2fs_i_size_write(inode
, new_size
);
1113 static int f2fs_do_zero_range(struct dnode_of_data
*dn
, pgoff_t start
,
1116 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dn
->inode
);
1117 pgoff_t index
= start
;
1118 unsigned int ofs_in_node
= dn
->ofs_in_node
;
1122 for (; index
< end
; index
++, dn
->ofs_in_node
++) {
1123 if (datablock_addr(dn
->node_page
, dn
->ofs_in_node
) == NULL_ADDR
)
1127 dn
->ofs_in_node
= ofs_in_node
;
1128 ret
= reserve_new_blocks(dn
, count
);
1132 dn
->ofs_in_node
= ofs_in_node
;
1133 for (index
= start
; index
< end
; index
++, dn
->ofs_in_node
++) {
1135 datablock_addr(dn
->node_page
, dn
->ofs_in_node
);
1137 * reserve_new_blocks will not guarantee entire block
1140 if (dn
->data_blkaddr
== NULL_ADDR
) {
1144 if (dn
->data_blkaddr
!= NEW_ADDR
) {
1145 invalidate_blocks(sbi
, dn
->data_blkaddr
);
1146 dn
->data_blkaddr
= NEW_ADDR
;
1147 set_data_blkaddr(dn
);
1151 f2fs_update_extent_cache_range(dn
, start
, 0, index
- start
);
1156 static int f2fs_zero_range(struct inode
*inode
, loff_t offset
, loff_t len
,
1159 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
1160 struct address_space
*mapping
= inode
->i_mapping
;
1161 pgoff_t index
, pg_start
, pg_end
;
1162 loff_t new_size
= i_size_read(inode
);
1163 loff_t off_start
, off_end
;
1166 ret
= inode_newsize_ok(inode
, (len
+ offset
));
1170 ret
= f2fs_convert_inline_inode(inode
);
1174 ret
= filemap_write_and_wait_range(mapping
, offset
, offset
+ len
- 1);
1178 truncate_pagecache_range(inode
, offset
, offset
+ len
- 1);
1180 pg_start
= ((unsigned long long) offset
) >> PAGE_SHIFT
;
1181 pg_end
= ((unsigned long long) offset
+ len
) >> PAGE_SHIFT
;
1183 off_start
= offset
& (PAGE_SIZE
- 1);
1184 off_end
= (offset
+ len
) & (PAGE_SIZE
- 1);
1186 if (pg_start
== pg_end
) {
1187 ret
= fill_zero(inode
, pg_start
, off_start
,
1188 off_end
- off_start
);
1192 if (offset
+ len
> new_size
)
1193 new_size
= offset
+ len
;
1194 new_size
= max_t(loff_t
, new_size
, offset
+ len
);
1197 ret
= fill_zero(inode
, pg_start
++, off_start
,
1198 PAGE_SIZE
- off_start
);
1202 new_size
= max_t(loff_t
, new_size
,
1203 (loff_t
)pg_start
<< PAGE_SHIFT
);
1206 for (index
= pg_start
; index
< pg_end
;) {
1207 struct dnode_of_data dn
;
1208 unsigned int end_offset
;
1213 set_new_dnode(&dn
, inode
, NULL
, NULL
, 0);
1214 ret
= get_dnode_of_data(&dn
, index
, ALLOC_NODE
);
1216 f2fs_unlock_op(sbi
);
1220 end_offset
= ADDRS_PER_PAGE(dn
.node_page
, inode
);
1221 end
= min(pg_end
, end_offset
- dn
.ofs_in_node
+ index
);
1223 ret
= f2fs_do_zero_range(&dn
, index
, end
);
1224 f2fs_put_dnode(&dn
);
1225 f2fs_unlock_op(sbi
);
1230 new_size
= max_t(loff_t
, new_size
,
1231 (loff_t
)index
<< PAGE_SHIFT
);
1235 ret
= fill_zero(inode
, pg_end
, 0, off_end
);
1239 new_size
= max_t(loff_t
, new_size
, offset
+ len
);
1244 if (!(mode
& FALLOC_FL_KEEP_SIZE
) && i_size_read(inode
) < new_size
)
1245 f2fs_i_size_write(inode
, new_size
);
1250 static int f2fs_insert_range(struct inode
*inode
, loff_t offset
, loff_t len
)
1252 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
1253 pgoff_t nr
, pg_start
, pg_end
, delta
, idx
;
1257 new_size
= i_size_read(inode
) + len
;
1258 if (new_size
> inode
->i_sb
->s_maxbytes
)
1261 if (offset
>= i_size_read(inode
))
1264 /* insert range should be aligned to block size of f2fs. */
1265 if (offset
& (F2FS_BLKSIZE
- 1) || len
& (F2FS_BLKSIZE
- 1))
1268 ret
= f2fs_convert_inline_inode(inode
);
1272 f2fs_balance_fs(sbi
, true);
1274 ret
= truncate_blocks(inode
, i_size_read(inode
), true);
1278 /* write out all dirty pages from offset */
1279 ret
= filemap_write_and_wait_range(inode
->i_mapping
, offset
, LLONG_MAX
);
1283 truncate_pagecache(inode
, offset
);
1285 pg_start
= offset
>> PAGE_SHIFT
;
1286 pg_end
= (offset
+ len
) >> PAGE_SHIFT
;
1287 delta
= pg_end
- pg_start
;
1288 idx
= (i_size_read(inode
) + PAGE_SIZE
- 1) / PAGE_SIZE
;
1290 while (!ret
&& idx
> pg_start
) {
1291 nr
= idx
- pg_start
;
1297 f2fs_drop_extent_tree(inode
);
1299 ret
= __exchange_data_block(inode
, inode
, idx
,
1300 idx
+ delta
, nr
, false);
1301 f2fs_unlock_op(sbi
);
1304 /* write out all moved pages, if possible */
1305 filemap_write_and_wait_range(inode
->i_mapping
, offset
, LLONG_MAX
);
1306 truncate_pagecache(inode
, offset
);
1309 f2fs_i_size_write(inode
, new_size
);
1313 static int expand_inode_data(struct inode
*inode
, loff_t offset
,
1314 loff_t len
, int mode
)
1316 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
1317 struct f2fs_map_blocks map
= { .m_next_pgofs
= NULL
};
1319 loff_t new_size
= i_size_read(inode
);
1323 ret
= inode_newsize_ok(inode
, (len
+ offset
));
1327 ret
= f2fs_convert_inline_inode(inode
);
1331 f2fs_balance_fs(sbi
, true);
1333 pg_end
= ((unsigned long long)offset
+ len
) >> PAGE_SHIFT
;
1334 off_end
= (offset
+ len
) & (PAGE_SIZE
- 1);
1336 map
.m_lblk
= ((unsigned long long)offset
) >> PAGE_SHIFT
;
1337 map
.m_len
= pg_end
- map
.m_lblk
;
1341 ret
= f2fs_map_blocks(inode
, &map
, 1, F2FS_GET_BLOCK_PRE_AIO
);
1348 last_off
= map
.m_lblk
+ map
.m_len
- 1;
1350 /* update new size to the failed position */
1351 new_size
= (last_off
== pg_end
) ? offset
+ len
:
1352 (loff_t
)(last_off
+ 1) << PAGE_SHIFT
;
1354 new_size
= ((loff_t
)pg_end
<< PAGE_SHIFT
) + off_end
;
1357 if (!(mode
& FALLOC_FL_KEEP_SIZE
) && i_size_read(inode
) < new_size
)
1358 f2fs_i_size_write(inode
, new_size
);
1363 static long f2fs_fallocate(struct file
*file
, int mode
,
1364 loff_t offset
, loff_t len
)
1366 struct inode
*inode
= file_inode(file
);
1369 /* f2fs only support ->fallocate for regular file */
1370 if (!S_ISREG(inode
->i_mode
))
1373 if (f2fs_encrypted_inode(inode
) &&
1374 (mode
& (FALLOC_FL_COLLAPSE_RANGE
| FALLOC_FL_INSERT_RANGE
)))
1377 if (mode
& ~(FALLOC_FL_KEEP_SIZE
| FALLOC_FL_PUNCH_HOLE
|
1378 FALLOC_FL_COLLAPSE_RANGE
| FALLOC_FL_ZERO_RANGE
|
1379 FALLOC_FL_INSERT_RANGE
))
1384 if (mode
& FALLOC_FL_PUNCH_HOLE
) {
1385 if (offset
>= inode
->i_size
)
1388 ret
= punch_hole(inode
, offset
, len
);
1389 } else if (mode
& FALLOC_FL_COLLAPSE_RANGE
) {
1390 ret
= f2fs_collapse_range(inode
, offset
, len
);
1391 } else if (mode
& FALLOC_FL_ZERO_RANGE
) {
1392 ret
= f2fs_zero_range(inode
, offset
, len
, mode
);
1393 } else if (mode
& FALLOC_FL_INSERT_RANGE
) {
1394 ret
= f2fs_insert_range(inode
, offset
, len
);
1396 ret
= expand_inode_data(inode
, offset
, len
, mode
);
1400 inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
1401 f2fs_mark_inode_dirty_sync(inode
);
1402 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
1406 inode_unlock(inode
);
1408 trace_f2fs_fallocate(inode
, mode
, offset
, len
, ret
);
1412 static int f2fs_release_file(struct inode
*inode
, struct file
*filp
)
1415 * f2fs_relase_file is called at every close calls. So we should
1416 * not drop any inmemory pages by close called by other process.
1418 if (!(filp
->f_mode
& FMODE_WRITE
) ||
1419 atomic_read(&inode
->i_writecount
) != 1)
1422 /* some remained atomic pages should discarded */
1423 if (f2fs_is_atomic_file(inode
))
1424 drop_inmem_pages(inode
);
1425 if (f2fs_is_volatile_file(inode
)) {
1426 clear_inode_flag(inode
, FI_VOLATILE_FILE
);
1427 set_inode_flag(inode
, FI_DROP_CACHE
);
1428 filemap_fdatawrite(inode
->i_mapping
);
1429 clear_inode_flag(inode
, FI_DROP_CACHE
);
1434 #define F2FS_REG_FLMASK (~(FS_DIRSYNC_FL | FS_TOPDIR_FL))
1435 #define F2FS_OTHER_FLMASK (FS_NODUMP_FL | FS_NOATIME_FL)
1437 static inline __u32
f2fs_mask_flags(umode_t mode
, __u32 flags
)
1441 else if (S_ISREG(mode
))
1442 return flags
& F2FS_REG_FLMASK
;
1444 return flags
& F2FS_OTHER_FLMASK
;
1447 static int f2fs_ioc_getflags(struct file
*filp
, unsigned long arg
)
1449 struct inode
*inode
= file_inode(filp
);
1450 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
1451 unsigned int flags
= fi
->i_flags
& FS_FL_USER_VISIBLE
;
1452 return put_user(flags
, (int __user
*)arg
);
1455 static int f2fs_ioc_setflags(struct file
*filp
, unsigned long arg
)
1457 struct inode
*inode
= file_inode(filp
);
1458 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
1460 unsigned int oldflags
;
1463 if (!inode_owner_or_capable(inode
))
1466 if (get_user(flags
, (int __user
*)arg
))
1469 ret
= mnt_want_write_file(filp
);
1473 flags
= f2fs_mask_flags(inode
->i_mode
, flags
);
1477 oldflags
= fi
->i_flags
;
1479 if ((flags
^ oldflags
) & (FS_APPEND_FL
| FS_IMMUTABLE_FL
)) {
1480 if (!capable(CAP_LINUX_IMMUTABLE
)) {
1481 inode_unlock(inode
);
1487 flags
= flags
& FS_FL_USER_MODIFIABLE
;
1488 flags
|= oldflags
& ~FS_FL_USER_MODIFIABLE
;
1489 fi
->i_flags
= flags
;
1490 inode_unlock(inode
);
1492 inode
->i_ctime
= CURRENT_TIME
;
1493 f2fs_set_inode_flags(inode
);
1495 mnt_drop_write_file(filp
);
1499 static int f2fs_ioc_getversion(struct file
*filp
, unsigned long arg
)
1501 struct inode
*inode
= file_inode(filp
);
1503 return put_user(inode
->i_generation
, (int __user
*)arg
);
1506 static int f2fs_ioc_start_atomic_write(struct file
*filp
)
1508 struct inode
*inode
= file_inode(filp
);
1511 if (!inode_owner_or_capable(inode
))
1514 ret
= mnt_want_write_file(filp
);
1520 if (f2fs_is_atomic_file(inode
))
1523 ret
= f2fs_convert_inline_inode(inode
);
1527 set_inode_flag(inode
, FI_ATOMIC_FILE
);
1528 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
1530 if (!get_dirty_pages(inode
))
1533 f2fs_msg(F2FS_I_SB(inode
)->sb
, KERN_WARNING
,
1534 "Unexpected flush for atomic writes: ino=%lu, npages=%lld",
1535 inode
->i_ino
, get_dirty_pages(inode
));
1536 ret
= filemap_write_and_wait_range(inode
->i_mapping
, 0, LLONG_MAX
);
1538 clear_inode_flag(inode
, FI_ATOMIC_FILE
);
1540 inode_unlock(inode
);
1541 mnt_drop_write_file(filp
);
1545 static int f2fs_ioc_commit_atomic_write(struct file
*filp
)
1547 struct inode
*inode
= file_inode(filp
);
1550 if (!inode_owner_or_capable(inode
))
1553 ret
= mnt_want_write_file(filp
);
1559 if (f2fs_is_volatile_file(inode
))
1562 if (f2fs_is_atomic_file(inode
)) {
1563 clear_inode_flag(inode
, FI_ATOMIC_FILE
);
1564 ret
= commit_inmem_pages(inode
);
1566 set_inode_flag(inode
, FI_ATOMIC_FILE
);
1571 ret
= f2fs_do_sync_file(filp
, 0, LLONG_MAX
, 0, true);
1573 inode_unlock(inode
);
1574 mnt_drop_write_file(filp
);
1578 static int f2fs_ioc_start_volatile_write(struct file
*filp
)
1580 struct inode
*inode
= file_inode(filp
);
1583 if (!inode_owner_or_capable(inode
))
1586 ret
= mnt_want_write_file(filp
);
1592 if (f2fs_is_volatile_file(inode
))
1595 ret
= f2fs_convert_inline_inode(inode
);
1599 set_inode_flag(inode
, FI_VOLATILE_FILE
);
1600 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
1602 inode_unlock(inode
);
1603 mnt_drop_write_file(filp
);
1607 static int f2fs_ioc_release_volatile_write(struct file
*filp
)
1609 struct inode
*inode
= file_inode(filp
);
1612 if (!inode_owner_or_capable(inode
))
1615 ret
= mnt_want_write_file(filp
);
1621 if (!f2fs_is_volatile_file(inode
))
1624 if (!f2fs_is_first_block_written(inode
)) {
1625 ret
= truncate_partial_data_page(inode
, 0, true);
1629 ret
= punch_hole(inode
, 0, F2FS_BLKSIZE
);
1631 inode_unlock(inode
);
1632 mnt_drop_write_file(filp
);
1636 static int f2fs_ioc_abort_volatile_write(struct file
*filp
)
1638 struct inode
*inode
= file_inode(filp
);
1641 if (!inode_owner_or_capable(inode
))
1644 ret
= mnt_want_write_file(filp
);
1650 if (f2fs_is_atomic_file(inode
))
1651 drop_inmem_pages(inode
);
1652 if (f2fs_is_volatile_file(inode
)) {
1653 clear_inode_flag(inode
, FI_VOLATILE_FILE
);
1654 ret
= f2fs_do_sync_file(filp
, 0, LLONG_MAX
, 0, true);
1657 inode_unlock(inode
);
1659 mnt_drop_write_file(filp
);
1660 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
1664 static int f2fs_ioc_shutdown(struct file
*filp
, unsigned long arg
)
1666 struct inode
*inode
= file_inode(filp
);
1667 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
1668 struct super_block
*sb
= sbi
->sb
;
1672 if (!capable(CAP_SYS_ADMIN
))
1675 if (get_user(in
, (__u32 __user
*)arg
))
1678 ret
= mnt_want_write_file(filp
);
1683 case F2FS_GOING_DOWN_FULLSYNC
:
1684 sb
= freeze_bdev(sb
->s_bdev
);
1685 if (sb
&& !IS_ERR(sb
)) {
1686 f2fs_stop_checkpoint(sbi
, false);
1687 thaw_bdev(sb
->s_bdev
, sb
);
1690 case F2FS_GOING_DOWN_METASYNC
:
1691 /* do checkpoint only */
1692 f2fs_sync_fs(sb
, 1);
1693 f2fs_stop_checkpoint(sbi
, false);
1695 case F2FS_GOING_DOWN_NOSYNC
:
1696 f2fs_stop_checkpoint(sbi
, false);
1698 case F2FS_GOING_DOWN_METAFLUSH
:
1699 sync_meta_pages(sbi
, META
, LONG_MAX
);
1700 f2fs_stop_checkpoint(sbi
, false);
1706 f2fs_update_time(sbi
, REQ_TIME
);
1708 mnt_drop_write_file(filp
);
1712 static int f2fs_ioc_fitrim(struct file
*filp
, unsigned long arg
)
1714 struct inode
*inode
= file_inode(filp
);
1715 struct super_block
*sb
= inode
->i_sb
;
1716 struct request_queue
*q
= bdev_get_queue(sb
->s_bdev
);
1717 struct fstrim_range range
;
1720 if (!capable(CAP_SYS_ADMIN
))
1723 if (!blk_queue_discard(q
))
1726 if (copy_from_user(&range
, (struct fstrim_range __user
*)arg
,
1730 ret
= mnt_want_write_file(filp
);
1734 range
.minlen
= max((unsigned int)range
.minlen
,
1735 q
->limits
.discard_granularity
);
1736 ret
= f2fs_trim_fs(F2FS_SB(sb
), &range
);
1737 mnt_drop_write_file(filp
);
1741 if (copy_to_user((struct fstrim_range __user
*)arg
, &range
,
1744 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
1748 static bool uuid_is_nonzero(__u8 u
[16])
1752 for (i
= 0; i
< 16; i
++)
1758 static int f2fs_ioc_set_encryption_policy(struct file
*filp
, unsigned long arg
)
1760 struct fscrypt_policy policy
;
1761 struct inode
*inode
= file_inode(filp
);
1764 if (copy_from_user(&policy
, (struct fscrypt_policy __user
*)arg
,
1768 ret
= mnt_want_write_file(filp
);
1772 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
1773 ret
= fscrypt_process_policy(inode
, &policy
);
1775 mnt_drop_write_file(filp
);
1779 static int f2fs_ioc_get_encryption_policy(struct file
*filp
, unsigned long arg
)
1781 struct fscrypt_policy policy
;
1782 struct inode
*inode
= file_inode(filp
);
1785 err
= fscrypt_get_policy(inode
, &policy
);
1789 if (copy_to_user((struct fscrypt_policy __user
*)arg
, &policy
, sizeof(policy
)))
1794 static int f2fs_ioc_get_encryption_pwsalt(struct file
*filp
, unsigned long arg
)
1796 struct inode
*inode
= file_inode(filp
);
1797 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
1800 if (!f2fs_sb_has_crypto(inode
->i_sb
))
1803 if (uuid_is_nonzero(sbi
->raw_super
->encrypt_pw_salt
))
1806 err
= mnt_want_write_file(filp
);
1810 /* update superblock with uuid */
1811 generate_random_uuid(sbi
->raw_super
->encrypt_pw_salt
);
1813 err
= f2fs_commit_super(sbi
, false);
1816 memset(sbi
->raw_super
->encrypt_pw_salt
, 0, 16);
1817 mnt_drop_write_file(filp
);
1820 mnt_drop_write_file(filp
);
1822 if (copy_to_user((__u8 __user
*)arg
, sbi
->raw_super
->encrypt_pw_salt
,
1828 static int f2fs_ioc_gc(struct file
*filp
, unsigned long arg
)
1830 struct inode
*inode
= file_inode(filp
);
1831 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
1835 if (!capable(CAP_SYS_ADMIN
))
1838 if (get_user(sync
, (__u32 __user
*)arg
))
1841 if (f2fs_readonly(sbi
->sb
))
1844 ret
= mnt_want_write_file(filp
);
1849 if (!mutex_trylock(&sbi
->gc_mutex
)) {
1854 mutex_lock(&sbi
->gc_mutex
);
1857 ret
= f2fs_gc(sbi
, sync
);
1859 mnt_drop_write_file(filp
);
1863 static int f2fs_ioc_write_checkpoint(struct file
*filp
, unsigned long arg
)
1865 struct inode
*inode
= file_inode(filp
);
1866 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
1869 if (!capable(CAP_SYS_ADMIN
))
1872 if (f2fs_readonly(sbi
->sb
))
1875 ret
= mnt_want_write_file(filp
);
1879 ret
= f2fs_sync_fs(sbi
->sb
, 1);
1881 mnt_drop_write_file(filp
);
1885 static int f2fs_defragment_range(struct f2fs_sb_info
*sbi
,
1887 struct f2fs_defragment
*range
)
1889 struct inode
*inode
= file_inode(filp
);
1890 struct f2fs_map_blocks map
= { .m_next_pgofs
= NULL
};
1891 struct extent_info ei
;
1892 pgoff_t pg_start
, pg_end
;
1893 unsigned int blk_per_seg
= sbi
->blocks_per_seg
;
1894 unsigned int total
= 0, sec_num
;
1895 unsigned int pages_per_sec
= sbi
->segs_per_sec
* blk_per_seg
;
1896 block_t blk_end
= 0;
1897 bool fragmented
= false;
1900 /* if in-place-update policy is enabled, don't waste time here */
1901 if (need_inplace_update(inode
))
1904 pg_start
= range
->start
>> PAGE_SHIFT
;
1905 pg_end
= (range
->start
+ range
->len
) >> PAGE_SHIFT
;
1907 f2fs_balance_fs(sbi
, true);
1911 /* writeback all dirty pages in the range */
1912 err
= filemap_write_and_wait_range(inode
->i_mapping
, range
->start
,
1913 range
->start
+ range
->len
- 1);
1918 * lookup mapping info in extent cache, skip defragmenting if physical
1919 * block addresses are continuous.
1921 if (f2fs_lookup_extent_cache(inode
, pg_start
, &ei
)) {
1922 if (ei
.fofs
+ ei
.len
>= pg_end
)
1926 map
.m_lblk
= pg_start
;
1929 * lookup mapping info in dnode page cache, skip defragmenting if all
1930 * physical block addresses are continuous even if there are hole(s)
1931 * in logical blocks.
1933 while (map
.m_lblk
< pg_end
) {
1934 map
.m_len
= pg_end
- map
.m_lblk
;
1935 err
= f2fs_map_blocks(inode
, &map
, 0, F2FS_GET_BLOCK_READ
);
1939 if (!(map
.m_flags
& F2FS_MAP_FLAGS
)) {
1944 if (blk_end
&& blk_end
!= map
.m_pblk
) {
1948 blk_end
= map
.m_pblk
+ map
.m_len
;
1950 map
.m_lblk
+= map
.m_len
;
1956 map
.m_lblk
= pg_start
;
1957 map
.m_len
= pg_end
- pg_start
;
1959 sec_num
= (map
.m_len
+ pages_per_sec
- 1) / pages_per_sec
;
1962 * make sure there are enough free section for LFS allocation, this can
1963 * avoid defragment running in SSR mode when free section are allocated
1966 if (has_not_enough_free_secs(sbi
, sec_num
)) {
1971 while (map
.m_lblk
< pg_end
) {
1976 map
.m_len
= pg_end
- map
.m_lblk
;
1977 err
= f2fs_map_blocks(inode
, &map
, 0, F2FS_GET_BLOCK_READ
);
1981 if (!(map
.m_flags
& F2FS_MAP_FLAGS
)) {
1986 set_inode_flag(inode
, FI_DO_DEFRAG
);
1989 while (idx
< map
.m_lblk
+ map
.m_len
&& cnt
< blk_per_seg
) {
1992 page
= get_lock_data_page(inode
, idx
, true);
1994 err
= PTR_ERR(page
);
1998 set_page_dirty(page
);
1999 f2fs_put_page(page
, 1);
2008 if (idx
< pg_end
&& cnt
< blk_per_seg
)
2011 clear_inode_flag(inode
, FI_DO_DEFRAG
);
2013 err
= filemap_fdatawrite(inode
->i_mapping
);
2018 clear_inode_flag(inode
, FI_DO_DEFRAG
);
2020 inode_unlock(inode
);
2022 range
->len
= (u64
)total
<< PAGE_SHIFT
;
2026 static int f2fs_ioc_defragment(struct file
*filp
, unsigned long arg
)
2028 struct inode
*inode
= file_inode(filp
);
2029 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
2030 struct f2fs_defragment range
;
2033 if (!capable(CAP_SYS_ADMIN
))
2036 if (!S_ISREG(inode
->i_mode
))
2039 err
= mnt_want_write_file(filp
);
2043 if (f2fs_readonly(sbi
->sb
)) {
2048 if (copy_from_user(&range
, (struct f2fs_defragment __user
*)arg
,
2054 /* verify alignment of offset & size */
2055 if (range
.start
& (F2FS_BLKSIZE
- 1) ||
2056 range
.len
& (F2FS_BLKSIZE
- 1)) {
2061 err
= f2fs_defragment_range(sbi
, filp
, &range
);
2062 f2fs_update_time(sbi
, REQ_TIME
);
2066 if (copy_to_user((struct f2fs_defragment __user
*)arg
, &range
,
2070 mnt_drop_write_file(filp
);
2074 static int f2fs_move_file_range(struct file
*file_in
, loff_t pos_in
,
2075 struct file
*file_out
, loff_t pos_out
, size_t len
)
2077 struct inode
*src
= file_inode(file_in
);
2078 struct inode
*dst
= file_inode(file_out
);
2079 struct f2fs_sb_info
*sbi
= F2FS_I_SB(src
);
2080 size_t olen
= len
, dst_max_i_size
= 0;
2084 if (file_in
->f_path
.mnt
!= file_out
->f_path
.mnt
||
2085 src
->i_sb
!= dst
->i_sb
)
2088 if (unlikely(f2fs_readonly(src
->i_sb
)))
2091 if (!S_ISREG(src
->i_mode
) || !S_ISREG(dst
->i_mode
))
2094 if (f2fs_encrypted_inode(src
) || f2fs_encrypted_inode(dst
))
2099 if (!inode_trylock(dst
)) {
2106 if (pos_in
+ len
> src
->i_size
|| pos_in
+ len
< pos_in
)
2109 olen
= len
= src
->i_size
- pos_in
;
2110 if (pos_in
+ len
== src
->i_size
)
2111 len
= ALIGN(src
->i_size
, F2FS_BLKSIZE
) - pos_in
;
2117 dst_osize
= dst
->i_size
;
2118 if (pos_out
+ olen
> dst
->i_size
)
2119 dst_max_i_size
= pos_out
+ olen
;
2121 /* verify the end result is block aligned */
2122 if (!IS_ALIGNED(pos_in
, F2FS_BLKSIZE
) ||
2123 !IS_ALIGNED(pos_in
+ len
, F2FS_BLKSIZE
) ||
2124 !IS_ALIGNED(pos_out
, F2FS_BLKSIZE
))
2127 ret
= f2fs_convert_inline_inode(src
);
2131 ret
= f2fs_convert_inline_inode(dst
);
2135 /* write out all dirty pages from offset */
2136 ret
= filemap_write_and_wait_range(src
->i_mapping
,
2137 pos_in
, pos_in
+ len
);
2141 ret
= filemap_write_and_wait_range(dst
->i_mapping
,
2142 pos_out
, pos_out
+ len
);
2146 f2fs_balance_fs(sbi
, true);
2148 ret
= __exchange_data_block(src
, dst
, pos_in
,
2149 pos_out
, len
>> F2FS_BLKSIZE_BITS
, false);
2153 f2fs_i_size_write(dst
, dst_max_i_size
);
2154 else if (dst_osize
!= dst
->i_size
)
2155 f2fs_i_size_write(dst
, dst_osize
);
2157 f2fs_unlock_op(sbi
);
2166 static int f2fs_ioc_move_range(struct file
*filp
, unsigned long arg
)
2168 struct f2fs_move_range range
;
2172 if (!(filp
->f_mode
& FMODE_READ
) ||
2173 !(filp
->f_mode
& FMODE_WRITE
))
2176 if (copy_from_user(&range
, (struct f2fs_move_range __user
*)arg
,
2180 dst
= fdget(range
.dst_fd
);
2184 if (!(dst
.file
->f_mode
& FMODE_WRITE
)) {
2189 err
= mnt_want_write_file(filp
);
2193 err
= f2fs_move_file_range(filp
, range
.pos_in
, dst
.file
,
2194 range
.pos_out
, range
.len
);
2196 mnt_drop_write_file(filp
);
2198 if (copy_to_user((struct f2fs_move_range __user
*)arg
,
2199 &range
, sizeof(range
)))
2206 long f2fs_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
2209 case F2FS_IOC_GETFLAGS
:
2210 return f2fs_ioc_getflags(filp
, arg
);
2211 case F2FS_IOC_SETFLAGS
:
2212 return f2fs_ioc_setflags(filp
, arg
);
2213 case F2FS_IOC_GETVERSION
:
2214 return f2fs_ioc_getversion(filp
, arg
);
2215 case F2FS_IOC_START_ATOMIC_WRITE
:
2216 return f2fs_ioc_start_atomic_write(filp
);
2217 case F2FS_IOC_COMMIT_ATOMIC_WRITE
:
2218 return f2fs_ioc_commit_atomic_write(filp
);
2219 case F2FS_IOC_START_VOLATILE_WRITE
:
2220 return f2fs_ioc_start_volatile_write(filp
);
2221 case F2FS_IOC_RELEASE_VOLATILE_WRITE
:
2222 return f2fs_ioc_release_volatile_write(filp
);
2223 case F2FS_IOC_ABORT_VOLATILE_WRITE
:
2224 return f2fs_ioc_abort_volatile_write(filp
);
2225 case F2FS_IOC_SHUTDOWN
:
2226 return f2fs_ioc_shutdown(filp
, arg
);
2228 return f2fs_ioc_fitrim(filp
, arg
);
2229 case F2FS_IOC_SET_ENCRYPTION_POLICY
:
2230 return f2fs_ioc_set_encryption_policy(filp
, arg
);
2231 case F2FS_IOC_GET_ENCRYPTION_POLICY
:
2232 return f2fs_ioc_get_encryption_policy(filp
, arg
);
2233 case F2FS_IOC_GET_ENCRYPTION_PWSALT
:
2234 return f2fs_ioc_get_encryption_pwsalt(filp
, arg
);
2235 case F2FS_IOC_GARBAGE_COLLECT
:
2236 return f2fs_ioc_gc(filp
, arg
);
2237 case F2FS_IOC_WRITE_CHECKPOINT
:
2238 return f2fs_ioc_write_checkpoint(filp
, arg
);
2239 case F2FS_IOC_DEFRAGMENT
:
2240 return f2fs_ioc_defragment(filp
, arg
);
2241 case F2FS_IOC_MOVE_RANGE
:
2242 return f2fs_ioc_move_range(filp
, arg
);
2248 static ssize_t
f2fs_file_write_iter(struct kiocb
*iocb
, struct iov_iter
*from
)
2250 struct file
*file
= iocb
->ki_filp
;
2251 struct inode
*inode
= file_inode(file
);
2252 struct blk_plug plug
;
2255 if (f2fs_encrypted_inode(inode
) &&
2256 !fscrypt_has_encryption_key(inode
) &&
2257 fscrypt_get_encryption_info(inode
))
2261 ret
= generic_write_checks(iocb
, from
);
2263 ret
= f2fs_preallocate_blocks(iocb
, from
);
2265 blk_start_plug(&plug
);
2266 ret
= __generic_file_write_iter(iocb
, from
);
2267 blk_finish_plug(&plug
);
2270 inode_unlock(inode
);
2273 ret
= generic_write_sync(iocb
, ret
);
2277 #ifdef CONFIG_COMPAT
2278 long f2fs_compat_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
2281 case F2FS_IOC32_GETFLAGS
:
2282 cmd
= F2FS_IOC_GETFLAGS
;
2284 case F2FS_IOC32_SETFLAGS
:
2285 cmd
= F2FS_IOC_SETFLAGS
;
2287 case F2FS_IOC32_GETVERSION
:
2288 cmd
= F2FS_IOC_GETVERSION
;
2290 case F2FS_IOC_START_ATOMIC_WRITE
:
2291 case F2FS_IOC_COMMIT_ATOMIC_WRITE
:
2292 case F2FS_IOC_START_VOLATILE_WRITE
:
2293 case F2FS_IOC_RELEASE_VOLATILE_WRITE
:
2294 case F2FS_IOC_ABORT_VOLATILE_WRITE
:
2295 case F2FS_IOC_SHUTDOWN
:
2296 case F2FS_IOC_SET_ENCRYPTION_POLICY
:
2297 case F2FS_IOC_GET_ENCRYPTION_PWSALT
:
2298 case F2FS_IOC_GET_ENCRYPTION_POLICY
:
2299 case F2FS_IOC_GARBAGE_COLLECT
:
2300 case F2FS_IOC_WRITE_CHECKPOINT
:
2301 case F2FS_IOC_DEFRAGMENT
:
2303 case F2FS_IOC_MOVE_RANGE
:
2306 return -ENOIOCTLCMD
;
2308 return f2fs_ioctl(file
, cmd
, (unsigned long) compat_ptr(arg
));
2312 const struct file_operations f2fs_file_operations
= {
2313 .llseek
= f2fs_llseek
,
2314 .read_iter
= generic_file_read_iter
,
2315 .write_iter
= f2fs_file_write_iter
,
2316 .open
= f2fs_file_open
,
2317 .release
= f2fs_release_file
,
2318 .mmap
= f2fs_file_mmap
,
2319 .fsync
= f2fs_sync_file
,
2320 .fallocate
= f2fs_fallocate
,
2321 .unlocked_ioctl
= f2fs_ioctl
,
2322 #ifdef CONFIG_COMPAT
2323 .compat_ioctl
= f2fs_compat_ioctl
,
2325 .splice_read
= generic_file_splice_read
,
2326 .splice_write
= iter_file_splice_write
,