file.c (1d1df41c5a33359a00e919d54eaebfb789711fdc) file.c (e4544b63a7ee49e7fbebf35ece0a6acd3b9617ae)
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>

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

232 return ret;
233}
234
235static void try_to_fix_pino(struct inode *inode)
236{
237 struct f2fs_inode_info *fi = F2FS_I(inode);
238 nid_t pino;
239
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>

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

232 return ret;
233}
234
235static void try_to_fix_pino(struct inode *inode)
236{
237 struct f2fs_inode_info *fi = F2FS_I(inode);
238 nid_t pino;
239
240 down_write(&fi->i_sem);
240 f2fs_down_write(&fi->i_sem);
241 if (file_wrong_pino(inode) && inode->i_nlink == 1 &&
242 get_parent_ino(inode, &pino)) {
243 f2fs_i_pino_write(inode, pino);
244 file_got_pino(inode);
245 }
241 if (file_wrong_pino(inode) && inode->i_nlink == 1 &&
242 get_parent_ino(inode, &pino)) {
243 f2fs_i_pino_write(inode, pino);
244 file_got_pino(inode);
245 }
246 up_write(&fi->i_sem);
246 f2fs_up_write(&fi->i_sem);
247}
248
249static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end,
250 int datasync, bool atomic)
251{
252 struct inode *inode = file->f_mapping->host;
253 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
254 nid_t ino = inode->i_ino;

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

313 FSYNC_MODE_STRICT && !atomic)
314 atomic = true;
315 }
316go_write:
317 /*
318 * Both of fdatasync() and fsync() are able to be recovered from
319 * sudden-power-off.
320 */
247}
248
249static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end,
250 int datasync, bool atomic)
251{
252 struct inode *inode = file->f_mapping->host;
253 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
254 nid_t ino = inode->i_ino;

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

313 FSYNC_MODE_STRICT && !atomic)
314 atomic = true;
315 }
316go_write:
317 /*
318 * Both of fdatasync() and fsync() are able to be recovered from
319 * sudden-power-off.
320 */
321 down_read(&F2FS_I(inode)->i_sem);
321 f2fs_down_read(&F2FS_I(inode)->i_sem);
322 cp_reason = need_do_checkpoint(inode);
322 cp_reason = need_do_checkpoint(inode);
323 up_read(&F2FS_I(inode)->i_sem);
323 f2fs_up_read(&F2FS_I(inode)->i_sem);
324
325 if (cp_reason) {
326 /* all the dirty node pages should be flushed for POR */
327 ret = f2fs_sync_fs(inode->i_sb, 1);
328
329 /*
330 * We've secured consistency through sync_fs. Following pino
331 * will be used only for fsynced inodes after checkpoint.

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

953 * should convert inline inode before i_size_write to
954 * keep smaller than inline_data size with inline flag.
955 */
956 err = f2fs_convert_inline_inode(inode);
957 if (err)
958 return err;
959 }
960
324
325 if (cp_reason) {
326 /* all the dirty node pages should be flushed for POR */
327 ret = f2fs_sync_fs(inode->i_sb, 1);
328
329 /*
330 * We've secured consistency through sync_fs. Following pino
331 * will be used only for fsynced inodes after checkpoint.

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

953 * should convert inline inode before i_size_write to
954 * keep smaller than inline_data size with inline flag.
955 */
956 err = f2fs_convert_inline_inode(inode);
957 if (err)
958 return err;
959 }
960
961 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
961 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
962 filemap_invalidate_lock(inode->i_mapping);
963
964 truncate_setsize(inode, attr->ia_size);
965
966 if (attr->ia_size <= old_size)
967 err = f2fs_truncate(inode);
968 /*
969 * do not trim all blocks after i_size if target size is
970 * larger than i_size.
971 */
972 filemap_invalidate_unlock(inode->i_mapping);
962 filemap_invalidate_lock(inode->i_mapping);
963
964 truncate_setsize(inode, attr->ia_size);
965
966 if (attr->ia_size <= old_size)
967 err = f2fs_truncate(inode);
968 /*
969 * do not trim all blocks after i_size if target size is
970 * larger than i_size.
971 */
972 filemap_invalidate_unlock(inode->i_mapping);
973 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
973 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
974 if (err)
975 return err;
976
977 spin_lock(&F2FS_I(inode)->i_size_lock);
978 inode->i_mtime = inode->i_ctime = current_time(inode);
979 F2FS_I(inode)->last_disk_size = i_size_read(inode);
980 spin_unlock(&F2FS_I(inode)->i_size_lock);
981 }

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

1107 loff_t blk_start, blk_end;
1108 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1109
1110 f2fs_balance_fs(sbi, true);
1111
1112 blk_start = (loff_t)pg_start << PAGE_SHIFT;
1113 blk_end = (loff_t)pg_end << PAGE_SHIFT;
1114
974 if (err)
975 return err;
976
977 spin_lock(&F2FS_I(inode)->i_size_lock);
978 inode->i_mtime = inode->i_ctime = current_time(inode);
979 F2FS_I(inode)->last_disk_size = i_size_read(inode);
980 spin_unlock(&F2FS_I(inode)->i_size_lock);
981 }

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

1107 loff_t blk_start, blk_end;
1108 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1109
1110 f2fs_balance_fs(sbi, true);
1111
1112 blk_start = (loff_t)pg_start << PAGE_SHIFT;
1113 blk_end = (loff_t)pg_end << PAGE_SHIFT;
1114
1115 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1115 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1116 filemap_invalidate_lock(inode->i_mapping);
1117
1118 truncate_pagecache_range(inode, blk_start, blk_end - 1);
1119
1120 f2fs_lock_op(sbi);
1121 ret = f2fs_truncate_hole(inode, pg_start, pg_end);
1122 f2fs_unlock_op(sbi);
1123
1124 filemap_invalidate_unlock(inode->i_mapping);
1116 filemap_invalidate_lock(inode->i_mapping);
1117
1118 truncate_pagecache_range(inode, blk_start, blk_end - 1);
1119
1120 f2fs_lock_op(sbi);
1121 ret = f2fs_truncate_hole(inode, pg_start, pg_end);
1122 f2fs_unlock_op(sbi);
1123
1124 filemap_invalidate_unlock(inode->i_mapping);
1125 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1125 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1126 }
1127 }
1128
1129 return ret;
1130}
1131
1132static int __read_out_blkaddrs(struct inode *inode, block_t *blkaddr,
1133 int *do_replace, pgoff_t off, pgoff_t len)

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

