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

Commit 75ff24fa authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull nfsd updates from Bruce Fields:
 "Highlights:
   - server-side nfs/rdma fixes from Jeff Layton and Tom Tucker
   - xdr fixes (a larger xdr rewrite has been posted but I decided it
     would be better to queue it up for 3.16).
   - miscellaneous fixes and cleanup from all over (thanks especially to
     Kinglong Mee)"

* 'for-3.15' of git://linux-nfs.org/~bfields/linux: (36 commits)
  nfsd4: don't create unnecessary mask acl
  nfsd: revert v2 half of "nfsd: don't return high mode bits"
  nfsd4: fix memory leak in nfsd4_encode_fattr()
  nfsd: check passed socket's net matches NFSd superblock's one
  SUNRPC: Clear xpt_bc_xprt if xs_setup_bc_tcp failed
  NFSD/SUNRPC: Check rpc_xprt out of xs_setup_bc_tcp
  SUNRPC: New helper for creating client with rpc_xprt
  NFSD: Free backchannel xprt in bc_destroy
  NFSD: Clear wcc data between compound ops
  nfsd: Don't return NFS4ERR_STALE_STATEID for NFSv4.1+
  nfsd4: fix nfs4err_resource in 4.1 case
  nfsd4: fix setclientid encode size
  nfsd4: remove redundant check from nfsd4_check_resp_size
  nfsd4: use more generous NFS4_ACL_MAX
  nfsd4: minor nfsd4_replay_cache_entry cleanup
  nfsd4: nfsd4_replay_cache_entry should be static
  nfsd4: update comments with obsolete function name
  rpc: Allow xdr_buf_subsegment to operate in-place
  NFSD: Using free_conn free connection
  SUNRPC: fix memory leak of peer addresses in XPRT
  ...
parents 0f386a70 06f9cc12

fs/lockd/svc.c

+1 −0
Original line number Diff line number Diff line
@@ -235,6 +235,7 @@ static int make_socks(struct svc_serv *serv, struct net *net) 
	if (warned++ == 0)

		printk(KERN_WARNING

			"lockd_up: makesock failed, error=%d\n", err);

	svc_shutdown_net(serv, net);

	return err;

}

fs/nfsd/acl.h

+7 −3
Original line number Diff line number Diff line
@@ -39,9 +39,13 @@ struct nfs4_acl; 
struct svc_fh;

struct svc_rqst;



/* Maximum ACL we'll accept from client; chosen (somewhat arbitrarily) to

 * fit in a page: */

#define NFS4_ACL_MAX 170

/*

 * Maximum ACL we'll accept from a client; chosen (somewhat

 * arbitrarily) so that kmalloc'ing the ACL shouldn't require a

 * high-order allocation.  This allows 204 ACEs on x86_64:

 */

#define NFS4_ACL_MAX ((PAGE_SIZE - sizeof(struct nfs4_acl)) \

			/ sizeof(struct nfs4_ace))



struct nfs4_acl *nfs4_acl_new(int);

int nfs4_acl_get_whotype(char *, u32);

fs/nfsd/nfs4acl.c

+9 −4
Original line number Diff line number Diff line
@@ -542,6 +542,9 @@ posix_state_to_acl(struct posix_acl_state *state, unsigned int flags) 
	 * up setting a 3-element effective posix ACL with all

	 * permissions zero.

	 */

	if (!state->users->n && !state->groups->n)

		nace = 3;

	else /* Note we also include a MASK ACE in this case: */

		nace = 4 + state->users->n + state->groups->n;

	pacl = posix_acl_alloc(nace, GFP_KERNEL);

	if (!pacl)
@@ -586,9 +589,11 @@ posix_state_to_acl(struct posix_acl_state *state, unsigned int flags) 
		add_to_mask(state, &state->groups->aces[i].perms);

	}



	if (!state->users->n && !state->groups->n) {

		pace++;

		pace->e_tag = ACL_MASK;

		low_mode_from_nfs4(state->mask.allow, &pace->e_perm, flags);

	}



	pace++;

	pace->e_tag = ACL_OTHER;

fs/nfsd/nfs4callback.c

+18 −1
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ 
 */



#include <linux/sunrpc/clnt.h>

#include <linux/sunrpc/xprt.h>

#include <linux/sunrpc/svc_xprt.h>

#include <linux/slab.h>

#include "nfsd.h"
@@ -635,6 +636,22 @@ static struct rpc_cred *get_backchannel_cred(struct nfs4_client *clp, struct rpc 
	}

}



static struct rpc_clnt *create_backchannel_client(struct rpc_create_args *args)

{

	struct rpc_xprt *xprt;



	if (args->protocol != XPRT_TRANSPORT_BC_TCP)

		return rpc_create(args);



	xprt = args->bc_xprt->xpt_bc_xprt;

	if (xprt) {

		xprt_get(xprt);

		return rpc_create_xprt(args, xprt);

	}



	return rpc_create(args);

}



