Merge tag 'nfs-for-3.11-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs

Pull NFS client updates from Trond Myklebust:
 "Feature highlights include:
   - Add basic client support for NFSv4.2
   - Add basic client support for Labeled NFS (selinux for NFSv4.2)
   - Fix the use of credentials in NFSv4.1 stateful operations, and add
     support for NFSv4.1 state protection.

  Bugfix highlights:
   - Fix another NFSv4 open state recovery race
   - Fix an NFSv4.1 back channel session regression
   - Various rpc_pipefs races
   - Fix another issue with NFSv3 auth negotiation

  Please note that Labeled NFS does require some additional support from
  the security subsystem.  The relevant changesets have all been
  reviewed and acked by James Morris."

* tag 'nfs-for-3.11-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs: (54 commits)
  NFS: Set NFS_CS_MIGRATION for NFSv4 mounts
  NFSv4.1 Refactor nfs4_init_session and nfs4_init_channel_attrs
  nfs: have NFSv3 try server-specified auth flavors in turn
  nfs: have nfs_mount fake up a auth_flavs list when the server didn't provide it
  nfs: move server_authlist into nfs_try_mount_request
  nfs: refactor "need_mount" code out of nfs_try_mount
  SUNRPC: PipeFS MOUNT notification optimization for dying clients
  SUNRPC: split client creation routine into setup and registration
  SUNRPC: fix races on PipeFS UMOUNT notifications
  SUNRPC: fix races on PipeFS MOUNT notifications
  NFSv4.1 use pnfs_device maxcount for the objectlayout gdia_maxcount
  NFSv4.1 use pnfs_device maxcount for the blocklayout gdia_maxcount
  NFSv4.1 Fix gdia_maxcount calculation to fit in ca_maxresponsesize
  NFS: Improve legacy idmapping fallback
  NFSv4.1 end back channel session draining
  NFS: Apply v4.1 capabilities to v4.2
  NFSv4.1: Clean up layout segment comparison helper names
  NFSv4.1: layout segment comparison helpers should take 'const' parameters
  NFSv4: Move the DNS resolver into the NFSv4 module
  rpc_pipefs: only set rpc_dentry_ops if d_op isn't already set
  ...

35 files changed, 1234 insertions, 453 deletions

diff --git a/fs/nfs/Kconfig b/fs/nfs/Kconfig
index 13ca196385f5..b5e80b0af315 100644
--- a/fs/nfs/Kconfig
+++ b/fs/nfs/Kconfig
@@ -104,6 +104,15 @@ config NFS_V4_1
 
           If unsure, say N.
 
+config NFS_V4_2
+        bool "NFS client support for NFSv4.2"
+        depends on NFS_V4_1
+        help
+          This option enables support for minor version 2 of the NFSv4 protocol
+          in the kernel's NFS client.
+
+          If unsure, say N.
+
 config PNFS_FILE_LAYOUT
         tristate
         depends on NFS_V4_1
@@ -131,6 +140,11 @@ config NFS_V4_1_IMPLEMENTATION_ID_DOMAIN
           If the NFS client is unchanged from the upstream kernel, this
           option should be set to the default "kernel.org".
 
+config NFS_V4_SECURITY_LABEL
+        bool
+        depends on NFS_V4_2 && SECURITY
+        default y
+
 config ROOT_NFS
         bool "Root file system on NFS"
         depends on NFS_FS=y && IP_PNP
diff --git a/fs/nfs/Makefile b/fs/nfs/Makefile
index cce2c057bd2d..e0bb048e9576 100644
--- a/fs/nfs/Makefile
+++ b/fs/nfs/Makefile
@@ -6,8 +6,7 @@ obj-$(CONFIG_NFS_FS) += nfs.o
 
 nfs-y                   := client.o dir.o file.o getroot.o inode.o super.o \
                            direct.o pagelist.o read.o symlink.o unlink.o \
-                           write.o namespace.o mount_clnt.o \
-                           dns_resolve.o cache_lib.o
+                           write.o namespace.o mount_clnt.o
 nfs-$(CONFIG_ROOT_NFS)  += nfsroot.o
 nfs-$(CONFIG_SYSCTL)    += sysctl.o
 nfs-$(CONFIG_NFS_FSCACHE) += fscache.o fscache-index.o
@@ -22,7 +21,8 @@ nfsv3-$(CONFIG_NFS_V3_ACL) += nfs3acl.o
 obj-$(CONFIG_NFS_V4) += nfsv4.o
 nfsv4-y := nfs4proc.o nfs4xdr.o nfs4state.o nfs4renewd.o nfs4super.o nfs4file.o \
           delegation.o idmap.o callback.o callback_xdr.o callback_proc.o \
-          nfs4namespace.o nfs4getroot.o nfs4client.o
+          nfs4namespace.o nfs4getroot.o nfs4client.o dns_resolve.o
+nfsv4-$(CONFIG_NFS_USE_LEGACY_DNS) += cache_lib.o
 nfsv4-$(CONFIG_SYSCTL)  += nfs4sysctl.o
 nfsv4-$(CONFIG_NFS_V4_1)        += nfs4session.o pnfs.o pnfs_dev.o
 
