file.c (c8e43d55b1aa05d175daac25d228c7c1c71c7b11) file.c (e17fe6579de023725ec22a16965e9099e4a05ac9)
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * fs/f2fs/file.c
4 *
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
7 */
8#include <linux/fs.h>

--- 15 unchanged lines hidden (view full) ---

24#include <linux/sched/signal.h>
25
26#include "f2fs.h"
27#include "node.h"
28#include "segment.h"
29#include "xattr.h"
30#include "acl.h"
31#include "gc.h"
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * fs/f2fs/file.c
4 *
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
7 */
8#include <linux/fs.h>

--- 15 unchanged lines hidden (view full) ---

24#include <linux/sched/signal.h>
25
26#include "f2fs.h"
27#include "node.h"
28#include "segment.h"
29#include "xattr.h"
30#include "acl.h"
31#include "gc.h"
32#include "trace.h"
32#include <trace/events/f2fs.h>
33#include <uapi/linux/f2fs.h>
34
35static vm_fault_t f2fs_filemap_fault(struct vm_fault *vmf)
36{
37 struct inode *inode = file_inode(vmf->vma->vm_file);
38 vm_fault_t ret;
39

--- 14 unchanged lines hidden (view full) ---

54{
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;
60 int err = 0;
61
33#include <trace/events/f2fs.h>
34#include <uapi/linux/f2fs.h>
35
36static vm_fault_t f2fs_filemap_fault(struct vm_fault *vmf)
37{
38 struct inode *inode = file_inode(vmf->vma->vm_file);
39 vm_fault_t ret;
40

--- 14 unchanged lines hidden (view full) ---

55{
56 struct page *page = vmf->page;
57 struct inode *inode = file_inode(vmf->vma->vm_file);
58 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
59 struct dnode_of_data dn;
60 bool need_alloc = true;
61 int err = 0;
62
62 if (unlikely(IS_IMMUTABLE(inode)))
63 return VM_FAULT_SIGBUS;
64
65 if (unlikely(f2fs_cp_error(sbi))) {
66 err = -EIO;
67 goto err;
68 }
69
70 if (!f2fs_is_checkpoint_ready(sbi)) {
71 err = -ENOSPC;
72 goto err;
73 }
74
63 if (unlikely(f2fs_cp_error(sbi))) {
64 err = -EIO;
65 goto err;
66 }
67
68 if (!f2fs_is_checkpoint_ready(sbi)) {
69 err = -ENOSPC;
70 goto err;
71 }
72
75 err = f2fs_convert_inline_inode(inode);
76 if (err)
77 goto err;
78
79#ifdef CONFIG_F2FS_FS_COMPRESSION
80 if (f2fs_compressed_file(inode)) {
81 int ret = f2fs_is_compressed_cluster(inode, page->index);
82
83 if (ret < 0) {
84 err = ret;
85 goto err;
86 } else if (ret) {

--- 280 unchanged lines hidden (view full) ---

367 if (!ret) {
368 f2fs_remove_ino_entry(sbi, ino, UPDATE_INO);
369 clear_inode_flag(inode, FI_UPDATE_WRITE);
370 f2fs_remove_ino_entry(sbi, ino, FLUSH_INO);
371 }
372 f2fs_update_time(sbi, REQ_TIME);
373out:
374 trace_f2fs_sync_file_exit(inode, cp_reason, datasync, ret);
73#ifdef CONFIG_F2FS_FS_COMPRESSION
74 if (f2fs_compressed_file(inode)) {
75 int ret = f2fs_is_compressed_cluster(inode, page->index);
76
77 if (ret < 0) {
78 err = ret;
79 goto err;
80 } else if (ret) {

--- 280 unchanged lines hidden (view full) ---

361 if (!ret) {
362 f2fs_remove_ino_entry(sbi, ino, UPDATE_INO);
363 clear_inode_flag(inode, FI_UPDATE_WRITE);
364 f2fs_remove_ino_entry(sbi, ino, FLUSH_INO);
365 }
366 f2fs_update_time(sbi, REQ_TIME);
367out:
368 trace_f2fs_sync_file_exit(inode, cp_reason, datasync, ret);
369 f2fs_trace_ios(NULL, 1);
375 return ret;
376}
377
378int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
379{
380 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(file)))))
381 return -EIO;
382 return f2fs_do_sync_file(file, start, end, datasync, false);

--- 100 unchanged lines hidden (view full) ---

483 return -ENXIO;
484}
485
486static loff_t f2fs_llseek(struct file *file, loff_t offset, int whence)
487{
488 struct inode *inode = file->f_mapping->host;
489 loff_t maxbytes = inode->i_sb->s_maxbytes;
490
370 return ret;
371}
372
373int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
374{
375 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(file)))))
376 return -EIO;
377 return f2fs_do_sync_file(file, start, end, datasync, false);

