file.c (84c9c2de0626567c0d964ee5fa1ae3310911ddf8) file.c (ef8d563f184e1112651f2cbde383d43e599334e8)
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>

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

558 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
559 struct f2fs_node *raw_node;
560 int nr_free = 0, ofs = dn->ofs_in_node, len = count;
561 __le32 *addr;
562 int base = 0;
563 bool compressed_cluster = false;
564 int cluster_index = 0, valid_blocks = 0;
565 int cluster_size = F2FS_I(dn->inode)->i_cluster_size;
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>

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

558 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
559 struct f2fs_node *raw_node;
560 int nr_free = 0, ofs = dn->ofs_in_node, len = count;
561 __le32 *addr;
562 int base = 0;
563 bool compressed_cluster = false;
564 int cluster_index = 0, valid_blocks = 0;
565 int cluster_size = F2FS_I(dn->inode)->i_cluster_size;
566 bool released = !F2FS_I(dn->inode)->i_compr_blocks;
566
567 if (IS_INODE(dn->node_page) && f2fs_has_extra_attr(dn->inode))
568 base = get_extra_isize(dn->inode);
569
570 raw_node = F2FS_NODE(dn->node_page);
571 addr = blkaddr_in_node(raw_node) + base + ofs;
572
573 /* Assumption: truncateion starts with cluster */

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

596 if (compressed_cluster)
597 valid_blocks++;
598 }
599
600 if (dn->ofs_in_node == 0 && IS_INODE(dn->node_page))
601 clear_inode_flag(dn->inode, FI_FIRST_BLOCK_WRITTEN);
602
603 f2fs_invalidate_blocks(sbi, blkaddr);
567
568 if (IS_INODE(dn->node_page) && f2fs_has_extra_attr(dn->inode))
569 base = get_extra_isize(dn->inode);
570
571 raw_node = F2FS_NODE(dn->node_page);
572 addr = blkaddr_in_node(raw_node) + base + ofs;
573
574 /* Assumption: truncateion starts with cluster */

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