1350 pgoff_t nrpages = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
1351 pgoff_t start = offset >> PAGE_SHIFT;
1352 pgoff_t end = (offset + len) >> PAGE_SHIFT;
1353 int ret;
1354
1355 f2fs_balance_fs(sbi, true);
1356
1357 /* avoid gc operation during block exchange */
1126 }
1127 }
1128
1129 return ret;
1130}
1131
1132static int __read_out_blkaddrs(struct inode *inode, block_t *blkaddr,
1133 int *do_replace, pgoff_t off, pgoff_t len)

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

1350 pgoff_t nrpages = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
1351 pgoff_t start = offset >> PAGE_SHIFT;
1352 pgoff_t end = (offset + len) >> PAGE_SHIFT;
1353 int ret;
1354
1355 f2fs_balance_fs(sbi, true);
1356
1357 /* avoid gc operation during block exchange */
1358 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1358 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1359 filemap_invalidate_lock(inode->i_mapping);
1360
1361 f2fs_lock_op(sbi);
1362 f2fs_drop_extent_tree(inode);
1363 truncate_pagecache(inode, offset);
1364 ret = __exchange_data_block(inode, inode, end, start, nrpages - end, true);
1365 f2fs_unlock_op(sbi);
1366
1367 filemap_invalidate_unlock(inode->i_mapping);
1359 filemap_invalidate_lock(inode->i_mapping);
1360
1361 f2fs_lock_op(sbi);
1362 f2fs_drop_extent_tree(inode);
1363 truncate_pagecache(inode, offset);
1364 ret = __exchange_data_block(inode, inode, end, start, nrpages - end, true);
1365 f2fs_unlock_op(sbi);
1366
1367 filemap_invalidate_unlock(inode->i_mapping);
1368 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1368 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1369 return ret;
1370}
1371
1372static int f2fs_collapse_range(struct inode *inode, loff_t offset, loff_t len)
1373{
1374 loff_t new_size;
1375 int ret;
1376

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

1495 (loff_t)pg_start << PAGE_SHIFT);
1496 }
1497
1498 for (index = pg_start; index < pg_end;) {
1499 struct dnode_of_data dn;
1500 unsigned int end_offset;
1501 pgoff_t end;
1502
1369 return ret;
1370}
1371
1372static int f2fs_collapse_range(struct inode *inode, loff_t offset, loff_t len)
1373{
1374 loff_t new_size;
1375 int ret;
1376

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

1495 (loff_t)pg_start << PAGE_SHIFT);
1496 }
1497
1498 for (index = pg_start; index < pg_end;) {
1499 struct dnode_of_data dn;
1500 unsigned int end_offset;
1501 pgoff_t end;
1502
1503 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1503 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1504 filemap_invalidate_lock(mapping);
1505
1506 truncate_pagecache_range(inode,
1507 (loff_t)index << PAGE_SHIFT,
1508 ((loff_t)pg_end << PAGE_SHIFT) - 1);
1509
1510 f2fs_lock_op(sbi);
1511
1512 set_new_dnode(&dn, inode, NULL, NULL, 0);
1513 ret = f2fs_get_dnode_of_data(&dn, index, ALLOC_NODE);
1514 if (ret) {
1515 f2fs_unlock_op(sbi);
1516 filemap_invalidate_unlock(mapping);
1504 filemap_invalidate_lock(mapping);
1505
1506 truncate_pagecache_range(inode,
1507 (loff_t)index << PAGE_SHIFT,
1508 ((loff_t)pg_end << PAGE_SHIFT) - 1);
1509
1510 f2fs_lock_op(sbi);
1511
1512 set_new_dnode(&dn, inode, NULL, NULL, 0);
1513 ret = f2fs_get_dnode_of_data(&dn, index, ALLOC_NODE);
1514 if (ret) {
1515 f2fs_unlock_op(sbi);
1516 filemap_invalidate_unlock(mapping);
1517 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1517 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1518 goto out;
1519 }
1520
1521 end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
1522 end = min(pg_end, end_offset - dn.ofs_in_node + index);
1523
1524 ret = f2fs_do_zero_range(&dn, index, end);
1525 f2fs_put_dnode(&dn);
1526
1527 f2fs_unlock_op(sbi);
1528 filemap_invalidate_unlock(mapping);
1518 goto out;
1519 }
1520
1521 end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
1522 end = min(pg_end, end_offset - dn.ofs_in_node + index);
1523
1524 ret = f2fs_do_zero_range(&dn, index, end);
1525 f2fs_put_dnode(&dn);
1526
1527 f2fs_unlock_op(sbi);
1528 filemap_invalidate_unlock(mapping);
1529 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1529 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1530
1531 f2fs_balance_fs(sbi, dn.node_changed);
1532
1533 if (ret)
1534 goto out;
1535
1536 index = end;
1537 new_size = max_t(loff_t, new_size,

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

1595 return ret;
1596
1597 pg_start = offset >> PAGE_SHIFT;
1598 pg_end = (offset + len) >> PAGE_SHIFT;
1599 delta = pg_end - pg_start;
1600 idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
1601
1602 /* avoid gc operation during block exchange */
1530
1531 f2fs_balance_fs(sbi, dn.node_changed);
1532
1533 if (ret)
1534 goto out;
1535
1536 index = end;
1537 new_size = max_t(loff_t, new_size,

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

1595 return ret;
1596
1597 pg_start = offset >> PAGE_SHIFT;
1598 pg_end = (offset + len) >> PAGE_SHIFT;
1599 delta = pg_end - pg_start;
1600 idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
1601
1602 /* avoid gc operation during block exchange */
1603 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1603 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1604 filemap_invalidate_lock(mapping);
1605 truncate_pagecache(inode, offset);
1606
1607 while (!ret && idx > pg_start) {
1608 nr = idx - pg_start;
1609 if (nr > delta)
1610 nr = delta;
1611 idx -= nr;
1612
1613 f2fs_lock_op(sbi);
1614 f2fs_drop_extent_tree(inode);
1615
1616 ret = __exchange_data_block(inode, inode, idx,
1617 idx + delta, nr, false);
1618 f2fs_unlock_op(sbi);
1619 }
1620 filemap_invalidate_unlock(mapping);
1604 filemap_invalidate_lock(mapping);
1605 truncate_pagecache(inode, offset);
1606
1607 while (!ret && idx > pg_start) {
1608 nr = idx - pg_start;
1609 if (nr > delta)
1610 nr = delta;
1611 idx -= nr;
1612
1613 f2fs_lock_op(sbi);
1614 f2fs_drop_extent_tree(inode);
1615
1616 ret = __exchange_data_block(inode, inode, idx,
1617 idx + delta, nr, false);
1618 f2fs_unlock_op(sbi);
1619 }
1620 filemap_invalidate_unlock(mapping);
1621 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1621 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1622
1623 /* write out all moved pages, if possible */
1624 filemap_invalidate_lock(mapping);
1625 filemap_write_and_wait_range(mapping, offset, LLONG_MAX);
1626 truncate_pagecache(inode, offset);
1627 filemap_invalidate_unlock(mapping);
1628
1629 if (!ret)

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

1669 if (f2fs_is_pinned_file(inode)) {
1670 block_t sec_blks = BLKS_PER_SEC(sbi);
1671 block_t sec_len = roundup(map.m_len, sec_blks);
1672
1673 map.m_len = sec_blks;
1674next_alloc:
1675 if (has_not_enough_free_secs(sbi, 0,
1676 GET_SEC_FROM_SEG(sbi, overprovision_segments(sbi)))) {
1622
1623 /* write out all moved pages, if possible */
1624 filemap_invalidate_lock(mapping);
1625 filemap_write_and_wait_range(mapping, offset, LLONG_MAX);
1626 truncate_pagecache(inode, offset);
1627 filemap_invalidate_unlock(mapping);
1628
1629 if (!ret)

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

1669 if (f2fs_is_pinned_file(inode)) {
1670 block_t sec_blks = BLKS_PER_SEC(sbi);
1671 block_t sec_len = roundup(map.m_len, sec_blks);
1672
1673 map.m_len = sec_blks;
1674next_alloc:
1675 if (has_not_enough_free_secs(sbi, 0,
1676 GET_SEC_FROM_SEG(sbi, overprovision_segments(sbi)))) {
1677 down_write(&sbi->gc_lock);
1677 f2fs_down_write(&sbi->gc_lock);
1678 err = f2fs_gc(sbi, true, false, false, NULL_SEGNO);
1679 if (err && err != -ENODATA && err != -EAGAIN)
1680 goto out_err;
1681 }
1682
1678 err = f2fs_gc(sbi, true, false, false, NULL_SEGNO);
1679 if (err && err != -ENODATA && err != -EAGAIN)
1680 goto out_err;
1681 }
1682
1683 down_write(&sbi->pin_sem);
1683 f2fs_down_write(&sbi->pin_sem);
1684
1685 f2fs_lock_op(sbi);
1686 f2fs_allocate_new_section(sbi, CURSEG_COLD_DATA_PINNED, false);
1687 f2fs_unlock_op(sbi);
1688
1689 map.m_seg_type = CURSEG_COLD_DATA_PINNED;
1690 err = f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_DIO);
1691 file_dont_truncate(inode);
1692
1684
1685 f2fs_lock_op(sbi);
1686 f2fs_allocate_new_section(sbi, CURSEG_COLD_DATA_PINNED, false);
1687 f2fs_unlock_op(sbi);
1688
1689 map.m_seg_type = CURSEG_COLD_DATA_PINNED;
1690 err = f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_DIO);
1691 file_dont_truncate(inode);
1692
1693 up_write(&sbi->pin_sem);
1693 f2fs_up_write(&sbi->pin_sem);
1694
1695 expanded += map.m_len;
1696 sec_len -= map.m_len;
1697 map.m_lblk += map.m_len;
1698 if (!err && sec_len)
1699 goto next_alloc;
1700
1701 map.m_len = expanded;

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

2015 ret = -EINVAL;
2016 goto out;
2017 }
2018
2019 ret = f2fs_convert_inline_inode(inode);
2020 if (ret)
2021 goto out;
2022
1694
1695 expanded += map.m_len;
1696 sec_len -= map.m_len;
1697 map.m_lblk += map.m_len;
1698 if (!err && sec_len)
1699 goto next_alloc;
1700
1701 map.m_len = expanded;

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

2015 ret = -EINVAL;
2016 goto out;
2017 }
2018
2019 ret = f2fs_convert_inline_inode(inode);
2020 if (ret)
2021 goto out;
2022
2023 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
2023 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
2024
2025 /*
2026 * Should wait end_io to count F2FS_WB_CP_DATA correctly by
2027 * f2fs_is_atomic_file.
2028 */
2029 if (get_dirty_pages(inode))
2030 f2fs_warn(F2FS_I_SB(inode), "Unexpected flush for atomic writes: ino=%lu, npages=%u",
2031 inode->i_ino, get_dirty_pages(inode));
2032 ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
2033 if (ret) {
2024
2025 /*
2026 * Should wait end_io to count F2FS_WB_CP_DATA correctly by
2027 * f2fs_is_atomic_file.
2028 */
2029 if (get_dirty_pages(inode))
2030 f2fs_warn(F2FS_I_SB(inode), "Unexpected flush for atomic writes: ino=%lu, npages=%u",
2031 inode->i_ino, get_dirty_pages(inode));
2032 ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
2033 if (ret) {
2034 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
2034 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
2035 goto out;
2036 }
2037
2038 spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
2039 if (list_empty(&fi->inmem_ilist))
2040 list_add_tail(&fi->inmem_ilist, &sbi->inode_list[ATOMIC_FILE]);
2041 sbi->atomic_files++;
2042 spin_unlock(&sbi->inode_lock[ATOMIC_FILE]);
2043
2044 /* add inode in inmem_list first and set atomic_file */
2045 set_inode_flag(inode, FI_ATOMIC_FILE);
2046 clear_inode_flag(inode, FI_ATOMIC_REVOKE_REQUEST);
2035 goto out;
2036 }
2037
2038 spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
2039 if (list_empty(&fi->inmem_ilist))
2040 list_add_tail(&fi->inmem_ilist, &sbi->inode_list[ATOMIC_FILE]);
2041 sbi->atomic_files++;
2042 spin_unlock(&sbi->inode_lock[ATOMIC_FILE]);
2043
2044 /* add inode in inmem_list first and set atomic_file */
2045 set_inode_flag(inode, FI_ATOMIC_FILE);
2046 clear_inode_flag(inode, FI_ATOMIC_REVOKE_REQUEST);
2047 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
2047 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
2048
2049 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
2050 F2FS_I(inode)->inmem_task = current;
2051 stat_update_max_atomic_write(inode);
2052out:
2053 inode_unlock(inode);
2054 mnt_drop_write_file(filp);
2055 return ret;

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

2346
2347 if (!f2fs_sb_has_encrypt(sbi))
2348 return -EOPNOTSUPP;
2349
2350 err = mnt_want_write_file(filp);
2351 if (err)
2352 return err;
2353
2048
2049 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
2050 F2FS_I(inode)->inmem_task = current;
2051 stat_update_max_atomic_write(inode);
2052out:
2053 inode_unlock(inode);
2054 mnt_drop_write_file(filp);
2055 return ret;

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

2346
2347 if (!f2fs_sb_has_encrypt(sbi))
2348 return -EOPNOTSUPP;
2349
2350 err = mnt_want_write_file(filp);
2351 if (err)
2352 return err;
2353
2354 down_write(&sbi->sb_lock);
2354 f2fs_down_write(&sbi->sb_lock);
2355
2356 if (uuid_is_nonzero(sbi->raw_super->encrypt_pw_salt))
2357 goto got_it;
2358
2359 /* update superblock with uuid */
2360 generate_random_uuid(sbi->raw_super->encrypt_pw_salt);
2361
2362 err = f2fs_commit_super(sbi, false);
2363 if (err) {
2364 /* undo new data */
2365 memset(sbi->raw_super->encrypt_pw_salt, 0, 16);
2366 goto out_err;
2367 }
2368got_it:
2369 if (copy_to_user((__u8 __user *)arg, sbi->raw_super->encrypt_pw_salt,
2370 16))
2371 err = -EFAULT;
2372out_err:
2355
2356 if (uuid_is_nonzero(sbi->raw_super->encrypt_pw_salt))
2357 goto got_it;
2358
2359 /* update superblock with uuid */
2360 generate_random_uuid(sbi->raw_super->encrypt_pw_salt);
2361
2362 err = f2fs_commit_super(sbi, false);
2363 if (err) {
2364 /* undo new data */
2365 memset(sbi->raw_super->encrypt_pw_salt, 0, 16);
2366 goto out_err;
2367 }
2368got_it:
2369 if (copy_to_user((__u8 __user *)arg, sbi->raw_super->encrypt_pw_salt,
2370 16))
2371 err = -EFAULT;
2372out_err:
2373 up_write(&sbi->sb_lock);
2373 f2fs_up_write(&sbi->sb_lock);
2374 mnt_drop_write_file(filp);
2375 return err;
2376}
2377
2378static int f2fs_ioc_get_encryption_policy_ex(struct file *filp,
2379 unsigned long arg)
2380{
2381 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))

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