--- 100 unchanged lines hidden (view full) ---

478 return -ENXIO;
479}
480
481static loff_t f2fs_llseek(struct file *file, loff_t offset, int whence)
482{
483 struct inode *inode = file->f_mapping->host;
484 loff_t maxbytes = inode->i_sb->s_maxbytes;
485
491 if (f2fs_compressed_file(inode))
492 maxbytes = max_file_blocks(inode) << F2FS_BLKSIZE_BITS;
493
494 switch (whence) {
495 case SEEK_SET:
496 case SEEK_CUR:
497 case SEEK_END:
498 return generic_file_llseek_size(file, offset, whence,
499 maxbytes, i_size_read(inode));
500 case SEEK_DATA:
501 case SEEK_HOLE:
502 if (offset < 0)
503 return -ENXIO;
504 return f2fs_seek_block(file, offset, whence);
505 }
506
507 return -EINVAL;
508}
509
510static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
511{
512 struct inode *inode = file_inode(file);
486 switch (whence) {
487 case SEEK_SET:
488 case SEEK_CUR:
489 case SEEK_END:
490 return generic_file_llseek_size(file, offset, whence,
491 maxbytes, i_size_read(inode));
492 case SEEK_DATA:
493 case SEEK_HOLE:
494 if (offset < 0)
495 return -ENXIO;
496 return f2fs_seek_block(file, offset, whence);
497 }
498
499 return -EINVAL;
500}
501
502static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
503{
504 struct inode *inode = file_inode(file);
505 int err;
513
514 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
515 return -EIO;
516
517 if (!f2fs_is_compress_backend_ready(inode))
518 return -EOPNOTSUPP;
519
506
507 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
508 return -EIO;
509
510 if (!f2fs_is_compress_backend_ready(inode))
511 return -EOPNOTSUPP;
512
513 /* we don't need to use inline_data strictly */
514 err = f2fs_convert_inline_inode(inode);
515 if (err)
516 return err;
517
520 file_accessed(file);
521 vma->vm_ops = &f2fs_file_vm_ops;
522 set_inode_flag(inode, FI_MMAP_FILE);
523 return 0;
524}
525
526static int f2fs_file_open(struct inode *inode, struct file *filp)
527{

--- 136 unchanged lines hidden (view full) ---

664 int count = 0, err = 0;
665 struct page *ipage;
666 bool truncate_page = false;
667
668 trace_f2fs_truncate_blocks_enter(inode, from);
669
670 free_from = (pgoff_t)F2FS_BLK_ALIGN(from);
671
518 file_accessed(file);
519 vma->vm_ops = &f2fs_file_vm_ops;
520 set_inode_flag(inode, FI_MMAP_FILE);
521 return 0;
522}
523
524static int f2fs_file_open(struct inode *inode, struct file *filp)
525{

--- 136 unchanged lines hidden (view full) ---

662 int count = 0, err = 0;
663 struct page *ipage;
664 bool truncate_page = false;
665
666 trace_f2fs_truncate_blocks_enter(inode, from);
667
668 free_from = (pgoff_t)F2FS_BLK_ALIGN(from);
669
672 if (free_from >= max_file_blocks(inode))
670 if (free_from >= sbi->max_file_blocks)
673 goto free_partial;
674
675 if (lock)
676 f2fs_lock_op(sbi);
677
678 ipage = f2fs_get_node_page(sbi, inode->i_ino);
679 if (IS_ERR(ipage)) {
680 err = PTR_ERR(ipage);

--- 83 unchanged lines hidden (view full) ---

764
765 trace_f2fs_truncate(inode);
766
767 if (time_to_inject(F2FS_I_SB(inode), FAULT_TRUNCATE)) {
768 f2fs_show_injection_info(F2FS_I_SB(inode), FAULT_TRUNCATE);
769 return -EIO;
770 }
771
671 goto free_partial;
672
673 if (lock)
674 f2fs_lock_op(sbi);
675
676 ipage = f2fs_get_node_page(sbi, inode->i_ino);
677 if (IS_ERR(ipage)) {
678 err = PTR_ERR(ipage);

--- 83 unchanged lines hidden (view full) ---

762
763 trace_f2fs_truncate(inode);
764
765 if (time_to_inject(F2FS_I_SB(inode), FAULT_TRUNCATE)) {
766 f2fs_show_injection_info(F2FS_I_SB(inode), FAULT_TRUNCATE);
767 return -EIO;
768 }
769
772 err = dquot_initialize(inode);
773 if (err)
774 return err;
775
776 /* we should check inline_data size */
777 if (!f2fs_may_inline_data(inode)) {
778 err = f2fs_convert_inline_inode(inode);
779 if (err)
780 return err;
781 }
782
783 err = f2fs_truncate_blocks(inode, i_size_read(inode), true);

--- 65 unchanged lines hidden (view full) ---

849 inode->i_atime = attr->ia_atime;
850 if (ia_valid & ATTR_MTIME)
851 inode->i_mtime = attr->ia_mtime;
852 if (ia_valid & ATTR_CTIME)
853 inode->i_ctime = attr->ia_ctime;
854 if (ia_valid & ATTR_MODE) {
855 umode_t mode = attr->ia_mode;
856
770 /* we should check inline_data size */
771 if (!f2fs_may_inline_data(inode)) {
772 err = f2fs_convert_inline_inode(inode);
773 if (err)
774 return err;
775 }
776
777 err = f2fs_truncate_blocks(inode, i_size_read(inode), true);

--- 65 unchanged lines hidden (view full) ---

843 inode->i_atime = attr->ia_atime;
844 if (ia_valid & ATTR_MTIME)
845 inode->i_mtime = attr->ia_mtime;
846 if (ia_valid & ATTR_CTIME)
847 inode->i_ctime = attr->ia_ctime;
848 if (ia_valid & ATTR_MODE) {
849 umode_t mode = attr->ia_mode;
850
857 if (!in_group_p(inode->i_gid) &&
858 !capable_wrt_inode_uidgid(inode, CAP_FSETID))
851 if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
859 mode &= ~S_ISGID;
860 set_acl_inode(inode, mode);
861 }
862}
863#else
864#define __setattr_copy setattr_copy
865#endif
866
867int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
868{
869 struct inode *inode = d_inode(dentry);
870 int err;
871
872 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
873 return -EIO;
874
852 mode &= ~S_ISGID;
853 set_acl_inode(inode, mode);
854 }
855}
856#else
857#define __setattr_copy setattr_copy
858#endif
859
860int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
861{
862 struct inode *inode = d_inode(dentry);
863 int err;
864
865 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
866 return -EIO;
867
875 if (unlikely(IS_IMMUTABLE(inode)))
876 return -EPERM;
877
878 if (unlikely(IS_APPEND(inode) &&
879 (attr->ia_valid & (ATTR_MODE | ATTR_UID |
880 ATTR_GID | ATTR_TIMES_SET))))
881 return -EPERM;
882
883 if ((attr->ia_valid & ATTR_SIZE) &&
884 !f2fs_is_compress_backend_ready(inode))
885 return -EOPNOTSUPP;
886
887 err = setattr_prepare(dentry, attr);
888 if (err)
889 return err;
890

--- 68 unchanged lines hidden (view full) ---

959 F2FS_I(inode)->last_disk_size = i_size_read(inode);
960 spin_unlock(&F2FS_I(inode)->i_size_lock);
961 }
962
963 __setattr_copy(inode, attr);
964
965 if (attr->ia_valid & ATTR_MODE) {
966 err = posix_acl_chmod(inode, f2fs_get_inode_mode(inode));
868 if ((attr->ia_valid & ATTR_SIZE) &&
869 !f2fs_is_compress_backend_ready(inode))
870 return -EOPNOTSUPP;
871
872 err = setattr_prepare(dentry, attr);
873 if (err)
874 return err;
875

--- 68 unchanged lines hidden (view full) ---

944 F2FS_I(inode)->last_disk_size = i_size_read(inode);
945 spin_unlock(&F2FS_I(inode)->i_size_lock);
946 }
947
948 __setattr_copy(inode, attr);
949
950 if (attr->ia_valid & ATTR_MODE) {
951 err = posix_acl_chmod(inode, f2fs_get_inode_mode(inode));
967
968 if (is_inode_flag_set(inode, FI_ACL_MODE)) {
969 if (!err)
970 inode->i_mode = F2FS_I(inode)->i_acl_mode;
952 if (err || is_inode_flag_set(inode, FI_ACL_MODE)) {
953 inode->i_mode = F2FS_I(inode)->i_acl_mode;
971 clear_inode_flag(inode, FI_ACL_MODE);
972 }
973 }
974
975 /* file size may changed here */
976 f2fs_mark_inode_dirty_sync(inode, true);
977
978 /* inode change will produce dirty node pages flushed by checkpoint */

--- 1763 unchanged lines hidden (view full) ---

2742 sizeof(range)))
2743 return -EFAULT;
2744
2745 /* verify alignment of offset & size */
2746 if (range.start & (F2FS_BLKSIZE - 1) || range.len & (F2FS_BLKSIZE - 1))
2747 return -EINVAL;
2748
2749 if (unlikely((range.start + range.len) >> PAGE_SHIFT >
954 clear_inode_flag(inode, FI_ACL_MODE);
955 }
956 }
957
958 /* file size may changed here */
959 f2fs_mark_inode_dirty_sync(inode, true);
960
961 /* inode change will produce dirty node pages flushed by checkpoint */

--- 1763 unchanged lines hidden (view full) ---

2725 sizeof(range)))
2726 return -EFAULT;
2727
2728 /* verify alignment of offset & size */
2729 if (range.start & (F2FS_BLKSIZE - 1) || range.len & (F2FS_BLKSIZE - 1))
2730 return -EINVAL;
2731
2732 if (unlikely((range.start + range.len) >> PAGE_SHIFT >
2750 max_file_blocks(inode)))
2733 sbi->max_file_blocks))
2751 return -EINVAL;
2752
2753 err = mnt_want_write_file(filp);
2754 if (err)
2755 return err;
2756
2757 err = f2fs_defragment_range(sbi, filp, &range);
2758 mnt_drop_write_file(filp);

