[PATCH v1 0/2] add support for IO_ADVISE

Adds support for using the NFS v4.2 operation IO_ADVISE to
send client I/O access pattern hints to the server.

There is a one-to-one correspondence between the advice
(POSIX_FADV_*) given in fadvise64() and the bitmap mask sent
to the server. Any other advice given results in just
calling generic_fadvise().

The bitmap mask given by the server reply is just ignored
since the fadvise64() returns 0 on success. If server
replies with more than one bitmap word, only the first word
is stored on the nfs42_io_advise_res struct and all other
words are ignored.

Signed-off-by: Jorge Mora <redacted>
---
 fs/nfs/nfs42.h            |  1 +
 fs/nfs/nfs42proc.c        | 67 +++++++++++++++++++++++++++++++
 fs/nfs/nfs42xdr.c         | 84
+++++++++++++++++++++++++++++++++++++++
 fs/nfs/nfs4file.c         | 37 +++++++++++++++++
 fs/nfs/nfs4proc.c         |  1 +
 fs/nfs/nfs4xdr.c          |  1 +
 include/linux/nfs4.h      |  1 +
 include/linux/nfs_fs_sb.h |  1 +
 include/linux/nfs_xdr.h   | 28 +++++++++++++
 9 files changed, 221 insertions(+)

diff --git a/fs/nfs/nfs42.h b/fs/nfs/nfs42.h
index 0fe5aacbcfdf..c3e9fcd54c72 100644
--- a/fs/nfs/nfs42.h
+++ b/fs/nfs/nfs42.h

@@ -20,6 +20,7 @@ int nfs42_proc_allocate(struct file *, loff_t,

loff_t);
 ssize_t nfs42_proc_copy(struct file *, loff_t, struct file *,
loff_t, size_t,
                        struct nl4_server *, nfs4_stateid *, bool);
 int nfs42_proc_deallocate(struct file *, loff_t, loff_t);
+int nfs42_proc_io_advise(struct file *, loff_t, u64, u32);
 loff_t nfs42_proc_llseek(struct file *, loff_t, int);
 int nfs42_proc_layoutstats_generic(struct nfs_server *,
                                   struct nfs42_layoutstat_data *);

diff --git a/fs/nfs/nfs42proc.c b/fs/nfs/nfs42proc.c
index ecb428512fe1..af40f705386a 100644
--- a/fs/nfs/nfs42proc.c
+++ b/fs/nfs/nfs42proc.c

@@ -172,6 +172,73 @@ int nfs42_proc_deallocate(struct file *filep,

loff_t offset, loff_t len)
        return err;
 }
 
+static loff_t _nfs42_proc_io_advise(struct file *filep,
+               struct nfs_lock_context *lock, loff_t offset,
+               u64 count, u32 hints)
+{
+       struct inode *inode = file_inode(filep);
+       struct nfs42_io_advise_args args = {
+               .fh     = NFS_FH(inode),
+               .offset = offset,
+               .count  = count,
+               .hints  = hints,
+       };
+       struct nfs42_io_advise_res res;
+       struct rpc_message msg = {
+               .rpc_proc =
&nfs4_procedures[NFSPROC4_CLNT_IO_ADVISE],
+               .rpc_argp = &args,
+               .rpc_resp = &res,
+       };
+       struct nfs_server *server = NFS_SERVER(inode);
+       int status;
+
+       if (!nfs_server_capable(inode, NFS_CAP_IO_ADVISE))
+               return -ENOTSUPP;
+
+       status = nfs4_set_rw_stateid(&args.stateid, lock-

quoted

open_context,

+                       lock, FMODE_READ);
+       if (status) {
+               if (status == -EAGAIN)
+                       status = -NFS4ERR_BAD_STATEID;
+               return status;
+       }
+
+       status = nfs4_call_sync(server->client, server, &msg,
+                               &args.seq_args, &res.seq_res, 0);
+       if (status == -ENOTSUPP)
+               server->caps &= ~NFS_CAP_IO_ADVISE;
+       return status;
+}
+
+int nfs42_proc_io_advise(struct file *filep, loff_t offset, u64
count, u32 hints)
+{
+       struct nfs_server *server = NFS_SERVER(file_inode(filep));
+       struct nfs4_exception exception = { };
+       struct nfs_lock_context *lock;
+       loff_t err;
+
+       lock = nfs_get_lock_context(nfs_file_open_context(filep));
+       if (IS_ERR(lock))
+               return PTR_ERR(lock);
+
+       exception.inode = file_inode(filep);
+       exception.state = lock->open_context->state;
+
+       do {
+               err = _nfs42_proc_io_advise(filep, lock, offset,
count, hints);
+               if (err >= 0)
+                       break;
+               if (err == -ENOTSUPP) {
+                       err = -EOPNOTSUPP;
+                       break;
+               }
+               err = nfs4_handle_exception(server, err, &exception);
+       } while (exception.retry);
+
+       nfs_put_lock_context(lock);
+       return err;
+}
+
 static int handle_async_copy(struct nfs42_copy_res *res,
                             struct nfs_server *dst_server,
                             struct nfs_server *src_server,

diff --git a/fs/nfs/nfs42xdr.c b/fs/nfs/nfs42xdr.c
index d80ee88ca996..1e30729b0ed5 100644
--- a/fs/nfs/nfs42xdr.c
+++ b/fs/nfs/nfs42xdr.c

@@ -45,6 +45,14 @@

 #define encode_deallocate_maxsz                (op_encode_hdr_maxsz
+ \
                                         encode_fallocate_maxsz)
 #define decode_deallocate_maxsz                (op_decode_hdr_maxsz)