diff --git a/fs/nfs/blocklayout/blocklayout.c b/fs/nfs/blocklayout/blocklayout.c
index 434b93ec0970..e242bbf72972 100644
--- a/fs/nfs/blocklayout/blocklayout.c
+++ b/fs/nfs/blocklayout/blocklayout.c
@@ -1089,9 +1089,10 @@ nfs4_blk_get_deviceinfo(struct nfs_server *server, const struct nfs_fh *fh,
         dev->pgbase = 0;
         dev->pglen = PAGE_SIZE * max_pages;
         dev->mincount = 0;
+        dev->maxcount = max_resp_sz - nfs41_maxgetdevinfo_overhead;
 
         dprintk("%s: dev_id: %s\n", __func__, dev->dev_id.data);
-        rc = nfs4_proc_getdeviceinfo(server, dev);
+        rc = nfs4_proc_getdeviceinfo(server, dev, NULL);
         dprintk("%s getdevice info returns %d\n", __func__, rc);
         if (rc) {
                 rv = ERR_PTR(rc);
diff --git a/fs/nfs/callback.c b/fs/nfs/callback.c
index da6a43d19aa3..67cd73213168 100644
--- a/fs/nfs/callback.c
+++ b/fs/nfs/callback.c
@@ -281,6 +281,7 @@ static int nfs_callback_up_net(int minorversion, struct svc_serv *serv, struct n
                         ret = nfs4_callback_up_net(serv, net);
                         break;
                 case 1:
+                case 2:
                         ret = nfs41_callback_up_net(serv, net);
                         break;
                 default:
diff --git a/fs/nfs/callback.h b/fs/nfs/callback.h
index efd54f0a4c46..84326e9fb47a 100644
--- a/fs/nfs/callback.h
+++ b/fs/nfs/callback.h
@@ -32,6 +32,8 @@ enum nfs4_callback_opnum {
         OP_CB_WANTS_CANCELLED = 12,
         OP_CB_NOTIFY_LOCK   = 13,
         OP_CB_NOTIFY_DEVICEID = 14,
+/* Callback operations new to NFSv4.2 */
+        OP_CB_OFFLOAD = 15,
         OP_CB_ILLEGAL = 10044,
 };
 
@@ -39,6 +41,7 @@ struct cb_process_state {
         __be32                  drc_status;
         struct nfs_client       *clp;
         u32                     slotid;
+        u32                     minorversion;
         struct net              *net;
 };
 
diff --git a/fs/nfs/callback_proc.c b/fs/nfs/callback_proc.c
index 0bc27684ebfa..e6ebc4c38c81 100644
--- a/fs/nfs/callback_proc.c
+++ b/fs/nfs/callback_proc.c
@@ -406,7 +406,8 @@ __be32 nfs4_callback_sequence(struct cb_sequenceargs *args,
         int i;
         __be32 status = htonl(NFS4ERR_BADSESSION);
 
-        clp = nfs4_find_client_sessionid(cps->net, args->csa_addr, &args->csa_sessionid);
+        clp = nfs4_find_client_sessionid(cps->net, args->csa_addr,
+                                         &args->csa_sessionid, cps->minorversion);
         if (clp == NULL)
                 goto out;
 
diff --git a/fs/nfs/callback_xdr.c b/fs/nfs/callback_xdr.c
index a35582c9d444..f4ccfe6521ec 100644
--- a/fs/nfs/callback_xdr.c
+++ b/fs/nfs/callback_xdr.c
@@ -166,9 +166,9 @@ static __be32 decode_compound_hdr_arg(struct xdr_stream *xdr, struct cb_compound
         if (unlikely(p == NULL))
                 return htonl(NFS4ERR_RESOURCE);
         hdr->minorversion = ntohl(*p++);
-        /* Check minor version is zero or one. */
-        if (hdr->minorversion <= 1) {
-                hdr->cb_ident = ntohl(*p++); /* ignored by v4.1 */
+        /* Check for minor version support */
+        if (hdr->minorversion <= NFS4_MAX_MINOR_VERSION) {
+                hdr->cb_ident = ntohl(*p++); /* ignored by v4.1 and v4.2 */
         } else {
                 pr_warn_ratelimited("NFS: %s: NFSv4 server callback with "
                         "illegal minor version %u!\n",
@@ -786,6 +786,26 @@ static void nfs4_cb_free_slot(struct cb_process_state *cps)
 }
 #endif /* CONFIG_NFS_V4_1 */
 
+#ifdef CONFIG_NFS_V4_2
+static __be32
+preprocess_nfs42_op(int nop, unsigned int op_nr, struct callback_op **op)
+{
+        __be32 status = preprocess_nfs41_op(nop, op_nr, op);
+        if (status != htonl(NFS4ERR_OP_ILLEGAL))
+                return status;
+
+        if (op_nr == OP_CB_OFFLOAD)
+                return htonl(NFS4ERR_NOTSUPP);
+        return htonl(NFS4ERR_OP_ILLEGAL);
+}
+#else /* CONFIG_NFS_V4_2 */
+static __be32
+preprocess_nfs42_op(int nop, unsigned int op_nr, struct callback_op **op)
+{
+        return htonl(NFS4ERR_MINOR_VERS_MISMATCH);
+}
+#endif /* CONFIG_NFS_V4_2 */
+
 static __be32
 preprocess_nfs4_op(unsigned int op_nr, struct callback_op **op)
 {
@@ -801,8 +821,7 @@ preprocess_nfs4_op(unsigned int op_nr, struct callback_op **op)
         return htonl(NFS_OK);
 }
 
-static __be32 process_op(uint32_t minorversion, int nop,
-                struct svc_rqst *rqstp,
+static __be32 process_op(int nop, struct svc_rqst *rqstp,
                 struct xdr_stream *xdr_in, void *argp,
                 struct xdr_stream *xdr_out, void *resp,
                 struct cb_process_state *cps)
@@ -819,10 +838,22 @@ static __be32 process_op(uint32_t minorversion, int nop,
                 return status;
 
         dprintk("%s: minorversion=%d nop=%d op_nr=%u\n",
-                __func__, minorversion, nop, op_nr);
+                __func__, cps->minorversion, nop, op_nr);
+
+        switch (cps->minorversion) {
+        case 0:
+                status = preprocess_nfs4_op(op_nr, &op);
+                break;
+        case 1:
+                status = preprocess_nfs41_op(nop, op_nr, &op);
+                break;
+        case 2:
+                status = preprocess_nfs42_op(nop, op_nr, &op);
+                break;
+        default:
+                status = htonl(NFS4ERR_MINOR_VERS_MISMATCH);
+        }
 
-        status = minorversion ? preprocess_nfs41_op(nop, op_nr, &op) :
-                                preprocess_nfs4_op(op_nr, &op);
         if (status == htonl(NFS4ERR_OP_ILLEGAL))
                 op_nr = OP_CB_ILLEGAL;
         if (status)
@@ -885,14 +916,15 @@ static __be32 nfs4_callback_compound(struct svc_rqst *rqstp, void *argp, void *r
                         return rpc_drop_reply;
         }
 
+        cps.minorversion = hdr_arg.minorversion;
         hdr_res.taglen = hdr_arg.taglen;
         hdr_res.tag = hdr_arg.tag;
         if (encode_compound_hdr_res(&xdr_out, &hdr_res) != 0)
                 return rpc_system_err;
 
         while (status == 0 && nops != hdr_arg.nops) {
-                status = process_op(hdr_arg.minorversion, nops, rqstp,
-                                    &xdr_in, argp, &xdr_out, resp, &cps);
+                status = process_op(nops, rqstp, &xdr_in,
+                                    argp, &xdr_out, resp, &cps);
                 nops++;
         }
 
diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index c513b0cc835f..340b1eff0267 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -753,8 +753,6 @@ static int nfs_init_server(struct nfs_server *server,
                         data->timeo, data->retrans);
         if (data->flags & NFS_MOUNT_NORESVPORT)
                 set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags);
-        if (server->options & NFS_OPTION_MIGRATION)
-                set_bit(NFS_CS_MIGRATION, &cl_init.init_flags);
 
         /* Allocate or find a client reference we can use */
         clp = nfs_get_client(&cl_init, &timeparms, NULL, RPC_AUTH_UNIX);
@@ -1076,7 +1074,7 @@ struct nfs_server *nfs_create_server(struct nfs_mount_info *mount_info,
         }
 
         if (!(fattr->valid & NFS_ATTR_FATTR)) {
-                error = nfs_mod->rpc_ops->getattr(server, mount_info->mntfh, fattr);
+                error = nfs_mod->rpc_ops->getattr(server, mount_info->mntfh, fattr, NULL);
                 if (error < 0) {
                         dprintk("nfs_create_server: getattr error = %d\n", -error);
                         goto error;
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index c933bdfbcb1f..0fac2cb1ea18 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -437,6 +437,7 @@ void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
         struct dentry *alias;
         struct inode *dir = parent->d_inode;
         struct inode *inode;
+        int status;
 
         if (filename.name[0] == '.') {
                 if (filename.len == 1)
@@ -449,7 +450,9 @@ void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
         dentry = d_lookup(parent, &filename);
         if (dentry != NULL) {
                 if (nfs_same_file(dentry, entry)) {
-                        nfs_refresh_inode(dentry->d_inode, entry->fattr);
+                        status = nfs_refresh_inode(dentry->d_inode, entry->fattr);
+                        if (!status)
+                                nfs_setsecurity(dentry->d_inode, entry->fattr, entry->label);
                         goto out;
                 } else {
                         if (d_invalidate(dentry) != 0)
@@ -462,7 +465,7 @@ void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
         if (dentry == NULL)
                 return;
 
-        inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr);
+        inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr, entry->label);
         if (IS_ERR(inode))
                 goto out;
 
@@ -587,10 +590,16 @@ int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page,
         if (entry.fh == NULL || entry.fattr == NULL)
                 goto out;
 
+        entry.label = nfs4_label_alloc(NFS_SERVER(inode), GFP_NOWAIT);
+        if (IS_ERR(entry.label)) {
+                status = PTR_ERR(entry.label);
+                goto out;
+        }
+
         array = nfs_readdir_get_array(page);
         if (IS_ERR(array)) {
                 status = PTR_ERR(array);
-                goto out;
+                goto out_label_free;
         }
         memset(array, 0, sizeof(struct nfs_cache_array));
         array->eof_index = -1;
@@ -616,6 +625,8 @@ int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page,
         nfs_readdir_free_large_page(pages_ptr, pages, array_size);
 out_release_array:
         nfs_readdir_release_array(page);
+out_label_free:
+        nfs4_label_free(entry.label);
 out:
         nfs_free_fattr(entry.fattr);
         nfs_free_fhandle(entry.fh);
@@ -1040,6 +1051,7 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
         struct dentry *parent;
         struct nfs_fh *fhandle = NULL;
         struct nfs_fattr *fattr = NULL;
+        struct nfs4_label *label = NULL;
         int error;
 
         if (flags & LOOKUP_RCU)
@@ -1082,7 +1094,11 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
         if (fhandle == NULL || fattr == NULL)
                 goto out_error;
 
-        error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
+        label = nfs4_label_alloc(NFS_SERVER(inode), GFP_NOWAIT);
+        if (IS_ERR(label))
+                goto out_error;
+
+        error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, label);
         if (error)
                 goto out_bad;
         if (nfs_compare_fh(NFS_FH(inode), fhandle))
@@ -1090,8 +1106,12 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
         if ((error = nfs_refresh_inode(inode, fattr)) != 0)
                 goto out_bad;
 
+        nfs_setsecurity(inode, fattr, label);
+
         nfs_free_fattr(fattr);
         nfs_free_fhandle(fhandle);
+        nfs4_label_free(label);
+
 out_set_verifier:
         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
  out_valid:
@@ -1108,6 +1128,7 @@ out_zap_parent:
  out_bad:
         nfs_free_fattr(fattr);
         nfs_free_fhandle(fhandle);
+        nfs4_label_free(label);
         nfs_mark_for_revalidate(dir);
         if (inode && S_ISDIR(inode->i_mode)) {
                 /* Purge readdir caches. */
@@ -1128,6 +1149,7 @@ out_zap_parent:
 out_error:
         nfs_free_fattr(fattr);
         nfs_free_fhandle(fhandle);
+        nfs4_label_free(label);
         dput(parent);
         dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) lookup returned error %d\n",
                         __func__, dentry->d_parent->d_name.name,
@@ -1256,6 +1278,7 @@ struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned in
         struct inode *inode = NULL;
         struct nfs_fh *fhandle = NULL;
         struct nfs_fattr *fattr = NULL;
+        struct nfs4_label *label = NULL;
         int error;
 
         dfprintk(VFS, "NFS: lookup(%s/%s)\n",
@@ -1282,17 +1305,21 @@ struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned in
         if (fhandle == NULL || fattr == NULL)
                 goto out;
 
+        label = nfs4_label_alloc(NFS_SERVER(dir), GFP_NOWAIT);
+        if (IS_ERR(label))
+                goto out;
+
         parent = dentry->d_parent;
         /* Protect against concurrent sillydeletes */
         nfs_block_sillyrename(parent);
-        error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
+        error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, label);
         if (error == -ENOENT)
                 goto no_entry;
         if (error < 0) {
                 res = ERR_PTR(error);
                 goto out_unblock_sillyrename;
         }
-        inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
+        inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label);
         res = ERR_CAST(inode);
         if (IS_ERR(res))
                 goto out_unblock_sillyrename;
@@ -1310,6 +1337,7 @@ no_entry:
         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
 out_unblock_sillyrename:
         nfs_unblock_sillyrename(parent);
+        nfs4_label_free(label);
 out:
         nfs_free_fattr(fattr);
         nfs_free_fhandle(fhandle);
@@ -1357,18 +1385,6 @@ static int nfs_finish_open(struct nfs_open_context *ctx,
 {
         int err;
 
-        if (ctx->dentry != dentry) {
-                dput(ctx->dentry);
-                ctx->dentry = dget(dentry);
-        }
-
-        /* If the open_intent is for execute, we have an extra check to make */
-        if (ctx->mode & FMODE_EXEC) {
-                err = nfs_may_open(dentry->d_inode, ctx->cred, open_flags);
-                if (err < 0)
-                        goto out;
-        }
-
         err = finish_open(file, dentry, do_open, opened);
         if (err)
                 goto out;
@@ -1427,13 +1443,13 @@ int nfs_atomic_open(struct inode *dir, struct dentry *dentry,
 
         nfs_block_sillyrename(dentry->d_parent);
         inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr);
-        d_drop(dentry);
+        nfs_unblock_sillyrename(dentry->d_parent);
         if (IS_ERR(inode)) {
-                nfs_unblock_sillyrename(dentry->d_parent);
                 put_nfs_open_context(ctx);
                 err = PTR_ERR(inode);
                 switch (err) {
                 case -ENOENT:
+                        d_drop(dentry);
                         d_add(dentry, NULL);
                         break;
                 case -EISDIR:
@@ -1449,16 +1465,8 @@ int nfs_atomic_open(struct inode *dir, struct dentry *dentry,
                 }
                 goto out;
         }
-        res = d_add_unique(dentry, inode);
-        if (res != NULL)
-                dentry = res;
-
-        nfs_unblock_sillyrename(dentry->d_parent);
-        nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
-
-        err = nfs_finish_open(ctx, dentry, file, open_flags, opened);
 
-        dput(res);
+        err = nfs_finish_open(ctx, ctx->dentry, file, open_flags, opened);
 out:
         return err;
 
@@ -1528,7 +1536,8 @@ no_open:
  * Code common to create, mkdir, and mknod.
  */
 int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
-                                struct nfs_fattr *fattr)
+                                struct nfs_fattr *fattr,
+                                struct nfs4_label *label)
 {
         struct dentry *parent = dget_parent(dentry);
         struct inode *dir = parent->d_inode;
@@ -1541,18 +1550,18 @@ int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
         if (dentry->d_inode)
                 goto out;
         if (fhandle->size == 0) {
-                error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
+                error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, NULL);
                 if (error)
                         goto out_error;
         }
         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
         if (!(fattr->valid & NFS_ATTR_FATTR)) {
                 struct nfs_server *server = NFS_SB(dentry->d_sb);
-                error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr);
+                error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr, NULL);
                 if (error < 0)
                         goto out_error;
         }
-        inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
+        inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label);
         error = PTR_ERR(inode);
         if (IS_ERR(inode))
                 goto out_error;
diff --git a/fs/nfs/dns_resolve.c b/fs/nfs/dns_resolve.c
index 945527092295..fc0f95ec7358 100644
--- a/fs/nfs/dns_resolve.c
+++ b/fs/nfs/dns_resolve.c
@@ -29,7 +29,6 @@ ssize_t nfs_dns_resolve_name(struct net *net, char *name, size_t namelen,
         kfree(ip_addr);
         return ret;
 }
-EXPORT_SYMBOL_GPL(nfs_dns_resolve_name);
 
 #else
 
@@ -351,7 +350,6 @@ ssize_t nfs_dns_resolve_name(struct net *net, char *name,
                 ret = -ESRCH;
         return ret;
 }
-EXPORT_SYMBOL_GPL(nfs_dns_resolve_name);
 
 static struct cache_detail nfs_dns_resolve_template = {
         .owner          = THIS_MODULE,
@@ -396,6 +394,21 @@ void nfs_dns_resolver_cache_destroy(struct net *net)
         cache_destroy_net(nn->nfs_dns_resolve, net);
 }
 
+static int nfs4_dns_net_init(struct net *net)
+{
+        return nfs_dns_resolver_cache_init(net);
+}
+
+static void nfs4_dns_net_exit(struct net *net)
+{
+        nfs_dns_resolver_cache_destroy(net);
+}
+
+static struct pernet_operations nfs4_dns_resolver_ops = {
+        .init = nfs4_dns_net_init,
+        .exit = nfs4_dns_net_exit,
+};
+
 static int rpc_pipefs_event(struct notifier_block *nb, unsigned long event,
                            void *ptr)
 {
@@ -432,11 +445,24 @@ static struct notifier_block nfs_dns_resolver_block = {
 
 int nfs_dns_resolver_init(void)
 {
-        return rpc_pipefs_notifier_register(&nfs_dns_resolver_block);
+        int err;
+
+        err = register_pernet_subsys(&nfs4_dns_resolver_ops);
+        if (err < 0)
+                goto out;
+        err = rpc_pipefs_notifier_register(&nfs_dns_resolver_block);
+        if (err < 0)
+                goto out1;
+        return 0;
+out1:
+        unregister_pernet_subsys(&nfs4_dns_resolver_ops);
+out:
+        return err;
 }
 
 void nfs_dns_resolver_destroy(void)
 {
         rpc_pipefs_notifier_unregister(&nfs_dns_resolver_block);
+        unregister_pernet_subsys(&nfs4_dns_resolver_ops);
 }
 #endif
diff --git a/fs/nfs/getroot.c b/fs/nfs/getroot.c
index 44efaa8c5f78..66984a9aafaa 100644
--- a/fs/nfs/getroot.c
+++ b/fs/nfs/getroot.c
@@ -95,7 +95,7 @@ struct dentry *nfs_get_root(struct super_block *sb, struct nfs_fh *mntfh,
                 goto out;
         }
 
-        inode = nfs_fhget(sb, mntfh, fsinfo.fattr);
+        inode = nfs_fhget(sb, mntfh, fsinfo.fattr, NULL);
         if (IS_ERR(inode)) {
                 dprintk("nfs_get_root: get root inode failed\n");
                 ret = ERR_CAST(inode);
diff --git a/fs/nfs/idmap.c b/fs/nfs/idmap.c
index c516da5873fd..c2c4163d5683 100644
--- a/fs/nfs/idmap.c
+++ b/fs/nfs/idmap.c
@@ -262,29 +262,42 @@ static ssize_t nfs_idmap_get_desc(const char *name, size_t namelen,
         return desclen;
 }
 
-static ssize_t nfs_idmap_request_key(struct key_type *key_type,
-                                     const char *name, size_t namelen,
-                                     const char *type, void *data,
-                                     size_t data_size, struct idmap *idmap)
+static struct key *nfs_idmap_request_key(const char *name, size_t namelen,
+                                         const char *type, struct idmap *idmap)
 {
-        const struct cred *saved_cred;
-        struct key *rkey;
         char *desc;
-        struct user_key_payload *payload;
+        struct key *rkey;
         ssize_t ret;
 
         ret = nfs_idmap_get_desc(name, namelen, type, strlen(type), &desc);
         if (ret <= 0)
-                goto out;
+                return ERR_PTR(ret);
+
+        rkey = request_key(&key_type_id_resolver, desc, "");
+        if (IS_ERR(rkey)) {
+                mutex_lock(&idmap->idmap_mutex);
+                rkey = request_key_with_auxdata(&key_type_id_resolver_legacy,
+                                                desc, "", 0, idmap);
+                mutex_unlock(&idmap->idmap_mutex);
+        }
+
+        kfree(desc);
+        return rkey;
+}
+
+static ssize_t nfs_idmap_get_key(const char *name, size_t namelen,
+                                 const char *type, void *data,
+                                 size_t data_size, struct idmap *idmap)
+{
+        const struct cred *saved_cred;
+        struct key *rkey;
+        struct user_key_payload *payload;
+        ssize_t ret;
 
         saved_cred = override_creds(id_resolver_cache);
-        if (idmap)
-                rkey = request_key_with_auxdata(key_type, desc, "", 0, idmap);
-        else
-                rkey = request_key(&key_type_id_resolver, desc, "");
+        rkey = nfs_idmap_request_key(name, namelen, type, idmap);
         revert_creds(saved_cred);
 
-        kfree(desc);
         if (IS_ERR(rkey)) {
                 ret = PTR_ERR(rkey);
                 goto out;
@@ -316,23 +329,6 @@ out:
         return ret;
 }
 
-static ssize_t nfs_idmap_get_key(const char *name, size_t namelen,
-                                 const char *type, void *data,
-                                 size_t data_size, struct idmap *idmap)
-{
-        ssize_t ret = nfs_idmap_request_key(&key_type_id_resolver,
-                                            name, namelen, type, data,
-                                            data_size, NULL);
-        if (ret < 0) {
-                mutex_lock(&idmap->idmap_mutex);
-                ret = nfs_idmap_request_key(&key_type_id_resolver_legacy,
-                                            name, namelen, type, data,
-                                            data_size, idmap);
-                mutex_unlock(&idmap->idmap_mutex);
-        }
-        return ret;
-}
-
 /* ID -> Name */
 static ssize_t nfs_idmap_lookup_name(__u32 id, const char *type, char *buf,
                                      size_t buflen, struct idmap *idmap)
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index ce727047ee87..c93639e6cf68 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -48,7 +48,6 @@
 #include "iostat.h"
 #include "internal.h"
 #include "fscache.h"
-#include "dns_resolve.h"
 #include "pnfs.h"
 #include "nfs.h"
 #include "netns.h"
@@ -162,11 +161,19 @@ static void nfs_zap_caches_locked(struct inode *inode)
 
         memset(NFS_I(inode)->cookieverf, 0, sizeof(NFS_I(inode)->cookieverf));
         if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) {
-                nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
                 nfs_fscache_invalidate(inode);
-        } else {
-                nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
-        }
+                nfsi->cache_validity |= NFS_INO_INVALID_ATTR
+                                        | NFS_INO_INVALID_LABEL
+                                        | NFS_INO_INVALID_DATA
+                                        | NFS_INO_INVALID_ACCESS
+                                        | NFS_INO_INVALID_ACL
+                                        | NFS_INO_REVAL_PAGECACHE;
+        } else
+                nfsi->cache_validity |= NFS_INO_INVALID_ATTR
+                                        | NFS_INO_INVALID_LABEL
+                                        | NFS_INO_INVALID_ACCESS
+                                        | NFS_INO_INVALID_ACL
+                                        | NFS_INO_REVAL_PAGECACHE;
 }
 
 void nfs_zap_caches(struct inode *inode)
@@ -257,12 +264,72 @@ nfs_init_locked(struct inode *inode, void *opaque)
         return 0;
 }
 
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr,
+                                        struct nfs4_label *label)
+{
+        int error;
+
+        if (label == NULL)
+                return;
+
+        if (nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL) == 0)
+                return;
+
+        if (NFS_SERVER(inode)->nfs_client->cl_minorversion < 2)
+                return;
+
+        if ((fattr->valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL) && inode->i_security) {
+                error = security_inode_notifysecctx(inode, label->label,
+                                label->len);
+                if (error)
+                        printk(KERN_ERR "%s() %s %d "
+                                        "security_inode_notifysecctx() %d\n",
+                                        __func__,
+                                        (char *)label->label,
+                                        label->len, error);
+        }
+}
+
+struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags)
+{
+        struct nfs4_label *label = NULL;
+        int minor_version = server->nfs_client->cl_minorversion;
+
+        if (minor_version < 2)
+                return label;
+
+        if (!(server->caps & NFS_CAP_SECURITY_LABEL))
+                return label;
+
+        label = kzalloc(sizeof(struct nfs4_label), flags);
+        if (label == NULL)
+                return ERR_PTR(-ENOMEM);
+
+        label->label = kzalloc(NFS4_MAXLABELLEN, flags);
+        if (label->label == NULL) {
+                kfree(label);
+                return ERR_PTR(-ENOMEM);
+        }
+        label->len = NFS4_MAXLABELLEN;
+
+        return label;
+}
+EXPORT_SYMBOL_GPL(nfs4_label_alloc);
+#else
+void inline nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr,
+                                        struct nfs4_label *label)
+{
+}
+#endif
+EXPORT_SYMBOL_GPL(nfs_setsecurity);
+
 /*
  * This is our front-end to iget that looks up inodes by file handle
  * instead of inode number.
  */
 struct inode *
-nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
+nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr, struct nfs4_label *label)
 {
         struct nfs_find_desc desc = {
                 .fh     = fh,
@@ -384,6 +451,9 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
                          */
                         inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
                 }
+
+                nfs_setsecurity(inode, fattr, label);
+
                 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
                 nfsi->attrtimeo_timestamp = now;
                 nfsi->access_cache = RB_ROOT;
@@ -393,6 +463,7 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
                 unlock_new_inode(inode);
         } else
                 nfs_refresh_inode(inode, fattr);
+                nfs_setsecurity(inode, fattr, label);
         dprintk("NFS: nfs_fhget(%s/%Ld fh_crc=0x%08x ct=%d)\n",
                 inode->i_sb->s_id,
                 (long long)NFS_FILEID(inode),
@@ -449,7 +520,7 @@ nfs_setattr(struct dentry *dentry, struct iattr *attr)
                 NFS_PROTO(inode)->return_delegation(inode);
         error = NFS_PROTO(inode)->setattr(dentry, fattr, attr);
         if (error == 0)
-                nfs_refresh_inode(inode, fattr);
+                error = nfs_refresh_inode(inode, fattr);
         nfs_free_fattr(fattr);
 out:
         return error;
@@ -713,16 +784,23 @@ EXPORT_SYMBOL_GPL(put_nfs_open_context);
  * Ensure that mmap has a recent RPC credential for use when writing out
  * shared pages
  */
-void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
+void nfs_inode_attach_open_context(struct nfs_open_context *ctx)
 {
-        struct inode *inode = file_inode(filp);
+        struct inode *inode = ctx->dentry->d_inode;
         struct nfs_inode *nfsi = NFS_I(inode);
 
-        filp->private_data = get_nfs_open_context(ctx);
         spin_lock(&inode->i_lock);
         list_add(&ctx->list, &nfsi->open_files);
         spin_unlock(&inode->i_lock);
 }
+EXPORT_SYMBOL_GPL(nfs_inode_attach_open_context);
+
+void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
+{
+        filp->private_data = get_nfs_open_context(ctx);
+        if (list_empty(&ctx->list))
+                nfs_inode_attach_open_context(ctx);
+}
 EXPORT_SYMBOL_GPL(nfs_file_set_open_context);
 
 /*
@@ -748,10 +826,11 @@ struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_c
 
 static void nfs_file_clear_open_context(struct file *filp)
 {
-        struct inode *inode = file_inode(filp);
         struct nfs_open_context *ctx = nfs_file_open_context(filp);
 
         if (ctx) {
+                struct inode *inode = ctx->dentry->d_inode;
+
                 filp->private_data = NULL;
                 spin_lock(&inode->i_lock);
                 list_move_tail(&ctx->list, &NFS_I(inode)->open_files);
@@ -790,6 +869,7 @@ int
 __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
 {
         int              status = -ESTALE;
+        struct nfs4_label *label = NULL;
         struct nfs_fattr *fattr = NULL;
         struct nfs_inode *nfsi = NFS_I(inode);
 
@@ -807,7 +887,14 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
                 goto out;
 
         nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
-        status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr);
+
+        label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
+        if (IS_ERR(label)) {
+                status = PTR_ERR(label);
+                goto out;
+        }
+
+        status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr, label);
         if (status != 0) {
                 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n",
                          inode->i_sb->s_id,
@@ -817,7 +904,7 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
                         if (!S_ISDIR(inode->i_mode))
                                 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
                 }
-                goto out;
+                goto err_out;
         }
 
         status = nfs_refresh_inode(inode, fattr);
@@ -825,7 +912,7 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
                 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n",
                          inode->i_sb->s_id,
                          (long long)NFS_FILEID(inode), status);
-                goto out;
+                goto err_out;
         }
 
         if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
@@ -835,7 +922,9 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
                 inode->i_sb->s_id,
                 (long long)NFS_FILEID(inode));
 
- out:
+err_out:
+        nfs4_label_free(label);
+out:
         nfs_free_fattr(fattr);
         return status;
 }
@@ -863,7 +952,8 @@ static int nfs_attribute_cache_expired(struct inode *inode)
  */
 int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
 {
-        if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR)
+        if (!(NFS_I(inode)->cache_validity &
+                        (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_LABEL))
                         && !nfs_attribute_cache_expired(inode))
                 return NFS_STALE(inode) ? -ESTALE : 0;
         return __nfs_revalidate_inode(server, inode);
@@ -1243,6 +1333,7 @@ int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
         spin_lock(&inode->i_lock);
         status = nfs_post_op_update_inode_locked(inode, fattr);
         spin_unlock(&inode->i_lock);
+
         return status;
 }
 EXPORT_SYMBOL_GPL(nfs_post_op_update_inode);
@@ -1483,7 +1574,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
                 inode->i_blocks = fattr->du.nfs2.blocks;
 
         /* Update attrtimeo value if we're out of the unstable period */
-        if (invalid & NFS_INO_INVALID_ATTR) {
+        if (invalid & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_LABEL)) {
                 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
                 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
                 nfsi->attrtimeo_timestamp = now;
@@ -1496,6 +1587,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
                 }
         }
         invalid &= ~NFS_INO_INVALID_ATTR;
+        invalid &= ~NFS_INO_INVALID_LABEL;
         /* Don't invalidate the data if we were to blame */
         if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
                                 || S_ISLNK(inode->i_mode)))
@@ -1638,12 +1730,11 @@ EXPORT_SYMBOL_GPL(nfs_net_id);
 static int nfs_net_init(struct net *net)
 {
         nfs_clients_init(net);
-        return nfs_dns_resolver_cache_init(net);
+        return 0;
 }
 
 static void nfs_net_exit(struct net *net)
 {
-        nfs_dns_resolver_cache_destroy(net);
         nfs_cleanup_cb_ident_idr(net);
 }
 
@@ -1661,10 +1752,6 @@ static int __init init_nfs_fs(void)
 {
         int err;
 
-        err = nfs_dns_resolver_init();
-        if (err < 0)
-                goto out10;;
-
         err = register_pernet_subsys(&nfs_net_ops);
         if (err < 0)
                 goto out9;
@@ -1730,8 +1817,6 @@ out7:
 out8:
         unregister_pernet_subsys(&nfs_net_ops);
 out9:
-        nfs_dns_resolver_destroy();
-out10:
         return err;
 }
 
@@ -1744,7 +1829,6 @@ static void __exit exit_nfs_fs(void)
         nfs_destroy_nfspagecache();
         nfs_fscache_unregister();
         unregister_pernet_subsys(&nfs_net_ops);