--- 546 unchanged lines hidden (view full) ---

3305 if (is_inode_flag_set(inode, FI_NO_EXTENT))
3306 return -EOPNOTSUPP;
3307
3308 map.m_lblk = 0;
3309 map.m_next_pgofs = NULL;
3310 map.m_next_extent = &m_next_extent;
3311 map.m_seg_type = NO_CHECK_TYPE;
3312 map.m_may_create = false;
2734 return -EINVAL;
2735
2736 err = mnt_want_write_file(filp);
2737 if (err)
2738 return err;
2739
2740 err = f2fs_defragment_range(sbi, filp, &range);
2741 mnt_drop_write_file(filp);

--- 546 unchanged lines hidden (view full) ---

3288 if (is_inode_flag_set(inode, FI_NO_EXTENT))
3289 return -EOPNOTSUPP;
3290
3291 map.m_lblk = 0;
3292 map.m_next_pgofs = NULL;
3293 map.m_next_extent = &m_next_extent;
3294 map.m_seg_type = NO_CHECK_TYPE;
3295 map.m_may_create = false;
3313 end = max_file_blocks(inode);
3296 end = F2FS_I_SB(inode)->max_file_blocks;
3314
3315 while (map.m_lblk < end) {
3316 map.m_len = end - map.m_lblk;
3317
3318 down_write(&fi->i_gc_rwsem[WRITE]);
3319 err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_PRECACHE);
3320 up_write(&fi->i_gc_rwsem[WRITE]);
3321 if (err)

