7 files changed, 116 insertions, 111 deletions

diff --git a/fs/nfsd/export.c b/fs/nfsd/export.c
index c487810a2366..a0c4016413f1 100644
--- a/fs/nfsd/export.c
+++ b/fs/nfsd/export.c
@@ -1316,19 +1316,11 @@ rqst_exp_parent(struct svc_rqst *rqstp, struct path *path)
 
 static struct svc_export *find_fsidzero_export(struct svc_rqst *rqstp)
 {
-        struct svc_export *exp;
         u32 fsidv[2];
 
         mk_fsid(FSID_NUM, fsidv, 0, 0, 0, NULL);
 
-        exp = rqst_exp_find(rqstp, FSID_NUM, fsidv);
-        /*
-         * We shouldn't have accepting an nfsv4 request at all if we
-         * don't have a pseudoexport!:
-         */
-        if (IS_ERR(exp) && PTR_ERR(exp) == -ENOENT)
-                exp = ERR_PTR(-ESERVERFAULT);
-        return exp;
+        return rqst_exp_find(rqstp, FSID_NUM, fsidv);
 }
 
 /*
diff --git a/fs/nfsd/nfs4callback.c b/fs/nfsd/nfs4callback.c
index c6eed2a3b093..4bc22c763de7 100644
--- a/fs/nfsd/nfs4callback.c
+++ b/fs/nfsd/nfs4callback.c
@@ -525,6 +525,8 @@ static struct rpc_cred *callback_cred;
 
 int set_callback_cred(void)
 {
+        if (callback_cred)
+                return 0;
         callback_cred = rpc_lookup_machine_cred();
         if (!callback_cred)
                 return -ENOMEM;
@@ -542,7 +544,8 @@ void do_probe_callback(struct nfs4_client *clp)
         };
         int status;
 
-        status = rpc_call_async(cb->cb_client, &msg, RPC_TASK_SOFT,
+        status = rpc_call_async(cb->cb_client, &msg,
+                                RPC_TASK_SOFT | RPC_TASK_SOFTCONN,
                                 &nfsd4_cb_probe_ops, (void *)clp);
         if (status) {
                 warn_no_callback_path(clp, status);
diff --git a/fs/nfsd/nfs4recover.c b/fs/nfsd/nfs4recover.c
index 5a754f7b71ed..98fb98e330b4 100644
--- a/fs/nfsd/nfs4recover.c
+++ b/fs/nfsd/nfs4recover.c
@@ -119,9 +119,7 @@ out_no_tfm:
 static void
 nfsd4_sync_rec_dir(void)
 {
-        mutex_lock(&rec_dir.dentry->d_inode->i_mutex);
-        nfsd_sync_dir(rec_dir.dentry);
-        mutex_unlock(&rec_dir.dentry->d_inode->i_mutex);
+        vfs_fsync(NULL, rec_dir.dentry, 0);
 }
 
 int
diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index f19ed866c95f..c97fddbd17db 100644
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -1998,7 +1998,9 @@ nfs4_file_downgrade(struct file *filp, unsigned int share_access)
 {
         if (share_access & NFS4_SHARE_ACCESS_WRITE) {
                 drop_file_write_access(filp);
+                spin_lock(&filp->f_lock);
                 filp->f_mode = (filp->f_mode | FMODE_READ) & ~FMODE_WRITE;
+                spin_unlock(&filp->f_lock);
         }
 }
 
@@ -2480,8 +2482,10 @@ nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nf
         }
         memcpy(&open->op_stateid, &stp->st_stateid, sizeof(stateid_t));
 
-        if (nfsd4_has_session(&resp->cstate))
+        if (nfsd4_has_session(&resp->cstate)) {
                 open->op_stateowner->so_confirmed = 1;
+                nfsd4_create_clid_dir(open->op_stateowner->so_client);
+        }
 
         /*
         * Attempt to hand out a delegation. No error return, because the
diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index 143d43a93b72..c47b4d7bafa7 100644
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -1434,7 +1434,7 @@ nfsd4_decode_compound(struct nfsd4_compoundargs *argp)
                 }
                 op->opnum = ntohl(*argp->p++);
 
-                if (op->opnum >= OP_ACCESS && op->opnum < ops->nops)
+                if (op->opnum >= FIRST_NFS4_OP && op->opnum <= LAST_NFS4_OP)
                         op->status = ops->decoders[op->opnum](argp, &op->u);
                 else {
                         op->opnum = OP_ILLEGAL;
@@ -2121,9 +2121,15 @@ out_acl:
                  * and this is the root of a cross-mounted filesystem.
                  */
                 if (ignore_crossmnt == 0 &&
-                    exp->ex_path.mnt->mnt_root->d_inode == dentry->d_inode) {
-                        err = vfs_getattr(exp->ex_path.mnt->mnt_parent,
-                                exp->ex_path.mnt->mnt_mountpoint, &stat);
+                    dentry == exp->ex_path.mnt->mnt_root) {
+                        struct path path = exp->ex_path;
+                        path_get(&path);
+                        while (follow_up(&path)) {
+                                if (path.dentry != path.mnt->mnt_root)
+                                        break;
+                        }
+                        err = vfs_getattr(path.mnt, path.dentry, &stat);
+                        path_put(&path);
                         if (err)
                                 goto out_nfserr;
                 }
diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c
index 2604c3e70ea5..0f0e77f2012f 100644
--- a/fs/nfsd/nfsctl.c
+++ b/fs/nfsd/nfsctl.c
@@ -988,6 +988,7 @@ static ssize_t __write_ports_delfd(char *buf)
 static ssize_t __write_ports_addxprt(char *buf)
 {
         char transport[16];
+        struct svc_xprt *xprt;
         int port, err;
 
         if (sscanf(buf, "%15s %4u", transport, &port) != 2)
@@ -1002,13 +1003,24 @@ static ssize_t __write_ports_addxprt(char *buf)
 
         err = svc_create_xprt(nfsd_serv, transport,
                                 PF_INET, port, SVC_SOCK_ANONYMOUS);
-        if (err < 0) {
-                /* Give a reasonable perror msg for bad transport string */
-                if (err == -ENOENT)
-                        err = -EPROTONOSUPPORT;
-                return err;
-        }
+        if (err < 0)
+                goto out_err;
+
+        err = svc_create_xprt(nfsd_serv, transport,
+                                PF_INET6, port, SVC_SOCK_ANONYMOUS);
+        if (err < 0 && err != -EAFNOSUPPORT)
+                goto out_close;
         return 0;
+out_close:
+        xprt = svc_find_xprt(nfsd_serv, transport, PF_INET, port);
+        if (xprt != NULL) {
+                svc_close_xprt(xprt);
+                svc_xprt_put(xprt);
+        }
+out_err:
+        /* Decrease the count, but don't shut down the service */
+        nfsd_serv->sv_nrthreads--;
+        return err;
 }
 
 /*
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index c194793b642b..a11b0e8678ee 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -20,13 +20,14 @@
 #include <linux/fcntl.h>
 #include <linux/namei.h>
 #include <linux/delay.h>
-#include <linux/quotaops.h>
 #include <linux/fsnotify.h>
 #include <linux/posix_acl_xattr.h>
 #include <linux/xattr.h>
 #include <linux/jhash.h>
 #include <linux/ima.h>
 #include <asm/uaccess.h>
+#include <linux/exportfs.h>
+#include <linux/writeback.h>
 
 #ifdef CONFIG_NFSD_V3
 #include "xdr3.h"
@@ -271,6 +272,32 @@ out:
         return err;
 }
 
+/*
+ * Commit metadata changes to stable storage.
+ */
+static int
+commit_metadata(struct svc_fh *fhp)
+{
+        struct inode *inode = fhp->fh_dentry->d_inode;
+        const struct export_operations *export_ops = inode->i_sb->s_export_op;
+        int error = 0;
+
+        if (!EX_ISSYNC(fhp->fh_export))
+                return 0;
+
+        if (export_ops->commit_metadata) {
+                error = export_ops->commit_metadata(inode);
+        } else {
+                struct writeback_control wbc = {
+                        .sync_mode = WB_SYNC_ALL,
+                        .nr_to_write = 0, /* metadata only */
+                };
+
+                error = sync_inode(inode, &wbc);
+        }
+
+        return error;
+}
 
 /*
  * Set various file attributes.
@@ -361,7 +388,7 @@ nfsd_setattr(struct svc_rqst *rqstp, struct svc_fh *fhp, struct iattr *iap,
                  * If we are changing the size of the file, then
                  * we need to break all leases.
                  */
-                host_err = break_lease(inode, FMODE_WRITE | O_NONBLOCK);
+                host_err = break_lease(inode, O_WRONLY | O_NONBLOCK);
                 if (host_err == -EWOULDBLOCK)
                         host_err = -ETIMEDOUT;
                 if (host_err) /* ENOMEM or EWOULDBLOCK */
@@ -377,7 +404,6 @@ nfsd_setattr(struct svc_rqst *rqstp, struct svc_fh *fhp, struct iattr *iap,
                         put_write_access(inode);
                         goto out_nfserr;
                 }
-                vfs_dq_init(inode);
         }
 
         /* sanitize the mode change */
@@ -734,7 +760,7 @@ nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
          * Check to see if there are any leases on this file.
          * This may block while leases are broken.
          */
