nfs41: back channel drc minimal implementation

[deliverable/linux.git] / fs / nfs / callback_proc.c

diff --git a/fs/nfs/callback_proc.c b/fs/nfs/callback_proc.c
index 49c4b548b4d0c472295f7ceceeefab3439b07424..4062f7690a33f363ede1d823120272e68a48cd0b 100644 (file)
--- a/fs/nfs/callback_proc.c
+++ b/fs/nfs/callback_proc.c
@@ -143,9 +143,8 @@ int nfs41_validate_delegation_stateid(struct nfs_delegation *delegation, const n
  * Return success if the sequenceID is one more than what we last saw on
  * this slot, accounting for wraparound.  Increments the slot's sequence.
  *
- * We don't yet implement a duplicate request cache, so at this time
- * we will log replays, and process them as if we had not seen them before,
- * but we don't bump the sequence in the slot.  Not too worried about it,
+ * We don't yet implement a duplicate request cache, instead we set the
+ * back channel ca_maxresponsesize_cached to zero. This is OK for now
  * since we only currently implement idempotent callbacks anyway.
  *
  * We have a single slot backchannel at this time, so we don't bother
@@ -153,34 +152,40 @@ int nfs41_validate_delegation_stateid(struct nfs_delegation *delegation, const n
  * a single outstanding callback request at a time.
  */
 static int
-validate_seqid(struct nfs4_slot_table *tbl, u32 slotid, u32 seqid)
+validate_seqid(struct nfs4_slot_table *tbl, struct cb_sequenceargs * args)
 {
        struct nfs4_slot *slot;
 
        dprintk("%s enter. slotid %d seqid %d\n",
-               __func__, slotid, seqid);
+               __func__, args->csa_slotid, args->csa_sequenceid);
 
-       if (slotid > NFS41_BC_MAX_CALLBACKS)
+       if (args->csa_slotid > NFS41_BC_MAX_CALLBACKS)
                return htonl(NFS4ERR_BADSLOT);
 
-       slot = tbl->slots + slotid;
+       slot = tbl->slots + args->csa_slotid;
        dprintk("%s slot table seqid: %d\n", __func__, slot->seq_nr);
 
        /* Normal */
-       if (likely(seqid == slot->seq_nr + 1)) {
+       if (likely(args->csa_sequenceid == slot->seq_nr + 1)) {
                slot->seq_nr++;
                return htonl(NFS4_OK);
        }
 
        /* Replay */
-       if (seqid == slot->seq_nr) {
-               dprintk("%s seqid %d is a replay - no DRC available\n",
-                       __func__, seqid);
-               return htonl(NFS4_OK);
+       if (args->csa_sequenceid == slot->seq_nr) {
+               dprintk("%s seqid %d is a replay\n",
+                       __func__, args->csa_sequenceid);
+               /* Signal process_op to set this error on next op */
+               if (args->csa_cachethis == 0)
+                       return htonl(NFS4ERR_RETRY_UNCACHED_REP);
+
+               /* The ca_maxresponsesize_cached is 0 with no DRC */
+               else if (args->csa_cachethis == 1)
+                       return htonl(NFS4ERR_REP_TOO_BIG_TO_CACHE);
        }
 
        /* Wraparound */
-       if (seqid == 1 && (slot->seq_nr + 1) == 0) {
+       if (args->csa_sequenceid == 1 && (slot->seq_nr + 1) == 0) {
                slot->seq_nr = 1;
                return htonl(NFS4_OK);
        }
@@ -291,8 +296,7 @@ unsigned nfs4_callback_sequence(struct cb_sequenceargs *args,
        if (clp == NULL)
                goto out;
 
-       status = validate_seqid(&clp->cl_session->bc_slot_table,
-                               args->csa_slotid, args->csa_sequenceid);
+       status = validate_seqid(&clp->cl_session->bc_slot_table, args);
        if (status)
                goto out_putclient;
 
@@ -320,9 +324,13 @@ out:
                kfree(args->csa_rclists[i].rcl_refcalls);
        kfree(args->csa_rclists);
 
-       dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
-       res->csr_status = status;
-       return res->csr_status;
+       if (status == htonl(NFS4ERR_RETRY_UNCACHED_REP))
+               res->csr_status = 0;
+       else
+               res->csr_status = status;
+       dprintk("%s: exit with status = %d res->csr_status %d\n", __func__,
+               ntohl(status), ntohl(res->csr_status));
+       return status;
 }
 
 unsigned nfs4_callback_recallany(struct cb_recallanyargs *args, void *dummy)