f2fs: use err for f2fs_preallocate_blocks

This patch has no functional change.

Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 861173f0045922ce48c21df25eccd16d271f2381..2938311c97bf1e2c162fd08969f6686e51c8b350 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -658,11 +658,11 @@ alloc:
        return 0;
 }
 
-ssize_t f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *from)
+int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *from)
 {
        struct inode *inode = file_inode(iocb->ki_filp);
        struct f2fs_map_blocks map;
-       ssize_t ret = 0;
+       int err = 0;
 
        map.m_lblk = F2FS_BLK_ALIGN(iocb->ki_pos);
        map.m_len = F2FS_BYTES_TO_BLK(iocb->ki_pos + iov_iter_count(from));
@@ -674,19 +674,19 @@ ssize_t f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *from)
        map.m_next_pgofs = NULL;
 
        if (iocb->ki_flags & IOCB_DIRECT) {
-               ret = f2fs_convert_inline_inode(inode);
-               if (ret)
-                       return ret;
+               err = f2fs_convert_inline_inode(inode);
+               if (err)
+                       return err;
                return f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_DIO);
        }
        if (iocb->ki_pos + iov_iter_count(from) > MAX_INLINE_DATA) {
-               ret = f2fs_convert_inline_inode(inode);
-               if (ret)
-                       return ret;
+               err = f2fs_convert_inline_inode(inode);
+               if (err)
+                       return err;
        }
        if (!f2fs_has_inline_data(inode))
                return f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_AIO);
-       return ret;
+       return err;
 }
 
 /*
@@ -863,19 +863,19 @@ static int __get_data_block(struct inode *inode, sector_t iblock,
                        pgoff_t *next_pgofs)
 {
        struct f2fs_map_blocks map;
-       int ret;
+       int err;
 
        map.m_lblk = iblock;
        map.m_len = bh->b_size >> inode->i_blkbits;
        map.m_next_pgofs = next_pgofs;
 
-       ret = f2fs_map_blocks(inode, &map, create, flag);
-       if (!ret) {
+       err = f2fs_map_blocks(inode, &map, create, flag);
+       if (!err) {
                map_bh(bh, inode->i_sb, map.m_pblk);
                bh->b_state = (bh->b_state & ~F2FS_MAP_FLAGS) | map.m_flags;
                bh->b_size = map.m_len << inode->i_blkbits;
        }
-       return ret;
+       return err;
 }
 
 static int get_data_block(struct inode *inode, sector_t iblock,

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 96221b1f620ee6de3013dcad7661746ca021142d..a1dcc60ae946e42b2243b03ebece06dd4b209818 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -2160,7 +2160,7 @@ void f2fs_update_data_blkaddr(struct dnode_of_data *, block_t);
 int reserve_new_blocks(struct dnode_of_data *, blkcnt_t);
 int reserve_new_block(struct dnode_of_data *);
 int f2fs_get_block(struct dnode_of_data *, pgoff_t);
-ssize_t f2fs_preallocate_blocks(struct kiocb *, struct iov_iter *);
+int f2fs_preallocate_blocks(struct kiocb *, struct iov_iter *);
 int f2fs_reserve_block(struct dnode_of_data *, pgoff_t);
 struct page *get_read_data_page(struct inode *, pgoff_t, int, bool);
 struct page *find_data_page(struct inode *, pgoff_t);

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 67a6b5ddc251cbcb9b34b1e72f80cdbc78e295bd..39616de92a557491c8cda11c0c302ca99e2afedd 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -1320,15 +1320,15 @@ static int expand_inode_data(struct inode *inode, loff_t offset,
        pgoff_t pg_end;
        loff_t new_size = i_size_read(inode);
        loff_t off_end;
-       int ret;
+       int err;
 
-       ret = inode_newsize_ok(inode, (len + offset));
-       if (ret)
-               return ret;
+       err = inode_newsize_ok(inode, (len + offset));
+       if (err)
+               return err;
 
-       ret = f2fs_convert_inline_inode(inode);
-       if (ret)
-               return ret;
+       err = f2fs_convert_inline_inode(inode);
+       if (err)
+               return err;
 
        f2fs_balance_fs(sbi, true);
 
@@ -1340,12 +1340,12 @@ static int expand_inode_data(struct inode *inode, loff_t offset,
        if (off_end)
                map.m_len++;
 
-       ret = f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_AIO);
-       if (ret) {
+       err = f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_AIO);
+       if (err) {
                pgoff_t last_off;
 
                if (!map.m_len)
-                       return ret;
+                       return err;
 
                last_off = map.m_lblk + map.m_len - 1;
 
@@ -1359,7 +1359,7 @@ static int expand_inode_data(struct inode *inode, loff_t offset,
        if (!(mode & FALLOC_FL_KEEP_SIZE) && i_size_read(inode) < new_size)
                f2fs_i_size_write(inode, new_size);
 
-       return ret;
+       return err;
 }
 
 static long f2fs_fallocate(struct file *file, int mode,
@@ -2263,12 +2263,15 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
        inode_lock(inode);
        ret = generic_write_checks(iocb, from);
        if (ret > 0) {
-               ret = f2fs_preallocate_blocks(iocb, from);
-               if (!ret) {
-                       blk_start_plug(&plug);
-                       ret = __generic_file_write_iter(iocb, from);
-                       blk_finish_plug(&plug);
+               int err = f2fs_preallocate_blocks(iocb, from);
+
+               if (err) {
+                       inode_unlock(inode);
+                       return err;
                }
+               blk_start_plug(&plug);
+               ret = __generic_file_write_iter(iocb, from);
+               blk_finish_plug(&plug);
        }
        inode_unlock(inode);