Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'vfs-6.10.iomap' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs
Pull vfs iomap updates from Christian Brauner:
"This contains a few cleanups to the iomap code. Nothing particularly
stands out"
* tag 'vfs-6.10.iomap' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs:
iomap: do some small logical cleanup in buffered write
iomap: make iomap_write_end() return a boolean
iomap: use a new variable to handle the written bytes in iomap_write_iter()
iomap: don't increase i_size if it's not a write operation
iomap: drop the write failure handles when unsharing and zeroing
iomap: convert iomap_writepages to writeack_iter
+66
-55
+66
-55
fs/iomap/buffered-io.c
+66
-55
fs/iomap/buffered-io.c
···
824
824
825
825
out_unlock:
826
826
__iomap_put_folio(iter, pos, 0, folio);
827
-
iomap_write_failed(iter->inode, pos, len);
828
827
829
828
return status;
830
829
}
831
830
832
-
static size_t __iomap_write_end(struct inode *inode, loff_t pos, size_t len,
831
+
static bool __iomap_write_end(struct inode *inode, loff_t pos, size_t len,
833
832
size_t copied, struct folio *folio)
834
833
{
835
834
flush_dcache_folio(folio);
···
845
846
* redo the whole thing.
846
847
*/
847
848
if (unlikely(copied < len && !folio_test_uptodate(folio)))
848
-
return 0;
849
+
return false;
849
850
iomap_set_range_uptodate(folio, offset_in_folio(folio, pos), len);
850
851
iomap_set_range_dirty(folio, offset_in_folio(folio, pos), copied);
851
852
filemap_dirty_folio(inode->i_mapping, folio);
852
-
return copied;
853
+
return true;
853
854
}
854
855
855
-
static size_t iomap_write_end_inline(const struct iomap_iter *iter,
856
+
static void iomap_write_end_inline(const struct iomap_iter *iter,
856
857
struct folio *folio, loff_t pos, size_t copied)
857
858
{
858
859
const struct iomap *iomap = &iter->iomap;
···
867
868
kunmap_local(addr);
868
869
869
870
mark_inode_dirty(iter->inode);
870
-
return copied;
871
871
}
872
872
873
-
/* Returns the number of bytes copied. May be 0. Cannot be an errno. */
874
-
static size_t iomap_write_end(struct iomap_iter *iter, loff_t pos, size_t len,
873
+
/*
874
+
* Returns true if all copied bytes have been written to the pagecache,
875
+
* otherwise return false.
876
+
*/
877
+
static bool iomap_write_end(struct iomap_iter *iter, loff_t pos, size_t len,
875
878
size_t copied, struct folio *folio)
876
879
{
877
880
const struct iomap *srcmap = iomap_iter_srcmap(iter);
878
-
loff_t old_size = iter->inode->i_size;
879
-
size_t ret;
880
881
881
882
if (srcmap->type == IOMAP_INLINE) {
882
-
ret = iomap_write_end_inline(iter, folio, pos, copied);
883
-
} else if (srcmap->flags & IOMAP_F_BUFFER_HEAD) {
884
-
ret = block_write_end(NULL, iter->inode->i_mapping, pos, len,
885
-
copied, &folio->page, NULL);
886
-
} else {
887
-
ret = __iomap_write_end(iter->inode, pos, len, copied, folio);
883
+
iomap_write_end_inline(iter, folio, pos, copied);
884
+
return true;
888
885
}
889
886
890
-
/*
891
-
* Update the in-memory inode size after copying the data into the page
892
-
* cache. It's up to the file system to write the updated size to disk,
893
-
* preferably after I/O completion so that no stale data is exposed.
894
-
*/
895
-
if (pos + ret > old_size) {
896
-
i_size_write(iter->inode, pos + ret);
897
-
iter->iomap.flags |= IOMAP_F_SIZE_CHANGED;
898
-
}
899
-
__iomap_put_folio(iter, pos, ret, folio);
887
+
if (srcmap->flags & IOMAP_F_BUFFER_HEAD) {
888
+
size_t bh_written;
900
889
901
-
if (old_size < pos)
902
-
pagecache_isize_extended(iter->inode, old_size, pos);
903
-
if (ret < len)
904
-
iomap_write_failed(iter->inode, pos + ret, len - ret);
905
-
return ret;
890
+
bh_written = block_write_end(NULL, iter->inode->i_mapping, pos,
891
+
len, copied, &folio->page, NULL);
892
+
WARN_ON_ONCE(bh_written != copied && bh_written != 0);
893
+
return bh_written == copied;
894
+
}
895
+
896
+
return __iomap_write_end(iter->inode, pos, len, copied, folio);
906
897
}
907
898
908
899
static loff_t iomap_write_iter(struct iomap_iter *iter, struct iov_iter *i)
···
900
911
loff_t length = iomap_length(iter);
901
912
size_t chunk = PAGE_SIZE << MAX_PAGECACHE_ORDER;
902
913
loff_t pos = iter->pos;
903
-
ssize_t written = 0;
914
+
ssize_t total_written = 0;
904
915
long status = 0;
905
916
struct address_space *mapping = iter->inode->i_mapping;
906
917
unsigned int bdp_flags = (iter->flags & IOMAP_NOWAIT) ? BDP_ASYNC : 0;
907
918
908
919
do {
909
920
struct folio *folio;
921
+
loff_t old_size;
910
922
size_t offset; /* Offset into folio */
911
923
size_t bytes; /* Bytes to write to folio */
912
924
size_t copied; /* Bytes copied from user */
925
+
size_t written; /* Bytes have been written */
913
926
914
927
bytes = iov_iter_count(i);
915
928
retry:
···
941
950
}
942
951
943
952
status = iomap_write_begin(iter, pos, bytes, &folio);
944
-
if (unlikely(status))
953
+
if (unlikely(status)) {
954
+
iomap_write_failed(iter->inode, pos, bytes);
945
955
break;
956
+
}
946
957
if (iter->iomap.flags & IOMAP_F_STALE)
947
958
break;
948
959
···
956
963
flush_dcache_folio(folio);
957
964
958
965
copied = copy_folio_from_iter_atomic(folio, offset, bytes, i);
959
-
status = iomap_write_end(iter, pos, bytes, copied, folio);
966
+
written = iomap_write_end(iter, pos, bytes, copied, folio) ?
967
+
copied : 0;
960
968
961
-
if (unlikely(copied != status))
962
-
iov_iter_revert(i, copied - status);
969
+
/*
970
+
* Update the in-memory inode size after copying the data into
971
+
* the page cache. It's up to the file system to write the
972
+
* updated size to disk, preferably after I/O completion so that
973
+
* no stale data is exposed. Only once that's done can we
974
+
* unlock and release the folio.
975
+
*/
976
+
old_size = iter->inode->i_size;
977
+
if (pos + written > old_size) {
978
+
i_size_write(iter->inode, pos + written);
979
+
iter->iomap.flags |= IOMAP_F_SIZE_CHANGED;
980
+
}
981
+
__iomap_put_folio(iter, pos, written, folio);
982
+
983
+
if (old_size < pos)
984
+
pagecache_isize_extended(iter->inode, old_size, pos);
963
985
964
986
cond_resched();
965
-
if (unlikely(status == 0)) {
987
+
if (unlikely(written == 0)) {
966
988
/*
967
989
* A short copy made iomap_write_end() reject the
968
990
* thing entirely. Might be memory poisoning
969
991
* halfway through, might be a race with munmap,
970
992
* might be severe memory pressure.
971
993
*/
994
+
iomap_write_failed(iter->inode, pos, bytes);
995
+
iov_iter_revert(i, copied);
996
+
972
997
if (chunk > PAGE_SIZE)
973
998
chunk /= 2;
974
999
if (copied) {
···
994
983
goto retry;
995
984
}
996
985
} else {
997
-
pos += status;
998
-
written += status;
999
-
length -= status;
986
+
pos += written;
987
+
total_written += written;
988
+
length -= written;
1000
989
}
1001
990
} while (iov_iter_count(i) && length);
1002
991
1003
992
if (status == -EAGAIN) {
1004
-
iov_iter_revert(i, written);
993
+
iov_iter_revert(i, total_written);
1005
994
return -EAGAIN;
1006
995
}
1007
-
return written ? written : status;
996
+
return total_written ? total_written : status;
1008
997
}
1009
998
1010
999
ssize_t
···
1333
1322
int status;
1334
1323
size_t offset;
1335
1324
size_t bytes = min_t(u64, SIZE_MAX, length);
1325
+
bool ret;
1336
1326
1337
1327
status = iomap_write_begin(iter, pos, bytes, &folio);
1338
1328
if (unlikely(status))
···
1345
1333
if (bytes > folio_size(folio) - offset)
1346
1334
bytes = folio_size(folio) - offset;
1347
1335
1348
-
bytes = iomap_write_end(iter, pos, bytes, bytes, folio);
1349
-
if (WARN_ON_ONCE(bytes == 0))
1336
+
ret = iomap_write_end(iter, pos, bytes, bytes, folio);
1337
+
__iomap_put_folio(iter, pos, bytes, folio);
1338
+
if (WARN_ON_ONCE(!ret))
1350
1339
return -EIO;
1351
1340
1352
1341
cond_resched();
···
1396
1383
int status;
1397
1384
size_t offset;
1398
1385
size_t bytes = min_t(u64, SIZE_MAX, length);
1386
+
bool ret;
1399
1387
1400
1388
status = iomap_write_begin(iter, pos, bytes, &folio);
1401
1389
if (status)
···
1411
1397
folio_zero_range(folio, offset, bytes);
1412
1398
folio_mark_accessed(folio);
1413
1399
1414
-
bytes = iomap_write_end(iter, pos, bytes, bytes, folio);
1415
-
if (WARN_ON_ONCE(bytes == 0))
1400
+
ret = iomap_write_end(iter, pos, bytes, bytes, folio);
1401
+
__iomap_put_folio(iter, pos, bytes, folio);
1402
+
if (WARN_ON_ONCE(!ret))
1416
1403
return -EIO;
1417
1404
1418
1405
pos += bytes;
···
1973
1958
return error;
1974
1959
}
1975
1960
1976
-
static int iomap_do_writepage(struct folio *folio,
1977
-
struct writeback_control *wbc, void *data)
1978
-
{
1979
-
return iomap_writepage_map(data, wbc, folio);
1980
-
}
1981
-
1982
1961
int
1983
1962
iomap_writepages(struct address_space *mapping, struct writeback_control *wbc,
1984
1963
struct iomap_writepage_ctx *wpc,
1985
1964
const struct iomap_writeback_ops *ops)
1986
1965
{
1987
-
int ret;
1966
+
struct folio *folio = NULL;
1967
+
int error;
1988
1968
1989
1969
/*
1990
1970
* Writeback from reclaim context should never happen except in the case
···
1990
1980
return -EIO;
1991
1981
1992
1982
wpc->ops = ops;
1993
-
ret = write_cache_pages(mapping, wbc, iomap_do_writepage, wpc);
1994
-
return iomap_submit_ioend(wpc, ret);
1983
+
while ((folio = writeback_iter(mapping, wbc, folio, &error)))
1984
+
error = iomap_writepage_map(wpc, wbc, folio);
1985
+
return iomap_submit_ioend(wpc, error);
1995
1986
}
1996
1987
EXPORT_SYMBOL_GPL(iomap_writepages);
1997
1988