--- 47 unchanged lines hidden (view full) ---

3369static int f2fs_ioc_measure_verity(struct file *filp, unsigned long arg)
3370{
3371 if (!f2fs_sb_has_verity(F2FS_I_SB(file_inode(filp))))
3372 return -EOPNOTSUPP;
3373
3374 return fsverity_ioctl_measure(filp, (void __user *)arg);
3375}
3376
3297
3298 while (map.m_lblk < end) {
3299 map.m_len = end - map.m_lblk;
3300
3301 down_write(&fi->i_gc_rwsem[WRITE]);
3302 err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_PRECACHE);
3303 up_write(&fi->i_gc_rwsem[WRITE]);
3304 if (err)

--- 47 unchanged lines hidden (view full) ---

3352static int f2fs_ioc_measure_verity(struct file *filp, unsigned long arg)
3353{
3354 if (!f2fs_sb_has_verity(F2FS_I_SB(file_inode(filp))))
3355 return -EOPNOTSUPP;
3356
3357 return fsverity_ioctl_measure(filp, (void __user *)arg);
3358}
3359
3360static int f2fs_ioc_read_verity_metadata(struct file *filp, unsigned long arg)
3361{
3362 if (!f2fs_sb_has_verity(F2FS_I_SB(file_inode(filp))))
3363 return -EOPNOTSUPP;
3364
3365 return fsverity_ioctl_read_metadata(filp, (const void __user *)arg);
3366}
3367
3377static int f2fs_ioc_getfslabel(struct file *filp, unsigned long arg)
3378{
3379 struct inode *inode = file_inode(filp);
3380 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3381 char *vbuf;
3382 int count;
3383 int err = 0;
3384

--- 670 unchanged lines hidden (view full) ---

4055 ret = PTR_ERR(page);
4056 break;
4057 }
4058 page_len++;
4059 }
4060
4061 for (i = 0; i < page_len; i++, redirty_idx++) {
4062 page = find_lock_page(mapping, redirty_idx);
3368static int f2fs_ioc_getfslabel(struct file *filp, unsigned long arg)
3369{
3370 struct inode *inode = file_inode(filp);
3371 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3372 char *vbuf;
3373 int count;
3374 int err = 0;
3375

--- 670 unchanged lines hidden (view full) ---

4046 ret = PTR_ERR(page);
4047 break;
4048 }
4049 page_len++;
4050 }
4051
4052 for (i = 0; i < page_len; i++, redirty_idx++) {
4053 page = find_lock_page(mapping, redirty_idx);
4063 if (!page) {
4064 ret = -ENOMEM;
4065 break;
4066 }
4054 if (!page)
4055 ret = -ENOENT;
4067 set_page_dirty(page);
4068 f2fs_put_page(page, 1);
4069 f2fs_put_page(page, 0);
4070 }
4071
4072 return ret;
4073}
4074