597 if (compressed_cluster)
598 valid_blocks++;
599 }
600
601 if (dn->ofs_in_node == 0 && IS_INODE(dn->node_page))
602 clear_inode_flag(dn->inode, FI_FIRST_BLOCK_WRITTEN);
603
604 f2fs_invalidate_blocks(sbi, blkaddr);
604 nr_free++;
605
606 if (!released || blkaddr != COMPRESS_ADDR)
607 nr_free++;
605 }
606
607 if (compressed_cluster)
608 f2fs_i_compr_blocks_update(dn->inode, valid_blocks, false);
609
610 if (nr_free) {
611 pgoff_t fofs;
612 /*

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

3429
3430 if (!f2fs_compressed_file(inode))
3431 return -EINVAL;
3432
3433 blocks = F2FS_I(inode)->i_compr_blocks;
3434 return put_user(blocks, (u64 __user *)arg);
3435}
3436
608 }
609
610 if (compressed_cluster)
611 f2fs_i_compr_blocks_update(dn->inode, valid_blocks, false);
612
613 if (nr_free) {
614 pgoff_t fofs;
615 /*

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

3432
3433 if (!f2fs_compressed_file(inode))
3434 return -EINVAL;
3435
3436 blocks = F2FS_I(inode)->i_compr_blocks;
3437 return put_user(blocks, (u64 __user *)arg);
3438}
3439
3440static int release_compress_blocks(struct dnode_of_data *dn, pgoff_t count)
3441{
3442 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
3443 unsigned int released_blocks = 0;
3444 int cluster_size = F2FS_I(dn->inode)->i_cluster_size;
3445 block_t blkaddr;
3446 int i;
3447
3448 for (i = 0; i < count; i++) {
3449 blkaddr = data_blkaddr(dn->inode, dn->node_page,
3450 dn->ofs_in_node + i);
3451
3452 if (!__is_valid_data_blkaddr(blkaddr))
3453 continue;
3454 if (unlikely(!f2fs_is_valid_blkaddr(sbi, blkaddr,
3455 DATA_GENERIC_ENHANCE)))
3456 return -EFSCORRUPTED;
3457 }
3458
3459 while (count) {
3460 int compr_blocks = 0;
3461
3462 for (i = 0; i < cluster_size; i++, dn->ofs_in_node++) {
3463 blkaddr = f2fs_data_blkaddr(dn);
3464
3465 if (i == 0) {
3466 if (blkaddr == COMPRESS_ADDR)
3467 continue;
3468 dn->ofs_in_node += cluster_size;
3469 goto next;
3470 }
3471
3472 if (__is_valid_data_blkaddr(blkaddr))
3473 compr_blocks++;
3474
3475 if (blkaddr != NEW_ADDR)
3476 continue;
3477
3478 dn->data_blkaddr = NULL_ADDR;
3479 f2fs_set_data_blkaddr(dn);
3480 }
3481
3482 f2fs_i_compr_blocks_update(dn->inode, compr_blocks, false);
3483 dec_valid_block_count(sbi, dn->inode,
3484 cluster_size - compr_blocks);
3485
3486 released_blocks += cluster_size - compr_blocks;
3487next:
3488 count -= cluster_size;
3489 }
3490
3491 return released_blocks;
3492}
3493
3494static int f2fs_release_compress_blocks(struct file *filp, unsigned long arg)
3495{
3496 struct inode *inode = file_inode(filp);
3497 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3498 pgoff_t page_idx = 0, last_idx;
3499 unsigned int released_blocks = 0;
3500 int ret;
3501 int writecount;
3502
3503 if (!f2fs_sb_has_compression(F2FS_I_SB(inode)))
3504 return -EOPNOTSUPP;
3505
3506 if (!f2fs_compressed_file(inode))
3507 return -EINVAL;
3508
3509 if (f2fs_readonly(sbi->sb))
3510 return -EROFS;
3511
3512 ret = mnt_want_write_file(filp);
3513 if (ret)
3514 return ret;
3515
3516 f2fs_balance_fs(F2FS_I_SB(inode), true);
3517
3518 inode_lock(inode);
3519
3520 writecount = atomic_read(&inode->i_writecount);
3521 if ((filp->f_mode & FMODE_WRITE && writecount != 1) || writecount) {
3522 ret = -EBUSY;
3523 goto out;
3524 }
3525
3526 if (IS_IMMUTABLE(inode)) {
3527 ret = -EINVAL;
3528 goto out;
3529 }
3530
3531 ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
3532 if (ret)
3533 goto out;
3534
3535 if (!F2FS_I(inode)->i_compr_blocks)
3536 goto out;
3537
3538 F2FS_I(inode)->i_flags |= F2FS_IMMUTABLE_FL;
3539 f2fs_set_inode_flags(inode);
3540 inode->i_ctime = current_time(inode);
3541 f2fs_mark_inode_dirty_sync(inode, true);
3542
3543 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3544 down_write(&F2FS_I(inode)->i_mmap_sem);
3545
3546 last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
3547
3548 while (page_idx < last_idx) {
3549 struct dnode_of_data dn;
3550 pgoff_t end_offset, count;
3551
3552 set_new_dnode(&dn, inode, NULL, NULL, 0);
3553 ret = f2fs_get_dnode_of_data(&dn, page_idx, LOOKUP_NODE);
3554 if (ret) {
3555 if (ret == -ENOENT) {
3556 page_idx = f2fs_get_next_page_offset(&dn,
3557 page_idx);
3558 ret = 0;
3559 continue;
3560 }
3561 break;
3562 }
3563
3564 end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
3565 count = min(end_offset - dn.ofs_in_node, last_idx - page_idx);
3566 count = roundup(count, F2FS_I(inode)->i_cluster_size);
3567
3568 ret = release_compress_blocks(&dn, count);
3569
3570 f2fs_put_dnode(&dn);
3571
3572 if (ret < 0)
3573 break;
3574
3575 page_idx += count;
3576 released_blocks += ret;
3577 }
3578
3579 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3580 up_write(&F2FS_I(inode)->i_mmap_sem);
3581out:
3582 inode_unlock(inode);
3583
3584 mnt_drop_write_file(filp);
3585
3586 if (ret >= 0) {
3587 ret = put_user(released_blocks, (u64 __user *)arg);
3588 } else if (released_blocks && F2FS_I(inode)->i_compr_blocks) {
3589 set_sbi_flag(sbi, SBI_NEED_FSCK);
3590 f2fs_warn(sbi, "%s: partial blocks were released i_ino=%lx "
3591 "iblocks=%llu, released=%u, compr_blocks=%llu, "
3592 "run fsck to fix.",
3593 __func__, inode->i_ino, inode->i_blocks,
3594 released_blocks,
3595 F2FS_I(inode)->i_compr_blocks);
3596 }
3597
3598 return ret;
3599}
3600
3437long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
3438{
3439 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp)))))
3440 return -EIO;
3441 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(file_inode(filp))))
3442 return -ENOSPC;
3443
3444 switch (cmd) {

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

3511 case FS_IOC_MEASURE_VERITY:
3512 return f2fs_ioc_measure_verity(filp, arg);
3513 case F2FS_IOC_GET_VOLUME_NAME:
3514 return f2fs_get_volume_name(filp, arg);
3515 case F2FS_IOC_SET_VOLUME_NAME:
3516 return f2fs_set_volume_name(filp, arg);
3517 case F2FS_IOC_GET_COMPRESS_BLOCKS:
3518 return f2fs_get_compress_blocks(filp, arg);
3601long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
3602{
3603 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp)))))
3604 return -EIO;
3605 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(file_inode(filp))))
3606 return -ENOSPC;
3607
3608 switch (cmd) {

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

3675 case FS_IOC_MEASURE_VERITY:
3676 return f2fs_ioc_measure_verity(filp, arg);
3677 case F2FS_IOC_GET_VOLUME_NAME:
3678 return f2fs_get_volume_name(filp, arg);
3679 case F2FS_IOC_SET_VOLUME_NAME:
3680 return f2fs_set_volume_name(filp, arg);
3681 case F2FS_IOC_GET_COMPRESS_BLOCKS:
3682 return f2fs_get_compress_blocks(filp, arg);
3683 case F2FS_IOC_RELEASE_COMPRESS_BLOCKS:
3684 return f2fs_release_compress_blocks(filp, arg);
3519 default:
3520 return -ENOTTY;
3521 }
3522}
3523
3524static ssize_t f2fs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
3525{
3526 struct file *file = iocb->ki_filp;

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

3678 case F2FS_IOC_SET_PIN_FILE:
3679 case F2FS_IOC_PRECACHE_EXTENTS:
3680 case F2FS_IOC_RESIZE_FS:
3681 case FS_IOC_ENABLE_VERITY:
3682 case FS_IOC_MEASURE_VERITY:
3683 case F2FS_IOC_GET_VOLUME_NAME:
3684 case F2FS_IOC_SET_VOLUME_NAME:
3685 case F2FS_IOC_GET_COMPRESS_BLOCKS:
3685 default:
3686 return -ENOTTY;
3687 }
3688}
3689
3690static ssize_t f2fs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
3691{
3692 struct file *file = iocb->ki_filp;

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

3844 case F2FS_IOC_SET_PIN_FILE:
3845 case F2FS_IOC_PRECACHE_EXTENTS:
3846 case F2FS_IOC_RESIZE_FS:
3847 case FS_IOC_ENABLE_VERITY:
3848 case FS_IOC_MEASURE_VERITY:
3849 case F2FS_IOC_GET_VOLUME_NAME:
3850 case F2FS_IOC_SET_VOLUME_NAME:
3851 case F2FS_IOC_GET_COMPRESS_BLOCKS:
3852 case F2FS_IOC_RELEASE_COMPRESS_BLOCKS:
3686 break;
3687 default:
3688 return -ENOIOCTLCMD;
3689 }
3690 return f2fs_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
3691}
3692#endif
3693

--- 17 unchanged lines hidden --- 		3853 break;
3854 default:
3855 return -ENOIOCTLCMD;
3856 }
3857 return f2fs_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
3858}
3859#endif
3860

--- 17 unchanged lines hidden ---