2442 if (f2fs_readonly(sbi->sb))
2443 return -EROFS;
2444
2445 ret = mnt_want_write_file(filp);
2446 if (ret)
2447 return ret;
2448
2449 if (!sync) {
2374 mnt_drop_write_file(filp);
2375 return err;
2376}
2377
2378static int f2fs_ioc_get_encryption_policy_ex(struct file *filp,
2379 unsigned long arg)
2380{
2381 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))

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

2442 if (f2fs_readonly(sbi->sb))
2443 return -EROFS;
2444
2445 ret = mnt_want_write_file(filp);
2446 if (ret)
2447 return ret;
2448
2449 if (!sync) {
2450 if (!down_write_trylock(&sbi->gc_lock)) {
2450 if (!f2fs_down_write_trylock(&sbi->gc_lock)) {
2451 ret = -EBUSY;
2452 goto out;
2453 }
2454 } else {
2451 ret = -EBUSY;
2452 goto out;
2453 }
2454 } else {
2455 down_write(&sbi->gc_lock);
2455 f2fs_down_write(&sbi->gc_lock);
2456 }
2457
2458 ret = f2fs_gc(sbi, sync, true, false, NULL_SEGNO);
2459out:
2460 mnt_drop_write_file(filp);
2461 return ret;
2462}
2463

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

