netfs: Fix undifferentiation of DIO reads from unbuffered reads

On cifs, "DIO reads" (specified by O_DIRECT) need to be differentiated from
"unbuffered reads" (specified by cache=none in the mount parameters).  The
difference is flagged in the protocol and the server may behave
differently: Windows Server will, for example, mandate that DIO reads are
block aligned.

Fix this by adding a NETFS_UNBUFFERED_READ to differentiate this from
NETFS_DIO_READ, parallelling the write differentiation that already exists.
cifs will then do the right thing.

Fixes: 016dc8516aec ("netfs: Implement unbuffered/DIO read support")
Signed-off-by: David Howells <dhowells@redhat.com>
Link: https://lore.kernel.org/3444961.1747987072@warthog.procyon.org.uk
Reviewed-by: "Paulo Alcantara (Red Hat)" <pc@manguebit.com>
Reviewed-by: Viacheslav Dubeyko <Slava.Dubeyko@ibm.com>
cc: Steve French <sfrench@samba.org>
cc: netfs@lists.linux.dev
cc: v9fs@lists.linux.dev
cc: linux-afs@lists.infradead.org
cc: linux-cifs@vger.kernel.org
cc: ceph-devel@vger.kernel.org
cc: linux-nfs@vger.kernel.org
cc: linux-fsdevel@vger.kernel.org
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/fs/9p/vfs_addr.c b/fs/9p/vfs_addr.c
index b5a4a28e0fe79bf8a39c12e58e4aa632be59ffe7..e4420591cf3543aca7240f752c0b90155f72e879 100644 (file)
--- a/fs/9p/vfs_addr.c
+++ b/fs/9p/vfs_addr.c
@@ -77,7 +77,8 @@ static void v9fs_issue_read(struct netfs_io_subrequest *subreq)
 
        /* if we just extended the file size, any portion not in
         * cache won't be on server and is zeroes */
-       if (subreq->rreq->origin != NETFS_DIO_READ)
+       if (subreq->rreq->origin != NETFS_UNBUFFERED_READ &&
+           subreq->rreq->origin != NETFS_DIO_READ)
                __set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags);
        if (pos + total >= i_size_read(rreq->inode))
                __set_bit(NETFS_SREQ_HIT_EOF, &subreq->flags);

diff --git a/fs/afs/write.c b/fs/afs/write.c
index 7df7b2f5e7b298b3e01d4d4ce1d43ba5ba61e2fc..2e7526ea883ae231935b301935f802a0ad9f0dfa 100644 (file)
--- a/fs/afs/write.c
+++ b/fs/afs/write.c
@@ -202,6 +202,7 @@ void afs_retry_request(struct netfs_io_request *wreq, struct netfs_io_stream *st
        case NETFS_READ_GAPS:
        case NETFS_READ_SINGLE:
        case NETFS_READ_FOR_WRITE:
+       case NETFS_UNBUFFERED_READ:
        case NETFS_DIO_READ:
                return;
        default:

diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
index 557c326561fdc030359b7a67b0210dcba8b3c022..b95c4cb21c13f0b4a3ae47aba2916b49c398b3fa 100644 (file)
--- a/fs/ceph/addr.c
+++ b/fs/ceph/addr.c
@@ -238,6 +238,7 @@ static void finish_netfs_read(struct ceph_osd_request *req)
                if (sparse && err > 0)
                        err = ceph_sparse_ext_map_end(op);
                if (err < subreq->len &&
+                   subreq->rreq->origin != NETFS_UNBUFFERED_READ &&
                    subreq->rreq->origin != NETFS_DIO_READ)
                        __set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags);
                if (IS_ENCRYPTED(inode) && err > 0) {
@@ -281,7 +282,8 @@ static bool ceph_netfs_issue_op_inline(struct netfs_io_subrequest *subreq)
        size_t len;
        int mode;
 
-       if (rreq->origin != NETFS_DIO_READ)
+       if (rreq->origin != NETFS_UNBUFFERED_READ &&
+           rreq->origin != NETFS_DIO_READ)
                __set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags);
        __clear_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags);
 