-        host_err = break_lease(inode, O_NONBLOCK | ((access & NFSD_MAY_WRITE) ? FMODE_WRITE : 0));
+        host_err = break_lease(inode, O_NONBLOCK | ((access & NFSD_MAY_WRITE) ? O_WRONLY : 0));
         if (host_err == -EWOULDBLOCK)
                 host_err = -ETIMEDOUT;
         if (host_err) /* NOMEM or WOULDBLOCK */
@@ -745,13 +771,13 @@ nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
                         flags = O_RDWR|O_LARGEFILE;
                 else
                         flags = O_WRONLY|O_LARGEFILE;
-
-                vfs_dq_init(inode);
         }
         *filp = dentry_open(dget(dentry), mntget(fhp->fh_export->ex_path.mnt),
                             flags, current_cred());
         if (IS_ERR(*filp))
                 host_err = PTR_ERR(*filp);
+        else
+                host_err = ima_file_check(*filp, access);
 out_nfserr:
         err = nfserrno(host_err);
 out:
@@ -769,43 +795,6 @@ nfsd_close(struct file *filp)
 }
 
 /*
- * Sync a file
- * As this calls fsync (not fdatasync) there is no need for a write_inode
- * after it.
- */
-static inline int nfsd_dosync(struct file *filp, struct dentry *dp,
-                              const struct file_operations *fop)
-{
-        struct inode *inode = dp->d_inode;
-        int (*fsync) (struct file *, struct dentry *, int);
-        int err;
-
-        err = filemap_write_and_wait(inode->i_mapping);
-        if (err == 0 && fop && (fsync = fop->fsync))
-                err = fsync(filp, dp, 0);
-        return err;
-}
-
-static int
-nfsd_sync(struct file *filp)
-{
-        int err;
-        struct inode *inode = filp->f_path.dentry->d_inode;
-        dprintk("nfsd: sync file %s\n", filp->f_path.dentry->d_name.name);
-        mutex_lock(&inode->i_mutex);
-        err=nfsd_dosync(filp, filp->f_path.dentry, filp->f_op);
-        mutex_unlock(&inode->i_mutex);
-
-        return err;
-}
-
-int
-nfsd_sync_dir(struct dentry *dp)
-{
-        return nfsd_dosync(NULL, dp, dp->d_inode->i_fop);
-}
-
-/*
  * Obtain the readahead parameters for the file
  * specified by (dev, ino).
  */
@@ -1008,7 +997,7 @@ static int wait_for_concurrent_writes(struct file *file)
 
         if (inode->i_state & I_DIRTY) {
                 dprintk("nfsd: write sync %d\n", task_pid_nr(current));
-                err = nfsd_sync(file);
+                err = vfs_fsync(file, file->f_path.dentry, 0);
         }
         last_ino = inode->i_ino;
         last_dev = inode->i_sb->s_dev;
@@ -1156,8 +1145,9 @@ out:
 #ifdef CONFIG_NFSD_V3
 /*
  * Commit all pending writes to stable storage.
- * Strictly speaking, we could sync just the indicated file region here,
- * but there's currently no way we can ask the VFS to do so.
+ *
+ * Note: we only guarantee that data that lies within the range specified
+ * by the 'offset' and 'count' parameters will be synced.
  *
  * Unfortunately we cannot lock the file to make sure we return full WCC
  * data to the client, as locking happens lower down in the filesystem.
@@ -1167,23 +1157,32 @@ nfsd_commit(struct svc_rqst *rqstp, struct svc_fh *fhp,
                loff_t offset, unsigned long count)
 {
         struct file     *file;
-        __be32          err;
+        loff_t          end = LLONG_MAX;
+        __be32          err = nfserr_inval;
 
-        if ((u64)count > ~(u64)offset)
-                return nfserr_inval;
+        if (offset < 0)
+                goto out;
+        if (count != 0) {
+                end = offset + (loff_t)count - 1;
+                if (end < offset)
+                        goto out;
+        }
 
         err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_WRITE, &file);
         if (err)
-                return err;
+                goto out;
         if (EX_ISSYNC(fhp->fh_export)) {
-                if (file->f_op && file->f_op->fsync) {
-                        err = nfserrno(nfsd_sync(file));
-                } else {
+                int err2 = vfs_fsync_range(file, file->f_path.dentry,
+                                offset, end, 0);
+
+                if (err2 != -EINVAL)
+                        err = nfserrno(err2);
+                else
                         err = nfserr_notsupp;
-                }
         }
 
         nfsd_close(file);
+out:
         return err;
 }
 #endif /* CONFIG_NFSD_V3 */
@@ -1336,12 +1335,14 @@ nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 goto out_nfserr;
         }
 