2478 return -EINVAL;
2479
2480 ret = mnt_want_write_file(filp);
2481 if (ret)
2482 return ret;
2483
2484do_more:
2485 if (!range->sync) {
2456 }
2457
2458 ret = f2fs_gc(sbi, sync, true, false, NULL_SEGNO);
2459out:
2460 mnt_drop_write_file(filp);
2461 return ret;
2462}
2463

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

2478 return -EINVAL;
2479
2480 ret = mnt_want_write_file(filp);
2481 if (ret)
2482 return ret;
2483
2484do_more:
2485 if (!range->sync) {
2486 if (!down_write_trylock(&sbi->gc_lock)) {
2486 if (!f2fs_down_write_trylock(&sbi->gc_lock)) {
2487 ret = -EBUSY;
2488 goto out;
2489 }
2490 } else {
2487 ret = -EBUSY;
2488 goto out;
2489 }
2490 } else {
2491 down_write(&sbi->gc_lock);
2491 f2fs_down_write(&sbi->gc_lock);
2492 }
2493
2494 ret = f2fs_gc(sbi, range->sync, true, false,
2495 GET_SEGNO(sbi, range->start));
2496 if (ret) {
2497 if (ret == -EBUSY)
2498 ret = -EAGAIN;
2499 goto out;

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

2815
2816 ret = filemap_write_and_wait_range(dst->i_mapping,
2817 pos_out, pos_out + len);
2818 if (ret)
2819 goto out_unlock;
2820
2821 f2fs_balance_fs(sbi, true);
2822
2492 }
2493
2494 ret = f2fs_gc(sbi, range->sync, true, false,
2495 GET_SEGNO(sbi, range->start));
2496 if (ret) {
2497 if (ret == -EBUSY)
2498 ret = -EAGAIN;
2499 goto out;

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

2815
2816 ret = filemap_write_and_wait_range(dst->i_mapping,
2817 pos_out, pos_out + len);
2818 if (ret)
2819 goto out_unlock;
2820
2821 f2fs_balance_fs(sbi, true);
2822
2823 down_write(&F2FS_I(src)->i_gc_rwsem[WRITE]);
2823 f2fs_down_write(&F2FS_I(src)->i_gc_rwsem[WRITE]);
2824 if (src != dst) {
2825 ret = -EBUSY;
2824 if (src != dst) {
2825 ret = -EBUSY;
2826 if (!down_write_trylock(&F2FS_I(dst)->i_gc_rwsem[WRITE]))
2826 if (!f2fs_down_write_trylock(&F2FS_I(dst)->i_gc_rwsem[WRITE]))
2827 goto out_src;
2828 }
2829
2830 f2fs_lock_op(sbi);
2831 ret = __exchange_data_block(src, dst, pos_in >> F2FS_BLKSIZE_BITS,
2832 pos_out >> F2FS_BLKSIZE_BITS,
2833 len >> F2FS_BLKSIZE_BITS, false);
2834
2835 if (!ret) {
2836 if (dst_max_i_size)
2837 f2fs_i_size_write(dst, dst_max_i_size);
2838 else if (dst_osize != dst->i_size)
2839 f2fs_i_size_write(dst, dst_osize);
2840 }
2841 f2fs_unlock_op(sbi);
2842
2843 if (src != dst)
2827 goto out_src;
2828 }
2829
2830 f2fs_lock_op(sbi);
2831 ret = __exchange_data_block(src, dst, pos_in >> F2FS_BLKSIZE_BITS,
2832 pos_out >> F2FS_BLKSIZE_BITS,
2833 len >> F2FS_BLKSIZE_BITS, false);
2834
2835 if (!ret) {
2836 if (dst_max_i_size)
2837 f2fs_i_size_write(dst, dst_max_i_size);
2838 else if (dst_osize != dst->i_size)
2839 f2fs_i_size_write(dst, dst_osize);
2840 }
2841 f2fs_unlock_op(sbi);
2842
2843 if (src != dst)
2844 up_write(&F2FS_I(dst)->i_gc_rwsem[WRITE]);
2844 f2fs_up_write(&F2FS_I(dst)->i_gc_rwsem[WRITE]);
2845out_src:
2845out_src:
2846 up_write(&F2FS_I(src)->i_gc_rwsem[WRITE]);
2846 f2fs_up_write(&F2FS_I(src)->i_gc_rwsem[WRITE]);
2847out_unlock:
2848 if (src != dst)
2849 inode_unlock(dst);
2850out:
2851 inode_unlock(src);
2852 return ret;
2853}
2854

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