-        nfs_dns_resolver_destroy();
 #ifdef CONFIG_PROC_FS
         rpc_proc_unregister(&init_net, "nfs");
 #endif
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index 91e59a39fc08..3c8373f90ab3 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -165,7 +165,7 @@ extern void nfs_free_client(struct nfs_client *);
 extern struct nfs_client *nfs4_find_client_ident(struct net *, int);
 extern struct nfs_client *
 nfs4_find_client_sessionid(struct net *, const struct sockaddr *,
-                                struct nfs4_sessionid *);
+                                struct nfs4_sessionid *, u32);
 extern struct nfs_server *nfs_create_server(struct nfs_mount_info *,
                                         struct nfs_subversion *);
 extern struct nfs_server *nfs4_create_server(
@@ -255,6 +255,7 @@ extern int nfs4_decode_dirent(struct xdr_stream *,
 #ifdef CONFIG_NFS_V4_1
 extern const u32 nfs41_maxread_overhead;
 extern const u32 nfs41_maxwrite_overhead;
+extern const u32 nfs41_maxgetdevinfo_overhead;
 #endif
 
 /* nfs4proc.c */
diff --git a/fs/nfs/mount_clnt.c b/fs/nfs/mount_clnt.c
index 91a6faf811ac..99a45283b9ee 100644
--- a/fs/nfs/mount_clnt.c
+++ b/fs/nfs/mount_clnt.c
@@ -139,7 +139,10 @@ struct mnt_fhstatus {
  * nfs_mount - Obtain an NFS file handle for the given host and path
  * @info: pointer to mount request arguments
  *
- * Uses default timeout parameters specified by underlying transport.
+ * Uses default timeout parameters specified by underlying transport. On
+ * successful return, the auth_flavs list and auth_flav_len will be populated
+ * with the list from the server or a faked-up list if the server didn't
+ * provide one.
  */
 int nfs_mount(struct nfs_mount_request *info)
 {
@@ -195,6 +198,15 @@ int nfs_mount(struct nfs_mount_request *info)
         dprintk("NFS: MNT request succeeded\n");
         status = 0;
 
+        /*
+         * If the server didn't provide a flavor list, allow the
+         * client to try any flavor.
+         */
+        if (info->version != NFS_MNT3_VERSION || *info->auth_flav_len == 0) {
+                dprintk("NFS: Faking up auth_flavs list\n");
+                info->auth_flavs[0] = RPC_AUTH_NULL;
+                *info->auth_flav_len = 1;
+        }
 out:
         return status;
 
diff --git a/fs/nfs/namespace.c b/fs/nfs/namespace.c
index fc8dc20fdeb9..348b535cd786 100644
--- a/fs/nfs/namespace.c
+++ b/fs/nfs/namespace.c
@@ -280,7 +280,7 @@ struct vfsmount *nfs_submount(struct nfs_server *server, struct dentry *dentry,
         struct dentry *parent = dget_parent(dentry);
 
         /* Look it up again to get its attributes */
-        err = server->nfs_client->rpc_ops->lookup(parent->d_inode, &dentry->d_name, fh, fattr);
+        err = server->nfs_client->rpc_ops->lookup(parent->d_inode, &dentry->d_name, fh, fattr, NULL);
         dput(parent);
         if (err != 0)
                 return ERR_PTR(err);
diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c
index ce90eb4775c2..f5c84c3efbca 100644
--- a/fs/nfs/nfs3proc.c
+++ b/fs/nfs/nfs3proc.c
@@ -98,7 +98,7 @@ nfs3_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
  */
 static int
 nfs3_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
-                struct nfs_fattr *fattr)
+                struct nfs_fattr *fattr, struct nfs4_label *label)
 {
         struct rpc_message msg = {
                 .rpc_proc       = &nfs3_procedures[NFS3PROC_GETATTR],
@@ -143,7 +143,8 @@ nfs3_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
 
 static int
 nfs3_proc_lookup(struct inode *dir, struct qstr *name,
-                 struct nfs_fh *fhandle, struct nfs_fattr *fattr)
+                 struct nfs_fh *fhandle, struct nfs_fattr *fattr,
+                 struct nfs4_label *label)
 {
         struct nfs3_diropargs   arg = {
                 .fh             = NFS_FH(dir),
@@ -300,7 +301,7 @@ static int nfs3_do_create(struct inode *dir, struct dentry *dentry, struct nfs3_
         status = rpc_call_sync(NFS_CLIENT(dir), &data->msg, 0);
         nfs_post_op_update_inode(dir, data->res.dir_attr);
         if (status == 0)
-                status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
+                status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
         return status;
 }
 
diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
index a1dd768d0a35..ee81e354bce7 100644
--- a/fs/nfs/nfs4_fs.h
+++ b/fs/nfs/nfs4_fs.h
@@ -194,7 +194,7 @@ struct nfs4_state_recovery_ops {
         int (*recover_lock)(struct nfs4_state *, struct file_lock *);
         int (*establish_clid)(struct nfs_client *, struct rpc_cred *);
         struct rpc_cred * (*get_clid_cred)(struct nfs_client *);
-        int (*reclaim_complete)(struct nfs_client *);
+        int (*reclaim_complete)(struct nfs_client *, struct rpc_cred *);
         int (*detect_trunking)(struct nfs_client *, struct nfs_client **,
                 struct rpc_cred *);
 };
@@ -303,10 +303,10 @@ is_ds_client(struct nfs_client *clp)
 extern const struct nfs4_minor_version_ops *nfs_v4_minor_ops[];
 
 extern const u32 nfs4_fattr_bitmap[3];
-extern const u32 nfs4_statfs_bitmap[2];
-extern const u32 nfs4_pathconf_bitmap[2];
+extern const u32 nfs4_statfs_bitmap[3];
+extern const u32 nfs4_pathconf_bitmap[3];
 extern const u32 nfs4_fsinfo_bitmap[3];
-extern const u32 nfs4_fs_locations_bitmap[2];
+extern const u32 nfs4_fs_locations_bitmap[3];
 
 void nfs4_free_client(struct nfs_client *);
 
diff --git a/fs/nfs/nfs4client.c b/fs/nfs/nfs4client.c
index 4cbad5d6b276..90dce91dd5b5 100644
--- a/fs/nfs/nfs4client.c
+++ b/fs/nfs/nfs4client.c
@@ -66,6 +66,11 @@ struct nfs_client *nfs4_alloc_client(const struct nfs_client_initdata *cl_init)
         if (err)
                 goto error;
 
+        if (cl_init->minorversion > NFS4_MAX_MINOR_VERSION) {
+                err = -EINVAL;
+                goto error;
+        }
+
         spin_lock_init(&clp->cl_lock);
         INIT_DELAYED_WORK(&clp->cl_renewd, nfs4_renew_state);
         rpc_init_wait_queue(&clp->cl_rpcwaitq, "NFS client");
@@ -562,14 +567,14 @@ static bool nfs4_cb_match_client(const struct sockaddr *addr,
  */
 struct nfs_client *
 nfs4_find_client_sessionid(struct net *net, const struct sockaddr *addr,
-                           struct nfs4_sessionid *sid)
+                           struct nfs4_sessionid *sid, u32 minorversion)
 {
         struct nfs_client *clp;
         struct nfs_net *nn = net_generic(net, nfs_net_id);
 
         spin_lock(&nn->nfs_client_lock);
         list_for_each_entry(clp, &nn->nfs_client_list, cl_share_link) {
-                if (nfs4_cb_match_client(addr, clp, 1) == false)
+                if (nfs4_cb_match_client(addr, clp, minorversion) == false)
                         continue;
 
                 if (!nfs4_has_session(clp))
@@ -592,7 +597,7 @@ nfs4_find_client_sessionid(struct net *net, const struct sockaddr *addr,
 
 struct nfs_client *
 nfs4_find_client_sessionid(struct net *net, const struct sockaddr *addr,
-                           struct nfs4_sessionid *sid)
+                           struct nfs4_sessionid *sid, u32 minorversion)
 {
         return NULL;
 }
@@ -626,6 +631,8 @@ static int nfs4_set_client(struct nfs_server *server,
 
         if (server->flags & NFS_MOUNT_NORESVPORT)
                 set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags);
+        if (server->options & NFS_OPTION_MIGRATION)
+                set_bit(NFS_CS_MIGRATION, &cl_init.init_flags);
 
         /* Allocate or find a client reference we can use */
         clp = nfs_get_client(&cl_init, timeparms, ip_addr, authflavour);
@@ -730,7 +737,7 @@ static int nfs4_server_common_setup(struct nfs_server *server,
                 return -ENOMEM;
 
         /* We must ensure the session is initialised first */
-        error = nfs4_init_session(server);
+        error = nfs4_init_session(server->nfs_client);
         if (error < 0)
                 goto out;
 
diff --git a/fs/nfs/nfs4file.c b/fs/nfs/nfs4file.c
index 13e6bb3e3fe5..e5b804dd944c 100644
--- a/fs/nfs/nfs4file.c
+++ b/fs/nfs/nfs4file.c
@@ -69,7 +69,6 @@ nfs4_file_open(struct inode *inode, struct file *filp)
                         goto out_drop;
                 }
         }
-        iput(inode);
         if (inode != dentry->d_inode)
                 goto out_drop;
 
diff --git a/fs/nfs/nfs4filelayout.c b/fs/nfs/nfs4filelayout.c
index 22d10623f5ee..17ed87ef9de8 100644
--- a/fs/nfs/nfs4filelayout.c
+++ b/fs/nfs/nfs4filelayout.c
@@ -643,7 +643,8 @@ filelayout_check_layout(struct pnfs_layout_hdr *lo,
         d = nfs4_find_get_deviceid(NFS_SERVER(lo->plh_inode)->pnfs_curr_ld,
                                    NFS_SERVER(lo->plh_inode)->nfs_client, id);
         if (d == NULL) {
-                dsaddr = filelayout_get_device_info(lo->plh_inode, id, gfp_flags);
+                dsaddr = filelayout_get_device_info(lo->plh_inode, id,
+                                lo->plh_lc_cred, gfp_flags);
                 if (dsaddr == NULL)
                         goto out;
         } else
diff --git a/fs/nfs/nfs4filelayout.h b/fs/nfs/nfs4filelayout.h
index 235ff952d3c8..cebd20e7e923 100644
--- a/fs/nfs/nfs4filelayout.h
+++ b/fs/nfs/nfs4filelayout.h
@@ -150,6 +150,7 @@ struct nfs4_pnfs_ds *nfs4_fl_prepare_ds(struct pnfs_layout_segment *lseg,
 extern void nfs4_fl_put_deviceid(struct nfs4_file_layout_dsaddr *dsaddr);
 extern void nfs4_fl_free_deviceid(struct nfs4_file_layout_dsaddr *dsaddr);
 struct nfs4_file_layout_dsaddr *
-filelayout_get_device_info(struct inode *inode, struct nfs4_deviceid *dev_id, gfp_t gfp_flags);
+filelayout_get_device_info(struct inode *inode, struct nfs4_deviceid *dev_id,
+                struct rpc_cred *cred, gfp_t gfp_flags);
 
 #endif /* FS_NFS_NFS4FILELAYOUT_H */
diff --git a/fs/nfs/nfs4filelayoutdev.c b/fs/nfs/nfs4filelayoutdev.c
index 661a0f611215..95604f64cab8 100644
--- a/fs/nfs/nfs4filelayoutdev.c
+++ b/fs/nfs/nfs4filelayoutdev.c
@@ -668,7 +668,10 @@ decode_and_add_device(struct inode *inode, struct pnfs_device *dev, gfp_t gfp_fl
  * of available devices, and return it.
  */
 struct nfs4_file_layout_dsaddr *
-filelayout_get_device_info(struct inode *inode, struct nfs4_deviceid *dev_id, gfp_t gfp_flags)
+filelayout_get_device_info(struct inode *inode,
+                struct nfs4_deviceid *dev_id,
+                struct rpc_cred *cred,
+                gfp_t gfp_flags)
 {
         struct pnfs_device *pdev = NULL;
         u32 max_resp_sz;
@@ -708,8 +711,9 @@ filelayout_get_device_info(struct inode *inode, struct nfs4_deviceid *dev_id, gf
         pdev->pgbase = 0;
         pdev->pglen = max_resp_sz;
         pdev->mincount = 0;
+        pdev->maxcount = max_resp_sz - nfs41_maxgetdevinfo_overhead;
 
-        rc = nfs4_proc_getdeviceinfo(server, pdev);
+        rc = nfs4_proc_getdeviceinfo(server, pdev, cred);
         dprintk("%s getdevice info returns %d\n", __func__, rc);
         if (rc)
                 goto out_free;
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 28241a42f363..cf11799297c4 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -77,15 +77,68 @@ static int _nfs4_recover_proc_open(struct nfs4_opendata *data);
 static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *);
 static int nfs4_async_handle_error(struct rpc_task *, const struct nfs_server *, struct nfs4_state *);
 static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr);
-static int nfs4_proc_getattr(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *);
-static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr);
+static int nfs4_proc_getattr(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *, struct nfs4_label *label);
+static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr, struct nfs4_label *label);
 static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
                             struct nfs_fattr *fattr, struct iattr *sattr,
-                            struct nfs4_state *state);
+                            struct nfs4_state *state, struct nfs4_label *ilabel,
+                            struct nfs4_label *olabel);
 #ifdef CONFIG_NFS_V4_1
-static int nfs41_test_stateid(struct nfs_server *, nfs4_stateid *);
-static int nfs41_free_stateid(struct nfs_server *, nfs4_stateid *);
+static int nfs41_test_stateid(struct nfs_server *, nfs4_stateid *,
+                struct rpc_cred *);
+static int nfs41_free_stateid(struct nfs_server *, nfs4_stateid *,
+                struct rpc_cred *);
 #endif
+
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+static inline struct nfs4_label *
+nfs4_label_init_security(struct inode *dir, struct dentry *dentry,
+        struct iattr *sattr, struct nfs4_label *label)
+{
+        int err;
+
+        if (label == NULL)
+                return NULL;
+
+        if (nfs_server_capable(dir, NFS_CAP_SECURITY_LABEL) == 0)
+                return NULL;
+
+        if (NFS_SERVER(dir)->nfs_client->cl_minorversion < 2)
+                return NULL;
+
+        err = security_dentry_init_security(dentry, sattr->ia_mode,
+                                &dentry->d_name, (void **)&label->label, &label->len);
+        if (err == 0)
+                return label;
+
+        return NULL;
+}
+static inline void
+nfs4_label_release_security(struct nfs4_label *label)
+{
+        if (label)
+                security_release_secctx(label->label, label->len);
+}
+static inline u32 *nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label)
+{
+        if (label)
+                return server->attr_bitmask;
+
+        return server->attr_bitmask_nl;
+}
+#else
+static inline struct nfs4_label *
+nfs4_label_init_security(struct inode *dir, struct dentry *dentry,
+        struct iattr *sattr, struct nfs4_label *l)
+{ return NULL; }
+static inline void
+nfs4_label_release_security(struct nfs4_label *label)
+{ return; }
+static inline u32 *
+nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label)
+{ return server->attr_bitmask; }
+#endif
+
 /* Prevent leaks of NFSv4 errors into userland */
 static int nfs4_map_errors(int err)
 {
@@ -134,7 +187,10 @@ const u32 nfs4_fattr_bitmap[3] = {
         | FATTR4_WORD1_SPACE_USED
         | FATTR4_WORD1_TIME_ACCESS
         | FATTR4_WORD1_TIME_METADATA
-        | FATTR4_WORD1_TIME_MODIFY
+        | FATTR4_WORD1_TIME_MODIFY,
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+        FATTR4_WORD2_SECURITY_LABEL
+#endif
 };
 
 static const u32 nfs4_pnfs_open_bitmap[3] = {
@@ -161,7 +217,7 @@ static const u32 nfs4_open_noattr_bitmap[3] = {
         | FATTR4_WORD0_FILEID,
 };
 
-const u32 nfs4_statfs_bitmap[2] = {
+const u32 nfs4_statfs_bitmap[3] = {
         FATTR4_WORD0_FILES_AVAIL
         | FATTR4_WORD0_FILES_FREE
         | FATTR4_WORD0_FILES_TOTAL,
@@ -170,7 +226,7 @@ const u32 nfs4_statfs_bitmap[2] = {
         | FATTR4_WORD1_SPACE_TOTAL
 };
 
-const u32 nfs4_pathconf_bitmap[2] = {
+const u32 nfs4_pathconf_bitmap[3] = {
         FATTR4_WORD0_MAXLINK
         | FATTR4_WORD0_MAXNAME,
         0
@@ -185,7 +241,7 @@ const u32 nfs4_fsinfo_bitmap[3] = { FATTR4_WORD0_MAXFILESIZE
                         FATTR4_WORD2_LAYOUT_BLKSIZE
 };
 
-const u32 nfs4_fs_locations_bitmap[2] = {
+const u32 nfs4_fs_locations_bitmap[3] = {
         FATTR4_WORD0_TYPE
         | FATTR4_WORD0_CHANGE
         | FATTR4_WORD0_SIZE
@@ -201,7 +257,7 @@ const u32 nfs4_fs_locations_bitmap[2] = {
         | FATTR4_WORD1_TIME_ACCESS
         | FATTR4_WORD1_TIME_METADATA
         | FATTR4_WORD1_TIME_MODIFY
-        | FATTR4_WORD1_MOUNTED_ON_FILEID
+        | FATTR4_WORD1_MOUNTED_ON_FILEID,
 };
 
 static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dentry,
@@ -762,6 +818,7 @@ struct nfs4_opendata {
         struct nfs4_string owner_name;
         struct nfs4_string group_name;
         struct nfs_fattr f_attr;
+        struct nfs4_label *f_label;
         struct dentry *dir;
         struct dentry *dentry;
         struct nfs4_state_owner *owner;
@@ -807,6 +864,7 @@ nfs4_map_atomic_open_claim(struct nfs_server *server,
 static void nfs4_init_opendata_res(struct nfs4_opendata *p)
 {
         p->o_res.f_attr = &p->f_attr;
+        p->o_res.f_label = p->f_label;
         p->o_res.seqid = p->o_arg.seqid;
         p->c_res.seqid = p->c_arg.seqid;
         p->o_res.server = p->o_arg.server;
@@ -818,6 +876,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata *p)
 static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
                 struct nfs4_state_owner *sp, fmode_t fmode, int flags,
                 const struct iattr *attrs,
+                struct nfs4_label *label,
                 enum open_claim_type4 claim,
                 gfp_t gfp_mask)
 {
@@ -829,9 +888,14 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
         p = kzalloc(sizeof(*p), gfp_mask);
         if (p == NULL)
                 goto err;
+
+        p->f_label = nfs4_label_alloc(server, gfp_mask);
+        if (IS_ERR(p->f_label))
+                goto err_free_p;
+
         p->o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid, gfp_mask);
         if (p->o_arg.seqid == NULL)
-                goto err_free;
+                goto err_free_label;
         nfs_sb_active(dentry->d_sb);
         p->dentry = dget(dentry);
         p->dir = parent;
@@ -852,8 +916,9 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
         p->o_arg.id.uniquifier = sp->so_seqid.owner_id;
         p->o_arg.name = &dentry->d_name;
         p->o_arg.server = server;
-        p->o_arg.bitmask = server->attr_bitmask;
+        p->o_arg.bitmask = nfs4_bitmask(server, label);
         p->o_arg.open_bitmap = &nfs4_fattr_bitmap[0];
+        p->o_arg.label = label;
         p->o_arg.claim = nfs4_map_atomic_open_claim(server, claim);
         switch (p->o_arg.claim) {
         case NFS4_OPEN_CLAIM_NULL:
@@ -884,7 +949,10 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
         nfs4_init_opendata_res(p);
         kref_init(&p->kref);
         return p;
-err_free:
+
+err_free_label:
+        nfs4_label_free(p->f_label);
+err_free_p:
         kfree(p);
 err:
         dput(parent);
@@ -901,6 +969,9 @@ static void nfs4_opendata_free(struct kref *kref)
         if (p->state != NULL)
                 nfs4_put_open_state(p->state);
         nfs4_put_state_owner(p->owner);
+
+        nfs4_label_free(p->f_label);
+
         dput(p->dir);
         dput(p->dentry);
         nfs_sb_deactive(sb);
@@ -1179,6 +1250,8 @@ _nfs4_opendata_reclaim_to_nfs4_state(struct nfs4_opendata *data)
         if (ret)
                 goto err;
 
+        nfs_setsecurity(inode, &data->f_attr, data->f_label);
+
         if (data->o_res.delegation_type != 0)
                 nfs4_opendata_check_deleg(data, state);
         update_open_stateid(state, &data->o_res.stateid, NULL,
@@ -1205,7 +1278,7 @@ _nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
         ret = -EAGAIN;
         if (!(data->f_attr.valid & NFS_ATTR_FATTR))
                 goto err;
-        inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr);
+        inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr, data->f_label);
         ret = PTR_ERR(inode);
         if (IS_ERR(inode))
                 goto err;
@@ -1258,7 +1331,7 @@ static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context
         struct nfs4_opendata *opendata;
 
         opendata = nfs4_opendata_alloc(ctx->dentry, state->owner, 0, 0,
-                        NULL, claim, GFP_NOFS);
+                        NULL, NULL, claim, GFP_NOFS);
         if (opendata == NULL)
                 return ERR_PTR(-ENOMEM);
         opendata->state = state;
@@ -1784,7 +1857,7 @@ static int _nfs4_proc_open(struct nfs4_opendata *data)
                         return status;
         }
         if (!(o_res->f_attr->valid & NFS_ATTR_FATTR))
-                _nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr);
+                _nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr, o_res->f_label);
         return 0;
 }
 
@@ -1855,18 +1928,30 @@ static void nfs41_clear_delegation_stateid(struct nfs4_state *state)
 {
         struct nfs_server *server = NFS_SERVER(state->inode);
         nfs4_stateid *stateid = &state->stateid;
-        int status;
+        struct nfs_delegation *delegation;
+        struct rpc_cred *cred = NULL;
+        int status = -NFS4ERR_BAD_STATEID;
 
         /* If a state reset has been done, test_stateid is unneeded */
         if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
                 return;
 
-        status = nfs41_test_stateid(server, stateid);
+        /* Get the delegation credential for use by test/free_stateid */
+        rcu_read_lock();
+        delegation = rcu_dereference(NFS_I(state->inode)->delegation);
+        if (delegation != NULL &&
+            nfs4_stateid_match(&delegation->stateid, stateid)) {
+                cred = get_rpccred(delegation->cred);
+                rcu_read_unlock();
+                status = nfs41_test_stateid(server, stateid, cred);
+        } else
+                rcu_read_unlock();
+
         if (status != NFS_OK) {
                 /* Free the stateid unless the server explicitly
                  * informs us the stateid is unrecognized. */
                 if (status != -NFS4ERR_BAD_STATEID)
-                        nfs41_free_stateid(server, stateid);
+                        nfs41_free_stateid(server, stateid, cred);
                 nfs_remove_bad_delegation(state->inode);
 
                 write_seqlock(&state->seqlock);
@@ -1874,6 +1959,9 @@ static void nfs41_clear_delegation_stateid(struct nfs4_state *state)
                 write_sequnlock(&state->seqlock);
                 clear_bit(NFS_DELEGATED_STATE, &state->flags);
         }
+
+        if (cred != NULL)
+                put_rpccred(cred);
 }
 
 /**
@@ -1888,6 +1976,7 @@ static int nfs41_check_open_stateid(struct nfs4_state *state)
 {
         struct nfs_server *server = NFS_SERVER(state->inode);
         nfs4_stateid *stateid = &state->open_stateid;
+        struct rpc_cred *cred = state->owner->so_cred;
         int status;
 
         /* If a state reset has been done, test_stateid is unneeded */
@@ -1896,12 +1985,12 @@ static int nfs41_check_open_stateid(struct nfs4_state *state)
             (test_bit(NFS_O_RDWR_STATE, &state->flags) == 0))
                 return -NFS4ERR_BAD_STATEID;
 
-        status = nfs41_test_stateid(server, stateid);
+        status = nfs41_test_stateid(server, stateid, cred);
         if (status != NFS_OK) {
                 /* Free the stateid unless the server explicitly
                  * informs us the stateid is unrecognized. */
                 if (status != -NFS4ERR_BAD_STATEID)
-                        nfs41_free_stateid(server, stateid);
+                        nfs41_free_stateid(server, stateid, cred);
 
                 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
                 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
@@ -1942,10 +2031,11 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata, struct
 static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata,
                 fmode_t fmode,
                 int flags,
-                struct nfs4_state **res)
+                struct nfs_open_context *ctx)
 {
         struct nfs4_state_owner *sp = opendata->owner;
         struct nfs_server *server = sp->so_server;
+        struct dentry *dentry;
         struct nfs4_state *state;
         unsigned int seq;
         int ret;
@@ -1963,13 +2053,31 @@ static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata,
         if (server->caps & NFS_CAP_POSIX_LOCK)
                 set_bit(NFS_STATE_POSIX_LOCKS, &state->flags);
 
+        dentry = opendata->dentry;
+        if (dentry->d_inode == NULL) {
+                /* FIXME: Is this d_drop() ever needed? */
+                d_drop(dentry);
+                dentry = d_add_unique(dentry, igrab(state->inode));
+                if (dentry == NULL) {
+                        dentry = opendata->dentry;
+                } else if (dentry != ctx->dentry) {
+                        dput(ctx->dentry);
+                        ctx->dentry = dget(dentry);
+                }
+                nfs_set_verifier(dentry,
+                                nfs_save_change_attribute(opendata->dir->d_inode));
+        }
+
         ret = nfs4_opendata_access(sp->so_cred, opendata, state, fmode, flags);
         if (ret != 0)
                 goto out;
 
-        if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
-                nfs4_schedule_stateid_recovery(server, state);
-        *res = state;
+        ctx->state = state;
+        if (dentry->d_inode == state->inode) {
+                nfs_inode_attach_open_context(ctx);
+                if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
+                        nfs4_schedule_stateid_recovery(server, state);
+        }
 out:
         return ret;
 }
@@ -1978,19 +2086,21 @@ out:
  * Returns a referenced nfs4_state
  */
 static int _nfs4_do_open(struct inode *dir,
-                        struct dentry *dentry,
-                        fmode_t fmode,
+                        struct nfs_open_context *ctx,
                         int flags,
                         struct iattr *sattr,
-                        struct rpc_cred *cred,
-                        struct nfs4_state **res,
-                        struct nfs4_threshold **ctx_th)
+                        struct nfs4_label *label)
 {
         struct nfs4_state_owner  *sp;
         struct nfs4_state     *state = NULL;
         struct nfs_server       *server = NFS_SERVER(dir);
         struct nfs4_opendata *opendata;
+        struct dentry *dentry = ctx->dentry;
+        struct rpc_cred *cred = ctx->cred;
+        struct nfs4_threshold **ctx_th = &ctx->mdsthreshold;
+        fmode_t fmode = ctx->mode & (FMODE_READ|FMODE_WRITE|FMODE_EXEC);
         enum open_claim_type4 claim = NFS4_OPEN_CLAIM_NULL;
+        struct nfs4_label *olabel = NULL;
         int status;
 
         /* Protect against reboot recovery conflicts */
@@ -2009,22 +2119,31 @@ static int _nfs4_do_open(struct inode *dir,
         if (dentry->d_inode)
                 claim = NFS4_OPEN_CLAIM_FH;
         opendata = nfs4_opendata_alloc(dentry, sp, fmode, flags, sattr,
-                        claim, GFP_KERNEL);
+                        label, claim, GFP_KERNEL);
         if (opendata == NULL)
                 goto err_put_state_owner;
 
+        if (label) {
+                olabel = nfs4_label_alloc(server, GFP_KERNEL);
+                if (IS_ERR(olabel)) {
+                        status = PTR_ERR(olabel);
+                        goto err_opendata_put;
+                }
+        }
+
         if (ctx_th && server->attr_bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD) {
                 opendata->f_attr.mdsthreshold = pnfs_mdsthreshold_alloc();
                 if (!opendata->f_attr.mdsthreshold)
-                        goto err_opendata_put;
+                        goto err_free_label;
                 opendata->o_arg.open_bitmap = &nfs4_pnfs_open_bitmap[0];
         }
         if (dentry->d_inode != NULL)
                 opendata->state = nfs4_get_open_state(dentry->d_inode, sp);
 
-        status = _nfs4_open_and_get_state(opendata, fmode, flags, &state);
+        status = _nfs4_open_and_get_state(opendata, fmode, flags, ctx);
         if (status != 0)
-                goto err_opendata_put;
+                goto err_free_label;
+        state = ctx->state;
 
         if ((opendata->o_arg.open_flags & O_EXCL) &&
             (opendata->o_arg.createmode != NFS4_CREATE_GUARDED)) {
@@ -2033,10 +2152,12 @@ static int _nfs4_do_open(struct inode *dir,
                 nfs_fattr_init(opendata->o_res.f_attr);
                 status = nfs4_do_setattr(state->inode, cred,
                                 opendata->o_res.f_attr, sattr,
-                                state);
-                if (status == 0)
+                                state, label, olabel);
+                if (status == 0) {
                         nfs_setattr_update_inode(state->inode, sattr);
-                nfs_post_op_update_inode(state->inode, opendata->o_res.f_attr);
+                        nfs_post_op_update_inode(state->inode, opendata->o_res.f_attr);
+                        nfs_setsecurity(state->inode, opendata->o_res.f_attr, olabel);
+                }
         }
 
         if (pnfs_use_threshold(ctx_th, opendata->f_attr.mdsthreshold, server))
@@ -2045,38 +2166,37 @@ static int _nfs4_do_open(struct inode *dir,
                 kfree(opendata->f_attr.mdsthreshold);
         opendata->f_attr.mdsthreshold = NULL;
 
+        nfs4_label_free(olabel);
+
         nfs4_opendata_put(opendata);
         nfs4_put_state_owner(sp);
-        *res = state;
         return 0;
+err_free_label:
+        nfs4_label_free(olabel);
 err_opendata_put:
         kfree(opendata->f_attr.mdsthreshold);
         nfs4_opendata_put(opendata);
 err_put_state_owner:
         nfs4_put_state_owner(sp);
 out_err:
-        *res = NULL;
         return status;
 }
 
 
 static struct nfs4_state *nfs4_do_open(struct inode *dir,
-                                        struct dentry *dentry,
-                                        fmode_t fmode,
+                                        struct nfs_open_context *ctx,
                                         int flags,
                                         struct iattr *sattr,
-                                        struct rpc_cred *cred,
-                                        struct nfs4_threshold **ctx_th)
+                                        struct nfs4_label *label)
 {
         struct nfs_server *server = NFS_SERVER(dir);
         struct nfs4_exception exception = { };
         struct nfs4_state *res;
         int status;
 
-        fmode &= FMODE_READ|FMODE_WRITE|FMODE_EXEC;
         do {
-                status = _nfs4_do_open(dir, dentry, fmode, flags, sattr, cred,
-                                       &res, ctx_th);
+                status = _nfs4_do_open(dir, ctx, flags, sattr, label);
+                res = ctx->state;
                 if (status == 0)
                         break;
                 /* NOTE: BAD_SEQID means the server and client disagree about the
@@ -2122,7 +2242,8 @@ static struct nfs4_state *nfs4_do_open(struct inode *dir,
 
 static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
                             struct nfs_fattr *fattr, struct iattr *sattr,
-                            struct nfs4_state *state)
+                            struct nfs4_state *state, struct nfs4_label *ilabel,
+                            struct nfs4_label *olabel)
 {
         struct nfs_server *server = NFS_SERVER(inode);
         struct nfs_setattrargs  arg = {
@@ -2130,9 +2251,11 @@ static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
                 .iap            = sattr,
                 .server         = server,
                 .bitmask = server->attr_bitmask,
+                .label          = ilabel,
         };
         struct nfs_setattrres  res = {
                 .fattr          = fattr,
+                .label          = olabel,
                 .server         = server,
         };
         struct rpc_message msg = {
@@ -2146,6 +2269,10 @@ static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
         bool truncate;
         int status;
 
+        arg.bitmask = nfs4_bitmask(server, ilabel);
+        if (ilabel)
+                arg.bitmask = nfs4_bitmask(server, olabel);
+
         nfs_fattr_init(fattr);
 
         /* Servers should only apply open mode checks for file size changes */
@@ -2172,7 +2299,8 @@ static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
 
 static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
                            struct nfs_fattr *fattr, struct iattr *sattr,
-                           struct nfs4_state *state)
+                           struct nfs4_state *state, struct nfs4_label *ilabel,
+                           struct nfs4_label *olabel)
 {
         struct nfs_server *server = NFS_SERVER(inode);
         struct nfs4_exception exception = {
@@ -2181,7 +2309,7 @@ static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
         };
         int err;
         do {
-                err = _nfs4_do_setattr(inode, cred, fattr, sattr, state);
+                err = _nfs4_do_setattr(inode, cred, fattr, sattr, state, ilabel, olabel);
                 switch (err) {
                 case -NFS4ERR_OPENMODE:
                         if (!(sattr->ia_valid & ATTR_SIZE)) {
@@ -2426,14 +2554,18 @@ static struct inode *
 nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx, int open_flags, struct iattr *attr)
 {
         struct nfs4_state *state;
+        struct nfs4_label l = {0, 0, 0, NULL}, *label = NULL;
+
+        label = nfs4_label_init_security(dir, ctx->dentry, attr, &l);
 
         /* Protect against concurrent sillydeletes */
-        state = nfs4_do_open(dir, ctx->dentry, ctx->mode, open_flags, attr,
-                             ctx->cred, &ctx->mdsthreshold);
+        state = nfs4_do_open(dir, ctx, open_flags, attr, label);
+
+        nfs4_label_release_security(label);
+
         if (IS_ERR(state))
                 return ERR_CAST(state);
-        ctx->state = state;
-        return igrab(state->inode);
+        return state->inode;
 }
 
 static void nfs4_close_context(struct nfs_open_context *ctx, int is_sync)
@@ -2489,7 +2621,17 @@ static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *f
                         server->caps |= NFS_CAP_CTIME;
                 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY)
                         server->caps |= NFS_CAP_MTIME;
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+                if (res.attr_bitmask[2] & FATTR4_WORD2_SECURITY_LABEL)
+                        server->caps |= NFS_CAP_SECURITY_LABEL;
+#endif
+                memcpy(server->attr_bitmask_nl, res.attr_bitmask,
+                                sizeof(server->attr_bitmask));
 
+                if (server->caps & NFS_CAP_SECURITY_LABEL) {
+                        server->attr_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
+                        res.attr_bitmask[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
+                }
                 memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask));
                 server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE;
                 server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY;
@@ -2515,8 +2657,9 @@ int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
 static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
                 struct nfs_fsinfo *info)
 {
+        u32 bitmask[3];
         struct nfs4_lookup_root_arg args = {
-                .bitmask = nfs4_fattr_bitmap,
+                .bitmask = bitmask,
         };
         struct nfs4_lookup_res res = {
                 .server = server,
@@ -2529,6 +2672,13 @@ static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
                 .rpc_resp = &res,
         };
 
+        bitmask[0] = nfs4_fattr_bitmap[0];
+        bitmask[1] = nfs4_fattr_bitmap[1];
+        /*
+         * Process the label in the upcoming getfattr
+         */
+        bitmask[2] = nfs4_fattr_bitmap[2] & ~FATTR4_WORD2_SECURITY_LABEL;
+
         nfs_fattr_init(info->fattr);
         return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
 }
@@ -2648,6 +2798,7 @@ static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh,
 {
         int error;
         struct nfs_fattr *fattr = info->fattr;
+        struct nfs4_label *label = NULL;
 
         error = nfs4_server_capabilities(server, mntfh);
         if (error < 0) {
@@ -2655,16 +2806,23 @@ static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh,
                 return error;
         }
 
-        error = nfs4_proc_getattr(server, mntfh, fattr);
+        label = nfs4_label_alloc(server, GFP_KERNEL);
+        if (IS_ERR(label))
+                return PTR_ERR(label);
+
+        error = nfs4_proc_getattr(server, mntfh, fattr, label);
         if (error < 0) {
                 dprintk("nfs4_get_root: getattr error = %d\n", -error);
-                return error;
+                goto err_free_label;
         }
 
         if (fattr->valid & NFS_ATTR_FATTR_FSID &&
             !nfs_fsid_equal(&server->fsid, &fattr->fsid))
                 memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));
 
+err_free_label:
+        nfs4_label_free(label);
+
         return error;
 }
 
@@ -2711,7 +2869,8 @@ out:
         return status;
 }
 
-static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
+static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
+                                struct nfs_fattr *fattr, struct nfs4_label *label)
 {
         struct nfs4_getattr_arg args = {
                 .fh = fhandle,
@@ -2719,6 +2878,7 @@ static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
         };
         struct nfs4_getattr_res res = {
                 .fattr = fattr,
+                .label = label,
                 .server = server,
         };
         struct rpc_message msg = {
@@ -2726,18 +2886,21 @@ static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
                 .rpc_argp = &args,
                 .rpc_resp = &res,
         };
-        
+
+        args.bitmask = nfs4_bitmask(server, label);
+
         nfs_fattr_init(fattr);
         return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
 }
 
-static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
+static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
+                                struct nfs_fattr *fattr, struct nfs4_label *label)
 {
         struct nfs4_exception exception = { };
         int err;
         do {
                 err = nfs4_handle_exception(server,
-                                _nfs4_proc_getattr(server, fhandle, fattr),
+                                _nfs4_proc_getattr(server, fhandle, fattr, label),
                                 &exception);
         } while (exception.retry);
         return err;
@@ -2767,6 +2930,7 @@ nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
         struct inode *inode = dentry->d_inode;
         struct rpc_cred *cred = NULL;
         struct nfs4_state *state = NULL;
+        struct nfs4_label *label = NULL;
         int status;
 
         if (pnfs_ld_layoutret_on_setattr(inode))
@@ -2793,15 +2957,22 @@ nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
                 }
         }
 
