pnfs for 2.6.40

From: Marc Eshel <[email protected]>

Note: This functionlaity is incomplete as all layout segments referring to the 'to be removed device id' need to be reaped, and all in flight I/O drained.

Signed-off-by Benny Halevy <[email protected]>

---
 fs/nfs/callback.h          |   17 ++++++++
 fs/nfs/callback_proc.c     |   51 +++++++++++++++++++++++ fs/nfs/callback_xdr.c      |   96 +++++++++++++++++++++++++++++++++++++++++++- fs/nfs/nfs4filelayout.c    |    1 +
 fs/nfs/nfs4filelayout.h    |    1 +
 fs/nfs/nfs4filelayoutdev.c |   38 +++++++++++++++++- fs/nfs/pnfs.h              |    3 +

 7 files changed, 205 insertions(+), 2 deletions(-)

fs/nfs/callback.h +17 -0

index 46d93ce..b257383 100644
@@ -167,6 +167,23 @@ extern unsigned nfs4_callback_layoutrecall(
 
  extern void nfs4_check_drain_bc_complete(struct nfs4_session *ses);
  extern void nfs4_cb_take_slot(struct nfs_client *clp);
+
+struct cb_devicenotifyitem {
+       uint32_t                cbd_notify_type;
+       uint32_t                cbd_layout_type;
+       struct nfs4_deviceid    cbd_dev_id;
+       uint32_t                cbd_immediate;
+};
+
+struct cb_devicenotifyargs {
+       int                              ndevs;
+       struct cb_devicenotifyitem       *devs;
+};
+
+extern __be32 nfs4_callback_devicenotify(
+       struct cb_devicenotifyargs *args,
+       void *dummy, struct cb_process_state *cps);
+
  #endif /* CONFIG_NFS_V4_1 */
  extern int check_gss_callback_principal(struct nfs_client *, struct svc_rqst *);
  extern __be32 nfs4_callback_getattr(struct cb_getattrargs *args,

fs/nfs/callback_proc.c +25 -0

index 2f41dcce..975c8f2 100644
@@ -241,6 +241,57 @@ static void pnfs_recall_all_layouts(struct nfs_client *clp)
        do_callback_layoutrecall(clp, &args);
  }
 
+__be32 nfs4_callback_devicenotify(struct cb_devicenotifyargs *args,
+                                 void *dummy, struct cb_process_state *cps)
+{
+       int i;
+       u32 res = 0;
+       struct nfs_client *clp = cps->clp;
+       struct nfs_server *server = NULL;
+
+       dprintk("%s: -->\n", __func__);
+
+       if (!clp) {
+               res = NFS4ERR_OP_NOT_IN_SESSION;
+               goto out;
+       }
+
+       for (i = 0; i < args->ndevs; i++) {
+               struct cb_devicenotifyitem *dev = &args->devs[i];
+
+               if (!server ||
+                   server->pnfs_curr_ld->id != dev->cbd_layout_type) {
+                       rcu_read_lock();
+                       list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
+                               if (server->pnfs_curr_ld &&
+                                   server->pnfs_curr_ld->id == dev->cbd_layout_type) {
+                                       rcu_read_unlock();

fs/nfs/callback_proc.c +16 -0

+                       res = NFS4ERR_NOTSUPP;
+                       break;
+               }
+               if (dev->cbd_notify_type == NOTIFY_DEVICEID4_CHANGE)
+                       dprintk("%s: NOTIFY_DEVICEID4_CHANGE not supported, "
+                               "deleting instead\n", __func__);
+               server->pnfs_curr_ld->delete_deviceid(&dev->cbd_dev_id);
+       }
+
+out:
+       kfree(args->devs);
+       dprintk("%s: exit with status = %u\n",
+               __func__, res);
+       return cpu_to_be32(res);
+}
+
  int nfs41_validate_delegation_stateid(struct nfs_delegation *delegation, const nfs4_stateid *stateid)
  {
        if (delegation == NULL)

fs/nfs/callback_xdr.c +88 -0

index 00ecf62..c6c86a7 100644
@@ -25,6 +25,7 @@
 
  #if defined(CONFIG_NFS_V4_1)
  #define CB_OP_LAYOUTRECALL_RES_MAXSZ   (CB_OP_HDR_RES_MAXSZ)
+#define CB_OP_DEVICENOTIFY_RES_MAXSZ   (CB_OP_HDR_RES_MAXSZ)
  #define CB_OP_SEQUENCE_RES_MAXSZ       (CB_OP_HDR_RES_MAXSZ + \
                                        4 + 1 + 3)
  #define CB_OP_RECALLANY_RES_MAXSZ      (CB_OP_HDR_RES_MAXSZ)

@@ -284,6 +285,93 @@ out:
        return status;
  }
 
+static
+__be32 decode_devicenotify_args(struct svc_rqst *rqstp,
+                               struct xdr_stream *xdr,
+                               struct cb_devicenotifyargs *args)
+{
+       __be32 *p;
+       __be32 status = 0;
+       u32 tmp;
+       int n, i;
+       args->ndevs = 0;
+
+       /* Num of device notifications */
+       p = read_buf(xdr, sizeof(uint32_t));
+       if (unlikely(p == NULL)) {
+               status = htonl(NFS4ERR_BADXDR);
+               goto out;
+       }
+       n = ntohl(*p++);
+       if (n <= 0)
+               goto out;
+
+       args->devs = kmalloc(n * sizeof(*args->devs), GFP_KERNEL);
+       if (!args->devs) {
+               status = htonl(NFS4ERR_DELAY);
+               goto out;
+       }
+
+       /* Decode each dev notification */
+       for (i = 0; i < n; i++) {
+               struct cb_devicenotifyitem *dev = &args->devs[i];
+
+               p = read_buf(xdr, (4 * sizeof(uint32_t)) + NFS4_DEVICEID4_SIZE);
+               if (unlikely(p == NULL)) {
+                       status = htonl(NFS4ERR_BADXDR);
+                       goto err;
+               }
+
+               tmp = ntohl(*p++);      /* bitmap size */
+               if (tmp != 1) {
+                       status = htonl(NFS4ERR_INVAL);
+                       goto err;
+               }
+               dev->cbd_notify_type = ntohl(*p++);
+               if (dev->cbd_notify_type != NOTIFY_DEVICEID4_CHANGE &&
+                   dev->cbd_notify_type != NOTIFY_DEVICEID4_DELETE) {
+                       status = htonl(NFS4ERR_INVAL);
+                       goto err;
+               }
+
+               tmp = ntohl(*p++);      /* opaque size */
+               if (((dev->cbd_notify_type == NOTIFY_DEVICEID4_CHANGE) &&
+                    (tmp != NFS4_DEVICEID4_SIZE + 8)) ||
+                   ((dev->cbd_notify_type == NOTIFY_DEVICEID4_DELETE) &&
+                    (tmp != NFS4_DEVICEID4_SIZE + 4))) {
+                       status = htonl(NFS4ERR_INVAL);
+                       goto err;
+               }
+               dev->cbd_layout_type = ntohl(*p++);
+               memcpy(dev->cbd_dev_id.data, p, NFS4_DEVICEID4_SIZE);
+               p += XDR_QUADLEN(NFS4_DEVICEID4_SIZE);
+
+               if (dev->cbd_layout_type == NOTIFY_DEVICEID4_CHANGE) {
+                       p = read_buf(xdr, sizeof(uint32_t));
+                       if (unlikely(p == NULL)) {
+                               status = htonl(NFS4ERR_BADXDR);
+                               goto err;
+                       }
+                       dev->cbd_immediate = ntohl(*p++);
+               } else {
+                       dev->cbd_immediate = 0;
+               }
+
+               args->ndevs++;
+
+               dprintk("%s: type %d layout 0x%x immediate %d\n",
+                       __func__, dev->cbd_notify_type, dev->cbd_layout_type,
+                       dev->cbd_immediate);
+       }
+out:
+       dprintk("%s: status %d ndevs %d\n",
+               __func__, ntohl(status), args->ndevs);
+       return status;
+err:
+       kfree(args->devs);
+       goto out;
+}
+
  static __be32 decode_sessionid(struct xdr_stream *xdr,
                                 struct nfs4_sessionid *sid)
  {

@@ -639,10 +727,10 @@ preprocess_nfs41_op(int nop, unsigned int op_nr, struct callback_op **op)

       case OP_CB_RECALL_ANY:
       case OP_CB_RECALL_SLOT:
       case OP_CB_LAYOUTRECALL:
+       case OP_CB_NOTIFY_DEVICEID:
               *op = &callback_ops[op_nr];
               break;

-       case OP_CB_NOTIFY_DEVICEID:
       case OP_CB_NOTIFY:
       case OP_CB_PUSH_DELEG:
       case OP_CB_RECALLABLE_OBJ_AVAIL:

fs/nfs/callback_xdr.c +6 -0

@@ -849,6 +937,12 @@ static struct callback_op callback_ops[] = {
                        (callback_decode_arg_t)decode_layoutrecall_args,
                .res_maxsize = CB_OP_LAYOUTRECALL_RES_MAXSZ,
        },
+       [OP_CB_NOTIFY_DEVICEID] = {
+               .process_op = (callback_process_op_t)nfs4_callback_devicenotify,
+               .decode_args =
+                       (callback_decode_arg_t)decode_devicenotify_args,
+               .res_maxsize = CB_OP_DEVICENOTIFY_RES_MAXSZ,
+       },
        [OP_CB_SEQUENCE] = {
                .process_op = (callback_process_op_t)nfs4_callback_sequence,
                .decode_args = (callback_decode_arg_t)decode_cb_sequence_args,

fs/nfs/nfs4filelayout.c +1 -0

index e6e0c294..2feab7f 100644
@@ -867,6 +867,7 @@ static struct pnfs_layoutdriver_type filelayout_type = {
        .commit_pagelist        = filelayout_commit_pagelist,
        .read_pagelist          = filelayout_read_pagelist,
        .write_pagelist         = filelayout_write_pagelist,
+       .delete_deviceid        = filelayout_delete_deviceid,
  };
 
  static int __init nfs4filelayout_init(void)

fs/nfs/nfs4filelayout.h +0 -0

index 7c44579..8be70ab 100644
@@ -105,5 +105,6 @@ nfs4_fl_find_get_deviceid(struct nfs4_deviceid *dev_id);
  extern void nfs4_fl_put_deviceid(struct nfs4_file_layout_dsaddr *dsaddr);

 struct nfs4_file_layout_dsaddr *
 get_device_info(struct inode *inode, struct nfs4_deviceid *dev_id); +void filelayout_delete_deviceid(struct nfs4_deviceid *);

 #endif /* FS_NFS_NFS4FILELAYOUT_H */

fs/nfs/nfs4filelayoutdev.c +37 -1

index de5350f..601aaea 100644
@@ -601,7 +601,7 @@ void
  nfs4_fl_put_deviceid(struct nfs4_file_layout_dsaddr *dsaddr)
  {
        if (atomic_dec_and_lock(&dsaddr->ref, &filelayout_deviceid_lock)) {
-               hlist_del_rcu(&dsaddr->node);
+               hlist_del_init_rcu(&dsaddr->node);
                spin_unlock(&filelayout_deviceid_lock);
 
                synchronize_rcu();

@@ -631,6 +631,42 @@ fail:
        return NULL;
  }
 
+static struct nfs4_file_layout_dsaddr *
+nfs4_fl_unhash_deviceid(struct nfs4_deviceid *id)
+{
+       struct nfs4_file_layout_dsaddr *d;
+       struct hlist_node *n;
+       long hash = nfs4_fl_deviceid_hash(id);
+
+       dprintk("%s: hash %ld\n", __func__, hash);
+       rcu_read_lock();
+       hlist_for_each_entry_rcu(d, n, &filelayout_deviceid_cache[hash], node)
+               if (!memcmp(&d->deviceid, id, sizeof(*id)))
+                       goto found;
+       rcu_read_unlock();
+       return NULL;
+
+found:
+       rcu_read_unlock();
+       spin_lock(&filelayout_deviceid_lock);
+       hlist_del_init_rcu(&d->node);
+       spin_unlock(&filelayout_deviceid_lock);
+       synchronize_rcu();
+
+       return d;
+}
+
+void
+filelayout_delete_deviceid(struct nfs4_deviceid *id)
+{
+       struct nfs4_file_layout_dsaddr *d;
+
+       d = nfs4_fl_unhash_deviceid(id);
+       /* balance the initial ref taken in decode_and_add_device */
+       if (d && atomic_dec_and_test(&d->ref))
+               nfs4_fl_free_deviceid(d);
+}
+
  /*
  * Want res = (offset - layout->pattern_offset)/ layout->stripe_unit
  * Then: ((res + fsi) % dsaddr->stripe_count)

fs/nfs/pnfs.h +3 -1

index bc48272..4cb0a0d 100644
@@ -89,6 +89,9 @@ struct pnfs_layoutdriver_type {
         */
        enum pnfs_try_status (*read_pagelist) (struct nfs_read_data *nfs_data);
        enum pnfs_try_status (*write_pagelist) (struct nfs_write_data *nfs_data, int how);
+
+       /* device notification methods */
+       void (*delete_deviceid)(struct nfs4_deviceid *);
  };
 
  struct pnfs_layout_hdr {
--

1.7.3.4

--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in the body of a message to [email protected]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Quoted 81 lines · Benny Halevy

From: Marc Eshel <[email protected]>

Note: This functionlaity is incomplete as all layout segments referring to the 'to be removed device id' need to be reaped, and all in flight I/O drained.

Signed-off-by Benny Halevy <[email protected]>

---
 fs/nfs/callback.h          |   17 ++++++++
 fs/nfs/callback_proc.c     |   51 +++++++++++++++++++++++
 fs/nfs/callback_xdr.c      |   96 +++++++++++++++++++++++++++++++++++++++++++-
 fs/nfs/nfs4filelayout.c    |    1 +
 fs/nfs/nfs4filelayout.h    |    1 +
 fs/nfs/nfs4filelayoutdev.c |   38 +++++++++++++++++-
 fs/nfs/pnfs.h              |    3 +
 7 files changed, 205 insertions(+), 2 deletions(-)

fs/nfs/callback.h +17 -0

index 46d93ce..b257383 100644
@@ -167,6 +167,23 @@ extern unsigned nfs4_callback_layoutrecall(
 
 extern void nfs4_check_drain_bc_complete(struct nfs4_session *ses);
 extern void nfs4_cb_take_slot(struct nfs_client *clp);
+
+struct cb_devicenotifyitem {
+       uint32_t                cbd_notify_type;
+       uint32_t                cbd_layout_type;
+       struct nfs4_deviceid    cbd_dev_id;
+       uint32_t                cbd_immediate;
+};
+
+struct cb_devicenotifyargs {
+       int                              ndevs;
+       struct cb_devicenotifyitem       *devs;
+};
+
+extern __be32 nfs4_callback_devicenotify(
+       struct cb_devicenotifyargs *args,
+       void *dummy, struct cb_process_state *cps);
+
 #endif /* CONFIG_NFS_V4_1 */
 extern int check_gss_callback_principal(struct nfs_client *, struct svc_rqst *);
 extern __be32 nfs4_callback_getattr(struct cb_getattrargs *args,

fs/nfs/callback_proc.c +29 -0

index 2f41dcce..975c8f2 100644
@@ -241,6 +241,57 @@ static void pnfs_recall_all_layouts(struct nfs_client *clp)
       do_callback_layoutrecall(clp, &args);
 }
 
+__be32 nfs4_callback_devicenotify(struct cb_devicenotifyargs *args,
+                                 void *dummy, struct cb_process_state *cps)
+{
+       int i;
+       u32 res = 0;
+       struct nfs_client *clp = cps->clp;
+       struct nfs_server *server = NULL;
+
+       dprintk("%s: -->\n", __func__);
+
+       if (!clp) {
+               res = NFS4ERR_OP_NOT_IN_SESSION;
+               goto out;
+       }
+
+       for (i = 0; i < args->ndevs; i++) {
+               struct cb_devicenotifyitem *dev = &args->devs[i];
+
+               if (!server ||
+                   server->pnfs_curr_ld->id != dev->cbd_layout_type) {
+                       rcu_read_lock();
+                       list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
+                               if (server->pnfs_curr_ld &&
+                                   server->pnfs_curr_ld->id == dev->cbd_layout_type) {
+                                       rcu_read_unlock();
+                                       goto found;
+                               }
+                       rcu_read_unlock();
+                       dprintk("%s: layout type %u not found\n",

fs/nfs/callback_proc.c static void pnfs_recall_all_layouts(struct nfs_client *clp) · line 278

Quoted 6 lines

fs/nfs/callback_proc.c +6 -0

+                               __func__, dev->cbd_layout_type);
+                       continue;
+               }
+
+       found:
+               if (!server->pnfs_curr_ld->delete_deviceid) {

You shouldn't be accessing server outside the rcu_read_lock.

Quoted 246 lines

fs/nfs/callback_proc.c +16 -0

+                       res = NFS4ERR_NOTSUPP;
+                       break;
+               }
+               if (dev->cbd_notify_type == NOTIFY_DEVICEID4_CHANGE)
+                       dprintk("%s: NOTIFY_DEVICEID4_CHANGE not supported, "
+                               "deleting instead\n", __func__);
+               server->pnfs_curr_ld->delete_deviceid(&dev->cbd_dev_id);
+       }
+
+out:
+       kfree(args->devs);
+       dprintk("%s: exit with status = %u\n",
+               __func__, res);
+       return cpu_to_be32(res);
+}
+
 int nfs41_validate_delegation_stateid(struct nfs_delegation *delegation, const nfs4_stateid *stateid)
 {
       if (delegation == NULL)

fs/nfs/callback_xdr.c +95 -1

index 00ecf62..c6c86a7 100644
@@ -25,6 +25,7 @@
 
 #if defined(CONFIG_NFS_V4_1)
 #define CB_OP_LAYOUTRECALL_RES_MAXSZ   (CB_OP_HDR_RES_MAXSZ)
+#define CB_OP_DEVICENOTIFY_RES_MAXSZ   (CB_OP_HDR_RES_MAXSZ)
 #define CB_OP_SEQUENCE_RES_MAXSZ       (CB_OP_HDR_RES_MAXSZ + \
                                       4 + 1 + 3)
 #define CB_OP_RECALLANY_RES_MAXSZ      (CB_OP_HDR_RES_MAXSZ)

@@ -284,6 +285,93 @@ out:
       return status;
 }
 
+static
+__be32 decode_devicenotify_args(struct svc_rqst *rqstp,
+                               struct xdr_stream *xdr,
+                               struct cb_devicenotifyargs *args)
+{
+       __be32 *p;
+       __be32 status = 0;
+       u32 tmp;
+       int n, i;
+       args->ndevs = 0;
+
+       /* Num of device notifications */
+       p = read_buf(xdr, sizeof(uint32_t));
+       if (unlikely(p == NULL)) {
+               status = htonl(NFS4ERR_BADXDR);
+               goto out;
+       }
+       n = ntohl(*p++);
+       if (n <= 0)
+               goto out;
+
+       args->devs = kmalloc(n * sizeof(*args->devs), GFP_KERNEL);
+       if (!args->devs) {
+               status = htonl(NFS4ERR_DELAY);
+               goto out;
+       }
+
+       /* Decode each dev notification */
+       for (i = 0; i < n; i++) {
+               struct cb_devicenotifyitem *dev = &args->devs[i];
+
+               p = read_buf(xdr, (4 * sizeof(uint32_t)) + NFS4_DEVICEID4_SIZE);
+               if (unlikely(p == NULL)) {
+                       status = htonl(NFS4ERR_BADXDR);
+                       goto err;
+               }
+
+               tmp = ntohl(*p++);      /* bitmap size */
+               if (tmp != 1) {
+                       status = htonl(NFS4ERR_INVAL);
+                       goto err;
+               }
+               dev->cbd_notify_type = ntohl(*p++);
+               if (dev->cbd_notify_type != NOTIFY_DEVICEID4_CHANGE &&
+                   dev->cbd_notify_type != NOTIFY_DEVICEID4_DELETE) {
+                       status = htonl(NFS4ERR_INVAL);
+                       goto err;
+               }
+
+               tmp = ntohl(*p++);      /* opaque size */
+               if (((dev->cbd_notify_type == NOTIFY_DEVICEID4_CHANGE) &&
+                    (tmp != NFS4_DEVICEID4_SIZE + 8)) ||
+                   ((dev->cbd_notify_type == NOTIFY_DEVICEID4_DELETE) &&
+                    (tmp != NFS4_DEVICEID4_SIZE + 4))) {
+                       status = htonl(NFS4ERR_INVAL);
+                       goto err;
+               }
+               dev->cbd_layout_type = ntohl(*p++);
+               memcpy(dev->cbd_dev_id.data, p, NFS4_DEVICEID4_SIZE);
+               p += XDR_QUADLEN(NFS4_DEVICEID4_SIZE);
+
+               if (dev->cbd_layout_type == NOTIFY_DEVICEID4_CHANGE) {
+                       p = read_buf(xdr, sizeof(uint32_t));
+                       if (unlikely(p == NULL)) {
+                               status = htonl(NFS4ERR_BADXDR);
+                               goto err;
+                       }
+                       dev->cbd_immediate = ntohl(*p++);
+               } else {
+                       dev->cbd_immediate = 0;
+               }
+
+               args->ndevs++;
+
+               dprintk("%s: type %d layout 0x%x immediate %d\n",
+                       __func__, dev->cbd_notify_type, dev->cbd_layout_type,
+                       dev->cbd_immediate);
+       }
+out:
+       dprintk("%s: status %d ndevs %d\n",
+               __func__, ntohl(status), args->ndevs);
+       return status;
+err:
+       kfree(args->devs);
+       goto out;
+}
+
 static __be32 decode_sessionid(struct xdr_stream *xdr,
                                struct nfs4_sessionid *sid)
 {

@@ -639,10 +727,10 @@ preprocess_nfs41_op(int nop, unsigned int op_nr, struct callback_op **op)
       case OP_CB_RECALL_ANY:
       case OP_CB_RECALL_SLOT:
       case OP_CB_LAYOUTRECALL:
+       case OP_CB_NOTIFY_DEVICEID:
               *op = &callback_ops[op_nr];
               break;
 
-       case OP_CB_NOTIFY_DEVICEID:
       case OP_CB_NOTIFY:
       case OP_CB_PUSH_DELEG:
       case OP_CB_RECALLABLE_OBJ_AVAIL:

@@ -849,6 +937,12 @@ static struct callback_op callback_ops[] = {
                       (callback_decode_arg_t)decode_layoutrecall_args,
               .res_maxsize = CB_OP_LAYOUTRECALL_RES_MAXSZ,
       },
+       [OP_CB_NOTIFY_DEVICEID] = {
+               .process_op = (callback_process_op_t)nfs4_callback_devicenotify,
+               .decode_args =
+                       (callback_decode_arg_t)decode_devicenotify_args,
+               .res_maxsize = CB_OP_DEVICENOTIFY_RES_MAXSZ,
+       },
       [OP_CB_SEQUENCE] = {
               .process_op = (callback_process_op_t)nfs4_callback_sequence,
               .decode_args = (callback_decode_arg_t)decode_cb_sequence_args,

fs/nfs/nfs4filelayout.c +1 -0

index e6e0c294..2feab7f 100644
@@ -867,6 +867,7 @@ static struct pnfs_layoutdriver_type filelayout_type = {
       .commit_pagelist        = filelayout_commit_pagelist,
       .read_pagelist          = filelayout_read_pagelist,
       .write_pagelist         = filelayout_write_pagelist,
+       .delete_deviceid        = filelayout_delete_deviceid,
 };
 
 static int __init nfs4filelayout_init(void)

fs/nfs/nfs4filelayout.h +1 -0

index 7c44579..8be70ab 100644
@@ -105,5 +105,6 @@ nfs4_fl_find_get_deviceid(struct nfs4_deviceid *dev_id);
 extern void nfs4_fl_put_deviceid(struct nfs4_file_layout_dsaddr *dsaddr);
 struct nfs4_file_layout_dsaddr *
 get_device_info(struct inode *inode, struct nfs4_deviceid *dev_id);
+void filelayout_delete_deviceid(struct nfs4_deviceid *);
 
 #endif /* FS_NFS_NFS4FILELAYOUT_H */

fs/nfs/nfs4filelayoutdev.c +37 -1

index de5350f..601aaea 100644
@@ -601,7 +601,7 @@ void
 nfs4_fl_put_deviceid(struct nfs4_file_layout_dsaddr *dsaddr)
 {
       if (atomic_dec_and_lock(&dsaddr->ref, &filelayout_deviceid_lock)) {
-               hlist_del_rcu(&dsaddr->node);
+               hlist_del_init_rcu(&dsaddr->node);
               spin_unlock(&filelayout_deviceid_lock);
 
               synchronize_rcu();

@@ -631,6 +631,42 @@ fail:
       return NULL;
 }
 
+static struct nfs4_file_layout_dsaddr *
+nfs4_fl_unhash_deviceid(struct nfs4_deviceid *id)
+{
+       struct nfs4_file_layout_dsaddr *d;
+       struct hlist_node *n;
+       long hash = nfs4_fl_deviceid_hash(id);
+
+       dprintk("%s: hash %ld\n", __func__, hash);
+       rcu_read_lock();
+       hlist_for_each_entry_rcu(d, n, &filelayout_deviceid_cache[hash], node)
+               if (!memcmp(&d->deviceid, id, sizeof(*id)))
+                       goto found;
+       rcu_read_unlock();
+       return NULL;
+
+found:
+       rcu_read_unlock();
+       spin_lock(&filelayout_deviceid_lock);
+       hlist_del_init_rcu(&d->node);
+       spin_unlock(&filelayout_deviceid_lock);
+       synchronize_rcu();
+
+       return d;
+}
+
+void
+filelayout_delete_deviceid(struct nfs4_deviceid *id)
+{
+       struct nfs4_file_layout_dsaddr *d;
+
+       d = nfs4_fl_unhash_deviceid(id);
+       /* balance the initial ref taken in decode_and_add_device */
+       if (d && atomic_dec_and_test(&d->ref))
+               nfs4_fl_free_deviceid(d);
+}
+
 /*
 * Want res = (offset - layout->pattern_offset)/ layout->stripe_unit
 * Then: ((res + fsi) % dsaddr->stripe_count)

fs/nfs/pnfs.h +3 -1

index bc48272..4cb0a0d 100644
@@ -89,6 +89,9 @@ struct pnfs_layoutdriver_type {
        */
       enum pnfs_try_status (*read_pagelist) (struct nfs_read_data *nfs_data);
       enum pnfs_try_status (*write_pagelist) (struct nfs_write_data *nfs_data, int how);
+
+       /* device notification methods */
+       void (*delete_deviceid)(struct nfs4_deviceid *);
 };
 
 struct pnfs_layout_hdr {
--

1.7.3.4

Quoted 5 lines

--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html

--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html

From: Andy Adamson <[email protected]>

Signed-off-by Dean Hildebrand <[email protected]>

Signed-off-by Fred Isaman <[email protected]>

Signed-off-by Andy Adamson <[email protected]>

Signed-off-by Benny Halevy <[email protected]>

---
 fs/nfs/direct.c |  160 +++++++++++++++++++++++++++++++-----------------------

 1 files changed, 92 insertions(+), 68 deletions(-)

fs/nfs/direct.c +92 -69

index 8eea253..55dffb7 100644
@@ -272,6 +272,38 @@ static const struct rpc_call_ops nfs_read_direct_ops = {
        .rpc_release = nfs_direct_read_release,
  };
 
+static long nfs_direct_read_execute(struct nfs_read_data *data,
+                                   struct rpc_task_setup *task_setup_data,
+                                   struct rpc_message *msg)
+{
+       struct inode *inode = data->inode;
+       struct rpc_task *task;
+
+       nfs_fattr_init(&data->fattr);
+       msg->rpc_argp = &data->args;
+       msg->rpc_resp = &data->res;
+
+       task_setup_data->task = &data->task;
+       task_setup_data->callback_data = data;
+       NFS_PROTO(inode)->read_setup(data, msg);
+
+       task = rpc_run_task(task_setup_data);
+       if (IS_ERR(task))
+               return PTR_ERR(task);
+
+       rpc_put_task(task);
+
+       dprintk("NFS: %5u initiated direct read call "
+               "(req %s/%lld, %u bytes @ offset %llu)\n",
+               data->task.tk_pid,
+               inode->i_sb->s_id,
+               (long long)NFS_FILEID(inode),
+               data->args.count,
+               (unsigned long long)data->args.offset);
+
+       return 0;
+}
+
  /*
  * For each rsize'd chunk of the user's buffer, dispatch an NFS READ
  * operation.  If nfs_readdata_alloc() or get_user_pages() fails,

@@ -288,7 +320,6 @@ static ssize_t nfs_direct_read_schedule_segment(struct nfs_direct_req *dreq,
        unsigned long user_addr = (unsigned long)iov->iov_base;
        size_t count = iov->iov_len;
        size_t rsize = NFS_SERVER(inode)->rsize;
-       struct rpc_task *task;
        struct rpc_message msg = {
                .rpc_cred = ctx->cred,
        };

@@ -349,26 +380,9 @@ static ssize_t nfs_direct_read_schedule_segment(struct nfs_direct_req *dreq,
                data->res.fattr = &data->fattr;
                data->res.eof = 0;
                data->res.count = bytes;
-               nfs_fattr_init(&data->fattr);
-               msg.rpc_argp = &data->args;
-               msg.rpc_resp = &data->res;
 
-               task_setup_data.task = &data->task;
-               task_setup_data.callback_data = data;
-               NFS_PROTO(inode)->read_setup(data, &msg);
-
-               task = rpc_run_task(&task_setup_data);
-               if (IS_ERR(task))
+               if (nfs_direct_read_execute(data, &task_setup_data, &msg))
                        break;
-               rpc_put_task(task);
-
-               dprintk("NFS: %5u initiated direct read call "
-                       "(req %s/%Ld, %zu bytes @ offset %Lu)\n",
-                               data->task.tk_pid,
-                               inode->i_sb->s_id,
-                               (long long)NFS_FILEID(inode),
-                               bytes,
-                               (unsigned long long)data->args.offset);
 
                started += bytes;
                user_addr += bytes;

@@ -461,12 +475,15 @@ static void nfs_direct_free_writedata(struct nfs_direct_req *dreq)
  }
 
  #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
+static long nfs_direct_write_execute(struct nfs_write_data *data,
+                                    struct rpc_task_setup *task_setup_data,
+                                    struct rpc_message *msg);
+
  static void nfs_direct_write_reschedule(struct nfs_direct_req *dreq)
  {
        struct inode *inode = dreq->inode;
        struct list_head *p;
        struct nfs_write_data *data;
-       struct rpc_task *task;
        struct rpc_message msg = {
                .rpc_cred = dreq->ctx->cred,
        };

@@ -500,25 +517,7 @@ static void nfs_direct_write_reschedule(struct nfs_direct_req *dreq)
                 * Reuse data->task; data->args should not have changed
                 * since the original request was sent.
                 */
-               task_setup_data.task = &data->task;
-               task_setup_data.callback_data = data;
-               msg.rpc_argp = &data->args;
-               msg.rpc_resp = &data->res;
-               NFS_PROTO(inode)->write_setup(data, &msg);
-
-               /*
-                * We're called via an RPC callback, so BKL is already held.
-                */
-               task = rpc_run_task(&task_setup_data);
-               if (!IS_ERR(task))
-                       rpc_put_task(task);
-
-               dprintk("NFS: %5u rescheduled direct write call (req %s/%Ld, %u bytes @ offset %Lu)\n",
-                               data->task.tk_pid,
-                               inode->i_sb->s_id,
-                               (long long)NFS_FILEID(inode),
-                               data->args.count,
-                               (unsigned long long)data->args.offset);
+               nfs_direct_write_execute(data, &task_setup_data, &msg);
        }
 
        if (put_dreq(dreq))

@@ -561,10 +560,31 @@ static const struct rpc_call_ops nfs_commit_direct_ops = {
        .rpc_release = nfs_direct_commit_release,
  };
 
+static long nfs_direct_commit_execute(struct nfs_direct_req *dreq,
+                                     struct nfs_write_data *data,
+                                     struct rpc_task_setup *task_setup_data,
+                                     struct rpc_message *msg)
+{
+       struct rpc_task *task;
+
+       NFS_PROTO(data->inode)->commit_setup(data, msg);
+
+       /* Note: task.tk_ops->rpc_release will free dreq->commit_data */
+       dreq->commit_data = NULL;
+
+       dprintk("NFS: %5u initiated commit call\n", data->task.tk_pid);
+
+       task = rpc_run_task(task_setup_data);
+       if (IS_ERR(task))
+               return PTR_ERR(task);
+
+       rpc_put_task(task);
+       return 0;
+}
+
  static void nfs_direct_commit_schedule(struct nfs_direct_req *dreq)
  {
        struct nfs_write_data *data = dreq->commit_data;
-       struct rpc_task *task;
        struct rpc_message msg = {
                .rpc_argp = &data->args,
                .rpc_resp = &data->res,

@@ -593,16 +613,7 @@ static void nfs_direct_commit_schedule(struct nfs_direct_req *dreq)
        data->res.verf = &data->verf;
        nfs_fattr_init(&data->fattr);
 
-       NFS_PROTO(data->inode)->commit_setup(data, &msg);
-
-       /* Note: task.tk_ops->rpc_release will free dreq->commit_data */
-       dreq->commit_data = NULL;
-
-       dprintk("NFS: %5u initiated commit call\n", data->task.tk_pid);
-
-       task = rpc_run_task(&task_setup_data);
-       if (!IS_ERR(task))
-               rpc_put_task(task);
+       nfs_direct_commit_execute(dreq, data, &task_setup_data, &msg);
  }
 
  static void nfs_direct_write_complete(struct nfs_direct_req *dreq, struct inode *inode)

@@ -703,6 +714,36 @@ static const struct rpc_call_ops nfs_write_direct_ops = {
        .rpc_release = nfs_direct_write_release,
  };
 
+static long nfs_direct_write_execute(struct nfs_write_data *data,
+                                    struct rpc_task_setup *task_setup_data,
+                                    struct rpc_message *msg)
+{
+       struct inode *inode = data->inode;
+       struct rpc_task *task;
+
+       task_setup_data->task = &data->task;
+       task_setup_data->callback_data = data;
+       msg->rpc_argp = &data->args;
+       msg->rpc_resp = &data->res;
+       NFS_PROTO(inode)->write_setup(data, msg);
+
+       task = rpc_run_task(task_setup_data);
+       if (IS_ERR(task))
+               return PTR_ERR(task);
+
+       rpc_put_task(task);
+
+       dprintk("NFS: %5u initiated direct write call "
+               "(req %s/%lld, %u bytes @ offset %llu)\n",
+               data->task.tk_pid,
+               inode->i_sb->s_id,
+               (long long)NFS_FILEID(inode),
+               data->args.count,
+               (unsigned long long)data->args.offset);
+
+       return 0;
+}
+
  /*
  * For each wsize'd chunk of the user's buffer, dispatch an NFS WRITE
  * operation.  If nfs_writedata_alloc() or get_user_pages() fails,

@@ -718,7 +759,6 @@ static ssize_t nfs_direct_write_schedule_segment(struct nfs_direct_req *dreq,
        struct inode *inode = ctx->path.dentry->d_inode;
        unsigned long user_addr = (unsigned long)iov->iov_base;
        size_t count = iov->iov_len;
-       struct rpc_task *task;
        struct rpc_message msg = {
                .rpc_cred = ctx->cred,
        };

@@ -785,24 +825,8 @@ static ssize_t nfs_direct_write_schedule_segment(struct nfs_direct_req *dreq,
                data->res.verf = &data->verf;
                nfs_fattr_init(&data->fattr);
 
-               task_setup_data.task = &data->task;
-               task_setup_data.callback_data = data;
-               msg.rpc_argp = &data->args;
-               msg.rpc_resp = &data->res;
-               NFS_PROTO(inode)->write_setup(data, &msg);
-
-               task = rpc_run_task(&task_setup_data);
-               if (IS_ERR(task))
+               if (nfs_direct_write_execute(data, &task_setup_data, &msg))
                        break;
-               rpc_put_task(task);
-
-               dprintk("NFS: %5u initiated direct write call "
-                       "(req %s/%Ld, %zu bytes @ offset %Lu)\n",
-                               data->task.tk_pid,
-                               inode->i_sb->s_id,
-                               (long long)NFS_FILEID(inode),
-                               bytes,
-                               (unsigned long long)data->args.offset);
 
                started += bytes;
                user_addr += bytes;
--

1.7.3.4

--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in the body of a message to [email protected]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Note this does not seem to change any functionality, just rearranges the code. Is this patch needed?

Fred

Quoted 258 lines · Benny Halevy

From: Andy Adamson <[email protected]>

Signed-off-by Dean Hildebrand <[email protected]>

Signed-off-by Fred Isaman <[email protected]>

Signed-off-by Andy Adamson <[email protected]>

Signed-off-by Benny Halevy <[email protected]>

---
 fs/nfs/direct.c |  160 +++++++++++++++++++++++++++++++-----------------------
 1 files changed, 92 insertions(+), 68 deletions(-)

fs/nfs/direct.c +92 -69

index 8eea253..55dffb7 100644
@@ -272,6 +272,38 @@ static const struct rpc_call_ops nfs_read_direct_ops = {
       .rpc_release = nfs_direct_read_release,
 };
 
+static long nfs_direct_read_execute(struct nfs_read_data *data,
+                                   struct rpc_task_setup *task_setup_data,
+                                   struct rpc_message *msg)
+{
+       struct inode *inode = data->inode;
+       struct rpc_task *task;
+
+       nfs_fattr_init(&data->fattr);
+       msg->rpc_argp = &data->args;
+       msg->rpc_resp = &data->res;
+
+       task_setup_data->task = &data->task;
+       task_setup_data->callback_data = data;
+       NFS_PROTO(inode)->read_setup(data, msg);
+
+       task = rpc_run_task(task_setup_data);
+       if (IS_ERR(task))
+               return PTR_ERR(task);
+
+       rpc_put_task(task);
+
+       dprintk("NFS: %5u initiated direct read call "
+               "(req %s/%lld, %u bytes @ offset %llu)\n",
+               data->task.tk_pid,
+               inode->i_sb->s_id,
+               (long long)NFS_FILEID(inode),
+               data->args.count,
+               (unsigned long long)data->args.offset);
+
+       return 0;
+}
+
 /*
 * For each rsize'd chunk of the user's buffer, dispatch an NFS READ
 * operation.  If nfs_readdata_alloc() or get_user_pages() fails,

@@ -288,7 +320,6 @@ static ssize_t nfs_direct_read_schedule_segment(struct nfs_direct_req *dreq,
       unsigned long user_addr = (unsigned long)iov->iov_base;
       size_t count = iov->iov_len;
       size_t rsize = NFS_SERVER(inode)->rsize;
-       struct rpc_task *task;
       struct rpc_message msg = {
               .rpc_cred = ctx->cred,
       };

@@ -349,26 +380,9 @@ static ssize_t nfs_direct_read_schedule_segment(struct nfs_direct_req *dreq,
               data->res.fattr = &data->fattr;
               data->res.eof = 0;
               data->res.count = bytes;
-               nfs_fattr_init(&data->fattr);
-               msg.rpc_argp = &data->args;
-               msg.rpc_resp = &data->res;
 
-               task_setup_data.task = &data->task;
-               task_setup_data.callback_data = data;
-               NFS_PROTO(inode)->read_setup(data, &msg);
-
-               task = rpc_run_task(&task_setup_data);
-               if (IS_ERR(task))
+               if (nfs_direct_read_execute(data, &task_setup_data, &msg))
                       break;
-               rpc_put_task(task);
-
-               dprintk("NFS: %5u initiated direct read call "
-                       "(req %s/%Ld, %zu bytes @ offset %Lu)\n",
-                               data->task.tk_pid,
-                               inode->i_sb->s_id,
-                               (long long)NFS_FILEID(inode),
-                               bytes,
-                               (unsigned long long)data->args.offset);
 
               started += bytes;
               user_addr += bytes;

@@ -461,12 +475,15 @@ static void nfs_direct_free_writedata(struct nfs_direct_req *dreq)
 }
 
 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
+static long nfs_direct_write_execute(struct nfs_write_data *data,
+                                    struct rpc_task_setup *task_setup_data,
+                                    struct rpc_message *msg);
+
 static void nfs_direct_write_reschedule(struct nfs_direct_req *dreq)
 {
       struct inode *inode = dreq->inode;
       struct list_head *p;
       struct nfs_write_data *data;
-       struct rpc_task *task;
       struct rpc_message msg = {
               .rpc_cred = dreq->ctx->cred,
       };

@@ -500,25 +517,7 @@ static void nfs_direct_write_reschedule(struct nfs_direct_req *dreq)
                * Reuse data->task; data->args should not have changed
                * since the original request was sent.
                */
-               task_setup_data.task = &data->task;
-               task_setup_data.callback_data = data;
-               msg.rpc_argp = &data->args;
-               msg.rpc_resp = &data->res;
-               NFS_PROTO(inode)->write_setup(data, &msg);
-
-               /*
-                * We're called via an RPC callback, so BKL is already held.
-                */
-               task = rpc_run_task(&task_setup_data);
-               if (!IS_ERR(task))
-                       rpc_put_task(task);
-
-               dprintk("NFS: %5u rescheduled direct write call (req %s/%Ld, %u bytes @ offset %Lu)\n",
-                               data->task.tk_pid,
-                               inode->i_sb->s_id,
-                               (long long)NFS_FILEID(inode),
-                               data->args.count,
-                               (unsigned long long)data->args.offset);
+               nfs_direct_write_execute(data, &task_setup_data, &msg);
       }
 
       if (put_dreq(dreq))

@@ -561,10 +560,31 @@ static const struct rpc_call_ops nfs_commit_direct_ops = {
       .rpc_release = nfs_direct_commit_release,
 };
 
+static long nfs_direct_commit_execute(struct nfs_direct_req *dreq,
+                                     struct nfs_write_data *data,
+                                     struct rpc_task_setup *task_setup_data,
+                                     struct rpc_message *msg)
+{
+       struct rpc_task *task;
+
+       NFS_PROTO(data->inode)->commit_setup(data, msg);
+
+       /* Note: task.tk_ops->rpc_release will free dreq->commit_data */
+       dreq->commit_data = NULL;
+
+       dprintk("NFS: %5u initiated commit call\n", data->task.tk_pid);
+
+       task = rpc_run_task(task_setup_data);
+       if (IS_ERR(task))
+               return PTR_ERR(task);
+
+       rpc_put_task(task);
+       return 0;
+}
+
 static void nfs_direct_commit_schedule(struct nfs_direct_req *dreq)
 {
       struct nfs_write_data *data = dreq->commit_data;
-       struct rpc_task *task;
       struct rpc_message msg = {
               .rpc_argp = &data->args,
               .rpc_resp = &data->res,

@@ -593,16 +613,7 @@ static void nfs_direct_commit_schedule(struct nfs_direct_req *dreq)
       data->res.verf = &data->verf;
       nfs_fattr_init(&data->fattr);
 
-       NFS_PROTO(data->inode)->commit_setup(data, &msg);
-
-       /* Note: task.tk_ops->rpc_release will free dreq->commit_data */
-       dreq->commit_data = NULL;
-
-       dprintk("NFS: %5u initiated commit call\n", data->task.tk_pid);
-
-       task = rpc_run_task(&task_setup_data);
-       if (!IS_ERR(task))
-               rpc_put_task(task);
+       nfs_direct_commit_execute(dreq, data, &task_setup_data, &msg);
 }
 
 static void nfs_direct_write_complete(struct nfs_direct_req *dreq, struct inode *inode)

@@ -703,6 +714,36 @@ static const struct rpc_call_ops nfs_write_direct_ops = {
       .rpc_release = nfs_direct_write_release,
 };
 
+static long nfs_direct_write_execute(struct nfs_write_data *data,
+                                    struct rpc_task_setup *task_setup_data,
+                                    struct rpc_message *msg)
+{
+       struct inode *inode = data->inode;
+       struct rpc_task *task;
+
+       task_setup_data->task = &data->task;
+       task_setup_data->callback_data = data;
+       msg->rpc_argp = &data->args;
+       msg->rpc_resp = &data->res;
+       NFS_PROTO(inode)->write_setup(data, msg);
+
+       task = rpc_run_task(task_setup_data);
+       if (IS_ERR(task))
+               return PTR_ERR(task);
+
+       rpc_put_task(task);
+
+       dprintk("NFS: %5u initiated direct write call "
+               "(req %s/%lld, %u bytes @ offset %llu)\n",
+               data->task.tk_pid,
+               inode->i_sb->s_id,
+               (long long)NFS_FILEID(inode),
+               data->args.count,
+               (unsigned long long)data->args.offset);
+
+       return 0;
+}
+
 /*
 * For each wsize'd chunk of the user's buffer, dispatch an NFS WRITE
 * operation.  If nfs_writedata_alloc() or get_user_pages() fails,

@@ -718,7 +759,6 @@ static ssize_t nfs_direct_write_schedule_segment(struct nfs_direct_req *dreq,
       struct inode *inode = ctx->path.dentry->d_inode;
       unsigned long user_addr = (unsigned long)iov->iov_base;
       size_t count = iov->iov_len;
-       struct rpc_task *task;
       struct rpc_message msg = {
               .rpc_cred = ctx->cred,
       };

@@ -785,24 +825,8 @@ static ssize_t nfs_direct_write_schedule_segment(struct nfs_direct_req *dreq,
               data->res.verf = &data->verf;
               nfs_fattr_init(&data->fattr);
 
-               task_setup_data.task = &data->task;
-               task_setup_data.callback_data = data;
-               msg.rpc_argp = &data->args;
-               msg.rpc_resp = &data->res;
-               NFS_PROTO(inode)->write_setup(data, &msg);
-
-               task = rpc_run_task(&task_setup_data);
-               if (IS_ERR(task))
+               if (nfs_direct_write_execute(data, &task_setup_data, &msg))
                       break;
-               rpc_put_task(task);
-
-               dprintk("NFS: %5u initiated direct write call "
-                       "(req %s/%Ld, %zu bytes @ offset %Lu)\n",
-                               data->task.tk_pid,
-                               inode->i_sb->s_id,
-                               (long long)NFS_FILEID(inode),
-                               bytes,
-                               (unsigned long long)data->args.offset);
 
               started += bytes;
               user_addr += bytes;
--

1.7.3.4

Quoted 5 lines

--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html

--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html

Add offset and count parameters to pnfs_update_layout and use them to get the layout in the pageio path.

Test byte range against the layout segment in use in pnfs_{read,write}_pg_test so not to coalesce pages not using the same layout segment.

Signed-off-by Benny Halevy <[email protected]>

---

 fs/nfs/pnfs.c  |  149 +++++++++++++++++++++++++++++++++++++++++++++-----------
 fs/nfs/pnfs.h  |    4 +-
 fs/nfs/read.c  |   10 +++-
 fs/nfs/write.c |    8 ++-
 4 files changed, 136 insertions(+), 35 deletions(-)

fs/nfs/pnfs.c +59 -0

index d9ab972..e689bdf 100644
@@ -261,6 +261,65 @@ put_lseg(struct pnfs_layout_segment *lseg)
  }
  EXPORT_SYMBOL_GPL(put_lseg);
 
+static inline u64
+end_offset(u64 start, u64 len)
+{
+       u64 end;
+
+       end = start + len;
+       return end >= start ? end : NFS4_MAX_UINT64;
+}
+
+/* last octet in a range */
+static inline u64
+last_byte_offset(u64 start, u64 len)
+{
+       u64 end;
+
+       BUG_ON(!len);
+       end = start + len;
+       return end > start ? end - 1 : NFS4_MAX_UINT64;
+}
+
+/*
+ * is l2 fully contained in l1?
+ *   start1                             end1
+ *   [----------------------------------)
+ *           start2           end2
+ *           [----------------)
+ */
+static inline int
+lo_seg_contained(struct pnfs_layout_range *l1,
+                struct pnfs_layout_range *l2)
+{
+       u64 start1 = l1->offset;
+       u64 end1 = end_offset(start1, l1->length);
+       u64 start2 = l2->offset;
+       u64 end2 = end_offset(start2, l2->length);
+
+       return (start1 <= start2) && (end1 >= end2);
+}
+
+/*
+ * is l1 and l2 intersecting?
+ *   start1                             end1
+ *   [----------------------------------)
+ *                              start2           end2
+ *                              [----------------)
+ */
+static inline int
+lo_seg_intersecting(struct pnfs_layout_range *l1,
+                   struct pnfs_layout_range *l2)
+{
+       u64 start1 = l1->offset;
+       u64 end1 = end_offset(start1, l1->length);
+       u64 start2 = l2->offset;
+       u64 end2 = end_offset(start2, l2->length);
+
+       return (end1 == NFS4_MAX_UINT64 || end1 > start2) &&
+              (end2 == NFS4_MAX_UINT64 || end2 > start1);
+}
+

 static bool
 should_free_lseg(u32 lseg_iomode, u32 recall_iomode) {

fs/nfs/pnfs.c +0 -0

@@ -466,7 +525,7 @@ pnfs_choose_layoutget_stateid(nfs4_stateid *dst, struct pnfs_layout_hdr *lo,

 static struct pnfs_layout_segment * send_layoutget(struct pnfs_layout_hdr *lo, struct nfs_open_context *ctx,
-          u32 iomode)
+          struct pnfs_layout_range *range) {
       struct inode *ino = lo->plh_inode; struct nfs_server *server = NFS_SERVER(ino);

fs/nfs/pnfs.c +0 -0

@@ -497,11 +556,11 @@ send_layoutget(struct pnfs_layout_hdr *lo,
                        goto out_err_free;
        }

fs/nfs/pnfs.c +1 -1

        lgp->args.type = server->pnfs_curr_ld->id;
        lgp->args.inode = ino;
        lgp->args.ctx = get_nfs_open_context(ctx);

@@ -515,7 +574,7 @@ send_layoutget(struct pnfs_layout_hdr *lo,
        nfs4_proc_layoutget(lgp);
        if (!lseg) {
                /* remember that LAYOUTGET failed and suspend trying */
-               set_bit(lo_fail_bit(iomode), &lo->plh_flags);
+               set_bit(lo_fail_bit(range->iomode), &lo->plh_flags);
        }
 
        /* free xdr pages */

@@ -622,10 +681,24 @@ bool pnfs_roc_drain(struct inode *ino, u32 *barrier)
  * are seen first.
  */

 static s64

fs/nfs/pnfs.c +2 -1

-cmp_layout(u32 iomode1, u32 iomode2)
+cmp_layout(struct pnfs_layout_range *l1,
+          struct pnfs_layout_range *l2)

 {
+       s64 d;

fs/nfs/pnfs.c +1 -0

+

       /* read > read/write */
-       return (int)(iomode2 == IOMODE_READ) - (int)(iomode1 == IOMODE_READ);
+       return (int)(l2->iomode == IOMODE_READ) -
+               (int)(l1->iomode == IOMODE_READ);
 }

 static void

fs/nfs/pnfs.c +1 -1

@@ -639,7 +712,7 @@ pnfs_insert_layout(struct pnfs_layout_hdr *lo,
 
        assert_spin_locked(&lo->plh_inode->i_lock);
        list_for_each_entry(lp, &lo->plh_segs, pls_list) {
-               if (cmp_layout(lp->pls_range.iomode, lseg->pls_range.iomode) > 0)
+               if (cmp_layout(&lp->pls_range, &lseg->pls_range) > 0)
                        continue;
                list_add_tail(&lseg->pls_list, &lp->pls_list);

               dprintk("%s: inserted lseg %p "

fs/nfs/pnfs.c +0 -0

@@ -718,16 +791,28 @@ pnfs_find_alloc_layout(struct inode *ino)
  * READ                RW      true
  */

 static int

 {
-       return (iomode != IOMODE_RW || lseg->pls_range.iomode == IOMODE_RW);
+       struct pnfs_layout_range range1;

fs/nfs/pnfs.c +10 -0

+
+       if ((range->iomode == IOMODE_RW &&
+            lseg->pls_range.iomode != IOMODE_RW) ||
+           !lo_seg_intersecting(&lseg->pls_range, range))
+               return 0;
+
+       /* range1 covers only the first byte in the range */
+       range1 = *range;
+       range1.length = 1;
+       return lo_seg_contained(&lseg->pls_range, &range1);

 }

 /*
 * lookup range in layout
 */
 static struct pnfs_layout_segment *

fs/nfs/pnfs.c +2 -1

-pnfs_find_lseg(struct pnfs_layout_hdr *lo, u32 iomode)
+pnfs_find_lseg(struct pnfs_layout_hdr *lo,
+               struct pnfs_layout_range *range)

 {
       struct pnfs_layout_segment *lseg, *ret = NULL;

fs/nfs/pnfs.c +0 -0

@@ -736,11 +821,11 @@ pnfs_find_lseg(struct pnfs_layout_hdr *lo, u32 iomode)
        assert_spin_locked(&lo->plh_inode->i_lock);
        list_for_each_entry(lseg, &lo->plh_segs, pls_list) {

               if (test_bit(NFS_LSEG_VALID, &lseg->pls_flags) &&
-                   is_matching_lseg(lseg, iomode)) {
+                   is_matching_lseg(lseg, range)) {
                       ret = get_lseg(lseg);
                       break;
               }
-               if (cmp_layout(iomode, lseg->pls_range.iomode) > 0)
+               if (cmp_layout(range, &lseg->pls_range) > 0) break;
       }

fs/nfs/pnfs.c +0 -0

@@ -756,8 +841,15 @@ pnfs_find_lseg(struct pnfs_layout_hdr *lo, u32 iomode)

 struct pnfs_layout_segment * pnfs_update_layout(struct inode *ino,
                  struct nfs_open_context *ctx,
+                  loff_t pos,
+                  u64 count,
                  enum pnfs_iomode iomode)
 {
+       struct pnfs_layout_range arg = {
+               .iomode = iomode,
+               .offset = pos,
+               .length = count,
+       };
       struct nfs_inode *nfsi = NFS_I(ino);
       struct nfs_client *clp = NFS_SERVER(ino)->nfs_client; struct pnfs_layout_hdr *lo;

fs/nfs/pnfs.c +14 -15

@@ -785,7 +877,7 @@ pnfs_update_layout(struct inode *ino,
                goto out_unlock;
 
        /* Check to see if the layout for the given range already exists */
-       lseg = pnfs_find_lseg(lo, iomode);
+       lseg = pnfs_find_lseg(lo, &arg);
        if (lseg)
                goto out_unlock;
 

@@ -807,7 +899,7 @@ pnfs_update_layout(struct inode *ino,
                spin_unlock(&clp->cl_lock);
        }
 
-       lseg = send_layoutget(lo, ctx, iomode);
+       lseg = send_layoutget(lo, ctx, &arg);
        if (!lseg && first) {
                spin_lock(&clp->cl_lock);
                list_del_init(&lo->plh_layouts);

@@ -834,17 +926,6 @@ pnfs_layout_process(struct nfs4_layoutget *lgp)
        struct nfs_client *clp = NFS_SERVER(ino)->nfs_client;
        int status = 0;
 
-       /* Verify we got what we asked for.
-        * Note that because the xdr parsing only accepts a single
-        * element array, this can fail even if the server is behaving
-        * correctly.
-        */
-       if (lgp->args.range.iomode > res->range.iomode ||
-           res->range.offset != 0 ||
-           res->range.length != NFS4_MAX_UINT64) {
-               status = -EINVAL;
-               goto out;
-       }
        /* Inject layout blob into I/O device driver */
        lseg = NFS_SERVER(ino)->pnfs_curr_ld->alloc_lseg(lo, res);
        if (!lseg || IS_ERR(lseg)) {

@@ -899,8 +980,13 @@ static int pnfs_read_pg_test(struct nfs_pageio_descriptor *pgio,
                /* This is first coelesce call for a series of nfs_pages */
                pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
                                                   prev->wb_context,
+                                                  req_offset(req),
+                                                  pgio->pg_count,
                                                   IOMODE_READ);
-       }
+       } else if (pgio->pg_lseg &&
+                  req_offset(req) > end_offset(pgio->pg_lseg->pls_range.offset,
+                                               pgio->pg_lseg->pls_range.length))
+               return 0;
        return NFS_SERVER(pgio->pg_inode)->pnfs_curr_ld->pg_test(pgio, prev, req);
  }
 

@@ -921,8 +1007,13 @@ static int pnfs_write_pg_test(struct nfs_pageio_descriptor *pgio,
                /* This is first coelesce call for a series of nfs_pages */
                pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
                                                   prev->wb_context,
+                                                  req_offset(req),
+                                                  pgio->pg_count,
                                                   IOMODE_RW);
-       }
+       } else if (pgio->pg_lseg &&
+                  req_offset(req) > end_offset(pgio->pg_lseg->pls_range.offset,
+                                               pgio->pg_lseg->pls_range.length))
+               return 0;
        return NFS_SERVER(pgio->pg_inode)->pnfs_curr_ld->pg_test(pgio, prev, req);
  }
 

fs/nfs/pnfs.h +0 -0

index 4cb0a0d..14a2af9 100644
@@ -129,7 +129,7 @@ void get_layout_hdr(struct pnfs_layout_hdr *lo);
  void put_lseg(struct pnfs_layout_segment *lseg);

 struct pnfs_layout_segment *
 pnfs_update_layout(struct inode *ino, struct nfs_open_context *ctx,
-                  enum pnfs_iomode access_type);
+                  loff_t pos, u64 count, enum pnfs_iomode access_type); void set_pnfs_layoutdriver(struct nfs_server *, u32 id); void unset_pnfs_layoutdriver(struct nfs_server *);
 enum pnfs_try_status pnfs_try_to_write_data(struct nfs_write_data *,

fs/nfs/pnfs.h +0 -0

@@ -248,7 +248,7 @@ static inline void put_lseg(struct pnfs_layout_segment *lseg)
 

 static inline struct pnfs_layout_segment * pnfs_update_layout(struct inode *ino, struct nfs_open_context *ctx,
-                  enum pnfs_iomode access_type)
+                  loff_t pos, u64 count, enum pnfs_iomode access_type) {
       return NULL;
 }

fs/nfs/read.c +1 -1

index 7cded2b..10eff1c 100644
@@ -288,13 +288,17 @@ static int nfs_pagein_multi(struct nfs_pageio_descriptor *desc)
        atomic_set(&req->wb_complete, requests);
 
        BUG_ON(desc->pg_lseg != NULL);
-       lseg = pnfs_update_layout(desc->pg_inode, req->wb_context, IOMODE_READ);
+       lseg = pnfs_update_layout(desc->pg_inode, req->wb_context,

fs/nfs/read.c +3 -1

                data = list_entry(list.next, struct nfs_read_data, pages);
                list_del_init(&data->pages);
 

@@ -351,7 +355,9 @@ static int nfs_pagein_one(struct nfs_pageio_descriptor *desc)
        }
        req = nfs_list_entry(data->pages.next);
        if ((!lseg) && list_is_singular(&data->pages))
-               lseg = pnfs_update_layout(desc->pg_inode, req->wb_context, IOMODE_READ);
+               lseg = pnfs_update_layout(desc->pg_inode, req->wb_context,
+                                         req_offset(req), desc->pg_count,
+                                         IOMODE_READ);
 
        ret = nfs_read_rpcsetup(req, data, &nfs_read_full_ops, desc->pg_count,
                                0, lseg);

fs/nfs/write.c +6 -2

index e4cbc11..318e0a3 100644
@@ -940,7 +940,9 @@ static int nfs_flush_multi(struct nfs_pageio_descriptor *desc)
        atomic_set(&req->wb_complete, requests);
 
        BUG_ON(desc->pg_lseg);
-       lseg = pnfs_update_layout(desc->pg_inode, req->wb_context, IOMODE_RW);
+       lseg = pnfs_update_layout(desc->pg_inode, req->wb_context,
+                                 req_offset(req), desc->pg_count,
+                                 IOMODE_RW);
        ClearPageError(page);
        offset = 0;
        nbytes = desc->pg_count;

@@ -1014,7 +1016,9 @@ static int nfs_flush_one(struct nfs_pageio_descriptor *desc)
        }
        req = nfs_list_entry(data->pages.next);
        if ((!lseg) && list_is_singular(&data->pages))
-               lseg = pnfs_update_layout(desc->pg_inode, req->wb_context, IOMODE_RW);
+               lseg = pnfs_update_layout(desc->pg_inode, req->wb_context,
+                                         req_offset(req), desc->pg_count,
+                                         IOMODE_RW);
 

       if ((desc->pg_ioflags & FLUSH_COND_STABLE) && (desc->pg_moreio || NFS_I(desc->pg_inode)->ncommit)) --
1.7.3.4

--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in the body of a message to [email protected]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Quoted 97 lines · Benny Halevy

Add offset and count parameters to pnfs_update_layout and use them to get the layout in the pageio path.

Test byte range against the layout segment in use in pnfs_{read,write}_pg_test so not to coalesce pages not using the same layout segment.

Signed-off-by Benny Halevy <[email protected]>

---
 fs/nfs/pnfs.c  |  149 +++++++++++++++++++++++++++++++++++++++++++++-----------
 fs/nfs/pnfs.h  |    4 +-
 fs/nfs/read.c  |   10 +++-
 fs/nfs/write.c |    8 ++-
 4 files changed, 136 insertions(+), 35 deletions(-)

fs/nfs/pnfs.c +60 -1

index d9ab972..e689bdf 100644
@@ -261,6 +261,65 @@ put_lseg(struct pnfs_layout_segment *lseg)
 }
 EXPORT_SYMBOL_GPL(put_lseg);
 
+static inline u64
+end_offset(u64 start, u64 len)
+{
+       u64 end;
+
+       end = start + len;
+       return end >= start ? end : NFS4_MAX_UINT64;
+}
+
+/* last octet in a range */
+static inline u64
+last_byte_offset(u64 start, u64 len)
+{
+       u64 end;
+
+       BUG_ON(!len);
+       end = start + len;
+       return end > start ? end - 1 : NFS4_MAX_UINT64;
+}
+
+/*
+ * is l2 fully contained in l1?
+ *   start1                             end1
+ *   [----------------------------------)
+ *           start2           end2
+ *           [----------------)
+ */
+static inline int
+lo_seg_contained(struct pnfs_layout_range *l1,
+                struct pnfs_layout_range *l2)
+{
+       u64 start1 = l1->offset;
+       u64 end1 = end_offset(start1, l1->length);
+       u64 start2 = l2->offset;
+       u64 end2 = end_offset(start2, l2->length);
+
+       return (start1 <= start2) && (end1 >= end2);
+}
+
+/*
+ * is l1 and l2 intersecting?
+ *   start1                             end1
+ *   [----------------------------------)
+ *                              start2           end2
+ *                              [----------------)
+ */
+static inline int
+lo_seg_intersecting(struct pnfs_layout_range *l1,
+                   struct pnfs_layout_range *l2)
+{
+       u64 start1 = l1->offset;
+       u64 end1 = end_offset(start1, l1->length);
+       u64 start2 = l2->offset;
+       u64 end2 = end_offset(start2, l2->length);
+
+       return (end1 == NFS4_MAX_UINT64 || end1 > start2) &&
+              (end2 == NFS4_MAX_UINT64 || end2 > start1);
+}
+
 static bool
 should_free_lseg(u32 lseg_iomode, u32 recall_iomode)
 {

@@ -466,7 +525,7 @@ pnfs_choose_layoutget_stateid(nfs4_stateid *dst, struct pnfs_layout_hdr *lo,
 static struct pnfs_layout_segment *
 send_layoutget(struct pnfs_layout_hdr *lo,
          struct nfs_open_context *ctx,
-          u32 iomode)
+          struct pnfs_layout_range *range)
 {
       struct inode *ino = lo->plh_inode;
       struct nfs_server *server = NFS_SERVER(ino);

@@ -497,11 +556,11 @@ send_layoutget(struct pnfs_layout_hdr *lo,
                       goto out_err_free;
       }
 

fs/nfs/pnfs.c send_layoutget(struct pnfs_layout_hdr *lo, · line 563

Quoted 9 lines

fs/nfs/pnfs.c +4 -4

-       lgp->args.minlength = NFS4_MAX_UINT64;
+       lgp->args.minlength = PAGE_CACHE_SIZE;
+       if (lgp->args.minlength > range->length)
+               lgp->args.minlength = range->length;
       lgp->args.maxcount = PNFS_LAYOUT_MAXSIZE;
-       lgp->args.range.iomode = iomode;
-       lgp->args.range.offset = 0;
-       lgp->args.range.length = NFS4_MAX_UINT64;
+       lgp->args.range = *range;

Do you want to align offet to page boundary?

Quoted 26 lines

fs/nfs/pnfs.c +9 -2

       lgp->args.type = server->pnfs_curr_ld->id;
       lgp->args.inode = ino;
       lgp->args.ctx = get_nfs_open_context(ctx);

@@ -515,7 +574,7 @@ send_layoutget(struct pnfs_layout_hdr *lo,
       nfs4_proc_layoutget(lgp);
       if (!lseg) {
               /* remember that LAYOUTGET failed and suspend trying */
-               set_bit(lo_fail_bit(iomode), &lo->plh_flags);
+               set_bit(lo_fail_bit(range->iomode), &lo->plh_flags);
       }
 
       /* free xdr pages */

@@ -622,10 +681,24 @@ bool pnfs_roc_drain(struct inode *ino, u32 *barrier)
 * are seen first.
 */
 static s64
-cmp_layout(u32 iomode1, u32 iomode2)
+cmp_layout(struct pnfs_layout_range *l1,
+          struct pnfs_layout_range *l2)
 {
+       s64 d;
+
+       /* higher offset > lower offset */
+       d = l1->offset - l2->offset;
+       if (d)
+               return d;

fs/nfs/pnfs.c bool pnfs_roc_drain(struct inode *ino, u32 *barrier) · line 698

Quoted 6 lines

fs/nfs/pnfs.c +6 -0

+
+       /* longer length > shorter length */
+       d = l1->length - l2->length;
+       if (d)
+               return d;
+

Assuming iomodes the same, don't we prefer seeing the longer to the shorter?

Wouldn't we prefer a short rw to a long ro?

Quoted 9 lines

fs/nfs/pnfs.c +2 -1

       /* read > read/write */
-       return (int)(iomode2 == IOMODE_READ) - (int)(iomode1 == IOMODE_READ);
+       return (int)(l2->iomode == IOMODE_READ) -
+               (int)(l1->iomode == IOMODE_READ);
 }
 
 static void

@@ -639,7 +712,7 @@ pnfs_insert_layout(struct pnfs_layout_hdr *lo,
 

Quoted 8 lines

fs/nfs/pnfs.c +1 -1

       assert_spin_locked(&lo->plh_inode->i_lock);
       list_for_each_entry(lp, &lo->plh_segs, pls_list) {
-               if (cmp_layout(lp->pls_range.iomode, lseg->pls_range.iomode) > 0)
+               if (cmp_layout(&lp->pls_range, &lseg->pls_range) > 0)
                       continue;
               list_add_tail(&lseg->pls_list, &lp->pls_list);
               dprintk("%s: inserted lseg %p "

fs/nfs/pnfs.c pnfs_find_alloc_layout(struct inode *ino) · line 795

Quoted 6 lines

fs/nfs/pnfs.c +2 -1

@@ -718,16 +791,28 @@ pnfs_find_alloc_layout(struct inode *ino)
 * READ                RW      true
 */
 static int
-is_matching_lseg(struct pnfs_layout_segment *lseg, u32 iomode)
+is_matching_lseg(struct pnfs_layout_segment *lseg,
+                struct pnfs_layout_range *range)

arguments to this should probably both be of struct pnfs_layout_range

Quoted 162 lines

fs/nfs/pnfs.c +36 -19

 {
-       return (iomode != IOMODE_RW || lseg->pls_range.iomode == IOMODE_RW);
+       struct pnfs_layout_range range1;
+
+       if ((range->iomode == IOMODE_RW &&
+            lseg->pls_range.iomode != IOMODE_RW) ||
+           !lo_seg_intersecting(&lseg->pls_range, range))
+               return 0;
+
+       /* range1 covers only the first byte in the range */
+       range1 = *range;
+       range1.length = 1;
+       return lo_seg_contained(&lseg->pls_range, &range1);
 }
 
 /*
 * lookup range in layout
 */
 static struct pnfs_layout_segment *
-pnfs_find_lseg(struct pnfs_layout_hdr *lo, u32 iomode)
+pnfs_find_lseg(struct pnfs_layout_hdr *lo,
+               struct pnfs_layout_range *range)
 {
       struct pnfs_layout_segment *lseg, *ret = NULL;
 

@@ -736,11 +821,11 @@ pnfs_find_lseg(struct pnfs_layout_hdr *lo, u32 iomode)
       assert_spin_locked(&lo->plh_inode->i_lock);
       list_for_each_entry(lseg, &lo->plh_segs, pls_list) {
               if (test_bit(NFS_LSEG_VALID, &lseg->pls_flags) &&
-                   is_matching_lseg(lseg, iomode)) {
+                   is_matching_lseg(lseg, range)) {
                       ret = get_lseg(lseg);
                       break;
               }
-               if (cmp_layout(iomode, lseg->pls_range.iomode) > 0)
+               if (cmp_layout(range, &lseg->pls_range) > 0)
                       break;
       }
 

@@ -756,8 +841,15 @@ pnfs_find_lseg(struct pnfs_layout_hdr *lo, u32 iomode)
 struct pnfs_layout_segment *
 pnfs_update_layout(struct inode *ino,
                  struct nfs_open_context *ctx,
+                  loff_t pos,
+                  u64 count,
                  enum pnfs_iomode iomode)
 {
+       struct pnfs_layout_range arg = {
+               .iomode = iomode,
+               .offset = pos,
+               .length = count,
+       };
       struct nfs_inode *nfsi = NFS_I(ino);
       struct nfs_client *clp = NFS_SERVER(ino)->nfs_client;
       struct pnfs_layout_hdr *lo;

@@ -785,7 +877,7 @@ pnfs_update_layout(struct inode *ino,
               goto out_unlock;
 
       /* Check to see if the layout for the given range already exists */
-       lseg = pnfs_find_lseg(lo, iomode);
+       lseg = pnfs_find_lseg(lo, &arg);
       if (lseg)
               goto out_unlock;
 

@@ -807,7 +899,7 @@ pnfs_update_layout(struct inode *ino,
               spin_unlock(&clp->cl_lock);
       }
 
-       lseg = send_layoutget(lo, ctx, iomode);
+       lseg = send_layoutget(lo, ctx, &arg);
       if (!lseg && first) {
               spin_lock(&clp->cl_lock);
               list_del_init(&lo->plh_layouts);

@@ -834,17 +926,6 @@ pnfs_layout_process(struct nfs4_layoutget *lgp)
       struct nfs_client *clp = NFS_SERVER(ino)->nfs_client;
       int status = 0;
 
-       /* Verify we got what we asked for.
-        * Note that because the xdr parsing only accepts a single
-        * element array, this can fail even if the server is behaving
-        * correctly.
-        */
-       if (lgp->args.range.iomode > res->range.iomode ||
-           res->range.offset != 0 ||
-           res->range.length != NFS4_MAX_UINT64) {
-               status = -EINVAL;
-               goto out;
-       }
       /* Inject layout blob into I/O device driver */
       lseg = NFS_SERVER(ino)->pnfs_curr_ld->alloc_lseg(lo, res);
       if (!lseg || IS_ERR(lseg)) {

@@ -899,8 +980,13 @@ static int pnfs_read_pg_test(struct nfs_pageio_descriptor *pgio,
               /* This is first coelesce call for a series of nfs_pages */
               pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
                                                  prev->wb_context,
+                                                  req_offset(req),
+                                                  pgio->pg_count,
                                                  IOMODE_READ);
-       }
+       } else if (pgio->pg_lseg &&
+                  req_offset(req) > end_offset(pgio->pg_lseg->pls_range.offset,
+                                               pgio->pg_lseg->pls_range.length))
+               return 0;
       return NFS_SERVER(pgio->pg_inode)->pnfs_curr_ld->pg_test(pgio, prev, req);
 }
 

@@ -921,8 +1007,13 @@ static int pnfs_write_pg_test(struct nfs_pageio_descriptor *pgio,
               /* This is first coelesce call for a series of nfs_pages */
               pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
                                                  prev->wb_context,
+                                                  req_offset(req),
+                                                  pgio->pg_count,
                                                  IOMODE_RW);
-       }
+       } else if (pgio->pg_lseg &&
+                  req_offset(req) > end_offset(pgio->pg_lseg->pls_range.offset,
+                                               pgio->pg_lseg->pls_range.length))
+               return 0;
       return NFS_SERVER(pgio->pg_inode)->pnfs_curr_ld->pg_test(pgio, prev, req);
 }
 

fs/nfs/pnfs.h +2 -2

index 4cb0a0d..14a2af9 100644
@@ -129,7 +129,7 @@ void get_layout_hdr(struct pnfs_layout_hdr *lo);
 void put_lseg(struct pnfs_layout_segment *lseg);
 struct pnfs_layout_segment *
 pnfs_update_layout(struct inode *ino, struct nfs_open_context *ctx,
-                  enum pnfs_iomode access_type);
+                  loff_t pos, u64 count, enum pnfs_iomode access_type);
 void set_pnfs_layoutdriver(struct nfs_server *, u32 id);
 void unset_pnfs_layoutdriver(struct nfs_server *);
 enum pnfs_try_status pnfs_try_to_write_data(struct nfs_write_data *,

@@ -248,7 +248,7 @@ static inline void put_lseg(struct pnfs_layout_segment *lseg)
 
 static inline struct pnfs_layout_segment *
 pnfs_update_layout(struct inode *ino, struct nfs_open_context *ctx,
-                  enum pnfs_iomode access_type)
+                  loff_t pos, u64 count, enum pnfs_iomode access_type)
 {
       return NULL;
 }

fs/nfs/read.c +3 -1

index 7cded2b..10eff1c 100644
@@ -288,13 +288,17 @@ static int nfs_pagein_multi(struct nfs_pageio_descriptor *desc)
       atomic_set(&req->wb_complete, requests);
 
       BUG_ON(desc->pg_lseg != NULL);
-       lseg = pnfs_update_layout(desc->pg_inode, req->wb_context, IOMODE_READ);
+       lseg = pnfs_update_layout(desc->pg_inode, req->wb_context,
+                                 req_offset(req), desc->pg_count,
+                                 IOMODE_READ);
       ClearPageError(page);
       offset = 0;
       nbytes = desc->pg_count;
       do {
               int ret2;
 

fs/nfs/read.c static int nfs_pagein_multi(struct nfs_pageio_descriptor *desc) · line 301

Quoted 2 lines

fs/nfs/read.c +2 -0

+               /* FIXME: need a new layout segment? */
+

No need for FIXME, since we assume strongly throughout that the layouts are page aligned.

Fred

Quoted 43 lines

fs/nfs/read.c +3 -1

               data = list_entry(list.next, struct nfs_read_data, pages);
               list_del_init(&data->pages);
 

@@ -351,7 +355,9 @@ static int nfs_pagein_one(struct nfs_pageio_descriptor *desc)
       }
       req = nfs_list_entry(data->pages.next);
       if ((!lseg) && list_is_singular(&data->pages))
-               lseg = pnfs_update_layout(desc->pg_inode, req->wb_context, IOMODE_READ);
+               lseg = pnfs_update_layout(desc->pg_inode, req->wb_context,
+                                         req_offset(req), desc->pg_count,
+                                         IOMODE_READ);
 
       ret = nfs_read_rpcsetup(req, data, &nfs_read_full_ops, desc->pg_count,
                               0, lseg);

fs/nfs/write.c +6 -3

index e4cbc11..318e0a3 100644
@@ -940,7 +940,9 @@ static int nfs_flush_multi(struct nfs_pageio_descriptor *desc)
       atomic_set(&req->wb_complete, requests);
 
       BUG_ON(desc->pg_lseg);
-       lseg = pnfs_update_layout(desc->pg_inode, req->wb_context, IOMODE_RW);
+       lseg = pnfs_update_layout(desc->pg_inode, req->wb_context,
+                                 req_offset(req), desc->pg_count,
+                                 IOMODE_RW);
       ClearPageError(page);
       offset = 0;
       nbytes = desc->pg_count;

@@ -1014,7 +1016,9 @@ static int nfs_flush_one(struct nfs_pageio_descriptor *desc)
       }
       req = nfs_list_entry(data->pages.next);
       if ((!lseg) && list_is_singular(&data->pages))
-               lseg = pnfs_update_layout(desc->pg_inode, req->wb_context, IOMODE_RW);
+               lseg = pnfs_update_layout(desc->pg_inode, req->wb_context,
+                                         req_offset(req), desc->pg_count,
+                                         IOMODE_RW);
 
       if ((desc->pg_ioflags & FLUSH_COND_STABLE) &&
           (desc->pg_moreio || NFS_I(desc->pg_inode)->ncommit))
--

1.7.3.4

Quoted 5 lines

--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html

--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html