--- 211 unchanged lines hidden (view full) ---

4286 case F2FS_IOC_PRECACHE_EXTENTS:
4287 return f2fs_ioc_precache_extents(filp, arg);
4288 case F2FS_IOC_RESIZE_FS:
4289 return f2fs_ioc_resize_fs(filp, arg);
4290 case FS_IOC_ENABLE_VERITY:
4291 return f2fs_ioc_enable_verity(filp, arg);
4292 case FS_IOC_MEASURE_VERITY:
4293 return f2fs_ioc_measure_verity(filp, arg);
4056 set_page_dirty(page);
4057 f2fs_put_page(page, 1);
4058 f2fs_put_page(page, 0);
4059 }
4060
4061 return ret;
4062}
4063

--- 211 unchanged lines hidden (view full) ---

4275 case F2FS_IOC_PRECACHE_EXTENTS:
4276 return f2fs_ioc_precache_extents(filp, arg);
4277 case F2FS_IOC_RESIZE_FS:
4278 return f2fs_ioc_resize_fs(filp, arg);
4279 case FS_IOC_ENABLE_VERITY:
4280 return f2fs_ioc_enable_verity(filp, arg);
4281 case FS_IOC_MEASURE_VERITY:
4282 return f2fs_ioc_measure_verity(filp, arg);
4283 case FS_IOC_READ_VERITY_METADATA:
4284 return f2fs_ioc_read_verity_metadata(filp, arg);
4294 case FS_IOC_GETFSLABEL:
4295 return f2fs_ioc_getfslabel(filp, arg);
4296 case FS_IOC_SETFSLABEL:
4297 return f2fs_ioc_setfslabel(filp, arg);
4298 case F2FS_IOC_GET_COMPRESS_BLOCKS:
4299 return f2fs_get_compress_blocks(filp, arg);
4300 case F2FS_IOC_RELEASE_COMPRESS_BLOCKS:
4301 return f2fs_release_compress_blocks(filp, arg);

--- 61 unchanged lines hidden (view full) ---

4363 if (!inode_trylock(inode)) {
4364 ret = -EAGAIN;
4365 goto out;
4366 }
4367 } else {
4368 inode_lock(inode);
4369 }
4370
4285 case FS_IOC_GETFSLABEL:
4286 return f2fs_ioc_getfslabel(filp, arg);
4287 case FS_IOC_SETFSLABEL:
4288 return f2fs_ioc_setfslabel(filp, arg);
4289 case F2FS_IOC_GET_COMPRESS_BLOCKS:
4290 return f2fs_get_compress_blocks(filp, arg);
4291 case F2FS_IOC_RELEASE_COMPRESS_BLOCKS:
4292 return f2fs_release_compress_blocks(filp, arg);

--- 61 unchanged lines hidden (view full) ---