2933 dev_end_segno = GET_SEGNO(sbi, FDEV(range.dev_num).end_blk);
2934
2935 start_segno = sm->last_victim[FLUSH_DEVICE];
2936 if (start_segno < dev_start_segno || start_segno >= dev_end_segno)
2937 start_segno = dev_start_segno;
2938 end_segno = min(start_segno + range.segments, dev_end_segno);
2939
2940 while (start_segno < end_segno) {
2847out_unlock:
2848 if (src != dst)
2849 inode_unlock(dst);
2850out:
2851 inode_unlock(src);
2852 return ret;
2853}
2854

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

2933 dev_end_segno = GET_SEGNO(sbi, FDEV(range.dev_num).end_blk);
2934
2935 start_segno = sm->last_victim[FLUSH_DEVICE];
2936 if (start_segno < dev_start_segno || start_segno >= dev_end_segno)
2937 start_segno = dev_start_segno;
2938 end_segno = min(start_segno + range.segments, dev_end_segno);
2939
2940 while (start_segno < end_segno) {
2941 if (!down_write_trylock(&sbi->gc_lock)) {
2941 if (!f2fs_down_write_trylock(&sbi->gc_lock)) {
2942 ret = -EBUSY;
2943 goto out;
2944 }
2945 sm->last_victim[GC_CB] = end_segno + 1;
2946 sm->last_victim[GC_GREEDY] = end_segno + 1;
2947 sm->last_victim[ALLOC_NEXT] = end_segno + 1;
2948 ret = f2fs_gc(sbi, true, true, true, start_segno);
2949 if (ret == -EAGAIN)

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

3210 map.m_next_extent = &m_next_extent;
3211 map.m_seg_type = NO_CHECK_TYPE;
3212 map.m_may_create = false;
3213 end = max_file_blocks(inode);
3214
3215 while (map.m_lblk < end) {
3216 map.m_len = end - map.m_lblk;
3217
2942 ret = -EBUSY;
2943 goto out;
2944 }
2945 sm->last_victim[GC_CB] = end_segno + 1;
2946 sm->last_victim[GC_GREEDY] = end_segno + 1;
2947 sm->last_victim[ALLOC_NEXT] = end_segno + 1;
2948 ret = f2fs_gc(sbi, true, true, true, start_segno);
2949 if (ret == -EAGAIN)

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

3210 map.m_next_extent = &m_next_extent;
3211 map.m_seg_type = NO_CHECK_TYPE;
3212 map.m_may_create = false;
3213 end = max_file_blocks(inode);
3214
3215 while (map.m_lblk < end) {
3216 map.m_len = end - map.m_lblk;
3217
3218 down_write(&fi->i_gc_rwsem[WRITE]);
3218 f2fs_down_write(&fi->i_gc_rwsem[WRITE]);
3219 err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_PRECACHE);
3219 err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_PRECACHE);
3220 up_write(&fi->i_gc_rwsem[WRITE]);
3220 f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
3221 if (err)
3222 return err;
3223
3224 map.m_lblk = m_next_extent;
3225 }
3226
3227 return 0;
3228}

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

3289 char *vbuf;
3290 int count;
3291 int err = 0;
3292
3293 vbuf = f2fs_kzalloc(sbi, MAX_VOLUME_NAME, GFP_KERNEL);
3294 if (!vbuf)
3295 return -ENOMEM;
3296
3221 if (err)
3222 return err;
3223
3224 map.m_lblk = m_next_extent;
3225 }
3226
3227 return 0;
3228}

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

