Commit b9efa1b2 authored by Andy Adamson's avatar Andy Adamson Committed by Trond Myklebust
Browse files

nfs41: implement cb_recall_slot 



Drain the fore channel and reset the max_slots to the new value.

Signed-off-by: default avatarAndy Adamson <andros@netapp.com>
Signed-off-by: default avatarTrond Myklebust <Trond.Myklebust@netapp.com>
parent 4911096f

fs/nfs/callback.h

+8 −0
Original line number Diff line number Diff line
@@ -119,6 +119,14 @@ struct cb_recallanyargs { 
};



extern unsigned nfs4_callback_recallany(struct cb_recallanyargs *args, void *dummy);



struct cb_recallslotargs {

	struct sockaddr	*crsa_addr;

	uint32_t	crsa_target_max_slots;

};

extern unsigned nfs4_callback_recallslot(struct cb_recallslotargs *args,

					  void *dummy);



#endif /* CONFIG_NFS_V4_1 */



extern __be32 nfs4_callback_getattr(struct cb_getattrargs *args, struct cb_getattrres *res);

fs/nfs/callback_proc.c

+32 −0
Original line number Diff line number Diff line
@@ -361,4 +361,36 @@ unsigned nfs4_callback_recallany(struct cb_recallanyargs *args, void *dummy) 
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));

	return status;

}



/* Reduce the fore channel's max_slots to the target value */

unsigned nfs4_callback_recallslot(struct cb_recallslotargs *args, void *dummy)

{

	struct nfs_client *clp;

	struct nfs4_slot_table *fc_tbl;

	int status;



	status = htonl(NFS4ERR_OP_NOT_IN_SESSION);

	clp = nfs_find_client(args->crsa_addr, 4);

	if (clp == NULL)

		goto out;



	dprintk("NFS: CB_RECALL_SLOT request from %s target max slots %d\n",

		rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR),

		args->crsa_target_max_slots);



	fc_tbl = &clp->cl_session->fc_slot_table;



	status = htonl(NFS4ERR_BAD_HIGH_SLOT);

	if (args->crsa_target_max_slots >= fc_tbl->max_slots ||

	    args->crsa_target_max_slots < 1)

		goto out;



	fc_tbl->target_max_slots = args->crsa_target_max_slots;

	nfs41_handle_recall_slot(clp);

	status = htonl(NFS4_OK);

	nfs_put_client(clp);	/* balance nfs_find_client */

out:

	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));

	return status;

}

#endif /* CONFIG_NFS_V4_1 */

fs/nfs/callback_xdr.c

+21 −1
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ 
#define CB_OP_SEQUENCE_RES_MAXSZ	(CB_OP_HDR_RES_MAXSZ + \

					4 + 1 + 3)

#define CB_OP_RECALLANY_RES_MAXSZ	(CB_OP_HDR_RES_MAXSZ)

#define CB_OP_RECALLSLOT_RES_MAXSZ	(CB_OP_HDR_RES_MAXSZ)

#endif /* CONFIG_NFS_V4_1 */



#define NFSDBG_FACILITY NFSDBG_CALLBACK
@@ -349,6 +350,20 @@ static unsigned decode_recallany_args(struct svc_rqst *rqstp, 
	return 0;

}



static unsigned decode_recallslot_args(struct svc_rqst *rqstp,

					struct xdr_stream *xdr,

					struct cb_recallslotargs *args)

{

	__be32 *p;



	args->crsa_addr = svc_addr(rqstp);

	p = read_buf(xdr, 4);

	if (unlikely(p == NULL))

		return htonl(NFS4ERR_BADXDR);

	args->crsa_target_max_slots = ntohl(*p++);

	return 0;

}



#endif /* CONFIG_NFS_V4_1 */



static __be32 encode_string(struct xdr_stream *xdr, unsigned int len, const char *str)
@@ -557,6 +572,7 @@ preprocess_nfs41_op(int nop, unsigned int op_nr, struct callback_op **op) 
	case OP_CB_RECALL:

	case OP_CB_SEQUENCE:

	case OP_CB_RECALL_ANY:

	case OP_CB_RECALL_SLOT:

		*op = &callback_ops[op_nr];

		break;
@@ -565,7 +581,6 @@ preprocess_nfs41_op(int nop, unsigned int op_nr, struct callback_op **op) 
	case OP_CB_NOTIFY:

	case OP_CB_PUSH_DELEG:

	case OP_CB_RECALLABLE_OBJ_AVAIL:

	case OP_CB_RECALL_SLOT:

	case OP_CB_WANTS_CANCELLED:

	case OP_CB_NOTIFY_LOCK:

		return htonl(NFS4ERR_NOTSUPP);
