12 files changed, 99 insertions, 18 deletions

diff --git a/fs/nfs/callback.c b/fs/nfs/callback.c
index ecc06c619494..66648dd92d97 100644
--- a/fs/nfs/callback.c
+++ b/fs/nfs/callback.c
@@ -93,6 +93,7 @@ static void nfs_callback_svc(struct svc_rqst *rqstp)
                 svc_process(rqstp);
         }
 
+        flush_signals(current);
         svc_exit_thread(rqstp);
         nfs_callback_info.pid = 0;
         complete(&nfs_callback_info.stopped);
@@ -171,7 +172,7 @@ void nfs_callback_down(void)
 static int nfs_callback_authenticate(struct svc_rqst *rqstp)
 {
         struct nfs_client *clp;
-        char buf[RPC_MAX_ADDRBUFLEN];
+        RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
 
         /* Don't talk to strangers */
         clp = nfs_find_client(svc_addr(rqstp), 4);
diff --git a/fs/nfs/callback_xdr.c b/fs/nfs/callback_xdr.c
index c63eb720b68b..13619d24f023 100644
--- a/fs/nfs/callback_xdr.c
+++ b/fs/nfs/callback_xdr.c
@@ -254,7 +254,7 @@ static __be32 encode_attr_change(struct xdr_stream *xdr, const uint32_t *bitmap,
         if (!(bitmap[0] & FATTR4_WORD0_CHANGE))
                 return 0;
         p = xdr_reserve_space(xdr, 8);
-        if (unlikely(p == 0))
+        if (unlikely(!p))
                 return htonl(NFS4ERR_RESOURCE);
         p = xdr_encode_hyper(p, change);
         return 0;
@@ -267,7 +267,7 @@ static __be32 encode_attr_size(struct xdr_stream *xdr, const uint32_t *bitmap, u
         if (!(bitmap[0] & FATTR4_WORD0_SIZE))
                 return 0;
         p = xdr_reserve_space(xdr, 8);
-        if (unlikely(p == 0))
+        if (unlikely(!p))
                 return htonl(NFS4ERR_RESOURCE);
         p = xdr_encode_hyper(p, size);
         return 0;
@@ -278,7 +278,7 @@ static __be32 encode_attr_time(struct xdr_stream *xdr, const struct timespec *ti
         __be32 *p;
 
         p = xdr_reserve_space(xdr, 12);
-        if (unlikely(p == 0))
+        if (unlikely(!p))
                 return htonl(NFS4ERR_RESOURCE);
         p = xdr_encode_hyper(p, time->tv_sec);
         *p = htonl(time->tv_nsec);
diff --git a/fs/nfs/delegation.c b/fs/nfs/delegation.c
index b9eadd18ba70..00a5e4405e16 100644
--- a/fs/nfs/delegation.c
+++ b/fs/nfs/delegation.c
@@ -49,7 +49,7 @@ static int nfs_delegation_claim_locks(struct nfs_open_context *ctx, struct nfs4_
         struct file_lock *fl;
         int status;
 
-        for (fl = inode->i_flock; fl != 0; fl = fl->fl_next) {
+        for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
                 if (!(fl->fl_flags & (FL_POSIX|FL_FLOCK)))
                         continue;
                 if (nfs_file_open_context(fl->fl_file) != ctx)
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index ae04892a5e5d..d9e30ac2798d 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -710,6 +710,8 @@ int nfs_lookup_verify_inode(struct inode *inode, struct nameidata *nd)
 {
         struct nfs_server *server = NFS_SERVER(inode);
 
+        if (test_bit(NFS_INO_MOUNTPOINT, &NFS_I(inode)->flags))
+                return 0;
         if (nd != NULL) {
                 /* VFS wants an on-the-wire revalidation */
                 if (nd->flags & LOOKUP_REVAL)
@@ -965,7 +967,8 @@ static int is_atomic_open(struct inode *dir, struct nameidata *nd)
         if (nd->flags & LOOKUP_DIRECTORY)
                 return 0;
         /* Are we trying to write to a read only partition? */
-        if (IS_RDONLY(dir) && (nd->intent.open.flags & (O_CREAT|O_TRUNC|FMODE_WRITE)))
+        if (__mnt_is_readonly(nd->path.mnt) &&
+            (nd->intent.open.flags & (O_CREAT|O_TRUNC|FMODE_WRITE)))
                 return 0;
         return 1;
 }
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index ef57a5ae5904..5d2e9d9a4e28 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -64,7 +64,11 @@ const struct file_operations nfs_file_operations = {
         .write          = do_sync_write,
         .aio_read       = nfs_file_read,
         .aio_write      = nfs_file_write,
+#ifdef CONFIG_MMU
         .mmap           = nfs_file_mmap,
+#else
+        .mmap           = generic_file_mmap,
+#endif
         .open           = nfs_file_open,
         .flush          = nfs_file_flush,
         .release        = nfs_file_release,
diff --git a/fs/nfs/idmap.c b/fs/nfs/idmap.c
index 8ae5dba2d4e5..86147b0ab2cf 100644
--- a/fs/nfs/idmap.c
+++ b/fs/nfs/idmap.c
@@ -309,7 +309,7 @@ nfs_idmap_name(struct idmap *idmap, struct idmap_hashtable *h,
         mutex_lock(&idmap->idmap_im_lock);
 
         he = idmap_lookup_id(h, id);
-        if (he != 0) {
+        if (he) {
                 memcpy(name, he->ih_name, he->ih_namelen);
                 ret = he->ih_namelen;
                 goto out;
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 966a8850aa30..6f88d7c77ac9 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -299,6 +299,7 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
                                 else
                                         inode->i_op = &nfs_mountpoint_inode_operations;
                                 inode->i_fop = NULL;
+                                set_bit(NFS_INO_MOUNTPOINT, &nfsi->flags);
                         }
                 } else if (S_ISLNK(inode->i_mode))
                         inode->i_op = &nfs_symlink_inode_operations;
@@ -505,6 +506,7 @@ static struct nfs_open_context *alloc_nfs_open_context(struct vfsmount *mnt, str
                 ctx->cred = get_rpccred(cred);
                 ctx->state = NULL;
                 ctx->lockowner = current->files;
+                ctx->flags = 0;
                 ctx->error = 0;
                 ctx->dir_cookie = 0;
                 atomic_set(&ctx->count, 1);
@@ -1003,8 +1005,9 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
 
         server = NFS_SERVER(inode);
         /* Update the fsid? */
-        if (S_ISDIR(inode->i_mode)
-                        && !nfs_fsid_equal(&server->fsid, &fattr->fsid))
+        if (S_ISDIR(inode->i_mode) &&
+                        !nfs_fsid_equal(&server->fsid, &fattr->fsid) &&
+                        !test_bit(NFS_INO_MOUNTPOINT, &nfsi->flags))
                 server->fsid = fattr->fsid;
 
         /*
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index 0f5619611b8d..931992763e68 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -3,6 +3,7 @@
  */
 
 #include <linux/mount.h>
+#include <linux/security.h>
 
 struct nfs_string;
 
@@ -57,6 +58,8 @@ struct nfs_parsed_mount_data {
                 char                    *export_path;
                 int                     protocol;
         } nfs_server;
+
+        struct security_mnt_opts lsm_opts;
 };
 
 /* client.c */
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 6233eb5e98c1..b962397004c1 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -785,7 +785,7 @@ static int nfs4_reclaim_locks(struct nfs4_state_recovery_ops *ops, struct nfs4_s
         struct file_lock *fl;
         int status = 0;
 
-        for (fl = inode->i_flock; fl != 0; fl = fl->fl_next) {
+        for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
                 if (!(fl->fl_flags & (FL_POSIX|FL_FLOCK)))
                         continue;
                 if (nfs_file_open_context(fl->fl_file)->state != state)
diff --git a/fs/nfs/read.c b/fs/nfs/read.c
index 3d7d9631e125..5a70be589bbe 100644
--- a/fs/nfs/read.c
+++ b/fs/nfs/read.c
@@ -533,7 +533,10 @@ readpage_async_filler(void *data, struct page *page)
 
         if (len < PAGE_CACHE_SIZE)
                 zero_user_segment(page, len, PAGE_CACHE_SIZE);
-        nfs_pageio_add_request(desc->pgio, new);
+        if (!nfs_pageio_add_request(desc->pgio, new)) {
+                error = desc->pgio->pg_error;
+                goto out_unlock;
+        }
         return 0;
 out_error:
         error = PTR_ERR(new);
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index 1fb381843650..f9219024f31a 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -589,8 +589,6 @@ static void nfs_umount_begin(struct vfsmount *vfsmnt, int flags)
         struct nfs_server *server = NFS_SB(vfsmnt->mnt_sb);
         struct rpc_clnt *rpc;
 
-        shrink_submounts(vfsmnt, &nfs_automount_list);
-
         if (!(flags & MNT_FORCE))
                 return;
         /* -EIO all pending I/O */
@@ -632,7 +630,7 @@ static int nfs_verify_server_address(struct sockaddr *addr)
         switch (addr->sa_family) {
         case AF_INET: {
                 struct sockaddr_in *sa = (struct sockaddr_in *)addr;
-                return sa->sin_addr.s_addr != INADDR_ANY;
+                return sa->sin_addr.s_addr != htonl(INADDR_ANY);
         }
         case AF_INET6: {
                 struct in6_addr *sa = &((struct sockaddr_in6 *)addr)->sin6_addr;
@@ -684,8 +682,9 @@ static void nfs_parse_server_address(char *value,
 static int nfs_parse_mount_options(char *raw,
                                    struct nfs_parsed_mount_data *mnt)
 {
-        char *p, *string;
+        char *p, *string, *secdata;
         unsigned short port = 0;
+        int rc;
 
         if (!raw) {
                 dfprintk(MOUNT, "NFS: mount options string was NULL.\n");
@@ -693,6 +692,20 @@ static int nfs_parse_mount_options(char *raw,
         }
         dfprintk(MOUNT, "NFS: nfs mount opts='%s'\n", raw);
 
+        secdata = alloc_secdata();
+        if (!secdata)
+                goto out_nomem;
+
+        rc = security_sb_copy_data(raw, secdata);
+        if (rc)
+                goto out_security_failure;
+
+        rc = security_sb_parse_opts_str(secdata, &mnt->lsm_opts);
+        if (rc)
+                goto out_security_failure;
+
+        free_secdata(secdata);
+
         while ((p = strsep(&raw, ",")) != NULL) {
                 substring_t args[MAX_OPT_ARGS];
                 int option, token;
@@ -1042,7 +1055,10 @@ static int nfs_parse_mount_options(char *raw,
 out_nomem:
         printk(KERN_INFO "NFS: not enough memory to parse option\n");
         return 0;
-
+out_security_failure:
+        free_secdata(secdata);
+        printk(KERN_INFO "NFS: security options invalid: %d\n", rc);
+        return 0;
 out_unrec_vers:
         printk(KERN_INFO "NFS: unrecognized NFS version number\n");
         return 0;
@@ -1214,6 +1230,33 @@ static int nfs_validate_mount_data(void *options,
                 args->namlen            = data->namlen;
                 args->bsize             = data->bsize;
                 args->auth_flavors[0]   = data->pseudoflavor;
+
+                /*
+                 * The legacy version 6 binary mount data from userspace has a
+                 * field used only to transport selinux information into the
+                 * the kernel.  To continue to support that functionality we
+                 * have a touch of selinux knowledge here in the NFS code. The
+                 * userspace code converted context=blah to just blah so we are
+                 * converting back to the full string selinux understands.
+                 */
+                if (data->context[0]){
+#ifdef CONFIG_SECURITY_SELINUX
+                        int rc;
+                        char *opts_str = kmalloc(sizeof(data->context) + 8, GFP_KERNEL);
+                        if (!opts_str)
+                                return -ENOMEM;
+                        strcpy(opts_str, "context=");
+                        data->context[NFS_MAX_CONTEXT_LEN] = '\0';
+                        strcat(opts_str, &data->context[0]);
+                        rc = security_sb_parse_opts_str(opts_str, &args->lsm_opts);
+                        kfree(opts_str);
+                        if (rc)
+                                return rc;
+#else
+                        return -EINVAL;
+#endif
+                }
+
                 break;
         default: {
                 unsigned int len;
@@ -1476,6 +1519,8 @@ static int nfs_get_sb(struct file_system_type *fs_type,
         };
         int error;
 
+        security_init_mnt_opts(&data.lsm_opts);
+
         /* Validate the mount data */
         error = nfs_validate_mount_data(raw_data, &data, &mntfh, dev_name);
         if (error < 0)
@@ -1515,6 +1560,10 @@ static int nfs_get_sb(struct file_system_type *fs_type,
                 goto error_splat_super;
         }
 
+        error = security_sb_set_mnt_opts(s, &data.lsm_opts);
+        if (error)
+                goto error_splat_root;
+
         s->s_flags |= MS_ACTIVE;
         mnt->mnt_sb = s;
         mnt->mnt_root = mntroot;
@@ -1523,12 +1572,15 @@ static int nfs_get_sb(struct file_system_type *fs_type,
 out:
         kfree(data.nfs_server.hostname);
         kfree(data.mount_server.hostname);
+        security_free_mnt_opts(&data.lsm_opts);
         return error;
 
 out_err_nosb:
         nfs_free_server(server);
         goto out;
 
+error_splat_root:
+        dput(mntroot);
 error_splat_super:
         up_write(&s->s_umount);
         deactivate_super(s);
@@ -1608,6 +1660,9 @@ static int nfs_xdev_get_sb(struct file_system_type *fs_type, int flags,
         mnt->mnt_sb = s;
         mnt->mnt_root = mntroot;
 
+        /* clone any lsm security options from the parent to the new sb */
+        security_sb_clone_mnt_opts(data->sb, s);
+
         dprintk("<-- nfs_xdev_get_sb() = 0\n");
         return 0;
 
@@ -1850,6 +1905,8 @@ static int nfs4_get_sb(struct file_system_type *fs_type,
         };
         int error;
 
+        security_init_mnt_opts(&data.lsm_opts);
+
         /* Validate the mount data */
         error = nfs4_validate_mount_data(raw_data, &data, dev_name);
         if (error < 0)
@@ -1898,6 +1955,7 @@ out:
         kfree(data.client_address);
         kfree(data.nfs_server.export_path);
         kfree(data.nfs_server.hostname);
+        security_free_mnt_opts(&data.lsm_opts);
         return error;
 
 out_free:
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index f55c437124a2..bed63416a55b 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -39,6 +39,7 @@ static struct nfs_page * nfs_update_request(struct nfs_open_context*,
                                             unsigned int, unsigned int);
 static void nfs_pageio_init_write(struct nfs_pageio_descriptor *desc,
                                   struct inode *inode, int ioflags);
+static void nfs_redirty_request(struct nfs_page *req);
 static const struct rpc_call_ops nfs_write_partial_ops;
 static const struct rpc_call_ops nfs_write_full_ops;
 static const struct rpc_call_ops nfs_commit_ops;
@@ -288,7 +289,12 @@ static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio,
                 BUG();
         }
         spin_unlock(&inode->i_lock);
-        nfs_pageio_add_request(pgio, req);
+        if (!nfs_pageio_add_request(pgio, req)) {
+                nfs_redirty_request(req);
+                nfs_end_page_writeback(page);
+                nfs_clear_page_tag_locked(req);
+                return pgio->pg_error;
+        }
         return 0;
 }
 
@@ -734,7 +740,7 @@ int nfs_updatepage(struct file *file, struct page *page,
          */
         if (nfs_write_pageuptodate(page, inode) &&
                         inode->i_flock == NULL &&
-                        !(file->f_mode & O_SYNC)) {
+                        !(file->f_flags & O_SYNC)) {
                 count = max(count + offset, nfs_page_length(page));
                 offset = 0;
         }