diff --git a/fs/netfs/direct_read.c b/fs/netfs/direct_read.c
index e72c8b69b1475eedaa15199479f2056007374608..a05e13472bafb22adb25c6578791a30ac399fc1e 100644 (file)
--- a/fs/netfs/direct_read.c
+++ b/fs/netfs/direct_read.c
@@ -185,7 +185,8 @@ ssize_t netfs_unbuffered_read_iter_locked(struct kiocb *iocb, struct iov_iter *i
 
        rreq = netfs_alloc_request(iocb->ki_filp->f_mapping, iocb->ki_filp,
                                   iocb->ki_pos, orig_count,
-                                  NETFS_DIO_READ);
+                                  iocb->ki_flags & IOCB_DIRECT ?
+                                  NETFS_DIO_READ : NETFS_UNBUFFERED_READ);
        if (IS_ERR(rreq))
                return PTR_ERR(rreq);
 

diff --git a/fs/netfs/main.c b/fs/netfs/main.c
index 4e3e62040831408b6a330219b2f426400ec1ed2f..7ade92aee45a34516517b51dcc79ade77efe0dce 100644 (file)
--- a/fs/netfs/main.c
+++ b/fs/netfs/main.c
@@ -39,6 +39,7 @@ static const char *netfs_origins[nr__netfs_io_origin] = {
        [NETFS_READ_GAPS]               = "RG",
        [NETFS_READ_SINGLE]             = "R1",
        [NETFS_READ_FOR_WRITE]          = "RW",
+       [NETFS_UNBUFFERED_READ]         = "UR",
        [NETFS_DIO_READ]                = "DR",
        [NETFS_WRITEBACK]               = "WB",
        [NETFS_WRITEBACK_SINGLE]        = "W1",

diff --git a/fs/netfs/misc.c b/fs/netfs/misc.c
index 77e7f7c79d27c2a69758d8c86c745bce53cfb643..43b67a28a8fa07b265c354b919766561d69285ad 100644 (file)
--- a/fs/netfs/misc.c
+++ b/fs/netfs/misc.c
@@ -461,6 +461,7 @@ all_collected:
                case NETFS_DIO_READ:
                case NETFS_DIO_WRITE:
                case NETFS_READ_SINGLE:
+               case NETFS_UNBUFFERED_READ:
                case NETFS_UNBUFFERED_WRITE:
                        break;
                default:

diff --git a/fs/netfs/objects.c b/fs/netfs/objects.c
index f603f107ba1d29a2c62d1f289cd01d78cd0e810a..e8c99738b5bbf26f48c6e02c418a05956a6c8385 100644 (file)
--- a/fs/netfs/objects.c
+++ b/fs/netfs/objects.c
@@ -59,6 +59,7 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,
            origin == NETFS_READ_GAPS ||
            origin == NETFS_READ_SINGLE ||
            origin == NETFS_READ_FOR_WRITE ||
+           origin == NETFS_UNBUFFERED_READ ||
            origin == NETFS_DIO_READ) {
                INIT_WORK(&rreq->work, netfs_read_collection_worker);
                rreq->io_streams[0].avail = true;

diff --git a/fs/netfs/read_collect.c b/fs/netfs/read_collect.c
index 31d00e30a59ced4eead2c65dc65d560ff57c6d8a..96ee18af28ef82996b4101b237a6ba1c9b36d781 100644 (file)
--- a/fs/netfs/read_collect.c
+++ b/fs/netfs/read_collect.c
@@ -340,7 +340,8 @@ static void netfs_rreq_assess_dio(struct netfs_io_request *rreq)
 {
        unsigned int i;
 
-       if (rreq->origin == NETFS_DIO_READ) {
+       if (rreq->origin == NETFS_UNBUFFERED_READ ||
+           rreq->origin == NETFS_DIO_READ) {
                for (i = 0; i < rreq->direct_bv_count; i++) {
                        flush_dcache_page(rreq->direct_bv[i].bv_page);
                        // TODO: cifs marks pages in the destination buffer
@@ -358,7 +359,8 @@ static void netfs_rreq_assess_dio(struct netfs_io_request *rreq)
        }
        if (rreq->netfs_ops->done)
                rreq->netfs_ops->done(rreq);
-       if (rreq->origin == NETFS_DIO_READ)
+       if (rreq->origin == NETFS_UNBUFFERED_READ ||
+           rreq->origin == NETFS_DIO_READ)
                inode_dio_end(rreq->inode);
 }
 
@@ -414,6 +416,7 @@ bool netfs_read_collection(struct netfs_io_request *rreq)
        //netfs_rreq_is_still_valid(rreq);
 
        switch (rreq->origin) {
+       case NETFS_UNBUFFERED_READ:
        case NETFS_DIO_READ:
        case NETFS_READ_GAPS:
                netfs_rreq_assess_dio(rreq);

diff --git a/fs/nfs/fscache.c b/fs/nfs/fscache.c
index e278a1ad1ca3e8a0f7aacb505a272d6c2602bc7a..8b07851787312bbe91de7ed59396b78cbc91ae9d 100644 (file)
--- a/fs/nfs/fscache.c
+++ b/fs/nfs/fscache.c
@@ -367,6 +367,7 @@ void nfs_netfs_read_completion(struct nfs_pgio_header *hdr)
 
        sreq = netfs->sreq;
        if (test_bit(NFS_IOHDR_EOF, &hdr->flags) &&
+           sreq->rreq->origin != NETFS_UNBUFFERED_READ &&
            sreq->rreq->origin != NETFS_DIO_READ)
                __set_bit(NETFS_SREQ_CLEAR_TAIL, &sreq->flags);
 

diff --git a/fs/smb/client/file.c b/fs/smb/client/file.c
index ba2817320c9b6be72ef90833f0646b3f1e866eea..ad917dbc00ef1a6c4ab96ba0a0ac69ade51a1e81 100644 (file)
--- a/fs/smb/client/file.c
+++ b/fs/smb/client/file.c
@@ -219,7 +219,8 @@ static void cifs_issue_read(struct netfs_io_subrequest *subreq)
                        goto failed;
        }
 
-       if (subreq->rreq->origin != NETFS_DIO_READ)
+       if (subreq->rreq->origin != NETFS_UNBUFFERED_READ &&
+           subreq->rreq->origin != NETFS_DIO_READ)
                __set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags);
 
        trace_netfs_sreq(subreq, netfs_sreq_trace_submit);

diff --git a/include/linux/netfs.h b/include/linux/netfs.h
index 7a649cfedc0967babd82684908287d909f98f9cb..065c17385e5314bcc1797ed95e4251d74c37c381 100644 (file)
--- a/include/linux/netfs.h
+++ b/include/linux/netfs.h
@@ -203,6 +203,7 @@ enum netfs_io_origin {
        NETFS_READ_GAPS,                /* This read is a synchronous read to fill gaps */
        NETFS_READ_SINGLE,              /* This read should be treated as a single object */
        NETFS_READ_FOR_WRITE,           /* This read is to prepare a write */
+       NETFS_UNBUFFERED_READ,          /* This is an unbuffered read */
        NETFS_DIO_READ,                 /* This is a direct I/O read */
        NETFS_WRITEBACK,                /* This write was triggered by writepages */
        NETFS_WRITEBACK_SINGLE,         /* This monolithic write was triggered by writepages */

diff --git a/include/trace/events/netfs.h b/include/trace/events/netfs.h
index d7ceae7e15c13e541452e30639e4fb78ebde3a23..333d2e38dd2cbc16b80a16fad06c782f13e6a001 100644 (file)
--- a/include/trace/events/netfs.h
+++ b/include/trace/events/netfs.h
@@ -39,6 +39,7 @@
        EM(NETFS_READ_GAPS,                     "RG")           \
        EM(NETFS_READ_SINGLE,                   "R1")           \
        EM(NETFS_READ_FOR_WRITE,                "RW")           \
+       EM(NETFS_UNBUFFERED_READ,               "UR")           \
        EM(NETFS_DIO_READ,                      "DR")           \
        EM(NETFS_WRITEBACK,                     "WB")           \
        EM(NETFS_WRITEBACK_SINGLE,              "W1")           \