3289 char *vbuf;
3290 int count;
3291 int err = 0;
3292
3293 vbuf = f2fs_kzalloc(sbi, MAX_VOLUME_NAME, GFP_KERNEL);
3294 if (!vbuf)
3295 return -ENOMEM;
3296
3297 down_read(&sbi->sb_lock);
3297 f2fs_down_read(&sbi->sb_lock);
3298 count = utf16s_to_utf8s(sbi->raw_super->volume_name,
3299 ARRAY_SIZE(sbi->raw_super->volume_name),
3300 UTF16_LITTLE_ENDIAN, vbuf, MAX_VOLUME_NAME);
3298 count = utf16s_to_utf8s(sbi->raw_super->volume_name,
3299 ARRAY_SIZE(sbi->raw_super->volume_name),
3300 UTF16_LITTLE_ENDIAN, vbuf, MAX_VOLUME_NAME);
3301 up_read(&sbi->sb_lock);
3301 f2fs_up_read(&sbi->sb_lock);
3302
3303 if (copy_to_user((char __user *)arg, vbuf,
3304 min(FSLABEL_MAX, count)))
3305 err = -EFAULT;
3306
3307 kfree(vbuf);
3308 return err;
3309}

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

3321 vbuf = strndup_user((const char __user *)arg, FSLABEL_MAX);
3322 if (IS_ERR(vbuf))
3323 return PTR_ERR(vbuf);
3324
3325 err = mnt_want_write_file(filp);
3326 if (err)
3327 goto out;
3328
3302
3303 if (copy_to_user((char __user *)arg, vbuf,
3304 min(FSLABEL_MAX, count)))
3305 err = -EFAULT;
3306
3307 kfree(vbuf);
3308 return err;
3309}

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

3321 vbuf = strndup_user((const char __user *)arg, FSLABEL_MAX);
3322 if (IS_ERR(vbuf))
3323 return PTR_ERR(vbuf);
3324
3325 err = mnt_want_write_file(filp);
3326 if (err)
3327 goto out;
3328
3329 down_write(&sbi->sb_lock);
3329 f2fs_down_write(&sbi->sb_lock);
3330
3331 memset(sbi->raw_super->volume_name, 0,
3332 sizeof(sbi->raw_super->volume_name));
3333 utf8s_to_utf16s(vbuf, strlen(vbuf), UTF16_LITTLE_ENDIAN,
3334 sbi->raw_super->volume_name,
3335 ARRAY_SIZE(sbi->raw_super->volume_name));
3336
3337 err = f2fs_commit_super(sbi, false);
3338
3330
3331 memset(sbi->raw_super->volume_name, 0,
3332 sizeof(sbi->raw_super->volume_name));
3333 utf8s_to_utf16s(vbuf, strlen(vbuf), UTF16_LITTLE_ENDIAN,
3334 sbi->raw_super->volume_name,
3335 ARRAY_SIZE(sbi->raw_super->volume_name));
3336
3337 err = f2fs_commit_super(sbi, false);
3338
3339 up_write(&sbi->sb_lock);
3339 f2fs_up_write(&sbi->sb_lock);
3340
3341 mnt_drop_write_file(filp);
3342out:
3343 kfree(vbuf);
3344 return err;
3345}
3346
3347static int f2fs_get_compress_blocks(struct file *filp, unsigned long arg)

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

3457
3458 set_inode_flag(inode, FI_COMPRESS_RELEASED);
3459 inode->i_ctime = current_time(inode);
3460 f2fs_mark_inode_dirty_sync(inode, true);
3461
3462 if (!atomic_read(&F2FS_I(inode)->i_compr_blocks))
3463 goto out;
3464
3340
3341 mnt_drop_write_file(filp);
3342out:
3343 kfree(vbuf);
3344 return err;
3345}
3346
3347static int f2fs_get_compress_blocks(struct file *filp, unsigned long arg)

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