+#define nfs42_io_advise_bitmap_maxsz   2 /* bitmap length and hints
mask */
+#define encode_io_advise_maxsz         (op_encode_hdr_maxsz + \
+                                        encode_stateid_maxsz + \
+                                        2 /* offset */ + \
+                                        2 /* count */  + \
+                                        nfs42_io_advise_bitmap_maxsz
/* hints */)
+#define decode_io_advise_maxsz         (op_decode_hdr_maxsz + \
+                                        nfs42_io_advise_bitmap_maxsz
/* hints */)
 #define encode_read_plus_maxsz         (op_encode_hdr_maxsz + \
                                         encode_stateid_maxsz + 3)
 #define NFS42_READ_PLUS_DATA_SEGMENT_SIZE \

@@ -138,6 +146,14 @@

                                         decode_putfh_maxsz + \
                                         decode_deallocate_maxsz + \
                                         decode_getattr_maxsz)
+#define NFS4_enc_io_advise_sz          (compound_encode_hdr_maxsz +
\
+                                        encode_sequence_maxsz + \
+                                        encode_putfh_maxsz + \
+                                        encode_io_advise_maxsz)
+#define NFS4_dec_io_advise_sz          (compound_decode_hdr_maxsz +
\
+                                        decode_sequence_maxsz + \
+                                        decode_putfh_maxsz + \
+                                        decode_io_advise_maxsz)
 #define NFS4_enc_read_plus_sz          (compound_encode_hdr_maxsz +
\
                                         encode_sequence_maxsz + \
                                         encode_putfh_maxsz + \

@@ -342,6 +358,17 @@ static void encode_deallocate(struct xdr_stream

*xdr,
        encode_fallocate(xdr, args);
 }
 
+static void encode_io_advise(struct xdr_stream *xdr,
+                       const struct nfs42_io_advise_args *args,
+                       struct compound_hdr *hdr)
+{
+       encode_op_hdr(xdr, OP_IO_ADVISE, decode_io_advise_maxsz,
hdr);
+       encode_nfs4_stateid(xdr, &args->stateid);
+       encode_uint64(xdr, args->offset);
+       encode_uint64(xdr, args->count);
+       xdr_encode_bitmap4(xdr, &args->hints, 1);
+}
+
 static void encode_read_plus(struct xdr_stream *xdr,
                             const struct nfs_pgio_args *args,
                             struct compound_hdr *hdr)

@@ -764,6 +791,25 @@ static void nfs4_xdr_enc_deallocate(struct

rpc_rqst *req,
        encode_nops(&hdr);
 }
 
+/*
+ * Encode IO_ADVISE request
+ */
+static void nfs4_xdr_enc_io_advise(struct rpc_rqst *req,
+                                  struct xdr_stream *xdr,
+                                  const void *data)
+{
+       const struct nfs42_io_advise_args *args = data;
+       struct compound_hdr hdr = {
+               .minorversion = nfs4_xdr_minorversion(&args-

quoted

seq_args),

+       };
+
+       encode_compound_hdr(xdr, req, &hdr);
+       encode_sequence(xdr, &args->seq_args, &hdr);
+       encode_putfh(xdr, args->fh, &hdr);
+       encode_io_advise(xdr, args, &hdr);
+       encode_nops(&hdr);
+}
+
 /*
  * Encode READ_PLUS request
  */

