Merge branch 'for-3.4' of git://linux-nfs.org/~bfields/linux

Pull nfsd changes from Bruce Fields:

Highlights:
 - Benny Halevy and Tigran Mkrtchyan implemented some more 4.1 features,
   moving us closer to a complete 4.1 implementation.
 - Bernd Schubert fixed a long-standing problem with readdir cookies on
   ext2/3/4.
 - Jeff Layton performed a long-overdue overhaul of the server reboot
   recovery code which will allow us to deprecate the current code (a
   rather unusual user of the vfs), and give us some needed flexibility
   for further improvements.
 - Like the client, we now support numeric uid's and gid's in the
   auth_sys case, allowing easier upgrades from NFSv2/v3 to v4.x.

Plus miscellaneous bugfixes and cleanup.

Thanks to everyone!

There are also some delegation fixes waiting on vfs review that I
suppose will have to wait for 3.5.  With that done I think we'll finally
turn off the "EXPERIMENTAL" dependency for v4 (though that's mostly
symbolic as it's been on by default in distro's for a while).

And the list of 4.1 todo's should be achievable for 3.5 as well:

   http://wiki.linux-nfs.org/wiki/index.php/Server_4.0_and_4.1_issues

though we may still want a bit more experience with it before turning it
on by default.

* 'for-3.4' of git://linux-nfs.org/~bfields/linux: (55 commits)
  nfsd: only register cld pipe notifier when CONFIG_NFSD_V4 is enabled
  nfsd4: use auth_unix unconditionally on backchannel
  nfsd: fix NULL pointer dereference in cld_pipe_downcall
  nfsd4: memory corruption in numeric_name_to_id()
  sunrpc: skip portmap calls on sessions backchannel
  nfsd4: allow numeric idmapping
  nfsd: don't allow legacy client tracker init for anything but init_net
  nfsd: add notifier to handle mount/unmount of rpc_pipefs sb
  nfsd: add the infrastructure to handle the cld upcall
  nfsd: add a header describing upcall to nfsdcld
  nfsd: add a per-net-namespace struct for nfsd
  sunrpc: create nfsd dir in rpc_pipefs
  nfsd: add nfsd4_client_tracking_ops struct and a way to set it
  nfsd: convert nfs4_client->cl_cb_flags to a generic flags field
  NFSD: Fix nfs4_verifier memory alignment
  NFSD: Fix warnings when NFSD_DEBUG is not defined
  nfsd: vfs_llseek() with 32 or 64 bit offsets (hashes)
  nfsd: rename 'int access' to 'int may_flags' in nfsd_open()
  ext4: return 32/64-bit dir name hash according to usage type
  fs: add new FMODE flags: FMODE_32bithash and FMODE_64bithash
  ...

1 files changed, 83 insertions, 35 deletions

diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c
index 896da74ec563..2ed14dfd00a2 100644
--- a/fs/nfsd/nfs4proc.c
+++ b/fs/nfsd/nfs4proc.c
@@ -39,6 +39,7 @@
 #include "cache.h"
 #include "xdr4.h"
 #include "vfs.h"
+#include "current_stateid.h"
 
 #define NFSDDBG_FACILITY                NFSDDBG_PROC
 
@@ -192,10 +193,13 @@ static __be32 nfsd_check_obj_isreg(struct svc_fh *fh)
 static __be32
 do_open_lookup(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
 {
-        struct svc_fh resfh;
+        struct svc_fh *resfh;
         __be32 status;
 
-        fh_init(&resfh, NFS4_FHSIZE);
+        resfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL);
+        if (!resfh)
+                return nfserr_jukebox;
+        fh_init(resfh, NFS4_FHSIZE);
         open->op_truncate = 0;
 
         if (open->op_create) {
@@ -220,7 +224,7 @@ do_open_lookup(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_o
                  */
                 status = do_nfsd_create(rqstp, current_fh, open->op_fname.data,
                                         open->op_fname.len, &open->op_iattr,
-                                        &resfh, open->op_createmode,
+                                        resfh, open->op_createmode,
                                         (u32 *)open->op_verf.data,
                                         &open->op_truncate, &open->op_created);
 
@@ -234,30 +238,29 @@ do_open_lookup(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_o
                                                 FATTR4_WORD1_TIME_MODIFY);
         } else {
                 status = nfsd_lookup(rqstp, current_fh,
-                                     open->op_fname.data, open->op_fname.len, &resfh);
+                                     open->op_fname.data, open->op_fname.len, resfh);
                 fh_unlock(current_fh);
                 if (status)
                         goto out;
-                status = nfsd_check_obj_isreg(&resfh);
+                status = nfsd_check_obj_isreg(resfh);
         }
         if (status)
                 goto out;
 
         if (is_create_with_attrs(open) && open->op_acl != NULL)
-                do_set_nfs4_acl(rqstp, &resfh, open->op_acl, open->op_bmval);
-
-        set_change_info(&open->op_cinfo, current_fh);
-        fh_dup2(current_fh, &resfh);
+                do_set_nfs4_acl(rqstp, resfh, open->op_acl, open->op_bmval);
 
         /* set reply cache */
         fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh,
-                        &resfh.fh_handle);
+                        &resfh->fh_handle);
         if (!open->op_created)
