1 files changed, 54 insertions, 32 deletions

diff --git a/fs/nfs/pnfs.c b/fs/nfs/pnfs.c
index 38e5508555c6..e550e8836c37 100644
--- a/fs/nfs/pnfs.c
+++ b/fs/nfs/pnfs.c
@@ -76,8 +76,11 @@ find_pnfs_driver(u32 id)
 void
 unset_pnfs_layoutdriver(struct nfs_server *nfss)
 {
-        if (nfss->pnfs_curr_ld)
+        if (nfss->pnfs_curr_ld) {
+                if (nfss->pnfs_curr_ld->clear_layoutdriver)
+                        nfss->pnfs_curr_ld->clear_layoutdriver(nfss);
                 module_put(nfss->pnfs_curr_ld->owner);
+        }
         nfss->pnfs_curr_ld = NULL;
 }
 
@@ -88,7 +91,8 @@ unset_pnfs_layoutdriver(struct nfs_server *nfss)
  * @id layout type. Zero (illegal layout type) indicates pNFS not in use.
  */
 void
-set_pnfs_layoutdriver(struct nfs_server *server, u32 id)
+set_pnfs_layoutdriver(struct nfs_server *server, const struct nfs_fh *mntfh,
+                      u32 id)
 {
         struct pnfs_layoutdriver_type *ld_type = NULL;
 
@@ -115,6 +119,13 @@ set_pnfs_layoutdriver(struct nfs_server *server, u32 id)
                 goto out_no_driver;
         }
         server->pnfs_curr_ld = ld_type;
+        if (ld_type->set_layoutdriver
+            && ld_type->set_layoutdriver(server, mntfh)) {
+                printk(KERN_ERR "%s: Error initializing pNFS layout driver %u.\n",
+                                __func__, id);
+                module_put(ld_type->owner);
+                goto out_no_driver;
+        }
 
         dprintk("%s: pNFS module for %u set\n", __func__, id);
         return;
@@ -190,6 +201,7 @@ static void
 pnfs_free_layout_hdr(struct pnfs_layout_hdr *lo)
 {
         struct pnfs_layoutdriver_type *ld = NFS_SERVER(lo->plh_inode)->pnfs_curr_ld;
+        put_rpccred(lo->plh_lc_cred);
         return ld->alloc_layout_hdr ? ld->free_layout_hdr(lo) : kfree(lo);
 }
 
@@ -224,6 +236,7 @@ static void
 init_lseg(struct pnfs_layout_hdr *lo, struct pnfs_layout_segment *lseg)
 {
         INIT_LIST_HEAD(&lseg->pls_list);
+        INIT_LIST_HEAD(&lseg->pls_lc_list);
         atomic_set(&lseg->pls_refcount, 1);
         smp_mb();
         set_bit(NFS_LSEG_VALID, &lseg->pls_flags);
@@ -816,7 +829,9 @@ out:
 }
 
 static struct pnfs_layout_hdr *
-alloc_init_layout_hdr(struct inode *ino, gfp_t gfp_flags)
+alloc_init_layout_hdr(struct inode *ino,
+                      struct nfs_open_context *ctx,
+                      gfp_t gfp_flags)
 {
         struct pnfs_layout_hdr *lo;
 
@@ -828,11 +843,14 @@ alloc_init_layout_hdr(struct inode *ino, gfp_t gfp_flags)
         INIT_LIST_HEAD(&lo->plh_segs);
         INIT_LIST_HEAD(&lo->plh_bulk_recall);
         lo->plh_inode = ino;
+        lo->plh_lc_cred = get_rpccred(ctx->state->owner->so_cred);
         return lo;
 }
 
 static struct pnfs_layout_hdr *
-pnfs_find_alloc_layout(struct inode *ino, gfp_t gfp_flags)
+pnfs_find_alloc_layout(struct inode *ino,
+                       struct nfs_open_context *ctx,
+                       gfp_t gfp_flags)
 {
         struct nfs_inode *nfsi = NFS_I(ino);
         struct pnfs_layout_hdr *new = NULL;
@@ -847,7 +865,7 @@ pnfs_find_alloc_layout(struct inode *ino, gfp_t gfp_flags)
                         return nfsi->layout;
         }
         spin_unlock(&ino->i_lock);
-        new = alloc_init_layout_hdr(ino, gfp_flags);
+        new = alloc_init_layout_hdr(ino, ctx, gfp_flags);
         spin_lock(&ino->i_lock);
 
         if (likely(nfsi->layout == NULL))       /* Won the race? */