-        status = nfs4_do_setattr(inode, cred, fattr, sattr, state);
-        if (status == 0)
+        label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
+        if (IS_ERR(label))
+                return PTR_ERR(label);
+
+        status = nfs4_do_setattr(inode, cred, fattr, sattr, state, NULL, label);
+        if (status == 0) {
                 nfs_setattr_update_inode(inode, sattr);
+                nfs_setsecurity(inode, fattr, label);
+        }
+        nfs4_label_free(label);
         return status;
 }
 
 static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,
                 const struct qstr *name, struct nfs_fh *fhandle,
-                struct nfs_fattr *fattr)
+                struct nfs_fattr *fattr, struct nfs4_label *label)
 {
         struct nfs_server *server = NFS_SERVER(dir);
         int                    status;
@@ -2813,6 +2984,7 @@ static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,
         struct nfs4_lookup_res res = {
                 .server = server,
                 .fattr = fattr,
+                .label = label,
                 .fh = fhandle,
         };
         struct rpc_message msg = {
@@ -2821,6 +2993,8 @@ static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,
                 .rpc_resp = &res,
         };
 
+        args.bitmask = nfs4_bitmask(server, label);
+
         nfs_fattr_init(fattr);
 
         dprintk("NFS call  lookup %s\n", name->name);
@@ -2839,13 +3013,13 @@ static void nfs_fixup_secinfo_attributes(struct nfs_fattr *fattr)
 
 static int nfs4_proc_lookup_common(struct rpc_clnt **clnt, struct inode *dir,
                                    struct qstr *name, struct nfs_fh *fhandle,
-                                   struct nfs_fattr *fattr)
+                                   struct nfs_fattr *fattr, struct nfs4_label *label)
 {
         struct nfs4_exception exception = { };
         struct rpc_clnt *client = *clnt;
         int err;
         do {
-                err = _nfs4_proc_lookup(client, dir, name, fhandle, fattr);
+                err = _nfs4_proc_lookup(client, dir, name, fhandle, fattr, label);
                 switch (err) {
                 case -NFS4ERR_BADNAME:
                         err = -ENOENT;
@@ -2879,12 +3053,13 @@ out:
 }
 
 static int nfs4_proc_lookup(struct inode *dir, struct qstr *name,
-                            struct nfs_fh *fhandle, struct nfs_fattr *fattr)
+                            struct nfs_fh *fhandle, struct nfs_fattr *fattr,
+                            struct nfs4_label *label)
 {
         int status;
         struct rpc_clnt *client = NFS_CLIENT(dir);
 
-        status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr);
+        status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr, label);
         if (client != NFS_CLIENT(dir)) {
                 rpc_shutdown_client(client);
                 nfs_fixup_secinfo_attributes(fattr);
@@ -2899,7 +3074,7 @@ nfs4_proc_lookup_mountpoint(struct inode *dir, struct qstr *name,
         int status;
         struct rpc_clnt *client = rpc_clone_client(NFS_CLIENT(dir));
 
-        status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr);
+        status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr, NULL);
         if (status < 0) {
                 rpc_shutdown_client(client);
                 return ERR_PTR(status);
@@ -2924,7 +3099,7 @@ static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry
                 .rpc_cred = entry->cred,
         };
         int mode = entry->mask;