@@ -734,6 +749,11 @@ static struct callback_op callback_ops[] = { 
		.decode_args = (callback_decode_arg_t)decode_recallany_args,

		.res_maxsize = CB_OP_RECALLANY_RES_MAXSZ,

	},

	[OP_CB_RECALL_SLOT] = {

		.process_op = (callback_process_op_t)nfs4_callback_recallslot,

		.decode_args = (callback_decode_arg_t)decode_recallslot_args,

		.res_maxsize = CB_OP_RECALLSLOT_RES_MAXSZ,

	},

#endif /* CONFIG_NFS_V4_1 */

};

fs/nfs/nfs4_fs.h

+2 −0
Original line number Diff line number Diff line
@@ -46,6 +46,7 @@ enum nfs4_client_state { 
	NFS4CLNT_DELEGRETURN,

	NFS4CLNT_SESSION_RESET,

	NFS4CLNT_SESSION_DRAINING,

	NFS4CLNT_RECALL_SLOT,

};



/*
@@ -280,6 +281,7 @@ extern void nfs4_schedule_state_manager(struct nfs_client *); 
extern int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state);

extern int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state);

extern void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags);

extern void nfs41_handle_recall_slot(struct nfs_client *clp);

extern void nfs4_put_lock_state(struct nfs4_lock_state *lsp);

extern int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl);

extern void nfs4_copy_stateid(nfs4_stateid *, struct nfs4_state *, fl_owner_t);

fs/nfs/nfs4state.c

+44 −0
Original line number Diff line number Diff line
@@ -1249,6 +1249,12 @@ static int nfs4_reclaim_lease(struct nfs_client *clp) 
}



#ifdef CONFIG_NFS_V4_1

void nfs41_handle_recall_slot(struct nfs_client *clp)

{

	set_bit(NFS4CLNT_RECALL_SLOT, &clp->cl_state);

	nfs4_schedule_state_recovery(clp);

}



void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags)

{

	if (!flags)
@@ -1299,9 +1305,38 @@ static int nfs4_reset_session(struct nfs_client *clp) 
	return status;

}



static int nfs4_recall_slot(struct nfs_client *clp)

{

	struct nfs4_slot_table *fc_tbl = &clp->cl_session->fc_slot_table;

	struct nfs4_channel_attrs *fc_attrs = &clp->cl_session->fc_attrs;

	struct nfs4_slot *new, *old;

	int i;



	nfs4_begin_drain_session(clp);

	new = kmalloc(fc_tbl->target_max_slots * sizeof(struct nfs4_slot),

		      GFP_KERNEL);

        if (!new)

		return -ENOMEM;



	spin_lock(&fc_tbl->slot_tbl_lock);

	for (i = 0; i < fc_tbl->target_max_slots; i++)

		new[i].seq_nr = fc_tbl->slots[i].seq_nr;

	old = fc_tbl->slots;

	fc_tbl->slots = new;

	fc_tbl->max_slots = fc_tbl->target_max_slots;

	fc_tbl->target_max_slots = 0;

	fc_attrs->max_reqs = fc_tbl->max_slots;

	spin_unlock(&fc_tbl->slot_tbl_lock);



	kfree(old);

	nfs4_end_drain_session(clp);

	return 0;

}



#else /* CONFIG_NFS_V4_1 */

static int nfs4_reset_session(struct nfs_client *clp) { return 0; }

static int nfs4_end_drain_session(struct nfs_client *clp) { return 0; }

static int nfs4_recall_slot(struct nfs_client *clp) { return 0; }

#endif /* CONFIG_NFS_V4_1 */



/* Set NFS4CLNT_LEASE_EXPIRED for all v4.0 errors and for recoverable errors
@@ -1398,6 +1433,15 @@ static void nfs4_state_manager(struct nfs_client *clp) 
			nfs_client_return_marked_delegations(clp);

			continue;

		}

		/* Recall session slots */

		if (test_and_clear_bit(NFS4CLNT_RECALL_SLOT, &clp->cl_state)

		   && nfs4_has_session(clp)) {

			status = nfs4_recall_slot(clp);

			if (status < 0)

				goto out_error;

			continue;

		}





		nfs4_clear_state_manager_bit(clp);

		/* Did we race with an attempt to give us more work? */