@@ -940,7 +958,7 @@ pnfs_update_layout(struct inode *ino,
         if (!pnfs_enabled_sb(NFS_SERVER(ino)))
                 return NULL;
         spin_lock(&ino->i_lock);
-        lo = pnfs_find_alloc_layout(ino, gfp_flags);
+        lo = pnfs_find_alloc_layout(ino, ctx, gfp_flags);
         if (lo == NULL) {
                 dprintk("%s ERROR: can't get pnfs_layout_hdr\n", __func__);
                 goto out_unlock;
@@ -1350,16 +1368,17 @@ pnfs_generic_pg_readpages(struct nfs_pageio_descriptor *desc)
 EXPORT_SYMBOL_GPL(pnfs_generic_pg_readpages);
 
 /*
- * Currently there is only one (whole file) write lseg.
+ * There can be multiple RW segments.
  */
-static struct pnfs_layout_segment *pnfs_list_write_lseg(struct inode *inode)
+static void pnfs_list_write_lseg(struct inode *inode, struct list_head *listp)
 {
-        struct pnfs_layout_segment *lseg, *rv = NULL;
+        struct pnfs_layout_segment *lseg;
 
-        list_for_each_entry(lseg, &NFS_I(inode)->layout->plh_segs, pls_list)
-                if (lseg->pls_range.iomode == IOMODE_RW)
-                        rv = lseg;
-        return rv;
+        list_for_each_entry(lseg, &NFS_I(inode)->layout->plh_segs, pls_list) {
+                if (lseg->pls_range.iomode == IOMODE_RW &&
+                    test_bit(NFS_LSEG_LAYOUTCOMMIT, &lseg->pls_flags))
+                        list_add(&lseg->pls_lc_list, listp);
+        }
 }
 
 void
@@ -1371,17 +1390,19 @@ pnfs_set_layoutcommit(struct nfs_write_data *wdata)
 
         spin_lock(&nfsi->vfs_inode.i_lock);
         if (!test_and_set_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags)) {
-                /* references matched in nfs4_layoutcommit_release */
-                get_lseg(wdata->lseg);
-                wdata->lseg->pls_lc_cred =
-                        get_rpccred(wdata->args.context->state->owner->so_cred);
                 mark_as_dirty = true;
                 dprintk("%s: Set layoutcommit for inode %lu ",
                         __func__, wdata->inode->i_ino);
         }
-        if (end_pos > wdata->lseg->pls_end_pos)
-                wdata->lseg->pls_end_pos = end_pos;
+        if (!test_and_set_bit(NFS_LSEG_LAYOUTCOMMIT, &wdata->lseg->pls_flags)) {
+                /* references matched in nfs4_layoutcommit_release */
+                get_lseg(wdata->lseg);
+        }
+        if (end_pos > nfsi->layout->plh_lwb)
+                nfsi->layout->plh_lwb = end_pos;
         spin_unlock(&nfsi->vfs_inode.i_lock);
+        dprintk("%s: lseg %p end_pos %llu\n",
+                __func__, wdata->lseg, nfsi->layout->plh_lwb);
 
         /* if pnfs_layoutcommit_inode() runs between inode locks, the next one
          * will be a noop because NFS_INO_LAYOUTCOMMIT will not be set */
@@ -1390,6 +1411,14 @@ pnfs_set_layoutcommit(struct nfs_write_data *wdata)
 }
 EXPORT_SYMBOL_GPL(pnfs_set_layoutcommit);
 
+void pnfs_cleanup_layoutcommit(struct nfs4_layoutcommit_data *data)
+{
+        struct nfs_server *nfss = NFS_SERVER(data->args.inode);
+
+        if (nfss->pnfs_curr_ld->cleanup_layoutcommit)
+                nfss->pnfs_curr_ld->cleanup_layoutcommit(data);
+}
+
 /*
  * For the LAYOUT4_NFSV4_1_FILES layout type, NFS_DATA_SYNC WRITEs and
  * NFS_UNSTABLE WRITEs with a COMMIT to data servers must store enough
@@ -1403,8 +1432,6 @@ pnfs_layoutcommit_inode(struct inode *inode, bool sync)
 {
         struct nfs4_layoutcommit_data *data;
         struct nfs_inode *nfsi = NFS_I(inode);
-        struct pnfs_layout_segment *lseg;
-        struct rpc_cred *cred;
         loff_t end_pos;
         int status = 0;
 
@@ -1421,30 +1448,25 @@ pnfs_layoutcommit_inode(struct inode *inode, bool sync)
                 goto out;
         }
 
+        INIT_LIST_HEAD(&data->lseg_list);
         spin_lock(&inode->i_lock);
         if (!test_and_clear_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags)) {
                 spin_unlock(&inode->i_lock);
                 kfree(data);
                 goto out;
         }
-        /*
-         * Currently only one (whole file) write lseg which is referenced
-         * in pnfs_set_layoutcommit and will be found.
-         */
-        lseg = pnfs_list_write_lseg(inode);
 
-        end_pos = lseg->pls_end_pos;
-        cred = lseg->pls_lc_cred;
-        lseg->pls_end_pos = 0;
-        lseg->pls_lc_cred = NULL;
+        pnfs_list_write_lseg(inode, &data->lseg_list);
+
+        end_pos = nfsi->layout->plh_lwb;
+        nfsi->layout->plh_lwb = 0;
 
         memcpy(&data->args.stateid.data, nfsi->layout->plh_stateid.data,
                 sizeof(nfsi->layout->plh_stateid.data));
         spin_unlock(&inode->i_lock);
 
         data->args.inode = inode;
-        data->lseg = lseg;
-        data->cred = cred;
+        data->cred = get_rpccred(nfsi->layout->plh_lc_cred);
         nfs_fattr_init(&data->fattr);
         data->args.bitmask = NFS_SERVER(inode)->cache_consistency_bitmask;
         data->res.fattr = &data->fattr;