Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit cc7889ff authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'nfs-for-2.6.34' of git://git.linux-nfs.org/projects/trondmy/nfs-2.6 

* 'nfs-for-2.6.34' of git://git.linux-nfs.org/projects/trondmy/nfs-2.6: (44 commits)
  NFS: Remove requirement for inode->i_mutex from nfs_invalidate_mapping
  NFS: Clean up nfs_sync_mapping
  NFS: Simplify nfs_wb_page()
  NFS: Replace __nfs_write_mapping with sync_inode()
  NFS: Simplify nfs_wb_page_cancel()
  NFS: Ensure inode is always marked I_DIRTY_DATASYNC, if it has unstable pages
  NFS: Run COMMIT as an asynchronous RPC call when wbc->for_background is set
  NFS: Reduce the number of unnecessary COMMIT calls
  NFS: Add a count of the number of unstable writes carried by an inode
  NFS: Cleanup - move nfs_write_inode() into fs/nfs/write.c
  nfs41 fix NFS4ERR_CLID_INUSE for exchange id
  NFS: Fix an allocation-under-spinlock bug
  SUNRPC: Handle EINVAL error returns from the TCP connect operation
  NFSv4.1: Various fixes to the sequence flag error handling
  nfs4: renewd renew operations should take/put a client reference
  nfs41: renewd sequence operations should take/put client reference
  nfs: prevent backlogging of renewd requests
  nfs: kill renewd before clearing client minor version
  NFS: Make close(2) asynchronous when closing NFS O_DIRECT files
  NFS: Improve NFS iostat byte count accuracy for writes
  ...
parents b13d3c6e 3fa04ecd

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;