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 f2fs_disable_compressed_file(inode
);
2007 if (f2fs_is_atomic_file(inode
)) {
2008 if (is_inode_flag_set(inode
, FI_ATOMIC_REVOKE_REQUEST
))
2013 ret
= f2fs_convert_inline_inode(inode
);
2017 down_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
2020 * Should wait end_io to count F2FS_WB_CP_DATA correctly by
2021 * f2fs_is_atomic_file.
2023 if (get_dirty_pages(inode
))
2024 f2fs_warn(F2FS_I_SB(inode
), "Unexpected flush for atomic writes: ino=%lu, npages=%u",
2025 inode
->i_ino
, get_dirty_pages(inode
));
2026 ret
= filemap_write_and_wait_range(inode
->i_mapping
, 0, LLONG_MAX
);
2028 up_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
2032 spin_lock(&sbi
->inode_lock
[ATOMIC_FILE
]);
2033 if (list_empty(&fi
->inmem_ilist
))
2034 list_add_tail(&fi
->inmem_ilist
, &sbi
->inode_list
[ATOMIC_FILE
]);
2035 sbi
->atomic_files
++;
2036 spin_unlock(&sbi
->inode_lock
[ATOMIC_FILE
]);
2038 /* add inode in inmem_list first and set atomic_file */
2039 set_inode_flag(inode
, FI_ATOMIC_FILE
);
2040 clear_inode_flag(inode
, FI_ATOMIC_REVOKE_REQUEST
);
2041 up_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
2043 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
2044 F2FS_I(inode
)->inmem_task
= current
;
2045 stat_update_max_atomic_write(inode
);
2047 inode_unlock(inode
);
2048 mnt_drop_write_file(filp
);
2052 static int f2fs_ioc_commit_atomic_write(struct file
*filp
)
2054 struct inode
*inode
= file_inode(filp
);
2057 if (!inode_owner_or_capable(&init_user_ns
, inode
))
2060 ret
= mnt_want_write_file(filp
);
2064 f2fs_balance_fs(F2FS_I_SB(inode
), true);
2068 if (f2fs_is_volatile_file(inode
)) {
2073 if (f2fs_is_atomic_file(inode
)) {
2074 ret
= f2fs_commit_inmem_pages(inode
);
2078 ret
= f2fs_do_sync_file(filp
, 0, LLONG_MAX
, 0, true);
2080 f2fs_drop_inmem_pages(inode
);
2082 ret
= f2fs_do_sync_file(filp
, 0, LLONG_MAX
, 1, false);
2085 if (is_inode_flag_set(inode
, FI_ATOMIC_REVOKE_REQUEST
)) {
2086 clear_inode_flag(inode
, FI_ATOMIC_REVOKE_REQUEST
);
2089 inode_unlock(inode
);
2090 mnt_drop_write_file(filp
);
2094 static int f2fs_ioc_start_volatile_write(struct file
*filp
)
2096 struct inode
*inode
= file_inode(filp
);
2099 if (!inode_owner_or_capable(&init_user_ns
, inode
))
2102 if (!S_ISREG(inode
->i_mode
))
2105 ret
= mnt_want_write_file(filp
);
2111 if (f2fs_is_volatile_file(inode
))
2114 ret
= f2fs_convert_inline_inode(inode
);
2118 stat_inc_volatile_write(inode
);
2119 stat_update_max_volatile_write(inode
);
2121 set_inode_flag(inode
, FI_VOLATILE_FILE
);
2122 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
2124 inode_unlock(inode
);
2125 mnt_drop_write_file(filp
);
2129 static int f2fs_ioc_release_volatile_write(struct file
*filp
)
2131 struct inode
*inode
= file_inode(filp
);
2134 if (!inode_owner_or_capable(&init_user_ns
, inode
))
2137 ret
= mnt_want_write_file(filp
);
2143 if (!f2fs_is_volatile_file(inode
))
2146 if (!f2fs_is_first_block_written(inode
)) {
2147 ret
= truncate_partial_data_page(inode
, 0, true);
2151 ret
= punch_hole(inode
, 0, F2FS_BLKSIZE
);
2153 inode_unlock(inode
);
2154 mnt_drop_write_file(filp
);
2158 static int f2fs_ioc_abort_volatile_write(struct file
*filp
)
2160 struct inode
*inode
= file_inode(filp
);
2163 if (!inode_owner_or_capable(&init_user_ns
, inode
))
2166 ret
= mnt_want_write_file(filp
);
2172 if (f2fs_is_atomic_file(inode
))
2173 f2fs_drop_inmem_pages(inode
);
2174 if (f2fs_is_volatile_file(inode
)) {
2175 clear_inode_flag(inode
, FI_VOLATILE_FILE
);
2176 stat_dec_volatile_write(inode
);
2177 ret
= f2fs_do_sync_file(filp
, 0, LLONG_MAX
, 0, true);
2180 clear_inode_flag(inode
, FI_ATOMIC_REVOKE_REQUEST
);
2182 inode_unlock(inode
);
2184 mnt_drop_write_file(filp
);
2185 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
2189 static int f2fs_ioc_shutdown(struct file
*filp
, unsigned long arg
)
2191 struct inode
*inode
= file_inode(filp
);
2192 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
2193 struct super_block
*sb
= sbi
->sb
;
2197 if (!capable(CAP_SYS_ADMIN
))
2200 if (get_user(in
, (__u32 __user
*)arg
))
2203 if (in
!= F2FS_GOING_DOWN_FULLSYNC
) {
2204 ret
= mnt_want_write_file(filp
);
2206 if (ret
== -EROFS
) {
2208 f2fs_stop_checkpoint(sbi
, false);
2209 set_sbi_flag(sbi
, SBI_IS_SHUTDOWN
);
2210 trace_f2fs_shutdown(sbi
, in
, ret
);
2217 case F2FS_GOING_DOWN_FULLSYNC
:
2218 ret
= freeze_bdev(sb
->s_bdev
);
2221 f2fs_stop_checkpoint(sbi
, false);
2222 set_sbi_flag(sbi
, SBI_IS_SHUTDOWN
);
2223 thaw_bdev(sb
->s_bdev
);
2225 case F2FS_GOING_DOWN_METASYNC
:
2226 /* do checkpoint only */
2227 ret
= f2fs_sync_fs(sb
, 1);
2230 f2fs_stop_checkpoint(sbi
, false);
2231 set_sbi_flag(sbi
, SBI_IS_SHUTDOWN
);
2233 case F2FS_GOING_DOWN_NOSYNC
:
2234 f2fs_stop_checkpoint(sbi
, false);
2235 set_sbi_flag(sbi
, SBI_IS_SHUTDOWN
);
2237 case F2FS_GOING_DOWN_METAFLUSH
:
2238 f2fs_sync_meta_pages(sbi
, META
, LONG_MAX
, FS_META_IO
);
2239 f2fs_stop_checkpoint(sbi
, false);
2240 set_sbi_flag(sbi
, SBI_IS_SHUTDOWN
);
2242 case F2FS_GOING_DOWN_NEED_FSCK
:
2243 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
2244 set_sbi_flag(sbi
, SBI_CP_DISABLED_QUICK
);
2245 set_sbi_flag(sbi
, SBI_IS_DIRTY
);
2246 /* do checkpoint only */
2247 ret
= f2fs_sync_fs(sb
, 1);
2254 f2fs_stop_gc_thread(sbi
);
2255 f2fs_stop_discard_thread(sbi
);
2257 f2fs_drop_discard_cmd(sbi
);
2258 clear_opt(sbi
, DISCARD
);
2260 f2fs_update_time(sbi
, REQ_TIME
);
2262 if (in
!= F2FS_GOING_DOWN_FULLSYNC
)
2263 mnt_drop_write_file(filp
);
2265 trace_f2fs_shutdown(sbi
, in
, ret
);
2270 static int f2fs_ioc_fitrim(struct file
*filp
, unsigned long arg
)
2272 struct inode
*inode
= file_inode(filp
);
2273 struct super_block
*sb
= inode
->i_sb
;
2274 struct request_queue
*q
= bdev_get_queue(sb
->s_bdev
);
2275 struct fstrim_range range
;
2278 if (!capable(CAP_SYS_ADMIN
))
2281 if (!f2fs_hw_support_discard(F2FS_SB(sb
)))
2284 if (copy_from_user(&range
, (struct fstrim_range __user
*)arg
,
2288 ret
= mnt_want_write_file(filp
);
2292 range
.minlen
= max((unsigned int)range
.minlen
,
2293 q
->limits
.discard_granularity
);
2294 ret
= f2fs_trim_fs(F2FS_SB(sb
), &range
);
2295 mnt_drop_write_file(filp
);
2299 if (copy_to_user((struct fstrim_range __user
*)arg
, &range
,
2302 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
2306 static bool uuid_is_nonzero(__u8 u
[16])
2310 for (i
= 0; i
< 16; i
++)
2316 static int f2fs_ioc_set_encryption_policy(struct file
*filp
, unsigned long arg
)
2318 struct inode
*inode
= file_inode(filp
);
2320 if (!f2fs_sb_has_encrypt(F2FS_I_SB(inode
)))
2323 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
2325 return fscrypt_ioctl_set_policy(filp
, (const void __user
*)arg
);
2328 static int f2fs_ioc_get_encryption_policy(struct file
*filp
, unsigned long arg
)
2330 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp
))))
2332 return fscrypt_ioctl_get_policy(filp
, (void __user
*)arg
);
2335 static int f2fs_ioc_get_encryption_pwsalt(struct file
*filp
, unsigned long arg
)
2337 struct inode
*inode
= file_inode(filp
);
2338 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
2341 if (!f2fs_sb_has_encrypt(sbi
))
2344 err
= mnt_want_write_file(filp
);
2348 down_write(&sbi
->sb_lock
);
2350 if (uuid_is_nonzero(sbi
->raw_super
->encrypt_pw_salt
))
2353 /* update superblock with uuid */
2354 generate_random_uuid(sbi
->raw_super
->encrypt_pw_salt
);
2356 err
= f2fs_commit_super(sbi
, false);
2359 memset(sbi
->raw_super
->encrypt_pw_salt
, 0, 16);
2363 if (copy_to_user((__u8 __user
*)arg
, sbi
->raw_super
->encrypt_pw_salt
,
2367 up_write(&sbi
->sb_lock
);
2368 mnt_drop_write_file(filp
);
2372 static int f2fs_ioc_get_encryption_policy_ex(struct file
*filp
,
2375 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp
))))
2378 return fscrypt_ioctl_get_policy_ex(filp
, (void __user
*)arg
);
2381 static int f2fs_ioc_add_encryption_key(struct file
*filp
, unsigned long arg
)
2383 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp
))))
2386 return fscrypt_ioctl_add_key(filp
, (void __user
*)arg
);
2389 static int f2fs_ioc_remove_encryption_key(struct file
*filp
, unsigned long arg
)
2391 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp
))))
2394 return fscrypt_ioctl_remove_key(filp
, (void __user
*)arg
);
2397 static int f2fs_ioc_remove_encryption_key_all_users(struct file
*filp
,
2400 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp
))))
2403 return fscrypt_ioctl_remove_key_all_users(filp
, (void __user
*)arg
);
2406 static int f2fs_ioc_get_encryption_key_status(struct file
*filp
,
2409 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp
))))
2412 return fscrypt_ioctl_get_key_status(filp
, (void __user
*)arg
);
2415 static int f2fs_ioc_get_encryption_nonce(struct file
*filp
, unsigned long arg
)
2417 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp
))))
2420 return fscrypt_ioctl_get_nonce(filp
, (void __user
*)arg
);
2423 static int f2fs_ioc_gc(struct file
*filp
, unsigned long arg
)
2425 struct inode
*inode
= file_inode(filp
);
2426 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
2430 if (!capable(CAP_SYS_ADMIN
))
2433 if (get_user(sync
, (__u32 __user
*)arg
))
2436 if (f2fs_readonly(sbi
->sb
))
2439 ret
= mnt_want_write_file(filp
);
2444 if (!down_write_trylock(&sbi
->gc_lock
)) {
2449 down_write(&sbi
->gc_lock
);
2452 ret
= f2fs_gc(sbi
, sync
, true, false, NULL_SEGNO
);
2454 mnt_drop_write_file(filp
);
2458 static int __f2fs_ioc_gc_range(struct file
*filp
, struct f2fs_gc_range
*range
)
2460 struct f2fs_sb_info
*sbi
= F2FS_I_SB(file_inode(filp
));
2464 if (!capable(CAP_SYS_ADMIN
))
2466 if (f2fs_readonly(sbi
->sb
))
2469 end
= range
->start
+ range
->len
;
2470 if (end
< range
->start
|| range
->start
< MAIN_BLKADDR(sbi
) ||
2471 end
>= MAX_BLKADDR(sbi
))
2474 ret
= mnt_want_write_file(filp
);
2480 if (!down_write_trylock(&sbi
->gc_lock
)) {
2485 down_write(&sbi
->gc_lock
);
2488 ret
= f2fs_gc(sbi
, range
->sync
, true, false,
2489 GET_SEGNO(sbi
, range
->start
));
2495 range
->start
+= BLKS_PER_SEC(sbi
);
2496 if (range
->start
<= end
)
2499 mnt_drop_write_file(filp
);
2503 static int f2fs_ioc_gc_range(struct file
*filp
, unsigned long arg
)
2505 struct f2fs_gc_range range
;
2507 if (copy_from_user(&range
, (struct f2fs_gc_range __user
*)arg
,
2510 return __f2fs_ioc_gc_range(filp
, &range
);
2513 static int f2fs_ioc_write_checkpoint(struct file
*filp
, unsigned long arg
)
2515 struct inode
*inode
= file_inode(filp
);
2516 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
2519 if (!capable(CAP_SYS_ADMIN
))
2522 if (f2fs_readonly(sbi
->sb
))
2525 if (unlikely(is_sbi_flag_set(sbi
, SBI_CP_DISABLED
))) {
2526 f2fs_info(sbi
, "Skipping Checkpoint. Checkpoints currently disabled.");
2530 ret
= mnt_want_write_file(filp
);
2534 ret
= f2fs_sync_fs(sbi
->sb
, 1);
2536 mnt_drop_write_file(filp
);
2540 static int f2fs_defragment_range(struct f2fs_sb_info
*sbi
,
2542 struct f2fs_defragment
*range
)
2544 struct inode
*inode
= file_inode(filp
);
2545 struct f2fs_map_blocks map
= { .m_next_extent
= NULL
,
2546 .m_seg_type
= NO_CHECK_TYPE
,
2547 .m_may_create
= false };
2548 struct extent_info ei
= {0, 0, 0};
2549 pgoff_t pg_start
, pg_end
, next_pgofs
;
2550 unsigned int blk_per_seg
= sbi
->blocks_per_seg
;
2551 unsigned int total
= 0, sec_num
;
2552 block_t blk_end
= 0;
2553 bool fragmented
= false;
2556 /* if in-place-update policy is enabled, don't waste time here */
2557 if (f2fs_should_update_inplace(inode
, NULL
))
2560 pg_start
= range
->start
>> PAGE_SHIFT
;
2561 pg_end
= (range
->start
+ range
->len
) >> PAGE_SHIFT
;
2563 f2fs_balance_fs(sbi
, true);
2567 /* writeback all dirty pages in the range */
2568 err
= filemap_write_and_wait_range(inode
->i_mapping
, range
->start
,
2569 range
->start
+ range
->len
- 1);
2574 * lookup mapping info in extent cache, skip defragmenting if physical
2575 * block addresses are continuous.
2577 if (f2fs_lookup_extent_cache(inode
, pg_start
, &ei
)) {
2578 if (ei
.fofs
+ ei
.len
>= pg_end
)
2582 map
.m_lblk
= pg_start
;
2583 map
.m_next_pgofs
= &next_pgofs
;
2586 * lookup mapping info in dnode page cache, skip defragmenting if all
2587 * physical block addresses are continuous even if there are hole(s)
2588 * in logical blocks.
2590 while (map
.m_lblk
< pg_end
) {
2591 map
.m_len
= pg_end
- map
.m_lblk
;
2592 err
= f2fs_map_blocks(inode
, &map
, 0, F2FS_GET_BLOCK_DEFAULT
);
2596 if (!(map
.m_flags
& F2FS_MAP_FLAGS
)) {
2597 map
.m_lblk
= next_pgofs
;
2601 if (blk_end
&& blk_end
!= map
.m_pblk
)
2604 /* record total count of block that we're going to move */
2607 blk_end
= map
.m_pblk
+ map
.m_len
;
2609 map
.m_lblk
+= map
.m_len
;
2617 sec_num
= DIV_ROUND_UP(total
, BLKS_PER_SEC(sbi
));
2620 * make sure there are enough free section for LFS allocation, this can
2621 * avoid defragment running in SSR mode when free section are allocated
2624 if (has_not_enough_free_secs(sbi
, 0, sec_num
)) {
2629 map
.m_lblk
= pg_start
;
2630 map
.m_len
= pg_end
- pg_start
;
2633 while (map
.m_lblk
< pg_end
) {
2638 map
.m_len
= pg_end
- map
.m_lblk
;
2639 err
= f2fs_map_blocks(inode
, &map
, 0, F2FS_GET_BLOCK_DEFAULT
);
2643 if (!(map
.m_flags
& F2FS_MAP_FLAGS
)) {
2644 map
.m_lblk
= next_pgofs
;
2648 set_inode_flag(inode
, FI_DO_DEFRAG
);
2651 while (idx
< map
.m_lblk
+ map
.m_len
&& cnt
< blk_per_seg
) {
2654 page
= f2fs_get_lock_data_page(inode
, idx
, true);
2656 err
= PTR_ERR(page
);
2660 set_page_dirty(page
);
2661 f2fs_put_page(page
, 1);
2670 if (map
.m_lblk
< pg_end
&& cnt
< blk_per_seg
)
2673 clear_inode_flag(inode
, FI_DO_DEFRAG
);
2675 err
= filemap_fdatawrite(inode
->i_mapping
);
2680 clear_inode_flag(inode
, FI_DO_DEFRAG
);
2682 inode_unlock(inode
);
2684 range
->len
= (u64
)total
<< PAGE_SHIFT
;
2688 static int f2fs_ioc_defragment(struct file
*filp
, unsigned long arg
)
2690 struct inode
*inode
= file_inode(filp
);
2691 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
2692 struct f2fs_defragment range
;
2695 if (!capable(CAP_SYS_ADMIN
))
2698 if (!S_ISREG(inode
->i_mode
) || f2fs_is_atomic_file(inode
))
2701 if (f2fs_readonly(sbi
->sb
))
2704 if (copy_from_user(&range
, (struct f2fs_defragment __user
*)arg
,
2708 /* verify alignment of offset & size */
2709 if (range
.start
& (F2FS_BLKSIZE
- 1) || range
.len
& (F2FS_BLKSIZE
- 1))
2712 if (unlikely((range
.start
+ range
.len
) >> PAGE_SHIFT
>
2713 max_file_blocks(inode
)))
2716 err
= mnt_want_write_file(filp
);
2720 err
= f2fs_defragment_range(sbi
, filp
, &range
);
2721 mnt_drop_write_file(filp
);
2723 f2fs_update_time(sbi
, REQ_TIME
);
2727 if (copy_to_user((struct f2fs_defragment __user
*)arg
, &range
,
2734 static int f2fs_move_file_range(struct file
*file_in
, loff_t pos_in
,
2735 struct file
*file_out
, loff_t pos_out
, size_t len
)
2737 struct inode
*src
= file_inode(file_in
);
2738 struct inode
*dst
= file_inode(file_out
);
2739 struct f2fs_sb_info
*sbi
= F2FS_I_SB(src
);
2740 size_t olen
= len
, dst_max_i_size
= 0;
2744 if (file_in
->f_path
.mnt
!= file_out
->f_path
.mnt
||
2745 src
->i_sb
!= dst
->i_sb
)
2748 if (unlikely(f2fs_readonly(src
->i_sb
)))
2751 if (!S_ISREG(src
->i_mode
) || !S_ISREG(dst
->i_mode
))
2754 if (IS_ENCRYPTED(src
) || IS_ENCRYPTED(dst
))
2757 if (pos_out
< 0 || pos_in
< 0)
2761 if (pos_in
== pos_out
)
2763 if (pos_out
> pos_in
&& pos_out
< pos_in
+ len
)
2770 if (!inode_trylock(dst
))
2775 if (pos_in
+ len
> src
->i_size
|| pos_in
+ len
< pos_in
)
2778 olen
= len
= src
->i_size
- pos_in
;
2779 if (pos_in
+ len
== src
->i_size
)
2780 len
= ALIGN(src
->i_size
, F2FS_BLKSIZE
) - pos_in
;
2786 dst_osize
= dst
->i_size
;
2787 if (pos_out
+ olen
> dst
->i_size
)
2788 dst_max_i_size
= pos_out
+ olen
;
2790 /* verify the end result is block aligned */
2791 if (!IS_ALIGNED(pos_in
, F2FS_BLKSIZE
) ||
2792 !IS_ALIGNED(pos_in
+ len
, F2FS_BLKSIZE
) ||
2793 !IS_ALIGNED(pos_out
, F2FS_BLKSIZE
))
2796 ret
= f2fs_convert_inline_inode(src
);
2800 ret
= f2fs_convert_inline_inode(dst
);
2804 /* write out all dirty pages from offset */
2805 ret
= filemap_write_and_wait_range(src
->i_mapping
,
2806 pos_in
, pos_in
+ len
);
2810 ret
= filemap_write_and_wait_range(dst
->i_mapping
,
2811 pos_out
, pos_out
+ len
);
2815 f2fs_balance_fs(sbi
, true);
2817 down_write(&F2FS_I(src
)->i_gc_rwsem
[WRITE
]);
2820 if (!down_write_trylock(&F2FS_I(dst
)->i_gc_rwsem
[WRITE
]))
2825 ret
= __exchange_data_block(src
, dst
, pos_in
>> F2FS_BLKSIZE_BITS
,
2826 pos_out
>> F2FS_BLKSIZE_BITS
,
2827 len
>> F2FS_BLKSIZE_BITS
, false);
2831 f2fs_i_size_write(dst
, dst_max_i_size
);
2832 else if (dst_osize
!= dst
->i_size
)
2833 f2fs_i_size_write(dst
, dst_osize
);
2835 f2fs_unlock_op(sbi
);
2838 up_write(&F2FS_I(dst
)->i_gc_rwsem
[WRITE
]);
2840 up_write(&F2FS_I(src
)->i_gc_rwsem
[WRITE
]);
2849 static int __f2fs_ioc_move_range(struct file
*filp
,
2850 struct f2fs_move_range
*range
)
2855 if (!(filp
->f_mode
& FMODE_READ
) ||
2856 !(filp
->f_mode
& FMODE_WRITE
))
2859 dst
= fdget(range
->dst_fd
);
2863 if (!(dst
.file
->f_mode
& FMODE_WRITE
)) {
2868 err
= mnt_want_write_file(filp
);
2872 err
= f2fs_move_file_range(filp
, range
->pos_in
, dst
.file
,
2873 range
->pos_out
, range
->len
);
2875 mnt_drop_write_file(filp
);
2881 static int f2fs_ioc_move_range(struct file
*filp
, unsigned long arg
)
2883 struct f2fs_move_range range
;
2885 if (copy_from_user(&range
, (struct f2fs_move_range __user
*)arg
,
2888 return __f2fs_ioc_move_range(filp
, &range
);
2891 static int f2fs_ioc_flush_device(struct file
*filp
, unsigned long arg
)
2893 struct inode
*inode
= file_inode(filp
);
2894 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
2895 struct sit_info
*sm
= SIT_I(sbi
);
2896 unsigned int start_segno
= 0, end_segno
= 0;
2897 unsigned int dev_start_segno
= 0, dev_end_segno
= 0;
2898 struct f2fs_flush_device range
;
2901 if (!capable(CAP_SYS_ADMIN
))
2904 if (f2fs_readonly(sbi
->sb
))
2907 if (unlikely(is_sbi_flag_set(sbi
, SBI_CP_DISABLED
)))
2910 if (copy_from_user(&range
, (struct f2fs_flush_device __user
*)arg
,
2914 if (!f2fs_is_multi_device(sbi
) || sbi
->s_ndevs
- 1 <= range
.dev_num
||
2915 __is_large_section(sbi
)) {
2916 f2fs_warn(sbi
, "Can't flush %u in %d for segs_per_sec %u != 1",
2917 range
.dev_num
, sbi
->s_ndevs
, sbi
->segs_per_sec
);
2921 ret
= mnt_want_write_file(filp
);
2925 if (range
.dev_num
!= 0)
2926 dev_start_segno
= GET_SEGNO(sbi
, FDEV(range
.dev_num
).start_blk
);
2927 dev_end_segno
= GET_SEGNO(sbi
, FDEV(range
.dev_num
).end_blk
);
2929 start_segno
= sm
->last_victim
[FLUSH_DEVICE
];
2930 if (start_segno
< dev_start_segno
|| start_segno
>= dev_end_segno
)
2931 start_segno
= dev_start_segno
;
2932 end_segno
= min(start_segno
+ range
.segments
, dev_end_segno
);
2934 while (start_segno
< end_segno
) {
2935 if (!down_write_trylock(&sbi
->gc_lock
)) {
2939 sm
->last_victim
[GC_CB
] = end_segno
+ 1;
2940 sm
->last_victim
[GC_GREEDY
] = end_segno
+ 1;
2941 sm
->last_victim
[ALLOC_NEXT
] = end_segno
+ 1;
2942 ret
= f2fs_gc(sbi
, true, true, true, start_segno
);
2950 mnt_drop_write_file(filp
);
2954 static int f2fs_ioc_get_features(struct file
*filp
, unsigned long arg
)
2956 struct inode
*inode
= file_inode(filp
);
2957 u32 sb_feature
= le32_to_cpu(F2FS_I_SB(inode
)->raw_super
->feature
);
2959 /* Must validate to set it with SQLite behavior in Android. */
2960 sb_feature
|= F2FS_FEATURE_ATOMIC_WRITE
;
2962 return put_user(sb_feature
, (u32 __user
*)arg
);
2966 int f2fs_transfer_project_quota(struct inode
*inode
, kprojid_t kprojid
)
2968 struct dquot
*transfer_to
[MAXQUOTAS
] = {};
2969 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
2970 struct super_block
*sb
= sbi
->sb
;
2973 transfer_to
[PRJQUOTA
] = dqget(sb
, make_kqid_projid(kprojid
));
2974 if (!IS_ERR(transfer_to
[PRJQUOTA
])) {
2975 err
= __dquot_transfer(inode
, transfer_to
);
2977 set_sbi_flag(sbi
, SBI_QUOTA_NEED_REPAIR
);
2978 dqput(transfer_to
[PRJQUOTA
]);
2983 static int f2fs_ioc_setproject(struct inode
*inode
, __u32 projid
)
2985 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
2986 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
2991 if (!f2fs_sb_has_project_quota(sbi
)) {
2992 if (projid
!= F2FS_DEF_PROJID
)
2998 if (!f2fs_has_extra_attr(inode
))
3001 kprojid
= make_kprojid(&init_user_ns
, (projid_t
)projid
);
3003 if (projid_eq(kprojid
, F2FS_I(inode
)->i_projid
))
3007 /* Is it quota file? Do not allow user to mess with it */
3008 if (IS_NOQUOTA(inode
))
3011 ipage
= f2fs_get_node_page(sbi
, inode
->i_ino
);
3013 return PTR_ERR(ipage
);
3015 if (!F2FS_FITS_IN_INODE(F2FS_INODE(ipage
), fi
->i_extra_isize
,
3018 f2fs_put_page(ipage
, 1);
3021 f2fs_put_page(ipage
, 1);
3023 err
= dquot_initialize(inode
);
3028 err
= f2fs_transfer_project_quota(inode
, kprojid
);
3032 F2FS_I(inode
)->i_projid
= kprojid
;
3033 inode
->i_ctime
= current_time(inode
);
3034 f2fs_mark_inode_dirty_sync(inode
, true);
3036 f2fs_unlock_op(sbi
);
3040 int f2fs_transfer_project_quota(struct inode
*inode
, kprojid_t kprojid
)
3045 static int f2fs_ioc_setproject(struct inode
*inode
, __u32 projid
)
3047 if (projid
!= F2FS_DEF_PROJID
)
3053 int f2fs_fileattr_get(struct dentry
*dentry
, struct fileattr
*fa
)
3055 struct inode
*inode
= d_inode(dentry
);
3056 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
3057 u32 fsflags
= f2fs_iflags_to_fsflags(fi
->i_flags
);
3059 if (IS_ENCRYPTED(inode
))
3060 fsflags
|= FS_ENCRYPT_FL
;
3061 if (IS_VERITY(inode
))
3062 fsflags
|= FS_VERITY_FL
;
3063 if (f2fs_has_inline_data(inode
) || f2fs_has_inline_dentry(inode
))
3064 fsflags
|= FS_INLINE_DATA_FL
;
3065 if (is_inode_flag_set(inode
, FI_PIN_FILE
))
3066 fsflags
|= FS_NOCOW_FL
;
3068 fileattr_fill_flags(fa
, fsflags
& F2FS_GETTABLE_FS_FL
);
3070 if (f2fs_sb_has_project_quota(F2FS_I_SB(inode
)))
3071 fa
->fsx_projid
= from_kprojid(&init_user_ns
, fi
->i_projid
);
3076 int f2fs_fileattr_set(struct user_namespace
*mnt_userns
,
3077 struct dentry
*dentry
, struct fileattr
*fa
)
3079 struct inode
*inode
= d_inode(dentry
);
3080 u32 fsflags
= fa
->flags
, mask
= F2FS_SETTABLE_FS_FL
;
3084 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode
))))
3086 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode
)))
3088 if (fsflags
& ~F2FS_GETTABLE_FS_FL
)
3090 fsflags
&= F2FS_SETTABLE_FS_FL
;
3091 if (!fa
->flags_valid
)
3092 mask
&= FS_COMMON_FL
;
3094 iflags
= f2fs_fsflags_to_iflags(fsflags
);
3095 if (f2fs_mask_flags(inode
->i_mode
, iflags
) != iflags
)
3098 err
= f2fs_setflags_common(inode
, iflags
, f2fs_fsflags_to_iflags(mask
));
3100 err
= f2fs_ioc_setproject(inode
, fa
->fsx_projid
);
3105 int f2fs_pin_file_control(struct inode
*inode
, bool inc
)
3107 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
3108 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
3110 /* Use i_gc_failures for normal file as a risk signal. */
3112 f2fs_i_gc_failures_write(inode
,
3113 fi
->i_gc_failures
[GC_FAILURE_PIN
] + 1);
3115 if (fi
->i_gc_failures
[GC_FAILURE_PIN
] > sbi
->gc_pin_file_threshold
) {
3116 f2fs_warn(sbi
, "%s: Enable GC = ino %lx after %x GC trials",
3117 __func__
, inode
->i_ino
,
3118 fi
->i_gc_failures
[GC_FAILURE_PIN
]);
3119 clear_inode_flag(inode
, FI_PIN_FILE
);
3125 static int f2fs_ioc_set_pin_file(struct file
*filp
, unsigned long arg
)
3127 struct inode
*inode
= file_inode(filp
);
3131 if (get_user(pin
, (__u32 __user
*)arg
))
3134 if (!S_ISREG(inode
->i_mode
))
3137 if (f2fs_readonly(F2FS_I_SB(inode
)->sb
))
3140 ret
= mnt_want_write_file(filp
);
3146 if (f2fs_should_update_outplace(inode
, NULL
)) {
3152 clear_inode_flag(inode
, FI_PIN_FILE
);
3153 f2fs_i_gc_failures_write(inode
, 0);
3157 if (f2fs_pin_file_control(inode
, false)) {
3162 ret
= f2fs_convert_inline_inode(inode
);
3166 if (!f2fs_disable_compressed_file(inode
)) {
3171 set_inode_flag(inode
, FI_PIN_FILE
);
3172 ret
= F2FS_I(inode
)->i_gc_failures
[GC_FAILURE_PIN
];
3174 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
3176 inode_unlock(inode
);
3177 mnt_drop_write_file(filp
);
3181 static int f2fs_ioc_get_pin_file(struct file
*filp
, unsigned long arg
)
3183 struct inode
*inode
= file_inode(filp
);
3186 if (is_inode_flag_set(inode
, FI_PIN_FILE
))
3187 pin
= F2FS_I(inode
)->i_gc_failures
[GC_FAILURE_PIN
];
3188 return put_user(pin
, (u32 __user
*)arg
);
3191 int f2fs_precache_extents(struct inode
*inode
)
3193 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
3194 struct f2fs_map_blocks map
;
3195 pgoff_t m_next_extent
;
3199 if (is_inode_flag_set(inode
, FI_NO_EXTENT
))
3203 map
.m_next_pgofs
= NULL
;
3204 map
.m_next_extent
= &m_next_extent
;
3205 map
.m_seg_type
= NO_CHECK_TYPE
;
3206 map
.m_may_create
= false;
3207 end
= max_file_blocks(inode
);
3209 while (map
.m_lblk
< end
) {
3210 map
.m_len
= end
- map
.m_lblk
;
3212 down_write(&fi
->i_gc_rwsem
[WRITE
]);
3213 err
= f2fs_map_blocks(inode
, &map
, 0, F2FS_GET_BLOCK_PRECACHE
);
3214 up_write(&fi
->i_gc_rwsem
[WRITE
]);
3218 map
.m_lblk
= m_next_extent
;
3224 static int f2fs_ioc_precache_extents(struct file
*filp
, unsigned long arg
)
3226 return f2fs_precache_extents(file_inode(filp
));
3229 static int f2fs_ioc_resize_fs(struct file
*filp
, unsigned long arg
)
3231 struct f2fs_sb_info
*sbi
= F2FS_I_SB(file_inode(filp
));
3234 if (!capable(CAP_SYS_ADMIN
))
3237 if (f2fs_readonly(sbi
->sb
))
3240 if (copy_from_user(&block_count
, (void __user
*)arg
,
3241 sizeof(block_count
)))
3244 return f2fs_resize_fs(sbi
, block_count
);
3247 static int f2fs_ioc_enable_verity(struct file
*filp
, unsigned long arg
)
3249 struct inode
*inode
= file_inode(filp
);
3251 f2fs_update_time(F2FS_I_SB(inode
), REQ_TIME
);
3253 if (!f2fs_sb_has_verity(F2FS_I_SB(inode
))) {
3254 f2fs_warn(F2FS_I_SB(inode
),
3255 "Can't enable fs-verity on inode %lu: the verity feature is not enabled on this filesystem",
3260 return fsverity_ioctl_enable(filp
, (const void __user
*)arg
);
3263 static int f2fs_ioc_measure_verity(struct file
*filp
, unsigned long arg
)
3265 if (!f2fs_sb_has_verity(F2FS_I_SB(file_inode(filp
))))
3268 return fsverity_ioctl_measure(filp
, (void __user
*)arg
);
3271 static int f2fs_ioc_read_verity_metadata(struct file
*filp
, unsigned long arg
)
3273 if (!f2fs_sb_has_verity(F2FS_I_SB(file_inode(filp
))))
3276 return fsverity_ioctl_read_metadata(filp
, (const void __user
*)arg
);
3279 static int f2fs_ioc_getfslabel(struct file
*filp
, unsigned long arg
)
3281 struct inode
*inode
= file_inode(filp
);
3282 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
3287 vbuf
= f2fs_kzalloc(sbi
, MAX_VOLUME_NAME
, GFP_KERNEL
);
3291 down_read(&sbi
->sb_lock
);
3292 count
= utf16s_to_utf8s(sbi
->raw_super
->volume_name
,
3293 ARRAY_SIZE(sbi
->raw_super
->volume_name
),
3294 UTF16_LITTLE_ENDIAN
, vbuf
, MAX_VOLUME_NAME
);
3295 up_read(&sbi
->sb_lock
);
3297 if (copy_to_user((char __user
*)arg
, vbuf
,
3298 min(FSLABEL_MAX
, count
)))
3305 static int f2fs_ioc_setfslabel(struct file
*filp
, unsigned long arg
)
3307 struct inode
*inode
= file_inode(filp
);
3308 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
3312 if (!capable(CAP_SYS_ADMIN
))
3315 vbuf
= strndup_user((const char __user
*)arg
, FSLABEL_MAX
);
3317 return PTR_ERR(vbuf
);
3319 err
= mnt_want_write_file(filp
);
3323 down_write(&sbi
->sb_lock
);
3325 memset(sbi
->raw_super
->volume_name
, 0,
3326 sizeof(sbi
->raw_super
->volume_name
));
3327 utf8s_to_utf16s(vbuf
, strlen(vbuf
), UTF16_LITTLE_ENDIAN
,
3328 sbi
->raw_super
->volume_name
,
3329 ARRAY_SIZE(sbi
->raw_super
->volume_name
));
3331 err
= f2fs_commit_super(sbi
, false);
3333 up_write(&sbi
->sb_lock
);
3335 mnt_drop_write_file(filp
);
3341 static int f2fs_get_compress_blocks(struct file
*filp
, unsigned long arg
)
3343 struct inode
*inode
= file_inode(filp
);
3346 if (!f2fs_sb_has_compression(F2FS_I_SB(inode
)))
3349 if (!f2fs_compressed_file(inode
))
3352 blocks
= atomic_read(&F2FS_I(inode
)->i_compr_blocks
);
3353 return put_user(blocks
, (u64 __user
*)arg
);
3356 static int release_compress_blocks(struct dnode_of_data
*dn
, pgoff_t count
)
3358 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dn
->inode
);
3359 unsigned int released_blocks
= 0;
3360 int cluster_size
= F2FS_I(dn
->inode
)->i_cluster_size
;
3364 for (i
= 0; i
< count
; i
++) {
3365 blkaddr
= data_blkaddr(dn
->inode
, dn
->node_page
,
3366 dn
->ofs_in_node
+ i
);
3368 if (!__is_valid_data_blkaddr(blkaddr
))
3370 if (unlikely(!f2fs_is_valid_blkaddr(sbi
, blkaddr
,
3371 DATA_GENERIC_ENHANCE
)))
3372 return -EFSCORRUPTED
;
3376 int compr_blocks
= 0;
3378 for (i
= 0; i
< cluster_size
; i
++, dn
->ofs_in_node
++) {
3379 blkaddr
= f2fs_data_blkaddr(dn
);
3382 if (blkaddr
== COMPRESS_ADDR
)
3384 dn
->ofs_in_node
+= cluster_size
;
3388 if (__is_valid_data_blkaddr(blkaddr
))
3391 if (blkaddr
!= NEW_ADDR
)
3394 dn
->data_blkaddr
= NULL_ADDR
;
3395 f2fs_set_data_blkaddr(dn
);
3398 f2fs_i_compr_blocks_update(dn
->inode
, compr_blocks
, false);
3399 dec_valid_block_count(sbi
, dn
->inode
,
3400 cluster_size
- compr_blocks
);
3402 released_blocks
+= cluster_size
- compr_blocks
;
3404 count
-= cluster_size
;
3407 return released_blocks
;
3410 static int f2fs_release_compress_blocks(struct file
*filp
, unsigned long arg
)
3412 struct inode
*inode
= file_inode(filp
);
3413 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
3414 pgoff_t page_idx
= 0, last_idx
;
3415 unsigned int released_blocks
= 0;
3419 if (!f2fs_sb_has_compression(F2FS_I_SB(inode
)))
3422 if (!f2fs_compressed_file(inode
))
3425 if (f2fs_readonly(sbi
->sb
))
3428 ret
= mnt_want_write_file(filp
);
3432 f2fs_balance_fs(F2FS_I_SB(inode
), true);
3436 writecount
= atomic_read(&inode
->i_writecount
);
3437 if ((filp
->f_mode
& FMODE_WRITE
&& writecount
!= 1) ||
3438 (!(filp
->f_mode
& FMODE_WRITE
) && writecount
)) {
3443 if (is_inode_flag_set(inode
, FI_COMPRESS_RELEASED
)) {
3448 ret
= filemap_write_and_wait_range(inode
->i_mapping
, 0, LLONG_MAX
);
3452 set_inode_flag(inode
, FI_COMPRESS_RELEASED
);
3453 inode
->i_ctime
= current_time(inode
);
3454 f2fs_mark_inode_dirty_sync(inode
, true);
3456 if (!atomic_read(&F2FS_I(inode
)->i_compr_blocks
))
3459 down_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
3460 filemap_invalidate_lock(inode
->i_mapping
);
3462 last_idx
= DIV_ROUND_UP(i_size_read(inode
), PAGE_SIZE
);
3464 while (page_idx
< last_idx
) {
3465 struct dnode_of_data dn
;
3466 pgoff_t end_offset
, count
;
3468 set_new_dnode(&dn
, inode
, NULL
, NULL
, 0);
3469 ret
= f2fs_get_dnode_of_data(&dn
, page_idx
, LOOKUP_NODE
);
3471 if (ret
== -ENOENT
) {
3472 page_idx
= f2fs_get_next_page_offset(&dn
,
3480 end_offset
= ADDRS_PER_PAGE(dn
.node_page
, inode
);
3481 count
= min(end_offset
- dn
.ofs_in_node
, last_idx
- page_idx
);
3482 count
= round_up(count
, F2FS_I(inode
)->i_cluster_size
);
3484 ret
= release_compress_blocks(&dn
, count
);
3486 f2fs_put_dnode(&dn
);
3492 released_blocks
+= ret
;
3495 filemap_invalidate_unlock(inode
->i_mapping
);
3496 up_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
3498 inode_unlock(inode
);
3500 mnt_drop_write_file(filp
);
3503 ret
= put_user(released_blocks
, (u64 __user
*)arg
);
3504 } else if (released_blocks
&&
3505 atomic_read(&F2FS_I(inode
)->i_compr_blocks
)) {
3506 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
3507 f2fs_warn(sbi
, "%s: partial blocks were released i_ino=%lx "
3508 "iblocks=%llu, released=%u, compr_blocks=%u, "
3510 __func__
, inode
->i_ino
, inode
->i_blocks
,
3512 atomic_read(&F2FS_I(inode
)->i_compr_blocks
));
3518 static int reserve_compress_blocks(struct dnode_of_data
*dn
, pgoff_t count
)
3520 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dn
->inode
);
3521 unsigned int reserved_blocks
= 0;
3522 int cluster_size
= F2FS_I(dn
->inode
)->i_cluster_size
;
3526 for (i
= 0; i
< count
; i
++) {
3527 blkaddr
= data_blkaddr(dn
->inode
, dn
->node_page
,
3528 dn
->ofs_in_node
+ i
);
3530 if (!__is_valid_data_blkaddr(blkaddr
))
3532 if (unlikely(!f2fs_is_valid_blkaddr(sbi
, blkaddr
,
3533 DATA_GENERIC_ENHANCE
)))
3534 return -EFSCORRUPTED
;
3538 int compr_blocks
= 0;
3542 for (i
= 0; i
< cluster_size
; i
++, dn
->ofs_in_node
++) {
3543 blkaddr
= f2fs_data_blkaddr(dn
);
3546 if (blkaddr
== COMPRESS_ADDR
)
3548 dn
->ofs_in_node
+= cluster_size
;
3552 if (__is_valid_data_blkaddr(blkaddr
)) {
3557 dn
->data_blkaddr
= NEW_ADDR
;
3558 f2fs_set_data_blkaddr(dn
);
3561 reserved
= cluster_size
- compr_blocks
;
3562 ret
= inc_valid_block_count(sbi
, dn
->inode
, &reserved
);
3566 if (reserved
!= cluster_size
- compr_blocks
)
3569 f2fs_i_compr_blocks_update(dn
->inode
, compr_blocks
, true);
3571 reserved_blocks
+= reserved
;
3573 count
-= cluster_size
;
3576 return reserved_blocks
;
3579 static int f2fs_reserve_compress_blocks(struct file
*filp
, unsigned long arg
)
3581 struct inode
*inode
= file_inode(filp
);
3582 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
3583 pgoff_t page_idx
= 0, last_idx
;
3584 unsigned int reserved_blocks
= 0;
3587 if (!f2fs_sb_has_compression(F2FS_I_SB(inode
)))
3590 if (!f2fs_compressed_file(inode
))
3593 if (f2fs_readonly(sbi
->sb
))
3596 ret
= mnt_want_write_file(filp
);
3600 if (atomic_read(&F2FS_I(inode
)->i_compr_blocks
))
3603 f2fs_balance_fs(F2FS_I_SB(inode
), true);
3607 if (!is_inode_flag_set(inode
, FI_COMPRESS_RELEASED
)) {
3612 down_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
3613 filemap_invalidate_lock(inode
->i_mapping
);
3615 last_idx
= DIV_ROUND_UP(i_size_read(inode
), PAGE_SIZE
);
3617 while (page_idx
< last_idx
) {
3618 struct dnode_of_data dn
;
3619 pgoff_t end_offset
, count
;
3621 set_new_dnode(&dn
, inode
, NULL
, NULL
, 0);
3622 ret
= f2fs_get_dnode_of_data(&dn
, page_idx
, LOOKUP_NODE
);
3624 if (ret
== -ENOENT
) {
3625 page_idx
= f2fs_get_next_page_offset(&dn
,
3633 end_offset
= ADDRS_PER_PAGE(dn
.node_page
, inode
);
3634 count
= min(end_offset
- dn
.ofs_in_node
, last_idx
- page_idx
);
3635 count
= round_up(count
, F2FS_I(inode
)->i_cluster_size
);
3637 ret
= reserve_compress_blocks(&dn
, count
);
3639 f2fs_put_dnode(&dn
);
3645 reserved_blocks
+= ret
;
3648 filemap_invalidate_unlock(inode
->i_mapping
);
3649 up_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
3652 clear_inode_flag(inode
, FI_COMPRESS_RELEASED
);
3653 inode
->i_ctime
= current_time(inode
);
3654 f2fs_mark_inode_dirty_sync(inode
, true);
3657 inode_unlock(inode
);
3659 mnt_drop_write_file(filp
);
3662 ret
= put_user(reserved_blocks
, (u64 __user
*)arg
);
3663 } else if (reserved_blocks
&&
3664 atomic_read(&F2FS_I(inode
)->i_compr_blocks
)) {
3665 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
3666 f2fs_warn(sbi
, "%s: partial blocks were released i_ino=%lx "
3667 "iblocks=%llu, reserved=%u, compr_blocks=%u, "
3669 __func__
, inode
->i_ino
, inode
->i_blocks
,
3671 atomic_read(&F2FS_I(inode
)->i_compr_blocks
));
3677 static int f2fs_secure_erase(struct block_device
*bdev
, struct inode
*inode
,
3678 pgoff_t off
, block_t block
, block_t len
, u32 flags
)
3680 struct request_queue
*q
= bdev_get_queue(bdev
);
3681 sector_t sector
= SECTOR_FROM_BLOCK(block
);
3682 sector_t nr_sects
= SECTOR_FROM_BLOCK(len
);
3688 if (flags
& F2FS_TRIM_FILE_DISCARD
)
3689 ret
= blkdev_issue_discard(bdev
, sector
, nr_sects
, GFP_NOFS
,
3690 blk_queue_secure_erase(q
) ?
3691 BLKDEV_DISCARD_SECURE
: 0);
3693 if (!ret
&& (flags
& F2FS_TRIM_FILE_ZEROOUT
)) {
3694 if (IS_ENCRYPTED(inode
))
3695 ret
= fscrypt_zeroout_range(inode
, off
, block
, len
);
3697 ret
= blkdev_issue_zeroout(bdev
, sector
, nr_sects
,
3704 static int f2fs_sec_trim_file(struct file
*filp
, unsigned long arg
)
3706 struct inode
*inode
= file_inode(filp
);
3707 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
3708 struct address_space
*mapping
= inode
->i_mapping
;
3709 struct block_device
*prev_bdev
= NULL
;
3710 struct f2fs_sectrim_range range
;
3711 pgoff_t index
, pg_end
, prev_index
= 0;
3712 block_t prev_block
= 0, len
= 0;
3714 bool to_end
= false;
3717 if (!(filp
->f_mode
& FMODE_WRITE
))
3720 if (copy_from_user(&range
, (struct f2fs_sectrim_range __user
*)arg
,
3724 if (range
.flags
== 0 || (range
.flags
& ~F2FS_TRIM_FILE_MASK
) ||
3725 !S_ISREG(inode
->i_mode
))
3728 if (((range
.flags
& F2FS_TRIM_FILE_DISCARD
) &&
3729 !f2fs_hw_support_discard(sbi
)) ||
3730 ((range
.flags
& F2FS_TRIM_FILE_ZEROOUT
) &&
3731 IS_ENCRYPTED(inode
) && f2fs_is_multi_device(sbi
)))
3734 file_start_write(filp
);
3737 if (f2fs_is_atomic_file(inode
) || f2fs_compressed_file(inode
) ||
3738 range
.start
>= inode
->i_size
) {
3746 if (inode
->i_size
- range
.start
> range
.len
) {
3747 end_addr
= range
.start
+ range
.len
;
3749 end_addr
= range
.len
== (u64
)-1 ?
3750 sbi
->sb
->s_maxbytes
: inode
->i_size
;
3754 if (!IS_ALIGNED(range
.start
, F2FS_BLKSIZE
) ||
3755 (!to_end
&& !IS_ALIGNED(end_addr
, F2FS_BLKSIZE
))) {
3760 index
= F2FS_BYTES_TO_BLK(range
.start
);
3761 pg_end
= DIV_ROUND_UP(end_addr
, F2FS_BLKSIZE
);
3763 ret
= f2fs_convert_inline_inode(inode
);
3767 down_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
3768 filemap_invalidate_lock(mapping
);
3770 ret
= filemap_write_and_wait_range(mapping
, range
.start
,
3771 to_end
? LLONG_MAX
: end_addr
- 1);
3775 truncate_inode_pages_range(mapping
, range
.start
,
3776 to_end
? -1 : end_addr
- 1);
3778 while (index
< pg_end
) {
3779 struct dnode_of_data dn
;
3780 pgoff_t end_offset
, count
;
3783 set_new_dnode(&dn
, inode
, NULL
, NULL
, 0);
3784 ret
= f2fs_get_dnode_of_data(&dn
, index
, LOOKUP_NODE
);
3786 if (ret
== -ENOENT
) {
3787 index
= f2fs_get_next_page_offset(&dn
, index
);
3793 end_offset
= ADDRS_PER_PAGE(dn
.node_page
, inode
);
3794 count
= min(end_offset
- dn
.ofs_in_node
, pg_end
- index
);
3795 for (i
= 0; i
< count
; i
++, index
++, dn
.ofs_in_node
++) {
3796 struct block_device
*cur_bdev
;
3797 block_t blkaddr
= f2fs_data_blkaddr(&dn
);
3799 if (!__is_valid_data_blkaddr(blkaddr
))
3802 if (!f2fs_is_valid_blkaddr(sbi
, blkaddr
,
3803 DATA_GENERIC_ENHANCE
)) {
3804 ret
= -EFSCORRUPTED
;
3805 f2fs_put_dnode(&dn
);
3809 cur_bdev
= f2fs_target_device(sbi
, blkaddr
, NULL
);
3810 if (f2fs_is_multi_device(sbi
)) {
3811 int di
= f2fs_target_device_index(sbi
, blkaddr
);
3813 blkaddr
-= FDEV(di
).start_blk
;
3817 if (prev_bdev
== cur_bdev
&&
3818 index
== prev_index
+ len
&&
3819 blkaddr
== prev_block
+ len
) {
3822 ret
= f2fs_secure_erase(prev_bdev
,
3823 inode
, prev_index
, prev_block
,
3826 f2fs_put_dnode(&dn
);
3835 prev_bdev
= cur_bdev
;
3837 prev_block
= blkaddr
;
3842 f2fs_put_dnode(&dn
);
3844 if (fatal_signal_pending(current
)) {
3852 ret
= f2fs_secure_erase(prev_bdev
, inode
, prev_index
,
3853 prev_block
, len
, range
.flags
);
3855 filemap_invalidate_unlock(mapping
);
3856 up_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
3858 inode_unlock(inode
);
3859 file_end_write(filp
);
3864 static int f2fs_ioc_get_compress_option(struct file
*filp
, unsigned long arg
)
3866 struct inode
*inode
= file_inode(filp
);
3867 struct f2fs_comp_option option
;
3869 if (!f2fs_sb_has_compression(F2FS_I_SB(inode
)))
3872 inode_lock_shared(inode
);
3874 if (!f2fs_compressed_file(inode
)) {
3875 inode_unlock_shared(inode
);
3879 option
.algorithm
= F2FS_I(inode
)->i_compress_algorithm
;
3880 option
.log_cluster_size
= F2FS_I(inode
)->i_log_cluster_size
;
3882 inode_unlock_shared(inode
);
3884 if (copy_to_user((struct f2fs_comp_option __user
*)arg
, &option
,
3891 static int f2fs_ioc_set_compress_option(struct file
*filp
, unsigned long arg
)
3893 struct inode
*inode
= file_inode(filp
);
3894 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
3895 struct f2fs_comp_option option
;
3898 if (!f2fs_sb_has_compression(sbi
))
3901 if (!(filp
->f_mode
& FMODE_WRITE
))
3904 if (copy_from_user(&option
, (struct f2fs_comp_option __user
*)arg
,
3908 if (!f2fs_compressed_file(inode
) ||
3909 option
.log_cluster_size
< MIN_COMPRESS_LOG_SIZE
||
3910 option
.log_cluster_size
> MAX_COMPRESS_LOG_SIZE
||
3911 option
.algorithm
>= COMPRESS_MAX
)
3914 file_start_write(filp
);
3917 if (f2fs_is_mmap_file(inode
) || get_dirty_pages(inode
)) {
3922 if (inode
->i_size
!= 0) {
3927 F2FS_I(inode
)->i_compress_algorithm
= option
.algorithm
;
3928 F2FS_I(inode
)->i_log_cluster_size
= option
.log_cluster_size
;
3929 F2FS_I(inode
)->i_cluster_size
= 1 << option
.log_cluster_size
;
3930 f2fs_mark_inode_dirty_sync(inode
, true);
3932 if (!f2fs_is_compress_backend_ready(inode
))
3933 f2fs_warn(sbi
, "compression algorithm is successfully set, "
3934 "but current kernel doesn't support this algorithm.");
3936 inode_unlock(inode
);
3937 file_end_write(filp
);
3942 static int redirty_blocks(struct inode
*inode
, pgoff_t page_idx
, int len
)
3944 DEFINE_READAHEAD(ractl
, NULL
, NULL
, inode
->i_mapping
, page_idx
);
3945 struct address_space
*mapping
= inode
->i_mapping
;
3947 pgoff_t redirty_idx
= page_idx
;
3948 int i
, page_len
= 0, ret
= 0;
3950 page_cache_ra_unbounded(&ractl
, len
, 0);
3952 for (i
= 0; i
< len
; i
++, page_idx
++) {
3953 page
= read_cache_page(mapping
, page_idx
, NULL
, NULL
);
3955 ret
= PTR_ERR(page
);
3961 for (i
= 0; i
< page_len
; i
++, redirty_idx
++) {
3962 page
= find_lock_page(mapping
, redirty_idx
);
3967 set_page_dirty(page
);
3968 f2fs_put_page(page
, 1);
3969 f2fs_put_page(page
, 0);
3975 static int f2fs_ioc_decompress_file(struct file
*filp
, unsigned long arg
)
3977 struct inode
*inode
= file_inode(filp
);
3978 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
3979 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
3980 pgoff_t page_idx
= 0, last_idx
;
3981 unsigned int blk_per_seg
= sbi
->blocks_per_seg
;
3982 int cluster_size
= F2FS_I(inode
)->i_cluster_size
;
3985 if (!f2fs_sb_has_compression(sbi
) ||
3986 F2FS_OPTION(sbi
).compress_mode
!= COMPR_MODE_USER
)
3989 if (!(filp
->f_mode
& FMODE_WRITE
))
3992 if (!f2fs_compressed_file(inode
))
3995 f2fs_balance_fs(F2FS_I_SB(inode
), true);
3997 file_start_write(filp
);
4000 if (!f2fs_is_compress_backend_ready(inode
)) {
4005 if (f2fs_is_mmap_file(inode
)) {
4010 ret
= filemap_write_and_wait_range(inode
->i_mapping
, 0, LLONG_MAX
);
4014 if (!atomic_read(&fi
->i_compr_blocks
))
4017 last_idx
= DIV_ROUND_UP(i_size_read(inode
), PAGE_SIZE
);
4019 count
= last_idx
- page_idx
;
4021 int len
= min(cluster_size
, count
);
4023 ret
= redirty_blocks(inode
, page_idx
, len
);
4027 if (get_dirty_pages(inode
) >= blk_per_seg
)
4028 filemap_fdatawrite(inode
->i_mapping
);
4035 ret
= filemap_write_and_wait_range(inode
->i_mapping
, 0,
4039 f2fs_warn(sbi
, "%s: The file might be partially decompressed (errno=%d). Please delete the file.",
4042 inode_unlock(inode
);
4043 file_end_write(filp
);
4048 static int f2fs_ioc_compress_file(struct file
*filp
, unsigned long arg
)
4050 struct inode
*inode
= file_inode(filp
);
4051 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
4052 pgoff_t page_idx
= 0, last_idx
;
4053 unsigned int blk_per_seg
= sbi
->blocks_per_seg
;
4054 int cluster_size
= F2FS_I(inode
)->i_cluster_size
;
4057 if (!f2fs_sb_has_compression(sbi
) ||
4058 F2FS_OPTION(sbi
).compress_mode
!= COMPR_MODE_USER
)
4061 if (!(filp
->f_mode
& FMODE_WRITE
))
4064 if (!f2fs_compressed_file(inode
))
4067 f2fs_balance_fs(F2FS_I_SB(inode
), true);
4069 file_start_write(filp
);
4072 if (!f2fs_is_compress_backend_ready(inode
)) {
4077 if (f2fs_is_mmap_file(inode
)) {
4082 ret
= filemap_write_and_wait_range(inode
->i_mapping
, 0, LLONG_MAX
);
4086 set_inode_flag(inode
, FI_ENABLE_COMPRESS
);
4088 last_idx
= DIV_ROUND_UP(i_size_read(inode
), PAGE_SIZE
);
4090 count
= last_idx
- page_idx
;
4092 int len
= min(cluster_size
, count
);
4094 ret
= redirty_blocks(inode
, page_idx
, len
);
4098 if (get_dirty_pages(inode
) >= blk_per_seg
)
4099 filemap_fdatawrite(inode
->i_mapping
);
4106 ret
= filemap_write_and_wait_range(inode
->i_mapping
, 0,
4109 clear_inode_flag(inode
, FI_ENABLE_COMPRESS
);
4112 f2fs_warn(sbi
, "%s: The file might be partially compressed (errno=%d). Please delete the file.",
4115 inode_unlock(inode
);
4116 file_end_write(filp
);
4121 static long __f2fs_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
4124 case FS_IOC_GETVERSION
:
4125 return f2fs_ioc_getversion(filp
, arg
);
4126 case F2FS_IOC_START_ATOMIC_WRITE
:
4127 return f2fs_ioc_start_atomic_write(filp
);
4128 case F2FS_IOC_COMMIT_ATOMIC_WRITE
:
4129 return f2fs_ioc_commit_atomic_write(filp
);
4130 case F2FS_IOC_START_VOLATILE_WRITE
:
4131 return f2fs_ioc_start_volatile_write(filp
);
4132 case F2FS_IOC_RELEASE_VOLATILE_WRITE
:
4133 return f2fs_ioc_release_volatile_write(filp
);
4134 case F2FS_IOC_ABORT_VOLATILE_WRITE
:
4135 return f2fs_ioc_abort_volatile_write(filp
);
4136 case F2FS_IOC_SHUTDOWN
:
4137 return f2fs_ioc_shutdown(filp
, arg
);
4139 return f2fs_ioc_fitrim(filp
, arg
);
4140 case FS_IOC_SET_ENCRYPTION_POLICY
:
4141 return f2fs_ioc_set_encryption_policy(filp
, arg
);
4142 case FS_IOC_GET_ENCRYPTION_POLICY
:
4143 return f2fs_ioc_get_encryption_policy(filp
, arg
);
4144 case FS_IOC_GET_ENCRYPTION_PWSALT
:
4145 return f2fs_ioc_get_encryption_pwsalt(filp
, arg
);
4146 case FS_IOC_GET_ENCRYPTION_POLICY_EX
:
4147 return f2fs_ioc_get_encryption_policy_ex(filp
, arg
);
4148 case FS_IOC_ADD_ENCRYPTION_KEY
:
4149 return f2fs_ioc_add_encryption_key(filp
, arg
);
4150 case FS_IOC_REMOVE_ENCRYPTION_KEY
:
4151 return f2fs_ioc_remove_encryption_key(filp
, arg
);
4152 case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS
:
4153 return f2fs_ioc_remove_encryption_key_all_users(filp
, arg
);
4154 case FS_IOC_GET_ENCRYPTION_KEY_STATUS
:
4155 return f2fs_ioc_get_encryption_key_status(filp
, arg
);
4156 case FS_IOC_GET_ENCRYPTION_NONCE
:
4157 return f2fs_ioc_get_encryption_nonce(filp
, arg
);
4158 case F2FS_IOC_GARBAGE_COLLECT
:
4159 return f2fs_ioc_gc(filp
, arg
);
4160 case F2FS_IOC_GARBAGE_COLLECT_RANGE
:
4161 return f2fs_ioc_gc_range(filp
, arg
);
4162 case F2FS_IOC_WRITE_CHECKPOINT
:
4163 return f2fs_ioc_write_checkpoint(filp
, arg
);
4164 case F2FS_IOC_DEFRAGMENT
:
4165 return f2fs_ioc_defragment(filp
, arg
);
4166 case F2FS_IOC_MOVE_RANGE
:
4167 return f2fs_ioc_move_range(filp
, arg
);
4168 case F2FS_IOC_FLUSH_DEVICE
:
4169 return f2fs_ioc_flush_device(filp
, arg
);
4170 case F2FS_IOC_GET_FEATURES
:
4171 return f2fs_ioc_get_features(filp
, arg
);
4172 case F2FS_IOC_GET_PIN_FILE
:
4173 return f2fs_ioc_get_pin_file(filp
, arg
);
4174 case F2FS_IOC_SET_PIN_FILE
:
4175 return f2fs_ioc_set_pin_file(filp
, arg
);
4176 case F2FS_IOC_PRECACHE_EXTENTS
:
4177 return f2fs_ioc_precache_extents(filp
, arg
);
4178 case F2FS_IOC_RESIZE_FS
:
4179 return f2fs_ioc_resize_fs(filp
, arg
);
4180 case FS_IOC_ENABLE_VERITY
:
4181 return f2fs_ioc_enable_verity(filp
, arg
);
4182 case FS_IOC_MEASURE_VERITY
:
4183 return f2fs_ioc_measure_verity(filp
, arg
);
4184 case FS_IOC_READ_VERITY_METADATA
:
4185 return f2fs_ioc_read_verity_metadata(filp
, arg
);
4186 case FS_IOC_GETFSLABEL
:
4187 return f2fs_ioc_getfslabel(filp
, arg
);
4188 case FS_IOC_SETFSLABEL
:
4189 return f2fs_ioc_setfslabel(filp
, arg
);
4190 case F2FS_IOC_GET_COMPRESS_BLOCKS
:
4191 return f2fs_get_compress_blocks(filp
, arg
);
4192 case F2FS_IOC_RELEASE_COMPRESS_BLOCKS
:
4193 return f2fs_release_compress_blocks(filp
, arg
);
4194 case F2FS_IOC_RESERVE_COMPRESS_BLOCKS
:
4195 return f2fs_reserve_compress_blocks(filp
, arg
);
4196 case F2FS_IOC_SEC_TRIM_FILE
:
4197 return f2fs_sec_trim_file(filp
, arg
);
4198 case F2FS_IOC_GET_COMPRESS_OPTION
:
4199 return f2fs_ioc_get_compress_option(filp
, arg
);
4200 case F2FS_IOC_SET_COMPRESS_OPTION
:
4201 return f2fs_ioc_set_compress_option(filp
, arg
);
4202 case F2FS_IOC_DECOMPRESS_FILE
:
4203 return f2fs_ioc_decompress_file(filp
, arg
);
4204 case F2FS_IOC_COMPRESS_FILE
:
4205 return f2fs_ioc_compress_file(filp
, arg
);
4211 long f2fs_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
4213 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp
)))))
4215 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(file_inode(filp
))))
4218 return __f2fs_ioctl(filp
, cmd
, arg
);
4221 static ssize_t
f2fs_file_read_iter(struct kiocb
*iocb
, struct iov_iter
*iter
)
4223 struct file
*file
= iocb
->ki_filp
;
4224 struct inode
*inode
= file_inode(file
);
4227 if (!f2fs_is_compress_backend_ready(inode
))
4230 ret
= generic_file_read_iter(iocb
, iter
);
4233 f2fs_update_iostat(F2FS_I_SB(inode
), APP_READ_IO
, ret
);
4238 static ssize_t
f2fs_file_write_iter(struct kiocb
*iocb
, struct iov_iter
*from
)
4240 struct file
*file
= iocb
->ki_filp
;
4241 struct inode
*inode
= file_inode(file
);
4244 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode
)))) {
4249 if (!f2fs_is_compress_backend_ready(inode
)) {
4254 if (iocb
->ki_flags
& IOCB_NOWAIT
) {
4255 if (!inode_trylock(inode
)) {
4263 if (unlikely(IS_IMMUTABLE(inode
))) {
4268 if (is_inode_flag_set(inode
, FI_COMPRESS_RELEASED
)) {
4273 ret
= generic_write_checks(iocb
, from
);
4275 bool preallocated
= false;
4276 size_t target_size
= 0;
4279 if (iov_iter_fault_in_readable(from
, iov_iter_count(from
)))
4280 set_inode_flag(inode
, FI_NO_PREALLOC
);
4282 if ((iocb
->ki_flags
& IOCB_NOWAIT
)) {
4283 if (!f2fs_overwrite_io(inode
, iocb
->ki_pos
,
4284 iov_iter_count(from
)) ||
4285 f2fs_has_inline_data(inode
) ||
4286 f2fs_force_buffered_io(inode
, iocb
, from
)) {
4287 clear_inode_flag(inode
, FI_NO_PREALLOC
);
4288 inode_unlock(inode
);
4295 if (is_inode_flag_set(inode
, FI_NO_PREALLOC
))
4298 if (iocb
->ki_flags
& IOCB_DIRECT
) {
4300 * Convert inline data for Direct I/O before entering
4303 err
= f2fs_convert_inline_inode(inode
);
4307 * If force_buffere_io() is true, we have to allocate
4308 * blocks all the time, since f2fs_direct_IO will fall
4309 * back to buffered IO.
4311 if (!f2fs_force_buffered_io(inode
, iocb
, from
) &&
4312 f2fs_lfs_mode(F2FS_I_SB(inode
)))
4315 preallocated
= true;
4316 target_size
= iocb
->ki_pos
+ iov_iter_count(from
);
4318 err
= f2fs_preallocate_blocks(iocb
, from
);
4321 clear_inode_flag(inode
, FI_NO_PREALLOC
);
4322 inode_unlock(inode
);
4327 ret
= __generic_file_write_iter(iocb
, from
);
4328 clear_inode_flag(inode
, FI_NO_PREALLOC
);
4330 /* if we couldn't write data, we should deallocate blocks. */
4331 if (preallocated
&& i_size_read(inode
) < target_size
) {
4332 down_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
4333 filemap_invalidate_lock(inode
->i_mapping
);
4334 f2fs_truncate(inode
);
4335 filemap_invalidate_unlock(inode
->i_mapping
);
4336 up_write(&F2FS_I(inode
)->i_gc_rwsem
[WRITE
]);
4340 f2fs_update_iostat(F2FS_I_SB(inode
), APP_WRITE_IO
, ret
);
4343 inode_unlock(inode
);
4345 trace_f2fs_file_write_iter(inode
, iocb
->ki_pos
,
4346 iov_iter_count(from
), ret
);
4348 ret
= generic_write_sync(iocb
, ret
);
4352 static int f2fs_file_fadvise(struct file
*filp
, loff_t offset
, loff_t len
,
4355 struct inode
*inode
;
4356 struct address_space
*mapping
;
4357 struct backing_dev_info
*bdi
;
4359 if (advice
== POSIX_FADV_SEQUENTIAL
) {
4360 inode
= file_inode(filp
);
4361 if (S_ISFIFO(inode
->i_mode
))
4364 mapping
= filp
->f_mapping
;
4365 if (!mapping
|| len
< 0)
4368 bdi
= inode_to_bdi(mapping
->host
);
4369 filp
->f_ra
.ra_pages
= bdi
->ra_pages
*
4370 F2FS_I_SB(inode
)->seq_file_ra_mul
;
4371 spin_lock(&filp
->f_lock
);
4372 filp
->f_mode
&= ~FMODE_RANDOM
;
4373 spin_unlock(&filp
->f_lock
);
4377 return generic_fadvise(filp
, offset
, len
, advice
);
4380 #ifdef CONFIG_COMPAT
4381 struct compat_f2fs_gc_range
{
4386 #define F2FS_IOC32_GARBAGE_COLLECT_RANGE _IOW(F2FS_IOCTL_MAGIC, 11,\
4387 struct compat_f2fs_gc_range)
4389 static int f2fs_compat_ioc_gc_range(struct file
*file
, unsigned long arg
)
4391 struct compat_f2fs_gc_range __user
*urange
;
4392 struct f2fs_gc_range range
;
4395 urange
= compat_ptr(arg
);
4396 err
= get_user(range
.sync
, &urange
->sync
);
4397 err
|= get_user(range
.start
, &urange
->start
);
4398 err
|= get_user(range
.len
, &urange
->len
);
4402 return __f2fs_ioc_gc_range(file
, &range
);
4405 struct compat_f2fs_move_range
{
4411 #define F2FS_IOC32_MOVE_RANGE _IOWR(F2FS_IOCTL_MAGIC, 9, \
4412 struct compat_f2fs_move_range)
4414 static int f2fs_compat_ioc_move_range(struct file
*file
, unsigned long arg
)
4416 struct compat_f2fs_move_range __user
*urange
;
4417 struct f2fs_move_range range
;
4420 urange
= compat_ptr(arg
);
4421 err
= get_user(range
.dst_fd
, &urange
->dst_fd
);
4422 err
|= get_user(range
.pos_in
, &urange
->pos_in
);
4423 err
|= get_user(range
.pos_out
, &urange
->pos_out
);
4424 err
|= get_user(range
.len
, &urange
->len
);
4428 return __f2fs_ioc_move_range(file
, &range
);
4431 long f2fs_compat_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
4433 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(file
)))))
4435 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(file_inode(file
))))
4439 case FS_IOC32_GETVERSION
:
4440 cmd
= FS_IOC_GETVERSION
;
4442 case F2FS_IOC32_GARBAGE_COLLECT_RANGE
:
4443 return f2fs_compat_ioc_gc_range(file
, arg
);
4444 case F2FS_IOC32_MOVE_RANGE
:
4445 return f2fs_compat_ioc_move_range(file
, arg
);
4446 case F2FS_IOC_START_ATOMIC_WRITE
:
4447 case F2FS_IOC_COMMIT_ATOMIC_WRITE
:
4448 case F2FS_IOC_START_VOLATILE_WRITE
:
4449 case F2FS_IOC_RELEASE_VOLATILE_WRITE
:
4450 case F2FS_IOC_ABORT_VOLATILE_WRITE
:
4451 case F2FS_IOC_SHUTDOWN
:
4453 case FS_IOC_SET_ENCRYPTION_POLICY
:
4454 case FS_IOC_GET_ENCRYPTION_PWSALT
:
4455 case FS_IOC_GET_ENCRYPTION_POLICY
:
4456 case FS_IOC_GET_ENCRYPTION_POLICY_EX
:
4457 case FS_IOC_ADD_ENCRYPTION_KEY
:
4458 case FS_IOC_REMOVE_ENCRYPTION_KEY
:
4459 case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS
:
4460 case FS_IOC_GET_ENCRYPTION_KEY_STATUS
:
4461 case FS_IOC_GET_ENCRYPTION_NONCE
:
4462 case F2FS_IOC_GARBAGE_COLLECT
:
4463 case F2FS_IOC_WRITE_CHECKPOINT
:
4464 case F2FS_IOC_DEFRAGMENT
:
4465 case F2FS_IOC_FLUSH_DEVICE
:
4466 case F2FS_IOC_GET_FEATURES
:
4467 case F2FS_IOC_GET_PIN_FILE
:
4468 case F2FS_IOC_SET_PIN_FILE
:
4469 case F2FS_IOC_PRECACHE_EXTENTS
:
4470 case F2FS_IOC_RESIZE_FS
:
4471 case FS_IOC_ENABLE_VERITY
:
4472 case FS_IOC_MEASURE_VERITY
:
4473 case FS_IOC_READ_VERITY_METADATA
:
4474 case FS_IOC_GETFSLABEL
:
4475 case FS_IOC_SETFSLABEL
:
4476 case F2FS_IOC_GET_COMPRESS_BLOCKS
:
4477 case F2FS_IOC_RELEASE_COMPRESS_BLOCKS
:
4478 case F2FS_IOC_RESERVE_COMPRESS_BLOCKS
:
4479 case F2FS_IOC_SEC_TRIM_FILE
:
4480 case F2FS_IOC_GET_COMPRESS_OPTION
:
4481 case F2FS_IOC_SET_COMPRESS_OPTION
:
4482 case F2FS_IOC_DECOMPRESS_FILE
:
4483 case F2FS_IOC_COMPRESS_FILE
:
4486 return -ENOIOCTLCMD
;
4488 return __f2fs_ioctl(file
, cmd
, (unsigned long) compat_ptr(arg
));
4492 const struct file_operations f2fs_file_operations
= {
4493 .llseek
= f2fs_llseek
,
4494 .read_iter
= f2fs_file_read_iter
,
4495 .write_iter
= f2fs_file_write_iter
,
4496 .open
= f2fs_file_open
,
4497 .release
= f2fs_release_file
,
4498 .mmap
= f2fs_file_mmap
,
4499 .flush
= f2fs_file_flush
,
4500 .fsync
= f2fs_sync_file
,
4501 .fallocate
= f2fs_fallocate
,
4502 .unlocked_ioctl
= f2fs_ioctl
,
4503 #ifdef CONFIG_COMPAT
4504 .compat_ioctl
= f2fs_compat_ioctl
,
4506 .splice_read
= generic_file_splice_read
,
4507 .splice_write
= iter_file_splice_write
,
4508 .fadvise
= f2fs_file_fadvise
,