Skip to content

Commit d205ebd

Browse files
committed
btrfs: btrfs_direct_write rename err to ret
A simple, trivial rename of err to ret to maintain consistent coding style and reduce confusion. Signed-off-by: Anand Jain <anand.jain@oracle.com>
1 parent f09fdb2 commit d205ebd

File tree

1 file changed

+24
-24
lines changed

1 file changed

+24
-24
lines changed

fs/btrfs/file.c

Lines changed: 24 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -1465,7 +1465,7 @@ static ssize_t btrfs_direct_write(struct kiocb *iocb, struct iov_iter *from)
14651465
ssize_t written_buffered;
14661466
size_t prev_left = 0;
14671467
loff_t endbyte;
1468-
ssize_t err;
1468+
ssize_t ret;
14691469
unsigned int ilock_flags = 0;
14701470
struct iomap_dio *dio;
14711471

@@ -1482,9 +1482,9 @@ static ssize_t btrfs_direct_write(struct kiocb *iocb, struct iov_iter *from)
14821482
ilock_flags |= BTRFS_ILOCK_SHARED;
14831483

14841484
relock:
1485-
err = btrfs_inode_lock(BTRFS_I(inode), ilock_flags);
1486-
if (err < 0)
1487-
return err;
1485+
ret = btrfs_inode_lock(BTRFS_I(inode), ilock_flags);
1486+
if (ret < 0)
1487+
return ret;
14881488

14891489
/* Shared lock cannot be used with security bits set. */
14901490
if ((ilock_flags & BTRFS_ILOCK_SHARED) && !IS_NOSEC(inode)) {
@@ -1493,14 +1493,14 @@ static ssize_t btrfs_direct_write(struct kiocb *iocb, struct iov_iter *from)
14931493
goto relock;
14941494
}
14951495

1496-
err = generic_write_checks(iocb, from);
1497-
if (err <= 0) {
1496+
ret = generic_write_checks(iocb, from);
1497+
if (ret <= 0) {
14981498
btrfs_inode_unlock(BTRFS_I(inode), ilock_flags);
1499-
return err;
1499+
return ret;
15001500
}
15011501

1502-
err = btrfs_write_check(iocb, from, err);
1503-
if (err < 0) {
1502+
ret = btrfs_write_check(iocb, from, ret);
1503+
if (ret < 0) {
15041504
btrfs_inode_unlock(BTRFS_I(inode), ilock_flags);
15051505
goto out;
15061506
}
@@ -1552,15 +1552,15 @@ static ssize_t btrfs_direct_write(struct kiocb *iocb, struct iov_iter *from)
15521552
btrfs_inode_unlock(BTRFS_I(inode), ilock_flags);
15531553

15541554
if (IS_ERR_OR_NULL(dio))
1555-
err = PTR_ERR_OR_ZERO(dio);
1555+
ret = PTR_ERR_OR_ZERO(dio);
15561556
else
1557-
err = iomap_dio_complete(dio);
1557+
ret = iomap_dio_complete(dio);
15581558

15591559
/* No increment (+=) because iomap returns a cumulative value. */
1560-
if (err > 0)
1561-
written = err;
1560+
if (ret > 0)
1561+
written = ret;
15621562

1563-
if (iov_iter_count(from) > 0 && (err == -EFAULT || err > 0)) {
1563+
if (iov_iter_count(from) > 0 && (ret == -EFAULT || ret > 0)) {
15641564
const size_t left = iov_iter_count(from);
15651565
/*
15661566
* We have more data left to write. Try to fault in as many as
@@ -1577,7 +1577,7 @@ static ssize_t btrfs_direct_write(struct kiocb *iocb, struct iov_iter *from)
15771577
* to buffered IO in case we haven't made any progress.
15781578
*/
15791579
if (left == prev_left) {
1580-
err = -ENOTBLK;
1580+
ret = -ENOTBLK;
15811581
} else {
15821582
fault_in_iov_iter_readable(from, left);
15831583
prev_left = left;
@@ -1586,10 +1586,10 @@ static ssize_t btrfs_direct_write(struct kiocb *iocb, struct iov_iter *from)
15861586
}
15871587

15881588
/*
1589-
* If 'err' is -ENOTBLK or we have not written all data, then it means
1589+
* If 'ret' is -ENOTBLK or we have not written all data, then it means
15901590
* we must fallback to buffered IO.
15911591
*/
1592-
if ((err < 0 && err != -ENOTBLK) || !iov_iter_count(from))
1592+
if ((ret < 0 && ret != -ENOTBLK) || !iov_iter_count(from))
15931593
goto out;
15941594

15951595
buffered:
@@ -1600,33 +1600,33 @@ static ssize_t btrfs_direct_write(struct kiocb *iocb, struct iov_iter *from)
16001600
* below, we will block when flushing and waiting for the IO.
16011601
*/
16021602
if (iocb->ki_flags & IOCB_NOWAIT) {
1603-
err = -EAGAIN;
1603+
ret = -EAGAIN;
16041604
goto out;
16051605
}
16061606

16071607
pos = iocb->ki_pos;
16081608
written_buffered = btrfs_buffered_write(iocb, from);
16091609
if (written_buffered < 0) {
1610-
err = written_buffered;
1610+
ret = written_buffered;
16111611
goto out;
16121612
}
16131613
/*
16141614
* Ensure all data is persisted. We want the next direct IO read to be
16151615
* able to read what was just written.
16161616
*/
16171617
endbyte = pos + written_buffered - 1;
1618-
err = btrfs_fdatawrite_range(inode, pos, endbyte);
1619-
if (err)
1618+
ret = btrfs_fdatawrite_range(inode, pos, endbyte);
1619+
if (ret)
16201620
goto out;
1621-
err = filemap_fdatawait_range(inode->i_mapping, pos, endbyte);
1622-
if (err)
1621+
ret = filemap_fdatawait_range(inode->i_mapping, pos, endbyte);
1622+
if (ret)
16231623
goto out;
16241624
written += written_buffered;
16251625
iocb->ki_pos = pos + written_buffered;
16261626
invalidate_mapping_pages(file->f_mapping, pos >> PAGE_SHIFT,
16271627
endbyte >> PAGE_SHIFT);
16281628
out:
1629-
return err < 0 ? err : written;
1629+
return ret < 0 ? ret : written;
16301630
}
16311631

16321632
static ssize_t btrfs_encoded_write(struct kiocb *iocb, struct iov_iter *from,

0 commit comments

Comments
 (0)