1 // SPDX-License-Identifier: GPL-2.0
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
9 #include <linux/f2fs_fs.h>
10 #include <linux/stat.h>
11 #include <linux/buffer_head.h>
12 #include <linux/writeback.h>
13 #include <linux/blkdev.h>
14 #include <linux/falloc.h>
15 #include <linux/types.h>
16 #include <linux/compat.h>
17 #include <linux/uaccess.h>
18 #include <linux/mount.h>
19 #include <linux/pagevec.h>
20 #include <linux/uio.h>
21 #include <linux/uuid.h>
22 #include <linux/file.h>
23 #include <linux/nls.h>
24 #include <linux/sched/signal.h>
25 #include <linux/fileattr.h>
26 #include <linux/fadvise.h>
35 #include <trace/events/f2fs.h>
36 #include <uapi/linux/f2fs.h>
38 static vm_fault_t
f2fs_filemap_fault(struct vm_fault
*vmf
)
40 struct inode
*inode
= file_inode(vmf
->vma
->vm_file
);
43 ret
= filemap_fault(vmf
);
45 f2fs_update_iostat(F2FS_I_SB(inode
), APP_MAPPED_READ_IO
,
48 trace_f2fs_filemap_fault(inode
, vmf
->pgoff
, (unsigned long)ret
);
53 static vm_fault_t
f2fs_vm_page_mkwrite(struct vm_fault
*vmf
)
55 struct page
*page
= vmf
->page
;
56 struct inode
*inode
= file_inode(vmf
->vma
->vm_file
);
57 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
58 struct dnode_of_data dn
;
59 bool need_alloc
= true;
62 if (unlikely(IS_IMMUTABLE(inode
)))
63 return VM_FAULT_SIGBUS
;
65 if (is_inode_flag_set(inode
, FI_COMPRESS_RELEASED
))
66 return VM_FAULT_SIGBUS
;
68 if (unlikely(f2fs_cp_error(sbi
))) {
73 if (!f2fs_is_checkpoint_ready(sbi
)) {
78 err
= f2fs_convert_inline_inode(inode
);
82 #ifdef CONFIG_F2FS_FS_COMPRESSION
83 if (f2fs_compressed_file(inode
)) {
84 int ret
= f2fs_is_compressed_cluster(inode
, page
->index
);
94 /* should do out of any locked page */
96 f2fs_balance_fs(sbi
, true);
98 sb_start_pagefault(inode
->i_sb
);
100 f2fs_bug_on(sbi
, f2fs_has_inline_data(inode
));
102 file_update_time(vmf
->vma
->vm_file
);
103 filemap_invalidate_lock_shared(inode
->i_mapping
);
105 if (unlikely(page
->mapping
!= inode
->i_mapping
||
106 page_offset(page
) > i_size_read(inode
) ||
107 !PageUptodate(page
))) {
114 /* block allocation */
115 f2fs_do_map_lock(sbi
, F2FS_GET_BLOCK_PRE_AIO
, true);
116 set_new_dnode(&dn
, inode
, NULL
, NULL
, 0);
117 err
= f2fs_get_block(&dn
, page
->index
);
118 f2fs_do_map_lock(sbi
, F2FS_GET_BLOCK_PRE_AIO
, false);
121 #ifdef CONFIG_F2FS_FS_COMPRESSION
123 set_new_dnode(&dn
, inode
, NULL
, NULL
, 0);
124 err
= f2fs_get_dnode_of_data(&dn
, page
->index
, LOOKUP_NODE
);
133 f2fs_wait_on_page_writeback(page
, DATA
, false, true);
135 /* wait for GCed page writeback via META_MAPPING */
136 f2fs_wait_on_block_writeback(inode
, dn
.data_blkaddr
);
139 * check to see if the page is mapped already (no holes)
141 if (PageMappedToDisk(page
))
144 /* page is wholly or partially inside EOF */
145 if (((loff_t
)(page
->index
+ 1) << PAGE_SHIFT
) >
146 i_size_read(inode
)) {
149 offset
= i_size_read(inode
) & ~PAGE_MASK
;
150 zero_user_segment(page
, offset
, PAGE_SIZE
);
152 set_page_dirty(page
);
153 if (!PageUptodate(page
))
154 SetPageUptodate(page
);
156 f2fs_update_iostat(sbi
, APP_MAPPED_IO
, F2FS_BLKSIZE
);
157 f2fs_update_time(sbi
, REQ_TIME
);
159 trace_f2fs_vm_page_mkwrite(page
, DATA
);
161 filemap_invalidate_unlock_shared(inode
->i_mapping
);
163 sb_end_pagefault(inode
->i_sb
);
165 return block_page_mkwrite_return(err
);
168 static const struct vm_operations_struct f2fs_file_vm_ops
= {
169 .fault
= f2fs_filemap_fault
,
170 .map_pages
= filemap_map_pages
,
171 .page_mkwrite
= f2fs_vm_page_mkwrite
,
174 static int get_parent_ino(struct inode
*inode
, nid_t
*pino
)
176 struct dentry
*dentry
;
179 * Make sure to get the non-deleted alias. The alias associated with
180 * the open file descriptor being fsync()'ed may be deleted already.
182 dentry
= d_find_alias(inode
);
186 *pino
= parent_ino(dentry
);
191 static inline enum cp_reason_type
need_do_checkpoint(struct inode
*inode
)
193 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
194 enum cp_reason_type cp_reason
= CP_NO_NEEDED
;
196 if (!S_ISREG(inode
->i_mode
))
197 cp_reason
= CP_NON_REGULAR
;
198 else if (f2fs_compressed_file(inode
))
199 cp_reason
= CP_COMPRESSED
;
200 else if (inode
->i_nlink
!= 1)
201 cp_reason
= CP_HARDLINK
;
202 else if (is_sbi_flag_set(sbi
, SBI_NEED_CP
))
203 cp_reason
= CP_SB_NEED_CP
;
204 else if (file_wrong_pino(inode
))
205 cp_reason
= CP_WRONG_PINO
;
206 else if (!f2fs_space_for_roll_forward(sbi
))
207 cp_reason
= CP_NO_SPC_ROLL
;
208 else if (!f2fs_is_checkpointed_node(sbi
, F2FS_I(inode
)->i_pino
))
209 cp_reason
= CP_NODE_NEED_CP
;
210 else if (test_opt(sbi
, FASTBOOT
))
211 cp_reason
= CP_FASTBOOT_MODE
;
212 else if (F2FS_OPTION(sbi
).active_logs
== 2)
213 cp_reason
= CP_SPEC_LOG_NUM
;
214 else if (F2FS_OPTION(sbi
).fsync_mode
== FSYNC_MODE_STRICT
&&
215 f2fs_need_dentry_mark(sbi
, inode
->i_ino
) &&
216 f2fs_exist_written_data(sbi
, F2FS_I(inode
)->i_pino
,
218 cp_reason
= CP_RECOVER_DIR
;
223 static bool need_inode_page_update(struct f2fs_sb_info
*sbi
, nid_t ino
)
225 struct page
*i
= find_get_page(NODE_MAPPING(sbi
), ino
);
227 /* But we need to avoid that there are some inode updates */
228 if ((i
&& PageDirty(i
)) || f2fs_need_inode_block_update(sbi
, ino
))
234 static void try_to_fix_pino(struct inode
*inode
)
236 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
239 down_write(&fi
->i_sem
);
240 if (file_wrong_pino(inode
) && inode
->i_nlink
== 1 &&
241 get_parent_ino(inode
, &pino
)) {
242 f2fs_i_pino_write(inode
, pino
);
243 file_got_pino(inode
);
245 up_write(&fi
->i_sem
);
248 static int f2fs_do_sync_file(struct file
*file
, loff_t start
, loff_t end
,
249 int datasync
, bool atomic
)
251 struct inode
*inode
= file
->f_mapping
->host
;
252 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
253 nid_t ino
= inode
->i_ino
;
255 enum cp_reason_type cp_reason
= 0;
256 struct writeback_control wbc
= {
257 .sync_mode
= WB_SYNC_ALL
,
258 .nr_to_write
= LONG_MAX
,
261 unsigned int seq_id
= 0;
263 if (unlikely(f2fs_readonly(inode
->i_sb
)))
266 trace_f2fs_sync_file_enter(inode
);
268 if (S_ISDIR(inode
->i_mode
))
271 /* if fdatasync is triggered, let's do in-place-update */
272 if (datasync
|| get_dirty_pages(inode
) <= SM_I(sbi
)->min_fsync_blocks
)
273 set_inode_flag(inode
, FI_NEED_IPU
);
274 ret
= file_write_and_wait_range(file
, start
, end
);
275 clear_inode_flag(inode
, FI_NEED_IPU
);
277 if (ret
|| is_sbi_flag_set(sbi
, SBI_CP_DISABLED
)) {
278 trace_f2fs_sync_file_exit(inode
, cp_reason
, datasync
, ret
);
282 /* if the inode is dirty, let's recover all the time */
283 if (!f2fs_skip_inode_update(inode
, datasync
)) {
284 f2fs_write_inode(inode
, NULL
);
289 * if there is no written data, don't waste time to write recovery info.
291 if (!is_inode_flag_set(inode
, FI_APPEND_WRITE
) &&
292 !f2fs_exist_written_data(sbi
, ino
, APPEND_INO
)) {
294 /* it may call write_inode just prior to fsync */
295 if (need_inode_page_update(sbi
, ino
))
298 if (is_inode_flag_set(inode
, FI_UPDATE_WRITE
) ||
299 f2fs_exist_written_data(sbi
, ino
, UPDATE_INO
))
304 * for OPU case, during fsync(), node can be persisted before
305 * data when lower device doesn't support write barrier, result
306 * in data corruption after SPO.
307 * So for strict fsync mode, force to use atomic write sematics
308 * to keep write order in between data/node and last node to
309 * avoid potential data corruption.
311 if (F2FS_OPTION(sbi
).fsync_mode
==
312 FSYNC_MODE_STRICT
&& !atomic
)
317 * Both of fdatasync() and fsync() are able to be recovered from
320 down_read(&F2FS_I(inode
)->i_sem
);
321 cp_reason
= need_do_checkpoint(inode
);
322 up_read(&F2FS_I(inode
)->i_sem
);
325 /* all the dirty node pages should be flushed for POR */
326 ret
= f2fs_sync_fs(inode
->i_sb
, 1);
329 * We've secured consistency through sync_fs. Following pino
330 * will be used only for fsynced inodes after checkpoint.
332 try_to_fix_pino(inode
);
333 clear_inode_flag(inode
, FI_APPEND_WRITE
);
334 clear_inode_flag(inode
, FI_UPDATE_WRITE
);
338 atomic_inc(&sbi
->wb_sync_req
[NODE
]);
339 ret
= f2fs_fsync_node_pages(sbi
, inode
, &wbc
, atomic
, &seq_id
);
340 atomic_dec(&sbi
->wb_sync_req
[NODE
]);
344 /* if cp_error was enabled, we should avoid infinite loop */
345 if (unlikely(f2fs_cp_error(sbi
))) {
350 if (f2fs_need_inode_block_update(sbi
, ino
)) {
351 f2fs_mark_inode_dirty_sync(inode
, true);
352 f2fs_write_inode(inode
, NULL
);
357 * If it's atomic_write, it's just fine to keep write ordering. So
358 * here we don't need to wait for node write completion, since we use
359 * node chain which serializes node blocks. If one of node writes are
360 * reordered, we can see simply broken chain, resulting in stopping
361 * roll-forward recovery. It means we'll recover all or none node blocks
365 ret
= f2fs_wait_on_node_pages_writeback(sbi
, seq_id
);
370 /* once recovery info is written, don't need to tack this */
371 f2fs_remove_ino_entry(sbi
, ino
, APPEND_INO
);
372 clear_inode_flag(inode
, FI_APPEND_WRITE
);
374 if (!atomic
&& F2FS_OPTION(sbi
).fsync_mode
!= FSYNC_MODE_NOBARRIER
)
375 ret
= f2fs_issue_flush(sbi
, inode
->i_ino
);
377 f2fs_remove_ino_entry(sbi
, ino
, UPDATE_INO
);
378 clear_inode_flag(inode
, FI_UPDATE_WRITE
);
379 f2fs_remove_ino_entry(sbi
, ino
, FLUSH_INO
);
381 f2fs_update_time(sbi
, REQ_TIME
);
383 trace_f2fs_sync_file_exit(inode
, cp_reason
, datasync
, ret
);
387 int f2fs_sync_file(struct file
*file
, loff_t start
, loff_t end
, int datasync
)
389 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(file
)))))
391 return f2fs_do_sync_file(file
, start
, end
, datasync
, false);
394 static bool __found_offset(struct address_space
*mapping
, block_t blkaddr
,
395 pgoff_t index
, int whence
)
399 if (__is_valid_data_blkaddr(blkaddr
))
401 if (blkaddr
== NEW_ADDR
&&
402 xa_get_mark(&mapping
->i_pages
, index
, PAGECACHE_TAG_DIRTY
))
406 if (blkaddr
== NULL_ADDR
)
413 static loff_t
f2fs_seek_block(struct file
*file
, loff_t offset
, int whence
)
415 struct inode
*inode
= file
->f_mapping
->host
;
416 loff_t maxbytes
= inode
->i_sb
->s_maxbytes
;
417 struct dnode_of_data dn
;
418 pgoff_t pgofs
, end_offset
;
419 loff_t data_ofs
= offset
;
425 isize
= i_size_read(inode
);
429 /* handle inline data case */
430 if (f2fs_has_inline_data(inode
)) {
431 if (whence
== SEEK_HOLE
) {
434 } else if (whence
== SEEK_DATA
) {
440 pgofs
= (pgoff_t
)(offset
>> PAGE_SHIFT
);
442 for (; data_ofs
< isize
; data_ofs
= (loff_t
)pgofs
<< PAGE_SHIFT
) {
443 set_new_dnode(&dn
, inode
, NULL
, NULL
, 0);
444 err
= f2fs_get_dnode_of_data(&dn
, pgofs
, LOOKUP_NODE
);
445 if (err
&& err
!= -ENOENT
) {
447 } else if (err
== -ENOENT
) {
448 /* direct node does not exists */
449 if (whence
== SEEK_DATA
) {
450 pgofs
= f2fs_get_next_page_offset(&dn
, pgofs
);
457 end_offset
= ADDRS_PER_PAGE(dn
.node_page
, inode
);
459 /* find data/hole in dnode block */
460 for (; dn
.ofs_in_node
< end_offset
;
461 dn
.ofs_in_node
++, pgofs
++,
462 data_ofs
= (loff_t
)pgofs
<< PAGE_SHIFT
) {
465 blkaddr
= f2fs_data_blkaddr(&dn
);
467 if (__is_valid_data_blkaddr(blkaddr
) &&
468 !f2fs_is_valid_blkaddr(F2FS_I_SB(inode
),
469 blkaddr
, DATA_GENERIC_ENHANCE
)) {
474 if (__found_offset(file
->f_mapping
, blkaddr
,
483 if (whence
== SEEK_DATA
)
486 if (whence
== SEEK_HOLE
&& data_ofs
> isize
)
489 return vfs_setpos(file
, data_ofs
, maxbytes
);
495 static loff_t
f2fs_llseek(struct file
*file
, loff_t offset
, int whence
)
497 struct inode
*inode
= file
->f_mapping
->host
;
498 loff_t maxbytes
= inode
->i_sb
->s_maxbytes
;
500 if (f2fs_compressed_file(inode
))
501 maxbytes
= max_file_blocks(inode
) << F2FS_BLKSIZE_BITS
;
507 return generic_file_llseek_size(file
, offset
, whence
,
508 maxbytes
, i_size_read(inode
));
513 return f2fs_seek_block(file
, offset
, whence
);
519 static int f2fs_file_mmap(struct file
*file
, struct vm_area_struct
*vma
)
521 struct inode
*inode
= file_inode(file
);
523 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode
))))
526 if (!f2fs_is_compress_backend_ready(inode
))
530 vma
->vm_ops
= &f2fs_file_vm_ops
;
531 set_inode_flag(inode
, FI_MMAP_FILE
);
535 static int f2fs_file_open(struct inode
*inode
, struct file
*filp
)
537 int err
= fscrypt_file_open(inode
, filp
);
542 if (!f2fs_is_compress_backend_ready(inode
))
545 err
= fsverity_file_open(inode
, filp
);
549 filp
->f_mode
|= FMODE_NOWAIT
;
551 return dquot_file_open(inode
, filp
);
554 void f2fs_truncate_data_blocks_range(struct dnode_of_data
*dn
, int count
)
556 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dn
->inode
);
557 struct f2fs_node
*raw_node
;
558 int nr_free
= 0, ofs
= dn
->ofs_in_node
, len
= count
;
561 bool compressed_cluster
= false;
562 int cluster_index
= 0, valid_blocks
= 0;
563 int cluster_size
= F2FS_I(dn
->inode
)->i_cluster_size
;
564 bool released
= !atomic_read(&F2FS_I(dn
->inode
)->i_compr_blocks
);
566 if (IS_INODE(dn
->node_page
) && f2fs_has_extra_attr(dn
->inode
))
567 base
= get_extra_isize(dn
->inode
);
569 raw_node
= F2FS_NODE(dn
->node_page
);
570 addr
= blkaddr_in_node(raw_node
) + base
+ ofs
;
572 /* Assumption: truncateion starts with cluster */
573 for (; count
> 0; count
--, addr
++, dn
->ofs_in_node
++, cluster_index
++) {
574 block_t blkaddr
= le32_to_cpu(*addr
);
576 if (f2fs_compressed_file(dn
->inode
) &&
577 !(cluster_index
& (cluster_size
- 1))) {
578 if (compressed_cluster
)
579 f2fs_i_compr_blocks_update(dn
->inode
,
580 valid_blocks
, false);
581 compressed_cluster
= (blkaddr
== COMPRESS_ADDR
);
585 if (blkaddr
== NULL_ADDR
)
588 dn
->data_blkaddr
= NULL_ADDR
;
589 f2fs_set_data_blkaddr(dn
);
591 if (__is_valid_data_blkaddr(blkaddr
)) {
592 if (!f2fs_is_valid_blkaddr(sbi
, blkaddr
,
593 DATA_GENERIC_ENHANCE
))
595 if (compressed_cluster
)
599 if (dn
->ofs_in_node
== 0 && IS_INODE(dn
->node_page
))
600 clear_inode_flag(dn
->inode
, FI_FIRST_BLOCK_WRITTEN
);
602 f2fs_invalidate_blocks(sbi
, blkaddr
);
604 if (!released
|| blkaddr
!= COMPRESS_ADDR
)
608 if (compressed_cluster
)
609 f2fs_i_compr_blocks_update(dn
->inode
, valid_blocks
, false);
614 * once we invalidate valid blkaddr in range [ofs, ofs + count],
615 * we will invalidate all blkaddr in the whole range.
617 fofs
= f2fs_start_bidx_of_node(ofs_of_node(dn
->node_page
),
619 f2fs_update_extent_cache_range(dn
, fofs
, 0, len
);
620 dec_valid_block_count(sbi
, dn
->inode
, nr_free
);
622 dn
->ofs_in_node
= ofs
;
624 f2fs_update_time(sbi
, REQ_TIME
);
625 trace_f2fs_truncate_data_blocks_range(dn
->inode
, dn
->nid
,
626 dn
->ofs_in_node
, nr_free
);
629 void f2fs_truncate_data_blocks(struct dnode_of_data
*dn
)
631 f2fs_truncate_data_blocks_range(dn
, ADDRS_PER_BLOCK(dn
->inode
));
634 static int truncate_partial_data_page(struct inode
*inode
, u64 from
,
637 loff_t offset
= from
& (PAGE_SIZE
- 1);
638 pgoff_t index
= from
>> PAGE_SHIFT
;
639 struct address_space
*mapping
= inode
->i_mapping
;
642 if (!offset
&& !cache_only
)
646 page
= find_lock_page(mapping
, index
);
647 if (page
&& PageUptodate(page
))
649 f2fs_put_page(page
, 1);
653 page
= f2fs_get_lock_data_page(inode
, index
, true);
655 return PTR_ERR(page
) == -ENOENT
? 0 : PTR_ERR(page
);
657 f2fs_wait_on_page_writeback(page
, DATA
, true, true);
658 zero_user(page
, offset
, PAGE_SIZE
- offset
);
660 /* An encrypted inode should have a key and truncate the last page. */
661 f2fs_bug_on(F2FS_I_SB(inode
), cache_only
&& IS_ENCRYPTED(inode
));
663 set_page_dirty(page
);
664 f2fs_put_page(page
, 1);
668 int f2fs_do_truncate_blocks(struct inode
*inode
, u64 from
, bool lock
)
670 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
671 struct dnode_of_data dn
;
673 int count
= 0, err
= 0;
675 bool truncate_page
= false;
677 trace_f2fs_truncate_blocks_enter(inode
, from
);
679 free_from
= (pgoff_t
)F2FS_BLK_ALIGN(from
);
681 if (free_from
>= max_file_blocks(inode
))
687 ipage
= f2fs_get_node_page(sbi
, inode
->i_ino
);
689 err
= PTR_ERR(ipage
);
693 if (f2fs_has_inline_data(inode
)) {
694 f2fs_truncate_inline_inode(inode
, ipage
, from
);
695 f2fs_put_page(ipage
, 1);
696 truncate_page
= true;
700 set_new_dnode(&dn
, inode
, ipage
, NULL
, 0);
701 err
= f2fs_get_dnode_of_data(&dn
, free_from
, LOOKUP_NODE_RA
);
708 count
= ADDRS_PER_PAGE(dn
.node_page
, inode
);
710 count
-= dn
.ofs_in_node
;
711 f2fs_bug_on(sbi
, count
< 0);
713 if (dn
.ofs_in_node
|| IS_INODE(dn
.node_page
)) {
714 f2fs_truncate_data_blocks_range(&dn
, count
);
720 err
= f2fs_truncate_inode_blocks(inode
, free_from
);
725 /* lastly zero out the first data page */
727 err
= truncate_partial_data_page(inode
, from
, truncate_page
);
729 trace_f2fs_truncate_blocks_exit(inode
, err
);
733 int f2fs_truncate_blocks(struct inode
*inode
, u64 from
, bool lock
)
735 u64 free_from
= from
;
738 #ifdef CONFIG_F2FS_FS_COMPRESSION
740 * for compressed file, only support cluster size
741 * aligned truncation.
743 if (f2fs_compressed_file(inode
))
744 free_from
= round_up(from
,
745 F2FS_I(inode
)->i_cluster_size
<< PAGE_SHIFT
);
748 err
= f2fs_do_truncate_blocks(inode
, free_from
, lock
);
752 #ifdef CONFIG_F2FS_FS_COMPRESSION
754 * For compressed file, after release compress blocks, don't allow write
755 * direct, but we should allow write direct after truncate to zero.
757 if (f2fs_compressed_file(inode
) && !free_from
758 && is_inode_flag_set(inode
, FI_COMPRESS_RELEASED
))
759 clear_inode_flag(inode
, FI_COMPRESS_RELEASED
);
761 if (from
!= free_from
) {
762 err
= f2fs_truncate_partial_cluster(inode
, from
, lock
);
771 int f2fs_truncate(struct inode
*inode
)
775 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode
))))
778 if (!(S_ISREG(inode
->i_mode
) || S_ISDIR(inode
->i_mode
) ||
779 S_ISLNK(inode
->i_mode
)))
782 trace_f2fs_truncate(inode
);
784 if (time_to_inject(F2FS_I_SB(inode
), FAULT_TRUNCATE
)) {
785 f2fs_show_injection_info(F2FS_I_SB(inode
), FAULT_TRUNCATE
);
789 err
= dquot_initialize(inode
);
793 /* we should check inline_data size */
794 if (!f2fs_may_inline_data(inode
)) {
795 err
= f2fs_convert_inline_inode(inode
);
800 err
= f2fs_truncate_blocks(inode
, i_size_read(inode
), true);
804 inode
->i_mtime
= inode
->i_ctime
= current_time(inode
);
805 f2fs_mark_inode_dirty_sync(inode
, false);
809 int f2fs_getattr(struct user_namespace
*mnt_userns
, const struct path
*path
,
810 struct kstat
*stat
, u32 request_mask
, unsigned int query_flags
)
812 struct inode
*inode
= d_inode(path
->dentry
);
813 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
814 struct f2fs_inode
*ri
;
817 if (f2fs_has_extra_attr(inode
) &&
818 f2fs_sb_has_inode_crtime(F2FS_I_SB(inode
)) &&
819 F2FS_FITS_IN_INODE(ri
, fi
->i_extra_isize
, i_crtime
)) {
820 stat
->result_mask
|= STATX_BTIME
;
821 stat
->btime
.tv_sec
= fi
->i_crtime
.tv_sec
;
822 stat
->btime
.tv_nsec
= fi
->i_crtime
.tv_nsec
;
826 if (flags
& F2FS_COMPR_FL
)
827 stat
->attributes
|= STATX_ATTR_COMPRESSED
;
828 if (flags
& F2FS_APPEND_FL
)
829 stat
->attributes
|= STATX_ATTR_APPEND
;
830 if (IS_ENCRYPTED(inode
))
831 stat
->attributes
|= STATX_ATTR_ENCRYPTED
;
832 if (flags
& F2FS_IMMUTABLE_FL
)
833 stat
->attributes
|= STATX_ATTR_IMMUTABLE
;
834 if (flags
& F2FS_NODUMP_FL
)
835 stat
->attributes
|= STATX_ATTR_NODUMP
;
836 if (IS_VERITY(inode
))
837 stat
->attributes
|= STATX_ATTR_VERITY
;
839 stat
->attributes_mask
|= (STATX_ATTR_COMPRESSED
|
841 STATX_ATTR_ENCRYPTED
|
842 STATX_ATTR_IMMUTABLE
|
846 generic_fillattr(&init_user_ns
, inode
, stat
);
848 /* we need to show initial sectors used for inline_data/dentries */
849 if ((S_ISREG(inode
->i_mode
) && f2fs_has_inline_data(inode
)) ||
850 f2fs_has_inline_dentry(inode
))
851 stat
->blocks
+= (stat
->size
+ 511) >> 9;
856 #ifdef CONFIG_F2FS_FS_POSIX_ACL
857 static void __setattr_copy(struct user_namespace
*mnt_userns
,
858 struct inode
*inode
, const struct iattr
*attr
)
860 unsigned int ia_valid
= attr
->ia_valid
;
862 if (ia_valid
& ATTR_UID
)
863 inode
->i_uid
= attr
->ia_uid
;
864 if (ia_valid
& ATTR_GID
)
865 inode
->i_gid
= attr
->ia_gid
;
866 if (ia_valid
& ATTR_ATIME
)
867 inode
->i_atime
= attr
->ia_atime
;
868 if (ia_valid
& ATTR_MTIME
)
869 inode
->i_mtime
= attr
->ia_mtime
;
870 if (ia_valid
& ATTR_CTIME
)
871 inode
->i_ctime
= attr
->ia_ctime
;
872 if (ia_valid
& ATTR_MODE
) {
873 umode_t mode
= attr
->ia_mode
;
874 kgid_t kgid
= i_gid_into_mnt(mnt_userns
, inode
);
876 if (!in_group_p(kgid
) && !capable_wrt_inode_uidgid(mnt_userns
, inode
, CAP_FSETID
))
878 set_acl_inode(inode
, mode
);
882 #define __setattr_copy setattr_copy
885 int f2fs_setattr(struct user_namespace
*mnt_userns
, struct dentry
*dentry
,
888 struct inode
*inode
= d_inode(dentry
);
891 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode
))))
894 if (unlikely(IS_IMMUTABLE(inode
)))
897 if (unlikely(IS_APPEND(inode
) &&
898 (attr
->ia_valid
& (ATTR_MODE
| ATTR_UID
|
899 ATTR_GID
| ATTR_TIMES_SET
))))
902 if ((attr
->ia_valid
& ATTR_SIZE
) &&
903 !f2fs_is_compress_backend_ready(inode
))
906 err
= setattr_prepare(&init_user_ns
, dentry
, attr
);
910 err
= fscrypt_prepare_setattr(dentry
, attr
);
914 err
= fsverity_prepare_setattr(dentry
, attr
);
918 if (is_quota_modification(inode
, attr
)) {
919 err
= dquot_initialize(inode
);
923 if ((attr
->ia_valid
& ATTR_UID
&&
924 !uid_eq(attr
->ia_uid
, inode
->i_uid
)) ||
925 (attr
->ia_valid
& ATTR_GID
&&
926 !gid_eq(attr
->ia_gid
, inode
->i_gid
))) {
927 f2fs_lock_op(F2FS_I_SB(inode
));
928 err
= dquot_transfer(inode
, attr
);
930 set_sbi_flag(F2FS_I_SB(inode
),
931 SBI_QUOTA_NEED_REPAIR
);
932 f2fs_unlock_op(F2FS_I_SB(inode
));
936 * update uid/gid under lock_op(), so that dquot and inode can
937 * be updated atomically.
939 if (attr
->ia_valid
& ATTR_UID
)
940 inode
->i_uid
= attr
->ia_uid
;
941 if (attr
->ia_valid
& ATTR_GID
)
942 inode
->i_gid
= attr
->ia_gid
;
943 f2fs_mark_inode_dirty_sync(inode
, true);
944 f2fs_unlock_op(F2FS_I_SB(inode
));
947 if (attr
->ia_valid
& ATTR_SIZE
) {
948 loff_t old_size
= i_size_read(inode
);
950 if (attr
->ia_size
> MAX_INLINE_DATA(inode
)) {
952 * should convert inline inode before i_size_write to
953 * keep smaller than inline_data size with inline flag.
955 err
= f2fs_convert_inline_inode(inode
);
960 down_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
961 filemap_invalidate_lock(inode
->i_mapping
);
963 truncate_setsize(inode
, attr
->ia_size
);
965 if (attr
->ia_size
<= old_size
)
966 err
= f2fs_truncate(inode
);
968 * do not trim all blocks after i_size if target size is
969 * larger than i_size.
971 filemap_invalidate_unlock(inode
->i_mapping
);
972 up_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
976 spin_lock(&F2FS_I(inode
)->i_size_lock
);
977 inode
->i_mtime
= inode
->i_ctime
= current_time(inode
);
978 F2FS_I(inode
)->last_disk_size
= i_size_read(inode
);
979 spin_unlock(&F2FS_I(inode
)->i_size_lock
);
982 __setattr_copy(&init_user_ns
, inode
, attr
);
984 if (attr
->ia_valid
& ATTR_MODE
) {
985 err
= posix_acl_chmod(&init_user_ns
, inode
, f2fs_get_inode_mode(inode
));
987 if (is_inode_flag_set(inode
, FI_ACL_MODE
)) {
989 inode
->i_mode
= F2FS_I(inode
)->i_acl_mode
;
990 clear_inode_flag(inode
, FI_ACL_MODE
);
994 /* file size may changed here */
995 f2fs_mark_inode_dirty_sync(inode
, true);
997 /* inode change will produce dirty node pages flushed by checkpoint */
998 f2fs_balance_fs(F2FS_I_SB(inode
), true);
1003 const struct inode_operations f2fs_file_inode_operations
= {
1004 .getattr
= f2fs_getattr
,
1005 .setattr
= f2fs_setattr
,
1006 .get_acl
= f2fs_get_acl
,
1007 .set_acl
= f2fs_set_acl
,
1008 .listxattr
= f2fs_listxattr
,
1009 .fiemap
= f2fs_fiemap
,
1010 .fileattr_get
= f2fs_fileattr_get
,
1011 .fileattr_set
= f2fs_fileattr_set
,
1014 static int fill_zero(struct inode
*inode
, pgoff_t index
,
1015 loff_t start
, loff_t len
)
1017 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
1023 f2fs_balance_fs(sbi
, true);
1026 page
= f2fs_get_new_data_page(inode
, NULL
, index
, false);
1027 f2fs_unlock_op(sbi
);
1030 return PTR_ERR(page
);
1032 f2fs_wait_on_page_writeback(page
, DATA
, true, true);
1033 zero_user(page
, start
, len
);
1034 set_page_dirty(page
);
1035 f2fs_put_page(page
, 1);
1039 int f2fs_truncate_hole(struct inode
*inode
, pgoff_t pg_start
, pgoff_t pg_end
)
1043 while (pg_start
< pg_end
) {
1044 struct dnode_of_data dn
;
1045 pgoff_t end_offset
, count
;
1047 set_new_dnode(&dn
, inode
, NULL
, NULL
, 0);
1048 err
= f2fs_get_dnode_of_data(&dn
, pg_start
, LOOKUP_NODE
);
1050 if (err
== -ENOENT
) {
1051 pg_start
= f2fs_get_next_page_offset(&dn
,
1058 end_offset
= ADDRS_PER_PAGE(dn
.node_page
, inode
);
1059 count
= min(end_offset
- dn
.ofs_in_node
, pg_end
- pg_start
);
1061 f2fs_bug_on(F2FS_I_SB(inode
), count
== 0 || count
> end_offset
);
1063 f2fs_truncate_data_blocks_range(&dn
, count
);
1064 f2fs_put_dnode(&dn
);
1071 static int punch_hole(struct inode
*inode
, loff_t offset
, loff_t len
)
1073 pgoff_t pg_start
, pg_end
;
1074 loff_t off_start
, off_end
;
1077 ret
= f2fs_convert_inline_inode(inode
);
1081 pg_start
= ((unsigned long long) offset
) >> PAGE_SHIFT
;
1082 pg_end
= ((unsigned long long) offset
+ len
) >> PAGE_SHIFT
;
1084 off_start
= offset
& (PAGE_SIZE
- 1);
1085 off_end
= (offset
+ len
) & (PAGE_SIZE
- 1);
1087 if (pg_start
== pg_end
) {
1088 ret
= fill_zero(inode
, pg_start
, off_start
,
1089 off_end
- off_start
);
1094 ret
= fill_zero(inode
, pg_start
++, off_start
,
1095 PAGE_SIZE
- off_start
);
1100 ret
= fill_zero(inode
, pg_end
, 0, off_end
);
1105 if (pg_start
< pg_end
) {
1106 loff_t blk_start
, blk_end
;
1107 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
1109 f2fs_balance_fs(sbi
, true);
1111 blk_start
= (loff_t
)pg_start
<< PAGE_SHIFT
;
1112 blk_end
= (loff_t
)pg_end
<< PAGE_SHIFT
;
1114 down_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
1115 filemap_invalidate_lock(inode
->i_mapping
);
1117 truncate_pagecache_range(inode
, blk_start
, blk_end
- 1);
1120 ret
= f2fs_truncate_hole(inode
, pg_start
, pg_end
);
1121 f2fs_unlock_op(sbi
);
1123 filemap_invalidate_unlock(inode
->i_mapping
);
1124 up_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
1131 static int __read_out_blkaddrs(struct inode
*inode
, block_t
*blkaddr
,
1132 int *do_replace
, pgoff_t off
, pgoff_t len
)
1134 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
1135 struct dnode_of_data dn
;
1139 set_new_dnode(&dn
, inode
, NULL
, NULL
, 0);
1140 ret
= f2fs_get_dnode_of_data(&dn
, off
, LOOKUP_NODE_RA
);
1141 if (ret
&& ret
!= -ENOENT
) {
1143 } else if (ret
== -ENOENT
) {
1144 if (dn
.max_level
== 0)
1146 done
= min((pgoff_t
)ADDRS_PER_BLOCK(inode
) -
1147 dn
.ofs_in_node
, len
);
1153 done
= min((pgoff_t
)ADDRS_PER_PAGE(dn
.node_page
, inode
) -
1154 dn
.ofs_in_node
, len
);
1155 for (i
= 0; i
< done
; i
++, blkaddr
++, do_replace
++, dn
.ofs_in_node
++) {
1156 *blkaddr
= f2fs_data_blkaddr(&dn
);
1158 if (__is_valid_data_blkaddr(*blkaddr
) &&
1159 !f2fs_is_valid_blkaddr(sbi
, *blkaddr
,
1160 DATA_GENERIC_ENHANCE
)) {
1161 f2fs_put_dnode(&dn
);
1162 return -EFSCORRUPTED
;
1165 if (!f2fs_is_checkpointed_data(sbi
, *blkaddr
)) {
1167 if (f2fs_lfs_mode(sbi
)) {
1168 f2fs_put_dnode(&dn
);
1172 /* do not invalidate this block address */
1173 f2fs_update_data_blkaddr(&dn
, NULL_ADDR
);
1177 f2fs_put_dnode(&dn
);
1186 static int __roll_back_blkaddrs(struct inode
*inode
, block_t
*blkaddr
,
1187 int *do_replace
, pgoff_t off
, int len
)
1189 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
1190 struct dnode_of_data dn
;
1193 for (i
= 0; i
< len
; i
++, do_replace
++, blkaddr
++) {
1194 if (*do_replace
== 0)
1197 set_new_dnode(&dn
, inode
, NULL
, NULL
, 0);
1198 ret
= f2fs_get_dnode_of_data(&dn
, off
+ i
, LOOKUP_NODE_RA
);
1200 dec_valid_block_count(sbi
, inode
, 1);
1201 f2fs_invalidate_blocks(sbi
, *blkaddr
);
1203 f2fs_update_data_blkaddr(&dn
, *blkaddr
);
1205 f2fs_put_dnode(&dn
);
1210 static int __clone_blkaddrs(struct inode
*src_inode
, struct inode
*dst_inode
,
1211 block_t
*blkaddr
, int *do_replace
,
1212 pgoff_t src
, pgoff_t dst
, pgoff_t len
, bool full
)
1214 struct f2fs_sb_info
*sbi
= F2FS_I_SB(src_inode
);
1219 if (blkaddr
[i
] == NULL_ADDR
&& !full
) {
1224 if (do_replace
[i
] || blkaddr
[i
] == NULL_ADDR
) {
1225 struct dnode_of_data dn
;
1226 struct node_info ni
;
1230 set_new_dnode(&dn
, dst_inode
, NULL
, NULL
, 0);
1231 ret
= f2fs_get_dnode_of_data(&dn
, dst
+ i
, ALLOC_NODE
);
1235 ret
= f2fs_get_node_info(sbi
, dn
.nid
, &ni
);
1237 f2fs_put_dnode(&dn
);
1241 ilen
= min((pgoff_t
)
1242 ADDRS_PER_PAGE(dn
.node_page
, dst_inode
) -
1243 dn
.ofs_in_node
, len
- i
);
1245 dn
.data_blkaddr
= f2fs_data_blkaddr(&dn
);
1246 f2fs_truncate_data_blocks_range(&dn
, 1);
1248 if (do_replace
[i
]) {
1249 f2fs_i_blocks_write(src_inode
,
1251 f2fs_i_blocks_write(dst_inode
,
1253 f2fs_replace_block(sbi
, &dn
, dn
.data_blkaddr
,
1254 blkaddr
[i
], ni
.version
, true, false);
1260 new_size
= (loff_t
)(dst
+ i
) << PAGE_SHIFT
;
1261 if (dst_inode
->i_size
< new_size
)
1262 f2fs_i_size_write(dst_inode
, new_size
);
1263 } while (--ilen
&& (do_replace
[i
] || blkaddr
[i
] == NULL_ADDR
));
1265 f2fs_put_dnode(&dn
);
1267 struct page
*psrc
, *pdst
;
1269 psrc
= f2fs_get_lock_data_page(src_inode
,
1272 return PTR_ERR(psrc
);
1273 pdst
= f2fs_get_new_data_page(dst_inode
, NULL
, dst
+ i
,
1276 f2fs_put_page(psrc
, 1);
1277 return PTR_ERR(pdst
);
1279 f2fs_copy_page(psrc
, pdst
);
1280 set_page_dirty(pdst
);
1281 f2fs_put_page(pdst
, 1);
1282 f2fs_put_page(psrc
, 1);
1284 ret
= f2fs_truncate_hole(src_inode
,
1285 src
+ i
, src
+ i
+ 1);
1294 static int __exchange_data_block(struct inode
*src_inode
,
1295 struct inode
*dst_inode
, pgoff_t src
, pgoff_t dst
,
1296 pgoff_t len
, bool full
)
1298 block_t
*src_blkaddr
;
1304 olen
= min((pgoff_t
)4 * ADDRS_PER_BLOCK(src_inode
), len
);
1306 src_blkaddr
= f2fs_kvzalloc(F2FS_I_SB(src_inode
),
1307 array_size(olen
, sizeof(block_t
)),
1312 do_replace
= f2fs_kvzalloc(F2FS_I_SB(src_inode
),
1313 array_size(olen
, sizeof(int)),
1316 kvfree(src_blkaddr
);
1320 ret
= __read_out_blkaddrs(src_inode
, src_blkaddr
,
1321 do_replace
, src
, olen
);
1325 ret
= __clone_blkaddrs(src_inode
, dst_inode
, src_blkaddr
,
1326 do_replace
, src
, dst
, olen
, full
);
1334 kvfree(src_blkaddr
);
1340 __roll_back_blkaddrs(src_inode
, src_blkaddr
, do_replace
, src
, olen
);
1341 kvfree(src_blkaddr
);
1346 static int f2fs_do_collapse(struct inode
*inode
, loff_t offset
, loff_t len
)
1348 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
1349 pgoff_t nrpages
= DIV_ROUND_UP(i_size_read(inode
), PAGE_SIZE
);
1350 pgoff_t start
= offset
>> PAGE_SHIFT
;
1351 pgoff_t end
= (offset
+ len
) >> PAGE_SHIFT
;
1354 f2fs_balance_fs(sbi
, true);
1356 /* avoid gc operation during block exchange */
1357 down_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
1358 filemap_invalidate_lock(inode
->i_mapping
);
1361 f2fs_drop_extent_tree(inode
);
1362 truncate_pagecache(inode
, offset
);
1363 ret
= __exchange_data_block(inode
, inode
, end
, start
, nrpages
- end
, true);
1364 f2fs_unlock_op(sbi
);
1366 filemap_invalidate_unlock(inode
->i_mapping
);
1367 up_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
1371 static int f2fs_collapse_range(struct inode
*inode
, loff_t offset
, loff_t len
)
1376 if (offset
+ len
>= i_size_read(inode
))
1379 /* collapse range should be aligned to block size of f2fs. */
1380 if (offset
& (F2FS_BLKSIZE
- 1) || len
& (F2FS_BLKSIZE
- 1))
1383 ret
= f2fs_convert_inline_inode(inode
);
1387 /* write out all dirty pages from offset */
1388 ret
= filemap_write_and_wait_range(inode
->i_mapping
, offset
, LLONG_MAX
);
1392 ret
= f2fs_do_collapse(inode
, offset
, len
);
1396 /* write out all moved pages, if possible */
1397 filemap_invalidate_lock(inode
->i_mapping
);
1398 filemap_write_and_wait_range(inode
->i_mapping
, offset
, LLONG_MAX
);
1399 truncate_pagecache(inode
, offset
);
1401 new_size
= i_size_read(inode
) - len
;
1402 ret
= f2fs_truncate_blocks(inode
, new_size
, true);
1403 filemap_invalidate_unlock(inode
->i_mapping
);
1405 f2fs_i_size_write(inode
, new_size
);
1409 static int f2fs_do_zero_range(struct dnode_of_data
*dn
, pgoff_t start
,
1412 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dn
->inode
);
1413 pgoff_t index
= start
;
1414 unsigned int ofs_in_node
= dn
->ofs_in_node
;
1418 for (; index
< end
; index
++, dn
->ofs_in_node
++) {
1419 if (f2fs_data_blkaddr(dn
) == NULL_ADDR
)
1423 dn
->ofs_in_node
= ofs_in_node
;
1424 ret
= f2fs_reserve_new_blocks(dn
, count
);
1428 dn
->ofs_in_node
= ofs_in_node
;
1429 for (index
= start
; index
< end
; index
++, dn
->ofs_in_node
++) {
1430 dn
->data_blkaddr
= f2fs_data_blkaddr(dn
);
1432 * f2fs_reserve_new_blocks will not guarantee entire block
1435 if (dn
->data_blkaddr
== NULL_ADDR
) {
1439 if (dn
->data_blkaddr
!= NEW_ADDR
) {
1440 f2fs_invalidate_blocks(sbi
, dn
->data_blkaddr
);
1441 dn
->data_blkaddr
= NEW_ADDR
;
1442 f2fs_set_data_blkaddr(dn
);
1446 f2fs_update_extent_cache_range(dn
, start
, 0, index
- start
);
1451 static int f2fs_zero_range(struct inode
*inode
, loff_t offset
, loff_t len
,
1454 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
1455 struct address_space
*mapping
= inode
->i_mapping
;
1456 pgoff_t index
, pg_start
, pg_end
;
1457 loff_t new_size
= i_size_read(inode
);
1458 loff_t off_start
, off_end
;
1461 ret
= inode_newsize_ok(inode
, (len
+ offset
));
1465 ret
= f2fs_convert_inline_inode(inode
);
1469 ret
= filemap_write_and_wait_range(mapping
, offset
, offset
+ len
- 1);
1473 pg_start
= ((unsigned long long) offset
) >> PAGE_SHIFT
;
1474 pg_end
= ((unsigned long long) offset
+ len
) >> PAGE_SHIFT
;
1476 off_start
= offset
& (PAGE_SIZE
- 1);
1477 off_end
= (offset
+ len
) & (PAGE_SIZE
- 1);
1479 if (pg_start
== pg_end
) {
1480 ret
= fill_zero(inode
, pg_start
, off_start
,
1481 off_end
- off_start
);
1485 new_size
= max_t(loff_t
, new_size
, offset
+ len
);
1488 ret
= fill_zero(inode
, pg_start
++, off_start
,
1489 PAGE_SIZE
- off_start
);
1493 new_size
= max_t(loff_t
, new_size
,
1494 (loff_t
)pg_start
<< PAGE_SHIFT
);
1497 for (index
= pg_start
; index
< pg_end
;) {
1498 struct dnode_of_data dn
;
1499 unsigned int end_offset
;
1502 down_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
1503 filemap_invalidate_lock(mapping
);
1505 truncate_pagecache_range(inode
,
1506 (loff_t
)index
<< PAGE_SHIFT
,
1507 ((loff_t
)pg_end
<< PAGE_SHIFT
) - 1);
1511 set_new_dnode(&dn
, inode
, NULL
, NULL
, 0);
1512 ret
= f2fs_get_dnode_of_data(&dn
, index
, ALLOC_NODE
);
1514 f2fs_unlock_op(sbi
);
1515 filemap_invalidate_unlock(mapping
);
1516 up_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
1520 end_offset
= ADDRS_PER_PAGE(dn
.node_page
, inode
);
1521 end
= min(pg_end
, end_offset
- dn
.ofs_in_node
+ index
);
1523 ret
= f2fs_do_zero_range(&dn
, index
, end
);
1524 f2fs_put_dnode(&dn
);
1526 f2fs_unlock_op(sbi
);
1527 filemap_invalidate_unlock(mapping
);
1528 up_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
1530 f2fs_balance_fs(sbi
, dn
.node_changed
);
1536 new_size
= max_t(loff_t
, new_size
,
1537 (loff_t
)index
<< PAGE_SHIFT
);
1541 ret
= fill_zero(inode
, pg_end
, 0, off_end
);
1545 new_size
= max_t(loff_t
, new_size
, offset
+ len
);
1550 if (new_size
> i_size_read(inode
)) {
1551 if (mode
& FALLOC_FL_KEEP_SIZE
)
1552 file_set_keep_isize(inode
);
1554 f2fs_i_size_write(inode
, new_size
);
1559 static int f2fs_insert_range(struct inode
*inode
, loff_t offset
, loff_t len
)
1561 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
1562 struct address_space
*mapping
= inode
->i_mapping
;
1563 pgoff_t nr
, pg_start
, pg_end
, delta
, idx
;
1567 new_size
= i_size_read(inode
) + len
;
1568 ret
= inode_newsize_ok(inode
, new_size
);
1572 if (offset
>= i_size_read(inode
))
1575 /* insert range should be aligned to block size of f2fs. */
1576 if (offset
& (F2FS_BLKSIZE
- 1) || len
& (F2FS_BLKSIZE
- 1))
1579 ret
= f2fs_convert_inline_inode(inode
);
1583 f2fs_balance_fs(sbi
, true);
1585 filemap_invalidate_lock(mapping
);
1586 ret
= f2fs_truncate_blocks(inode
, i_size_read(inode
), true);
1587 filemap_invalidate_unlock(mapping
);
1591 /* write out all dirty pages from offset */
1592 ret
= filemap_write_and_wait_range(mapping
, offset
, LLONG_MAX
);
1596 pg_start
= offset
>> PAGE_SHIFT
;
1597 pg_end
= (offset
+ len
) >> PAGE_SHIFT
;
1598 delta
= pg_end
- pg_start
;
1599 idx
= DIV_ROUND_UP(i_size_read(inode
), PAGE_SIZE
);
1601 /* avoid gc operation during block exchange */
1602 down_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
1603 filemap_invalidate_lock(mapping
);
1604 truncate_pagecache(inode
, offset
);
1606 while (!ret
&& idx
> pg_start
) {
1607 nr
= idx
- pg_start
;
1613 f2fs_drop_extent_tree(inode
);
1615 ret
= __exchange_data_block(inode
, inode
, idx
,
1616 idx
+ delta
, nr
, false);
1617 f2fs_unlock_op(sbi
);
1619 filemap_invalidate_unlock(mapping
);
1620 up_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
1622 /* write out all moved pages, if possible */
1623 filemap_invalidate_lock(mapping
);
1624 filemap_write_and_wait_range(mapping
, offset
, LLONG_MAX
);
1625 truncate_pagecache(inode
, offset
);
1626 filemap_invalidate_unlock(mapping
);
1629 f2fs_i_size_write(inode
, new_size
);
1633 static int expand_inode_data(struct inode
*inode
, loff_t offset
,
1634 loff_t len
, int mode
)
1636 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
1637 struct f2fs_map_blocks map
= { .m_next_pgofs
= NULL
,
1638 .m_next_extent
= NULL
, .m_seg_type
= NO_CHECK_TYPE
,
1639 .m_may_create
= true };
1640 pgoff_t pg_start
, pg_end
;
1641 loff_t new_size
= i_size_read(inode
);
1643 block_t expanded
= 0;
1646 err
= inode_newsize_ok(inode
, (len
+ offset
));
1650 err
= f2fs_convert_inline_inode(inode
);
1654 f2fs_balance_fs(sbi
, true);
1656 pg_start
= ((unsigned long long)offset
) >> PAGE_SHIFT
;
1657 pg_end
= ((unsigned long long)offset
+ len
) >> PAGE_SHIFT
;
1658 off_end
= (offset
+ len
) & (PAGE_SIZE
- 1);
1660 map
.m_lblk
= pg_start
;
1661 map
.m_len
= pg_end
- pg_start
;
1668 if (f2fs_is_pinned_file(inode
)) {
1669 block_t sec_blks
= BLKS_PER_SEC(sbi
);
1670 block_t sec_len
= roundup(map
.m_len
, sec_blks
);
1672 map
.m_len
= sec_blks
;
1674 if (has_not_enough_free_secs(sbi
, 0,
1675 GET_SEC_FROM_SEG(sbi
, overprovision_segments(sbi
)))) {
1676 down_write(&sbi
->gc_lock
);
1677 err
= f2fs_gc(sbi
, true, false, false, NULL_SEGNO
);
1678 if (err
&& err
!= -ENODATA
&& err
!= -EAGAIN
)
1682 down_write(&sbi
->pin_sem
);
1685 f2fs_allocate_new_section(sbi
, CURSEG_COLD_DATA_PINNED
, false);
1686 f2fs_unlock_op(sbi
);
1688 map
.m_seg_type
= CURSEG_COLD_DATA_PINNED
;
1689 err
= f2fs_map_blocks(inode
, &map
, 1, F2FS_GET_BLOCK_PRE_DIO
);
1691 up_write(&sbi
->pin_sem
);
1693 expanded
+= map
.m_len
;
1694 sec_len
-= map
.m_len
;
1695 map
.m_lblk
+= map
.m_len
;
1696 if (!err
&& sec_len
)
1699 map
.m_len
= expanded
;
1701 err
= f2fs_map_blocks(inode
, &map
, 1, F2FS_GET_BLOCK_PRE_AIO
);
1702 expanded
= map
.m_len
;
1711 last_off
= pg_start
+ expanded
- 1;
1713 /* update new size to the failed position */
1714 new_size
= (last_off
== pg_end
) ? offset
+ len
:
1715 (loff_t
)(last_off
+ 1) << PAGE_SHIFT
;
1717 new_size
= ((loff_t
)pg_end
<< PAGE_SHIFT
) + off_end
;
1720 if (new_size
> i_size_read(inode
)) {
1721 if (mode
& FALLOC_FL_KEEP_SIZE
)
1722 file_set_keep_isize(inode
);
1724 f2fs_i_size_write(inode
, new_size
);
1730 static long f2fs_fallocate(struct file
*file
, int mode
,
1731 loff_t offset
, loff_t len
)
1733 struct inode
*inode
= file_inode(file
);
1736 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode
))))
1738 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode
)))
1740 if (!f2fs_is_compress_backend_ready(inode
))
1743 /* f2fs only support ->fallocate for regular file */
1744 if (!S_ISREG(inode
->i_mode
))
1747 if (IS_ENCRYPTED(inode
) &&
1748 (mode
& (FALLOC_FL_COLLAPSE_RANGE
| FALLOC_FL_INSERT_RANGE
)))
1751 if (f2fs_compressed_file(inode
) &&
1752 (mode
& (FALLOC_FL_PUNCH_HOLE
| FALLOC_FL_COLLAPSE_RANGE
|
1753 FALLOC_FL_ZERO_RANGE
| FALLOC_FL_INSERT_RANGE
)))
1756 if (mode
& ~(FALLOC_FL_KEEP_SIZE
| FALLOC_FL_PUNCH_HOLE
|
1757 FALLOC_FL_COLLAPSE_RANGE
| FALLOC_FL_ZERO_RANGE
|
1758 FALLOC_FL_INSERT_RANGE
))
1763 if (mode
& FALLOC_FL_PUNCH_HOLE
) {
1764 if (offset
>= inode
->i_size
)
1767 ret
= punch_hole(inode
, offset
, len
);
1768 } else if (mode
& FALLOC_FL_COLLAPSE_RANGE
) {
1769 ret
= f2fs_collapse_range(inode
, offset
, len
);
1770 } else if (mode
& FALLOC_FL_ZERO_RANGE
) {
1771 ret
= f2fs_zero_range(inode
, offset
, len
, mode
);
1772 } else if (mode
& FALLOC_FL_INSERT_RANGE
) {
1773 ret
= f2fs_insert_range(inode
, offset
, len
);
1775 ret
= expand_inode_data(inode
, offset
, len
, mode
);
1779 inode
->i_mtime
= inode
->i_ctime
= current_time(inode
);
1780 f2fs_mark_inode_dirty_sync(inode
, false);
1781 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
1785 inode_unlock(inode
);
1787 trace_f2fs_fallocate(inode
, mode
, offset
, len
, ret
);
1791 static int f2fs_release_file(struct inode
*inode
, struct file
*filp
)
1794 * f2fs_relase_file is called at every close calls. So we should
1795 * not drop any inmemory pages by close called by other process.
1797 if (!(filp
->f_mode
& FMODE_WRITE
) ||
1798 atomic_read(&inode
->i_writecount
) != 1)
1801 /* some remained atomic pages should discarded */
1802 if (f2fs_is_atomic_file(inode
))
1803 f2fs_drop_inmem_pages(inode
);
1804 if (f2fs_is_volatile_file(inode
)) {
1805 set_inode_flag(inode
, FI_DROP_CACHE
);
1806 filemap_fdatawrite(inode
->i_mapping
);
1807 clear_inode_flag(inode
, FI_DROP_CACHE
);
1808 clear_inode_flag(inode
, FI_VOLATILE_FILE
);
1809 stat_dec_volatile_write(inode
);
1814 static int f2fs_file_flush(struct file
*file
, fl_owner_t id
)
1816 struct inode
*inode
= file_inode(file
);
1819 * If the process doing a transaction is crashed, we should do
1820 * roll-back. Otherwise, other reader/write can see corrupted database
1821 * until all the writers close its file. Since this should be done
1822 * before dropping file lock, it needs to do in ->flush.
1824 if (f2fs_is_atomic_file(inode
) &&
1825 F2FS_I(inode
)->inmem_task
== current
)
1826 f2fs_drop_inmem_pages(inode
);
1830 static int f2fs_setflags_common(struct inode
*inode
, u32 iflags
, u32 mask
)
1832 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
1833 u32 masked_flags
= fi
->i_flags
& mask
;
1835 /* mask can be shrunk by flags_valid selector */
1838 /* Is it quota file? Do not allow user to mess with it */
1839 if (IS_NOQUOTA(inode
))
1842 if ((iflags
^ masked_flags
) & F2FS_CASEFOLD_FL
) {
1843 if (!f2fs_sb_has_casefold(F2FS_I_SB(inode
)))
1845 if (!f2fs_empty_dir(inode
))
1849 if (iflags
& (F2FS_COMPR_FL
| F2FS_NOCOMP_FL
)) {
1850 if (!f2fs_sb_has_compression(F2FS_I_SB(inode
)))
1852 if ((iflags
& F2FS_COMPR_FL
) && (iflags
& F2FS_NOCOMP_FL
))
1856 if ((iflags
^ masked_flags
) & F2FS_COMPR_FL
) {
1857 if (masked_flags
& F2FS_COMPR_FL
) {
1858 if (!f2fs_disable_compressed_file(inode
))
1861 if (iflags
& F2FS_NOCOMP_FL
)
1863 if (iflags
& F2FS_COMPR_FL
) {
1864 if (!f2fs_may_compress(inode
))
1866 if (S_ISREG(inode
->i_mode
) && inode
->i_size
)
1869 set_compress_context(inode
);
1872 if ((iflags
^ masked_flags
) & F2FS_NOCOMP_FL
) {
1873 if (masked_flags
& F2FS_COMPR_FL
)
1877 fi
->i_flags
= iflags
| (fi
->i_flags
& ~mask
);
1878 f2fs_bug_on(F2FS_I_SB(inode
), (fi
->i_flags
& F2FS_COMPR_FL
) &&
1879 (fi
->i_flags
& F2FS_NOCOMP_FL
));
1881 if (fi
->i_flags
& F2FS_PROJINHERIT_FL
)
1882 set_inode_flag(inode
, FI_PROJ_INHERIT
);
1884 clear_inode_flag(inode
, FI_PROJ_INHERIT
);
1886 inode
->i_ctime
= current_time(inode
);
1887 f2fs_set_inode_flags(inode
);
1888 f2fs_mark_inode_dirty_sync(inode
, true);
1892 /* FS_IOC_[GS]ETFLAGS and FS_IOC_FS[GS]ETXATTR support */
1895 * To make a new on-disk f2fs i_flag gettable via FS_IOC_GETFLAGS, add an entry
1896 * for it to f2fs_fsflags_map[], and add its FS_*_FL equivalent to
1897 * F2FS_GETTABLE_FS_FL. To also make it settable via FS_IOC_SETFLAGS, also add
1898 * its FS_*_FL equivalent to F2FS_SETTABLE_FS_FL.
1900 * Translating flags to fsx_flags value used by FS_IOC_FSGETXATTR and
1901 * FS_IOC_FSSETXATTR is done by the VFS.
1904 static const struct {
1907 } f2fs_fsflags_map
[] = {
1908 { F2FS_COMPR_FL
, FS_COMPR_FL
},
1909 { F2FS_SYNC_FL
, FS_SYNC_FL
},
1910 { F2FS_IMMUTABLE_FL
, FS_IMMUTABLE_FL
},
1911 { F2FS_APPEND_FL
, FS_APPEND_FL
},
1912 { F2FS_NODUMP_FL
, FS_NODUMP_FL
},
1913 { F2FS_NOATIME_FL
, FS_NOATIME_FL
},
1914 { F2FS_NOCOMP_FL
, FS_NOCOMP_FL
},
1915 { F2FS_INDEX_FL
, FS_INDEX_FL
},
1916 { F2FS_DIRSYNC_FL
, FS_DIRSYNC_FL
},
1917 { F2FS_PROJINHERIT_FL
, FS_PROJINHERIT_FL
},
1918 { F2FS_CASEFOLD_FL
, FS_CASEFOLD_FL
},
1921 #define F2FS_GETTABLE_FS_FL ( \
1931 FS_PROJINHERIT_FL | \
1933 FS_INLINE_DATA_FL | \
1938 #define F2FS_SETTABLE_FS_FL ( \
1947 FS_PROJINHERIT_FL | \
1950 /* Convert f2fs on-disk i_flags to FS_IOC_{GET,SET}FLAGS flags */
1951 static inline u32
f2fs_iflags_to_fsflags(u32 iflags
)
1956 for (i
= 0; i
< ARRAY_SIZE(f2fs_fsflags_map
); i
++)
1957 if (iflags
& f2fs_fsflags_map
[i
].iflag
)
1958 fsflags
|= f2fs_fsflags_map
[i
].fsflag
;
1963 /* Convert FS_IOC_{GET,SET}FLAGS flags to f2fs on-disk i_flags */
1964 static inline u32
f2fs_fsflags_to_iflags(u32 fsflags
)
1969 for (i
= 0; i
< ARRAY_SIZE(f2fs_fsflags_map
); i
++)
1970 if (fsflags
& f2fs_fsflags_map
[i
].fsflag
)
1971 iflags
|= f2fs_fsflags_map
[i
].iflag
;
1976 static int f2fs_ioc_getversion(struct file
*filp
, unsigned long arg
)
1978 struct inode
*inode
= file_inode(filp
);
1980 return put_user(inode
->i_generation
, (int __user
*)arg
);
1983 static int f2fs_ioc_start_atomic_write(struct file
*filp
)
1985 struct inode
*inode
= file_inode(filp
);
1986 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
1987 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
1990 if (!inode_owner_or_capable(&init_user_ns
, inode
))
1993 if (!S_ISREG(inode
->i_mode
))
1996 if (filp
->f_flags
& O_DIRECT
)
1999 ret
= mnt_want_write_file(filp
);
2005 if (!f2fs_disable_compressed_file(inode
)) {
2010 if (f2fs_is_atomic_file(inode
)) {
2011 if (is_inode_flag_set(inode
, FI_ATOMIC_REVOKE_REQUEST
))
2016 ret
= f2fs_convert_inline_inode(inode
);
2020 down_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
2023 * Should wait end_io to count F2FS_WB_CP_DATA correctly by
2024 * f2fs_is_atomic_file.
2026 if (get_dirty_pages(inode
))
2027 f2fs_warn(F2FS_I_SB(inode
), "Unexpected flush for atomic writes: ino=%lu, npages=%u",
2028 inode
->i_ino
, get_dirty_pages(inode
));
2029 ret
= filemap_write_and_wait_range(inode
->i_mapping
, 0, LLONG_MAX
);
2031 up_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
2035 spin_lock(&sbi
->inode_lock
[ATOMIC_FILE
]);
2036 if (list_empty(&fi
->inmem_ilist
))
2037 list_add_tail(&fi
->inmem_ilist
, &sbi
->inode_list
[ATOMIC_FILE
]);
2038 sbi
->atomic_files
++;
2039 spin_unlock(&sbi
->inode_lock
[ATOMIC_FILE
]);
2041 /* add inode in inmem_list first and set atomic_file */
2042 set_inode_flag(inode
, FI_ATOMIC_FILE
);
2043 clear_inode_flag(inode
, FI_ATOMIC_REVOKE_REQUEST
);
2044 up_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
2046 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
2047 F2FS_I(inode
)->inmem_task
= current
;
2048 stat_update_max_atomic_write(inode
);
2050 inode_unlock(inode
);
2051 mnt_drop_write_file(filp
);
2055 static int f2fs_ioc_commit_atomic_write(struct file
*filp
)
2057 struct inode
*inode
= file_inode(filp
);
2060 if (!inode_owner_or_capable(&init_user_ns
, inode
))
2063 ret
= mnt_want_write_file(filp
);
2067 f2fs_balance_fs(F2FS_I_SB(inode
), true);
2071 if (f2fs_is_volatile_file(inode
)) {
2076 if (f2fs_is_atomic_file(inode
)) {
2077 ret
= f2fs_commit_inmem_pages(inode
);
2081 ret
= f2fs_do_sync_file(filp
, 0, LLONG_MAX
, 0, true);
2083 f2fs_drop_inmem_pages(inode
);
2085 ret
= f2fs_do_sync_file(filp
, 0, LLONG_MAX
, 1, false);
2088 if (is_inode_flag_set(inode
, FI_ATOMIC_REVOKE_REQUEST
)) {
2089 clear_inode_flag(inode
, FI_ATOMIC_REVOKE_REQUEST
);
2092 inode_unlock(inode
);
2093 mnt_drop_write_file(filp
);
2097 static int f2fs_ioc_start_volatile_write(struct file
*filp
)
2099 struct inode
*inode
= file_inode(filp
);
2102 if (!inode_owner_or_capable(&init_user_ns
, inode
))
2105 if (!S_ISREG(inode
->i_mode
))
2108 ret
= mnt_want_write_file(filp
);
2114 if (f2fs_is_volatile_file(inode
))
2117 ret
= f2fs_convert_inline_inode(inode
);
2121 stat_inc_volatile_write(inode
);
2122 stat_update_max_volatile_write(inode
);
2124 set_inode_flag(inode
, FI_VOLATILE_FILE
);
2125 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
2127 inode_unlock(inode
);
2128 mnt_drop_write_file(filp
);
2132 static int f2fs_ioc_release_volatile_write(struct file
*filp
)
2134 struct inode
*inode
= file_inode(filp
);
2137 if (!inode_owner_or_capable(&init_user_ns
, inode
))
2140 ret
= mnt_want_write_file(filp
);
2146 if (!f2fs_is_volatile_file(inode
))
2149 if (!f2fs_is_first_block_written(inode
)) {
2150 ret
= truncate_partial_data_page(inode
, 0, true);
2154 ret
= punch_hole(inode
, 0, F2FS_BLKSIZE
);
2156 inode_unlock(inode
);
2157 mnt_drop_write_file(filp
);
2161 static int f2fs_ioc_abort_volatile_write(struct file
*filp
)
2163 struct inode
*inode
= file_inode(filp
);
2166 if (!inode_owner_or_capable(&init_user_ns
, inode
))
2169 ret
= mnt_want_write_file(filp
);
2175 if (f2fs_is_atomic_file(inode
))
2176 f2fs_drop_inmem_pages(inode
);
2177 if (f2fs_is_volatile_file(inode
)) {
2178 clear_inode_flag(inode
, FI_VOLATILE_FILE
);
2179 stat_dec_volatile_write(inode
);
2180 ret
= f2fs_do_sync_file(filp
, 0, LLONG_MAX
, 0, true);
2183 clear_inode_flag(inode
, FI_ATOMIC_REVOKE_REQUEST
);
2185 inode_unlock(inode
);
2187 mnt_drop_write_file(filp
);
2188 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
2192 static int f2fs_ioc_shutdown(struct file
*filp
, unsigned long arg
)
2194 struct inode
*inode
= file_inode(filp
);
2195 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
2196 struct super_block
*sb
= sbi
->sb
;
2200 if (!capable(CAP_SYS_ADMIN
))
2203 if (get_user(in
, (__u32 __user
*)arg
))
2206 if (in
!= F2FS_GOING_DOWN_FULLSYNC
) {
2207 ret
= mnt_want_write_file(filp
);
2209 if (ret
== -EROFS
) {
2211 f2fs_stop_checkpoint(sbi
, false);
2212 set_sbi_flag(sbi
, SBI_IS_SHUTDOWN
);
2213 trace_f2fs_shutdown(sbi
, in
, ret
);
2220 case F2FS_GOING_DOWN_FULLSYNC
:
2221 ret
= freeze_bdev(sb
->s_bdev
);
2224 f2fs_stop_checkpoint(sbi
, false);
2225 set_sbi_flag(sbi
, SBI_IS_SHUTDOWN
);
2226 thaw_bdev(sb
->s_bdev
);
2228 case F2FS_GOING_DOWN_METASYNC
:
2229 /* do checkpoint only */
2230 ret
= f2fs_sync_fs(sb
, 1);
2233 f2fs_stop_checkpoint(sbi
, false);
2234 set_sbi_flag(sbi
, SBI_IS_SHUTDOWN
);
2236 case F2FS_GOING_DOWN_NOSYNC
:
2237 f2fs_stop_checkpoint(sbi
, false);
2238 set_sbi_flag(sbi
, SBI_IS_SHUTDOWN
);
2240 case F2FS_GOING_DOWN_METAFLUSH
:
2241 f2fs_sync_meta_pages(sbi
, META
, LONG_MAX
, FS_META_IO
);
2242 f2fs_stop_checkpoint(sbi
, false);
2243 set_sbi_flag(sbi
, SBI_IS_SHUTDOWN
);
2245 case F2FS_GOING_DOWN_NEED_FSCK
:
2246 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
2247 set_sbi_flag(sbi
, SBI_CP_DISABLED_QUICK
);
2248 set_sbi_flag(sbi
, SBI_IS_DIRTY
);
2249 /* do checkpoint only */
2250 ret
= f2fs_sync_fs(sb
, 1);
2257 f2fs_stop_gc_thread(sbi
);
2258 f2fs_stop_discard_thread(sbi
);
2260 f2fs_drop_discard_cmd(sbi
);
2261 clear_opt(sbi
, DISCARD
);
2263 f2fs_update_time(sbi
, REQ_TIME
);
2265 if (in
!= F2FS_GOING_DOWN_FULLSYNC
)
2266 mnt_drop_write_file(filp
);
2268 trace_f2fs_shutdown(sbi
, in
, ret
);
2273 static int f2fs_ioc_fitrim(struct file
*filp
, unsigned long arg
)
2275 struct inode
*inode
= file_inode(filp
);
2276 struct super_block
*sb
= inode
->i_sb
;
2277 struct request_queue
*q
= bdev_get_queue(sb
->s_bdev
);
2278 struct fstrim_range range
;
2281 if (!capable(CAP_SYS_ADMIN
))
2284 if (!f2fs_hw_support_discard(F2FS_SB(sb
)))
2287 if (copy_from_user(&range
, (struct fstrim_range __user
*)arg
,
2291 ret
= mnt_want_write_file(filp
);
2295 range
.minlen
= max((unsigned int)range
.minlen
,
2296 q
->limits
.discard_granularity
);
2297 ret
= f2fs_trim_fs(F2FS_SB(sb
), &range
);
2298 mnt_drop_write_file(filp
);
2302 if (copy_to_user((struct fstrim_range __user
*)arg
, &range
,
2305 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
2309 static bool uuid_is_nonzero(__u8 u
[16])
2313 for (i
= 0; i
< 16; i
++)
2319 static int f2fs_ioc_set_encryption_policy(struct file
*filp
, unsigned long arg
)
2321 struct inode
*inode
= file_inode(filp
);
2323 if (!f2fs_sb_has_encrypt(F2FS_I_SB(inode
)))
2326 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
2328 return fscrypt_ioctl_set_policy(filp
, (const void __user
*)arg
);
2331 static int f2fs_ioc_get_encryption_policy(struct file
*filp
, unsigned long arg
)
2333 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp
))))
2335 return fscrypt_ioctl_get_policy(filp
, (void __user
*)arg
);
2338 static int f2fs_ioc_get_encryption_pwsalt(struct file
*filp
, unsigned long arg
)
2340 struct inode
*inode
= file_inode(filp
);
2341 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
2344 if (!f2fs_sb_has_encrypt(sbi
))
2347 err
= mnt_want_write_file(filp
);
2351 down_write(&sbi
->sb_lock
);
2353 if (uuid_is_nonzero(sbi
->raw_super
->encrypt_pw_salt
))
2356 /* update superblock with uuid */
2357 generate_random_uuid(sbi
->raw_super
->encrypt_pw_salt
);
2359 err
= f2fs_commit_super(sbi
, false);
2362 memset(sbi
->raw_super
->encrypt_pw_salt
, 0, 16);
2366 if (copy_to_user((__u8 __user
*)arg
, sbi
->raw_super
->encrypt_pw_salt
,
2370 up_write(&sbi
->sb_lock
);
2371 mnt_drop_write_file(filp
);
2375 static int f2fs_ioc_get_encryption_policy_ex(struct file
*filp
,
2378 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp
))))
2381 return fscrypt_ioctl_get_policy_ex(filp
, (void __user
*)arg
);
2384 static int f2fs_ioc_add_encryption_key(struct file
*filp
, unsigned long arg
)
2386 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp
))))
2389 return fscrypt_ioctl_add_key(filp
, (void __user
*)arg
);
2392 static int f2fs_ioc_remove_encryption_key(struct file
*filp
, unsigned long arg
)
2394 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp
))))
2397 return fscrypt_ioctl_remove_key(filp
, (void __user
*)arg
);
2400 static int f2fs_ioc_remove_encryption_key_all_users(struct file
*filp
,
2403 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp
))))
2406 return fscrypt_ioctl_remove_key_all_users(filp
, (void __user
*)arg
);
2409 static int f2fs_ioc_get_encryption_key_status(struct file
*filp
,
2412 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp
))))
2415 return fscrypt_ioctl_get_key_status(filp
, (void __user
*)arg
);
2418 static int f2fs_ioc_get_encryption_nonce(struct file
*filp
, unsigned long arg
)
2420 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp
))))
2423 return fscrypt_ioctl_get_nonce(filp
, (void __user
*)arg
);
2426 static int f2fs_ioc_gc(struct file
*filp
, unsigned long arg
)
2428 struct inode
*inode
= file_inode(filp
);
2429 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
2433 if (!capable(CAP_SYS_ADMIN
))
2436 if (get_user(sync
, (__u32 __user
*)arg
))
2439 if (f2fs_readonly(sbi
->sb
))
2442 ret
= mnt_want_write_file(filp
);
2447 if (!down_write_trylock(&sbi
->gc_lock
)) {
2452 down_write(&sbi
->gc_lock
);
2455 ret
= f2fs_gc(sbi
, sync
, true, false, NULL_SEGNO
);
2457 mnt_drop_write_file(filp
);
2461 static int __f2fs_ioc_gc_range(struct file
*filp
, struct f2fs_gc_range
*range
)
2463 struct f2fs_sb_info
*sbi
= F2FS_I_SB(file_inode(filp
));
2467 if (!capable(CAP_SYS_ADMIN
))
2469 if (f2fs_readonly(sbi
->sb
))
2472 end
= range
->start
+ range
->len
;
2473 if (end
< range
->start
|| range
->start
< MAIN_BLKADDR(sbi
) ||
2474 end
>= MAX_BLKADDR(sbi
))
2477 ret
= mnt_want_write_file(filp
);
2483 if (!down_write_trylock(&sbi
->gc_lock
)) {
2488 down_write(&sbi
->gc_lock
);
2491 ret
= f2fs_gc(sbi
, range
->sync
, true, false,
2492 GET_SEGNO(sbi
, range
->start
));
2498 range
->start
+= BLKS_PER_SEC(sbi
);
2499 if (range
->start
<= end
)
2502 mnt_drop_write_file(filp
);
2506 static int f2fs_ioc_gc_range(struct file
*filp
, unsigned long arg
)
2508 struct f2fs_gc_range range
;
2510 if (copy_from_user(&range
, (struct f2fs_gc_range __user
*)arg
,
2513 return __f2fs_ioc_gc_range(filp
, &range
);
2516 static int f2fs_ioc_write_checkpoint(struct file
*filp
, unsigned long arg
)
2518 struct inode
*inode
= file_inode(filp
);
2519 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
2522 if (!capable(CAP_SYS_ADMIN
))
2525 if (f2fs_readonly(sbi
->sb
))
2528 if (unlikely(is_sbi_flag_set(sbi
, SBI_CP_DISABLED
))) {
2529 f2fs_info(sbi
, "Skipping Checkpoint. Checkpoints currently disabled.");
2533 ret
= mnt_want_write_file(filp
);
2537 ret
= f2fs_sync_fs(sbi
->sb
, 1);
2539 mnt_drop_write_file(filp
);
2543 static int f2fs_defragment_range(struct f2fs_sb_info
*sbi
,
2545 struct f2fs_defragment
*range
)
2547 struct inode
*inode
= file_inode(filp
);
2548 struct f2fs_map_blocks map
= { .m_next_extent
= NULL
,
2549 .m_seg_type
= NO_CHECK_TYPE
,
2550 .m_may_create
= false };
2551 struct extent_info ei
= {0, 0, 0};
2552 pgoff_t pg_start
, pg_end
, next_pgofs
;
2553 unsigned int blk_per_seg
= sbi
->blocks_per_seg
;
2554 unsigned int total
= 0, sec_num
;
2555 block_t blk_end
= 0;
2556 bool fragmented
= false;
2559 /* if in-place-update policy is enabled, don't waste time here */
2560 if (f2fs_should_update_inplace(inode
, NULL
))
2563 pg_start
= range
->start
>> PAGE_SHIFT
;
2564 pg_end
= (range
->start
+ range
->len
) >> PAGE_SHIFT
;
2566 f2fs_balance_fs(sbi
, true);
2570 /* writeback all dirty pages in the range */
2571 err
= filemap_write_and_wait_range(inode
->i_mapping
, range
->start
,
2572 range
->start
+ range
->len
- 1);
2577 * lookup mapping info in extent cache, skip defragmenting if physical
2578 * block addresses are continuous.
2580 if (f2fs_lookup_extent_cache(inode
, pg_start
, &ei
)) {
2581 if (ei
.fofs
+ ei
.len
>= pg_end
)
2585 map
.m_lblk
= pg_start
;
2586 map
.m_next_pgofs
= &next_pgofs
;
2589 * lookup mapping info in dnode page cache, skip defragmenting if all
2590 * physical block addresses are continuous even if there are hole(s)
2591 * in logical blocks.
2593 while (map
.m_lblk
< pg_end
) {
2594 map
.m_len
= pg_end
- map
.m_lblk
;
2595 err
= f2fs_map_blocks(inode
, &map
, 0, F2FS_GET_BLOCK_DEFAULT
);
2599 if (!(map
.m_flags
& F2FS_MAP_FLAGS
)) {
2600 map
.m_lblk
= next_pgofs
;
2604 if (blk_end
&& blk_end
!= map
.m_pblk
)
2607 /* record total count of block that we're going to move */
2610 blk_end
= map
.m_pblk
+ map
.m_len
;
2612 map
.m_lblk
+= map
.m_len
;
2620 sec_num
= DIV_ROUND_UP(total
, BLKS_PER_SEC(sbi
));
2623 * make sure there are enough free section for LFS allocation, this can
2624 * avoid defragment running in SSR mode when free section are allocated
2627 if (has_not_enough_free_secs(sbi
, 0, sec_num
)) {
2632 map
.m_lblk
= pg_start
;
2633 map
.m_len
= pg_end
- pg_start
;
2636 while (map
.m_lblk
< pg_end
) {
2641 map
.m_len
= pg_end
- map
.m_lblk
;
2642 err
= f2fs_map_blocks(inode
, &map
, 0, F2FS_GET_BLOCK_DEFAULT
);
2646 if (!(map
.m_flags
& F2FS_MAP_FLAGS
)) {
2647 map
.m_lblk
= next_pgofs
;
2651 set_inode_flag(inode
, FI_DO_DEFRAG
);
2654 while (idx
< map
.m_lblk
+ map
.m_len
&& cnt
< blk_per_seg
) {
2657 page
= f2fs_get_lock_data_page(inode
, idx
, true);
2659 err
= PTR_ERR(page
);
2663 set_page_dirty(page
);
2664 f2fs_put_page(page
, 1);
2673 if (map
.m_lblk
< pg_end
&& cnt
< blk_per_seg
)
2676 clear_inode_flag(inode
, FI_DO_DEFRAG
);
2678 err
= filemap_fdatawrite(inode
->i_mapping
);
2683 clear_inode_flag(inode
, FI_DO_DEFRAG
);
2685 inode_unlock(inode
);
2687 range
->len
= (u64
)total
<< PAGE_SHIFT
;
2691 static int f2fs_ioc_defragment(struct file
*filp
, unsigned long arg
)
2693 struct inode
*inode
= file_inode(filp
);
2694 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
2695 struct f2fs_defragment range
;
2698 if (!capable(CAP_SYS_ADMIN
))
2701 if (!S_ISREG(inode
->i_mode
) || f2fs_is_atomic_file(inode
))
2704 if (f2fs_readonly(sbi
->sb
))
2707 if (copy_from_user(&range
, (struct f2fs_defragment __user
*)arg
,
2711 /* verify alignment of offset & size */
2712 if (range
.start
& (F2FS_BLKSIZE
- 1) || range
.len
& (F2FS_BLKSIZE
- 1))
2715 if (unlikely((range
.start
+ range
.len
) >> PAGE_SHIFT
>
2716 max_file_blocks(inode
)))
2719 err
= mnt_want_write_file(filp
);
2723 err
= f2fs_defragment_range(sbi
, filp
, &range
);
2724 mnt_drop_write_file(filp
);
2726 f2fs_update_time(sbi
, REQ_TIME
);
2730 if (copy_to_user((struct f2fs_defragment __user
*)arg
, &range
,
2737 static int f2fs_move_file_range(struct file
*file_in
, loff_t pos_in
,
2738 struct file
*file_out
, loff_t pos_out
, size_t len
)
2740 struct inode
*src
= file_inode(file_in
);
2741 struct inode
*dst
= file_inode(file_out
);
2742 struct f2fs_sb_info
*sbi
= F2FS_I_SB(src
);
2743 size_t olen
= len
, dst_max_i_size
= 0;
2747 if (file_in
->f_path
.mnt
!= file_out
->f_path
.mnt
||
2748 src
->i_sb
!= dst
->i_sb
)
2751 if (unlikely(f2fs_readonly(src
->i_sb
)))
2754 if (!S_ISREG(src
->i_mode
) || !S_ISREG(dst
->i_mode
))
2757 if (IS_ENCRYPTED(src
) || IS_ENCRYPTED(dst
))
2760 if (pos_out
< 0 || pos_in
< 0)
2764 if (pos_in
== pos_out
)
2766 if (pos_out
> pos_in
&& pos_out
< pos_in
+ len
)
2773 if (!inode_trylock(dst
))
2778 if (pos_in
+ len
> src
->i_size
|| pos_in
+ len
< pos_in
)
2781 olen
= len
= src
->i_size
- pos_in
;
2782 if (pos_in
+ len
== src
->i_size
)
2783 len
= ALIGN(src
->i_size
, F2FS_BLKSIZE
) - pos_in
;
2789 dst_osize
= dst
->i_size
;
2790 if (pos_out
+ olen
> dst
->i_size
)
2791 dst_max_i_size
= pos_out
+ olen
;
2793 /* verify the end result is block aligned */
2794 if (!IS_ALIGNED(pos_in
, F2FS_BLKSIZE
) ||
2795 !IS_ALIGNED(pos_in
+ len
, F2FS_BLKSIZE
) ||
2796 !IS_ALIGNED(pos_out
, F2FS_BLKSIZE
))
2799 ret
= f2fs_convert_inline_inode(src
);
2803 ret
= f2fs_convert_inline_inode(dst
);
2807 /* write out all dirty pages from offset */
2808 ret
= filemap_write_and_wait_range(src
->i_mapping
,
2809 pos_in
, pos_in
+ len
);
2813 ret
= filemap_write_and_wait_range(dst
->i_mapping
,
2814 pos_out
, pos_out
+ len
);
2818 f2fs_balance_fs(sbi
, true);
2820 down_write(&F2FS_I(src
)->i_gc_rwsem
[WRITE
]);
2823 if (!down_write_trylock(&F2FS_I(dst
)->i_gc_rwsem
[WRITE
]))
2828 ret
= __exchange_data_block(src
, dst
, pos_in
>> F2FS_BLKSIZE_BITS
,
2829 pos_out
>> F2FS_BLKSIZE_BITS
,
2830 len
>> F2FS_BLKSIZE_BITS
, false);
2834 f2fs_i_size_write(dst
, dst_max_i_size
);
2835 else if (dst_osize
!= dst
->i_size
)
2836 f2fs_i_size_write(dst
, dst_osize
);
2838 f2fs_unlock_op(sbi
);
2841 up_write(&F2FS_I(dst
)->i_gc_rwsem
[WRITE
]);
2843 up_write(&F2FS_I(src
)->i_gc_rwsem
[WRITE
]);
2852 static int __f2fs_ioc_move_range(struct file
*filp
,
2853 struct f2fs_move_range
*range
)
2858 if (!(filp
->f_mode
& FMODE_READ
) ||
2859 !(filp
->f_mode
& FMODE_WRITE
))
2862 dst
= fdget(range
->dst_fd
);
2866 if (!(dst
.file
->f_mode
& FMODE_WRITE
)) {
2871 err
= mnt_want_write_file(filp
);
2875 err
= f2fs_move_file_range(filp
, range
->pos_in
, dst
.file
,
2876 range
->pos_out
, range
->len
);
2878 mnt_drop_write_file(filp
);
2884 static int f2fs_ioc_move_range(struct file
*filp
, unsigned long arg
)
2886 struct f2fs_move_range range
;
2888 if (copy_from_user(&range
, (struct f2fs_move_range __user
*)arg
,
2891 return __f2fs_ioc_move_range(filp
, &range
);
2894 static int f2fs_ioc_flush_device(struct file
*filp
, unsigned long arg
)
2896 struct inode
*inode
= file_inode(filp
);
2897 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
2898 struct sit_info
*sm
= SIT_I(sbi
);
2899 unsigned int start_segno
= 0, end_segno
= 0;
2900 unsigned int dev_start_segno
= 0, dev_end_segno
= 0;
2901 struct f2fs_flush_device range
;
2904 if (!capable(CAP_SYS_ADMIN
))
2907 if (f2fs_readonly(sbi
->sb
))
2910 if (unlikely(is_sbi_flag_set(sbi
, SBI_CP_DISABLED
)))
2913 if (copy_from_user(&range
, (struct f2fs_flush_device __user
*)arg
,
2917 if (!f2fs_is_multi_device(sbi
) || sbi
->s_ndevs
- 1 <= range
.dev_num
||
2918 __is_large_section(sbi
)) {
2919 f2fs_warn(sbi
, "Can't flush %u in %d for segs_per_sec %u != 1",
2920 range
.dev_num
, sbi
->s_ndevs
, sbi
->segs_per_sec
);
2924 ret
= mnt_want_write_file(filp
);
2928 if (range
.dev_num
!= 0)
2929 dev_start_segno
= GET_SEGNO(sbi
, FDEV(range
.dev_num
).start_blk
);
2930 dev_end_segno
= GET_SEGNO(sbi
, FDEV(range
.dev_num
).end_blk
);
2932 start_segno
= sm
->last_victim
[FLUSH_DEVICE
];
2933 if (start_segno
< dev_start_segno
|| start_segno
>= dev_end_segno
)
2934 start_segno
= dev_start_segno
;
2935 end_segno
= min(start_segno
+ range
.segments
, dev_end_segno
);
2937 while (start_segno
< end_segno
) {
2938 if (!down_write_trylock(&sbi
->gc_lock
)) {
2942 sm
->last_victim
[GC_CB
] = end_segno
+ 1;
2943 sm
->last_victim
[GC_GREEDY
] = end_segno
+ 1;
2944 sm
->last_victim
[ALLOC_NEXT
] = end_segno
+ 1;
2945 ret
= f2fs_gc(sbi
, true, true, true, start_segno
);
2953 mnt_drop_write_file(filp
);
2957 static int f2fs_ioc_get_features(struct file
*filp
, unsigned long arg
)
2959 struct inode
*inode
= file_inode(filp
);
2960 u32 sb_feature
= le32_to_cpu(F2FS_I_SB(inode
)->raw_super
->feature
);
2962 /* Must validate to set it with SQLite behavior in Android. */
2963 sb_feature
|= F2FS_FEATURE_ATOMIC_WRITE
;
2965 return put_user(sb_feature
, (u32 __user
*)arg
);
2969 int f2fs_transfer_project_quota(struct inode
*inode
, kprojid_t kprojid
)
2971 struct dquot
*transfer_to
[MAXQUOTAS
] = {};
2972 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
2973 struct super_block
*sb
= sbi
->sb
;
2976 transfer_to
[PRJQUOTA
] = dqget(sb
, make_kqid_projid(kprojid
));
2977 if (!IS_ERR(transfer_to
[PRJQUOTA
])) {
2978 err
= __dquot_transfer(inode
, transfer_to
);
2980 set_sbi_flag(sbi
, SBI_QUOTA_NEED_REPAIR
);
2981 dqput(transfer_to
[PRJQUOTA
]);
2986 static int f2fs_ioc_setproject(struct inode
*inode
, __u32 projid
)
2988 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
2989 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
2994 if (!f2fs_sb_has_project_quota(sbi
)) {
2995 if (projid
!= F2FS_DEF_PROJID
)
3001 if (!f2fs_has_extra_attr(inode
))
3004 kprojid
= make_kprojid(&init_user_ns
, (projid_t
)projid
);
3006 if (projid_eq(kprojid
, F2FS_I(inode
)->i_projid
))
3010 /* Is it quota file? Do not allow user to mess with it */
3011 if (IS_NOQUOTA(inode
))
3014 ipage
= f2fs_get_node_page(sbi
, inode
->i_ino
);
3016 return PTR_ERR(ipage
);
3018 if (!F2FS_FITS_IN_INODE(F2FS_INODE(ipage
), fi
->i_extra_isize
,
3021 f2fs_put_page(ipage
, 1);
3024 f2fs_put_page(ipage
, 1);
3026 err
= dquot_initialize(inode
);
3031 err
= f2fs_transfer_project_quota(inode
, kprojid
);
3035 F2FS_I(inode
)->i_projid
= kprojid
;
3036 inode
->i_ctime
= current_time(inode
);
3037 f2fs_mark_inode_dirty_sync(inode
, true);
3039 f2fs_unlock_op(sbi
);
3043 int f2fs_transfer_project_quota(struct inode
*inode
, kprojid_t kprojid
)
3048 static int f2fs_ioc_setproject(struct inode
*inode
, __u32 projid
)
3050 if (projid
!= F2FS_DEF_PROJID
)
3056 int f2fs_fileattr_get(struct dentry
*dentry
, struct fileattr
*fa
)
3058 struct inode
*inode
= d_inode(dentry
);
3059 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
3060 u32 fsflags
= f2fs_iflags_to_fsflags(fi
->i_flags
);
3062 if (IS_ENCRYPTED(inode
))
3063 fsflags
|= FS_ENCRYPT_FL
;
3064 if (IS_VERITY(inode
))
3065 fsflags
|= FS_VERITY_FL
;
3066 if (f2fs_has_inline_data(inode
) || f2fs_has_inline_dentry(inode
))
3067 fsflags
|= FS_INLINE_DATA_FL
;
3068 if (is_inode_flag_set(inode
, FI_PIN_FILE
))
3069 fsflags
|= FS_NOCOW_FL
;
3071 fileattr_fill_flags(fa
, fsflags
& F2FS_GETTABLE_FS_FL
);
3073 if (f2fs_sb_has_project_quota(F2FS_I_SB(inode
)))
3074 fa
->fsx_projid
= from_kprojid(&init_user_ns
, fi
->i_projid
);
3079 int f2fs_fileattr_set(struct user_namespace
*mnt_userns
,
3080 struct dentry
*dentry
, struct fileattr
*fa
)
3082 struct inode
*inode
= d_inode(dentry
);
3083 u32 fsflags
= fa
->flags
, mask
= F2FS_SETTABLE_FS_FL
;
3087 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode
))))
3089 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode
)))
3091 if (fsflags
& ~F2FS_GETTABLE_FS_FL
)
3093 fsflags
&= F2FS_SETTABLE_FS_FL
;
3094 if (!fa
->flags_valid
)
3095 mask
&= FS_COMMON_FL
;
3097 iflags
= f2fs_fsflags_to_iflags(fsflags
);
3098 if (f2fs_mask_flags(inode
->i_mode
, iflags
) != iflags
)
3101 err
= f2fs_setflags_common(inode
, iflags
, f2fs_fsflags_to_iflags(mask
));
3103 err
= f2fs_ioc_setproject(inode
, fa
->fsx_projid
);
3108 int f2fs_pin_file_control(struct inode
*inode
, bool inc
)
3110 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
3111 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
3113 /* Use i_gc_failures for normal file as a risk signal. */
3115 f2fs_i_gc_failures_write(inode
,
3116 fi
->i_gc_failures
[GC_FAILURE_PIN
] + 1);
3118 if (fi
->i_gc_failures
[GC_FAILURE_PIN
] > sbi
->gc_pin_file_threshold
) {
3119 f2fs_warn(sbi
, "%s: Enable GC = ino %lx after %x GC trials",
3120 __func__
, inode
->i_ino
,
3121 fi
->i_gc_failures
[GC_FAILURE_PIN
]);
3122 clear_inode_flag(inode
, FI_PIN_FILE
);
3128 static int f2fs_ioc_set_pin_file(struct file
*filp
, unsigned long arg
)
3130 struct inode
*inode
= file_inode(filp
);
3134 if (get_user(pin
, (__u32 __user
*)arg
))
3137 if (!S_ISREG(inode
->i_mode
))
3140 if (f2fs_readonly(F2FS_I_SB(inode
)->sb
))
3143 ret
= mnt_want_write_file(filp
);
3150 clear_inode_flag(inode
, FI_PIN_FILE
);
3151 f2fs_i_gc_failures_write(inode
, 0);
3155 if (f2fs_should_update_outplace(inode
, NULL
)) {
3160 if (f2fs_pin_file_control(inode
, false)) {
3165 ret
= f2fs_convert_inline_inode(inode
);
3169 if (!f2fs_disable_compressed_file(inode
)) {
3174 set_inode_flag(inode
, FI_PIN_FILE
);
3175 ret
= F2FS_I(inode
)->i_gc_failures
[GC_FAILURE_PIN
];
3177 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
3179 inode_unlock(inode
);
3180 mnt_drop_write_file(filp
);
3184 static int f2fs_ioc_get_pin_file(struct file
*filp
, unsigned long arg
)
3186 struct inode
*inode
= file_inode(filp
);
3189 if (is_inode_flag_set(inode
, FI_PIN_FILE
))
3190 pin
= F2FS_I(inode
)->i_gc_failures
[GC_FAILURE_PIN
];
3191 return put_user(pin
, (u32 __user
*)arg
);
3194 int f2fs_precache_extents(struct inode
*inode
)
3196 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
3197 struct f2fs_map_blocks map
;
3198 pgoff_t m_next_extent
;
3202 if (is_inode_flag_set(inode
, FI_NO_EXTENT
))
3206 map
.m_next_pgofs
= NULL
;
3207 map
.m_next_extent
= &m_next_extent
;
3208 map
.m_seg_type
= NO_CHECK_TYPE
;
3209 map
.m_may_create
= false;
3210 end
= max_file_blocks(inode
);
3212 while (map
.m_lblk
< end
) {
3213 map
.m_len
= end
- map
.m_lblk
;
3215 down_write(&fi
->i_gc_rwsem
[WRITE
]);
3216 err
= f2fs_map_blocks(inode
, &map
, 0, F2FS_GET_BLOCK_PRECACHE
);
3217 up_write(&fi
->i_gc_rwsem
[WRITE
]);
3221 map
.m_lblk
= m_next_extent
;
3227 static int f2fs_ioc_precache_extents(struct file
*filp
, unsigned long arg
)
3229 return f2fs_precache_extents(file_inode(filp
));
3232 static int f2fs_ioc_resize_fs(struct file
*filp
, unsigned long arg
)
3234 struct f2fs_sb_info
*sbi
= F2FS_I_SB(file_inode(filp
));
3237 if (!capable(CAP_SYS_ADMIN
))
3240 if (f2fs_readonly(sbi
->sb
))
3243 if (copy_from_user(&block_count
, (void __user
*)arg
,
3244 sizeof(block_count
)))
3247 return f2fs_resize_fs(sbi
, block_count
);
3250 static int f2fs_ioc_enable_verity(struct file
*filp
, unsigned long arg
)
3252 struct inode
*inode
= file_inode(filp
);
3254 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
3256 if (!f2fs_sb_has_verity(F2FS_I_SB(inode
))) {
3257 f2fs_warn(F2FS_I_SB(inode
),
3258 "Can't enable fs-verity on inode %lu: the verity feature is not enabled on this filesystem",
3263 return fsverity_ioctl_enable(filp
, (const void __user
*)arg
);
3266 static int f2fs_ioc_measure_verity(struct file
*filp
, unsigned long arg
)
3268 if (!f2fs_sb_has_verity(F2FS_I_SB(file_inode(filp
))))
3271 return fsverity_ioctl_measure(filp
, (void __user
*)arg
);
3274 static int f2fs_ioc_read_verity_metadata(struct file
*filp
, unsigned long arg
)
3276 if (!f2fs_sb_has_verity(F2FS_I_SB(file_inode(filp
))))
3279 return fsverity_ioctl_read_metadata(filp
, (const void __user
*)arg
);
3282 static int f2fs_ioc_getfslabel(struct file
*filp
, unsigned long arg
)
3284 struct inode
*inode
= file_inode(filp
);
3285 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
3290 vbuf
= f2fs_kzalloc(sbi
, MAX_VOLUME_NAME
, GFP_KERNEL
);
3294 down_read(&sbi
->sb_lock
);
3295 count
= utf16s_to_utf8s(sbi
->raw_super
->volume_name
,
3296 ARRAY_SIZE(sbi
->raw_super
->volume_name
),
3297 UTF16_LITTLE_ENDIAN
, vbuf
, MAX_VOLUME_NAME
);
3298 up_read(&sbi
->sb_lock
);
3300 if (copy_to_user((char __user
*)arg
, vbuf
,
3301 min(FSLABEL_MAX
, count
)))
3308 static int f2fs_ioc_setfslabel(struct file
*filp
, unsigned long arg
)
3310 struct inode
*inode
= file_inode(filp
);
3311 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
3315 if (!capable(CAP_SYS_ADMIN
))
3318 vbuf
= strndup_user((const char __user
*)arg
, FSLABEL_MAX
);
3320 return PTR_ERR(vbuf
);
3322 err
= mnt_want_write_file(filp
);
3326 down_write(&sbi
->sb_lock
);
3328 memset(sbi
->raw_super
->volume_name
, 0,
3329 sizeof(sbi
->raw_super
->volume_name
));
3330 utf8s_to_utf16s(vbuf
, strlen(vbuf
), UTF16_LITTLE_ENDIAN
,
3331 sbi
->raw_super
->volume_name
,
3332 ARRAY_SIZE(sbi
->raw_super
->volume_name
));
3334 err
= f2fs_commit_super(sbi
, false);
3336 up_write(&sbi
->sb_lock
);
3338 mnt_drop_write_file(filp
);
3344 static int f2fs_get_compress_blocks(struct file
*filp
, unsigned long arg
)
3346 struct inode
*inode
= file_inode(filp
);
3349 if (!f2fs_sb_has_compression(F2FS_I_SB(inode
)))
3352 if (!f2fs_compressed_file(inode
))
3355 blocks
= atomic_read(&F2FS_I(inode
)->i_compr_blocks
);
3356 return put_user(blocks
, (u64 __user
*)arg
);
3359 static int release_compress_blocks(struct dnode_of_data
*dn
, pgoff_t count
)
3361 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dn
->inode
);
3362 unsigned int released_blocks
= 0;
3363 int cluster_size
= F2FS_I(dn
->inode
)->i_cluster_size
;
3367 for (i
= 0; i
< count
; i
++) {
3368 blkaddr
= data_blkaddr(dn
->inode
, dn
->node_page
,
3369 dn
->ofs_in_node
+ i
);
3371 if (!__is_valid_data_blkaddr(blkaddr
))
3373 if (unlikely(!f2fs_is_valid_blkaddr(sbi
, blkaddr
,
3374 DATA_GENERIC_ENHANCE
)))
3375 return -EFSCORRUPTED
;
3379 int compr_blocks
= 0;
3381 for (i
= 0; i
< cluster_size
; i
++, dn
->ofs_in_node
++) {
3382 blkaddr
= f2fs_data_blkaddr(dn
);
3385 if (blkaddr
== COMPRESS_ADDR
)
3387 dn
->ofs_in_node
+= cluster_size
;
3391 if (__is_valid_data_blkaddr(blkaddr
))
3394 if (blkaddr
!= NEW_ADDR
)
3397 dn
->data_blkaddr
= NULL_ADDR
;
3398 f2fs_set_data_blkaddr(dn
);
3401 f2fs_i_compr_blocks_update(dn
->inode
, compr_blocks
, false);
3402 dec_valid_block_count(sbi
, dn
->inode
,
3403 cluster_size
- compr_blocks
);
3405 released_blocks
+= cluster_size
- compr_blocks
;
3407 count
-= cluster_size
;
3410 return released_blocks
;
3413 static int f2fs_release_compress_blocks(struct file
*filp
, unsigned long arg
)
3415 struct inode
*inode
= file_inode(filp
);
3416 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
3417 pgoff_t page_idx
= 0, last_idx
;
3418 unsigned int released_blocks
= 0;
3422 if (!f2fs_sb_has_compression(F2FS_I_SB(inode
)))
3425 if (!f2fs_compressed_file(inode
))
3428 if (f2fs_readonly(sbi
->sb
))
3431 ret
= mnt_want_write_file(filp
);
3435 f2fs_balance_fs(F2FS_I_SB(inode
), true);
3439 writecount
= atomic_read(&inode
->i_writecount
);
3440 if ((filp
->f_mode
& FMODE_WRITE
&& writecount
!= 1) ||
3441 (!(filp
->f_mode
& FMODE_WRITE
) && writecount
)) {
3446 if (is_inode_flag_set(inode
, FI_COMPRESS_RELEASED
)) {
3451 ret
= filemap_write_and_wait_range(inode
->i_mapping
, 0, LLONG_MAX
);
3455 set_inode_flag(inode
, FI_COMPRESS_RELEASED
);
3456 inode
->i_ctime
= current_time(inode
);
3457 f2fs_mark_inode_dirty_sync(inode
, true);
3459 if (!atomic_read(&F2FS_I(inode
)->i_compr_blocks
))
3462 down_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
3463 filemap_invalidate_lock(inode
->i_mapping
);
3465 last_idx
= DIV_ROUND_UP(i_size_read(inode
), PAGE_SIZE
);
3467 while (page_idx
< last_idx
) {
3468 struct dnode_of_data dn
;
3469 pgoff_t end_offset
, count
;
3471 set_new_dnode(&dn
, inode
, NULL
, NULL
, 0);
3472 ret
= f2fs_get_dnode_of_data(&dn
, page_idx
, LOOKUP_NODE
);
3474 if (ret
== -ENOENT
) {
3475 page_idx
= f2fs_get_next_page_offset(&dn
,
3483 end_offset
= ADDRS_PER_PAGE(dn
.node_page
, inode
);
3484 count
= min(end_offset
- dn
.ofs_in_node
, last_idx
- page_idx
);
3485 count
= round_up(count
, F2FS_I(inode
)->i_cluster_size
);
3487 ret
= release_compress_blocks(&dn
, count
);
3489 f2fs_put_dnode(&dn
);
3495 released_blocks
+= ret
;
3498 filemap_invalidate_unlock(inode
->i_mapping
);
3499 up_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
3501 inode_unlock(inode
);
3503 mnt_drop_write_file(filp
);
3506 ret
= put_user(released_blocks
, (u64 __user
*)arg
);
3507 } else if (released_blocks
&&
3508 atomic_read(&F2FS_I(inode
)->i_compr_blocks
)) {
3509 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
3510 f2fs_warn(sbi
, "%s: partial blocks were released i_ino=%lx "
3511 "iblocks=%llu, released=%u, compr_blocks=%u, "
3513 __func__
, inode
->i_ino
, inode
->i_blocks
,
3515 atomic_read(&F2FS_I(inode
)->i_compr_blocks
));
3521 static int reserve_compress_blocks(struct dnode_of_data
*dn
, pgoff_t count
)
3523 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dn
->inode
);
3524 unsigned int reserved_blocks
= 0;
3525 int cluster_size
= F2FS_I(dn
->inode
)->i_cluster_size
;
3529 for (i
= 0; i
< count
; i
++) {
3530 blkaddr
= data_blkaddr(dn
->inode
, dn
->node_page
,
3531 dn
->ofs_in_node
+ i
);
3533 if (!__is_valid_data_blkaddr(blkaddr
))
3535 if (unlikely(!f2fs_is_valid_blkaddr(sbi
, blkaddr
,
3536 DATA_GENERIC_ENHANCE
)))
3537 return -EFSCORRUPTED
;
3541 int compr_blocks
= 0;
3545 for (i
= 0; i
< cluster_size
; i
++, dn
->ofs_in_node
++) {
3546 blkaddr
= f2fs_data_blkaddr(dn
);
3549 if (blkaddr
== COMPRESS_ADDR
)
3551 dn
->ofs_in_node
+= cluster_size
;
3555 if (__is_valid_data_blkaddr(blkaddr
)) {
3560 dn
->data_blkaddr
= NEW_ADDR
;
3561 f2fs_set_data_blkaddr(dn
);
3564 reserved
= cluster_size
- compr_blocks
;
3565 ret
= inc_valid_block_count(sbi
, dn
->inode
, &reserved
);
3569 if (reserved
!= cluster_size
- compr_blocks
)
3572 f2fs_i_compr_blocks_update(dn
->inode
, compr_blocks
, true);
3574 reserved_blocks
+= reserved
;
3576 count
-= cluster_size
;
3579 return reserved_blocks
;
3582 static int f2fs_reserve_compress_blocks(struct file
*filp
, unsigned long arg
)
3584 struct inode
*inode
= file_inode(filp
);
3585 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
3586 pgoff_t page_idx
= 0, last_idx
;
3587 unsigned int reserved_blocks
= 0;
3590 if (!f2fs_sb_has_compression(F2FS_I_SB(inode
)))
3593 if (!f2fs_compressed_file(inode
))
3596 if (f2fs_readonly(sbi
->sb
))
3599 ret
= mnt_want_write_file(filp
);
3603 if (atomic_read(&F2FS_I(inode
)->i_compr_blocks
))
3606 f2fs_balance_fs(F2FS_I_SB(inode
), true);
3610 if (!is_inode_flag_set(inode
, FI_COMPRESS_RELEASED
)) {
3615 down_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
3616 filemap_invalidate_lock(inode
->i_mapping
);
3618 last_idx
= DIV_ROUND_UP(i_size_read(inode
), PAGE_SIZE
);
3620 while (page_idx
< last_idx
) {
3621 struct dnode_of_data dn
;
3622 pgoff_t end_offset
, count
;
3624 set_new_dnode(&dn
, inode
, NULL
, NULL
, 0);
3625 ret
= f2fs_get_dnode_of_data(&dn
, page_idx
, LOOKUP_NODE
);
3627 if (ret
== -ENOENT
) {
3628 page_idx
= f2fs_get_next_page_offset(&dn
,
3636 end_offset
= ADDRS_PER_PAGE(dn
.node_page
, inode
);
3637 count
= min(end_offset
- dn
.ofs_in_node
, last_idx
- page_idx
);
3638 count
= round_up(count
, F2FS_I(inode
)->i_cluster_size
);
3640 ret
= reserve_compress_blocks(&dn
, count
);
3642 f2fs_put_dnode(&dn
);
3648 reserved_blocks
+= ret
;
3651 filemap_invalidate_unlock(inode
->i_mapping
);
3652 up_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
3655 clear_inode_flag(inode
, FI_COMPRESS_RELEASED
);
3656 inode
->i_ctime
= current_time(inode
);
3657 f2fs_mark_inode_dirty_sync(inode
, true);
3660 inode_unlock(inode
);
3662 mnt_drop_write_file(filp
);
3665 ret
= put_user(reserved_blocks
, (u64 __user
*)arg
);
3666 } else if (reserved_blocks
&&
3667 atomic_read(&F2FS_I(inode
)->i_compr_blocks
)) {
3668 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
3669 f2fs_warn(sbi
, "%s: partial blocks were released i_ino=%lx "
3670 "iblocks=%llu, reserved=%u, compr_blocks=%u, "
3672 __func__
, inode
->i_ino
, inode
->i_blocks
,
3674 atomic_read(&F2FS_I(inode
)->i_compr_blocks
));
3680 static int f2fs_secure_erase(struct block_device
*bdev
, struct inode
*inode
,
3681 pgoff_t off
, block_t block
, block_t len
, u32 flags
)
3683 struct request_queue
*q
= bdev_get_queue(bdev
);
3684 sector_t sector
= SECTOR_FROM_BLOCK(block
);
3685 sector_t nr_sects
= SECTOR_FROM_BLOCK(len
);
3691 if (flags
& F2FS_TRIM_FILE_DISCARD
)
3692 ret
= blkdev_issue_discard(bdev
, sector
, nr_sects
, GFP_NOFS
,
3693 blk_queue_secure_erase(q
) ?
3694 BLKDEV_DISCARD_SECURE
: 0);
3696 if (!ret
&& (flags
& F2FS_TRIM_FILE_ZEROOUT
)) {
3697 if (IS_ENCRYPTED(inode
))
3698 ret
= fscrypt_zeroout_range(inode
, off
, block
, len
);
3700 ret
= blkdev_issue_zeroout(bdev
, sector
, nr_sects
,
3707 static int f2fs_sec_trim_file(struct file
*filp
, unsigned long arg
)
3709 struct inode
*inode
= file_inode(filp
);
3710 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
3711 struct address_space
*mapping
= inode
->i_mapping
;
3712 struct block_device
*prev_bdev
= NULL
;
3713 struct f2fs_sectrim_range range
;
3714 pgoff_t index
, pg_end
, prev_index
= 0;
3715 block_t prev_block
= 0, len
= 0;
3717 bool to_end
= false;
3720 if (!(filp
->f_mode
& FMODE_WRITE
))
3723 if (copy_from_user(&range
, (struct f2fs_sectrim_range __user
*)arg
,
3727 if (range
.flags
== 0 || (range
.flags
& ~F2FS_TRIM_FILE_MASK
) ||
3728 !S_ISREG(inode
->i_mode
))
3731 if (((range
.flags
& F2FS_TRIM_FILE_DISCARD
) &&
3732 !f2fs_hw_support_discard(sbi
)) ||
3733 ((range
.flags
& F2FS_TRIM_FILE_ZEROOUT
) &&
3734 IS_ENCRYPTED(inode
) && f2fs_is_multi_device(sbi
)))
3737 file_start_write(filp
);
3740 if (f2fs_is_atomic_file(inode
) || f2fs_compressed_file(inode
) ||
3741 range
.start
>= inode
->i_size
) {
3749 if (inode
->i_size
- range
.start
> range
.len
) {
3750 end_addr
= range
.start
+ range
.len
;
3752 end_addr
= range
.len
== (u64
)-1 ?
3753 sbi
->sb
->s_maxbytes
: inode
->i_size
;
3757 if (!IS_ALIGNED(range
.start
, F2FS_BLKSIZE
) ||
3758 (!to_end
&& !IS_ALIGNED(end_addr
, F2FS_BLKSIZE
))) {
3763 index
= F2FS_BYTES_TO_BLK(range
.start
);
3764 pg_end
= DIV_ROUND_UP(end_addr
, F2FS_BLKSIZE
);
3766 ret
= f2fs_convert_inline_inode(inode
);
3770 down_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
3771 filemap_invalidate_lock(mapping
);
3773 ret
= filemap_write_and_wait_range(mapping
, range
.start
,
3774 to_end
? LLONG_MAX
: end_addr
- 1);
3778 truncate_inode_pages_range(mapping
, range
.start
,
3779 to_end
? -1 : end_addr
- 1);
3781 while (index
< pg_end
) {
3782 struct dnode_of_data dn
;
3783 pgoff_t end_offset
, count
;
3786 set_new_dnode(&dn
, inode
, NULL
, NULL
, 0);
3787 ret
= f2fs_get_dnode_of_data(&dn
, index
, LOOKUP_NODE
);
3789 if (ret
== -ENOENT
) {
3790 index
= f2fs_get_next_page_offset(&dn
, index
);
3796 end_offset
= ADDRS_PER_PAGE(dn
.node_page
, inode
);
3797 count
= min(end_offset
- dn
.ofs_in_node
, pg_end
- index
);
3798 for (i
= 0; i
< count
; i
++, index
++, dn
.ofs_in_node
++) {
3799 struct block_device
*cur_bdev
;
3800 block_t blkaddr
= f2fs_data_blkaddr(&dn
);
3802 if (!__is_valid_data_blkaddr(blkaddr
))
3805 if (!f2fs_is_valid_blkaddr(sbi
, blkaddr
,
3806 DATA_GENERIC_ENHANCE
)) {
3807 ret
= -EFSCORRUPTED
;
3808 f2fs_put_dnode(&dn
);
3812 cur_bdev
= f2fs_target_device(sbi
, blkaddr
, NULL
);
3813 if (f2fs_is_multi_device(sbi
)) {
3814 int di
= f2fs_target_device_index(sbi
, blkaddr
);
3816 blkaddr
-= FDEV(di
).start_blk
;
3820 if (prev_bdev
== cur_bdev
&&
3821 index
== prev_index
+ len
&&
3822 blkaddr
== prev_block
+ len
) {
3825 ret
= f2fs_secure_erase(prev_bdev
,
3826 inode
, prev_index
, prev_block
,
3829 f2fs_put_dnode(&dn
);
3838 prev_bdev
= cur_bdev
;
3840 prev_block
= blkaddr
;
3845 f2fs_put_dnode(&dn
);
3847 if (fatal_signal_pending(current
)) {
3855 ret
= f2fs_secure_erase(prev_bdev
, inode
, prev_index
,
3856 prev_block
, len
, range
.flags
);
3858 filemap_invalidate_unlock(mapping
);
3859 up_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
3861 inode_unlock(inode
);
3862 file_end_write(filp
);
3867 static int f2fs_ioc_get_compress_option(struct file
*filp
, unsigned long arg
)
3869 struct inode
*inode
= file_inode(filp
);
3870 struct f2fs_comp_option option
;
3872 if (!f2fs_sb_has_compression(F2FS_I_SB(inode
)))
3875 inode_lock_shared(inode
);
3877 if (!f2fs_compressed_file(inode
)) {
3878 inode_unlock_shared(inode
);
3882 option
.algorithm
= F2FS_I(inode
)->i_compress_algorithm
;
3883 option
.log_cluster_size
= F2FS_I(inode
)->i_log_cluster_size
;
3885 inode_unlock_shared(inode
);
3887 if (copy_to_user((struct f2fs_comp_option __user
*)arg
, &option
,
3894 static int f2fs_ioc_set_compress_option(struct file
*filp
, unsigned long arg
)
3896 struct inode
*inode
= file_inode(filp
);
3897 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
3898 struct f2fs_comp_option option
;
3901 if (!f2fs_sb_has_compression(sbi
))
3904 if (!(filp
->f_mode
& FMODE_WRITE
))
3907 if (copy_from_user(&option
, (struct f2fs_comp_option __user
*)arg
,
3911 if (!f2fs_compressed_file(inode
) ||
3912 option
.log_cluster_size
< MIN_COMPRESS_LOG_SIZE
||
3913 option
.log_cluster_size
> MAX_COMPRESS_LOG_SIZE
||
3914 option
.algorithm
>= COMPRESS_MAX
)
3917 file_start_write(filp
);
3920 if (f2fs_is_mmap_file(inode
) || get_dirty_pages(inode
)) {
3925 if (inode
->i_size
!= 0) {
3930 F2FS_I(inode
)->i_compress_algorithm
= option
.algorithm
;
3931 F2FS_I(inode
)->i_log_cluster_size
= option
.log_cluster_size
;
3932 F2FS_I(inode
)->i_cluster_size
= 1 << option
.log_cluster_size
;
3933 f2fs_mark_inode_dirty_sync(inode
, true);
3935 if (!f2fs_is_compress_backend_ready(inode
))
3936 f2fs_warn(sbi
, "compression algorithm is successfully set, "
3937 "but current kernel doesn't support this algorithm.");
3939 inode_unlock(inode
);
3940 file_end_write(filp
);
3945 static int redirty_blocks(struct inode
*inode
, pgoff_t page_idx
, int len
)
3947 DEFINE_READAHEAD(ractl
, NULL
, NULL
, inode
->i_mapping
, page_idx
);
3948 struct address_space
*mapping
= inode
->i_mapping
;
3950 pgoff_t redirty_idx
= page_idx
;
3951 int i
, page_len
= 0, ret
= 0;
3953 page_cache_ra_unbounded(&ractl
, len
, 0);
3955 for (i
= 0; i
< len
; i
++, page_idx
++) {
3956 page
= read_cache_page(mapping
, page_idx
, NULL
, NULL
);
3958 ret
= PTR_ERR(page
);
3964 for (i
= 0; i
< page_len
; i
++, redirty_idx
++) {
3965 page
= find_lock_page(mapping
, redirty_idx
);
3970 set_page_dirty(page
);
3971 f2fs_put_page(page
, 1);
3972 f2fs_put_page(page
, 0);
3978 static int f2fs_ioc_decompress_file(struct file
*filp
, unsigned long arg
)
3980 struct inode
*inode
= file_inode(filp
);
3981 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
3982 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
3983 pgoff_t page_idx
= 0, last_idx
;
3984 unsigned int blk_per_seg
= sbi
->blocks_per_seg
;
3985 int cluster_size
= F2FS_I(inode
)->i_cluster_size
;
3988 if (!f2fs_sb_has_compression(sbi
) ||
3989 F2FS_OPTION(sbi
).compress_mode
!= COMPR_MODE_USER
)
3992 if (!(filp
->f_mode
& FMODE_WRITE
))
3995 if (!f2fs_compressed_file(inode
))
3998 f2fs_balance_fs(F2FS_I_SB(inode
), true);
4000 file_start_write(filp
);
4003 if (!f2fs_is_compress_backend_ready(inode
)) {
4008 if (f2fs_is_mmap_file(inode
)) {
4013 ret
= filemap_write_and_wait_range(inode
->i_mapping
, 0, LLONG_MAX
);
4017 if (!atomic_read(&fi
->i_compr_blocks
))
4020 last_idx
= DIV_ROUND_UP(i_size_read(inode
), PAGE_SIZE
);
4022 count
= last_idx
- page_idx
;
4024 int len
= min(cluster_size
, count
);
4026 ret
= redirty_blocks(inode
, page_idx
, len
);
4030 if (get_dirty_pages(inode
) >= blk_per_seg
)
4031 filemap_fdatawrite(inode
->i_mapping
);
4038 ret
= filemap_write_and_wait_range(inode
->i_mapping
, 0,
4042 f2fs_warn(sbi
, "%s: The file might be partially decompressed (errno=%d). Please delete the file.",
4045 inode_unlock(inode
);
4046 file_end_write(filp
);
4051 static int f2fs_ioc_compress_file(struct file
*filp
, unsigned long arg
)
4053 struct inode
*inode
= file_inode(filp
);
4054 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
4055 pgoff_t page_idx
= 0, last_idx
;
4056 unsigned int blk_per_seg
= sbi
->blocks_per_seg
;
4057 int cluster_size
= F2FS_I(inode
)->i_cluster_size
;
4060 if (!f2fs_sb_has_compression(sbi
) ||
4061 F2FS_OPTION(sbi
).compress_mode
!= COMPR_MODE_USER
)
4064 if (!(filp
->f_mode
& FMODE_WRITE
))
4067 if (!f2fs_compressed_file(inode
))
4070 f2fs_balance_fs(F2FS_I_SB(inode
), true);
4072 file_start_write(filp
);
4075 if (!f2fs_is_compress_backend_ready(inode
)) {
4080 if (f2fs_is_mmap_file(inode
)) {
4085 ret
= filemap_write_and_wait_range(inode
->i_mapping
, 0, LLONG_MAX
);
4089 set_inode_flag(inode
, FI_ENABLE_COMPRESS
);
4091 last_idx
= DIV_ROUND_UP(i_size_read(inode
), PAGE_SIZE
);
4093 count
= last_idx
- page_idx
;
4095 int len
= min(cluster_size
, count
);
4097 ret
= redirty_blocks(inode
, page_idx
, len
);
4101 if (get_dirty_pages(inode
) >= blk_per_seg
)
4102 filemap_fdatawrite(inode
->i_mapping
);
4109 ret
= filemap_write_and_wait_range(inode
->i_mapping
, 0,
4112 clear_inode_flag(inode
, FI_ENABLE_COMPRESS
);
4115 f2fs_warn(sbi
, "%s: The file might be partially compressed (errno=%d). Please delete the file.",
4118 inode_unlock(inode
);
4119 file_end_write(filp
);
4124 static long __f2fs_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
4127 case FS_IOC_GETVERSION
:
4128 return f2fs_ioc_getversion(filp
, arg
);
4129 case F2FS_IOC_START_ATOMIC_WRITE
:
4130 return f2fs_ioc_start_atomic_write(filp
);
4131 case F2FS_IOC_COMMIT_ATOMIC_WRITE
:
4132 return f2fs_ioc_commit_atomic_write(filp
);
4133 case F2FS_IOC_START_VOLATILE_WRITE
:
4134 return f2fs_ioc_start_volatile_write(filp
);
4135 case F2FS_IOC_RELEASE_VOLATILE_WRITE
:
4136 return f2fs_ioc_release_volatile_write(filp
);
4137 case F2FS_IOC_ABORT_VOLATILE_WRITE
:
4138 return f2fs_ioc_abort_volatile_write(filp
);
4139 case F2FS_IOC_SHUTDOWN
:
4140 return f2fs_ioc_shutdown(filp
, arg
);
4142 return f2fs_ioc_fitrim(filp
, arg
);
4143 case FS_IOC_SET_ENCRYPTION_POLICY
:
4144 return f2fs_ioc_set_encryption_policy(filp
, arg
);
4145 case FS_IOC_GET_ENCRYPTION_POLICY
:
4146 return f2fs_ioc_get_encryption_policy(filp
, arg
);
4147 case FS_IOC_GET_ENCRYPTION_PWSALT
:
4148 return f2fs_ioc_get_encryption_pwsalt(filp
, arg
);
4149 case FS_IOC_GET_ENCRYPTION_POLICY_EX
:
4150 return f2fs_ioc_get_encryption_policy_ex(filp
, arg
);
4151 case FS_IOC_ADD_ENCRYPTION_KEY
:
4152 return f2fs_ioc_add_encryption_key(filp
, arg
);
4153 case FS_IOC_REMOVE_ENCRYPTION_KEY
:
4154 return f2fs_ioc_remove_encryption_key(filp
, arg
);
4155 case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS
:
4156 return f2fs_ioc_remove_encryption_key_all_users(filp
, arg
);
4157 case FS_IOC_GET_ENCRYPTION_KEY_STATUS
:
4158 return f2fs_ioc_get_encryption_key_status(filp
, arg
);
4159 case FS_IOC_GET_ENCRYPTION_NONCE
:
4160 return f2fs_ioc_get_encryption_nonce(filp
, arg
);
4161 case F2FS_IOC_GARBAGE_COLLECT
:
4162 return f2fs_ioc_gc(filp
, arg
);
4163 case F2FS_IOC_GARBAGE_COLLECT_RANGE
:
4164 return f2fs_ioc_gc_range(filp
, arg
);
4165 case F2FS_IOC_WRITE_CHECKPOINT
:
4166 return f2fs_ioc_write_checkpoint(filp
, arg
);
4167 case F2FS_IOC_DEFRAGMENT
:
4168 return f2fs_ioc_defragment(filp
, arg
);
4169 case F2FS_IOC_MOVE_RANGE
:
4170 return f2fs_ioc_move_range(filp
, arg
);
4171 case F2FS_IOC_FLUSH_DEVICE
:
4172 return f2fs_ioc_flush_device(filp
, arg
);
4173 case F2FS_IOC_GET_FEATURES
:
4174 return f2fs_ioc_get_features(filp
, arg
);
4175 case F2FS_IOC_GET_PIN_FILE
:
4176 return f2fs_ioc_get_pin_file(filp
, arg
);
4177 case F2FS_IOC_SET_PIN_FILE
:
4178 return f2fs_ioc_set_pin_file(filp
, arg
);
4179 case F2FS_IOC_PRECACHE_EXTENTS
:
4180 return f2fs_ioc_precache_extents(filp
, arg
);
4181 case F2FS_IOC_RESIZE_FS
:
4182 return f2fs_ioc_resize_fs(filp
, arg
);
4183 case FS_IOC_ENABLE_VERITY
:
4184 return f2fs_ioc_enable_verity(filp
, arg
);
4185 case FS_IOC_MEASURE_VERITY
:
4186 return f2fs_ioc_measure_verity(filp
, arg
);
4187 case FS_IOC_READ_VERITY_METADATA
:
4188 return f2fs_ioc_read_verity_metadata(filp
, arg
);
4189 case FS_IOC_GETFSLABEL
:
4190 return f2fs_ioc_getfslabel(filp
, arg
);
4191 case FS_IOC_SETFSLABEL
:
4192 return f2fs_ioc_setfslabel(filp
, arg
);
4193 case F2FS_IOC_GET_COMPRESS_BLOCKS
:
4194 return f2fs_get_compress_blocks(filp
, arg
);
4195 case F2FS_IOC_RELEASE_COMPRESS_BLOCKS
:
4196 return f2fs_release_compress_blocks(filp
, arg
);
4197 case F2FS_IOC_RESERVE_COMPRESS_BLOCKS
:
4198 return f2fs_reserve_compress_blocks(filp
, arg
);
4199 case F2FS_IOC_SEC_TRIM_FILE
:
4200 return f2fs_sec_trim_file(filp
, arg
);
4201 case F2FS_IOC_GET_COMPRESS_OPTION
:
4202 return f2fs_ioc_get_compress_option(filp
, arg
);
4203 case F2FS_IOC_SET_COMPRESS_OPTION
:
4204 return f2fs_ioc_set_compress_option(filp
, arg
);
4205 case F2FS_IOC_DECOMPRESS_FILE
:
4206 return f2fs_ioc_decompress_file(filp
, arg
);
4207 case F2FS_IOC_COMPRESS_FILE
:
4208 return f2fs_ioc_compress_file(filp
, arg
);
4214 long f2fs_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
4216 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp
)))))
4218 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(file_inode(filp
))))
4221 return __f2fs_ioctl(filp
, cmd
, arg
);
4224 static ssize_t
f2fs_file_read_iter(struct kiocb
*iocb
, struct iov_iter
*iter
)
4226 struct file
*file
= iocb
->ki_filp
;
4227 struct inode
*inode
= file_inode(file
);
4230 if (!f2fs_is_compress_backend_ready(inode
))
4233 ret
= generic_file_read_iter(iocb
, iter
);
4236 f2fs_update_iostat(F2FS_I_SB(inode
), APP_READ_IO
, ret
);
4241 static ssize_t
f2fs_file_write_iter(struct kiocb
*iocb
, struct iov_iter
*from
)
4243 struct file
*file
= iocb
->ki_filp
;
4244 struct inode
*inode
= file_inode(file
);
4247 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode
)))) {
4252 if (!f2fs_is_compress_backend_ready(inode
)) {
4257 if (iocb
->ki_flags
& IOCB_NOWAIT
) {
4258 if (!inode_trylock(inode
)) {
4266 if (unlikely(IS_IMMUTABLE(inode
))) {
4271 if (is_inode_flag_set(inode
, FI_COMPRESS_RELEASED
)) {
4276 ret
= generic_write_checks(iocb
, from
);
4278 bool preallocated
= false;
4279 size_t target_size
= 0;
4282 if (iov_iter_fault_in_readable(from
, iov_iter_count(from
)))
4283 set_inode_flag(inode
, FI_NO_PREALLOC
);
4285 if ((iocb
->ki_flags
& IOCB_NOWAIT
)) {
4286 if (!f2fs_overwrite_io(inode
, iocb
->ki_pos
,
4287 iov_iter_count(from
)) ||
4288 f2fs_has_inline_data(inode
) ||
4289 f2fs_force_buffered_io(inode
, iocb
, from
)) {
4290 clear_inode_flag(inode
, FI_NO_PREALLOC
);
4291 inode_unlock(inode
);
4298 if (is_inode_flag_set(inode
, FI_NO_PREALLOC
))
4301 if (iocb
->ki_flags
& IOCB_DIRECT
) {
4303 * Convert inline data for Direct I/O before entering
4306 err
= f2fs_convert_inline_inode(inode
);
4310 * If force_buffere_io() is true, we have to allocate
4311 * blocks all the time, since f2fs_direct_IO will fall
4312 * back to buffered IO.
4314 if (!f2fs_force_buffered_io(inode
, iocb
, from
) &&
4315 f2fs_lfs_mode(F2FS_I_SB(inode
)))
4318 preallocated
= true;
4319 target_size
= iocb
->ki_pos
+ iov_iter_count(from
);
4321 err
= f2fs_preallocate_blocks(iocb
, from
);
4324 clear_inode_flag(inode
, FI_NO_PREALLOC
);
4325 inode_unlock(inode
);
4330 ret
= __generic_file_write_iter(iocb
, from
);
4331 clear_inode_flag(inode
, FI_NO_PREALLOC
);
4333 /* if we couldn't write data, we should deallocate blocks. */
4334 if (preallocated
&& i_size_read(inode
) < target_size
) {
4335 down_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
4336 filemap_invalidate_lock(inode
->i_mapping
);
4337 f2fs_truncate(inode
);
4338 filemap_invalidate_unlock(inode
->i_mapping
);
4339 up_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
4343 f2fs_update_iostat(F2FS_I_SB(inode
), APP_WRITE_IO
, ret
);
4346 inode_unlock(inode
);
4348 trace_f2fs_file_write_iter(inode
, iocb
->ki_pos
,
4349 iov_iter_count(from
), ret
);
4351 ret
= generic_write_sync(iocb
, ret
);
4355 static int f2fs_file_fadvise(struct file
*filp
, loff_t offset
, loff_t len
,
4358 struct inode
*inode
;
4359 struct address_space
*mapping
;
4360 struct backing_dev_info
*bdi
;
4362 if (advice
== POSIX_FADV_SEQUENTIAL
) {
4363 inode
= file_inode(filp
);
4364 if (S_ISFIFO(inode
->i_mode
))
4367 mapping
= filp
->f_mapping
;
4368 if (!mapping
|| len
< 0)
4371 bdi
= inode_to_bdi(mapping
->host
);
4372 filp
->f_ra
.ra_pages
= bdi
->ra_pages
*
4373 F2FS_I_SB(inode
)->seq_file_ra_mul
;
4374 spin_lock(&filp
->f_lock
);
4375 filp
->f_mode
&= ~FMODE_RANDOM
;
4376 spin_unlock(&filp
->f_lock
);
4380 return generic_fadvise(filp
, offset
, len
, advice
);
4383 #ifdef CONFIG_COMPAT
4384 struct compat_f2fs_gc_range
{
4389 #define F2FS_IOC32_GARBAGE_COLLECT_RANGE _IOW(F2FS_IOCTL_MAGIC, 11,\
4390 struct compat_f2fs_gc_range)
4392 static int f2fs_compat_ioc_gc_range(struct file
*file
, unsigned long arg
)
4394 struct compat_f2fs_gc_range __user
*urange
;
4395 struct f2fs_gc_range range
;
4398 urange
= compat_ptr(arg
);
4399 err
= get_user(range
.sync
, &urange
->sync
);
4400 err
|= get_user(range
.start
, &urange
->start
);
4401 err
|= get_user(range
.len
, &urange
->len
);
4405 return __f2fs_ioc_gc_range(file
, &range
);
4408 struct compat_f2fs_move_range
{
4414 #define F2FS_IOC32_MOVE_RANGE _IOWR(F2FS_IOCTL_MAGIC, 9, \
4415 struct compat_f2fs_move_range)
4417 static int f2fs_compat_ioc_move_range(struct file
*file
, unsigned long arg
)
4419 struct compat_f2fs_move_range __user
*urange
;
4420 struct f2fs_move_range range
;
4423 urange
= compat_ptr(arg
);
4424 err
= get_user(range
.dst_fd
, &urange
->dst_fd
);
4425 err
|= get_user(range
.pos_in
, &urange
->pos_in
);
4426 err
|= get_user(range
.pos_out
, &urange
->pos_out
);
4427 err
|= get_user(range
.len
, &urange
->len
);
4431 return __f2fs_ioc_move_range(file
, &range
);
4434 long f2fs_compat_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
4436 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(file
)))))
4438 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(file_inode(file
))))
4442 case FS_IOC32_GETVERSION
:
4443 cmd
= FS_IOC_GETVERSION
;
4445 case F2FS_IOC32_GARBAGE_COLLECT_RANGE
:
4446 return f2fs_compat_ioc_gc_range(file
, arg
);
4447 case F2FS_IOC32_MOVE_RANGE
:
4448 return f2fs_compat_ioc_move_range(file
, arg
);
4449 case F2FS_IOC_START_ATOMIC_WRITE
:
4450 case F2FS_IOC_COMMIT_ATOMIC_WRITE
:
4451 case F2FS_IOC_START_VOLATILE_WRITE
:
4452 case F2FS_IOC_RELEASE_VOLATILE_WRITE
:
4453 case F2FS_IOC_ABORT_VOLATILE_WRITE
:
4454 case F2FS_IOC_SHUTDOWN
:
4456 case FS_IOC_SET_ENCRYPTION_POLICY
:
4457 case FS_IOC_GET_ENCRYPTION_PWSALT
:
4458 case FS_IOC_GET_ENCRYPTION_POLICY
:
4459 case FS_IOC_GET_ENCRYPTION_POLICY_EX
:
4460 case FS_IOC_ADD_ENCRYPTION_KEY
:
4461 case FS_IOC_REMOVE_ENCRYPTION_KEY
:
4462 case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS
:
4463 case FS_IOC_GET_ENCRYPTION_KEY_STATUS
:
4464 case FS_IOC_GET_ENCRYPTION_NONCE
:
4465 case F2FS_IOC_GARBAGE_COLLECT
:
4466 case F2FS_IOC_WRITE_CHECKPOINT
:
4467 case F2FS_IOC_DEFRAGMENT
:
4468 case F2FS_IOC_FLUSH_DEVICE
:
4469 case F2FS_IOC_GET_FEATURES
:
4470 case F2FS_IOC_GET_PIN_FILE
:
4471 case F2FS_IOC_SET_PIN_FILE
:
4472 case F2FS_IOC_PRECACHE_EXTENTS
:
4473 case F2FS_IOC_RESIZE_FS
:
4474 case FS_IOC_ENABLE_VERITY
:
4475 case FS_IOC_MEASURE_VERITY
:
4476 case FS_IOC_READ_VERITY_METADATA
:
4477 case FS_IOC_GETFSLABEL
:
4478 case FS_IOC_SETFSLABEL
:
4479 case F2FS_IOC_GET_COMPRESS_BLOCKS
:
4480 case F2FS_IOC_RELEASE_COMPRESS_BLOCKS
:
4481 case F2FS_IOC_RESERVE_COMPRESS_BLOCKS
:
4482 case F2FS_IOC_SEC_TRIM_FILE
:
4483 case F2FS_IOC_GET_COMPRESS_OPTION
:
4484 case F2FS_IOC_SET_COMPRESS_OPTION
:
4485 case F2FS_IOC_DECOMPRESS_FILE
:
4486 case F2FS_IOC_COMPRESS_FILE
:
4489 return -ENOIOCTLCMD
;
4491 return __f2fs_ioctl(file
, cmd
, (unsigned long) compat_ptr(arg
));
4495 const struct file_operations f2fs_file_operations
= {
4496 .llseek
= f2fs_llseek
,
4497 .read_iter
= f2fs_file_read_iter
,
4498 .write_iter
= f2fs_file_write_iter
,
4499 .open
= f2fs_file_open
,
4500 .release
= f2fs_release_file
,
4501 .mmap
= f2fs_file_mmap
,
4502 .flush
= f2fs_file_flush
,
4503 .fsync
= f2fs_sync_file
,
4504 .fallocate
= f2fs_fallocate
,
4505 .unlocked_ioctl
= f2fs_ioctl
,
4506 #ifdef CONFIG_COMPAT
4507 .compat_ioctl
= f2fs_compat_ioctl
,
4509 .splice_read
= generic_file_splice_read
,
4510 .splice_write
= iter_file_splice_write
,
4511 .fadvise
= f2fs_file_fadvise
,