Lines Matching +full:buffered +full:- +full:positive
1 // SPDX-License-Identifier: GPL-2.0
46 if (mapping_empty(inode->i_mapping)) in f2fs_zero_post_eof_page()
50 filemap_invalidate_lock(inode->i_mapping); in f2fs_zero_post_eof_page()
52 truncate_inode_pages_range(inode->i_mapping, old_size, new_size); in f2fs_zero_post_eof_page()
54 filemap_invalidate_unlock(inode->i_mapping); in f2fs_zero_post_eof_page()
59 struct inode *inode = file_inode(vmf->vma->vm_file); in f2fs_filemap_fault()
60 vm_flags_t flags = vmf->vma->vm_flags; in f2fs_filemap_fault()
68 trace_f2fs_filemap_fault(inode, vmf->pgoff, flags, ret); in f2fs_filemap_fault()
75 struct folio *folio = page_folio(vmf->page); in f2fs_vm_page_mkwrite()
76 struct inode *inode = file_inode(vmf->vma->vm_file); in f2fs_vm_page_mkwrite()
87 err = -EIO; in f2fs_vm_page_mkwrite()
92 err = -EIO; in f2fs_vm_page_mkwrite()
97 err = -ENOSPC; in f2fs_vm_page_mkwrite()
107 int ret = f2fs_is_compressed_cluster(inode, folio->index); in f2fs_vm_page_mkwrite()
121 sb_start_pagefault(inode->i_sb); in f2fs_vm_page_mkwrite()
125 f2fs_zero_post_eof_page(inode, (folio->index + 1) << PAGE_SHIFT, true); in f2fs_vm_page_mkwrite()
127 file_update_time(vmf->vma->vm_file); in f2fs_vm_page_mkwrite()
128 filemap_invalidate_lock_shared(inode->i_mapping); in f2fs_vm_page_mkwrite()
131 if (unlikely(folio->mapping != inode->i_mapping || in f2fs_vm_page_mkwrite()
135 err = -EFAULT; in f2fs_vm_page_mkwrite()
142 err = f2fs_get_block_locked(&dn, folio->index); in f2fs_vm_page_mkwrite()
144 err = f2fs_get_dnode_of_data(&dn, folio->index, LOOKUP_NODE); in f2fs_vm_page_mkwrite()
148 err = -EIO; in f2fs_vm_page_mkwrite()
168 if (((loff_t)(folio->index + 1) << PAGE_SHIFT) > in f2fs_vm_page_mkwrite()
181 filemap_invalidate_unlock_shared(inode->i_mapping); in f2fs_vm_page_mkwrite()
183 sb_end_pagefault(inode->i_sb); in f2fs_vm_page_mkwrite()
187 trace_f2fs_vm_page_mkwrite(inode, folio->index, vmf->vma->vm_flags, ret); in f2fs_vm_page_mkwrite()
202 * Make sure to get the non-deleted alias. The alias associated with in get_parent_ino()
219 if (!S_ISREG(inode->i_mode)) in need_do_checkpoint()
223 else if (inode->i_nlink != 1) in need_do_checkpoint()
231 else if (!f2fs_is_checkpointed_node(sbi, F2FS_I(inode)->i_pino)) in need_do_checkpoint()
238 f2fs_need_dentry_mark(sbi, inode->i_ino) && in need_do_checkpoint()
239 f2fs_exist_written_data(sbi, F2FS_I(inode)->i_pino, in need_do_checkpoint()
242 else if (f2fs_exist_written_data(sbi, F2FS_I(inode)->i_pino, in need_do_checkpoint()
266 f2fs_down_write(&fi->i_sem); in try_to_fix_pino()
267 if (file_wrong_pino(inode) && inode->i_nlink == 1 && in try_to_fix_pino()
272 f2fs_up_write(&fi->i_sem); in try_to_fix_pino()
278 struct inode *inode = file->f_mapping->host; in f2fs_do_sync_file()
280 nid_t ino = inode->i_ino; in f2fs_do_sync_file()
289 if (unlikely(f2fs_readonly(inode->i_sb))) in f2fs_do_sync_file()
294 if (S_ISDIR(inode->i_mode)) in f2fs_do_sync_file()
297 /* if fdatasync is triggered, let's do in-place-update */ in f2fs_do_sync_file()
298 if (datasync || get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks) in f2fs_do_sync_file()
344 * sudden-power-off. in f2fs_do_sync_file()
346 f2fs_down_read(&F2FS_I(inode)->i_sem); in f2fs_do_sync_file()
348 f2fs_up_read(&F2FS_I(inode)->i_sem); in f2fs_do_sync_file()
352 ret = f2fs_sync_fs(inode->i_sb, 1); in f2fs_do_sync_file()
364 atomic_inc(&sbi->wb_sync_req[NODE]); in f2fs_do_sync_file()
366 atomic_dec(&sbi->wb_sync_req[NODE]); in f2fs_do_sync_file()
372 ret = -EIO; in f2fs_do_sync_file()
387 * roll-forward recovery. It means we'll recover all or none node blocks in f2fs_do_sync_file()
401 ret = f2fs_issue_flush(sbi, inode->i_ino); in f2fs_do_sync_file()
416 return -EIO; in f2fs_sync_file()
424 struct inode *inode = mapping->host; in __found_offset()
428 block_t first_blkaddr = data_blkaddr(dn->inode, dn->node_folio, in __found_offset()
429 ALIGN_DOWN(dn->ofs_in_node, F2FS_I(inode)->i_cluster_size)); in __found_offset()
439 xa_get_mark(&mapping->i_pages, index, PAGECACHE_TAG_DIRTY)) in __found_offset()
456 struct inode *inode = file->f_mapping->host; in f2fs_seek_block()
486 if (err && err != -ENOENT) { in f2fs_seek_block()
488 } else if (err == -ENOENT) { in f2fs_seek_block()
515 if (__found_offset(file->f_mapping, &dn, in f2fs_seek_block()
533 return -ENXIO; in f2fs_seek_block()
538 struct inode *inode = file->f_mapping->host; in f2fs_llseek()
550 return -ENXIO; in f2fs_llseek()
554 return -EINVAL; in f2fs_llseek()
559 struct file *file = desc->file; in f2fs_file_mmap_prepare()
563 return -EIO; in f2fs_file_mmap_prepare()
566 return -EOPNOTSUPP; in f2fs_file_mmap_prepare()
569 desc->vm_ops = &f2fs_file_vm_ops; in f2fs_file_mmap_prepare()
571 f2fs_down_read(&F2FS_I(inode)->i_sem); in f2fs_file_mmap_prepare()
573 f2fs_up_read(&F2FS_I(inode)->i_sem); in f2fs_file_mmap_prepare()
583 f2fs_down_read(&F2FS_I(inode)->i_sem); in finish_preallocate_blocks()
585 f2fs_up_read(&F2FS_I(inode)->i_sem); in finish_preallocate_blocks()
596 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in finish_preallocate_blocks()
597 filemap_invalidate_lock(inode->i_mapping); in finish_preallocate_blocks()
602 filemap_invalidate_unlock(inode->i_mapping); in finish_preallocate_blocks()
603 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in finish_preallocate_blocks()
609 f2fs_down_write(&F2FS_I(inode)->i_sem); in finish_preallocate_blocks()
611 f2fs_up_write(&F2FS_I(inode)->i_sem); in finish_preallocate_blocks()
625 return -EOPNOTSUPP; in f2fs_file_open()
631 filp->f_mode |= FMODE_NOWAIT; in f2fs_file_open()
632 filp->f_mode |= FMODE_CAN_ODIRECT; in f2fs_file_open()
640 atomic_inc(&F2FS_I(inode)->open_count); in f2fs_file_open()
646 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode); in f2fs_truncate_data_blocks_range()
647 int nr_free = 0, ofs = dn->ofs_in_node, len = count; in f2fs_truncate_data_blocks_range()
651 int cluster_size = F2FS_I(dn->inode)->i_cluster_size; in f2fs_truncate_data_blocks_range()
652 bool released = !atomic_read(&F2FS_I(dn->inode)->i_compr_blocks); in f2fs_truncate_data_blocks_range()
656 addr = get_dnode_addr(dn->inode, dn->node_folio) + ofs; in f2fs_truncate_data_blocks_range()
660 for (; count > 0; count--, addr++, dn->ofs_in_node++, cluster_index++) { in f2fs_truncate_data_blocks_range()
663 if (f2fs_compressed_file(dn->inode) && in f2fs_truncate_data_blocks_range()
664 !(cluster_index & (cluster_size - 1))) { in f2fs_truncate_data_blocks_range()
666 f2fs_i_compr_blocks_update(dn->inode, in f2fs_truncate_data_blocks_range()
712 f2fs_i_compr_blocks_update(dn->inode, valid_blocks, false); in f2fs_truncate_data_blocks_range()
720 fofs = f2fs_start_bidx_of_node(ofs_of_node(dn->node_folio), in f2fs_truncate_data_blocks_range()
721 dn->inode) + ofs; in f2fs_truncate_data_blocks_range()
724 dec_valid_block_count(sbi, dn->inode, nr_free); in f2fs_truncate_data_blocks_range()
726 dn->ofs_in_node = ofs; in f2fs_truncate_data_blocks_range()
729 trace_f2fs_truncate_data_blocks_range(dn->inode, dn->nid, in f2fs_truncate_data_blocks_range()
730 dn->ofs_in_node, nr_free); in f2fs_truncate_data_blocks_range()
736 loff_t offset = from & (PAGE_SIZE - 1); in truncate_partial_data_page()
738 struct address_space *mapping = inode->i_mapping; in truncate_partial_data_page()
756 return PTR_ERR(folio) == -ENOENT ? 0 : PTR_ERR(folio); in truncate_partial_data_page()
781 err = -EINVAL; in f2fs_do_truncate_blocks()
793 ifolio = f2fs_get_inode_folio(sbi, inode->i_ino); in f2fs_do_truncate_blocks()
800 struct extent_tree *et = F2FS_I(inode)->extent_tree[EX_READ]; in f2fs_do_truncate_blocks()
801 struct extent_info ei = et->largest; in f2fs_do_truncate_blocks()
822 if (err == -ENOENT) in f2fs_do_truncate_blocks()
829 count -= dn.ofs_in_node; in f2fs_do_truncate_blocks()
864 F2FS_I(inode)->i_cluster_size << PAGE_SHIFT); in f2fs_truncate_blocks()
895 return -EIO; in f2fs_truncate()
897 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || in f2fs_truncate()
898 S_ISLNK(inode->i_mode))) in f2fs_truncate()
904 return -EIO; in f2fs_truncate()
918 truncate_inode_pages_range(inode->i_mapping, in f2fs_truncate()
945 * only force direct read to use buffered IO, for direct write, in f2fs_force_buffered_io()
952 if (f2fs_is_multi_device(sbi) && !sbi->aligned_blksize) in f2fs_force_buffered_io()
955 * for blkzoned device, fallback direct IO to buffered IO, so in f2fs_force_buffered_io()
956 * all IOs can be serialized by log-structured write. in f2fs_force_buffered_io()
970 struct inode *inode = d_inode(path->dentry); in f2fs_getattr()
977 F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_crtime)) { in f2fs_getattr()
978 stat->result_mask |= STATX_BTIME; in f2fs_getattr()
979 stat->btime.tv_sec = fi->i_crtime.tv_sec; in f2fs_getattr()
980 stat->btime.tv_nsec = fi->i_crtime.tv_nsec; in f2fs_getattr()
991 if ((request_mask & STATX_DIOALIGN) && S_ISREG(inode->i_mode)) { in f2fs_getattr()
994 stat->result_mask |= STATX_DIOALIGN; in f2fs_getattr()
996 stat->dio_mem_align = bsize; in f2fs_getattr()
997 stat->dio_offset_align = bsize; in f2fs_getattr()
1001 flags = fi->i_flags; in f2fs_getattr()
1003 stat->attributes |= STATX_ATTR_COMPRESSED; in f2fs_getattr()
1005 stat->attributes |= STATX_ATTR_APPEND; in f2fs_getattr()
1007 stat->attributes |= STATX_ATTR_ENCRYPTED; in f2fs_getattr()
1009 stat->attributes |= STATX_ATTR_IMMUTABLE; in f2fs_getattr()
1011 stat->attributes |= STATX_ATTR_NODUMP; in f2fs_getattr()
1013 stat->attributes |= STATX_ATTR_VERITY; in f2fs_getattr()
1015 stat->attributes_mask |= (STATX_ATTR_COMPRESSED | in f2fs_getattr()
1025 if ((S_ISREG(inode->i_mode) && f2fs_has_inline_data(inode)) || in f2fs_getattr()
1027 stat->blocks += (stat->size + 511) >> 9; in f2fs_getattr()
1036 unsigned int ia_valid = attr->ia_valid; in __setattr_copy()
1041 inode_set_atime_to_ts(inode, attr->ia_atime); in __setattr_copy()
1043 inode_set_mtime_to_ts(inode, attr->ia_mtime); in __setattr_copy()
1045 inode_set_ctime_to_ts(inode, attr->ia_ctime); in __setattr_copy()
1047 umode_t mode = attr->ia_mode; in __setattr_copy()
1067 return -EIO; in f2fs_setattr()
1082 return -EPERM; in f2fs_setattr()
1085 (attr->ia_valid & (ATTR_MODE | ATTR_UID | in f2fs_setattr()
1087 return -EPERM; in f2fs_setattr()
1089 if ((attr->ia_valid & ATTR_SIZE)) { in f2fs_setattr()
1092 return -EOPNOTSUPP; in f2fs_setattr()
1094 !IS_ALIGNED(attr->ia_size, in f2fs_setattr()
1095 F2FS_BLK_TO_BYTES(fi->i_cluster_size))) in f2fs_setattr()
1096 return -EINVAL; in f2fs_setattr()
1104 attr->ia_size <= i_size_read(inode) && in f2fs_setattr()
1105 !IS_ALIGNED(attr->ia_size, in f2fs_setattr()
1107 return -EINVAL; in f2fs_setattr()
1134 if (attr->ia_valid & ATTR_SIZE) { in f2fs_setattr()
1137 if (attr->ia_size > MAX_INLINE_DATA(inode)) { in f2fs_setattr()
1151 if (attr->ia_size < old_size) in f2fs_setattr()
1154 f2fs_down_write(&fi->i_gc_rwsem[WRITE]); in f2fs_setattr()
1155 filemap_invalidate_lock(inode->i_mapping); in f2fs_setattr()
1157 if (attr->ia_size > old_size) in f2fs_setattr()
1158 f2fs_zero_post_eof_page(inode, attr->ia_size, false); in f2fs_setattr()
1159 truncate_setsize(inode, attr->ia_size); in f2fs_setattr()
1161 if (attr->ia_size <= old_size) in f2fs_setattr()
1167 filemap_invalidate_unlock(inode->i_mapping); in f2fs_setattr()
1168 f2fs_up_write(&fi->i_gc_rwsem[WRITE]); in f2fs_setattr()
1172 spin_lock(&fi->i_size_lock); in f2fs_setattr()
1174 fi->last_disk_size = i_size_read(inode); in f2fs_setattr()
1175 spin_unlock(&fi->i_size_lock); in f2fs_setattr()
1180 if (attr->ia_valid & ATTR_MODE) { in f2fs_setattr()
1185 inode->i_mode = fi->i_acl_mode; in f2fs_setattr()
1246 if (err == -ENOENT) { in f2fs_truncate_hole()
1255 count = min(end_offset - dn.ofs_in_node, pg_end - pg_start); in f2fs_truncate_hole()
1282 off_start = offset & (PAGE_SIZE - 1); in f2fs_punch_hole()
1283 off_end = (offset + len) & (PAGE_SIZE - 1); in f2fs_punch_hole()
1287 off_end - off_start); in f2fs_punch_hole()
1293 PAGE_SIZE - off_start); in f2fs_punch_hole()
1312 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_punch_hole()
1313 filemap_invalidate_lock(inode->i_mapping); in f2fs_punch_hole()
1315 truncate_pagecache_range(inode, blk_start, blk_end - 1); in f2fs_punch_hole()
1321 filemap_invalidate_unlock(inode->i_mapping); in f2fs_punch_hole()
1322 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_punch_hole()
1339 if (ret && ret != -ENOENT) { in __read_out_blkaddrs()
1341 } else if (ret == -ENOENT) { in __read_out_blkaddrs()
1343 return -ENOENT; in __read_out_blkaddrs()
1344 done = min((pgoff_t)ADDRS_PER_BLOCK(inode) - in __read_out_blkaddrs()
1351 done = min((pgoff_t)ADDRS_PER_PAGE(dn.node_folio, inode) - in __read_out_blkaddrs()
1360 return -EFSCORRUPTED; in __read_out_blkaddrs()
1367 return -EOPNOTSUPP; in __read_out_blkaddrs()
1377 len -= done; in __read_out_blkaddrs()
1440 ADDRS_PER_PAGE(dn.node_folio, dst_inode) - in __clone_blkaddrs()
1441 dn.ofs_in_node, len - i); in __clone_blkaddrs()
1459 if (dst_inode->i_size < new_size) in __clone_blkaddrs()
1461 } while (--ilen && (do_replace[i] || blkaddr[i] == NULL_ADDR)); in __clone_blkaddrs()
1512 return -ENOMEM; in __exchange_data_block()
1519 return -ENOMEM; in __exchange_data_block()
1534 len -= olen; in __exchange_data_block()
1559 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_do_collapse()
1560 filemap_invalidate_lock(inode->i_mapping); in f2fs_do_collapse()
1567 ret = __exchange_data_block(inode, inode, end, start, nrpages - end, true); in f2fs_do_collapse()
1570 filemap_invalidate_unlock(inode->i_mapping); in f2fs_do_collapse()
1571 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_do_collapse()
1581 return -EINVAL; in f2fs_collapse_range()
1584 if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1)) in f2fs_collapse_range()
1585 return -EINVAL; in f2fs_collapse_range()
1592 ret = filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX); in f2fs_collapse_range()
1601 filemap_invalidate_lock(inode->i_mapping); in f2fs_collapse_range()
1602 filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX); in f2fs_collapse_range()
1605 new_size = i_size_read(inode) - len; in f2fs_collapse_range()
1607 filemap_invalidate_unlock(inode->i_mapping); in f2fs_collapse_range()
1616 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode); in f2fs_do_zero_range()
1618 unsigned int ofs_in_node = dn->ofs_in_node; in f2fs_do_zero_range()
1622 for (; index < end; index++, dn->ofs_in_node++) { in f2fs_do_zero_range()
1627 dn->ofs_in_node = ofs_in_node; in f2fs_do_zero_range()
1632 dn->ofs_in_node = ofs_in_node; in f2fs_do_zero_range()
1633 for (index = start; index < end; index++, dn->ofs_in_node++) { in f2fs_do_zero_range()
1634 dn->data_blkaddr = f2fs_data_blkaddr(dn); in f2fs_do_zero_range()
1639 if (dn->data_blkaddr == NULL_ADDR) { in f2fs_do_zero_range()
1640 ret = -ENOSPC; in f2fs_do_zero_range()
1644 if (dn->data_blkaddr == NEW_ADDR) in f2fs_do_zero_range()
1647 if (!f2fs_is_valid_blkaddr(sbi, dn->data_blkaddr, in f2fs_do_zero_range()
1649 ret = -EFSCORRUPTED; in f2fs_do_zero_range()
1653 f2fs_invalidate_blocks(sbi, dn->data_blkaddr, 1); in f2fs_do_zero_range()
1657 f2fs_update_read_extent_cache_range(dn, start, 0, index - start); in f2fs_do_zero_range()
1658 f2fs_update_age_extent_cache_range(dn, start, index - start); in f2fs_do_zero_range()
1667 struct address_space *mapping = inode->i_mapping; in f2fs_zero_range()
1681 ret = filemap_write_and_wait_range(mapping, offset, offset + len - 1); in f2fs_zero_range()
1690 off_start = offset & (PAGE_SIZE - 1); in f2fs_zero_range()
1691 off_end = (offset + len) & (PAGE_SIZE - 1); in f2fs_zero_range()
1695 off_end - off_start); in f2fs_zero_range()
1703 PAGE_SIZE - off_start); in f2fs_zero_range()
1716 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_zero_range()
1721 ((loff_t)pg_end << PAGE_SHIFT) - 1); in f2fs_zero_range()
1730 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_zero_range()
1735 end = min(pg_end, end_offset - dn.ofs_in_node + index); in f2fs_zero_range()
1742 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_zero_range()
1776 struct address_space *mapping = inode->i_mapping; in f2fs_insert_range()
1787 return -EINVAL; in f2fs_insert_range()
1790 if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1)) in f2fs_insert_range()
1791 return -EINVAL; in f2fs_insert_range()
1812 delta = pg_end - pg_start; in f2fs_insert_range()
1816 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_insert_range()
1823 nr = idx - pg_start; in f2fs_insert_range()
1826 idx -= nr; in f2fs_insert_range()
1836 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_insert_range()
1883 off_end = (offset + len) & (PAGE_SIZE - 1); in f2fs_expand_inode_data()
1886 map.m_len = pg_end - pg_start; in f2fs_expand_inode_data()
1899 f2fs_down_write(&sbi->pin_sem); in f2fs_expand_inode_data()
1903 f2fs_up_write(&sbi->pin_sem); in f2fs_expand_inode_data()
1904 err = -ENOSPC; in f2fs_expand_inode_data()
1908 inode->i_ino, pg_start, pg_end); in f2fs_expand_inode_data()
1914 sbi->reserved_pin_section)) { in f2fs_expand_inode_data()
1915 f2fs_down_write(&sbi->gc_lock); in f2fs_expand_inode_data()
1918 if (err && err != -ENODATA) { in f2fs_expand_inode_data()
1919 f2fs_up_write(&sbi->pin_sem); in f2fs_expand_inode_data()
1926 f2fs_up_write(&sbi->pin_sem); in f2fs_expand_inode_data()
1934 f2fs_up_write(&sbi->pin_sem); in f2fs_expand_inode_data()
1937 sec_len -= map.m_len; in f2fs_expand_inode_data()
1954 last_off = pg_start + expanded - 1; in f2fs_expand_inode_data()
1980 return -EIO; in f2fs_fallocate()
1982 return -ENOSPC; in f2fs_fallocate()
1984 return -EOPNOTSUPP; in f2fs_fallocate()
1986 /* f2fs only support ->fallocate for regular file */ in f2fs_fallocate()
1987 if (!S_ISREG(inode->i_mode)) in f2fs_fallocate()
1988 return -EINVAL; in f2fs_fallocate()
1992 return -EOPNOTSUPP; in f2fs_fallocate()
1997 return -EOPNOTSUPP; in f2fs_fallocate()
2008 ret = -EOPNOTSUPP; in f2fs_fallocate()
2023 if (offset >= inode->i_size) in f2fs_fallocate()
2052 if (atomic_dec_and_test(&F2FS_I(inode)->open_count)) in f2fs_release_file()
2059 if (!(filp->f_mode & FMODE_WRITE) || in f2fs_release_file()
2060 atomic_read(&inode->i_writecount) != 1) in f2fs_release_file()
2076 * roll-back. Otherwise, other reader/write can see corrupted database in f2fs_file_flush()
2078 * before dropping file lock, it needs to do in ->flush. in f2fs_file_flush()
2080 if (F2FS_I(inode)->atomic_write_task == current && in f2fs_file_flush()
2081 (current->flags & PF_EXITING)) { in f2fs_file_flush()
2093 u32 masked_flags = fi->i_flags & mask; in f2fs_setflags_common()
2100 return -EPERM; in f2fs_setflags_common()
2104 return -EOPNOTSUPP; in f2fs_setflags_common()
2106 return -ENOTEMPTY; in f2fs_setflags_common()
2111 return -EOPNOTSUPP; in f2fs_setflags_common()
2113 return -EINVAL; in f2fs_setflags_common()
2119 return -EINVAL; in f2fs_setflags_common()
2126 f2fs_down_write(&fi->i_sem); in f2fs_setflags_common()
2128 (S_ISREG(inode->i_mode) && in f2fs_setflags_common()
2130 f2fs_up_write(&fi->i_sem); in f2fs_setflags_common()
2131 return -EINVAL; in f2fs_setflags_common()
2134 f2fs_up_write(&fi->i_sem); in f2fs_setflags_common()
2141 fi->i_flags = iflags | (fi->i_flags & ~mask); in f2fs_setflags_common()
2142 f2fs_bug_on(F2FS_I_SB(inode), (fi->i_flags & F2FS_COMPR_FL) && in f2fs_setflags_common()
2143 (fi->i_flags & F2FS_NOCOMP_FL)); in f2fs_setflags_common()
2145 if (fi->i_flags & F2FS_PROJINHERIT_FL) in f2fs_setflags_common()
2159 * To make a new on-disk f2fs i_flag gettable via FS_IOC_GETFLAGS, add an entry
2214 /* Convert f2fs on-disk i_flags to FS_IOC_{GET,SET}FLAGS flags */
2227 /* Convert FS_IOC_{GET,SET}FLAGS flags to f2fs on-disk i_flags */
2244 return put_user(inode->i_generation, (int __user *)arg); in f2fs_ioc_getversion()
2256 if (!(filp->f_mode & FMODE_WRITE)) in f2fs_ioc_start_atomic_write()
2257 return -EBADF; in f2fs_ioc_start_atomic_write()
2260 return -EACCES; in f2fs_ioc_start_atomic_write()
2262 if (!S_ISREG(inode->i_mode)) in f2fs_ioc_start_atomic_write()
2263 return -EINVAL; in f2fs_ioc_start_atomic_write()
2265 if (filp->f_flags & O_DIRECT) in f2fs_ioc_start_atomic_write()
2266 return -EINVAL; in f2fs_ioc_start_atomic_write()
2276 ret = -EINVAL; in f2fs_ioc_start_atomic_write()
2287 f2fs_down_write(&fi->i_gc_rwsem[WRITE]); in f2fs_ioc_start_atomic_write()
2288 f2fs_down_write(&fi->i_gc_rwsem[READ]); in f2fs_ioc_start_atomic_write()
2296 inode->i_ino, get_dirty_pages(inode)); in f2fs_ioc_start_atomic_write()
2297 ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX); in f2fs_ioc_start_atomic_write()
2302 if (fi->cow_inode == NULL) { in f2fs_ioc_start_atomic_write()
2305 struct inode *dir = d_inode(dentry->d_parent); in f2fs_ioc_start_atomic_write()
2307 ret = f2fs_get_tmpfile(idmap, dir, &fi->cow_inode); in f2fs_ioc_start_atomic_write()
2311 set_inode_flag(fi->cow_inode, FI_COW_FILE); in f2fs_ioc_start_atomic_write()
2312 clear_inode_flag(fi->cow_inode, FI_INLINE_DATA); in f2fs_ioc_start_atomic_write()
2315 F2FS_I(fi->cow_inode)->atomic_inode = inode; in f2fs_ioc_start_atomic_write()
2318 f2fs_bug_on(sbi, get_dirty_pages(fi->cow_inode)); in f2fs_ioc_start_atomic_write()
2320 invalidate_mapping_pages(fi->cow_inode->i_mapping, 0, -1); in f2fs_ioc_start_atomic_write()
2322 ret = f2fs_do_truncate_blocks(fi->cow_inode, 0, true); in f2fs_ioc_start_atomic_write()
2334 fi->original_i_size = isize; in f2fs_ioc_start_atomic_write()
2337 truncate_inode_pages_final(inode->i_mapping); in f2fs_ioc_start_atomic_write()
2341 f2fs_i_size_write(fi->cow_inode, isize); in f2fs_ioc_start_atomic_write()
2344 f2fs_up_write(&fi->i_gc_rwsem[READ]); in f2fs_ioc_start_atomic_write()
2345 f2fs_up_write(&fi->i_gc_rwsem[WRITE]); in f2fs_ioc_start_atomic_write()
2350 fi->atomic_write_task = current; in f2fs_ioc_start_atomic_write()
2352 fi->atomic_write_cnt = 0; in f2fs_ioc_start_atomic_write()
2365 if (!(filp->f_mode & FMODE_WRITE)) in f2fs_ioc_commit_atomic_write()
2366 return -EBADF; in f2fs_ioc_commit_atomic_write()
2369 return -EACCES; in f2fs_ioc_commit_atomic_write()
2400 if (!(filp->f_mode & FMODE_WRITE)) in f2fs_ioc_abort_atomic_write()
2401 return -EBADF; in f2fs_ioc_abort_atomic_write()
2404 return -EACCES; in f2fs_ioc_abort_atomic_write()
2424 struct super_block *sb = sbi->sb; in f2fs_do_shutdown()
2429 ret = bdev_freeze(sb->s_bdev); in f2fs_do_shutdown()
2433 bdev_thaw(sb->s_bdev); in f2fs_do_shutdown()
2439 if (ret == -EIO) in f2fs_do_shutdown()
2458 if (ret == -EIO) in f2fs_do_shutdown()
2462 ret = -EINVAL; in f2fs_do_shutdown()
2470 * grab sb->s_umount to avoid racing w/ remount() and other shutdown in f2fs_do_shutdown()
2474 down_write(&sbi->sb->s_umount); in f2fs_do_shutdown()
2483 up_write(&sbi->sb->s_umount); in f2fs_do_shutdown()
2502 return -EPERM; in f2fs_ioc_shutdown()
2505 return -EFAULT; in f2fs_ioc_shutdown()
2510 if (ret != -EROFS) in f2fs_ioc_shutdown()
2537 if (!S_ISREG(inode->i_mode)) in f2fs_keep_noreuse_range()
2553 spin_lock(&sbi->inode_lock[DONATE_INODE]); in f2fs_keep_noreuse_range()
2556 if (!list_empty(&F2FS_I(inode)->gdonate_list)) { in f2fs_keep_noreuse_range()
2557 list_del_init(&F2FS_I(inode)->gdonate_list); in f2fs_keep_noreuse_range()
2558 sbi->donate_files--; in f2fs_keep_noreuse_range()
2560 ret = -EALREADY; in f2fs_keep_noreuse_range()
2564 ret = -ENOENT; in f2fs_keep_noreuse_range()
2566 if (list_empty(&F2FS_I(inode)->gdonate_list)) { in f2fs_keep_noreuse_range()
2567 list_add_tail(&F2FS_I(inode)->gdonate_list, in f2fs_keep_noreuse_range()
2568 &sbi->inode_list[DONATE_INODE]); in f2fs_keep_noreuse_range()
2569 sbi->donate_files++; in f2fs_keep_noreuse_range()
2571 list_move_tail(&F2FS_I(inode)->gdonate_list, in f2fs_keep_noreuse_range()
2572 &sbi->inode_list[DONATE_INODE]); in f2fs_keep_noreuse_range()
2574 F2FS_I(inode)->donate_start = start; in f2fs_keep_noreuse_range()
2575 F2FS_I(inode)->donate_end = end - 1; in f2fs_keep_noreuse_range()
2578 spin_unlock(&sbi->inode_lock[DONATE_INODE]); in f2fs_keep_noreuse_range()
2587 struct super_block *sb = inode->i_sb; in f2fs_ioc_fitrim()
2592 return -EPERM; in f2fs_ioc_fitrim()
2595 return -EOPNOTSUPP; in f2fs_ioc_fitrim()
2599 return -EFAULT; in f2fs_ioc_fitrim()
2606 bdev_discard_granularity(sb->s_bdev)); in f2fs_ioc_fitrim()
2614 return -EFAULT; in f2fs_ioc_fitrim()
2635 return -EOPNOTSUPP; in f2fs_ioc_set_encryption_policy()
2645 return -EOPNOTSUPP; in f2fs_ioc_get_encryption_policy()
2657 return -EOPNOTSUPP; in f2fs_ioc_get_encryption_pwsalt()
2663 f2fs_down_write(&sbi->sb_lock); in f2fs_ioc_get_encryption_pwsalt()
2665 if (uuid_is_nonzero(sbi->raw_super->encrypt_pw_salt)) in f2fs_ioc_get_encryption_pwsalt()
2669 generate_random_uuid(sbi->raw_super->encrypt_pw_salt); in f2fs_ioc_get_encryption_pwsalt()
2674 memset(sbi->raw_super->encrypt_pw_salt, 0, 16); in f2fs_ioc_get_encryption_pwsalt()
2678 memcpy(encrypt_pw_salt, sbi->raw_super->encrypt_pw_salt, 16); in f2fs_ioc_get_encryption_pwsalt()
2680 f2fs_up_write(&sbi->sb_lock); in f2fs_ioc_get_encryption_pwsalt()
2684 err = -EFAULT; in f2fs_ioc_get_encryption_pwsalt()
2693 return -EOPNOTSUPP; in f2fs_ioc_get_encryption_policy_ex()
2701 return -EOPNOTSUPP; in f2fs_ioc_add_encryption_key()
2709 return -EOPNOTSUPP; in f2fs_ioc_remove_encryption_key()
2718 return -EOPNOTSUPP; in f2fs_ioc_remove_encryption_key_all_users()
2727 return -EOPNOTSUPP; in f2fs_ioc_get_encryption_key_status()
2735 return -EOPNOTSUPP; in f2fs_ioc_get_encryption_nonce()
2752 return -EPERM; in f2fs_ioc_gc()
2755 return -EFAULT; in f2fs_ioc_gc()
2757 if (f2fs_readonly(sbi->sb)) in f2fs_ioc_gc()
2758 return -EROFS; in f2fs_ioc_gc()
2765 if (!f2fs_down_write_trylock(&sbi->gc_lock)) { in f2fs_ioc_gc()
2766 ret = -EBUSY; in f2fs_ioc_gc()
2770 f2fs_down_write(&sbi->gc_lock); in f2fs_ioc_gc()
2786 .init_gc_type = range->sync ? FG_GC : BG_GC, in __f2fs_ioc_gc_range()
2789 .err_gc_skipped = range->sync, in __f2fs_ioc_gc_range()
2795 return -EPERM; in __f2fs_ioc_gc_range()
2796 if (f2fs_readonly(sbi->sb)) in __f2fs_ioc_gc_range()
2797 return -EROFS; in __f2fs_ioc_gc_range()
2799 end = range->start + range->len; in __f2fs_ioc_gc_range()
2800 if (end < range->start || range->start < MAIN_BLKADDR(sbi) || in __f2fs_ioc_gc_range()
2802 return -EINVAL; in __f2fs_ioc_gc_range()
2809 if (!range->sync) { in __f2fs_ioc_gc_range()
2810 if (!f2fs_down_write_trylock(&sbi->gc_lock)) { in __f2fs_ioc_gc_range()
2811 ret = -EBUSY; in __f2fs_ioc_gc_range()
2815 f2fs_down_write(&sbi->gc_lock); in __f2fs_ioc_gc_range()
2818 gc_control.victim_segno = GET_SEGNO(sbi, range->start); in __f2fs_ioc_gc_range()
2822 if (ret == -EBUSY) in __f2fs_ioc_gc_range()
2823 ret = -EAGAIN; in __f2fs_ioc_gc_range()
2826 range->start += CAP_BLKS_PER_SEC(sbi); in __f2fs_ioc_gc_range()
2827 if (range->start <= end) in __f2fs_ioc_gc_range()
2840 return -EFAULT; in f2fs_ioc_gc_range()
2851 return -EPERM; in f2fs_ioc_write_checkpoint()
2853 if (f2fs_readonly(sbi->sb)) in f2fs_ioc_write_checkpoint()
2854 return -EROFS; in f2fs_ioc_write_checkpoint()
2858 return -EINVAL; in f2fs_ioc_write_checkpoint()
2865 ret = f2fs_sync_fs(sbi->sb, 1); in f2fs_ioc_write_checkpoint()
2889 pg_start = range->start >> PAGE_SHIFT; in f2fs_defragment_range()
2891 (range->start + range->len) >> PAGE_SHIFT, in f2fs_defragment_range()
2896 err = -EINVAL; in f2fs_defragment_range()
2900 /* if in-place-update policy is enabled, don't waste time here */ in f2fs_defragment_range()
2903 err = -EINVAL; in f2fs_defragment_range()
2908 err = filemap_write_and_wait_range(inode->i_mapping, in f2fs_defragment_range()
2910 (pg_end << PAGE_SHIFT) - 1); in f2fs_defragment_range()
2932 map.m_len = pg_end - map.m_lblk; in f2fs_defragment_range()
2966 err = -EAGAIN; in f2fs_defragment_range()
2971 map.m_len = pg_end - pg_start; in f2fs_defragment_range()
2979 map.m_len = pg_end - map.m_lblk; in f2fs_defragment_range()
3020 err = filemap_fdatawrite(inode->i_mapping); in f2fs_defragment_range()
3031 range->len = (u64)total << PAGE_SHIFT; in f2fs_defragment_range()
3043 return -EPERM; in f2fs_ioc_defragment()
3045 if (!S_ISREG(inode->i_mode)) in f2fs_ioc_defragment()
3046 return -EINVAL; in f2fs_ioc_defragment()
3048 if (f2fs_readonly(sbi->sb)) in f2fs_ioc_defragment()
3049 return -EROFS; in f2fs_ioc_defragment()
3053 return -EFAULT; in f2fs_ioc_defragment()
3056 if (range.start & (F2FS_BLKSIZE - 1) || range.len & (F2FS_BLKSIZE - 1)) in f2fs_ioc_defragment()
3057 return -EINVAL; in f2fs_ioc_defragment()
3061 return -EINVAL; in f2fs_ioc_defragment()
3077 return -EFAULT; in f2fs_ioc_defragment()
3092 if (file_in->f_path.mnt != file_out->f_path.mnt || in f2fs_move_file_range()
3093 src->i_sb != dst->i_sb) in f2fs_move_file_range()
3094 return -EXDEV; in f2fs_move_file_range()
3096 if (unlikely(f2fs_readonly(src->i_sb))) in f2fs_move_file_range()
3097 return -EROFS; in f2fs_move_file_range()
3099 if (!S_ISREG(src->i_mode) || !S_ISREG(dst->i_mode)) in f2fs_move_file_range()
3100 return -EINVAL; in f2fs_move_file_range()
3103 return -EOPNOTSUPP; in f2fs_move_file_range()
3106 return -EINVAL; in f2fs_move_file_range()
3112 return -EINVAL; in f2fs_move_file_range()
3117 ret = -EBUSY; in f2fs_move_file_range()
3124 ret = -EOPNOTSUPP; in f2fs_move_file_range()
3129 ret = -EINVAL; in f2fs_move_file_range()
3133 ret = -EINVAL; in f2fs_move_file_range()
3134 if (pos_in + len > src->i_size || pos_in + len < pos_in) in f2fs_move_file_range()
3137 olen = len = src->i_size - pos_in; in f2fs_move_file_range()
3138 if (pos_in + len == src->i_size) in f2fs_move_file_range()
3139 len = ALIGN(src->i_size, F2FS_BLKSIZE) - pos_in; in f2fs_move_file_range()
3145 dst_osize = dst->i_size; in f2fs_move_file_range()
3146 if (pos_out + olen > dst->i_size) in f2fs_move_file_range()
3164 ret = filemap_write_and_wait_range(src->i_mapping, in f2fs_move_file_range()
3169 ret = filemap_write_and_wait_range(dst->i_mapping, in f2fs_move_file_range()
3176 f2fs_down_write(&F2FS_I(src)->i_gc_rwsem[WRITE]); in f2fs_move_file_range()
3178 ret = -EBUSY; in f2fs_move_file_range()
3179 if (!f2fs_down_write_trylock(&F2FS_I(dst)->i_gc_rwsem[WRITE])) in f2fs_move_file_range()
3191 else if (dst_osize != dst->i_size) in f2fs_move_file_range()
3197 f2fs_up_write(&F2FS_I(dst)->i_gc_rwsem[WRITE]); in f2fs_move_file_range()
3199 f2fs_up_write(&F2FS_I(src)->i_gc_rwsem[WRITE]); in f2fs_move_file_range()
3224 if (!(filp->f_mode & FMODE_READ) || in __f2fs_ioc_move_range()
3225 !(filp->f_mode & FMODE_WRITE)) in __f2fs_ioc_move_range()
3226 return -EBADF; in __f2fs_ioc_move_range()
3228 CLASS(fd, dst)(range->dst_fd); in __f2fs_ioc_move_range()
3230 return -EBADF; in __f2fs_ioc_move_range()
3232 if (!(fd_file(dst)->f_mode & FMODE_WRITE)) in __f2fs_ioc_move_range()
3233 return -EBADF; in __f2fs_ioc_move_range()
3239 err = f2fs_move_file_range(filp, range->pos_in, fd_file(dst), in __f2fs_ioc_move_range()
3240 range->pos_out, range->len); in __f2fs_ioc_move_range()
3252 return -EFAULT; in f2fs_ioc_move_range()
3272 return -EPERM; in f2fs_ioc_flush_device()
3274 if (f2fs_readonly(sbi->sb)) in f2fs_ioc_flush_device()
3275 return -EROFS; in f2fs_ioc_flush_device()
3278 return -EINVAL; in f2fs_ioc_flush_device()
3282 return -EFAULT; in f2fs_ioc_flush_device()
3284 if (!f2fs_is_multi_device(sbi) || sbi->s_ndevs - 1 <= range.dev_num || in f2fs_ioc_flush_device()
3287 range.dev_num, sbi->s_ndevs, SEGS_PER_SEC(sbi)); in f2fs_ioc_flush_device()
3288 return -EINVAL; in f2fs_ioc_flush_device()
3299 start_segno = sm->last_victim[FLUSH_DEVICE]; in f2fs_ioc_flush_device()
3305 if (!f2fs_down_write_trylock(&sbi->gc_lock)) { in f2fs_ioc_flush_device()
3306 ret = -EBUSY; in f2fs_ioc_flush_device()
3309 sm->last_victim[GC_CB] = end_segno + 1; in f2fs_ioc_flush_device()
3310 sm->last_victim[GC_GREEDY] = end_segno + 1; in f2fs_ioc_flush_device()
3311 sm->last_victim[ALLOC_NEXT] = end_segno + 1; in f2fs_ioc_flush_device()
3316 if (ret == -EAGAIN) in f2fs_ioc_flush_device()
3330 u32 sb_feature = le32_to_cpu(F2FS_I_SB(inode)->raw_super->feature); in f2fs_ioc_get_features()
3343 struct super_block *sb = sbi->sb; in f2fs_transfer_project_quota()
3367 return -EOPNOTSUPP; in f2fs_ioc_setproject()
3373 return -EOPNOTSUPP; in f2fs_ioc_setproject()
3377 if (projid_eq(kprojid, fi->i_projid)) in f2fs_ioc_setproject()
3380 err = -EPERM; in f2fs_ioc_setproject()
3385 if (!F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_projid)) in f2fs_ioc_setproject()
3386 return -EOVERFLOW; in f2fs_ioc_setproject()
3397 fi->i_projid = kprojid; in f2fs_ioc_setproject()
3413 return -EOPNOTSUPP; in f2fs_ioc_setproject()
3422 u32 fsflags = f2fs_iflags_to_fsflags(fi->i_flags); in f2fs_fileattr_get()
3436 fa->fsx_projid = from_kprojid(&init_user_ns, fi->i_projid); in f2fs_fileattr_get()
3445 u32 fsflags = fa->flags, mask = F2FS_SETTABLE_FS_FL; in f2fs_fileattr_set()
3450 return -EIO; in f2fs_fileattr_set()
3452 return -ENOSPC; in f2fs_fileattr_set()
3454 return -EOPNOTSUPP; in f2fs_fileattr_set()
3456 if (!fa->flags_valid) in f2fs_fileattr_set()
3460 if (f2fs_mask_flags(inode->i_mode, iflags) != iflags) in f2fs_fileattr_set()
3461 return -EOPNOTSUPP; in f2fs_fileattr_set()
3465 err = f2fs_ioc_setproject(inode, fa->fsx_projid); in f2fs_fileattr_set()
3476 return -EINVAL; in f2fs_pin_file_control()
3478 if (fi->i_gc_failures >= sbi->gc_pin_file_threshold) { in f2fs_pin_file_control()
3480 __func__, inode->i_ino, fi->i_gc_failures); in f2fs_pin_file_control()
3482 return -EAGAIN; in f2fs_pin_file_control()
3487 f2fs_i_gc_failures_write(inode, fi->i_gc_failures + 1); in f2fs_pin_file_control()
3500 return -EFAULT; in f2fs_ioc_set_pin_file()
3502 if (!S_ISREG(inode->i_mode)) in f2fs_ioc_set_pin_file()
3503 return -EINVAL; in f2fs_ioc_set_pin_file()
3505 if (f2fs_readonly(sbi->sb)) in f2fs_ioc_set_pin_file()
3506 return -EROFS; in f2fs_ioc_set_pin_file()
3509 return -EOPNOTSUPP; in f2fs_ioc_set_pin_file()
3518 ret = -EINVAL; in f2fs_ioc_set_pin_file()
3531 ret = -EFBIG; in f2fs_ioc_set_pin_file()
3538 ret = -EINVAL; in f2fs_ioc_set_pin_file()
3543 ret = -EAGAIN; in f2fs_ioc_set_pin_file()
3552 ret = -EOPNOTSUPP; in f2fs_ioc_set_pin_file()
3557 ret = F2FS_I(inode)->i_gc_failures; in f2fs_ioc_set_pin_file()
3572 pin = F2FS_I(inode)->i_gc_failures; in f2fs_ioc_get_pin_file()
3588 return -EFAULT; in f2fs_ioc_io_prio()
3590 if (!S_ISREG(inode->i_mode) || level >= F2FS_IOPRIO_MAX) in f2fs_ioc_io_prio()
3591 return -EINVAL; in f2fs_ioc_io_prio()
3594 F2FS_I(inode)->ioprio_hint = level; in f2fs_ioc_io_prio()
3608 return -EOPNOTSUPP; in f2fs_precache_extents()
3619 map.m_len = end - map.m_lblk; in f2fs_precache_extents()
3621 f2fs_down_write(&fi->i_gc_rwsem[WRITE]); in f2fs_precache_extents()
3623 f2fs_up_write(&fi->i_gc_rwsem[WRITE]); in f2fs_precache_extents()
3644 return -EPERM; in f2fs_ioc_resize_fs()
3646 if (f2fs_readonly(sbi->sb)) in f2fs_ioc_resize_fs()
3647 return -EROFS; in f2fs_ioc_resize_fs()
3651 return -EFAULT; in f2fs_ioc_resize_fs()
3664 "Can't enable fs-verity on inode %lu: the verity feature is not enabled on this filesystem", in f2fs_ioc_enable_verity()
3665 inode->i_ino); in f2fs_ioc_enable_verity()
3666 return -EOPNOTSUPP; in f2fs_ioc_enable_verity()
3675 return -EOPNOTSUPP; in f2fs_ioc_measure_verity()
3683 return -EOPNOTSUPP; in f2fs_ioc_read_verity_metadata()
3698 return -ENOMEM; in f2fs_ioc_getfslabel()
3700 f2fs_down_read(&sbi->sb_lock); in f2fs_ioc_getfslabel()
3701 count = utf16s_to_utf8s(sbi->raw_super->volume_name, in f2fs_ioc_getfslabel()
3702 ARRAY_SIZE(sbi->raw_super->volume_name), in f2fs_ioc_getfslabel()
3704 f2fs_up_read(&sbi->sb_lock); in f2fs_ioc_getfslabel()
3708 err = -EFAULT; in f2fs_ioc_getfslabel()
3722 return -EPERM; in f2fs_ioc_setfslabel()
3732 f2fs_down_write(&sbi->sb_lock); in f2fs_ioc_setfslabel()
3734 memset(sbi->raw_super->volume_name, 0, in f2fs_ioc_setfslabel()
3735 sizeof(sbi->raw_super->volume_name)); in f2fs_ioc_setfslabel()
3737 sbi->raw_super->volume_name, in f2fs_ioc_setfslabel()
3738 ARRAY_SIZE(sbi->raw_super->volume_name)); in f2fs_ioc_setfslabel()
3742 f2fs_up_write(&sbi->sb_lock); in f2fs_ioc_setfslabel()
3753 return -EOPNOTSUPP; in f2fs_get_compress_blocks()
3756 return -EINVAL; in f2fs_get_compress_blocks()
3758 *blocks = atomic_read(&F2FS_I(inode)->i_compr_blocks); in f2fs_get_compress_blocks()
3778 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode); in release_compress_blocks()
3780 int cluster_size = F2FS_I(dn->inode)->i_cluster_size; in release_compress_blocks()
3785 blkaddr = data_blkaddr(dn->inode, dn->node_folio, in release_compress_blocks()
3786 dn->ofs_in_node + i); in release_compress_blocks()
3792 return -EFSCORRUPTED; in release_compress_blocks()
3798 for (i = 0; i < cluster_size; i++, dn->ofs_in_node++) { in release_compress_blocks()
3804 dn->ofs_in_node += cluster_size; in release_compress_blocks()
3817 f2fs_i_compr_blocks_update(dn->inode, compr_blocks, false); in release_compress_blocks()
3818 dec_valid_block_count(sbi, dn->inode, in release_compress_blocks()
3819 cluster_size - compr_blocks); in release_compress_blocks()
3821 released_blocks += cluster_size - compr_blocks; in release_compress_blocks()
3823 count -= cluster_size; in release_compress_blocks()
3840 return -EOPNOTSUPP; in f2fs_release_compress_blocks()
3842 if (f2fs_readonly(sbi->sb)) in f2fs_release_compress_blocks()
3843 return -EROFS; in f2fs_release_compress_blocks()
3853 writecount = atomic_read(&inode->i_writecount); in f2fs_release_compress_blocks()
3854 if ((filp->f_mode & FMODE_WRITE && writecount != 1) || in f2fs_release_compress_blocks()
3855 (!(filp->f_mode & FMODE_WRITE) && writecount)) { in f2fs_release_compress_blocks()
3856 ret = -EBUSY; in f2fs_release_compress_blocks()
3862 ret = -EINVAL; in f2fs_release_compress_blocks()
3866 ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX); in f2fs_release_compress_blocks()
3870 if (!atomic_read(&fi->i_compr_blocks)) { in f2fs_release_compress_blocks()
3871 ret = -EPERM; in f2fs_release_compress_blocks()
3879 f2fs_down_write(&fi->i_gc_rwsem[WRITE]); in f2fs_release_compress_blocks()
3880 filemap_invalidate_lock(inode->i_mapping); in f2fs_release_compress_blocks()
3894 if (ret == -ENOENT) { in f2fs_release_compress_blocks()
3904 count = min(end_offset - dn.ofs_in_node, last_idx - page_idx); in f2fs_release_compress_blocks()
3905 count = round_up(count, fi->i_cluster_size); in f2fs_release_compress_blocks()
3920 filemap_invalidate_unlock(inode->i_mapping); in f2fs_release_compress_blocks()
3921 f2fs_up_write(&fi->i_gc_rwsem[WRITE]); in f2fs_release_compress_blocks()
3932 atomic_read(&fi->i_compr_blocks)) { in f2fs_release_compress_blocks()
3937 __func__, inode->i_ino, inode->i_blocks, in f2fs_release_compress_blocks()
3939 atomic_read(&fi->i_compr_blocks)); in f2fs_release_compress_blocks()
3948 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode); in reserve_compress_blocks()
3949 int cluster_size = F2FS_I(dn->inode)->i_cluster_size; in reserve_compress_blocks()
3954 blkaddr = data_blkaddr(dn->inode, dn->node_folio, in reserve_compress_blocks()
3955 dn->ofs_in_node + i); in reserve_compress_blocks()
3961 return -EFSCORRUPTED; in reserve_compress_blocks()
3971 blkaddr = data_blkaddr(dn->inode, dn->node_folio, in reserve_compress_blocks()
3972 dn->ofs_in_node + i); in reserve_compress_blocks()
3976 dn->ofs_in_node += cluster_size; in reserve_compress_blocks()
3997 to_reserved = cluster_size - compr_blocks - reserved; in reserve_compress_blocks()
4001 dn->ofs_in_node += cluster_size; in reserve_compress_blocks()
4005 ret = inc_valid_block_count(sbi, dn->inode, in reserve_compress_blocks()
4010 for (i = 0; i < cluster_size; i++, dn->ofs_in_node++) { in reserve_compress_blocks()
4015 f2fs_i_compr_blocks_update(dn->inode, compr_blocks, true); in reserve_compress_blocks()
4019 count -= cluster_size; in reserve_compress_blocks()
4035 return -EOPNOTSUPP; in f2fs_reserve_compress_blocks()
4037 if (f2fs_readonly(sbi->sb)) in f2fs_reserve_compress_blocks()
4038 return -EROFS; in f2fs_reserve_compress_blocks()
4050 ret = -EINVAL; in f2fs_reserve_compress_blocks()
4054 if (atomic_read(&fi->i_compr_blocks)) in f2fs_reserve_compress_blocks()
4057 f2fs_down_write(&fi->i_gc_rwsem[WRITE]); in f2fs_reserve_compress_blocks()
4058 filemap_invalidate_lock(inode->i_mapping); in f2fs_reserve_compress_blocks()
4072 if (ret == -ENOENT) { in f2fs_reserve_compress_blocks()
4082 count = min(end_offset - dn.ofs_in_node, last_idx - page_idx); in f2fs_reserve_compress_blocks()
4083 count = round_up(count, fi->i_cluster_size); in f2fs_reserve_compress_blocks()
4097 filemap_invalidate_unlock(inode->i_mapping); in f2fs_reserve_compress_blocks()
4098 f2fs_up_write(&fi->i_gc_rwsem[WRITE]); in f2fs_reserve_compress_blocks()
4114 atomic_read(&fi->i_compr_blocks)) { in f2fs_reserve_compress_blocks()
4119 __func__, inode->i_ino, inode->i_blocks, in f2fs_reserve_compress_blocks()
4121 atomic_read(&fi->i_compr_blocks)); in f2fs_reserve_compress_blocks()
4158 struct address_space *mapping = inode->i_mapping; in f2fs_sec_trim_file()
4167 if (!(filp->f_mode & FMODE_WRITE)) in f2fs_sec_trim_file()
4168 return -EBADF; in f2fs_sec_trim_file()
4172 return -EFAULT; in f2fs_sec_trim_file()
4175 !S_ISREG(inode->i_mode)) in f2fs_sec_trim_file()
4176 return -EINVAL; in f2fs_sec_trim_file()
4182 return -EOPNOTSUPP; in f2fs_sec_trim_file()
4190 range.start >= inode->i_size) { in f2fs_sec_trim_file()
4191 ret = -EINVAL; in f2fs_sec_trim_file()
4198 if (inode->i_size - range.start > range.len) { in f2fs_sec_trim_file()
4201 end_addr = range.len == (u64)-1 ? in f2fs_sec_trim_file()
4202 sbi->sb->s_maxbytes : inode->i_size; in f2fs_sec_trim_file()
4208 ret = -EINVAL; in f2fs_sec_trim_file()
4219 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_sec_trim_file()
4223 to_end ? LLONG_MAX : end_addr - 1); in f2fs_sec_trim_file()
4228 to_end ? -1 : end_addr - 1); in f2fs_sec_trim_file()
4238 if (ret == -ENOENT) { in f2fs_sec_trim_file()
4246 count = min(end_offset - dn.ofs_in_node, pg_end - index); in f2fs_sec_trim_file()
4256 ret = -EFSCORRUPTED; in f2fs_sec_trim_file()
4265 blkaddr -= FDEV(di).start_blk; in f2fs_sec_trim_file()
4297 ret = -EINTR; in f2fs_sec_trim_file()
4309 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_sec_trim_file()
4323 return -EOPNOTSUPP; in f2fs_ioc_get_compress_option()
4329 return -ENODATA; in f2fs_ioc_get_compress_option()
4332 option.algorithm = F2FS_I(inode)->i_compress_algorithm; in f2fs_ioc_get_compress_option()
4333 option.log_cluster_size = F2FS_I(inode)->i_log_cluster_size; in f2fs_ioc_get_compress_option()
4339 return -EFAULT; in f2fs_ioc_get_compress_option()
4353 return -EOPNOTSUPP; in f2fs_ioc_set_compress_option()
4355 if (!(filp->f_mode & FMODE_WRITE)) in f2fs_ioc_set_compress_option()
4356 return -EBADF; in f2fs_ioc_set_compress_option()
4360 return -EFAULT; in f2fs_ioc_set_compress_option()
4365 return -EINVAL; in f2fs_ioc_set_compress_option()
4372 f2fs_down_write(&F2FS_I(inode)->i_sem); in f2fs_ioc_set_compress_option()
4374 ret = -EINVAL; in f2fs_ioc_set_compress_option()
4379 ret = -EBUSY; in f2fs_ioc_set_compress_option()
4384 ret = -EFBIG; in f2fs_ioc_set_compress_option()
4388 fi->i_compress_algorithm = option.algorithm; in f2fs_ioc_set_compress_option()
4389 fi->i_log_cluster_size = option.log_cluster_size; in f2fs_ioc_set_compress_option()
4390 fi->i_cluster_size = BIT(option.log_cluster_size); in f2fs_ioc_set_compress_option()
4392 if (fi->i_compress_algorithm == COMPRESS_ZSTD) in f2fs_ioc_set_compress_option()
4393 fi->i_compress_level = F2FS_ZSTD_DEFAULT_CLEVEL; in f2fs_ioc_set_compress_option()
4395 fi->i_compress_level = 0; in f2fs_ioc_set_compress_option()
4399 fi->i_compress_level = F2FS_OPTION(sbi).compress_level; in f2fs_ioc_set_compress_option()
4406 f2fs_up_write(&fi->i_sem); in f2fs_ioc_set_compress_option()
4415 DEFINE_READAHEAD(ractl, NULL, NULL, inode->i_mapping, page_idx); in redirty_blocks()
4416 struct address_space *mapping = inode->i_mapping; in redirty_blocks()
4429 page_len += folio_nr_pages(folio) - (page_idx - folio->index); in redirty_blocks()
4461 return -EOPNOTSUPP; in f2fs_ioc_decompress_file()
4463 if (!(filp->f_mode & FMODE_WRITE)) in f2fs_ioc_decompress_file()
4464 return -EBADF; in f2fs_ioc_decompress_file()
4474 ret = -EOPNOTSUPP; in f2fs_ioc_decompress_file()
4480 ret = -EINVAL; in f2fs_ioc_decompress_file()
4484 ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX); in f2fs_ioc_decompress_file()
4488 if (!atomic_read(&fi->i_compr_blocks)) in f2fs_ioc_decompress_file()
4492 last_idx >>= fi->i_log_cluster_size; in f2fs_ioc_decompress_file()
4495 page_idx = cluster_idx << fi->i_log_cluster_size; in f2fs_ioc_decompress_file()
4500 ret = redirty_blocks(inode, page_idx, fi->i_cluster_size); in f2fs_ioc_decompress_file()
4505 ret = filemap_fdatawrite(inode->i_mapping); in f2fs_ioc_decompress_file()
4512 ret = -EINTR; in f2fs_ioc_decompress_file()
4518 ret = filemap_write_and_wait_range(inode->i_mapping, 0, in f2fs_ioc_decompress_file()
4542 return -EOPNOTSUPP; in f2fs_ioc_compress_file()
4544 if (!(filp->f_mode & FMODE_WRITE)) in f2fs_ioc_compress_file()
4545 return -EBADF; in f2fs_ioc_compress_file()
4555 ret = -EOPNOTSUPP; in f2fs_ioc_compress_file()
4561 ret = -EINVAL; in f2fs_ioc_compress_file()
4565 ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX); in f2fs_ioc_compress_file()
4572 last_idx >>= fi->i_log_cluster_size; in f2fs_ioc_compress_file()
4575 page_idx = cluster_idx << fi->i_log_cluster_size; in f2fs_ioc_compress_file()
4580 ret = redirty_blocks(inode, page_idx, fi->i_cluster_size); in f2fs_ioc_compress_file()
4585 ret = filemap_fdatawrite(inode->i_mapping); in f2fs_ioc_compress_file()
4592 ret = -EINTR; in f2fs_ioc_compress_file()
4598 ret = filemap_write_and_wait_range(inode->i_mapping, 0, in f2fs_ioc_compress_file()
4629 return -EOPNOTSUPP; in __f2fs_ioctl()
4705 return -ENOTTY; in __f2fs_ioctl()
4712 return -EIO; in f2fs_ioctl()
4714 return -ENOSPC; in f2fs_ioctl()
4721 * %false if it should use buffered I/O.
4728 if (!(iocb->ki_flags & IOCB_DIRECT)) in f2fs_should_use_dio()
4736 * attempted, but will fail with -EINVAL. in f2fs_should_use_dio()
4740 * However, f2fs traditionally falls back to buffered I/O on requests in f2fs_should_use_dio()
4741 * that are logical_block_size-aligned but not fs-block aligned. in f2fs_should_use_dio()
4745 align = iocb->ki_pos | iov_iter_alignment(iter); in f2fs_should_use_dio()
4747 IS_ALIGNED(align, bdev_logical_block_size(inode->i_sb->s_bdev))) in f2fs_should_use_dio()
4756 struct f2fs_sb_info *sbi = F2FS_I_SB(file_inode(iocb->ki_filp)); in f2fs_dio_read_end_io()
4771 struct file *file = iocb->ki_filp; in f2fs_dio_read_iter()
4775 const loff_t pos = iocb->ki_pos; in f2fs_dio_read_iter()
4785 if (iocb->ki_flags & IOCB_NOWAIT) { in f2fs_dio_read_iter()
4786 if (!f2fs_down_read_trylock(&fi->i_gc_rwsem[READ])) { in f2fs_dio_read_iter()
4787 ret = -EAGAIN; in f2fs_dio_read_iter()
4791 f2fs_down_read(&fi->i_gc_rwsem[READ]); in f2fs_dio_read_iter()
4796 f2fs_up_read(&fi->i_gc_rwsem[READ]); in f2fs_dio_read_iter()
4797 ret = -EOPNOTSUPP; in f2fs_dio_read_iter()
4803 * the higher-level function iomap_dio_rw() in order to ensure that the in f2fs_dio_read_iter()
4811 if (ret != -EIOCBQUEUED) in f2fs_dio_read_iter()
4817 f2fs_up_read(&fi->i_gc_rwsem[READ]); in f2fs_dio_read_iter()
4839 current->pid, path, current->comm); in f2fs_trace_rw_file_path()
4842 current->pid, path, current->comm); in f2fs_trace_rw_file_path()
4849 struct inode *inode = file_inode(iocb->ki_filp); in f2fs_file_read_iter()
4850 const loff_t pos = iocb->ki_pos; in f2fs_file_read_iter()
4855 return -EOPNOTSUPP; in f2fs_file_read_iter()
4858 f2fs_trace_rw_file_path(iocb->ki_filp, iocb->ki_pos, in f2fs_file_read_iter()
4890 return -EOPNOTSUPP; in f2fs_file_splice_read()
4906 struct file *file = iocb->ki_filp; in f2fs_write_checks()
4912 return -EPERM; in f2fs_write_checks()
4915 return -EPERM; in f2fs_write_checks()
4926 iocb->ki_pos + iov_iter_count(from), true); in f2fs_write_checks()
4932 * so. Returns a positive number if blocks may have been preallocated, 0 if no
4940 struct inode *inode = file_inode(iocb->ki_filp); in f2fs_preallocate_blocks()
4942 const loff_t pos = iocb->ki_pos; in f2fs_preallocate_blocks()
4948 /* If it will be an out-of-place direct write, don't bother. */ in f2fs_preallocate_blocks()
4953 * buffered IO, if DIO meets any holes. in f2fs_preallocate_blocks()
4959 /* No-wait I/O can't allocate blocks. */ in f2fs_preallocate_blocks()
4960 if (iocb->ki_flags & IOCB_NOWAIT) in f2fs_preallocate_blocks()
4980 map.m_len -= map.m_lblk; in f2fs_preallocate_blocks()
4988 inode->i_write_hint); in f2fs_preallocate_blocks()
4996 /* -ENOSPC|-EDQUOT are fine to report the number of allocated blocks. */ in f2fs_preallocate_blocks()
4997 if (ret < 0 && !((ret == -ENOSPC || ret == -EDQUOT) && map.m_len > 0)) in f2fs_preallocate_blocks()
5007 struct file *file = iocb->ki_filp; in f2fs_buffered_write_iter()
5011 if (iocb->ki_flags & IOCB_NOWAIT) in f2fs_buffered_write_iter()
5012 return -EOPNOTSUPP; in f2fs_buffered_write_iter()
5026 struct f2fs_sb_info *sbi = F2FS_I_SB(file_inode(iocb->ki_filp)); in f2fs_dio_write_end_io()
5039 struct inode *inode = iter->inode; in f2fs_dio_write_submit_io()
5041 enum log_type type = f2fs_rw_hint_to_seg_type(sbi, inode->i_write_hint); in f2fs_dio_write_submit_io()
5044 bio->bi_write_hint = f2fs_io_type_to_rw_hint(sbi, DATA, temp); in f2fs_dio_write_submit_io()
5069 struct file *file = iocb->ki_filp; in f2fs_dio_write_iter()
5074 const loff_t pos = iocb->ki_pos; in f2fs_dio_write_iter()
5082 if (iocb->ki_flags & IOCB_NOWAIT) { in f2fs_dio_write_iter()
5086 ret = -EAGAIN; in f2fs_dio_write_iter()
5090 if (!f2fs_down_read_trylock(&fi->i_gc_rwsem[WRITE])) { in f2fs_dio_write_iter()
5091 ret = -EAGAIN; in f2fs_dio_write_iter()
5094 if (do_opu && !f2fs_down_read_trylock(&fi->i_gc_rwsem[READ])) { in f2fs_dio_write_iter()
5095 f2fs_up_read(&fi->i_gc_rwsem[WRITE]); in f2fs_dio_write_iter()
5096 ret = -EAGAIN; in f2fs_dio_write_iter()
5104 f2fs_down_read(&fi->i_gc_rwsem[WRITE]); in f2fs_dio_write_iter()
5106 f2fs_down_read(&fi->i_gc_rwsem[READ]); in f2fs_dio_write_iter()
5111 * the higher-level function iomap_dio_rw() in order to ensure that the in f2fs_dio_write_iter()
5116 if (pos + count > inode->i_size) in f2fs_dio_write_iter()
5122 if (ret == -ENOTBLK) in f2fs_dio_write_iter()
5124 if (ret != -EIOCBQUEUED) in f2fs_dio_write_iter()
5131 f2fs_up_read(&fi->i_gc_rwsem[READ]); in f2fs_dio_write_iter()
5132 f2fs_up_read(&fi->i_gc_rwsem[WRITE]); in f2fs_dio_write_iter()
5136 if (pos + ret > inode->i_size) in f2fs_dio_write_iter()
5143 loff_t bufio_start_pos = iocb->ki_pos; in f2fs_dio_write_iter()
5147 * buffered write for the remainder. in f2fs_dio_write_iter()
5152 f2fs_write_failed(inode, iocb->ki_pos); in f2fs_dio_write_iter()
5161 loff_t bufio_end_pos = bufio_start_pos + ret2 - 1; in f2fs_dio_write_iter()
5165 f2fs_flush_buffered_write(file->f_mapping, in f2fs_dio_write_iter()
5180 struct inode *inode = file_inode(iocb->ki_filp); in f2fs_file_write_iter()
5181 const loff_t orig_pos = iocb->ki_pos; in f2fs_file_write_iter()
5187 const loff_t pos = iocb->ki_pos; in f2fs_file_write_iter()
5192 ret = -EIO; in f2fs_file_write_iter()
5197 ret = -EOPNOTSUPP; in f2fs_file_write_iter()
5201 if (iocb->ki_flags & IOCB_NOWAIT) { in f2fs_file_write_iter()
5203 ret = -EAGAIN; in f2fs_file_write_iter()
5212 ret = -EIO; in f2fs_file_write_iter()
5220 /* Determine whether we will do a direct write or a buffered write. */ in f2fs_file_write_iter()
5225 ret = -EOPNOTSUPP; in f2fs_file_write_iter()
5230 target_size = iocb->ki_pos + iov_iter_count(from); in f2fs_file_write_iter()
5236 f2fs_trace_rw_file_path(iocb->ki_filp, iocb->ki_pos, in f2fs_file_write_iter()
5249 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_file_write_iter()
5250 filemap_invalidate_lock(inode->i_mapping); in f2fs_file_write_iter()
5253 filemap_invalidate_unlock(inode->i_mapping); in f2fs_file_write_iter()
5254 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_file_write_iter()
5268 /* If buffered IO was forced, flush and drop the data from in f2fs_file_write_iter()
5271 if (ret > 0 && !dio && (iocb->ki_flags & IOCB_DIRECT)) in f2fs_file_write_iter()
5272 f2fs_flush_buffered_write(iocb->ki_filp->f_mapping, in f2fs_file_write_iter()
5274 orig_pos + ret - 1); in f2fs_file_write_iter()
5288 if (S_ISFIFO(inode->i_mode)) in f2fs_file_fadvise()
5289 return -ESPIPE; in f2fs_file_fadvise()
5291 mapping = filp->f_mapping; in f2fs_file_fadvise()
5293 return -EINVAL; in f2fs_file_fadvise()
5295 bdi = inode_to_bdi(mapping->host); in f2fs_file_fadvise()
5296 filp->f_ra.ra_pages = bdi->ra_pages * in f2fs_file_fadvise()
5297 F2FS_I_SB(inode)->seq_file_ra_mul; in f2fs_file_fadvise()
5298 spin_lock(&filp->f_lock); in f2fs_file_fadvise()
5299 filp->f_mode &= ~FMODE_RANDOM; in f2fs_file_fadvise()
5300 spin_unlock(&filp->f_lock); in f2fs_file_fadvise()
5314 f2fs_invalidate_compress_pages(F2FS_I_SB(inode), inode->i_ino); in f2fs_file_fadvise()
5336 err = get_user(range.sync, &urange->sync); in f2fs_compat_ioc_gc_range()
5337 err |= get_user(range.start, &urange->start); in f2fs_compat_ioc_gc_range()
5338 err |= get_user(range.len, &urange->len); in f2fs_compat_ioc_gc_range()
5340 return -EFAULT; in f2fs_compat_ioc_gc_range()
5361 err = get_user(range.dst_fd, &urange->dst_fd); in f2fs_compat_ioc_move_range()
5362 err |= get_user(range.pos_in, &urange->pos_in); in f2fs_compat_ioc_move_range()
5363 err |= get_user(range.pos_out, &urange->pos_out); in f2fs_compat_ioc_move_range()
5364 err |= get_user(range.len, &urange->len); in f2fs_compat_ioc_move_range()
5366 return -EFAULT; in f2fs_compat_ioc_move_range()
5374 return -EIO; in f2fs_compat_ioctl()
5376 return -ENOSPC; in f2fs_compat_ioctl()
5429 return -ENOIOCTLCMD; in f2fs_compat_ioctl()