18 files changed, 436 insertions, 145 deletions

diff --git a/fs/nfs/blocklayout/blocklayout.c b/fs/nfs/blocklayout/blocklayout.c
index ddd0138f410c..02e4d87d2ed3 100644
--- a/fs/nfs/blocklayout/blocklayout.c
+++ b/fs/nfs/blocklayout/blocklayout.c
@@ -446,8 +446,8 @@ static void bl_free_layout_hdr(struct pnfs_layout_hdr *lo)
         kfree(bl);
 }
 
-static struct pnfs_layout_hdr *bl_alloc_layout_hdr(struct inode *inode,
-                                                   gfp_t gfp_flags)
+static struct pnfs_layout_hdr *__bl_alloc_layout_hdr(struct inode *inode,
+                gfp_t gfp_flags, bool is_scsi_layout)
 {
         struct pnfs_block_layout *bl;
 
@@ -460,9 +460,22 @@ static struct pnfs_layout_hdr *bl_alloc_layout_hdr(struct inode *inode,
         bl->bl_ext_ro = RB_ROOT;
         spin_lock_init(&bl->bl_ext_lock);
 
+        bl->bl_scsi_layout = is_scsi_layout;
         return &bl->bl_layout;
 }
 
+static struct pnfs_layout_hdr *bl_alloc_layout_hdr(struct inode *inode,
+                                                   gfp_t gfp_flags)
+{
+        return __bl_alloc_layout_hdr(inode, gfp_flags, false);
+}
+
+static struct pnfs_layout_hdr *sl_alloc_layout_hdr(struct inode *inode,
+                                                   gfp_t gfp_flags)
+{
+        return __bl_alloc_layout_hdr(inode, gfp_flags, true);
+}
+
 static void bl_free_lseg(struct pnfs_layout_segment *lseg)
 {
         dprintk("%s enter\n", __func__);
@@ -743,7 +756,7 @@ bl_set_layoutdriver(struct nfs_server *server, const struct nfs_fh *fh)
 
 static bool
 is_aligned_req(struct nfs_pageio_descriptor *pgio,
-                struct nfs_page *req, unsigned int alignment)
+                struct nfs_page *req, unsigned int alignment, bool is_write)
 {
         /*
          * Always accept buffered writes, higher layers take care of the
@@ -758,7 +771,8 @@ is_aligned_req(struct nfs_pageio_descriptor *pgio,
         if (IS_ALIGNED(req->wb_bytes, alignment))
                 return true;
 
-        if (req_offset(req) + req->wb_bytes == i_size_read(pgio->pg_inode)) {
+        if (is_write &&
+            (req_offset(req) + req->wb_bytes == i_size_read(pgio->pg_inode))) {
                 /*
                  * If the write goes up to the inode size, just write
                  * the full page.  Data past the inode size is
@@ -775,7 +789,7 @@ is_aligned_req(struct nfs_pageio_descriptor *pgio,
 static void
 bl_pg_init_read(struct nfs_pageio_descriptor *pgio, struct nfs_page *req)
 {
-        if (!is_aligned_req(pgio, req, SECTOR_SIZE)) {
+        if (!is_aligned_req(pgio, req, SECTOR_SIZE, false)) {
                 nfs_pageio_reset_read_mds(pgio);
                 return;
         }
@@ -791,7 +805,7 @@ static size_t
 bl_pg_test_read(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev,
                 struct nfs_page *req)
 {
-        if (!is_aligned_req(pgio, req, SECTOR_SIZE))
+        if (!is_aligned_req(pgio, req, SECTOR_SIZE, false))
                 return 0;
         return pnfs_generic_pg_test(pgio, prev, req);
 }
@@ -824,7 +838,7 @@ bl_pg_init_write(struct nfs_pageio_descriptor *pgio, struct nfs_page *req)
 {
         u64 wb_size;
 
-        if (!is_aligned_req(pgio, req, PAGE_SIZE)) {
+        if (!is_aligned_req(pgio, req, PAGE_SIZE, true)) {
                 nfs_pageio_reset_write_mds(pgio);
                 return;
         }
@@ -846,7 +860,7 @@ static size_t
 bl_pg_test_write(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev,
                  struct nfs_page *req)
 {
-        if (!is_aligned_req(pgio, req, PAGE_SIZE))
+        if (!is_aligned_req(pgio, req, PAGE_SIZE, true))
                 return 0;
         return pnfs_generic_pg_test(pgio, prev, req);
 }
@@ -888,22 +902,53 @@ static struct pnfs_layoutdriver_type blocklayout_type = {
         .sync                           = pnfs_generic_sync,
 };
 
+static struct pnfs_layoutdriver_type scsilayout_type = {
+        .id                             = LAYOUT_SCSI,
+        .name                           = "LAYOUT_SCSI",
+        .owner                          = THIS_MODULE,
+        .flags                          = PNFS_LAYOUTRET_ON_SETATTR |
+                                          PNFS_READ_WHOLE_PAGE,
+        .read_pagelist                  = bl_read_pagelist,
+        .write_pagelist                 = bl_write_pagelist,
+        .alloc_layout_hdr               = sl_alloc_layout_hdr,
+        .free_layout_hdr                = bl_free_layout_hdr,
+        .alloc_lseg                     = bl_alloc_lseg,
+        .free_lseg                      = bl_free_lseg,
+        .return_range                   = bl_return_range,
+        .prepare_layoutcommit           = bl_prepare_layoutcommit,
+        .cleanup_layoutcommit           = bl_cleanup_layoutcommit,
+        .set_layoutdriver               = bl_set_layoutdriver,
+        .alloc_deviceid_node            = bl_alloc_deviceid_node,
+        .free_deviceid_node             = bl_free_deviceid_node,
+        .pg_read_ops                    = &bl_pg_read_ops,
+        .pg_write_ops                   = &bl_pg_write_ops,
+        .sync                           = pnfs_generic_sync,
+};
+
+
 static int __init nfs4blocklayout_init(void)
 {
         int ret;
 
         dprintk("%s: NFSv4 Block Layout Driver Registering...\n", __func__);
 
-        ret = pnfs_register_layoutdriver(&blocklayout_type);
+        ret = bl_init_pipefs();
         if (ret)
                 goto out;
-        ret = bl_init_pipefs();
+
+        ret = pnfs_register_layoutdriver(&blocklayout_type);
         if (ret)
-                goto out_unregister;
+                goto out_cleanup_pipe;
+
+        ret = pnfs_register_layoutdriver(&scsilayout_type);
+        if (ret)
+                goto out_unregister_block;
         return 0;
 
-out_unregister:
+out_unregister_block:
         pnfs_unregister_layoutdriver(&blocklayout_type);
+out_cleanup_pipe:
+        bl_cleanup_pipefs();
 out:
         return ret;
 }
@@ -913,8 +958,9 @@ static void __exit nfs4blocklayout_exit(void)
         dprintk("%s: NFSv4 Block Layout Driver Unregistering...\n",
                __func__);
 
-        bl_cleanup_pipefs();
+        pnfs_unregister_layoutdriver(&scsilayout_type);
         pnfs_unregister_layoutdriver(&blocklayout_type);
+        bl_cleanup_pipefs();
 }
 
 MODULE_ALIAS("nfs-layouttype4-3");
diff --git a/fs/nfs/blocklayout/blocklayout.h b/fs/nfs/blocklayout/blocklayout.h
index c556640dcf3b..bc21205309e0 100644
--- a/fs/nfs/blocklayout/blocklayout.h
+++ b/fs/nfs/blocklayout/blocklayout.h
@@ -55,7 +55,6 @@ struct pnfs_block_dev;
  */
 #define PNFS_BLOCK_UUID_LEN     128
 
-
 struct pnfs_block_volume {
         enum pnfs_block_volume_type     type;
         union {
@@ -82,6 +81,13 @@ struct pnfs_block_volume {
                         u32             volumes_count;
                         u32             volumes[PNFS_BLOCK_MAX_DEVICES];
                 } stripe;
+                struct {
+                        enum scsi_code_set              code_set;
+                        enum scsi_designator_type       designator_type;
+                        int                             designator_len;
+                        u8                              designator[256];
+                        u64                             pr_key;
+                } scsi;
         };
 };
 
@@ -106,6 +112,9 @@ struct pnfs_block_dev {
         struct block_device             *bdev;
         u64                             disk_offset;
 
+        u64                             pr_key;
+        bool                            pr_registered;
+
         bool (*map)(struct pnfs_block_dev *dev, u64 offset,
                         struct pnfs_block_dev_map *map);
 };
@@ -131,6 +140,7 @@ struct pnfs_block_layout {
         struct rb_root          bl_ext_rw;
         struct rb_root          bl_ext_ro;
         spinlock_t              bl_ext_lock;   /* Protects list manipulation */
+        bool                    bl_scsi_layout;
 };
 
 static inline struct pnfs_block_layout *
@@ -182,6 +192,6 @@ void ext_tree_mark_committed(struct nfs4_layoutcommit_args *arg, int status);
 dev_t bl_resolve_deviceid(struct nfs_server *server,
                 struct pnfs_block_volume *b, gfp_t gfp_mask);
 int __init bl_init_pipefs(void);
-void __exit bl_cleanup_pipefs(void);
+void bl_cleanup_pipefs(void);
 
 #endif /* FS_NFS_NFS4BLOCKLAYOUT_H */
diff --git a/fs/nfs/blocklayout/dev.c b/fs/nfs/blocklayout/dev.c
index a861bbdfe577..e5b89675263e 100644
--- a/fs/nfs/blocklayout/dev.c
+++ b/fs/nfs/blocklayout/dev.c
@@ -1,11 +1,12 @@
 /*
- * Copyright (c) 2014 Christoph Hellwig.
+ * Copyright (c) 2014-2016 Christoph Hellwig.
  */
 #include <linux/sunrpc/svc.h>
 #include <linux/blkdev.h>
 #include <linux/nfs4.h>
 #include <linux/nfs_fs.h>
 #include <linux/nfs_xdr.h>
+#include <linux/pr.h>
 
 #include "blocklayout.h"
 
@@ -21,6 +22,17 @@ bl_free_device(struct pnfs_block_dev *dev)
                         bl_free_device(&dev->children[i]);
                 kfree(dev->children);
         } else {
+                if (dev->pr_registered) {
+                        const struct pr_ops *ops =
+                                dev->bdev->bd_disk->fops->pr_ops;
+                        int error;
+
+                        error = ops->pr_register(dev->bdev, dev->pr_key, 0,
+                                false);
+                        if (error)
+                                pr_err("failed to unregister PR key.\n");
+                }
+
                 if (dev->bdev)
                         blkdev_put(dev->bdev, FMODE_READ | FMODE_WRITE);
         }
@@ -113,6 +125,24 @@ nfs4_block_decode_volume(struct xdr_stream *xdr, struct pnfs_block_volume *b)
                 for (i = 0; i < b->stripe.volumes_count; i++)
                         b->stripe.volumes[i] = be32_to_cpup(p++);
                 break;
+        case PNFS_BLOCK_VOLUME_SCSI:
+                p = xdr_inline_decode(xdr, 4 + 4 + 4);
+                if (!p)
+                        return -EIO;
+                b->scsi.code_set = be32_to_cpup(p++);
+                b->scsi.designator_type = be32_to_cpup(p++);
+                b->scsi.designator_len = be32_to_cpup(p++);
+                p = xdr_inline_decode(xdr, b->scsi.designator_len);
+                if (!p)
+                        return -EIO;
+                if (b->scsi.designator_len > 256)
+                        return -EIO;
+                memcpy(&b->scsi.designator, p, b->scsi.designator_len);
+                p = xdr_inline_decode(xdr, 8);
+                if (!p)
+                        return -EIO;
+                p = xdr_decode_hyper(p, &b->scsi.pr_key);
+                break;
         default:
                 dprintk("unknown volume type!\n");
                 return -EIO;
@@ -216,6 +246,116 @@ bl_parse_simple(struct nfs_server *server, struct pnfs_block_dev *d,
         return 0;
 }
 
+static bool
+bl_validate_designator(struct pnfs_block_volume *v)
+{
+        switch (v->scsi.designator_type) {
+        case PS_DESIGNATOR_EUI64:
+                if (v->scsi.code_set != PS_CODE_SET_BINARY)
+                        return false;
+
+                if (v->scsi.designator_len != 8 &&
+                    v->scsi.designator_len != 10 &&
+                    v->scsi.designator_len != 16)
+                        return false;
+
+                return true;
+        case PS_DESIGNATOR_NAA:
+                if (v->scsi.code_set != PS_CODE_SET_BINARY)
+                        return false;
+
+                if (v->scsi.designator_len != 8 &&
+                    v->scsi.designator_len != 16)
+                        return false;
+
+                return true;
+        case PS_DESIGNATOR_T10:
+        case PS_DESIGNATOR_NAME:
+                pr_err("pNFS: unsupported designator "
+                        "(code set %d, type %d, len %d.\n",
+                        v->scsi.code_set,
+                        v->scsi.designator_type,
+                        v->scsi.designator_len);
+                return false;
+        default:
+                pr_err("pNFS: invalid designator "
+                        "(code set %d, type %d, len %d.\n",
+                        v->scsi.code_set,
+                        v->scsi.designator_type,
+                        v->scsi.designator_len);
+                return false;
+        }
+}
+
+static int
+bl_parse_scsi(struct nfs_server *server, struct pnfs_block_dev *d,
+                struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
+{
+        struct pnfs_block_volume *v = &volumes[idx];
+        const struct pr_ops *ops;
+        const char *devname;
+        int error;
+
+        if (!bl_validate_designator(v))
+                return -EINVAL;
+
+        switch (v->scsi.designator_len) {
+        case 8:
+                devname = kasprintf(GFP_KERNEL, "/dev/disk/by-id/wwn-0x%8phN",
+                                v->scsi.designator);
+                break;
+        case 12:
+                devname = kasprintf(GFP_KERNEL, "/dev/disk/by-id/wwn-0x%12phN",
+                                v->scsi.designator);
+                break;
+        case 16:
+                devname = kasprintf(GFP_KERNEL, "/dev/disk/by-id/wwn-0x%16phN",
+                                v->scsi.designator);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        d->bdev = blkdev_get_by_path(devname, FMODE_READ, NULL);
+        if (IS_ERR(d->bdev)) {
+                pr_warn("pNFS: failed to open device %s (%ld)\n",
+                        devname, PTR_ERR(d->bdev));
+                kfree(devname);
+                return PTR_ERR(d->bdev);
+        }
+
+        kfree(devname);
+
+        d->len = i_size_read(d->bdev->bd_inode);
+        d->map = bl_map_simple;
+        d->pr_key = v->scsi.pr_key;
+
+        pr_info("pNFS: using block device %s (reservation key 0x%llx)\n",
+                d->bdev->bd_disk->disk_name, d->pr_key);
+
+        ops = d->bdev->bd_disk->fops->pr_ops;
+        if (!ops) {
+                pr_err("pNFS: block device %s does not support reservations.",
+                                d->bdev->bd_disk->disk_name);
+                error = -EINVAL;
+                goto out_blkdev_put;
+        }
+
+        error = ops->pr_register(d->bdev, 0, d->pr_key, true);
+        if (error) {
+                pr_err("pNFS: failed to register key for block device %s.",
+                                d->bdev->bd_disk->disk_name);
+                goto out_blkdev_put;
+        }
+
+        d->pr_registered = true;
+        return 0;
+
+out_blkdev_put:
+        blkdev_put(d->bdev, FMODE_READ);
+        return error;
+}
+
 static int
 bl_parse_slice(struct nfs_server *server, struct pnfs_block_dev *d,
                 struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
@@ -303,6 +443,8 @@ bl_parse_deviceid(struct nfs_server *server, struct pnfs_block_dev *d,
                 return bl_parse_concat(server, d, volumes, idx, gfp_mask);
         case PNFS_BLOCK_VOLUME_STRIPE:
                 return bl_parse_stripe(server, d, volumes, idx, gfp_mask);
+        case PNFS_BLOCK_VOLUME_SCSI:
+                return bl_parse_scsi(server, d, volumes, idx, gfp_mask);
         default:
                 dprintk("unsupported volume type: %d\n", volumes[idx].type);
                 return -EIO;
diff --git a/fs/nfs/blocklayout/extent_tree.c b/fs/nfs/blocklayout/extent_tree.c
index 35ab51c04814..720b3ff55fa9 100644
--- a/fs/nfs/blocklayout/extent_tree.c
+++ b/fs/nfs/blocklayout/extent_tree.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014 Christoph Hellwig.
+ * Copyright (c) 2014-2016 Christoph Hellwig.
  */
 
 #include <linux/vmalloc.h>
@@ -462,10 +462,12 @@ out:
         return err;
 }
 
-static size_t ext_tree_layoutupdate_size(size_t count)
+static size_t ext_tree_layoutupdate_size(struct pnfs_block_layout *bl, size_t count)
 {
-        return sizeof(__be32) /* number of entries */ +
-                PNFS_BLOCK_EXTENT_SIZE * count;
+        if (bl->bl_scsi_layout)
+                return sizeof(__be32) + PNFS_SCSI_RANGE_SIZE * count;
+        else
+                return sizeof(__be32) + PNFS_BLOCK_EXTENT_SIZE * count;
 }
 
 static void ext_tree_free_commitdata(struct nfs4_layoutcommit_args *arg,
@@ -483,6 +485,23 @@ static void ext_tree_free_commitdata(struct nfs4_layoutcommit_args *arg,
         }
 }
 
+static __be32 *encode_block_extent(struct pnfs_block_extent *be, __be32 *p)
+{
+        p = xdr_encode_opaque_fixed(p, be->be_device->deviceid.data,
+                        NFS4_DEVICEID4_SIZE);
+        p = xdr_encode_hyper(p, be->be_f_offset << SECTOR_SHIFT);
+        p = xdr_encode_hyper(p, be->be_length << SECTOR_SHIFT);
+        p = xdr_encode_hyper(p, 0LL);
+        *p++ = cpu_to_be32(PNFS_BLOCK_READWRITE_DATA);
+        return p;
+}
+
+static __be32 *encode_scsi_range(struct pnfs_block_extent *be, __be32 *p)
+{
+        p = xdr_encode_hyper(p, be->be_f_offset << SECTOR_SHIFT);
+        return xdr_encode_hyper(p, be->be_length << SECTOR_SHIFT);
+}
+
 static int ext_tree_encode_commit(struct pnfs_block_layout *bl, __be32 *p,
                 size_t buffer_size, size_t *count)
 {
@@ -496,19 +515,16 @@ static int ext_tree_encode_commit(struct pnfs_block_layout *bl, __be32 *p,
                         continue;
 
                 (*count)++;
-                if (ext_tree_layoutupdate_size(*count) > buffer_size) {
+                if (ext_tree_layoutupdate_size(bl, *count) > buffer_size) {
                         /* keep counting.. */
                         ret = -ENOSPC;
                         continue;
                 }
 
-                p = xdr_encode_opaque_fixed(p, be->be_device->deviceid.data,
-                                NFS4_DEVICEID4_SIZE);
-                p = xdr_encode_hyper(p, be->be_f_offset << SECTOR_SHIFT);
-                p = xdr_encode_hyper(p, be->be_length << SECTOR_SHIFT);
-                p = xdr_encode_hyper(p, 0LL);
-                *p++ = cpu_to_be32(PNFS_BLOCK_READWRITE_DATA);
-
+                if (bl->bl_scsi_layout)
+                        p = encode_scsi_range(be, p);
+                else
+                        p = encode_block_extent(be, p);
                 be->be_tag = EXTENT_COMMITTING;
         }
         spin_unlock(&bl->bl_ext_lock);
@@ -537,7 +553,7 @@ retry:
         if (unlikely(ret)) {
                 ext_tree_free_commitdata(arg, buffer_size);
 
-                buffer_size = ext_tree_layoutupdate_size(count);
+                buffer_size = ext_tree_layoutupdate_size(bl, count);
                 count = 0;
 
                 arg->layoutupdate_pages =
@@ -556,7 +572,7 @@ retry:
         }
 
         *start_p = cpu_to_be32(count);
-        arg->layoutupdate_len = ext_tree_layoutupdate_size(count);
+        arg->layoutupdate_len = ext_tree_layoutupdate_size(bl, count);
 
         if (unlikely(arg->layoutupdate_pages != &arg->layoutupdate_page)) {
                 void *p = start_p, *end = p + arg->layoutupdate_len;
diff --git a/fs/nfs/blocklayout/rpc_pipefs.c b/fs/nfs/blocklayout/rpc_pipefs.c
index dbe5839cdeba..9fb067a6f7e0 100644
--- a/fs/nfs/blocklayout/rpc_pipefs.c
+++ b/fs/nfs/blocklayout/rpc_pipefs.c
@@ -281,7 +281,7 @@ out:
         return ret;
 }
 
-void __exit bl_cleanup_pipefs(void)
+void bl_cleanup_pipefs(void)
 {
         rpc_pipefs_notifier_unregister(&nfs4blocklayout_block);
         unregister_pernet_subsys(&nfs4blocklayout_net_ops);
diff --git a/fs/nfs/callback.h b/fs/nfs/callback.h
index ff8195bd75ea..5fe1cecbf9f0 100644
--- a/fs/nfs/callback.h
+++ b/fs/nfs/callback.h
@@ -37,10 +37,11 @@ enum nfs4_callback_opnum {
         OP_CB_ILLEGAL = 10044,
 };
 
+struct nfs4_slot;
 struct cb_process_state {
         __be32                  drc_status;
         struct nfs_client       *clp;
-        u32                     slotid;
+        struct nfs4_slot        *slot;
         u32                     minorversion;
         struct net              *net;
 };
diff --git a/fs/nfs/callback_proc.c b/fs/nfs/callback_proc.c
index f0939d097406..618ced381a14 100644
--- a/fs/nfs/callback_proc.c
+++ b/fs/nfs/callback_proc.c
@@ -354,47 +354,38 @@ out:
  * a single outstanding callback request at a time.
  */
 static __be32
-validate_seqid(struct nfs4_slot_table *tbl, struct cb_sequenceargs * args)
+validate_seqid(const struct nfs4_slot_table *tbl, const struct nfs4_slot *slot,
+                const struct cb_sequenceargs * args)
 {
-        struct nfs4_slot *slot;
-
-        dprintk("%s enter. slotid %u seqid %u\n",
-                __func__, args->csa_slotid, args->csa_sequenceid);
+        dprintk("%s enter. slotid %u seqid %u, slot table seqid: %u\n",
+                __func__, args->csa_slotid, args->csa_sequenceid, slot->seq_nr);
 
-        if (args->csa_slotid >= NFS41_BC_MAX_CALLBACKS)
+        if (args->csa_slotid > tbl->server_highest_slotid)
                 return htonl(NFS4ERR_BADSLOT);
 
-        slot = tbl->slots + args->csa_slotid;
-        dprintk("%s slot table seqid: %u\n", __func__, slot->seq_nr);
-
-        /* Normal */
-        if (likely(args->csa_sequenceid == slot->seq_nr + 1))
-                goto out_ok;
-
         /* Replay */
         if (args->csa_sequenceid == slot->seq_nr) {
                 dprintk("%s seqid %u is a replay\n",
                         __func__, args->csa_sequenceid);
+                if (nfs4_test_locked_slot(tbl, slot->slot_nr))
+                        return htonl(NFS4ERR_DELAY);
                 /* Signal process_op to set this error on next op */
                 if (args->csa_cachethis == 0)
                         return htonl(NFS4ERR_RETRY_UNCACHED_REP);
 
-                /* The ca_maxresponsesize_cached is 0 with no DRC */
-                else if (args->csa_cachethis == 1)
-                        return htonl(NFS4ERR_REP_TOO_BIG_TO_CACHE);
+                /* Liar! We never allowed you to set csa_cachethis != 0 */
+                return htonl(NFS4ERR_SEQ_FALSE_RETRY);
         }
 
         /* Wraparound */
-        if (args->csa_sequenceid == 1 && (slot->seq_nr + 1) == 0) {
-                slot->seq_nr = 1;
-                goto out_ok;
-        }
+        if (unlikely(slot->seq_nr == 0xFFFFFFFFU)) {
+                if (args->csa_sequenceid == 1)
+                        return htonl(NFS4_OK);
+        } else if (likely(args->csa_sequenceid == slot->seq_nr + 1))
+                return htonl(NFS4_OK);
 
         /* Misordered request */
         return htonl(NFS4ERR_SEQ_MISORDERED);
-out_ok:
-        tbl->highest_used_slotid = args->csa_slotid;
-        return htonl(NFS4_OK);
 }
 
 /*
@@ -473,6 +464,12 @@ __be32 nfs4_callback_sequence(struct cb_sequenceargs *args,
         tbl = &clp->cl_session->bc_slot_table;
         slot = tbl->slots + args->csa_slotid;
 
+        /* Set up res before grabbing the spinlock */
+        memcpy(&res->csr_sessionid, &args->csa_sessionid,
+               sizeof(res->csr_sessionid));
+        res->csr_sequenceid = args->csa_sequenceid;
+        res->csr_slotid = args->csa_slotid;
+
         spin_lock(&tbl->slot_tbl_lock);
         /* state manager is resetting the session */
         if (test_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state)) {
@@ -485,18 +482,26 @@ __be32 nfs4_callback_sequence(struct cb_sequenceargs *args,
                 goto out_unlock;
         }
 
-        memcpy(&res->csr_sessionid, &args->csa_sessionid,
-               sizeof(res->csr_sessionid));
-        res->csr_sequenceid = args->csa_sequenceid;
-        res->csr_slotid = args->csa_slotid;
-        res->csr_highestslotid = NFS41_BC_MAX_CALLBACKS - 1;
-        res->csr_target_highestslotid = NFS41_BC_MAX_CALLBACKS - 1;
+        status = htonl(NFS4ERR_BADSLOT);
+        slot = nfs4_lookup_slot(tbl, args->csa_slotid);
+        if (IS_ERR(slot))
+                goto out_unlock;
+
+        res->csr_highestslotid = tbl->server_highest_slotid;
+        res->csr_target_highestslotid = tbl->target_highest_slotid;
 
-        status = validate_seqid(tbl, args);
+        status = validate_seqid(tbl, slot, args);
         if (status)
                 goto out_unlock;
+        if (!nfs4_try_to_lock_slot(tbl, slot)) {
+                status = htonl(NFS4ERR_DELAY);
+                goto out_unlock;
+        }
+        cps->slot = slot;
 
-        cps->slotid = args->csa_slotid;
+        /* The ca_maxresponsesize_cached is 0 with no DRC */
+        if (args->csa_cachethis != 0)
+                return htonl(NFS4ERR_REP_TOO_BIG_TO_CACHE);
 
         /*
          * Check for pending referring calls.  If a match is found, a
@@ -513,7 +518,7 @@ __be32 nfs4_callback_sequence(struct cb_sequenceargs *args,
          * If CB_SEQUENCE returns an error, then the state of the slot
          * (sequence ID, cached reply) MUST NOT change.
          */
-        slot->seq_nr++;
+        slot->seq_nr = args->csa_sequenceid;
 out_unlock:
         spin_unlock(&tbl->slot_tbl_lock);
 
diff --git a/fs/nfs/callback_xdr.c b/fs/nfs/callback_xdr.c
index 646cdac73488..976c90608e56 100644
--- a/fs/nfs/callback_xdr.c
+++ b/fs/nfs/callback_xdr.c
@@ -752,7 +752,8 @@ preprocess_nfs41_op(int nop, unsigned int op_nr, struct callback_op **op)
         return htonl(NFS_OK);
 }
 
-static void nfs4_callback_free_slot(struct nfs4_session *session)
+static void nfs4_callback_free_slot(struct nfs4_session *session,
+                struct nfs4_slot *slot)
 {
         struct nfs4_slot_table *tbl = &session->bc_slot_table;
 
@@ -761,15 +762,17 @@ static void nfs4_callback_free_slot(struct nfs4_session *session)
          * Let the state manager know callback processing done.
          * A single slot, so highest used slotid is either 0 or -1
          */
-        tbl->highest_used_slotid = NFS4_NO_SLOT;
+        nfs4_free_slot(tbl, slot);
         nfs4_slot_tbl_drain_complete(tbl);
         spin_unlock(&tbl->slot_tbl_lock);
 }
 
 static void nfs4_cb_free_slot(struct cb_process_state *cps)
 {
-        if (cps->slotid != NFS4_NO_SLOT)
-                nfs4_callback_free_slot(cps->clp->cl_session);
+        if (cps->slot) {
+                nfs4_callback_free_slot(cps->clp->cl_session, cps->slot);
+                cps->slot = NULL;
+        }
 }
 
 #else /* CONFIG_NFS_V4_1 */
@@ -893,7 +896,6 @@ static __be32 nfs4_callback_compound(struct svc_rqst *rqstp, void *argp, void *r
         struct cb_process_state cps = {
                 .drc_status = 0,
                 .clp = NULL,
-                .slotid = NFS4_NO_SLOT,
                 .net = SVC_NET(rqstp),
         };
         unsigned int nops = 0;
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index 9cce67043f92..4bfa7d8bcade 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -1360,19 +1360,15 @@ struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned in
         dfprintk(VFS, "NFS: lookup(%pd2)\n", dentry);
         nfs_inc_stats(dir, NFSIOS_VFSLOOKUP);
 
-        res = ERR_PTR(-ENAMETOOLONG);
-        if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
-                goto out;
+        if (unlikely(dentry->d_name.len > NFS_SERVER(dir)->namelen))
+                return ERR_PTR(-ENAMETOOLONG);
 
         /*
          * If we're doing an exclusive create, optimize away the lookup
          * but don't hash the dentry.
          */
-        if (nfs_is_exclusive_create(dir, flags)) {
-                d_instantiate(dentry, NULL);
-                res = NULL;
-                goto out;
-        }
+        if (nfs_is_exclusive_create(dir, flags))
+                return NULL;
 
         res = ERR_PTR(-ENOMEM);
         fhandle = nfs_alloc_fhandle();
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 748bb813b8ec..89bf093d342a 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -233,7 +233,7 @@ EXPORT_SYMBOL_GPL(nfs_file_mmap);
  * nfs_file_write() that a write error occurred, and hence cause it to
  * fall back to doing a synchronous write.
  */
-int
+static int
 nfs_file_fsync_commit(struct file *file, loff_t start, loff_t end, int datasync)
 {
         struct nfs_open_context *ctx = nfs_file_open_context(file);
@@ -263,9 +263,8 @@ nfs_file_fsync_commit(struct file *file, loff_t start, loff_t end, int datasync)
 out:
         return ret;
 }
-EXPORT_SYMBOL_GPL(nfs_file_fsync_commit);
 
-static int
+int
 nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 {
         int ret;
@@ -273,13 +272,15 @@ nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 
         trace_nfs_fsync_enter(inode);
 
-        nfs_inode_dio_wait(inode);
+        inode_dio_wait(inode);
         do {
                 ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
                 if (ret != 0)
                         break;
                 inode_lock(inode);
                 ret = nfs_file_fsync_commit(file, start, end, datasync);
+                if (!ret)
+                        ret = pnfs_sync_inode(inode, !!datasync);
                 inode_unlock(inode);
                 /*
                  * If nfs_file_fsync_commit detected a server reboot, then
@@ -293,6 +294,7 @@ nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
         trace_nfs_fsync_exit(inode, ret);
         return ret;
 }
+EXPORT_SYMBOL_GPL(nfs_file_fsync);
 
 /*
  * Decide whether a read/modify/write cycle may be more efficient
@@ -368,7 +370,7 @@ start:
         /*
          * Wait for O_DIRECT to complete
          */
-        nfs_inode_dio_wait(mapping->host);
+        inode_dio_wait(mapping->host);
 
         page = grab_cache_page_write_begin(mapping, index, flags);
         if (!page)
diff --git a/fs/nfs/flexfilelayout/flexfilelayoutdev.c b/fs/nfs/flexfilelayout/flexfilelayoutdev.c
index eb370460ce20..add0e5a70bd6 100644
--- a/fs/nfs/flexfilelayout/flexfilelayoutdev.c
+++ b/fs/nfs/flexfilelayout/flexfilelayoutdev.c
@@ -418,6 +418,8 @@ nfs4_ff_layout_prepare_ds(struct pnfs_layout_segment *lseg, u32 ds_idx,
                                 pnfs_error_mark_layout_for_return(ino, lseg);
                 } else
                         pnfs_error_mark_layout_for_return(ino, lseg);
+                ds = NULL;
+                goto out;
         }
 out_update_creds:
         if (ff_layout_update_mirror_cred(mirror, ds))
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 86faecf8f328..33d18c411905 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -141,7 +141,7 @@ void nfs_evict_inode(struct inode *inode)
 
 int nfs_sync_inode(struct inode *inode)
 {
-        nfs_inode_dio_wait(inode);
+        inode_dio_wait(inode);
         return nfs_wb_all(inode);
 }
 EXPORT_SYMBOL_GPL(nfs_sync_inode);
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index 9a547aa3ec8e..565f8135ae1f 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -358,7 +358,7 @@ int nfs_mknod(struct inode *, struct dentry *, umode_t, dev_t);
 int nfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
 
 /* file.c */
-int nfs_file_fsync_commit(struct file *, loff_t, loff_t, int);
+int nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync);
 loff_t nfs_file_llseek(struct file *, loff_t, int);
 ssize_t nfs_file_read(struct kiocb *, struct iov_iter *);
 ssize_t nfs_file_splice_read(struct file *, loff_t *, struct pipe_inode_info *,
@@ -515,10 +515,6 @@ extern int nfs_sillyrename(struct inode *dir, struct dentry *dentry);
 /* direct.c */
 void nfs_init_cinfo_from_dreq(struct nfs_commit_info *cinfo,
                               struct nfs_direct_req *dreq);
-static inline void nfs_inode_dio_wait(struct inode *inode)
-{
-        inode_dio_wait(inode);
-}
 extern ssize_t nfs_dreq_bytes_left(struct nfs_direct_req *dreq);
 
 /* nfs4proc.c */
diff --git a/fs/nfs/nfs4file.c b/fs/nfs/nfs4file.c
index 57ca1c8039c1..22c35abbee9d 100644
--- a/fs/nfs/nfs4file.c
+++ b/fs/nfs/nfs4file.c
@@ -128,37 +128,6 @@ nfs4_file_flush(struct file *file, fl_owner_t id)
         return vfs_fsync(file, 0);
 }
 
-static int
-nfs4_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
-{
-        int ret;
-        struct inode *inode = file_inode(file);
-
-        trace_nfs_fsync_enter(inode);
-
-        nfs_inode_dio_wait(inode);
-        do {
-                ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
-                if (ret != 0)
-                        break;
-                inode_lock(inode);
-                ret = nfs_file_fsync_commit(file, start, end, datasync);
-                if (!ret)
-                        ret = pnfs_sync_inode(inode, !!datasync);
-                inode_unlock(inode);
-                /*
-                 * If nfs_file_fsync_commit detected a server reboot, then
-                 * resend all dirty pages that might have been covered by
-                 * the NFS_CONTEXT_RESEND_WRITES flag
-                 */
-                start = 0;
-                end = LLONG_MAX;
-        } while (ret == -EAGAIN);
-
-        trace_nfs_fsync_exit(inode, ret);
-        return ret;
-}
-
 #ifdef CONFIG_NFS_V4_2
 static loff_t nfs4_file_llseek(struct file *filep, loff_t offset, int whence)
 {
@@ -266,7 +235,7 @@ const struct file_operations nfs4_file_operations = {
         .open           = nfs4_file_open,
         .flush          = nfs4_file_flush,
         .release        = nfs_file_release,
-        .fsync          = nfs4_file_fsync,
+        .fsync          = nfs_file_fsync,
         .lock           = nfs_lock,
         .flock          = nfs_flock,
         .splice_read    = nfs_file_splice_read,
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 14881594dd07..327b8c34d360 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -2461,14 +2461,15 @@ static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata,
 
         dentry = opendata->dentry;
         if (d_really_is_negative(dentry)) {
-                /* FIXME: Is this d_drop() ever needed? */
+                struct dentry *alias;
                 d_drop(dentry);
-                dentry = d_add_unique(dentry, igrab(state->inode));
-                if (dentry == NULL) {
-                        dentry = opendata->dentry;
-                } else {
+                alias = d_exact_alias(dentry, state->inode);
+                if (!alias)
+                        alias = d_splice_alias(igrab(state->inode), dentry);
+                /* d_splice_alias() can't fail here - it's a non-directory */
+                if (alias) {
                         dput(ctx->dentry);
-                        ctx->dentry = dentry;
+                        ctx->dentry = dentry = alias;
                 }
                 nfs_set_verifier(dentry,
                                 nfs_save_change_attribute(d_inode(opendata->dir)));
@@ -6782,13 +6783,26 @@ nfs41_same_server_scope(struct nfs41_server_scope *a,
         return false;
 }
 
+static void
+nfs4_bind_one_conn_to_session_done(struct rpc_task *task, void *calldata)
+{
+}
+
+static const struct rpc_call_ops nfs4_bind_one_conn_to_session_ops = {
+        .rpc_call_done =  &nfs4_bind_one_conn_to_session_done,
+};
+
 /*
- * nfs4_proc_bind_conn_to_session()
+ * nfs4_proc_bind_one_conn_to_session()
  *
  * The 4.1 client currently uses the same TCP connection for the
  * fore and backchannel.
  */
-int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, struct rpc_cred *cred)
+static
+int nfs4_proc_bind_one_conn_to_session(struct rpc_clnt *clnt,
+                struct rpc_xprt *xprt,
+                struct nfs_client *clp,
+                struct rpc_cred *cred)
 {
         int status;
         struct nfs41_bind_conn_to_session_args args = {
@@ -6803,6 +6817,14 @@ int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, struct rpc_cred *cred
                 .rpc_resp = &res,
                 .rpc_cred = cred,
         };
+        struct rpc_task_setup task_setup_data = {
+                .rpc_client = clnt,
+                .rpc_xprt = xprt,
+                .callback_ops = &nfs4_bind_one_conn_to_session_ops,
+                .rpc_message = &msg,
+                .flags = RPC_TASK_TIMEOUT,
+        };
+        struct rpc_task *task;
 
         dprintk("--> %s\n", __func__);
 
@@ -6810,7 +6832,16 @@ int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, struct rpc_cred *cred
         if (!(clp->cl_session->flags & SESSION4_BACK_CHAN))
                 args.dir = NFS4_CDFC4_FORE;
 
-        status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
+        /* Do not set the backchannel flag unless this is clnt->cl_xprt */
+        if (xprt != rcu_access_pointer(clnt->cl_xprt))
+                args.dir = NFS4_CDFC4_FORE;
+
+        task = rpc_run_task(&task_setup_data);
+        if (!IS_ERR(task)) {
+                status = task->tk_status;
+                rpc_put_task(task);
+        } else
+                status = PTR_ERR(task);
         trace_nfs4_bind_conn_to_session(clp, status);
         if (status == 0) {
                 if (memcmp(res.sessionid.data,
@@ -6837,6 +6868,31 @@ out:
         return status;
 }
 
+struct rpc_bind_conn_calldata {
+        struct nfs_client *clp;
+        struct rpc_cred *cred;
+};
+
+static int
+nfs4_proc_bind_conn_to_session_callback(struct rpc_clnt *clnt,
+                struct rpc_xprt *xprt,
+                void *calldata)
+{
+        struct rpc_bind_conn_calldata *p = calldata;
+
+        return nfs4_proc_bind_one_conn_to_session(clnt, xprt, p->clp, p->cred);
+}
+
+int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, struct rpc_cred *cred)
+{
+        struct rpc_bind_conn_calldata data = {
+                .clp = clp,
+                .cred = cred,
+        };
+        return rpc_clnt_iterate_for_each_xprt(clp->cl_rpcclient,
+                        nfs4_proc_bind_conn_to_session_callback, &data);
+}
+
 /*
  * Minimum set of SP4_MACH_CRED operations from RFC 5661 in the enforce map
  * and operations we'd like to see to enable certain features in the allow map
@@ -7319,7 +7375,7 @@ static void nfs4_init_channel_attrs(struct nfs41_create_session_args *args)
         args->bc_attrs.max_resp_sz = PAGE_SIZE;
         args->bc_attrs.max_resp_sz_cached = 0;
         args->bc_attrs.max_ops = NFS4_MAX_BACK_CHANNEL_OPS;
-        args->bc_attrs.max_reqs = 1;
+        args->bc_attrs.max_reqs = NFS41_BC_MAX_CALLBACKS;
 
         dprintk("%s: Back Channel : max_rqst_sz=%u max_resp_sz=%u "
                 "max_resp_sz_cached=%u max_ops=%u max_reqs=%u\n",
diff --git a/fs/nfs/nfs4session.c b/fs/nfs/nfs4session.c
index e23366effcfb..332d06e64fa9 100644
--- a/fs/nfs/nfs4session.c
+++ b/fs/nfs/nfs4session.c
@@ -135,6 +135,43 @@ static struct nfs4_slot *nfs4_find_or_create_slot(struct nfs4_slot_table  *tbl,
         return ERR_PTR(-ENOMEM);
 }
 
+static void nfs4_lock_slot(struct nfs4_slot_table *tbl,
+                struct nfs4_slot *slot)
+{
+        u32 slotid = slot->slot_nr;
+
+        __set_bit(slotid, tbl->used_slots);
+        if (slotid > tbl->highest_used_slotid ||
+            tbl->highest_used_slotid == NFS4_NO_SLOT)
+                tbl->highest_used_slotid = slotid;
+        slot->generation = tbl->generation;
+}
+
+/*
+ * nfs4_try_to_lock_slot - Given a slot try to allocate it
+ *
+ * Note: must be called with the slot_tbl_lock held.
+ */
+bool nfs4_try_to_lock_slot(struct nfs4_slot_table *tbl, struct nfs4_slot *slot)
+{
+        if (nfs4_test_locked_slot(tbl, slot->slot_nr))
+                return false;
+        nfs4_lock_slot(tbl, slot);
+        return true;
+}
+
+/*
+ * nfs4_lookup_slot - Find a slot but don't allocate it
+ *
+ * Note: must be called with the slot_tbl_lock held.
+ */
+struct nfs4_slot *nfs4_lookup_slot(struct nfs4_slot_table *tbl, u32 slotid)
+{
+        if (slotid <= tbl->max_slotid)
+                return nfs4_find_or_create_slot(tbl, slotid, 1, GFP_NOWAIT);
+        return ERR_PTR(-E2BIG);
+}
+
 /*
  * nfs4_alloc_slot - efficiently look for a free slot
  *
@@ -153,18 +190,11 @@ struct nfs4_slot *nfs4_alloc_slot(struct nfs4_slot_table *tbl)
                 __func__, tbl->used_slots[0], tbl->highest_used_slotid,
                 tbl->max_slotid + 1);
         slotid = find_first_zero_bit(tbl->used_slots, tbl->max_slotid + 1);
-        if (slotid > tbl->max_slotid)
-                goto out;
-        ret = nfs4_find_or_create_slot(tbl, slotid, 1, GFP_NOWAIT);
-        if (IS_ERR(ret))
-                goto out;
-        __set_bit(slotid, tbl->used_slots);
-        if (slotid > tbl->highest_used_slotid ||
-                        tbl->highest_used_slotid == NFS4_NO_SLOT)
-                tbl->highest_used_slotid = slotid;
-        ret->generation = tbl->generation;
-
-out:
+        if (slotid <= tbl->max_slotid) {
+                ret = nfs4_find_or_create_slot(tbl, slotid, 1, GFP_NOWAIT);
+                if (!IS_ERR(ret))
+                        nfs4_lock_slot(tbl, ret);
+        }
         dprintk("<-- %s used_slots=%04lx highest_used=%u slotid=%u\n",
                 __func__, tbl->used_slots[0], tbl->highest_used_slotid,
                 !IS_ERR(ret) ? ret->slot_nr : NFS4_NO_SLOT);
diff --git a/fs/nfs/nfs4session.h b/fs/nfs/nfs4session.h
index e3ea2c5324d6..5b51298d1d03 100644
--- a/fs/nfs/nfs4session.h
+++ b/fs/nfs/nfs4session.h
@@ -77,6 +77,8 @@ extern int nfs4_setup_slot_table(struct nfs4_slot_table *tbl,
                 unsigned int max_reqs, const char *queue);
 extern void nfs4_shutdown_slot_table(struct nfs4_slot_table *tbl);
 extern struct nfs4_slot *nfs4_alloc_slot(struct nfs4_slot_table *tbl);
+extern struct nfs4_slot *nfs4_lookup_slot(struct nfs4_slot_table *tbl, u32 slotid);
+extern bool nfs4_try_to_lock_slot(struct nfs4_slot_table *tbl, struct nfs4_slot *slot);
 extern void nfs4_free_slot(struct nfs4_slot_table *tbl, struct nfs4_slot *slot);
 extern void nfs4_slot_tbl_drain_complete(struct nfs4_slot_table *tbl);
 bool nfs41_wake_and_assign_slot(struct nfs4_slot_table *tbl,
@@ -88,6 +90,12 @@ static inline bool nfs4_slot_tbl_draining(struct nfs4_slot_table *tbl)
         return !!test_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state);
 }
 
+static inline bool nfs4_test_locked_slot(const struct nfs4_slot_table *tbl,
+                u32 slotid)
+{
+        return !!test_bit(slotid, tbl->used_slots);
+}
+
 #if defined(CONFIG_NFS_V4_1)
 extern void nfs41_set_target_slotid(struct nfs4_slot_table *tbl,
                 u32 target_highest_slotid);
diff --git a/fs/nfs/pnfs_nfs.c b/fs/nfs/pnfs_nfs.c
index 81ac6480f9e7..4aaed890048f 100644
--- a/fs/nfs/pnfs_nfs.c
+++ b/fs/nfs/pnfs_nfs.c
@@ -606,12 +606,22 @@ static int _nfs4_pnfs_v3_ds_connect(struct nfs_server *mds_srv,
                 dprintk("%s: DS %s: trying address %s\n",
                         __func__, ds->ds_remotestr, da->da_remotestr);
 
-                clp = get_v3_ds_connect(mds_srv->nfs_client,
+                if (!IS_ERR(clp)) {
+                        struct xprt_create xprt_args = {
+                                .ident = XPRT_TRANSPORT_TCP,
+                                .net = clp->cl_net,
+                                .dstaddr = (struct sockaddr *)&da->da_addr,
+                                .addrlen = da->da_addrlen,
+                                .servername = clp->cl_hostname,
+                        };
+                        /* Add this address as an alias */
+                        rpc_clnt_add_xprt(clp->cl_rpcclient, &xprt_args,
+                                        rpc_clnt_test_and_add_xprt, NULL);
+                } else
+                        clp = get_v3_ds_connect(mds_srv->nfs_client,
                                         (struct sockaddr *)&da->da_addr,
                                         da->da_addrlen, IPPROTO_TCP,
                                         timeo, retrans, au_flavor);
-                if (!IS_ERR(clp))
-                        break;
         }
 
         if (IS_ERR(clp)) {