3457
3458 set_inode_flag(inode, FI_COMPRESS_RELEASED);
3459 inode->i_ctime = current_time(inode);
3460 f2fs_mark_inode_dirty_sync(inode, true);
3461
3462 if (!atomic_read(&F2FS_I(inode)->i_compr_blocks))
3463 goto out;
3464
3465 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3465 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3466 filemap_invalidate_lock(inode->i_mapping);
3467
3468 last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
3469
3470 while (page_idx < last_idx) {
3471 struct dnode_of_data dn;
3472 pgoff_t end_offset, count;
3473

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

3494 if (ret < 0)
3495 break;
3496
3497 page_idx += count;
3498 released_blocks += ret;
3499 }
3500
3501 filemap_invalidate_unlock(inode->i_mapping);
3466 filemap_invalidate_lock(inode->i_mapping);
3467
3468 last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
3469
3470 while (page_idx < last_idx) {
3471 struct dnode_of_data dn;
3472 pgoff_t end_offset, count;
3473

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

3494 if (ret < 0)
3495 break;
3496
3497 page_idx += count;
3498 released_blocks += ret;
3499 }
3500
3501 filemap_invalidate_unlock(inode->i_mapping);
3502 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3502 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3503out:
3504 inode_unlock(inode);
3505
3506 mnt_drop_write_file(filp);
3507
3508 if (ret >= 0) {
3509 ret = put_user(released_blocks, (u64 __user *)arg);
3510 } else if (released_blocks &&

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

3610
3611 inode_lock(inode);
3612
3613 if (!is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) {
3614 ret = -EINVAL;
3615 goto unlock_inode;
3616 }
3617
3503out:
3504 inode_unlock(inode);
3505
3506 mnt_drop_write_file(filp);
3507
3508 if (ret >= 0) {
3509 ret = put_user(released_blocks, (u64 __user *)arg);
3510 } else if (released_blocks &&

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

3610
3611 inode_lock(inode);
3612
3613 if (!is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) {
3614 ret = -EINVAL;
3615 goto unlock_inode;
3616 }
3617
3618 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3618 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3619 filemap_invalidate_lock(inode->i_mapping);
3620
3621 last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
3622
3623 while (page_idx < last_idx) {
3624 struct dnode_of_data dn;
3625 pgoff_t end_offset, count;
3626

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

3647 if (ret < 0)
3648 break;
3649
3650 page_idx += count;
3651 reserved_blocks += ret;
3652 }
3653
3654 filemap_invalidate_unlock(inode->i_mapping);
3619 filemap_invalidate_lock(inode->i_mapping);
3620
3621 last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
3622
3623 while (page_idx < last_idx) {
3624 struct dnode_of_data dn;
3625 pgoff_t end_offset, count;
3626

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

3647 if (ret < 0)
3648 break;
3649
3650 page_idx += count;
3651 reserved_blocks += ret;
3652 }
3653
3654 filemap_invalidate_unlock(inode->i_mapping);
3655 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3655 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3656
3657 if (ret >= 0) {
3658 clear_inode_flag(inode, FI_COMPRESS_RELEASED);
3659 inode->i_ctime = current_time(inode);
3660 f2fs_mark_inode_dirty_sync(inode, true);
3661 }
3662unlock_inode:
3663 inode_unlock(inode);

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

3765
3766 index = F2FS_BYTES_TO_BLK(range.start);
3767 pg_end = DIV_ROUND_UP(end_addr, F2FS_BLKSIZE);
3768
3769 ret = f2fs_convert_inline_inode(inode);
3770 if (ret)
3771 goto err;
3772
3656
3657 if (ret >= 0) {
3658 clear_inode_flag(inode, FI_COMPRESS_RELEASED);
3659 inode->i_ctime = current_time(inode);
3660 f2fs_mark_inode_dirty_sync(inode, true);
3661 }
3662unlock_inode:
3663 inode_unlock(inode);

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

3765
3766 index = F2FS_BYTES_TO_BLK(range.start);
3767 pg_end = DIV_ROUND_UP(end_addr, F2FS_BLKSIZE);
3768
3769 ret = f2fs_convert_inline_inode(inode);
3770 if (ret)
3771 goto err;
3772
3773 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3773 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3774 filemap_invalidate_lock(mapping);
3775
3776 ret = filemap_write_and_wait_range(mapping, range.start,
3777 to_end ? LLONG_MAX : end_addr - 1);
3778 if (ret)
3779 goto out;
3780
3781 truncate_inode_pages_range(mapping, range.start,

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

3854 cond_resched();
3855 }
3856
3857 if (len)
3858 ret = f2fs_secure_erase(prev_bdev, inode, prev_index,
3859 prev_block, len, range.flags);
3860out:
3861 filemap_invalidate_unlock(mapping);
3774 filemap_invalidate_lock(mapping);
3775
3776 ret = filemap_write_and_wait_range(mapping, range.start,
3777 to_end ? LLONG_MAX : end_addr - 1);
3778 if (ret)
3779 goto out;
3780
3781 truncate_inode_pages_range(mapping, range.start,

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

3854 cond_resched();
3855 }
3856
3857 if (len)
3858 ret = f2fs_secure_erase(prev_bdev, inode, prev_index,
3859 prev_block, len, range.flags);
3860out:
3861 filemap_invalidate_unlock(mapping);
3862 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3862 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3863err:
3864 inode_unlock(inode);
3865 file_end_write(filp);
3866
3867 return ret;
3868}
3869
3870static int f2fs_ioc_get_compress_option(struct file *filp, unsigned long arg)

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

4286 ssize_t ret;
4287
4288 if (count == 0)
4289 return 0; /* skip atime update */
4290
4291 trace_f2fs_direct_IO_enter(inode, iocb, count, READ);
4292
4293 if (iocb->ki_flags & IOCB_NOWAIT) {
3863err:
3864 inode_unlock(inode);
3865 file_end_write(filp);
3866
3867 return ret;
3868}
3869
3870static int f2fs_ioc_get_compress_option(struct file *filp, unsigned long arg)

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

4286 ssize_t ret;
4287
4288 if (count == 0)
4289 return 0; /* skip atime update */
4290
4291 trace_f2fs_direct_IO_enter(inode, iocb, count, READ);
4292
4293 if (iocb->ki_flags & IOCB_NOWAIT) {
4294 if (!down_read_trylock(&fi->i_gc_rwsem[READ])) {
4294 if (!f2fs_down_read_trylock(&fi->i_gc_rwsem[READ])) {
4295 ret = -EAGAIN;
4296 goto out;
4297 }
4298 } else {
4295 ret = -EAGAIN;
4296 goto out;
4297 }
4298 } else {
4299 down_read(&fi->i_gc_rwsem[READ]);
4299 f2fs_down_read(&fi->i_gc_rwsem[READ]);
4300 }
4301
4302 /*
4303 * We have to use __iomap_dio_rw() and iomap_dio_complete() instead of
4304 * the higher-level function iomap_dio_rw() in order to ensure that the
4305 * F2FS_DIO_READ counter will be decremented correctly in all cases.
4306 */
4307 inc_page_count(sbi, F2FS_DIO_READ);
4308 dio = __iomap_dio_rw(iocb, to, &f2fs_iomap_ops,
4309 &f2fs_iomap_dio_read_ops, 0, 0);
4310 if (IS_ERR_OR_NULL(dio)) {
4311 ret = PTR_ERR_OR_ZERO(dio);
4312 if (ret != -EIOCBQUEUED)
4313 dec_page_count(sbi, F2FS_DIO_READ);
4314 } else {
4315 ret = iomap_dio_complete(dio);
4316 }
4317
4300 }
4301
4302 /*
4303 * We have to use __iomap_dio_rw() and iomap_dio_complete() instead of
4304 * the higher-level function iomap_dio_rw() in order to ensure that the
4305 * F2FS_DIO_READ counter will be decremented correctly in all cases.
4306 */
4307 inc_page_count(sbi, F2FS_DIO_READ);
4308 dio = __iomap_dio_rw(iocb, to, &f2fs_iomap_ops,
4309 &f2fs_iomap_dio_read_ops, 0, 0);
4310 if (IS_ERR_OR_NULL(dio)) {
4311 ret = PTR_ERR_OR_ZERO(dio);
4312 if (ret != -EIOCBQUEUED)
4313 dec_page_count(sbi, F2FS_DIO_READ);
4314 } else {
4315 ret = iomap_dio_complete(dio);
4316 }
4317
4318 up_read(&fi->i_gc_rwsem[READ]);
4318 f2fs_up_read(&fi->i_gc_rwsem[READ]);
4319
4320 file_accessed(file);
4321out:
4322 trace_f2fs_direct_IO_exit(inode, pos, count, READ, ret);
4323 return ret;
4324}
4325
4326static ssize_t f2fs_file_read_iter(struct kiocb *iocb, struct iov_iter *to)

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