-                status = do_open_permission(rqstp, current_fh, open,
+                status = do_open_permission(rqstp, resfh, open,
                                             NFSD_MAY_NOP);
-
+        set_change_info(&open->op_cinfo, current_fh);
+        fh_dup2(current_fh, resfh);
 out:
-        fh_put(&resfh);
+        fh_put(resfh);
+        kfree(resfh);
         return status;
 }
 
@@ -310,16 +313,14 @@ nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
         if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL)
                 return nfserr_inval;
 
-        /* We don't yet support WANT bits: */
-        open->op_share_access &= NFS4_SHARE_ACCESS_MASK;
-
         open->op_created = 0;
         /*
          * RFC5661 18.51.3
          * Before RECLAIM_COMPLETE done, server should deny new lock
          */
         if (nfsd4_has_session(cstate) &&
-            !cstate->session->se_client->cl_firststate &&
+            !test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE,
+                      &cstate->session->se_client->cl_flags) &&
             open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
                 return nfserr_grace;
 
@@ -452,6 +453,10 @@ nfsd4_restorefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
                 return nfserr_restorefh;
 
         fh_dup2(&cstate->current_fh, &cstate->save_fh);
+        if (HAS_STATE_ID(cstate, SAVED_STATE_ID_FLAG)) {
+                memcpy(&cstate->current_stateid, &cstate->save_stateid, sizeof(stateid_t));
+                SET_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
+        }
         return nfs_ok;
 }
 
@@ -463,6 +468,10 @@ nfsd4_savefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
                 return nfserr_nofilehandle;
 
         fh_dup2(&cstate->save_fh, &cstate->current_fh);
+        if (HAS_STATE_ID(cstate, CURRENT_STATE_ID_FLAG)) {
+                memcpy(&cstate->save_stateid, &cstate->current_stateid, sizeof(stateid_t));
+                SET_STATE_ID(cstate, SAVED_STATE_ID_FLAG);
+        }
         return nfs_ok;
 }
 
@@ -481,14 +490,20 @@ nfsd4_access(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
                            &access->ac_supported);
 }
 
+static void gen_boot_verifier(nfs4_verifier *verifier)
+{
+        __be32 verf[2];
+
+        verf[0] = (__be32)nfssvc_boot.tv_sec;
+        verf[1] = (__be32)nfssvc_boot.tv_usec;
+        memcpy(verifier->data, verf, sizeof(verifier->data));
+}
+
 static __be32
 nfsd4_commit(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
              struct nfsd4_commit *commit)
 {
-        u32 *p = (u32 *)commit->co_verf.data;
-        *p++ = nfssvc_boot.tv_sec;
-        *p++ = nfssvc_boot.tv_usec;
-
+        gen_boot_verifier(&commit->co_verf);
         return nfsd_commit(rqstp, &cstate->current_fh, commit->co_offset,
                              commit->co_count);
 }
