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

Commit 46121cf7 authored by Chuck Lever's avatar Chuck Lever Committed by Trond Myklebust
Browse files

SUNRPC: fix print format for tk_pid 



The tk_pid field is an unsigned short.  The proper print format specifier for
that type is %5u, not %4d.

Also clean up some miscellaneous print formatting nits.

Signed-off-by: default avatarChuck Lever <chuck.lever@oracle.com>
Signed-off-by: default avatarTrond Myklebust <Trond.Myklebust@netapp.com>
parent 8885cb36

net/sunrpc/auth.c

+13 −12
Original line number Diff line number Diff line
@@ -287,7 +287,7 @@ rpcauth_bindcred(struct rpc_task *task) 
	struct rpc_cred *ret;

	int flags = 0;



	dprintk("RPC: %4d looking up %s cred\n",

	dprintk("RPC: %5u looking up %s cred\n",

		task->tk_pid, task->tk_auth->au_ops->au_name);

	get_group_info(acred.group_info);

	if (task->tk_flags & RPC_TASK_ROOTCREDS)
@@ -304,8 +304,9 @@ rpcauth_bindcred(struct rpc_task *task) 
void

rpcauth_holdcred(struct rpc_task *task)

{

	dprintk("RPC: %4d holding %s cred %p\n",

		task->tk_pid, task->tk_auth->au_ops->au_name, task->tk_msg.rpc_cred);

	dprintk("RPC: %5u holding %s cred %p\n",

		task->tk_pid, task->tk_auth->au_ops->au_name,

		task->tk_msg.rpc_cred);

	if (task->tk_msg.rpc_cred)

		get_rpccred(task->tk_msg.rpc_cred);

}
@@ -324,7 +325,7 @@ rpcauth_unbindcred(struct rpc_task *task) 
{

	struct rpc_cred	*cred = task->tk_msg.rpc_cred;



	dprintk("RPC: %4d releasing %s cred %p\n",

	dprintk("RPC: %5u releasing %s cred %p\n",

		task->tk_pid, task->tk_auth->au_ops->au_name, cred);



	put_rpccred(cred);
@@ -336,7 +337,7 @@ rpcauth_marshcred(struct rpc_task *task, __be32 *p) 
{

	struct rpc_cred	*cred = task->tk_msg.rpc_cred;



	dprintk("RPC: %4d marshaling %s cred %p\n",

	dprintk("RPC: %5u marshaling %s cred %p\n",

		task->tk_pid, task->tk_auth->au_ops->au_name, cred);



	return cred->cr_ops->crmarshal(task, p);
@@ -347,7 +348,7 @@ rpcauth_checkverf(struct rpc_task *task, __be32 *p) 
{

	struct rpc_cred	*cred = task->tk_msg.rpc_cred;



	dprintk("RPC: %4d validating %s cred %p\n",

	dprintk("RPC: %5u validating %s cred %p\n",

		task->tk_pid, task->tk_auth->au_ops->au_name, cred);



	return cred->cr_ops->crvalidate(task, p);
@@ -359,7 +360,7 @@ rpcauth_wrap_req(struct rpc_task *task, kxdrproc_t encode, void *rqstp, 
{

	struct rpc_cred *cred = task->tk_msg.rpc_cred;



	dprintk("RPC: %4d using %s cred %p to wrap rpc data\n",

	dprintk("RPC: %5u using %s cred %p to wrap rpc data\n",

			task->tk_pid, cred->cr_ops->cr_name, cred);

	if (cred->cr_ops->crwrap_req)

		return cred->cr_ops->crwrap_req(task, encode, rqstp, data, obj);
@@ -373,7 +374,7 @@ rpcauth_unwrap_resp(struct rpc_task *task, kxdrproc_t decode, void *rqstp, 
{

	struct rpc_cred *cred = task->tk_msg.rpc_cred;



	dprintk("RPC: %4d using %s cred %p to unwrap rpc data\n",

	dprintk("RPC: %5u using %s cred %p to unwrap rpc data\n",

			task->tk_pid, cred->cr_ops->cr_name, cred);

	if (cred->cr_ops->crunwrap_resp)

		return cred->cr_ops->crunwrap_resp(task, decode, rqstp,
@@ -388,7 +389,7 @@ rpcauth_refreshcred(struct rpc_task *task) 
	struct rpc_cred	*cred = task->tk_msg.rpc_cred;

	int err;



	dprintk("RPC: %4d refreshing %s cred %p\n",

	dprintk("RPC: %5u refreshing %s cred %p\n",

		task->tk_pid, task->tk_auth->au_ops->au_name, cred);



	err = cred->cr_ops->crrefresh(task);
@@ -400,7 +401,7 @@ rpcauth_refreshcred(struct rpc_task *task) 
void

rpcauth_invalcred(struct rpc_task *task)

{

	dprintk("RPC: %4d invalidating %s cred %p\n",

	dprintk("RPC: %5u invalidating %s cred %p\n",

		task->tk_pid, task->tk_auth->au_ops->au_name, task->tk_msg.rpc_cred);

	spin_lock(&rpc_credcache_lock);

	if (task->tk_msg.rpc_cred)

net/sunrpc/auth_unix.c

+5 −4
Original line number Diff line number Diff line
@@ -39,7 +39,8 @@ static struct rpc_credops unix_credops; 
static struct rpc_auth *

unx_create(struct rpc_clnt *clnt, rpc_authflavor_t flavor)

{

	dprintk("RPC: creating UNIX authenticator for client %p\n", clnt);

	dprintk("RPC:       creating UNIX authenticator for client %p\n",

			clnt);

	if (atomic_inc_return(&unix_auth.au_count) == 0)

		unix_cred_cache.nextgc = jiffies + (unix_cred_cache.expire >> 1);

	return &unix_auth;

net/sunrpc/cache.c

+2 −1
Original line number Diff line number Diff line
@@ -215,7 +215,8 @@ int cache_check(struct cache_detail *detail, 
		if (rv == -EAGAIN)

			rv = -ENOENT;

	} else if (rv == -EAGAIN || age > refresh_age/2) {

		dprintk("Want update, refage=%ld, age=%ld\n", refresh_age, age);

		dprintk("RPC:       Want update, refage=%ld, age=%ld\n",

				refresh_age, age);

		if (!test_and_set_bit(CACHE_PENDING, &h->flags)) {

			switch (cache_make_upcall(detail, h)) {

			case -EINVAL:

net/sunrpc/clnt.c

+69 −60
Original line number Diff line number Diff line
@@ -42,6 +42,10 @@ 
# define RPCDBG_FACILITY	RPCDBG_CALL

#endif



#define dprint_status(t)					\

	dprintk("RPC: %5u %s (status %d)\n", t->tk_pid,		\

			__FUNCTION__, t->tk_status)



static DECLARE_WAIT_QUEUE_HEAD(destroy_wait);
@@ -288,7 +292,7 @@ out_no_path: 
out_no_stats:

	kfree(new);

out_no_clnt:

	dprintk("RPC: %s returned error %d\n", __FUNCTION__, err);

	dprintk("RPC:       %s: returned error %d\n", __FUNCTION__, err);

	return ERR_PTR(err);

}
@@ -654,8 +658,9 @@ call_start(struct rpc_task *task) 
{

	struct rpc_clnt	*clnt = task->tk_client;



	dprintk("RPC: %4d call_start %s%d proc %d (%s)\n", task->tk_pid,

		clnt->cl_protname, clnt->cl_vers, task->tk_msg.rpc_proc->p_proc,

	dprintk("RPC: %5u call_start %s%d proc %d (%s)\n", task->tk_pid,

			clnt->cl_protname, clnt->cl_vers,

			task->tk_msg.rpc_proc->p_proc,

			(RPC_IS_ASYNC(task) ? "async" : "sync"));



	/* Increment call count */
@@ -670,7 +675,7 @@ call_start(struct rpc_task *task) 
static void

call_reserve(struct rpc_task *task)

{

	dprintk("RPC: %4d call_reserve\n", task->tk_pid);

	dprint_status(task);



	if (!rpcauth_uptodatecred(task)) {

		task->tk_action = call_refresh;
@@ -690,8 +695,7 @@ call_reserveresult(struct rpc_task *task) 
{

	int status = task->tk_status;



	dprintk("RPC: %4d call_reserveresult (status %d)\n",

				task->tk_pid, task->tk_status);

	dprint_status(task);



	/*

	 * After a call to xprt_reserve(), we must have either
@@ -745,8 +749,8 @@ call_allocate(struct rpc_task *task) 
	struct rpc_xprt *xprt = task->tk_xprt;

	unsigned int	bufsiz;



	dprintk("RPC: %4d call_allocate (status %d)\n", 

				task->tk_pid, task->tk_status);

	dprint_status(task);



	task->tk_action = call_bind;

	if (req->rq_buffer)

		return;
@@ -757,7 +761,8 @@ call_allocate(struct rpc_task *task) 


	if (xprt->ops->buf_alloc(task, bufsiz << 1) != NULL)

		return;

	printk(KERN_INFO "RPC: buffer allocation failed for task %p\n", task); 



	dprintk("RPC: %5u rpc_buffer allocation failed\n", task->tk_pid);



	if (RPC_IS_ASYNC(task) || !signalled()) {

		xprt_release(task);
@@ -794,8 +799,7 @@ call_encode(struct rpc_task *task) 
	kxdrproc_t	encode;

	__be32		*p;



	dprintk("RPC: %4d call_encode (status %d)\n", 

				task->tk_pid, task->tk_status);

	dprint_status(task);



	/* Default buffer setup */

	bufsiz = req->rq_bufsize >> 1;
@@ -841,8 +845,7 @@ call_bind(struct rpc_task *task) 
{

	struct rpc_xprt *xprt = task->tk_xprt;



	dprintk("RPC: %4d call_bind (status %d)\n",

				task->tk_pid, task->tk_status);

	dprint_status(task);



	task->tk_action = call_connect;

	if (!xprt_bound(xprt)) {
@@ -861,8 +864,7 @@ call_bind_status(struct rpc_task *task) 
	int status = -EACCES;



	if (task->tk_status >= 0) {

		dprintk("RPC: %4d call_bind_status (status %d)\n",

					task->tk_pid, task->tk_status);

		dprint_status(task);

		task->tk_status = 0;

		task->tk_action = call_connect;

		return;
@@ -870,24 +872,24 @@ call_bind_status(struct rpc_task *task) 


	switch (task->tk_status) {

	case -EACCES:

		dprintk("RPC: %4d remote rpcbind: RPC program/version unavailable\n",

				task->tk_pid);

		dprintk("RPC: %5u remote rpcbind: RPC program/version "

				"unavailable\n", task->tk_pid);

		rpc_delay(task, 3*HZ);

		goto retry_timeout;

	case -ETIMEDOUT:

		dprintk("RPC: %4d rpcbind request timed out\n",

		dprintk("RPC: %5u rpcbind request timed out\n",

				task->tk_pid);

		goto retry_timeout;

	case -EPFNOSUPPORT:

		dprintk("RPC: %4d remote rpcbind service unavailable\n",

		dprintk("RPC: %5u remote rpcbind service unavailable\n",

				task->tk_pid);

		break;

	case -EPROTONOSUPPORT:

		dprintk("RPC: %4d remote rpcbind version 2 unavailable\n",

		dprintk("RPC: %5u remote rpcbind version 2 unavailable\n",

				task->tk_pid);

		break;

	default:

		dprintk("RPC: %4d unrecognized rpcbind error (%d)\n",

		dprintk("RPC: %5u unrecognized rpcbind error (%d)\n",

				task->tk_pid, -task->tk_status);

		status = -EIO;

	}
@@ -907,7 +909,7 @@ call_connect(struct rpc_task *task) 
{

	struct rpc_xprt *xprt = task->tk_xprt;



	dprintk("RPC: %4d call_connect xprt %p %s connected\n",

	dprintk("RPC: %5u call_connect xprt %p %s connected\n",

			task->tk_pid, xprt,

			(xprt_connected(xprt) ? "is" : "is not"));
@@ -929,8 +931,7 @@ call_connect_status(struct rpc_task *task) 
	struct rpc_clnt *clnt = task->tk_client;

	int status = task->tk_status;



	dprintk("RPC: %5u call_connect_status (status %d)\n", 

				task->tk_pid, task->tk_status);

	dprint_status(task);



	task->tk_status = 0;

	if (status >= 0) {
@@ -962,8 +963,7 @@ call_connect_status(struct rpc_task *task) 
static void

call_transmit(struct rpc_task *task)

{

	dprintk("RPC: %4d call_transmit (status %d)\n", 

				task->tk_pid, task->tk_status);

	dprint_status(task);



	task->tk_action = call_status;

	if (task->tk_status < 0)
@@ -1024,8 +1024,7 @@ call_status(struct rpc_task *task) 
	if (req->rq_received > 0 && !req->rq_bytes_sent)

		task->tk_status = req->rq_received;



	dprintk("RPC: %4d call_status (status %d)\n", 

				task->tk_pid, task->tk_status);

	dprint_status(task);



	status = task->tk_status;

	if (status >= 0) {
@@ -1076,11 +1075,11 @@ call_timeout(struct rpc_task *task) 
	struct rpc_clnt	*clnt = task->tk_client;



	if (xprt_adjust_timeout(task->tk_rqstp) == 0) {

		dprintk("RPC: %4d call_timeout (minor)\n", task->tk_pid);

		dprintk("RPC: %5u call_timeout (minor)\n", task->tk_pid);

		goto retry;

	}



	dprintk("RPC: %4d call_timeout (major)\n", task->tk_pid);

	dprintk("RPC: %5u call_timeout (major)\n", task->tk_pid);

	task->tk_timeouts++;



	if (RPC_IS_SOFT(task)) {
@@ -1114,7 +1113,7 @@ call_decode(struct rpc_task *task) 
	kxdrproc_t	decode = task->tk_msg.rpc_proc->p_decode;

	__be32		*p;



	dprintk("RPC: %4d call_decode (status %d)\n", 

	dprintk("RPC: %5u call_decode (status %d)\n",

			task->tk_pid, task->tk_status);



	if (task->tk_flags & RPC_CALL_MAJORSEEN) {
@@ -1129,7 +1128,7 @@ call_decode(struct rpc_task *task) 
			clnt->cl_stats->rpcretrans++;

			goto out_retry;

		}

		dprintk("%s: too small RPC reply size (%d bytes)\n",

		dprintk("RPC:       %s: too small RPC reply size (%d bytes)\n",

				clnt->cl_protname, task->tk_status);

		task->tk_action = call_timeout;

		goto out_retry;
@@ -1162,7 +1161,7 @@ call_decode(struct rpc_task *task) 
						      task->tk_msg.rpc_resp);

		unlock_kernel();

	}

	dprintk("RPC: %4d call_decode result %d\n", task->tk_pid,

	dprintk("RPC: %5u call_decode result %d\n", task->tk_pid,

			task->tk_status);

	return;

out_retry:
@@ -1176,7 +1175,7 @@ out_retry: 
static void

call_refresh(struct rpc_task *task)

{

	dprintk("RPC: %4d call_refresh\n", task->tk_pid);

	dprint_status(task);



	xprt_release(task);	/* Must do to obtain new XID */

	task->tk_action = call_refreshresult;
@@ -1192,8 +1191,8 @@ static void 
call_refreshresult(struct rpc_task *task)

{

	int status = task->tk_status;

	dprintk("RPC: %4d call_refreshresult (status %d)\n", 

				task->tk_pid, task->tk_status);



	dprint_status(task);



	task->tk_status = 0;

	task->tk_action = call_reserve;
@@ -1271,11 +1270,15 @@ call_verify(struct rpc_task *task) 
			case RPC_AUTH_ERROR:

				break;

			case RPC_MISMATCH:

				dprintk("%s: RPC call version mismatch!\n", __FUNCTION__);

				dprintk("RPC: %5u %s: RPC call version "

						"mismatch!\n",

						task->tk_pid, __FUNCTION__);

				error = -EPROTONOSUPPORT;

				goto out_err;

			default:

				dprintk("%s: RPC call rejected, unknown error: %x\n", __FUNCTION__, n);

				dprintk("RPC: %5u %s: RPC call rejected, "

						"unknown error: %x\n",

						task->tk_pid, __FUNCTION__, n);

				goto out_eio;

		}

		if (--len < 0)
@@ -1288,8 +1291,8 @@ call_verify(struct rpc_task *task) 
			if (!task->tk_cred_retry)

				break;

			task->tk_cred_retry--;

			dprintk("RPC: %4d call_verify: retry stale creds\n",

							task->tk_pid);

			dprintk("RPC: %5u %s: retry stale creds\n",

					task->tk_pid, __FUNCTION__);

			rpcauth_invalcred(task);

			task->tk_action = call_refresh;

			goto out_retry;
@@ -1299,8 +1302,8 @@ call_verify(struct rpc_task *task) 
			if (!task->tk_garb_retry)

				break;

			task->tk_garb_retry--;

			dprintk("RPC: %4d call_verify: retry garbled creds\n",

							task->tk_pid);

			dprintk("RPC: %5u %s: retry garbled creds\n",

					task->tk_pid, __FUNCTION__);

			task->tk_action = call_bind;

			goto out_retry;

		case RPC_AUTH_TOOWEAK:
@@ -1311,8 +1314,8 @@ call_verify(struct rpc_task *task) 
			printk(KERN_WARNING "call_verify: unknown auth error: %x\n", n);

			error = -EIO;

		}

		dprintk("RPC: %4d call_verify: call rejected %d\n",

						task->tk_pid, n);

		dprintk("RPC: %5u %s: call rejected %d\n",

				task->tk_pid, __FUNCTION__, n);

		goto out_err;

	}

	if (!(p = rpcauth_checkverf(task, p))) {
@@ -1326,20 +1329,24 @@ call_verify(struct rpc_task *task) 
	case RPC_SUCCESS:

		return p;

	case RPC_PROG_UNAVAIL:

		dprintk("RPC: call_verify: program %u is unsupported by server %s\n",

		dprintk("RPC: %5u %s: program %u is unsupported by server %s\n",

				task->tk_pid, __FUNCTION__,

				(unsigned int)task->tk_client->cl_prog,

				task->tk_client->cl_server);

		error = -EPFNOSUPPORT;

		goto out_err;

	case RPC_PROG_MISMATCH:

		dprintk("RPC: call_verify: program %u, version %u unsupported by server %s\n",

		dprintk("RPC: %5u %s: program %u, version %u unsupported by "

				"server %s\n", task->tk_pid, __FUNCTION__,

				(unsigned int)task->tk_client->cl_prog,

				(unsigned int)task->tk_client->cl_vers,

				task->tk_client->cl_server);

		error = -EPROTONOSUPPORT;

		goto out_err;

	case RPC_PROC_UNAVAIL:

		dprintk("RPC: call_verify: proc %p unsupported by program %u, version %u on server %s\n",

		dprintk("RPC: %5u %s: proc %p unsupported by program %u, "

				"version %u on server %s\n",

				task->tk_pid, __FUNCTION__,

				task->tk_msg.rpc_proc,

				task->tk_client->cl_prog,

				task->tk_client->cl_vers,
@@ -1347,7 +1354,8 @@ call_verify(struct rpc_task *task) 
		error = -EOPNOTSUPP;

		goto out_err;

	case RPC_GARBAGE_ARGS:

		dprintk("RPC: %4d %s: server saw garbage\n", task->tk_pid, __FUNCTION__);

		dprintk("RPC: %5u %s: server saw garbage\n",

				task->tk_pid, __FUNCTION__);

		break;			/* retry */

	default:

		printk(KERN_WARNING "call_verify: server accept status: %x\n", n);
@@ -1358,7 +1366,8 @@ out_garbage: 
	task->tk_client->cl_stats->rpcgarbage++;

	if (task->tk_garb_retry) {

		task->tk_garb_retry--;

		dprintk("RPC %s: retrying %4d\n", __FUNCTION__, task->tk_pid);

		dprintk("RPC: %5u %s: retrying\n",

				task->tk_pid, __FUNCTION__);

		task->tk_action = call_bind;

out_retry:

		return ERR_PTR(-EAGAIN);

net/sunrpc/pmap_clnt.c

+10 −8
Original line number Diff line number Diff line
@@ -97,7 +97,7 @@ void rpc_getport(struct rpc_task *task) 
	struct rpc_task *child;

	int status;



	dprintk("RPC: %4d rpc_getport(%s, %u, %u, %d)\n",

	dprintk("RPC: %5u rpc_getport(%s, %u, %u, %d)\n",

			task->tk_pid, clnt->cl_server,

			clnt->cl_prog, clnt->cl_vers, xprt->prot);
@@ -221,7 +221,7 @@ static void pmap_getport_done(struct rpc_task *child, void *data) 
		status = 0;

	}



	dprintk("RPC: %4d pmap_getport_done(status %d, port %u)\n",

	dprintk("RPC: %5u pmap_getport_done(status %d, port %u)\n",

			child->tk_pid, status, map->pm_port);



	pmap_wake_portmap_waiters(xprt, status);
@@ -263,7 +263,8 @@ int rpc_register(u32 prog, u32 vers, int prot, unsigned short port, int *okay) 
	pmap_clnt = pmap_create("localhost", &sin, IPPROTO_UDP, 1);

	if (IS_ERR(pmap_clnt)) {

		error = PTR_ERR(pmap_clnt);

		dprintk("RPC: couldn't create pmap client. Error = %d\n", error);

		dprintk("RPC:       couldn't create pmap client. Error = %d\n",

				error);

		return error;

	}
@@ -306,7 +307,8 @@ static struct rpc_clnt *pmap_create(char *hostname, struct sockaddr_in *srvaddr, 
static int xdr_encode_mapping(struct rpc_rqst *req, __be32 *p, struct portmap_args *map)

{

	dprintk("RPC:       xdr_encode_mapping(%u, %u, %u, %u)\n",

		map->pm_prog, map->pm_vers, map->pm_prot, map->pm_port);

			map->pm_prog, map->pm_vers,

			map->pm_prot, map->pm_port);

	*p++ = htonl(map->pm_prog);

	*p++ = htonl(map->pm_vers);

	*p++ = htonl(map->pm_prot);