4354 if (!inode_trylock(inode)) {
4355 ret = -EAGAIN;
4356 goto out;
4357 }
4358 } else {
4359 inode_lock(inode);
4360 }
4361
4371 if (unlikely(IS_IMMUTABLE(inode))) {
4372 ret = -EPERM;
4373 goto unlock;
4374 }
4375
4376 ret = generic_write_checks(iocb, from);
4377 if (ret > 0) {
4378 bool preallocated = false;
4379 size_t target_size = 0;
4380 int err;
4381
4382 if (iov_iter_fault_in_readable(from, iov_iter_count(from)))
4383 set_inode_flag(inode, FI_NO_PREALLOC);

--- 48 unchanged lines hidden (view full) ---

4432
4433 /* if we couldn't write data, we should deallocate blocks. */
4434 if (preallocated && i_size_read(inode) < target_size)
4435 f2fs_truncate(inode);
4436
4437 if (ret > 0)
4438 f2fs_update_iostat(F2FS_I_SB(inode), APP_WRITE_IO, ret);
4439 }
4362 ret = generic_write_checks(iocb, from);
4363 if (ret > 0) {
4364 bool preallocated = false;
4365 size_t target_size = 0;
4366 int err;
4367
4368 if (iov_iter_fault_in_readable(from, iov_iter_count(from)))
4369 set_inode_flag(inode, FI_NO_PREALLOC);

--- 48 unchanged lines hidden (view full) ---

4418
4419 /* if we couldn't write data, we should deallocate blocks. */
4420 if (preallocated && i_size_read(inode) < target_size)
4421 f2fs_truncate(inode);
4422
4423 if (ret > 0)
4424 f2fs_update_iostat(F2FS_I_SB(inode), APP_WRITE_IO, ret);
4425 }
4440unlock:
4441 inode_unlock(inode);
4442out:
4443 trace_f2fs_file_write_iter(inode, iocb->ki_pos,
4444 iov_iter_count(from), ret);
4445 if (ret > 0)
4446 ret = generic_write_sync(iocb, ret);
4447 return ret;
4448}

--- 94 unchanged lines hidden (view full) ---

4543 case FS_IOC_FSGETXATTR:
4544 case FS_IOC_FSSETXATTR:
4545 case F2FS_IOC_GET_PIN_FILE:
4546 case F2FS_IOC_SET_PIN_FILE:
4547 case F2FS_IOC_PRECACHE_EXTENTS:
4548 case F2FS_IOC_RESIZE_FS:
4549 case FS_IOC_ENABLE_VERITY:
4550 case FS_IOC_MEASURE_VERITY:
4426 inode_unlock(inode);
4427out:
4428 trace_f2fs_file_write_iter(inode, iocb->ki_pos,
4429 iov_iter_count(from), ret);
4430 if (ret > 0)
4431 ret = generic_write_sync(iocb, ret);
4432 return ret;
4433}

--- 94 unchanged lines hidden (view full) ---

4528 case FS_IOC_FSGETXATTR:
4529 case FS_IOC_FSSETXATTR:
4530 case F2FS_IOC_GET_PIN_FILE:
4531 case F2FS_IOC_SET_PIN_FILE:
4532 case F2FS_IOC_PRECACHE_EXTENTS:
4533 case F2FS_IOC_RESIZE_FS:
4534 case FS_IOC_ENABLE_VERITY:
4535 case FS_IOC_MEASURE_VERITY:
4536 case FS_IOC_READ_VERITY_METADATA:
4551 case FS_IOC_GETFSLABEL:
4552 case FS_IOC_SETFSLABEL:
4553 case F2FS_IOC_GET_COMPRESS_BLOCKS:
4554 case F2FS_IOC_RELEASE_COMPRESS_BLOCKS:
4555 case F2FS_IOC_RESERVE_COMPRESS_BLOCKS:
4556 case F2FS_IOC_SEC_TRIM_FILE:
4557 case F2FS_IOC_GET_COMPRESS_OPTION:
4558 case F2FS_IOC_SET_COMPRESS_OPTION:

--- 27 unchanged lines hidden --- 		4537 case FS_IOC_GETFSLABEL:
4538 case FS_IOC_SETFSLABEL:
4539 case F2FS_IOC_GET_COMPRESS_BLOCKS:
4540 case F2FS_IOC_RELEASE_COMPRESS_BLOCKS:
4541 case F2FS_IOC_RESERVE_COMPRESS_BLOCKS:
4542 case F2FS_IOC_SEC_TRIM_FILE:
4543 case F2FS_IOC_GET_COMPRESS_OPTION:
4544 case F2FS_IOC_SET_COMPRESS_OPTION:

--- 27 unchanged lines hidden ---