@@ -865,7 +880,6 @@ nfsd4_write(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 {
         stateid_t *stateid = &write->wr_stateid;
         struct file *filp = NULL;
-        u32 *p;
         __be32 status = nfs_ok;
         unsigned long cnt;
 
@@ -887,9 +901,7 @@ nfsd4_write(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 
         cnt = write->wr_buflen;
         write->wr_how_written = write->wr_stable_how;
-        p = (u32 *)write->wr_verifier.data;
-        *p++ = nfssvc_boot.tv_sec;
-        *p++ = nfssvc_boot.tv_usec;
+        gen_boot_verifier(&write->wr_verifier);
 
         status =  nfsd_write(rqstp, &cstate->current_fh, filp,
                              write->wr_offset, rqstp->rq_vec, write->wr_vlen,
@@ -1000,6 +1012,8 @@ static inline void nfsd4_increment_op_stats(u32 opnum)
 typedef __be32(*nfsd4op_func)(struct svc_rqst *, struct nfsd4_compound_state *,
                               void *);
 typedef u32(*nfsd4op_rsize)(struct svc_rqst *, struct nfsd4_op *op);
+typedef void(*stateid_setter)(struct nfsd4_compound_state *, void *);
+typedef void(*stateid_getter)(struct nfsd4_compound_state *, void *);
 
 enum nfsd4_op_flags {
         ALLOWED_WITHOUT_FH = 1 << 0,    /* No current filehandle required */
@@ -1025,6 +1039,10 @@ enum nfsd4_op_flags {
          * the v4.0 case).
          */
         OP_CACHEME = 1 << 6,
+        /*
+         * These are ops which clear current state id.
+         */
+        OP_CLEAR_STATEID = 1 << 7,
 };
 
 struct nfsd4_operation {
@@ -1033,11 +1051,15 @@ struct nfsd4_operation {
         char *op_name;
         /* Try to get response size before operation */
         nfsd4op_rsize op_rsize_bop;
+        stateid_setter op_get_currentstateid;
+        stateid_getter op_set_currentstateid;
 };
 
 static struct nfsd4_operation nfsd4_ops[];
 
+#ifdef NFSD_DEBUG
 static const char *nfsd4_op_name(unsigned opnum);
+#endif
 
 /*
  * Enforce NFSv4.1 COMPOUND ordering rules:
@@ -1215,13 +1237,23 @@ nfsd4_proc_compound(struct svc_rqst *rqstp,
                 if (op->status)
                         goto encode_op;
 
-                if (opdesc->op_func)
+                if (opdesc->op_func) {
+                        if (opdesc->op_get_currentstateid)
+                                opdesc->op_get_currentstateid(cstate, &op->u);
                         op->status = opdesc->op_func(rqstp, cstate, &op->u);
-                else
+                } else
                         BUG_ON(op->status == nfs_ok);
 
-                if (!op->status && need_wrongsec_check(rqstp))
-                        op->status = check_nfsd_access(cstate->current_fh.fh_export, rqstp);
+                if (!op->status) {
+                        if (opdesc->op_set_currentstateid)
+                                opdesc->op_set_currentstateid(cstate, &op->u);
+
+                        if (opdesc->op_flags & OP_CLEAR_STATEID)
+                                clear_current_stateid(cstate);
+
+                        if (need_wrongsec_check(rqstp))
+                                op->status = check_nfsd_access(cstate->current_fh.fh_export, rqstp);
+                }
 
 encode_op:
                 /* Only from SEQUENCE */
@@ -1413,6 +1445,8 @@ static struct nfsd4_operation nfsd4_ops[] = {
                 .op_flags = OP_MODIFIES_SOMETHING,
                 .op_name = "OP_CLOSE",
                 .op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize,
+                .op_get_currentstateid = (stateid_getter)nfsd4_get_closestateid,
+                .op_set_currentstateid = (stateid_setter)nfsd4_set_closestateid,
         },
         [OP_COMMIT] = {
                 .op_func = (nfsd4op_func)nfsd4_commit,
@@ -1422,7 +1456,7 @@ static struct nfsd4_operation nfsd4_ops[] = {
         },
         [OP_CREATE] = {
                 .op_func = (nfsd4op_func)nfsd4_create,
-                .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
+                .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME | OP_CLEAR_STATEID,
                 .op_name = "OP_CREATE",
                 .op_rsize_bop = (nfsd4op_rsize)nfsd4_create_rsize,
         },
@@ -1431,6 +1465,7 @@ static struct nfsd4_operation nfsd4_ops[] = {
                 .op_flags = OP_MODIFIES_SOMETHING,
                 .op_name = "OP_DELEGRETURN",
                 .op_rsize_bop = nfsd4_only_status_rsize,
+                .op_get_currentstateid = (stateid_getter)nfsd4_get_delegreturnstateid,
         },
         [OP_GETATTR] = {
                 .op_func = (nfsd4op_func)nfsd4_getattr,
@@ -1453,6 +1488,7 @@ static struct nfsd4_operation nfsd4_ops[] = {
                 .op_flags = OP_MODIFIES_SOMETHING,
                 .op_name = "OP_LOCK",
                 .op_rsize_bop = (nfsd4op_rsize)nfsd4_lock_rsize,
+                .op_set_currentstateid = (stateid_setter)nfsd4_set_lockstateid,
         },
         [OP_LOCKT] = {
                 .op_func = (nfsd4op_func)nfsd4_lockt,
@@ -1463,15 +1499,16 @@ static struct nfsd4_operation nfsd4_ops[] = {
                 .op_flags = OP_MODIFIES_SOMETHING,
                 .op_name = "OP_LOCKU",
                 .op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize,
+                .op_get_currentstateid = (stateid_getter)nfsd4_get_lockustateid,
         },
         [OP_LOOKUP] = {
                 .op_func = (nfsd4op_func)nfsd4_lookup,
-                .op_flags = OP_HANDLES_WRONGSEC,
+                .op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID,
                 .op_name = "OP_LOOKUP",
         },
         [OP_LOOKUPP] = {
                 .op_func = (nfsd4op_func)nfsd4_lookupp,
-                .op_flags = OP_HANDLES_WRONGSEC,
+                .op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID,
                 .op_name = "OP_LOOKUPP",
         },
         [OP_NVERIFY] = {
@@ -1483,6 +1520,7 @@ static struct nfsd4_operation nfsd4_ops[] = {
                 .op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING,
                 .op_name = "OP_OPEN",
                 .op_rsize_bop = (nfsd4op_rsize)nfsd4_open_rsize,
+                .op_set_currentstateid = (stateid_setter)nfsd4_set_openstateid,
         },
         [OP_OPEN_CONFIRM] = {
                 .op_func = (nfsd4op_func)nfsd4_open_confirm,
@@ -1495,25 +1533,30 @@ static struct nfsd4_operation nfsd4_ops[] = {
                 .op_flags = OP_MODIFIES_SOMETHING,
                 .op_name = "OP_OPEN_DOWNGRADE",
                 .op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize,
+                .op_get_currentstateid = (stateid_getter)nfsd4_get_opendowngradestateid,
+                .op_set_currentstateid = (stateid_setter)nfsd4_set_opendowngradestateid,
         },
         [OP_PUTFH] = {
                 .op_func = (nfsd4op_func)nfsd4_putfh,
                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
-                                | OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING,
+                                | OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING
+                                | OP_CLEAR_STATEID,
                 .op_name = "OP_PUTFH",
                 .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
         },
         [OP_PUTPUBFH] = {
                 .op_func = (nfsd4op_func)nfsd4_putrootfh,
                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
-                                | OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING,
+                                | OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING
+                                | OP_CLEAR_STATEID,
                 .op_name = "OP_PUTPUBFH",
                 .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
         },
         [OP_PUTROOTFH] = {
                 .op_func = (nfsd4op_func)nfsd4_putrootfh,
                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
-                                | OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING,
+                                | OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING
+                                | OP_CLEAR_STATEID,
                 .op_name = "OP_PUTROOTFH",
                 .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
         },
@@ -1522,6 +1565,7 @@ static struct nfsd4_operation nfsd4_ops[] = {
                 .op_flags = OP_MODIFIES_SOMETHING,
                 .op_name = "OP_READ",
                 .op_rsize_bop = (nfsd4op_rsize)nfsd4_read_rsize,
+                .op_get_currentstateid = (stateid_getter)nfsd4_get_readstateid,
         },
         [OP_READDIR] = {
                 .op_func = (nfsd4op_func)nfsd4_readdir,
@@ -1576,6 +1620,7 @@ static struct nfsd4_operation nfsd4_ops[] = {
                 .op_name = "OP_SETATTR",
                 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
                 .op_rsize_bop = (nfsd4op_rsize)nfsd4_setattr_rsize,
+                .op_get_currentstateid = (stateid_getter)nfsd4_get_setattrstateid,
         },
         [OP_SETCLIENTID] = {
                 .op_func = (nfsd4op_func)nfsd4_setclientid,
@@ -1600,6 +1645,7 @@ static struct nfsd4_operation nfsd4_ops[] = {
                 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
                 .op_name = "OP_WRITE",
                 .op_rsize_bop = (nfsd4op_rsize)nfsd4_write_rsize,
+                .op_get_currentstateid = (stateid_getter)nfsd4_get_writestateid,
         },
         [OP_RELEASE_LOCKOWNER] = {
                 .op_func = (nfsd4op_func)nfsd4_release_lockowner,
@@ -1674,12 +1720,14 @@ static struct nfsd4_operation nfsd4_ops[] = {
         },
 };
 
+#ifdef NFSD_DEBUG
 static const char *nfsd4_op_name(unsigned opnum)
 {
         if (opnum < ARRAY_SIZE(nfsd4_ops))
                 return nfsd4_ops[opnum].op_name;
         return "unknown_operation";
 }
+#endif
 
 #define nfsd4_voidres                   nfsd4_voidargs
 struct nfsd4_voidargs { int dummy; };