Merge branch 'nfs-for-2.6.34' of git://git.linux-nfs.org/projects/trondmy/nfs-2.6 (cc7889ff) · Commits · 戴 / test

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

+137 −28

Original line number	Diff line number	Diff line
		@@ -143,44 +143,49 @@ 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
		* checking the used_slots bit array on the table. The lower layer guarantees
		* a single outstanding callback request at a time.
		*/
		static int
		validate_seqid(struct nfs4_slot_table *tbl, u32 slotid, u32 seqid)
		static __be32
		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);
		}
		@@ -225,27 +230,87 @@ validate_seqid(struct nfs4_slot_table *tbl, u32 slotid, u32 seqid)
		return NULL;
		}

		/* FIXME: referring calls should be processed */
		unsigned nfs4_callback_sequence(struct cb_sequenceargs *args,
		/*
		* For each referring call triple, check the session's slot table for
		* a match. If the slot is in use and the sequence numbers match, the
		* client is still waiting for a response to the original request.
		*/
		static bool referring_call_exists(struct nfs_client *clp,
		uint32_t nrclists,
		struct referring_call_list *rclists)
		{
		bool status = 0;
		int i, j;
		struct nfs4_session *session;
		struct nfs4_slot_table *tbl;
		struct referring_call_list *rclist;
		struct referring_call *ref;

		/*
		* XXX When client trunking is implemented, this becomes
		* a session lookup from within the loop
		*/
		session = clp->cl_session;
		tbl = &session->fc_slot_table;

		for (i = 0; i < nrclists; i++) {
		rclist = &rclists[i];
		if (memcmp(session->sess_id.data,
		rclist->rcl_sessionid.data,
		NFS4_MAX_SESSIONID_LEN) != 0)
		continue;

		for (j = 0; j < rclist->rcl_nrefcalls; j++) {
		ref = &rclist->rcl_refcalls[j];

		dprintk("%s: sessionid %x:%x:%x:%x sequenceid %u "
		"slotid %u\n", __func__,
		((u32 *)&rclist->rcl_sessionid.data)[0],
		((u32 *)&rclist->rcl_sessionid.data)[1],
		((u32 *)&rclist->rcl_sessionid.data)[2],
		((u32 *)&rclist->rcl_sessionid.data)[3],
		ref->rc_sequenceid, ref->rc_slotid);

		spin_lock(&tbl->slot_tbl_lock);
		status = (test_bit(ref->rc_slotid, tbl->used_slots) &&
		tbl->slots[ref->rc_slotid].seq_nr ==
		ref->rc_sequenceid);
		spin_unlock(&tbl->slot_tbl_lock);
		if (status)
		goto out;
		}
		}

		out:
		return status;
		}

		__be32 nfs4_callback_sequence(struct cb_sequenceargs *args,
		struct cb_sequenceres *res)
		{
		struct nfs_client *clp;
		int i, status;

		for (i = 0; i < args->csa_nrclists; i++)
		kfree(args->csa_rclists[i].rcl_refcalls);
		kfree(args->csa_rclists);
		int i;
		__be32 status;

		status = htonl(NFS4ERR_BADSESSION);
		clp = find_client_with_session(args->csa_addr, 4, &args->csa_sessionid);
		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;

		/*
		* Check for pending referring calls. If a match is found, a
		* related callback was received before the response to the original
		* call.
		*/
		if (referring_call_exists(clp, args->csa_nrclists, args->csa_rclists)) {
		status = htonl(NFS4ERR_DELAY);
		goto out_putclient;
		}

		memcpy(&res->csr_sessionid, &args->csa_sessionid,
		sizeof(res->csr_sessionid));
		res->csr_sequenceid = args->csa_sequenceid;
		@@ -256,15 +321,23 @@ unsigned nfs4_callback_sequence(struct cb_sequenceargs *args,
		out_putclient:
		nfs_put_client(clp);
		out:
		dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
		for (i = 0; i < args->csa_nrclists; i++)
		kfree(args->csa_rclists[i].rcl_refcalls);
		kfree(args->csa_rclists);

		if (status == htonl(NFS4ERR_RETRY_UNCACHED_REP))
		res->csr_status = 0;
		else
		res->csr_status = status;
		return res->csr_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)
		__be32 nfs4_callback_recallany(struct cb_recallanyargs args, void dummy)
		{
		struct nfs_client *clp;
		int status;
		__be32 status;
		fmode_t flags = 0;

		status = htonl(NFS4ERR_OP_NOT_IN_SESSION);
		@@ -289,4 +362,40 @@ out:
		dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
		return status;
		}

		/* Reduce the fore channel's max_slots to the target value */
		__be32 nfs4_callback_recallslot(struct cb_recallslotargs args, void dummy)
		{
		struct nfs_client *clp;
		struct nfs4_slot_table *fc_tbl;
		__be32 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_putclient;

		status = htonl(NFS4_OK);
		if (args->crsa_target_max_slots == fc_tbl->max_slots)
		goto out_putclient;

		fc_tbl->target_max_slots = args->crsa_target_max_slots;
		nfs41_handle_recall_slot(clp);
		out_putclient:
		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

+73 −32

Original line number	Diff line number	Diff line
		@@ -24,10 +24,14 @@
		#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

		/* Internal error code */
		#define NFS4ERR_RESOURCE_HDR 11050

		typedef __be32 (callback_process_op_t)(void , void *);
		typedef __be32 (callback_decode_arg_t)(struct svc_rqst , struct xdr_stream , void );
		typedef __be32 (callback_encode_res_t)(struct svc_rqst , struct xdr_stream , void );
		@@ -173,7 +177,7 @@ static __be32 decode_op_hdr(struct xdr_stream xdr, unsigned int op)
		__be32 *p;
		p = read_buf(xdr, 4);
		if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
		return htonl(NFS4ERR_RESOURCE_HDR);
		op = ntohl(p);
		return 0;
		}
		@@ -215,10 +219,10 @@ out:

		#if defined(CONFIG_NFS_V4_1)

		static unsigned decode_sessionid(struct xdr_stream *xdr,
		static __be32 decode_sessionid(struct xdr_stream *xdr,
		struct nfs4_sessionid *sid)
		{
		uint32_t *p;
		__be32 *p;
		int len = NFS4_MAX_SESSIONID_LEN;

		p = read_buf(xdr, len);
		@@ -229,12 +233,12 @@ static unsigned decode_sessionid(struct xdr_stream *xdr,
		return 0;
		}

		static unsigned decode_rc_list(struct xdr_stream *xdr,
		static __be32 decode_rc_list(struct xdr_stream *xdr,
		struct referring_call_list *rc_list)
		{
		uint32_t *p;
		__be32 *p;
		int i;
		unsigned status;
		__be32 status;

		status = decode_sessionid(xdr, &rc_list->rcl_sessionid);
		if (status)
		@@ -267,13 +271,13 @@ out:
		return status;
		}

		static unsigned decode_cb_sequence_args(struct svc_rqst *rqstp,
		static __be32 decode_cb_sequence_args(struct svc_rqst *rqstp,
		struct xdr_stream *xdr,
		struct cb_sequenceargs *args)
		{
		uint32_t *p;
		__be32 *p;
		int i;
		unsigned status;
		__be32 status;

		status = decode_sessionid(xdr, &args->csa_sessionid);
		if (status)
		@@ -327,11 +331,11 @@ out_free:
		goto out;
		}

		static unsigned decode_recallany_args(struct svc_rqst *rqstp,
		static __be32 decode_recallany_args(struct svc_rqst *rqstp,
		struct xdr_stream *xdr,
		struct cb_recallanyargs *args)
		{
		uint32_t *p;
		__be32 *p;

		args->craa_addr = svc_addr(rqstp);
		p = read_buf(xdr, 4);
		@@ -346,6 +350,20 @@ static unsigned decode_recallany_args(struct svc_rqst *rqstp,
		return 0;
		}

		static __be32 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)
		@@ -465,7 +483,7 @@ static __be32 encode_op_hdr(struct xdr_stream *xdr, uint32_t op, __be32 res)

		p = xdr_reserve_space(xdr, 8);
		if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
		return htonl(NFS4ERR_RESOURCE_HDR);
		*p++ = htonl(op);
		*p = res;
		return 0;
		@@ -499,10 +517,10 @@ out:

		#if defined(CONFIG_NFS_V4_1)

		static unsigned encode_sessionid(struct xdr_stream *xdr,
		static __be32 encode_sessionid(struct xdr_stream *xdr,
		const struct nfs4_sessionid *sid)
		{
		uint32_t *p;
		__be32 *p;
		int len = NFS4_MAX_SESSIONID_LEN;

		p = xdr_reserve_space(xdr, len);
		@@ -513,11 +531,11 @@ static unsigned encode_sessionid(struct xdr_stream *xdr,
		return 0;
		}

		static unsigned encode_cb_sequence_res(struct svc_rqst *rqstp,
		static __be32 encode_cb_sequence_res(struct svc_rqst *rqstp,
		struct xdr_stream *xdr,
		const struct cb_sequenceres *res)
		{
		uint32_t *p;
		__be32 *p;
		unsigned status = res->csr_status;

		if (unlikely(status != 0))
		@@ -554,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;

		@@ -562,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);
		@@ -602,20 +620,18 @@ preprocess_nfs4_op(unsigned int op_nr, struct callback_op **op)
		static __be32 process_op(uint32_t minorversion, int nop,
		struct svc_rqst *rqstp,
		struct xdr_stream xdr_in, void argp,
		struct xdr_stream xdr_out, void resp)
		struct xdr_stream xdr_out, void resp, int* drc_status)
		{
		struct callback_op *op = &callback_ops[0];
		unsigned int op_nr = OP_CB_ILLEGAL;
		unsigned int op_nr;
		__be32 status;
		long maxlen;
		__be32 res;

		dprintk("%s: start\n", __func__);
		status = decode_op_hdr(xdr_in, &op_nr);
		if (unlikely(status)) {
		status = htonl(NFS4ERR_OP_ILLEGAL);
		goto out;
		}
		if (unlikely(status))
		return status;

		dprintk("%s: minorversion=%d nop=%d op_nr=%u\n",
		__func__, minorversion, nop, op_nr);
		@@ -624,19 +640,32 @@ static __be32 process_op(uint32_t minorversion, int nop,
		preprocess_nfs4_op(op_nr, &op);
		if (status == htonl(NFS4ERR_OP_ILLEGAL))
		op_nr = OP_CB_ILLEGAL;
		out:
		if (status)
		goto encode_hdr;

		if (*drc_status) {
		status = *drc_status;
		goto encode_hdr;
		}

		maxlen = xdr_out->end - xdr_out->p;
		if (maxlen > 0 && maxlen < PAGE_SIZE) {
		if (likely(status == 0 && op->decode_args != NULL))
		status = op->decode_args(rqstp, xdr_in, argp);
		if (likely(status == 0 && op->process_op != NULL))
		if (likely(status == 0))
		status = op->process_op(argp, resp);
		} else
		status = htonl(NFS4ERR_RESOURCE);

		/* Only set by OP_CB_SEQUENCE processing */
		if (status == htonl(NFS4ERR_RETRY_UNCACHED_REP)) {
		*drc_status = status;
		status = 0;
		}

		encode_hdr:
		res = encode_op_hdr(xdr_out, op_nr, status);
		if (status == 0)
		status = res;
		if (unlikely(res))
		return res;
		if (op->encode_res != NULL && status == 0)
		status = op->encode_res(rqstp, xdr_out, resp);
		dprintk("%s: done, status = %d\n", __func__, ntohl(status));
		@@ -652,7 +681,7 @@ static __be32 nfs4_callback_compound(struct svc_rqst rqstp, void argp, void *r
		struct cb_compound_hdr_res hdr_res = { NULL };
		struct xdr_stream xdr_in, xdr_out;
		__be32 *p;
		__be32 status;
		__be32 status, drc_status = 0;
		unsigned int nops = 0;

		dprintk("%s: start\n", __func__);
		@@ -672,11 +701,18 @@ static __be32 nfs4_callback_compound(struct svc_rqst rqstp, void argp, void *r
		return rpc_system_err;

		while (status == 0 && nops != hdr_arg.nops) {
		status = process_op(hdr_arg.minorversion, nops,
		rqstp, &xdr_in, argp, &xdr_out, resp);
		status = process_op(hdr_arg.minorversion, nops, rqstp,
		&xdr_in, argp, &xdr_out, resp, &drc_status);
		nops++;
		}

		/* Buffer overflow in decode_ops_hdr or encode_ops_hdr. Return
		* resource error in cb_compound status without returning op */
		if (unlikely(status == htonl(NFS4ERR_RESOURCE_HDR))) {
		status = htonl(NFS4ERR_RESOURCE);
		nops--;
		}

		*hdr_res.status = status;
		*hdr_res.nops = htonl(nops);
		dprintk("%s: done, status = %u\n", __func__, ntohl(status));
		@@ -713,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/client.c

+24 −24

Original line number	Diff line number	Diff line
		@@ -164,30 +164,7 @@ error_0:
		return ERR_PTR(err);
		}

		static void nfs4_shutdown_client(struct nfs_client *clp)
		{
		#ifdef CONFIG_NFS_V4
		if (__test_and_clear_bit(NFS_CS_RENEWD, &clp->cl_res_state))
		nfs4_kill_renewd(clp);
		BUG_ON(!RB_EMPTY_ROOT(&clp->cl_state_owners));
		if (__test_and_clear_bit(NFS_CS_IDMAP, &clp->cl_res_state))
		nfs_idmap_delete(clp);

		rpc_destroy_wait_queue(&clp->cl_rpcwaitq);
		#endif
		}

		/*
		* Destroy the NFS4 callback service
		*/
		static void nfs4_destroy_callback(struct nfs_client *clp)
		{
		#ifdef CONFIG_NFS_V4
		if (__test_and_clear_bit(NFS_CS_CALLBACK, &clp->cl_res_state))
		nfs_callback_down(clp->cl_minorversion);
		#endif /* CONFIG_NFS_V4 */
		}

		/*
		* Clears/puts all minor version specific parts from an nfs_client struct
		* reverting it to minorversion 0.
		@@ -202,9 +179,33 @@ static void nfs4_clear_client_minor_version(struct nfs_client *clp)

		clp->cl_call_sync = _nfs4_call_sync;
		#endif /* CONFIG_NFS_V4_1 */
		}

		/*
		* Destroy the NFS4 callback service
		*/
		static void nfs4_destroy_callback(struct nfs_client *clp)
		{
		if (__test_and_clear_bit(NFS_CS_CALLBACK, &clp->cl_res_state))
		nfs_callback_down(clp->cl_minorversion);
		}

		static void nfs4_shutdown_client(struct nfs_client *clp)
		{
		if (__test_and_clear_bit(NFS_CS_RENEWD, &clp->cl_res_state))
		nfs4_kill_renewd(clp);
		nfs4_clear_client_minor_version(clp);
		nfs4_destroy_callback(clp);
		if (__test_and_clear_bit(NFS_CS_IDMAP, &clp->cl_res_state))
		nfs_idmap_delete(clp);

		rpc_destroy_wait_queue(&clp->cl_rpcwaitq);
		}
		#else
		static void nfs4_shutdown_client(struct nfs_client *clp)
		{
		}
		#endif /* CONFIG_NFS_V4 */

		/*
		* Destroy a shared client record
		@@ -213,7 +214,6 @@ static void nfs_free_client(struct nfs_client *clp)
		{
		dprintk("--> nfs_free_client(%u)\n", clp->rpc_ops->version);

		nfs4_clear_client_minor_version(clp);
		nfs4_shutdown_client(clp);

		nfs_fscache_release_client_cookie(clp);

fs/nfs/dir.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -560,7 +560,7 @@ static int nfs_readdir(struct file filp, void dirent, filldir_t filldir)
		desc->entry = &my_entry;

		nfs_block_sillyrename(dentry);
		res = nfs_revalidate_mapping_nolock(inode, filp->f_mapping);
		res = nfs_revalidate_mapping(inode, filp->f_mapping);
		if (res < 0)
		goto out;

Admin message