-        int status;
+        int status = 0;
 
         /*
          * Determine which access bits we want to ask for...
@@ -3029,6 +3204,7 @@ static int
 nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
                  int flags)
 {
+        struct nfs4_label l, *ilabel = NULL;
         struct nfs_open_context *ctx;
         struct nfs4_state *state;
         int status = 0;
@@ -3037,19 +3213,16 @@ nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
         if (IS_ERR(ctx))
                 return PTR_ERR(ctx);
 
+        ilabel = nfs4_label_init_security(dir, dentry, sattr, &l);
+
         sattr->ia_mode &= ~current_umask();
-        state = nfs4_do_open(dir, dentry, ctx->mode,
-                        flags, sattr, ctx->cred,
-                        &ctx->mdsthreshold);
-        d_drop(dentry);
+        state = nfs4_do_open(dir, ctx, flags, sattr, ilabel);
         if (IS_ERR(state)) {
                 status = PTR_ERR(state);
                 goto out;
         }
-        d_add(dentry, igrab(state->inode));
-        nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
-        ctx->state = state;
 out:
+        nfs4_label_release_security(ilabel);
         put_nfs_open_context(ctx);
         return status;
 }
@@ -3098,6 +3271,8 @@ static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
         res->server = server;
         msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE];
         nfs41_init_sequence(&args->seq_args, &res->seq_res, 1);
+
+        nfs_fattr_init(res->dir_attr);
 }
 
 static void nfs4_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
@@ -3173,7 +3348,7 @@ static int _nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
                 .rpc_resp = &res,
         };
         int status = -ENOMEM;
-        
+
         status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
         if (!status) {
                 update_changeattr(old_dir, &res.old_cinfo);
@@ -3207,6 +3382,7 @@ static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *
         };
         struct nfs4_link_res res = {
                 .server = server,
+                .label = NULL,
         };
         struct rpc_message msg = {
                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK],
@@ -3219,11 +3395,24 @@ static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *
         if (res.fattr == NULL)
                 goto out;
 
+        res.label = nfs4_label_alloc(server, GFP_KERNEL);
+        if (IS_ERR(res.label)) {
+                status = PTR_ERR(res.label);
+                goto out;
+        }
+        arg.bitmask = nfs4_bitmask(server, res.label);
+
         status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
         if (!status) {
                 update_changeattr(dir, &res.cinfo);
-                nfs_post_op_update_inode(inode, res.fattr);
+                status = nfs_post_op_update_inode(inode, res.fattr);
+                if (!status)
+                        nfs_setsecurity(inode, res.fattr, res.label);
         }
+
+
+        nfs4_label_free(res.label);
+
 out:
         nfs_free_fattr(res.fattr);
         return status;
@@ -3247,6 +3436,7 @@ struct nfs4_createdata {
         struct nfs4_create_res res;
         struct nfs_fh fh;
         struct nfs_fattr fattr;
+        struct nfs4_label *label;
 };
 
 static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,
@@ -3258,6 +3448,10 @@ static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,
         if (data != NULL) {
                 struct nfs_server *server = NFS_SERVER(dir);
 
+                data->label = nfs4_label_alloc(server, GFP_KERNEL);
+                if (IS_ERR(data->label))
+                        goto out_free;
+
                 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE];
                 data->msg.rpc_argp = &data->arg;
                 data->msg.rpc_resp = &data->res;
@@ -3266,13 +3460,17 @@ static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,
                 data->arg.name = name;
                 data->arg.attrs = sattr;
                 data->arg.ftype = ftype;
-                data->arg.bitmask = server->attr_bitmask;
+                data->arg.bitmask = nfs4_bitmask(server, data->label);
                 data->res.server = server;
                 data->res.fh = &data->fh;
                 data->res.fattr = &data->fattr;
+                data->res.label = data->label;
                 nfs_fattr_init(data->res.fattr);
         }
         return data;
+out_free:
+        kfree(data);
+        return NULL;
 }
 
 static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data)
@@ -3281,18 +3479,20 @@ static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_
                                     &data->arg.seq_args, &data->res.seq_res, 1);
         if (status == 0) {
                 update_changeattr(dir, &data->res.dir_cinfo);
-                status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
+                status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, data->res.label);
         }
         return status;
 }
 
 static void nfs4_free_createdata(struct nfs4_createdata *data)
 {
+        nfs4_label_free(data->label);
         kfree(data);
 }
 
 static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
-                struct page *page, unsigned int len, struct iattr *sattr)
+                struct page *page, unsigned int len, struct iattr *sattr,
+                struct nfs4_label *label)
 {
         struct nfs4_createdata *data;
         int status = -ENAMETOOLONG;
@@ -3308,6 +3508,7 @@ static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
         data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK];
         data->arg.u.symlink.pages = &page;
         data->arg.u.symlink.len = len;
+        data->arg.label = label;
         
         status = nfs4_do_create(dir, dentry, data);
 
@@ -3320,18 +3521,24 @@ static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
                 struct page *page, unsigned int len, struct iattr *sattr)
 {
         struct nfs4_exception exception = { };
+        struct nfs4_label l, *label = NULL;
         int err;
+
+        label = nfs4_label_init_security(dir, dentry, sattr, &l);
+
         do {
                 err = nfs4_handle_exception(NFS_SERVER(dir),
                                 _nfs4_proc_symlink(dir, dentry, page,
-                                                        len, sattr),
+                                                        len, sattr, label),
                                 &exception);
         } while (exception.retry);
+
+        nfs4_label_release_security(label);
         return err;
 }
 
 static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
-                struct iattr *sattr)
+                struct iattr *sattr, struct nfs4_label *label)
 {
         struct nfs4_createdata *data;
         int status = -ENOMEM;
@@ -3340,6 +3547,7 @@ static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
         if (data == NULL)
                 goto out;
 
+        data->arg.label = label;
         status = nfs4_do_create(dir, dentry, data);
 
         nfs4_free_createdata(data);
@@ -3351,14 +3559,19 @@ static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
                 struct iattr *sattr)
 {
         struct nfs4_exception exception = { };
+        struct nfs4_label l, *label = NULL;
         int err;
 
+        label = nfs4_label_init_security(dir, dentry, sattr, &l);
+
         sattr->ia_mode &= ~current_umask();
         do {
                 err = nfs4_handle_exception(NFS_SERVER(dir),
-                                _nfs4_proc_mkdir(dir, dentry, sattr),
+                                _nfs4_proc_mkdir(dir, dentry, sattr, label),
                                 &exception);
         } while (exception.retry);
+        nfs4_label_release_security(label);
+
         return err;
 }
 
@@ -3416,7 +3629,7 @@ static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
 }
 
 static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
-                struct iattr *sattr, dev_t rdev)
+                struct iattr *sattr, struct nfs4_label *label, dev_t rdev)
 {
         struct nfs4_createdata *data;
         int mode = sattr->ia_mode;
@@ -3441,7 +3654,8 @@ static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
                 status = -EINVAL;
                 goto out_free;
         }
-        
+
+        data->arg.label = label;
         status = nfs4_do_create(dir, dentry, data);
 out_free:
         nfs4_free_createdata(data);
@@ -3453,14 +3667,20 @@ static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
                 struct iattr *sattr, dev_t rdev)
 {
         struct nfs4_exception exception = { };
+        struct nfs4_label l, *label = NULL;
         int err;
 
+        label = nfs4_label_init_security(dir, dentry, sattr, &l);
+
         sattr->ia_mode &= ~current_umask();
         do {
                 err = nfs4_handle_exception(NFS_SERVER(dir),
-                                _nfs4_proc_mknod(dir, dentry, sattr, rdev),
+                                _nfs4_proc_mknod(dir, dentry, sattr, label, rdev),
                                 &exception);
         } while (exception.retry);
+
+        nfs4_label_release_security(label);
+
         return err;
 }
 
@@ -4187,6 +4407,155 @@ static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen
         return err;
 }
 
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+static int _nfs4_get_security_label(struct inode *inode, void *buf,
+                                        size_t buflen)
+{
+        struct nfs_server *server = NFS_SERVER(inode);
+        struct nfs_fattr fattr;
+        struct nfs4_label label = {0, 0, buflen, buf};
+
+        u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL };
+        struct nfs4_getattr_arg args = {
+                .fh             = NFS_FH(inode),
+                .bitmask        = bitmask,
+        };
+        struct nfs4_getattr_res res = {
+                .fattr          = &fattr,
+                .label          = &label,
+                .server         = server,
+        };
+        struct rpc_message msg = {
+                .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
+                .rpc_argp       = &args,
+                .rpc_resp       = &res,
+        };
+        int ret;
+
+        nfs_fattr_init(&fattr);
+
+        ret = rpc_call_sync(server->client, &msg, 0);
+        if (ret)
+                return ret;
+        if (!(fattr.valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL))
+                return -ENOENT;
+        if (buflen < label.len)
+                return -ERANGE;
+        return 0;
+}
+
+static int nfs4_get_security_label(struct inode *inode, void *buf,
+                                        size_t buflen)
+{
+        struct nfs4_exception exception = { };
+        int err;
+
+        if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
+                return -EOPNOTSUPP;
+
+        do {
+                err = nfs4_handle_exception(NFS_SERVER(inode),
+                                _nfs4_get_security_label(inode, buf, buflen),
+                                &exception);
+        } while (exception.retry);
+        return err;
+}
+
+static int _nfs4_do_set_security_label(struct inode *inode,
+                struct nfs4_label *ilabel,
+                struct nfs_fattr *fattr,
+                struct nfs4_label *olabel)
+{
+
+        struct iattr sattr = {0};
+        struct nfs_server *server = NFS_SERVER(inode);
+        const u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL };
+        struct nfs_setattrargs args = {
+                .fh             = NFS_FH(inode),
+                .iap            = &sattr,
+                .server         = server,
+                .bitmask        = bitmask,
+                .label          = ilabel,
+        };
+        struct nfs_setattrres res = {
+                .fattr          = fattr,
+                .label          = olabel,
+                .server         = server,
+        };
+        struct rpc_message msg = {
+                .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
+                .rpc_argp       = &args,
+                .rpc_resp       = &res,
+        };
+        int status;
+
+        nfs4_stateid_copy(&args.stateid, &zero_stateid);
+
+        status = rpc_call_sync(server->client, &msg, 0);
+        if (status)
+                dprintk("%s failed: %d\n", __func__, status);
+
+        return status;
+}
+
+static int nfs4_do_set_security_label(struct inode *inode,
+                struct nfs4_label *ilabel,
+                struct nfs_fattr *fattr,
+                struct nfs4_label *olabel)
+{
+        struct nfs4_exception exception = { };
+        int err;
+
+        do {
+                err = nfs4_handle_exception(NFS_SERVER(inode),
+                                _nfs4_do_set_security_label(inode, ilabel,
+                                fattr, olabel),
+                                &exception);
+        } while (exception.retry);
+        return err;
+}
+
+static int
+nfs4_set_security_label(struct dentry *dentry, const void *buf, size_t buflen)
+{
+        struct nfs4_label ilabel, *olabel = NULL;
+        struct nfs_fattr fattr;
+        struct rpc_cred *cred;
+        struct inode *inode = dentry->d_inode;
+        int status;
+
+        if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
+                return -EOPNOTSUPP;
+
+        nfs_fattr_init(&fattr);
+
+        ilabel.pi = 0;
+        ilabel.lfs = 0;
+        ilabel.label = (char *)buf;
+        ilabel.len = buflen;
+
+        cred = rpc_lookup_cred();
+        if (IS_ERR(cred))
+                return PTR_ERR(cred);
+
+        olabel = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
+        if (IS_ERR(olabel)) {
+                status = -PTR_ERR(olabel);
+                goto out;
+        }
+
+        status = nfs4_do_set_security_label(inode, &ilabel, &fattr, olabel);
+        if (status == 0)
+                nfs_setsecurity(inode, &fattr, olabel);
+
+        nfs4_label_free(olabel);
+out:
+        put_rpccred(cred);
+        return status;
+}
+#endif  /* CONFIG_NFS_V4_SECURITY_LABEL */
+
+
 static int
 nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server, struct nfs4_state *state)
 {
@@ -4345,7 +4714,7 @@ int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,
         /* cb_client4 */
         rcu_read_lock();
         setclientid.sc_netid_len = scnprintf(setclientid.sc_netid,
-                                sizeof(setclientid.sc_netid),
+                                sizeof(setclientid.sc_netid), "%s",
                                 rpc_peeraddr2str(clp->cl_rpcclient,
                                                         RPC_DISPLAY_NETID));
         rcu_read_unlock();
@@ -5056,13 +5425,18 @@ static int nfs41_check_expired_locks(struct nfs4_state *state)
 
         list_for_each_entry(lsp, &state->lock_states, ls_locks) {
                 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
-                        status = nfs41_test_stateid(server, &lsp->ls_stateid);
+                        struct rpc_cred *cred = lsp->ls_state->owner->so_cred;
+
+                        status = nfs41_test_stateid(server,
+                                        &lsp->ls_stateid,
+                                        cred);
                         if (status != NFS_OK) {
                                 /* Free the stateid unless the server
                                  * informs us the stateid is unrecognized. */
                                 if (status != -NFS4ERR_BAD_STATEID)
                                         nfs41_free_stateid(server,
-                                                        &lsp->ls_stateid);
+                                                        &lsp->ls_stateid,
+                                                        cred);
                                 clear_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags);
                                 ret = status;
                         }
@@ -5295,6 +5669,53 @@ static size_t nfs4_xattr_list_nfs4_acl(struct dentry *dentry, char *list,
         return len;
 }
 
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+static inline int nfs4_server_supports_labels(struct nfs_server *server)
+{
+        return server->caps & NFS_CAP_SECURITY_LABEL;
+}
+
+static int nfs4_xattr_set_nfs4_label(struct dentry *dentry, const char *key,
+                                   const void *buf, size_t buflen,
+                                   int flags, int type)
+{
+        if (security_ismaclabel(key))
+                return nfs4_set_security_label(dentry, buf, buflen);
+
+        return -EOPNOTSUPP;
+}
+
+static int nfs4_xattr_get_nfs4_label(struct dentry *dentry, const char *key,
+                                   void *buf, size_t buflen, int type)
+{
+        if (security_ismaclabel(key))
+                return nfs4_get_security_label(dentry->d_inode, buf, buflen);
+        return -EOPNOTSUPP;
+}
+
+static size_t nfs4_xattr_list_nfs4_label(struct dentry *dentry, char *list,
+                                       size_t list_len, const char *name,
+                                       size_t name_len, int type)
+{
+        size_t len = 0;
+
+        if (nfs_server_capable(dentry->d_inode, NFS_CAP_SECURITY_LABEL)) {
+                len = security_inode_listsecurity(dentry->d_inode, NULL, 0);
+                if (list && len <= list_len)
+                        security_inode_listsecurity(dentry->d_inode, list, len);
+        }
+        return len;
+}
+
+static const struct xattr_handler nfs4_xattr_nfs4_label_handler = {
+        .prefix = XATTR_SECURITY_PREFIX,
+        .list   = nfs4_xattr_list_nfs4_label,
+        .get    = nfs4_xattr_get_nfs4_label,
+        .set    = nfs4_xattr_set_nfs4_label,
+};
+#endif
+
+
 /*
  * nfs_fhget will use either the mounted_on_fileid or the fileid
  */
@@ -5318,7 +5739,7 @@ static int _nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
                                    struct page *page)
 {
         struct nfs_server *server = NFS_SERVER(dir);
-        u32 bitmask[2] = {
+        u32 bitmask[3] = {
                 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
         };
         struct nfs4_fs_locations_arg args = {
@@ -5505,7 +5926,8 @@ int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)
         struct nfs41_exchange_id_args args = {
                 .verifier = &verifier,
                 .client = clp,
-                .flags = EXCHGID4_FLAG_SUPP_MOVED_REFER,
+                .flags = EXCHGID4_FLAG_SUPP_MOVED_REFER |
+                        EXCHGID4_FLAG_BIND_PRINC_STATEID,
         };
         struct nfs41_exchange_id_res res = {
                 0
@@ -5762,17 +6184,14 @@ int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo)
  */
 static void nfs4_init_channel_attrs(struct nfs41_create_session_args *args)
 {
-        struct nfs4_session *session = args->client->cl_session;
-        unsigned int mxrqst_sz = session->fc_target_max_rqst_sz,
-                     mxresp_sz = session->fc_target_max_resp_sz;
+        unsigned int max_rqst_sz, max_resp_sz;
+
+        max_rqst_sz = NFS_MAX_FILE_IO_SIZE + nfs41_maxwrite_overhead;
+        max_resp_sz = NFS_MAX_FILE_IO_SIZE + nfs41_maxread_overhead;
 
-        if (mxrqst_sz == 0)
-                mxrqst_sz = NFS_MAX_FILE_IO_SIZE;
-        if (mxresp_sz == 0)
-                mxresp_sz = NFS_MAX_FILE_IO_SIZE;
         /* Fore channel attributes */
-        args->fc_attrs.max_rqst_sz = mxrqst_sz;
-        args->fc_attrs.max_resp_sz = mxresp_sz;
+        args->fc_attrs.max_rqst_sz = max_rqst_sz;
+        args->fc_attrs.max_resp_sz = max_resp_sz;
         args->fc_attrs.max_ops = NFS4_MAX_OPS;
         args->fc_attrs.max_reqs = max_session_slots;
 
@@ -6159,12 +6578,14 @@ static const struct rpc_call_ops nfs4_reclaim_complete_call_ops = {
 /*
  * Issue a global reclaim complete.
  */
-static int nfs41_proc_reclaim_complete(struct nfs_client *clp)
+static int nfs41_proc_reclaim_complete(struct nfs_client *clp,
+                struct rpc_cred *cred)
 {
         struct nfs4_reclaim_complete_data *calldata;
         struct rpc_task *task;
         struct rpc_message msg = {
                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RECLAIM_COMPLETE],
+                .rpc_cred = cred,
         };
         struct rpc_task_setup task_setup_data = {
                 .rpc_client = clp->cl_rpcclient,
@@ -6348,6 +6769,7 @@ nfs4_proc_layoutget(struct nfs4_layoutget *lgp, gfp_t gfp_flags)
                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTGET],
                 .rpc_argp = &lgp->args,
                 .rpc_resp = &lgp->res,
+                .rpc_cred = lgp->cred,
         };
         struct rpc_task_setup task_setup_data = {
                 .rpc_client = server->client,
@@ -6451,6 +6873,7 @@ int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp)
                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTRETURN],
                 .rpc_argp = &lrp->args,
                 .rpc_resp = &lrp->res,
+                .rpc_cred = lrp->cred,
         };
         struct rpc_task_setup task_setup_data = {
                 .rpc_client = lrp->clp->cl_rpcclient,
@@ -6520,7 +6943,9 @@ int nfs4_proc_getdevicelist(struct nfs_server *server,
 EXPORT_SYMBOL_GPL(nfs4_proc_getdevicelist);
 
 static int
-_nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)
+_nfs4_proc_getdeviceinfo(struct nfs_server *server,
+                struct pnfs_device *pdev,
+                struct rpc_cred *cred)
 {
         struct nfs4_getdeviceinfo_args args = {
                 .pdev = pdev,
@@ -6532,6 +6957,7 @@ _nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)
                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICEINFO],
                 .rpc_argp = &args,
                 .rpc_resp = &res,
+                .rpc_cred = cred,
         };
         int status;
 
@@ -6542,14 +6968,16 @@ _nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)
         return status;
 }
 