4492 if (iocb->ki_flags & IOCB_NOWAIT) {
4493 /* f2fs_convert_inline_inode() and block allocation can block */
4494 if (f2fs_has_inline_data(inode) ||
4495 !f2fs_overwrite_io(inode, pos, count)) {
4496 ret = -EAGAIN;
4497 goto out;
4498 }
4499
4319
4320 file_accessed(file);
4321out:
4322 trace_f2fs_direct_IO_exit(inode, pos, count, READ, ret);
4323 return ret;
4324}
4325
4326static ssize_t f2fs_file_read_iter(struct kiocb *iocb, struct iov_iter *to)

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

4492 if (iocb->ki_flags & IOCB_NOWAIT) {
4493 /* f2fs_convert_inline_inode() and block allocation can block */
4494 if (f2fs_has_inline_data(inode) ||
4495 !f2fs_overwrite_io(inode, pos, count)) {
4496 ret = -EAGAIN;
4497 goto out;
4498 }
4499
4500 if (!down_read_trylock(&fi->i_gc_rwsem[WRITE])) {
4500 if (!f2fs_down_read_trylock(&fi->i_gc_rwsem[WRITE])) {
4501 ret = -EAGAIN;
4502 goto out;
4503 }
4501 ret = -EAGAIN;
4502 goto out;
4503 }
4504 if (do_opu && !down_read_trylock(&fi->i_gc_rwsem[READ])) {
4505 up_read(&fi->i_gc_rwsem[WRITE]);
4504 if (do_opu && !f2fs_down_read_trylock(&fi->i_gc_rwsem[READ])) {
4505 f2fs_up_read(&fi->i_gc_rwsem[WRITE]);
4506 ret = -EAGAIN;
4507 goto out;
4508 }
4509 } else {
4510 ret = f2fs_convert_inline_inode(inode);
4511 if (ret)
4512 goto out;
4513
4506 ret = -EAGAIN;
4507 goto out;
4508 }
4509 } else {
4510 ret = f2fs_convert_inline_inode(inode);
4511 if (ret)
4512 goto out;
4513
4514 down_read(&fi->i_gc_rwsem[WRITE]);
4514 f2fs_down_read(&fi->i_gc_rwsem[WRITE]);
4515 if (do_opu)
4515 if (do_opu)
4516 down_read(&fi->i_gc_rwsem[READ]);
4516 f2fs_down_read(&fi->i_gc_rwsem[READ]);
4517 }
4518 if (whint_mode == WHINT_MODE_OFF)
4519 iocb->ki_hint = WRITE_LIFE_NOT_SET;
4520
4521 /*
4522 * We have to use __iomap_dio_rw() and iomap_dio_complete() instead of
4523 * the higher-level function iomap_dio_rw() in order to ensure that the
4524 * F2FS_DIO_WRITE counter will be decremented correctly in all cases.

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

4537 dec_page_count(sbi, F2FS_DIO_WRITE);
4538 } else {
4539 ret = iomap_dio_complete(dio);
4540 }
4541
4542 if (whint_mode == WHINT_MODE_OFF)
4543 iocb->ki_hint = hint;
4544 if (do_opu)
4517 }
4518 if (whint_mode == WHINT_MODE_OFF)
4519 iocb->ki_hint = WRITE_LIFE_NOT_SET;
4520
4521 /*
4522 * We have to use __iomap_dio_rw() and iomap_dio_complete() instead of
4523 * the higher-level function iomap_dio_rw() in order to ensure that the
4524 * F2FS_DIO_WRITE counter will be decremented correctly in all cases.

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

4537 dec_page_count(sbi, F2FS_DIO_WRITE);
4538 } else {
4539 ret = iomap_dio_complete(dio);
4540 }
4541
4542 if (whint_mode == WHINT_MODE_OFF)
4543 iocb->ki_hint = hint;
4544 if (do_opu)
4545 up_read(&fi->i_gc_rwsem[READ]);
4546 up_read(&fi->i_gc_rwsem[WRITE]);
4545 f2fs_up_read(&fi->i_gc_rwsem[READ]);
4546 f2fs_up_read(&fi->i_gc_rwsem[WRITE]);
4547
4548 if (ret < 0)
4549 goto out;
4550 if (pos + ret > inode->i_size)
4551 f2fs_i_size_write(inode, pos + ret);
4552 if (!do_opu)
4553 set_inode_flag(inode, FI_UPDATE_WRITE);
4554

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

4639 else
4640 /* Do the actual write. */
4641 ret = dio ?
4642 f2fs_dio_write_iter(iocb, from, &may_need_sync):
4643 f2fs_buffered_write_iter(iocb, from);
4644
4645 /* Don't leave any preallocated blocks around past i_size. */
4646 if (preallocated && i_size_read(inode) < target_size) {
4547
4548 if (ret < 0)
4549 goto out;
4550 if (pos + ret > inode->i_size)
4551 f2fs_i_size_write(inode, pos + ret);
4552 if (!do_opu)
4553 set_inode_flag(inode, FI_UPDATE_WRITE);
4554

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

4639 else
4640 /* Do the actual write. */
4641 ret = dio ?
4642 f2fs_dio_write_iter(iocb, from, &may_need_sync):
4643 f2fs_buffered_write_iter(iocb, from);
4644
4645 /* Don't leave any preallocated blocks around past i_size. */
4646 if (preallocated && i_size_read(inode) < target_size) {
4647 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
4647 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
4648 filemap_invalidate_lock(inode->i_mapping);
4649 if (!f2fs_truncate(inode))
4650 file_dont_truncate(inode);
4651 filemap_invalidate_unlock(inode->i_mapping);
4648 filemap_invalidate_lock(inode->i_mapping);
4649 if (!f2fs_truncate(inode))
4650 file_dont_truncate(inode);
4651 filemap_invalidate_unlock(inode->i_mapping);
4652 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
4652 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
4653 } else {
4654 file_dont_truncate(inode);
4655 }
4656
4657 clear_inode_flag(inode, FI_PREALLOCATED_ALL);
4658out_unlock:
4659 inode_unlock(inode);
4660out:

--- 170 unchanged lines hidden --- 		4653 } else {
4654 file_dont_truncate(inode);
4655 }
4656
4657 clear_inode_flag(inode, FI_PREALLOCATED_ALL);
4658out_unlock:
4659 inode_unlock(inode);
4660out:

--- 170 unchanged lines hidden ---