Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'gfs2-v5.18-rc4-fix3' of git://git.kernel.org/pub/scm/linux/kernel/git/gfs2/linux-gfs2
Pull gfs2 fixes from Andreas Gruenbacher:
"We've finally identified commit dc732906c245 ("gfs2: Introduce flag
for glock holder auto-demotion") to be the other cause of the
filesystem corruption we've been seeing. This feature isn't strictly
necessary anymore, so we've decided to stop using it for now.
With this and the gfs_iomap_end rounding fix you've already seen
("gfs2: Fix filesystem block deallocation for short writes" in this
pull request), we're corruption free again now.
- Fix filesystem block deallocation for short writes.
- Stop using glock holder auto-demotion for now.
- Get rid of buffered writes inefficiencies due to page faults being
disabled.
- Minor other cleanups"
* tag 'gfs2-v5.18-rc4-fix3' of git://git.kernel.org/pub/scm/linux/kernel/git/gfs2/linux-gfs2:
gfs2: Stop using glock holder auto-demotion for now
gfs2: buffered write prefaulting
gfs2: Align read and write chunks to the page cache
gfs2: Pull return value test out of should_fault_in_pages
gfs2: Clean up use of fault_in_iov_iter_{read,write}able
gfs2: Variable rename
gfs2: Fix filesystem block deallocation for short writes
+70
-84
+5
-6
fs/gfs2/bmap.c
+5
-6
fs/gfs2/bmap.c
···
1153
1153
1154
1154
if (length != written && (iomap->flags & IOMAP_F_NEW)) {
1155
1155
/* Deallocate blocks that were just allocated. */
1156
-
loff_t blockmask = i_blocksize(inode) - 1;
1157
-
loff_t end = (pos + length) & ~blockmask;
1156
+
loff_t hstart = round_up(pos + written, i_blocksize(inode));
1157
+
loff_t hend = iomap->offset + iomap->length;
1158
1158
1159
-
pos = (pos + written + blockmask) & ~blockmask;
1160
-
if (pos < end) {
1161
-
truncate_pagecache_range(inode, pos, end - 1);
1162
-
punch_hole(ip, pos, end - pos);
1159
+
if (hstart < hend) {
1160
+
truncate_pagecache_range(inode, hstart, hend - 1);
1161
+
punch_hole(ip, hstart, hend - hstart);
1163
1162
}
1164
1163
}
1165
1164
+65
-78
fs/gfs2/file.c
+65
-78
fs/gfs2/file.c
···
770
770
return ret ? ret : ret1;
771
771
}
772
772
773
-
static inline bool should_fault_in_pages(ssize_t ret, struct iov_iter *i,
773
+
static inline bool should_fault_in_pages(struct iov_iter *i,
774
+
struct kiocb *iocb,
774
775
size_t *prev_count,
775
776
size_t *window_size)
776
777
{
777
778
size_t count = iov_iter_count(i);
778
779
size_t size, offs;
779
780
780
-
if (likely(!count))
781
-
return false;
782
-
if (ret <= 0 && ret != -EFAULT)
781
+
if (!count)
783
782
return false;
784
783
if (!iter_is_iovec(i))
785
784
return false;
786
785
787
786
size = PAGE_SIZE;
788
-
offs = offset_in_page(i->iov[0].iov_base + i->iov_offset);
787
+
offs = offset_in_page(iocb->ki_pos);
789
788
if (*prev_count != count || !*window_size) {
790
789
size_t nr_dirtied;
791
790
792
-
size = ALIGN(offs + count, PAGE_SIZE);
793
-
size = min_t(size_t, size, SZ_1M);
794
791
nr_dirtied = max(current->nr_dirtied_pause -
795
792
current->nr_dirtied, 8);
796
-
size = min(size, nr_dirtied << PAGE_SHIFT);
793
+
size = min_t(size_t, SZ_1M, nr_dirtied << PAGE_SHIFT);
797
794
}
798
795
799
796
*prev_count = count;
···
804
807
struct file *file = iocb->ki_filp;
805
808
struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
806
809
size_t prev_count = 0, window_size = 0;
807
-
size_t written = 0;
810
+
size_t read = 0;
808
811
ssize_t ret;
809
812
810
813
/*
···
832
835
ret = gfs2_glock_nq(gh);
833
836
if (ret)
834
837
goto out_uninit;
835
-
retry_under_glock:
836
838
pagefault_disable();
837
839
to->nofault = true;
838
840
ret = iomap_dio_rw(iocb, to, &gfs2_iomap_ops, NULL,
839
-
IOMAP_DIO_PARTIAL, written);
841
+
IOMAP_DIO_PARTIAL, read);
840
842
to->nofault = false;
841
843
pagefault_enable();
844
+
if (ret <= 0 && ret != -EFAULT)
845
+
goto out_unlock;
842
846
if (ret > 0)
843
-
written = ret;
847
+
read = ret;
844
848
845
-
if (should_fault_in_pages(ret, to, &prev_count, &window_size)) {
846
-
size_t leftover;
847
-
848
-
gfs2_holder_allow_demote(gh);
849
-
leftover = fault_in_iov_iter_writeable(to, window_size);
850
-
gfs2_holder_disallow_demote(gh);
851
-
if (leftover != window_size) {
852
-
if (gfs2_holder_queued(gh))
853
-
goto retry_under_glock;
849
+
if (should_fault_in_pages(to, iocb, &prev_count, &window_size)) {
850
+
gfs2_glock_dq(gh);
851
+
window_size -= fault_in_iov_iter_writeable(to, window_size);
852
+
if (window_size)
854
853
goto retry;
855
-
}
856
854
}
855
+
out_unlock:
857
856
if (gfs2_holder_queued(gh))
858
857
gfs2_glock_dq(gh);
859
858
out_uninit:
860
859
gfs2_holder_uninit(gh);
861
860
if (ret < 0)
862
861
return ret;
863
-
return written;
862
+
return read;
864
863
}
865
864
866
865
static ssize_t gfs2_file_direct_write(struct kiocb *iocb, struct iov_iter *from,
···
866
873
struct inode *inode = file->f_mapping->host;
867
874
struct gfs2_inode *ip = GFS2_I(inode);
868
875
size_t prev_count = 0, window_size = 0;
869
-
size_t read = 0;
876
+
size_t written = 0;
870
877
ssize_t ret;
871
878
872
879
/*
···
894
901
goto out_uninit;
895
902
/* Silently fall back to buffered I/O when writing beyond EOF */
896
903
if (iocb->ki_pos + iov_iter_count(from) > i_size_read(&ip->i_inode))
897
-
goto out;
898
-
retry_under_glock:
904
+
goto out_unlock;
899
905
900
906
from->nofault = true;
901
907
ret = iomap_dio_rw(iocb, from, &gfs2_iomap_ops, NULL,
902
-
IOMAP_DIO_PARTIAL, read);
908
+
IOMAP_DIO_PARTIAL, written);
903
909
from->nofault = false;
904
-
905
-
if (ret == -ENOTBLK)
906
-
ret = 0;
907
-
if (ret > 0)
908
-
read = ret;
909
-
910
-
if (should_fault_in_pages(ret, from, &prev_count, &window_size)) {
911
-
size_t leftover;
912
-
913
-
gfs2_holder_allow_demote(gh);
914
-
leftover = fault_in_iov_iter_readable(from, window_size);
915
-
gfs2_holder_disallow_demote(gh);
916
-
if (leftover != window_size) {
917
-
if (gfs2_holder_queued(gh))
918
-
goto retry_under_glock;
919
-
goto retry;
920
-
}
910
+
if (ret <= 0) {
911
+
if (ret == -ENOTBLK)
912
+
ret = 0;
913
+
if (ret != -EFAULT)
914
+
goto out_unlock;
921
915
}
922
-
out:
916
+
if (ret > 0)
917
+
written = ret;
918
+
919
+
if (should_fault_in_pages(from, iocb, &prev_count, &window_size)) {
920
+
gfs2_glock_dq(gh);
921
+
window_size -= fault_in_iov_iter_readable(from, window_size);
922
+
if (window_size)
923
+
goto retry;
924
+
}
925
+
out_unlock:
923
926
if (gfs2_holder_queued(gh))
924
927
gfs2_glock_dq(gh);
925
928
out_uninit:
926
929
gfs2_holder_uninit(gh);
927
930
if (ret < 0)
928
931
return ret;
929
-
return read;
932
+
return written;
930
933
}
931
934
932
935
static ssize_t gfs2_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
···
930
941
struct gfs2_inode *ip;
931
942
struct gfs2_holder gh;
932
943
size_t prev_count = 0, window_size = 0;
933
-
size_t written = 0;
944
+
size_t read = 0;
934
945
ssize_t ret;
935
946
936
947
/*
···
951
962
if (ret >= 0) {
952
963
if (!iov_iter_count(to))
953
964
return ret;
954
-
written = ret;
965
+
read = ret;
955
966
} else if (ret != -EFAULT) {
956
967
if (ret != -EAGAIN)
957
968
return ret;
···
964
975
ret = gfs2_glock_nq(&gh);
965
976
if (ret)
966
977
goto out_uninit;
967
-
retry_under_glock:
968
978
pagefault_disable();
969
979
ret = generic_file_read_iter(iocb, to);
970
980
pagefault_enable();
981
+
if (ret <= 0 && ret != -EFAULT)
982
+
goto out_unlock;
971
983
if (ret > 0)
972
-
written += ret;
984
+
read += ret;
973
985
974
-
if (should_fault_in_pages(ret, to, &prev_count, &window_size)) {
975
-
size_t leftover;
976
-
977
-
gfs2_holder_allow_demote(&gh);
978
-
leftover = fault_in_iov_iter_writeable(to, window_size);
979
-
gfs2_holder_disallow_demote(&gh);
980
-
if (leftover != window_size) {
981
-
if (gfs2_holder_queued(&gh))
982
-
goto retry_under_glock;
986
+
if (should_fault_in_pages(to, iocb, &prev_count, &window_size)) {
987
+
gfs2_glock_dq(&gh);
988
+
window_size -= fault_in_iov_iter_writeable(to, window_size);
989
+
if (window_size)
983
990
goto retry;
984
-
}
985
991
}
992
+
out_unlock:
986
993
if (gfs2_holder_queued(&gh))
987
994
gfs2_glock_dq(&gh);
988
995
out_uninit:
989
996
gfs2_holder_uninit(&gh);
990
-
return written ? written : ret;
997
+
return read ? read : ret;
991
998
}
992
999
993
1000
static ssize_t gfs2_file_buffered_write(struct kiocb *iocb,
···
997
1012
struct gfs2_holder *statfs_gh = NULL;
998
1013
size_t prev_count = 0, window_size = 0;
999
1014
size_t orig_count = iov_iter_count(from);
1000
-
size_t read = 0;
1015
+
size_t written = 0;
1001
1016
ssize_t ret;
1002
1017
1003
1018
/*
···
1015
1030
1016
1031
gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, gh);
1017
1032
retry:
1033
+
if (should_fault_in_pages(from, iocb, &prev_count, &window_size)) {
1034
+
window_size -= fault_in_iov_iter_readable(from, window_size);
1035
+
if (!window_size) {
1036
+
ret = -EFAULT;
1037
+
goto out_uninit;
1038
+
}
1039
+
from->count = min(from->count, window_size);
1040
+
}
1018
1041
ret = gfs2_glock_nq(gh);
1019
1042
if (ret)
1020
1043
goto out_uninit;
1021
-
retry_under_glock:
1044
+
1022
1045
if (inode == sdp->sd_rindex) {
1023
1046
struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
1024
1047
···
1043
1050
current->backing_dev_info = NULL;
1044
1051
if (ret > 0) {
1045
1052
iocb->ki_pos += ret;
1046
-
read += ret;
1053
+
written += ret;
1047
1054
}
1048
1055
1049
1056
if (inode == sdp->sd_rindex)
1050
1057
gfs2_glock_dq_uninit(statfs_gh);
1051
1058
1052
-
from->count = orig_count - read;
1053
-
if (should_fault_in_pages(ret, from, &prev_count, &window_size)) {
1054
-
size_t leftover;
1059
+
if (ret <= 0 && ret != -EFAULT)
1060
+
goto out_unlock;
1055
1061
1056
-
gfs2_holder_allow_demote(gh);
1057
-
leftover = fault_in_iov_iter_readable(from, window_size);
1058
-
gfs2_holder_disallow_demote(gh);
1059
-
if (leftover != window_size) {
1060
-
from->count = min(from->count, window_size - leftover);
1061
-
if (gfs2_holder_queued(gh))
1062
-
goto retry_under_glock;
1063
-
goto retry;
1064
-
}
1062
+
from->count = orig_count - written;
1063
+
if (should_fault_in_pages(from, iocb, &prev_count, &window_size)) {
1064
+
gfs2_glock_dq(gh);
1065
+
goto retry;
1065
1066
}
1066
1067
out_unlock:
1067
1068
if (gfs2_holder_queued(gh))
···
1064
1077
gfs2_holder_uninit(gh);
1065
1078
if (statfs_gh)
1066
1079
kfree(statfs_gh);
1067
-
from->count = orig_count - read;
1068
-
return read ? read : ret;
1080
+
from->count = orig_count - written;
1081
+
return written ? written : ret;
1069
1082
}
1070
1083
1071
1084
/**