-int nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)
+int nfs4_proc_getdeviceinfo(struct nfs_server *server,
+                struct pnfs_device *pdev,
+                struct rpc_cred *cred)
 {
         struct nfs4_exception exception = { };
         int err;
 
         do {
                 err = nfs4_handle_exception(server,
-                                        _nfs4_proc_getdeviceinfo(server, pdev),
+                                        _nfs4_proc_getdeviceinfo(server, pdev, cred),
                                         &exception);
         } while (exception.retry);
         return err;
@@ -6733,7 +7161,9 @@ out:
         return err;
 }
 
-static int _nfs41_test_stateid(struct nfs_server *server, nfs4_stateid *stateid)
+static int _nfs41_test_stateid(struct nfs_server *server,
+                nfs4_stateid *stateid,
+                struct rpc_cred *cred)
 {
         int status;
         struct nfs41_test_stateid_args args = {
@@ -6744,6 +7174,7 @@ static int _nfs41_test_stateid(struct nfs_server *server, nfs4_stateid *stateid)
                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_TEST_STATEID],
                 .rpc_argp = &args,
                 .rpc_resp = &res,
+                .rpc_cred = cred,
         };
 
         dprintk("NFS call  test_stateid %p\n", stateid);
@@ -6764,17 +7195,20 @@ static int _nfs41_test_stateid(struct nfs_server *server, nfs4_stateid *stateid)
  *
  * @server: server / transport on which to perform the operation
  * @stateid: state ID to test
+ * @cred: credential
  *
  * Returns NFS_OK if the server recognizes that "stateid" is valid.
  * Otherwise a negative NFS4ERR value is returned if the operation
  * failed or the state ID is not currently valid.
  */
-static int nfs41_test_stateid(struct nfs_server *server, nfs4_stateid *stateid)
+static int nfs41_test_stateid(struct nfs_server *server,
+                nfs4_stateid *stateid,
+                struct rpc_cred *cred)
 {
         struct nfs4_exception exception = { };
         int err;
         do {
-                err = _nfs41_test_stateid(server, stateid);
+                err = _nfs41_test_stateid(server, stateid, cred);
                 if (err != -NFS4ERR_DELAY)
                         break;
                 nfs4_handle_exception(server, err, &exception);
@@ -6823,10 +7257,12 @@ const struct rpc_call_ops nfs41_free_stateid_ops = {
 
 static struct rpc_task *_nfs41_free_stateid(struct nfs_server *server,
                 nfs4_stateid *stateid,
+                struct rpc_cred *cred,
                 bool privileged)
 {
         struct rpc_message msg = {
                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FREE_STATEID],
+                .rpc_cred = cred,
         };
         struct rpc_task_setup task_setup = {
                 .rpc_client = server->client,
@@ -6859,16 +7295,19 @@ static struct rpc_task *_nfs41_free_stateid(struct nfs_server *server,
  *
  * @server: server / transport on which to perform the operation
  * @stateid: state ID to release
+ * @cred: credential
  *
  * Returns NFS_OK if the server freed "stateid".  Otherwise a
  * negative NFS4ERR value is returned.
  */
-static int nfs41_free_stateid(struct nfs_server *server, nfs4_stateid *stateid)
+static int nfs41_free_stateid(struct nfs_server *server,
+                nfs4_stateid *stateid,
+                struct rpc_cred *cred)
 {
         struct rpc_task *task;
         int ret;
 
-        task = _nfs41_free_stateid(server, stateid, true);
+        task = _nfs41_free_stateid(server, stateid, cred, true);
         if (IS_ERR(task))
                 return PTR_ERR(task);
         ret = rpc_wait_for_completion_task(task);
@@ -6881,8 +7320,9 @@ static int nfs41_free_stateid(struct nfs_server *server, nfs4_stateid *stateid)
 static int nfs41_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
 {
         struct rpc_task *task;
+        struct rpc_cred *cred = lsp->ls_state->owner->so_cred;
 
-        task = _nfs41_free_stateid(server, &lsp->ls_stateid, false);
+        task = _nfs41_free_stateid(server, &lsp->ls_stateid, cred, false);
         nfs4_free_lock_state(server, lsp);
         if (IS_ERR(task))
                 return PTR_ERR(task);
@@ -7004,11 +7444,33 @@ static const struct nfs4_minor_version_ops nfs_v4_1_minor_ops = {
 };
 #endif
 
+#if defined(CONFIG_NFS_V4_2)
+static const struct nfs4_minor_version_ops nfs_v4_2_minor_ops = {
+        .minor_version = 2,
+        .init_caps = NFS_CAP_READDIRPLUS
+                | NFS_CAP_ATOMIC_OPEN
+                | NFS_CAP_CHANGE_ATTR
+                | NFS_CAP_POSIX_LOCK
+                | NFS_CAP_STATEID_NFSV41
+                | NFS_CAP_ATOMIC_OPEN_V1,
+        .call_sync = nfs4_call_sync_sequence,
+        .match_stateid = nfs41_match_stateid,
+        .find_root_sec = nfs41_find_root_sec,
+        .free_lock_state = nfs41_free_lock_state,
+        .reboot_recovery_ops = &nfs41_reboot_recovery_ops,
+        .nograce_recovery_ops = &nfs41_nograce_recovery_ops,
+        .state_renewal_ops = &nfs41_state_renewal_ops,
+};
+#endif
+
 const struct nfs4_minor_version_ops *nfs_v4_minor_ops[] = {
         [0] = &nfs_v4_0_minor_ops,
 #if defined(CONFIG_NFS_V4_1)
         [1] = &nfs_v4_1_minor_ops,
 #endif
+#if defined(CONFIG_NFS_V4_2)
+        [2] = &nfs_v4_2_minor_ops,
+#endif
 };
 
 const struct inode_operations nfs4_dir_inode_operations = {
@@ -7108,6 +7570,9 @@ static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = {
 
 const struct xattr_handler *nfs4_xattr_handlers[] = {
         &nfs4_xattr_nfs4_acl_handler,
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+        &nfs4_xattr_nfs4_label_handler,
+#endif
         NULL
 };
 
diff --git a/fs/nfs/nfs4session.c b/fs/nfs/nfs4session.c
index c4e225e4a9af..36e21cb29d65 100644
--- a/fs/nfs/nfs4session.c
+++ b/fs/nfs/nfs4session.c
@@ -478,48 +478,12 @@ static int nfs41_check_session_ready(struct nfs_client *clp)
         return 0;
 }
 
-int nfs4_init_session(struct nfs_server *server)
+int nfs4_init_session(struct nfs_client *clp)
 {
-        struct nfs_client *clp = server->nfs_client;
-        struct nfs4_session *session;
-        unsigned int target_max_rqst_sz = NFS_MAX_FILE_IO_SIZE;
-        unsigned int target_max_resp_sz = NFS_MAX_FILE_IO_SIZE;
-
         if (!nfs4_has_session(clp))
                 return 0;
 
-        if (server->rsize != 0)
-                target_max_resp_sz = server->rsize;
-        target_max_resp_sz += nfs41_maxread_overhead;
-
-        if (server->wsize != 0)
-                target_max_rqst_sz = server->wsize;
-        target_max_rqst_sz += nfs41_maxwrite_overhead;
-
-        session = clp->cl_session;
-        spin_lock(&clp->cl_lock);
-        if (test_and_clear_bit(NFS4_SESSION_INITING, &session->session_state)) {
-                /* Initialise targets and channel attributes */
-                session->fc_target_max_rqst_sz = target_max_rqst_sz;
-                session->fc_attrs.max_rqst_sz = target_max_rqst_sz;
-                session->fc_target_max_resp_sz = target_max_resp_sz;
-                session->fc_attrs.max_resp_sz = target_max_resp_sz;
-        } else {
-                /* Just adjust the targets */
-                if (target_max_rqst_sz > session->fc_target_max_rqst_sz) {
-                        session->fc_target_max_rqst_sz = target_max_rqst_sz;
-                        set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
-                }
-                if (target_max_resp_sz > session->fc_target_max_resp_sz) {
-                        session->fc_target_max_resp_sz = target_max_resp_sz;
-                        set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
-                }
-        }
-        spin_unlock(&clp->cl_lock);
-
-        if (test_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state))
-                nfs4_schedule_lease_recovery(clp);
-
+        clear_bit(NFS4_SESSION_INITING, &clp->cl_session->session_state);
         return nfs41_check_session_ready(clp);
 }
 
diff --git a/fs/nfs/nfs4session.h b/fs/nfs/nfs4session.h
index ff7d9f0f8a65..3a153d82b90c 100644
--- a/fs/nfs/nfs4session.h
+++ b/fs/nfs/nfs4session.h
@@ -66,9 +66,6 @@ struct nfs4_session {
         struct nfs4_channel_attrs       bc_attrs;
         struct nfs4_slot_table          bc_slot_table;
         struct nfs_client               *clp;
-        /* Create session arguments */
-        unsigned int                    fc_target_max_rqst_sz;
-        unsigned int                    fc_target_max_resp_sz;
 };
 
 enum nfs4_session_state {
@@ -89,7 +86,7 @@ extern int nfs4_setup_session_slot_tables(struct nfs4_session *ses);
 
 extern struct nfs4_session *nfs4_alloc_session(struct nfs_client *clp);
 extern void nfs4_destroy_session(struct nfs4_session *session);
-extern int nfs4_init_session(struct nfs_server *server);
+extern int nfs4_init_session(struct nfs_client *clp);
 extern int nfs4_init_ds_session(struct nfs_client *, unsigned long);
 
 extern void nfs4_slot_tbl_drain_complete(struct nfs4_slot_table *tbl);
@@ -122,7 +119,7 @@ static inline int nfs4_has_persistent_session(const struct nfs_client *clp)
 
 #else /* defined(CONFIG_NFS_V4_1) */
 
-static inline int nfs4_init_session(struct nfs_server *server)
+static inline int nfs4_init_session(struct nfs_client *clp)
 {
         return 0;
 }
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 55418811a55a..e22862f13564 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -228,19 +228,8 @@ static int nfs41_setup_state_renewal(struct nfs_client *clp)
         return status;
 }
 
-/*
- * Back channel returns NFS4ERR_DELAY for new requests when
- * NFS4_SESSION_DRAINING is set so there is no work to be done when draining
- * is ended.
- */
-static void nfs4_end_drain_session(struct nfs_client *clp)
+static void nfs4_end_drain_slot_table(struct nfs4_slot_table *tbl)
 {
-        struct nfs4_session *ses = clp->cl_session;
-        struct nfs4_slot_table *tbl;
-
-        if (ses == NULL)
-                return;
-        tbl = &ses->fc_slot_table;
         if (test_and_clear_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state)) {
                 spin_lock(&tbl->slot_tbl_lock);
                 nfs41_wake_slot_table(tbl);
@@ -248,6 +237,16 @@ static void nfs4_end_drain_session(struct nfs_client *clp)
         }
 }
 
+static void nfs4_end_drain_session(struct nfs_client *clp)
+{
+        struct nfs4_session *ses = clp->cl_session;
+
+        if (ses != NULL) {
+                nfs4_end_drain_slot_table(&ses->bc_slot_table);
+                nfs4_end_drain_slot_table(&ses->fc_slot_table);
+        }
+}
+
 /*
  * Signal state manager thread if session fore channel is drained
  */
@@ -1563,11 +1562,12 @@ static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp)
 }
 
 static void nfs4_reclaim_complete(struct nfs_client *clp,
-                                 const struct nfs4_state_recovery_ops *ops)
+                                 const struct nfs4_state_recovery_ops *ops,
+                                 struct rpc_cred *cred)
 {
         /* Notify the server we're done reclaiming our state */
         if (ops->reclaim_complete)
-                (void)ops->reclaim_complete(clp);
+                (void)ops->reclaim_complete(clp, cred);
 }
 
 static void nfs4_clear_reclaim_server(struct nfs_server *server)
@@ -1612,9 +1612,15 @@ static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp)
 
 static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp)
 {
+        const struct nfs4_state_recovery_ops *ops;
+        struct rpc_cred *cred;
+
         if (!nfs4_state_clear_reclaim_reboot(clp))
                 return;
-        nfs4_reclaim_complete(clp, clp->cl_mvops->reboot_recovery_ops);
+        ops = clp->cl_mvops->reboot_recovery_ops;
+        cred = ops->get_clid_cred(clp);
+        nfs4_reclaim_complete(clp, ops, cred);
+        put_rpccred(cred);
 }
 
 static void nfs_delegation_clear_all(struct nfs_client *clp)
diff --git a/fs/nfs/nfs4super.c b/fs/nfs/nfs4super.c
index a5e1a3026d48..5dbe2d269210 100644
--- a/fs/nfs/nfs4super.c
+++ b/fs/nfs/nfs4super.c
@@ -9,6 +9,7 @@
 #include "delegation.h"
 #include "internal.h"
 #include "nfs4_fs.h"
+#include "dns_resolve.h"
 #include "pnfs.h"
 #include "nfs.h"
 
@@ -331,18 +332,24 @@ static int __init init_nfs_v4(void)
 {
         int err;
 
-        err = nfs_idmap_init();
+        err = nfs_dns_resolver_init();
         if (err)
                 goto out;
 
-        err = nfs4_register_sysctl();
+        err = nfs_idmap_init();
         if (err)
                 goto out1;
 
+        err = nfs4_register_sysctl();
+        if (err)
+                goto out2;
+
         register_nfs_version(&nfs_v4);
         return 0;
-out1:
+out2:
         nfs_idmap_quit();
+out1:
+        nfs_dns_resolver_destroy();
 out:
         return err;
 }
@@ -352,6 +359,7 @@ static void __exit exit_nfs_v4(void)
         unregister_nfs_version(&nfs_v4);
         nfs4_unregister_sysctl();
         nfs_idmap_quit();
+        nfs_dns_resolver_destroy();
 }
 
 MODULE_LICENSE("GPL");
diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index 4be8d135ed61..0abfb8466e79 100644
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -102,12 +102,23 @@ static int nfs4_stat_to_errno(int);
 #define nfs4_path_maxsz         (1 + ((3 + NFS4_MAXPATHLEN) >> 2))
 #define nfs4_owner_maxsz        (1 + XDR_QUADLEN(IDMAP_NAMESZ))
 #define nfs4_group_maxsz        (1 + XDR_QUADLEN(IDMAP_NAMESZ))
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+/* PI(4 bytes) + LFS(4 bytes) + 1(for null terminator?) + MAXLABELLEN */
+#define nfs4_label_maxsz        (4 + 4 + 1 + XDR_QUADLEN(NFS4_MAXLABELLEN))
+#define encode_readdir_space 24
+#define encode_readdir_bitmask_sz 3
+#else
+#define nfs4_label_maxsz        0
+#define encode_readdir_space 20
+#define encode_readdir_bitmask_sz 2
+#endif
 /* We support only one layout type per file system */
 #define decode_mdsthreshold_maxsz (1 + 1 + nfs4_fattr_bitmap_maxsz + 1 + 8)
 /* This is based on getfattr, which uses the most attributes: */
 #define nfs4_fattr_value_maxsz  (1 + (1 + 2 + 2 + 4 + 2 + 1 + 1 + 2 + 2 + \
                                 3 + 3 + 3 + nfs4_owner_maxsz + \
-                                nfs4_group_maxsz + decode_mdsthreshold_maxsz))
+                                nfs4_group_maxsz + nfs4_label_maxsz + \
+                                 decode_mdsthreshold_maxsz))
 #define nfs4_fattr_maxsz        (nfs4_fattr_bitmap_maxsz + \
                                 nfs4_fattr_value_maxsz)
 #define decode_getattr_maxsz    (op_decode_hdr_maxsz + nfs4_fattr_maxsz)
@@ -115,6 +126,7 @@ static int nfs4_stat_to_errno(int);
                                  1 + 2 + 1 + \
                                 nfs4_owner_maxsz + \
                                 nfs4_group_maxsz + \
+                                nfs4_label_maxsz + \
                                 4 + 4)
 #define encode_savefh_maxsz     (op_encode_hdr_maxsz)
 #define decode_savefh_maxsz     (op_decode_hdr_maxsz)
@@ -192,9 +204,11 @@ static int nfs4_stat_to_errno(int);
                                  encode_stateid_maxsz + 3)
 #define decode_read_maxsz       (op_decode_hdr_maxsz + 2)
 #define encode_readdir_maxsz    (op_encode_hdr_maxsz + \
-                                 2 + encode_verifier_maxsz + 5)
+                                 2 + encode_verifier_maxsz + 5 + \
+                                nfs4_label_maxsz)
 #define decode_readdir_maxsz    (op_decode_hdr_maxsz + \
-                                 decode_verifier_maxsz)
+                                 decode_verifier_maxsz + \
+                                nfs4_label_maxsz + nfs4_fattr_maxsz)
 #define encode_readlink_maxsz   (op_encode_hdr_maxsz)
 #define decode_readlink_maxsz   (op_decode_hdr_maxsz + 1)
 #define encode_write_maxsz      (op_encode_hdr_maxsz + \
@@ -853,6 +867,12 @@ const u32 nfs41_maxread_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
                                      decode_sequence_maxsz +
                                      decode_putfh_maxsz) *
                                     XDR_UNIT);