-        if (EX_ISSYNC(fhp->fh_export)) {
-                err = nfserrno(nfsd_sync_dir(dentry));
-                write_inode_now(dchild->d_inode, 1);
-        }
+        err = nfsd_create_setattr(rqstp, resfhp, iap);
 
-        err2 = nfsd_create_setattr(rqstp, resfhp, iap);
+        /*
+         * nfsd_setattr already committed the child.  Transactional filesystems
+         * had a chance to commit changes for both parent and child
+         * simultaneously making the following commit_metadata a noop.
+         */
+        err2 = nfserrno(commit_metadata(fhp));
         if (err2)
                 err = err2;
         mnt_drop_write(fhp->fh_export->ex_path.mnt);
@@ -1373,7 +1374,6 @@ nfsd_create_v3(struct svc_rqst *rqstp, struct svc_fh *fhp,
         struct dentry   *dentry, *dchild = NULL;
         struct inode    *dirp;
         __be32          err;
-        __be32          err2;
         int             host_err;
         __u32           v_mtime=0, v_atime=0;
 
@@ -1468,11 +1468,6 @@ nfsd_create_v3(struct svc_rqst *rqstp, struct svc_fh *fhp,
         if (created)
                 *created = 1;
 
-        if (EX_ISSYNC(fhp->fh_export)) {
-                err = nfserrno(nfsd_sync_dir(dentry));
-                /* setattr will sync the child (or not) */
-        }
-
         nfsd_check_ignore_resizing(iap);
 
         if (createmode == NFS3_CREATE_EXCLUSIVE) {
@@ -1487,9 +1482,13 @@ nfsd_create_v3(struct svc_rqst *rqstp, struct svc_fh *fhp,
         }
 
  set_attr:
-        err2 = nfsd_create_setattr(rqstp, resfhp, iap);
-        if (err2)
-                err = err2;
+        err = nfsd_create_setattr(rqstp, resfhp, iap);
+
+        /*
+         * nfsd_setattr already committed the child (and possibly also the parent).
+         */
+        if (!err)
+                err = nfserrno(commit_metadata(fhp));
 
         mnt_drop_write(fhp->fh_export->ex_path.mnt);
         /*
@@ -1604,12 +1603,9 @@ nfsd_symlink(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 }
         } else
                 host_err = vfs_symlink(dentry->d_inode, dnew, path);
-
-        if (!host_err) {
-                if (EX_ISSYNC(fhp->fh_export))
-                        host_err = nfsd_sync_dir(dentry);
-        }
         err = nfserrno(host_err);
+        if (!err)
+                err = nfserrno(commit_metadata(fhp));
         fh_unlock(fhp);
 
         mnt_drop_write(fhp->fh_export->ex_path.mnt);
@@ -1671,11 +1667,9 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,
         }
         host_err = vfs_link(dold, dirp, dnew);
         if (!host_err) {
-                if (EX_ISSYNC(ffhp->fh_export)) {
-                        err = nfserrno(nfsd_sync_dir(ddir));
-                        write_inode_now(dest, 1);
-                }
-                err = 0;
+                err = nfserrno(commit_metadata(ffhp));
+                if (!err)
+                        err = nfserrno(commit_metadata(tfhp));
         } else {
                 if (host_err == -EXDEV && rqstp->rq_vers == 2)
                         err = nfserr_acces;
@@ -1771,10 +1765,10 @@ nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,
                 goto out_dput_new;
 
         host_err = vfs_rename(fdir, odentry, tdir, ndentry);
-        if (!host_err && EX_ISSYNC(tfhp->fh_export)) {
-                host_err = nfsd_sync_dir(tdentry);
+        if (!host_err) {
+                host_err = commit_metadata(tfhp);
                 if (!host_err)
-                        host_err = nfsd_sync_dir(fdentry);
+                        host_err = commit_metadata(ffhp);
         }
 
         mnt_drop_write(ffhp->fh_export->ex_path.mnt);
@@ -1855,12 +1849,9 @@ nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
 
         dput(rdentry);
 
-        if (host_err)
-                goto out_drop;
-        if (EX_ISSYNC(fhp->fh_export))
-                host_err = nfsd_sync_dir(dentry);
+        if (!host_err)
+                host_err = commit_metadata(fhp);
 
-out_drop:
         mnt_drop_write(fhp->fh_export->ex_path.mnt);
 out_nfserr:
         err = nfserrno(host_err);
@@ -2127,7 +2118,6 @@ nfsd_permission(struct svc_rqst *rqstp, struct svc_export *exp,
          */
         path.mnt = exp->ex_path.mnt;
         path.dentry = dentry;
-        err = ima_path_check(&path, acc & (MAY_READ | MAY_WRITE | MAY_EXEC));
 nfsd_out:
         return err? nfserrno(err) : 0;
 }