@@ -1465,7 +1465,7 @@ static ssize_t btrfs_direct_write(struct kiocb *iocb, struct iov_iter *from)
1465
1465
ssize_t written_buffered ;
1466
1466
size_t prev_left = 0 ;
1467
1467
loff_t endbyte ;
1468
- ssize_t err ;
1468
+ ssize_t ret ;
1469
1469
unsigned int ilock_flags = 0 ;
1470
1470
struct iomap_dio * dio ;
1471
1471
@@ -1482,9 +1482,9 @@ static ssize_t btrfs_direct_write(struct kiocb *iocb, struct iov_iter *from)
1482
1482
ilock_flags |= BTRFS_ILOCK_SHARED ;
1483
1483
1484
1484
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 ;
1488
1488
1489
1489
/* Shared lock cannot be used with security bits set. */
1490
1490
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)
1493
1493
goto relock ;
1494
1494
}
1495
1495
1496
- err = generic_write_checks (iocb , from );
1497
- if (err <= 0 ) {
1496
+ ret = generic_write_checks (iocb , from );
1497
+ if (ret <= 0 ) {
1498
1498
btrfs_inode_unlock (BTRFS_I (inode ), ilock_flags );
1499
- return err ;
1499
+ return ret ;
1500
1500
}
1501
1501
1502
- err = btrfs_write_check (iocb , from , err );
1503
- if (err < 0 ) {
1502
+ ret = btrfs_write_check (iocb , from , ret );
1503
+ if (ret < 0 ) {
1504
1504
btrfs_inode_unlock (BTRFS_I (inode ), ilock_flags );
1505
1505
goto out ;
1506
1506
}
@@ -1552,15 +1552,15 @@ static ssize_t btrfs_direct_write(struct kiocb *iocb, struct iov_iter *from)
1552
1552
btrfs_inode_unlock (BTRFS_I (inode ), ilock_flags );
1553
1553
1554
1554
if (IS_ERR_OR_NULL (dio ))
1555
- err = PTR_ERR_OR_ZERO (dio );
1555
+ ret = PTR_ERR_OR_ZERO (dio );
1556
1556
else
1557
- err = iomap_dio_complete (dio );
1557
+ ret = iomap_dio_complete (dio );
1558
1558
1559
1559
/* No increment (+=) because iomap returns a cumulative value. */
1560
- if (err > 0 )
1561
- written = err ;
1560
+ if (ret > 0 )
1561
+ written = ret ;
1562
1562
1563
- if (iov_iter_count (from ) > 0 && (err == - EFAULT || err > 0 )) {
1563
+ if (iov_iter_count (from ) > 0 && (ret == - EFAULT || ret > 0 )) {
1564
1564
const size_t left = iov_iter_count (from );
1565
1565
/*
1566
1566
* 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)
1577
1577
* to buffered IO in case we haven't made any progress.
1578
1578
*/
1579
1579
if (left == prev_left ) {
1580
- err = - ENOTBLK ;
1580
+ ret = - ENOTBLK ;
1581
1581
} else {
1582
1582
fault_in_iov_iter_readable (from , left );
1583
1583
prev_left = left ;
@@ -1586,10 +1586,10 @@ static ssize_t btrfs_direct_write(struct kiocb *iocb, struct iov_iter *from)
1586
1586
}
1587
1587
1588
1588
/*
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
1590
1590
* we must fallback to buffered IO.
1591
1591
*/
1592
- if ((err < 0 && err != - ENOTBLK ) || !iov_iter_count (from ))
1592
+ if ((ret < 0 && ret != - ENOTBLK ) || !iov_iter_count (from ))
1593
1593
goto out ;
1594
1594
1595
1595
buffered :
@@ -1600,33 +1600,33 @@ static ssize_t btrfs_direct_write(struct kiocb *iocb, struct iov_iter *from)
1600
1600
* below, we will block when flushing and waiting for the IO.
1601
1601
*/
1602
1602
if (iocb -> ki_flags & IOCB_NOWAIT ) {
1603
- err = - EAGAIN ;
1603
+ ret = - EAGAIN ;
1604
1604
goto out ;
1605
1605
}
1606
1606
1607
1607
pos = iocb -> ki_pos ;
1608
1608
written_buffered = btrfs_buffered_write (iocb , from );
1609
1609
if (written_buffered < 0 ) {
1610
- err = written_buffered ;
1610
+ ret = written_buffered ;
1611
1611
goto out ;
1612
1612
}
1613
1613
/*
1614
1614
* Ensure all data is persisted. We want the next direct IO read to be
1615
1615
* able to read what was just written.
1616
1616
*/
1617
1617
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 )
1620
1620
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 )
1623
1623
goto out ;
1624
1624
written += written_buffered ;
1625
1625
iocb -> ki_pos = pos + written_buffered ;
1626
1626
invalidate_mapping_pages (file -> f_mapping , pos >> PAGE_SHIFT ,
1627
1627
endbyte >> PAGE_SHIFT );
1628
1628
out :
1629
- return err < 0 ? err : written ;
1629
+ return ret < 0 ? ret : written ;
1630
1630
}
1631
1631
1632
1632
static ssize_t btrfs_encoded_write (struct kiocb * iocb , struct iov_iter * from ,
0 commit comments