+
+const u32 nfs41_maxgetdevinfo_overhead = ((RPC_MAX_REPHEADER_WITH_AUTH +
+                                           compound_decode_hdr_maxsz +
+                                           decode_sequence_maxsz) *
+                                          XDR_UNIT);
+EXPORT_SYMBOL_GPL(nfs41_maxgetdevinfo_overhead);
 #endif /* CONFIG_NFS_V4_1 */
 
 static const umode_t nfs_type2fmt[] = {
@@ -968,7 +988,9 @@ static void encode_nfs4_verifier(struct xdr_stream *xdr, const nfs4_verifier *ve
         encode_opaque_fixed(xdr, verf->data, NFS4_VERIFIER_SIZE);
 }
 
-static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const struct nfs_server *server)
+static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap,
+                                const struct nfs4_label *label,
+                                const struct nfs_server *server)
 {
         char owner_name[IDMAP_NAMESZ];
         char owner_group[IDMAP_NAMESZ];
@@ -979,15 +1001,16 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const
         int len;
         uint32_t bmval0 = 0;
         uint32_t bmval1 = 0;
+        uint32_t bmval2 = 0;
 
         /*
          * We reserve enough space to write the entire attribute buffer at once.
          * In the worst-case, this would be
-         *   12(bitmap) + 4(attrlen) + 8(size) + 4(mode) + 4(atime) + 4(mtime)
-         *          = 36 bytes, plus any contribution from variable-length fields
+         * 16(bitmap) + 4(attrlen) + 8(size) + 4(mode) + 4(atime) + 4(mtime)
+         * = 40 bytes, plus any contribution from variable-length fields
          *            such as owner/group.
          */
-        len = 16;
+        len = 20;
 
         /* Sigh */
         if (iap->ia_valid & ATTR_SIZE)
@@ -1017,6 +1040,8 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const
                 }
                 len += 4 + (XDR_QUADLEN(owner_grouplen) << 2);
         }
+        if (label)
+                len += 4 + 4 + 4 + (XDR_QUADLEN(label->len) << 2);
         if (iap->ia_valid & ATTR_ATIME_SET)
                 len += 16;
         else if (iap->ia_valid & ATTR_ATIME)
@@ -1031,9 +1056,9 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const
          * We write the bitmap length now, but leave the bitmap and the attribute
          * buffer length to be backfilled at the end of this routine.
          */
-        *p++ = cpu_to_be32(2);
+        *p++ = cpu_to_be32(3);
         q = p;
-        p += 3;
+        p += 4;
 
         if (iap->ia_valid & ATTR_SIZE) {
                 bmval0 |= FATTR4_WORD0_SIZE;
@@ -1071,6 +1096,13 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const
                 bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET;
                 *p++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME);
         }
+        if (label) {
+                bmval2 |= FATTR4_WORD2_SECURITY_LABEL;
+                *p++ = cpu_to_be32(label->lfs);
+                *p++ = cpu_to_be32(label->pi);
+                *p++ = cpu_to_be32(label->len);
+                p = xdr_encode_opaque_fixed(p, label->label, label->len);
+        }
 
         /*
          * Now we backfill the bitmap and the attribute buffer length.
@@ -1080,9 +1112,10 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const
                                 len, ((char *)p - (char *)q) + 4);
                 BUG();
         }
-        len = (char *)p - (char *)q - 12;
+        len = (char *)p - (char *)q - 16;
         *q++ = htonl(bmval0);
         *q++ = htonl(bmval1);
+        *q++ = htonl(bmval2);
         *q = htonl(len);
 
 /* out: */
@@ -1136,7 +1169,7 @@ static void encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *
         }
 
         encode_string(xdr, create->name->len, create->name->name);
-        encode_attrs(xdr, create->attrs, create->server);
+        encode_attrs(xdr, create->attrs, create->label, create->server);
 }
 
 static void encode_getattr_one(struct xdr_stream *xdr, uint32_t bitmap, struct compound_hdr *hdr)
@@ -1188,8 +1221,10 @@ encode_getattr_three(struct xdr_stream *xdr,
 
 static void encode_getfattr(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)
 {
-        encode_getattr_two(xdr, bitmask[0] & nfs4_fattr_bitmap[0],
-                           bitmask[1] & nfs4_fattr_bitmap[1], hdr);
+        encode_getattr_three(xdr, bitmask[0] & nfs4_fattr_bitmap[0],
+                           bitmask[1] & nfs4_fattr_bitmap[1],
+                           bitmask[2] & nfs4_fattr_bitmap[2],
+                           hdr);
 }
 
 static void encode_getfattr_open(struct xdr_stream *xdr, const u32 *bitmask,
@@ -1367,11 +1402,11 @@ static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_op
         switch(arg->createmode) {
         case NFS4_CREATE_UNCHECKED:
                 *p = cpu_to_be32(NFS4_CREATE_UNCHECKED);
-                encode_attrs(xdr, arg->u.attrs, arg->server);
+                encode_attrs(xdr, arg->u.attrs, arg->label, arg->server);
                 break;
         case NFS4_CREATE_GUARDED:
                 *p = cpu_to_be32(NFS4_CREATE_GUARDED);
-                encode_attrs(xdr, arg->u.attrs, arg->server);
+                encode_attrs(xdr, arg->u.attrs, arg->label, arg->server);
                 break;
         case NFS4_CREATE_EXCLUSIVE:
                 *p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE);
@@ -1381,7 +1416,7 @@ static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_op
                 *p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE4_1);
                 encode_nfs4_verifier(xdr, &arg->u.verifier);
                 dummy.ia_valid = 0;
-                encode_attrs(xdr, &dummy, arg->server);
+                encode_attrs(xdr, &dummy, arg->label, arg->server);
         }
 }
 