static int setup_callback_client(struct nfs4_client *clp, struct nfs4_cb_conn *conn, struct nfsd4_session *ses)

{

	struct rpc_timeout	timeparms = {
@@ -674,7 +691,7 @@ static int setup_callback_client(struct nfs4_client *clp, struct nfs4_cb_conn *c 
		args.authflavor = ses->se_cb_sec.flavor;

	}

	/* Create RPC client */

	client = rpc_create(&args);

	client = create_backchannel_client(&args);

	if (IS_ERR(client)) {

		dprintk("NFSD: couldn't create callback client: %ld\n",

			PTR_ERR(client));

fs/nfsd/nfs4proc.c

+25 −14
Original line number Diff line number Diff line
@@ -1273,6 +1273,8 @@ nfsd4_proc_compound(struct svc_rqst *rqstp, 
	struct nfsd4_op	*op;

	struct nfsd4_operation *opdesc;

	struct nfsd4_compound_state *cstate = &resp->cstate;

	struct svc_fh *current_fh = &cstate->current_fh;

	struct svc_fh *save_fh = &cstate->save_fh;

	int		slack_bytes;

	u32		plen = 0;

	__be32		status;
@@ -1288,11 +1290,11 @@ nfsd4_proc_compound(struct svc_rqst *rqstp, 
	resp->tag = args->tag;

	resp->opcnt = 0;

	resp->rqstp = rqstp;

	resp->cstate.minorversion = args->minorversion;

	resp->cstate.replay_owner = NULL;

	resp->cstate.session = NULL;

	fh_init(&resp->cstate.current_fh, NFS4_FHSIZE);

	fh_init(&resp->cstate.save_fh, NFS4_FHSIZE);

	cstate->minorversion = args->minorversion;

	cstate->replay_owner = NULL;

	cstate->session = NULL;

	fh_init(current_fh, NFS4_FHSIZE);

	fh_init(save_fh, NFS4_FHSIZE);

	/*

	 * Don't use the deferral mechanism for NFSv4; compounds make it

	 * too hard to avoid non-idempotency problems.
@@ -1345,20 +1347,28 @@ nfsd4_proc_compound(struct svc_rqst *rqstp, 


		opdesc = OPDESC(op);



		if (!cstate->current_fh.fh_dentry) {

		if (!current_fh->fh_dentry) {

			if (!(opdesc->op_flags & ALLOWED_WITHOUT_FH)) {

				op->status = nfserr_nofilehandle;

				goto encode_op;

			}

		} else if (cstate->current_fh.fh_export->ex_fslocs.migrated &&

		} else if (current_fh->fh_export->ex_fslocs.migrated &&

			  !(opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) {

			op->status = nfserr_moved;

			goto encode_op;

		}



		fh_clear_wcc(current_fh);



		/* If op is non-idempotent */

		if (opdesc->op_flags & OP_MODIFIES_SOMETHING) {

			plen = opdesc->op_rsize_bop(rqstp, op);

			/*

			 * If there's still another operation, make sure

			 * we'll have space to at least encode an error:

			 */

			if (resp->opcnt < args->opcnt)

				plen += COMPOUND_ERR_SLACK_SPACE;

			op->status = nfsd4_check_resp_size(resp, plen);

		}
@@ -1377,12 +1387,12 @@ nfsd4_proc_compound(struct svc_rqst *rqstp, 
				clear_current_stateid(cstate);



			if (need_wrongsec_check(rqstp))

				op->status = check_nfsd_access(cstate->current_fh.fh_export, rqstp);

				op->status = check_nfsd_access(current_fh->fh_export, rqstp);

		}



encode_op:

		/* Only from SEQUENCE */

		if (resp->cstate.status == nfserr_replay_cache) {

		if (cstate->status == nfserr_replay_cache) {

			dprintk("%s NFS4.1 replay from cache\n", __func__);

			status = op->status;

			goto out;
@@ -1411,10 +1421,10 @@ nfsd4_proc_compound(struct svc_rqst *rqstp, 
		nfsd4_increment_op_stats(op->opnum);

	}



	resp->cstate.status = status;

	fh_put(&resp->cstate.current_fh);

	fh_put(&resp->cstate.save_fh);

	BUG_ON(resp->cstate.replay_owner);

	cstate->status = status;

	fh_put(current_fh);

	fh_put(save_fh);

	BUG_ON(cstate->replay_owner);

out:

	/* Reset deferral mechanism for RPC deferrals */

	rqstp->rq_usedeferral = 1;
@@ -1523,7 +1533,8 @@ static inline u32 nfsd4_setattr_rsize(struct svc_rqst *rqstp, struct nfsd4_op *o 


static inline u32 nfsd4_setclientid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)

{

	return (op_encode_hdr_size + 2 + 1024) * sizeof(__be32);

	return (op_encode_hdr_size + 2 + XDR_QUADLEN(NFS4_VERIFIER_SIZE)) *

								sizeof(__be32);

}



static inline u32 nfsd4_write_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)