@@ -1034,6 +1080,19 @@ static int decode_deallocate(struct xdr_stream

*xdr, struct nfs42_falloc_res *re
        return decode_op_hdr(xdr, OP_DEALLOCATE);
 }
 
+static int decode_io_advise(struct xdr_stream *xdr, struct
nfs42_io_advise_res *res)
+{
+       int status;
+
+       status = decode_op_hdr(xdr, OP_IO_ADVISE);
+       if (status)
+               return status;
+
+       if (unlikely(decode_bitmap4(xdr, &res->hints, 1) < 0))
+               return -EIO;
+       return 0;
+}
+
 struct read_plus_segment {
        enum data_content4 type;
        uint64_t offset;

@@ -1337,6 +1396,31 @@ static int nfs4_xdr_dec_deallocate(struct

rpc_rqst *rqstp,
        return status;
 }
 
+/*
+ * Decode IO_ADVISE response
+ */
+static int nfs4_xdr_dec_io_advise(struct rpc_rqst *rqstp,
+                                 struct xdr_stream *xdr,
+                                 void *data)
+{
+       struct nfs42_io_advise_res *res = data;
+       struct compound_hdr hdr;
+       int status;
+
+       status = decode_compound_hdr(xdr, &hdr);
+       if (status)
+               goto out;
+       status = decode_sequence(xdr, &res->seq_res, rqstp);
+       if (status)
+               goto out;
+       status = decode_putfh(xdr);
+       if (status)
+               goto out;
+       status = decode_io_advise(xdr, res);
+out:
+       return status;
+}
+
 /*
  * Decode READ_PLUS request
  */

diff --git a/fs/nfs/nfs4file.c b/fs/nfs/nfs4file.c
index 2563ed8580f3..5f6e4b5f1559 100644
--- a/fs/nfs/nfs4file.c
+++ b/fs/nfs/nfs4file.c

@@ -7,6 +7,7 @@

 #include <linux/fs.h>
 #include <linux/file.h>
 #include <linux/falloc.h>
+#include <linux/fadvise.h>
 #include <linux/mount.h>
 #include <linux/nfs_fs.h>
 #include <linux/nfs_ssc.h>

@@ -236,6 +237,41 @@ static long nfs42_fallocate(struct file *filep,

int mode, loff_t offset, loff_t
        return nfs42_proc_allocate(filep, offset, len);
 }
 
+static int nfs42_file_fadvise(struct file *filep, loff_t start,
loff_t len, int advice)
+{
+       int ret;
+       unsigned int hints = 0;
+
+       switch (advice) {
+       case POSIX_FADV_NORMAL:
+               hints = NFS_IO_ADVISE4_NORMAL;
+               break;
+       case POSIX_FADV_RANDOM:
+               hints = NFS_IO_ADVISE4_RANDOM;
+               break;
+       case POSIX_FADV_SEQUENTIAL:
+               hints = NFS_IO_ADVISE4_SEQUENTIAL;
+               break;
+       case POSIX_FADV_WILLNEED:
+               hints = NFS_IO_ADVISE4_WILLNEED;
+               break;
+       case POSIX_FADV_DONTNEED:
+               hints = NFS_IO_ADVISE4_DONTNEED;
+               break;
+       case POSIX_FADV_NOREUSE:
+               hints = NFS_IO_ADVISE4_NOREUSE;
+               break;
+       default:
+               goto out;
+       }
+
+       ret = nfs42_proc_io_advise(filep, start, len, hints);
+       if (ret < 0)
+               return ret;

+out:
+       return generic_fadvise(filep, start, len, advice);
+}
+
 static loff_t nfs42_remap_file_range(struct file *src_file, loff_t
src_off,
                struct file *dst_file, loff_t dst_off, loff_t count,
                unsigned int remap_flags)

@@ -462,6 +498,7 @@ const struct file_operations nfs4_file_operations

= {
        .copy_file_range = nfs4_copy_file_range,
        .llseek         = nfs4_file_llseek,
        .fallocate      = nfs42_fallocate,
+       .fadvise        = nfs42_file_fadvise,
        .remap_file_range = nfs42_remap_file_range,
 #else
        .llseek         = nfs_file_llseek,

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 40d749f29ed3..89b21b94f948 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c

@@ -10529,6 +10529,7 @@ static const struct nfs4_minor_version_ops

nfs_v4_2_minor_ops = {
                | NFS_CAP_OFFLOAD_CANCEL
                | NFS_CAP_COPY_NOTIFY
                | NFS_CAP_DEALLOCATE
+               | NFS_CAP_IO_ADVISE
                | NFS_CAP_SEEK
                | NFS_CAP_LAYOUTSTATS
                | NFS_CAP_CLONE

diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index deec76cf5afe..962c5b023769 100644
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c

@@ -7698,6 +7698,7 @@ const struct rpc_procinfo nfs4_procedures[] = {

        PROC42(SEEK,            enc_seek,               dec_seek),
        PROC42(ALLOCATE,        enc_allocate,           dec_allocate)
,
        PROC42(DEALLOCATE,      enc_deallocate,         dec_deallocat
e),
+       PROC42(IO_ADVISE,       enc_io_advise,          dec_io_advise
),
        PROC42(LAYOUTSTATS,     enc_layoutstats,        dec_layoutsta
ts),
        PROC42(CLONE,           enc_clone,              dec_clone),
        PROC42(COPY,            enc_copy,               dec_copy),

diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
index 8d04b6a5964c..a1d925b1f06b 100644
--- a/include/linux/nfs4.h
+++ b/include/linux/nfs4.h

@@ -557,6 +557,7 @@ enum {

        NFSPROC4_CLNT_LISTXATTRS,
        NFSPROC4_CLNT_REMOVEXATTR,
        NFSPROC4_CLNT_READ_PLUS,
+       NFSPROC4_CLNT_IO_ADVISE,
 };
 
 /* nfs41 types */

diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index ea2f7e6b1b0b..38eb0cd86979 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h

@@ -270,6 +270,7 @@ struct nfs_server {

 #define NFS_CAP_LGOPEN         (1U << 5)
 #define NFS_CAP_CASE_INSENSITIVE       (1U << 6)
 #define NFS_CAP_CASE_PRESERVING        (1U << 7)
+#define NFS_CAP_IO_ADVISE      (1U << 13)
 #define NFS_CAP_POSIX_LOCK     (1U << 14)
 #define NFS_CAP_UIDGID_NOMAP   (1U << 15)
 #define NFS_CAP_STATEID_NFSV41 (1U << 16)

diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index e86cf6642d21..3a52e5dc2fea 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h

@@ -17,6 +17,18 @@

 
 #define NFS_BITMASK_SZ         3
 
+#define NFS_IO_ADVISE4_NORMAL                  (1U << 0)
+#define NFS_IO_ADVISE4_SEQUENTIAL              (1U << 1)
+#define NFS_IO_ADVISE4_SEQUENTIAL_BACKWARDS    (1U << 2)
+#define NFS_IO_ADVISE4_RANDOM                  (1U << 3)
+#define NFS_IO_ADVISE4_WILLNEED                        (1U << 4)
+#define NFS_IO_ADVISE4_WILLNEED_OPPORTUNISTIC  (1U << 5)
+#define NFS_IO_ADVISE4_DONTNEED                        (1U << 6)
+#define NFS_IO_ADVISE4_NOREUSE                 (1U << 7)
+#define NFS_IO_ADVISE4_READ                    (1U << 8)
+#define NFS_IO_ADVISE4_WRITE                   (1U << 9)
+#define NFS_IO_ADVISE4_INIT_PROXIMITY          (1U << 10)
+
 struct nfs4_string {
        unsigned int len;
        char *data;

@@ -1449,6 +1461,22 @@ struct nfs42_falloc_res {

        const struct nfs_server         *falloc_server;
 };
 
+struct nfs42_io_advise_args {
+       struct nfs4_sequence_args       seq_args;
+
+       struct nfs_fh                   *fh;
+       nfs4_stateid                    stateid;
+       loff_t                          offset;
+       u64                             count;
+       u32                             hints;
+};
+
+struct nfs42_io_advise_res {
+       struct nfs4_sequence_res        seq_res;
+
+       u32                             hints;
+};
+
 struct nfs42_copy_args {
        struct nfs4_sequence_args       seq_args;