@@ -1532,7 +1567,7 @@ static void encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args,
 
 static void encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg *readdir, struct rpc_rqst *req, struct compound_hdr *hdr)
 {
-        uint32_t attrs[2] = {
+        uint32_t attrs[3] = {
                 FATTR4_WORD0_RDATTR_ERROR,
                 FATTR4_WORD1_MOUNTED_ON_FILEID,
         };
@@ -1555,20 +1590,26 @@ static void encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg
         encode_op_hdr(xdr, OP_READDIR, decode_readdir_maxsz, hdr);
         encode_uint64(xdr, readdir->cookie);
         encode_nfs4_verifier(xdr, &readdir->verifier);
-        p = reserve_space(xdr, 20);
+        p = reserve_space(xdr, encode_readdir_space);
         *p++ = cpu_to_be32(dircount);
         *p++ = cpu_to_be32(readdir->count);
-        *p++ = cpu_to_be32(2);
-
+        *p++ = cpu_to_be32(encode_readdir_bitmask_sz);
         *p++ = cpu_to_be32(attrs[0] & readdir->bitmask[0]);
-        *p = cpu_to_be32(attrs[1] & readdir->bitmask[1]);
+        *p   = cpu_to_be32(attrs[1] & readdir->bitmask[1]);
+        if (encode_readdir_bitmask_sz > 2) {
+                if (hdr->minorversion > 1)
+                        attrs[2] |= FATTR4_WORD2_SECURITY_LABEL;
+                p++, *p++ = cpu_to_be32(attrs[2] & readdir->bitmask[2]);
+        }
         memcpy(verf, readdir->verifier.data, sizeof(verf));
-        dprintk("%s: cookie = %Lu, verifier = %08x:%08x, bitmap = %08x:%08x\n",
+
+        dprintk("%s: cookie = %llu, verifier = %08x:%08x, bitmap = %08x:%08x:%08x\n",
                         __func__,
                         (unsigned long long)readdir->cookie,
                         verf[0], verf[1],
                         attrs[0] & readdir->bitmask[0],
-                        attrs[1] & readdir->bitmask[1]);
+                        attrs[1] & readdir->bitmask[1],
+                        attrs[2] & readdir->bitmask[2]);
 }
 
 static void encode_readlink(struct xdr_stream *xdr, const struct nfs4_readlink *readlink, struct rpc_rqst *req, struct compound_hdr *hdr)
@@ -1627,7 +1668,7 @@ static void encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs
 {
         encode_op_hdr(xdr, OP_SETATTR, decode_setattr_maxsz, hdr);
         encode_nfs4_stateid(xdr, &arg->stateid);
-        encode_attrs(xdr, arg->iap, server);
+        encode_attrs(xdr, arg->iap, arg->label, server);
 }
 
 static void encode_setclientid(struct xdr_stream *xdr, const struct nfs4_setclientid *setclientid, struct compound_hdr *hdr)
@@ -1889,7 +1930,7 @@ encode_getdeviceinfo(struct xdr_stream *xdr,
         p = xdr_encode_opaque_fixed(p, args->pdev->dev_id.data,
                                     NFS4_DEVICEID4_SIZE);
         *p++ = cpu_to_be32(args->pdev->layout_type);
-        *p++ = cpu_to_be32(args->pdev->pglen);          /* gdia_maxcount */
+        *p++ = cpu_to_be32(args->pdev->maxcount);       /* gdia_maxcount */
         *p++ = cpu_to_be32(0);                          /* bitmap length 0 */
 }
 
@@ -4038,6 +4079,56 @@ static int decode_attr_time_delta(struct xdr_stream *xdr, uint32_t *bitmap,
         return status;
 }
 
+static int decode_attr_security_label(struct xdr_stream *xdr, uint32_t *bitmap,
+                                        struct nfs4_label *label)
+{
+        uint32_t pi = 0;
+        uint32_t lfs = 0;
+        __u32 len;
+        __be32 *p;
+        int status = 0;
+
+        if (unlikely(bitmap[2] & (FATTR4_WORD2_SECURITY_LABEL - 1U)))
+                return -EIO;
+        if (likely(bitmap[2] & FATTR4_WORD2_SECURITY_LABEL)) {
+                p = xdr_inline_decode(xdr, 4);
+                if (unlikely(!p))
+                        goto out_overflow;
+                lfs = be32_to_cpup(p++);
+                p = xdr_inline_decode(xdr, 4);
+                if (unlikely(!p))
+                        goto out_overflow;
+                pi = be32_to_cpup(p++);
+                p = xdr_inline_decode(xdr, 4);
+                if (unlikely(!p))
+                        goto out_overflow;
+                len = be32_to_cpup(p++);
+                p = xdr_inline_decode(xdr, len);
+                if (unlikely(!p))
+                        goto out_overflow;
+                if (len < NFS4_MAXLABELLEN) {
+                        if (label) {
+                                memcpy(label->label, p, len);
+                                label->len = len;
+                                label->pi = pi;
+                                label->lfs = lfs;
+                                status = NFS_ATTR_FATTR_V4_SECURITY_LABEL;
+                        }
+                        bitmap[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
+                } else
+                        printk(KERN_WARNING "%s: label too long (%u)!\n",
+                                        __func__, len);
+        }
+        if (label && label->label)
+                dprintk("%s: label=%s, len=%d, PI=%d, LFS=%d\n", __func__,
+                        (char *)label->label, label->len, label->pi, label->lfs);
+        return status;
+
+out_overflow:
+        print_overflow_msg(__func__, xdr);
+        return -EIO;
+}
+
 static int decode_attr_time_modify(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
 {
         int status = 0;
@@ -4380,7 +4471,7 @@ out_overflow:
 
 static int decode_getfattr_attrs(struct xdr_stream *xdr, uint32_t *bitmap,
                 struct nfs_fattr *fattr, struct nfs_fh *fh,
-                struct nfs4_fs_locations *fs_loc,
+                struct nfs4_fs_locations *fs_loc, struct nfs4_label *label,
                 const struct nfs_server *server)
 {
         int status;
@@ -4488,6 +4579,13 @@ static int decode_getfattr_attrs(struct xdr_stream *xdr, uint32_t *bitmap,
         if (status < 0)
                 goto xdr_error;
 
+        if (label) {
+                status = decode_attr_security_label(xdr, bitmap, label);
+                if (status < 0)
+                        goto xdr_error;
+                fattr->valid |= status;
+        }
+
 xdr_error:
         dprintk("%s: xdr returned %d\n", __func__, -status);
         return status;
@@ -4495,7 +4593,7 @@ xdr_error:
 
 static int decode_getfattr_generic(struct xdr_stream *xdr, struct nfs_fattr *fattr,
                 struct nfs_fh *fh, struct nfs4_fs_locations *fs_loc,
-                const struct nfs_server *server)
+                struct nfs4_label *label, const struct nfs_server *server)
 {
         unsigned int savep;
         uint32_t attrlen,
@@ -4514,7 +4612,8 @@ static int decode_getfattr_generic(struct xdr_stream *xdr, struct nfs_fattr *fat
         if (status < 0)
                 goto xdr_error;
 
-        status = decode_getfattr_attrs(xdr, bitmap, fattr, fh, fs_loc, server);
+        status = decode_getfattr_attrs(xdr, bitmap, fattr, fh, fs_loc,
+                                        label, server);
         if (status < 0)
                 goto xdr_error;
 
@@ -4524,10 +4623,16 @@ xdr_error:
         return status;
 }
 
+static int decode_getfattr_label(struct xdr_stream *xdr, struct nfs_fattr *fattr,
+                struct nfs4_label *label, const struct nfs_server *server)
+{
+        return decode_getfattr_generic(xdr, fattr, NULL, NULL, label, server);
+}
+
 static int decode_getfattr(struct xdr_stream *xdr, struct nfs_fattr *fattr,
                 const struct nfs_server *server)
 {
-        return decode_getfattr_generic(xdr, fattr, NULL, NULL, server);
+        return decode_getfattr_generic(xdr, fattr, NULL, NULL, NULL, server);
 }
 
 /*
@@ -5919,7 +6024,7 @@ static int nfs4_xdr_dec_lookup(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
         status = decode_getfh(xdr, res->fh);
         if (status)
                 goto out;
-        status = decode_getfattr(xdr, res->fattr, res->server);
+        status = decode_getfattr_label(xdr, res->fattr, res->label, res->server);
 out:
         return status;
 }
@@ -5945,7 +6050,8 @@ static int nfs4_xdr_dec_lookup_root(struct rpc_rqst *rqstp,
                 goto out;
         status = decode_getfh(xdr, res->fh);
         if (status == 0)
-                status = decode_getfattr(xdr, res->fattr, res->server);
+                status = decode_getfattr_label(xdr, res->fattr,
+                                                res->label, res->server);
 out:
         return status;
 }
@@ -6036,7 +6142,7 @@ static int nfs4_xdr_dec_link(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
         status = decode_restorefh(xdr);
         if (status)
                 goto out;
-        decode_getfattr(xdr, res->fattr, res->server);
+        decode_getfattr_label(xdr, res->fattr, res->label, res->server);
 out:
         return status;
 }
@@ -6065,7 +6171,7 @@ static int nfs4_xdr_dec_create(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
         status = decode_getfh(xdr, res->fh);
         if (status)
                 goto out;
-        decode_getfattr(xdr, res->fattr, res->server);
+        decode_getfattr_label(xdr, res->fattr, res->label, res->server);
 out:
         return status;
 }
@@ -6097,7 +6203,7 @@ static int nfs4_xdr_dec_getattr(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
         status = decode_putfh(xdr);
         if (status)
                 goto out;
-        status = decode_getfattr(xdr, res->fattr, res->server);
+        status = decode_getfattr_label(xdr, res->fattr, res->label, res->server);
 out:
         return status;
 }
@@ -6230,7 +6336,7 @@ static int nfs4_xdr_dec_open(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
                 goto out;
         if (res->access_request)
                 decode_access(xdr, &res->access_supported, &res->access_result);
-        decode_getfattr(xdr, res->f_attr, res->server);
+        decode_getfattr_label(xdr, res->f_attr, res->f_label, res->server);
 out:
         return status;
 }
@@ -6307,7 +6413,7 @@ static int nfs4_xdr_dec_setattr(struct rpc_rqst *rqstp,
         status = decode_setattr(xdr);
         if (status)
                 goto out;
-        decode_getfattr(xdr, res->fattr, res->server);
+        decode_getfattr_label(xdr, res->fattr, res->label, res->server);
 out:
         return status;
 }
@@ -6696,7 +6802,7 @@ static int nfs4_xdr_dec_fs_locations(struct rpc_rqst *req,
         xdr_enter_page(xdr, PAGE_SIZE);
         status = decode_getfattr_generic(xdr, &res->fs_locations->fattr,
                                          NULL, res->fs_locations,
-                                         res->fs_locations->server);
+                                         NULL, res->fs_locations->server);
 out:
         return status;
 }
@@ -7109,7 +7215,7 @@ int nfs4_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
                 goto out_overflow;
 
         if (decode_getfattr_attrs(xdr, bitmap, entry->fattr, entry->fh,
-                                  NULL, entry->server) < 0)
+                        NULL, entry->label, entry->server) < 0)
                 goto out_overflow;
         if (entry->fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID)
                 entry->ino = entry->fattr->mounted_on_fileid;
diff --git a/fs/nfs/objlayout/objlayout.c b/fs/nfs/objlayout/objlayout.c
index a9ebd817278b..e4f9cbfec67b 100644
--- a/fs/nfs/objlayout/objlayout.c
+++ b/fs/nfs/objlayout/objlayout.c
@@ -613,8 +613,10 @@ int objlayout_get_deviceinfo(struct pnfs_layout_hdr *pnfslay,
         pd.pgbase = 0;
         pd.pglen = PAGE_SIZE;
         pd.mincount = 0;
+        pd.maxcount = PAGE_SIZE;
 
-        err = nfs4_proc_getdeviceinfo(NFS_SERVER(pnfslay->plh_inode), &pd);
+        err = nfs4_proc_getdeviceinfo(NFS_SERVER(pnfslay->plh_inode), &pd,
+                        pnfslay->plh_lc_cred);
         dprintk("%s nfs_getdeviceinfo returned %d\n", __func__, err);
         if (err)
                 goto err_out;
diff --git a/fs/nfs/pnfs.c b/fs/nfs/pnfs.c
index c5bd758e5637..3a3a79d6bf15 100644
--- a/fs/nfs/pnfs.c
+++ b/fs/nfs/pnfs.c
@@ -360,7 +360,7 @@ pnfs_put_lseg(struct pnfs_layout_segment *lseg)
 }
 EXPORT_SYMBOL_GPL(pnfs_put_lseg);
 
-static inline u64
+static u64
 end_offset(u64 start, u64 len)
 {
         u64 end;
@@ -376,9 +376,9 @@ end_offset(u64 start, u64 len)
  *           start2           end2
  *           [----------------)
  */
-static inline int
-lo_seg_contained(struct pnfs_layout_range *l1,
-                 struct pnfs_layout_range *l2)
+static bool
+pnfs_lseg_range_contained(const struct pnfs_layout_range *l1,
+                 const struct pnfs_layout_range *l2)
 {
         u64 start1 = l1->offset;
         u64 end1 = end_offset(start1, l1->length);
@@ -395,9 +395,9 @@ lo_seg_contained(struct pnfs_layout_range *l1,
  *                              start2           end2
  *                              [----------------)
  */
-static inline int
-lo_seg_intersecting(struct pnfs_layout_range *l1,
-                    struct pnfs_layout_range *l2)
+static bool
+pnfs_lseg_range_intersecting(const struct pnfs_layout_range *l1,
+                    const struct pnfs_layout_range *l2)
 {
         u64 start1 = l1->offset;
         u64 end1 = end_offset(start1, l1->length);
@@ -409,12 +409,12 @@ lo_seg_intersecting(struct pnfs_layout_range *l1,
 }
 
 static bool
-should_free_lseg(struct pnfs_layout_range *lseg_range,
-                 struct pnfs_layout_range *recall_range)
+should_free_lseg(const struct pnfs_layout_range *lseg_range,
+                 const struct pnfs_layout_range *recall_range)
 {
         return (recall_range->iomode == IOMODE_ANY ||
                 lseg_range->iomode == recall_range->iomode) &&
-               lo_seg_intersecting(lseg_range, recall_range);
+               pnfs_lseg_range_intersecting(lseg_range, recall_range);
 }
 
 static bool pnfs_lseg_dec_and_remove_zero(struct pnfs_layout_segment *lseg,
@@ -766,6 +766,7 @@ send_layoutget(struct pnfs_layout_hdr *lo,
         lgp->args.inode = ino;
         lgp->args.ctx = get_nfs_open_context(ctx);
         lgp->gfp_flags = gfp_flags;
+        lgp->cred = lo->plh_lc_cred;
 
         /* Synchronously retrieve layout information from server and
          * store in lseg.
@@ -860,6 +861,7 @@ _pnfs_return_layout(struct inode *ino)
         lrp->args.inode = ino;
         lrp->args.layout = lo;
         lrp->clp = NFS_SERVER(ino)->nfs_client;
+        lrp->cred = lo->plh_lc_cred;
 
         status = nfs4_proc_layoutreturn(lrp);
 out:
@@ -984,8 +986,8 @@ out:
  * are seen first.
  */
 static s64
-cmp_layout(struct pnfs_layout_range *l1,
-           struct pnfs_layout_range *l2)
+pnfs_lseg_range_cmp(const struct pnfs_layout_range *l1,
+           const struct pnfs_layout_range *l2)
 {
         s64 d;
 
@@ -1012,7 +1014,7 @@ pnfs_layout_insert_lseg(struct pnfs_layout_hdr *lo,
         dprintk("%s:Begin\n", __func__);
 
         list_for_each_entry(lp, &lo->plh_segs, pls_list) {
-                if (cmp_layout(&lseg->pls_range, &lp->pls_range) > 0)
+                if (pnfs_lseg_range_cmp(&lseg->pls_range, &lp->pls_range) > 0)
                         continue;
                 list_add_tail(&lseg->pls_list, &lp->pls_list);
                 dprintk("%s: inserted lseg %p "
@@ -1050,7 +1052,7 @@ alloc_init_layout_hdr(struct inode *ino,
         INIT_LIST_HEAD(&lo->plh_segs);
         INIT_LIST_HEAD(&lo->plh_bulk_destroy);
         lo->plh_inode = ino;
-        lo->plh_lc_cred = get_rpccred(ctx->state->owner->so_cred);
+        lo->plh_lc_cred = get_rpccred(ctx->cred);
         return lo;
 }
 
@@ -1091,21 +1093,21 @@ out_existing:
  * READ         READ    true
  * READ         RW      true
  */
-static int
-is_matching_lseg(struct pnfs_layout_range *ls_range,
-                 struct pnfs_layout_range *range)
+static bool
+pnfs_lseg_range_match(const struct pnfs_layout_range *ls_range,
+                 const struct pnfs_layout_range *range)
 {
         struct pnfs_layout_range range1;
 
         if ((range->iomode == IOMODE_RW &&
              ls_range->iomode != IOMODE_RW) ||
-            !lo_seg_intersecting(ls_range, range))
+            !pnfs_lseg_range_intersecting(ls_range, range))
                 return 0;
 
         /* range1 covers only the first byte in the range */
         range1 = *range;
         range1.length = 1;
-        return lo_seg_contained(ls_range, &range1);
+        return pnfs_lseg_range_contained(ls_range, &range1);
 }
 
 /*
@@ -1121,7 +1123,7 @@ pnfs_find_lseg(struct pnfs_layout_hdr *lo,
 
         list_for_each_entry(lseg, &lo->plh_segs, pls_list) {
                 if (test_bit(NFS_LSEG_VALID, &lseg->pls_flags) &&
-                    is_matching_lseg(&lseg->pls_range, range)) {
+                    pnfs_lseg_range_match(&lseg->pls_range, range)) {
                         ret = pnfs_get_lseg(lseg);
                         break;
                 }
diff --git a/fs/nfs/pnfs.h b/fs/nfs/pnfs.h
index f5f8a470a647..a4f41810a7f4 100644
--- a/fs/nfs/pnfs.h
+++ b/fs/nfs/pnfs.h
@@ -149,9 +149,10 @@ struct pnfs_device {
         struct nfs4_deviceid dev_id;
         unsigned int  layout_type;
         unsigned int  mincount;
+        unsigned int  maxcount; /* gdia_maxcount */
         struct page **pages;
         unsigned int  pgbase;
-        unsigned int  pglen;
+        unsigned int  pglen;    /* reply buffer length */
 };
 
 #define NFS4_PNFS_GETDEVLIST_MAXNUM 16
@@ -170,7 +171,8 @@ extern int nfs4_proc_getdevicelist(struct nfs_server *server,
                                    const struct nfs_fh *fh,
                                    struct pnfs_devicelist *devlist);
 extern int nfs4_proc_getdeviceinfo(struct nfs_server *server,
-                                   struct pnfs_device *dev);
+                                   struct pnfs_device *dev,
+                                   struct rpc_cred *cred);
 extern struct pnfs_layout_segment* nfs4_proc_layoutget(struct nfs4_layoutget *lgp, gfp_t gfp_flags);
 extern int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp);
 
diff --git a/fs/nfs/proc.c b/fs/nfs/proc.c
index fc8de9016acf..c041c41f7a52 100644
--- a/fs/nfs/proc.c
+++ b/fs/nfs/proc.c
@@ -98,7 +98,7 @@ nfs_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
  */
 static int
 nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
-                struct nfs_fattr *fattr)
+                struct nfs_fattr *fattr, struct nfs4_label *label)
 {
         struct rpc_message msg = {
                 .rpc_proc       = &nfs_procedures[NFSPROC_GETATTR],
@@ -146,7 +146,8 @@ nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
 
 static int
 nfs_proc_lookup(struct inode *dir, struct qstr *name,
-                struct nfs_fh *fhandle, struct nfs_fattr *fattr)
+                struct nfs_fh *fhandle, struct nfs_fattr *fattr,
+                struct nfs4_label *label)
 {
         struct nfs_diropargs    arg = {
                 .fh             = NFS_FH(dir),
@@ -243,7 +244,7 @@ nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
         nfs_mark_for_revalidate(dir);
         if (status == 0)
-                status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
+                status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
         nfs_free_createdata(data);
 out:
         dprintk("NFS reply create: %d\n", status);
@@ -290,7 +291,7 @@ nfs_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
                 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
         }
         if (status == 0)
-                status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
+                status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
         nfs_free_createdata(data);
 out:
         dprintk("NFS reply mknod: %d\n", status);
@@ -442,7 +443,7 @@ nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
          * should fill in the data with a LOOKUP call on the wire.
          */
         if (status == 0)
-                status = nfs_instantiate(dentry, fh, fattr);
+                status = nfs_instantiate(dentry, fh, fattr, NULL);
 
 out_free:
         nfs_free_fattr(fattr);
@@ -471,7 +472,7 @@ nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
         nfs_mark_for_revalidate(dir);
         if (status == 0)
-                status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
+                status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
         nfs_free_createdata(data);
 out:
         dprintk("NFS reply mkdir: %d\n", status);
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index 2d7525fbcf25..71fdc0dfa0d2 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -269,7 +269,7 @@ static match_table_t nfs_local_lock_tokens = {
 
 enum {
         Opt_vers_2, Opt_vers_3, Opt_vers_4, Opt_vers_4_0,
-        Opt_vers_4_1,
+        Opt_vers_4_1, Opt_vers_4_2,
 
         Opt_vers_err
 };
@@ -280,6 +280,7 @@ static match_table_t nfs_vers_tokens = {
         { Opt_vers_4, "4" },
         { Opt_vers_4_0, "4.0" },
         { Opt_vers_4_1, "4.1" },
+        { Opt_vers_4_2, "4.2" },
 
         { Opt_vers_err, NULL }
 };
@@ -832,6 +833,7 @@ int nfs_show_stats(struct seq_file *m, struct dentry *root)
                 seq_printf(m, "\n\tnfsv4:\t");
                 seq_printf(m, "bm0=0x%x", nfss->attr_bitmask[0]);
                 seq_printf(m, ",bm1=0x%x", nfss->attr_bitmask[1]);
+                seq_printf(m, ",bm2=0x%x", nfss->attr_bitmask[2]);
                 seq_printf(m, ",acl=0x%x", nfss->acl_bitmask);
                 show_sessions(m, nfss);
                 show_pnfs(m, nfss);
@@ -1097,6 +1099,10 @@ static int nfs_parse_version_string(char *string,
                 mnt->version = 4;
                 mnt->minorversion = 1;
                 break;
+        case Opt_vers_4_2:
+                mnt->version = 4;
+                mnt->minorversion = 2;
+                break;
         default:
                 return 0;
         }
@@ -1608,29 +1614,13 @@ out_security_failure:
 }
 
 /*
- * Select a security flavor for this mount.  The selected flavor
- * is planted in args->auth_flavors[0].
- *
- * Returns 0 on success, -EACCES on failure.
+ * Ensure that the specified authtype in args->auth_flavors[0] is supported by
+ * the server. Returns 0 if it's ok, and -EACCES if not.
  */
-static int nfs_select_flavor(struct nfs_parsed_mount_data *args,
-                              struct nfs_mount_request *request)
+static int nfs_verify_authflavor(struct nfs_parsed_mount_data *args,
+                        rpc_authflavor_t *server_authlist, unsigned int count)
 {
-        unsigned int i, count = *(request->auth_flav_len);
-        rpc_authflavor_t flavor;
-
-        /*
-         * The NFSv2 MNT operation does not return a flavor list.
-         */
-        if (args->mount_server.version != NFS_MNT3_VERSION)
-                goto out_default;
-
-        /*
-         * Certain releases of Linux's mountd return an empty
-         * flavor list in some cases.
-         */
-        if (count == 0)
-                goto out_default;
+        unsigned int i;
 
         /*
          * If the sec= mount option is used, the specified flavor or AUTH_NULL
@@ -1640,60 +1630,19 @@ static int nfs_select_flavor(struct nfs_parsed_mount_data *args,
          * means that the server will ignore the rpc creds, so any flavor
          * can be used.
          */
-        if (args->auth_flavors[0] != RPC_AUTH_MAXFLAVOR) {
-                for (i = 0; i < count; i++) {
-                        if (args->auth_flavors[0] == request->auth_flavs[i] ||
-                            request->auth_flavs[i] == RPC_AUTH_NULL)
-                                goto out;
-                }
-                dfprintk(MOUNT, "NFS: auth flavor %d not supported by server\n",
-                        args->auth_flavors[0]);
-                goto out_err;
-        }
-
-        /*
-         * RFC 2623, section 2.7 suggests we SHOULD prefer the
-         * flavor listed first.  However, some servers list
-         * AUTH_NULL first.  Avoid ever choosing AUTH_NULL.
-         */
         for (i = 0; i < count; i++) {
-                struct rpcsec_gss_info info;
-
-                flavor = request->auth_flavs[i];
-                switch (flavor) {
-                case RPC_AUTH_UNIX:
-                        goto out_set;
-                case RPC_AUTH_NULL:
-                        continue;
-                default:
-                        if (rpcauth_get_gssinfo(flavor, &info) == 0)
-                                goto out_set;
-                }
+                if (args->auth_flavors[0] == server_authlist[i] ||
+                    server_authlist[i] == RPC_AUTH_NULL)
+                        goto out;
         }
 
-        /*
-         * As a last chance, see if the server list contains AUTH_NULL -
-         * if it does, use the default flavor.
-         */
-        for (i = 0; i < count; i++) {
-                if (request->auth_flavs[i] == RPC_AUTH_NULL)
-                        goto out_default;
-        }
-
-        dfprintk(MOUNT, "NFS: no auth flavors in common with server\n");
-        goto out_err;
+        dfprintk(MOUNT, "NFS: auth flavor %u not supported by server\n",
+                args->auth_flavors[0]);
+        return -EACCES;
 
-out_default:
-        /* use default if flavor not already set */
-        flavor = (args->auth_flavors[0] == RPC_AUTH_MAXFLAVOR) ?
-                RPC_AUTH_UNIX : args->auth_flavors[0];
-out_set:
-        args->auth_flavors[0] = flavor;
 out:
-        dfprintk(MOUNT, "NFS: using auth flavor %d\n", args->auth_flavors[0]);
+        dfprintk(MOUNT, "NFS: using auth flavor %u\n", args->auth_flavors[0]);
         return 0;
-out_err:
-        return -EACCES;
 }
 
 /*
@@ -1701,10 +1650,10 @@ out_err:
  * corresponding to the provided path.
  */
 static int nfs_request_mount(struct nfs_parsed_mount_data *args,
-                             struct nfs_fh *root_fh)
+                             struct nfs_fh *root_fh,
+                             rpc_authflavor_t *server_authlist,
+                             unsigned int *server_authlist_len)
 {
-        rpc_authflavor_t server_authlist[NFS_MAX_SECFLAVORS];
-        unsigned int server_authlist_len = ARRAY_SIZE(server_authlist);
         struct nfs_mount_request request = {
                 .sap            = (struct sockaddr *)
                                                 &args->mount_server.address,
@@ -1712,7 +1661,7 @@ static int nfs_request_mount(struct nfs_parsed_mount_data *args,
                 .protocol       = args->mount_server.protocol,
                 .fh             = root_fh,
                 .noresvport     = args->flags & NFS_MOUNT_NORESVPORT,
-                .auth_flav_len  = &server_authlist_len,
+                .auth_flav_len  = server_authlist_len,
                 .auth_flavs     = server_authlist,
                 .net            = args->net,
         };
@@ -1756,24 +1705,92 @@ static int nfs_request_mount(struct nfs_parsed_mount_data *args,
                 return status;
         }
 
-        return nfs_select_flavor(args, &request);
+        return 0;
 }
 
-struct dentry *nfs_try_mount(int flags, const char *dev_name,
-                             struct nfs_mount_info *mount_info,
-                             struct nfs_subversion *nfs_mod)
+static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_info,
+                                        struct nfs_subversion *nfs_mod)
 {
         int status;
-        struct nfs_server *server;
+        unsigned int i;
+        bool tried_auth_unix = false;
+        bool auth_null_in_list = false;
+        struct nfs_server *server = ERR_PTR(-EACCES);
+        struct nfs_parsed_mount_data *args = mount_info->parsed;
+        rpc_authflavor_t authlist[NFS_MAX_SECFLAVORS];
+        unsigned int authlist_len = ARRAY_SIZE(authlist);
+
+        status = nfs_request_mount(args, mount_info->mntfh, authlist,
+                                        &authlist_len);
+        if (status)
+                return ERR_PTR(status);
 
-        if (mount_info->parsed->need_mount) {
-                status = nfs_request_mount(mount_info->parsed, mount_info->mntfh);
+        /*
+         * Was a sec= authflavor specified in the options? First, verify
+         * whether the server supports it, and then just try to use it if so.
+         */
+        if (args->auth_flavors[0] != RPC_AUTH_MAXFLAVOR) {
+                status = nfs_verify_authflavor(args, authlist, authlist_len);
+                dfprintk(MOUNT, "NFS: using auth flavor %u\n", args->auth_flavors[0]);
                 if (status)
                         return ERR_PTR(status);
+                return nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
+        }
+
+        /*
+         * No sec= option was provided. RFC 2623, section 2.7 suggests we
+         * SHOULD prefer the flavor listed first. However, some servers list
+         * AUTH_NULL first. Avoid ever choosing AUTH_NULL.
+         */
+        for (i = 0; i < authlist_len; ++i) {
+                rpc_authflavor_t flavor;
+                struct rpcsec_gss_info info;
+
+                flavor = authlist[i];
+                switch (flavor) {
+                case RPC_AUTH_UNIX:
+                        tried_auth_unix = true;
+                        break;
+                case RPC_AUTH_NULL:
+                        auth_null_in_list = true;
+                        continue;
+                default:
+                        if (rpcauth_get_gssinfo(flavor, &info) != 0)
+                                continue;
+                        /* Fallthrough */
+                }
+                dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", flavor);
+                args->auth_flavors[0] = flavor;
+                server = nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
+                if (!IS_ERR(server))
+                        return server;
         }
 
-        /* Get a volume representation */
-        server = nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
+        /*
+         * Nothing we tried so far worked. At this point, give up if we've
+         * already tried AUTH_UNIX or if the server's list doesn't contain
+         * AUTH_NULL
+         */
+        if (tried_auth_unix || !auth_null_in_list)
+                return server;
+
+        /* Last chance! Try AUTH_UNIX */
+        dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", RPC_AUTH_UNIX);
+        args->auth_flavors[0] = RPC_AUTH_UNIX;
+        return nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
+}
+
+struct dentry *nfs_try_mount(int flags, const char *dev_name,
+                             struct nfs_mount_info *mount_info,
+                             struct nfs_subversion *nfs_mod)
+{
+        struct nfs_server *server;
+
+        if (mount_info->parsed->need_mount)
+                server = nfs_try_mount_request(mount_info, nfs_mod);
+        else
+                server = nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
+
         if (IS_ERR(server))
                 return ERR_CAST(server);
 
@@ -2412,7 +2429,21 @@ static int nfs_bdi_register(struct nfs_server *server)
 int nfs_set_sb_security(struct super_block *s, struct dentry *mntroot,
                         struct nfs_mount_info *mount_info)
 {
-        return security_sb_set_mnt_opts(s, &mount_info->parsed->lsm_opts);
+        int error;
+        unsigned long kflags = 0, kflags_out = 0;
+        if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL)
+                kflags |= SECURITY_LSM_NATIVE_LABELS;
+
+        error = security_sb_set_mnt_opts(s, &mount_info->parsed->lsm_opts,
+                                                kflags, &kflags_out);
+        if (error)
+                goto err;
+
+        if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL &&
+                !(kflags_out & SECURITY_LSM_NATIVE_LABELS))
+                NFS_SB(s)->caps &= ~NFS_CAP_SECURITY_LABEL;
+err:
+        return error;
 }
 EXPORT_SYMBOL_GPL(nfs_set_sb_security);
 
diff --git a/fs/nfsd/nfsd.h b/fs/nfsd/nfsd.h
index 07a473fd49bc..c0d93170585d 100644
--- a/fs/nfsd/nfsd.h
+++ b/fs/nfsd/nfsd.h
@@ -243,6 +243,12 @@ void		nfsd_lockd_shutdown(void);
 #define nfserr_reject_deleg             cpu_to_be32(NFS4ERR_REJECT_DELEG)
 #define nfserr_returnconflict           cpu_to_be32(NFS4ERR_RETURNCONFLICT)
 #define nfserr_deleg_revoked            cpu_to_be32(NFS4ERR_DELEG_REVOKED)
+#define nfserr_partner_notsupp          cpu_to_be32(NFS4ERR_PARTNER_NOTSUPP)
+#define nfserr_partner_no_auth          cpu_to_be32(NFS4ERR_PARTNER_NO_AUTH)
+#define nfserr_metadata_notsupp         cpu_to_be32(NFS4ERR_METADATA_NOTSUPP)
+#define nfserr_offload_denied           cpu_to_be32(NFS4ERR_OFFLOAD_DENIED)
+#define nfserr_wrong_lfs                cpu_to_be32(NFS4ERR_WRONG_LFS)
+#define nfserr_badlabel         cpu_to_be32(NFS4ERR_BADLABEL)
 
 /* error codes for internal use */
 /* if a request fails due to kmalloc failure, it gets dropped.