FEX-Emu/linux
1
0
Fork 0
mirror of https://github.com/FEX-Emu/linux.git synced 2025-03-06 19:51:13 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

SUNRPC: Move clnt->cl_server into struct rpc_xprt

Browse Source 
When the cl_xprt field is updated, the cl_server field will also have
to change.  Since the contents of cl_server follow the remote endpoint
of cl_xprt, just move that field to the rpc_xprt.

Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
[ cel: simplify check_gss_callback_principal(), whitespace changes ]
[ cel: forward ported to 3.4 ]
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
This commit is contained in:
Trond Myklebust 2012-03-01 17:01:05 -05:00
parent 2446ab6070
commit 4e0038b6b2
8 changed files with 66 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
fs/nfs/callback.c
View File

@ -332,7 +332,6 @@ void nfs_callback_down(int minorversion)
int int
check_gss_callback_principal(struct nfs_client *clp, struct svc_rqst *rqstp) check_gss_callback_principal(struct nfs_client *clp, struct svc_rqst *rqstp)
{ {
struct rpc_clnt *r = clp->cl_rpcclient;
char *p = svc_gss_principal(rqstp); char *p = svc_gss_principal(rqstp);
if (rqstp->rq_authop->flavour != RPC_AUTH_GSS) if (rqstp->rq_authop->flavour != RPC_AUTH_GSS)
@ -353,7 +352,7 @@ check_gss_callback_principal(struct nfs_client *clp, struct svc_rqst *rqstp)
if (memcmp(p, "nfs@", 4) != 0) if (memcmp(p, "nfs@", 4) != 0)
return 0; return 0;
p += 4; p += 4;
if (strcmp(p, r->cl_server) != 0) if (strcmp(p, clp->cl_hostname) != 0)
return 0; return 0;
return 1; return 1;
} }

3
fs/nfs/nfs4proc.c
View File

@ -1100,6 +1100,7 @@ static struct nfs4_state *nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data
if (state == NULL) if (state == NULL)
goto err_put_inode; goto err_put_inode;
if (data->o_res.delegation_type != 0) { if (data->o_res.delegation_type != 0) {
struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
int delegation_flags = 0; int delegation_flags = 0;
rcu_read_lock(); rcu_read_lock();
@ -1111,7 +1112,7 @@ static struct nfs4_state *nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data
pr_err_ratelimited("NFS: Broken NFSv4 server %s is " pr_err_ratelimited("NFS: Broken NFSv4 server %s is "
"returning a delegation for " "returning a delegation for "
"OPEN(CLAIM_DELEGATE_CUR)\n", "OPEN(CLAIM_DELEGATE_CUR)\n",
NFS_CLIENT(inode)->cl_server); clp->cl_hostname);
} else if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0) } else if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0)
nfs_inode_set_delegation(state->inode, nfs_inode_set_delegation(state->inode,
data->owner->so_cred, data->owner->so_cred,

1
include/linux/sunrpc/clnt.h
View File

@ -41,7 +41,6 @@ struct rpc_clnt {
cl_vers, /* RPC version number */ cl_vers, /* RPC version number */
cl_maxproc; /* max procedure number */ cl_maxproc; /* max procedure number */
const char * cl_server; /* server machine name */
const char * cl_protname; /* protocol name */ const char * cl_protname; /* protocol name */
struct rpc_auth * cl_auth; /* authenticator */ struct rpc_auth * cl_auth; /* authenticator */
struct rpc_stat * cl_stats; /* per-program statistics */ struct rpc_stat * cl_stats; /* per-program statistics */

2
include/linux/sunrpc/xprt.h
View File

@ -229,6 +229,7 @@ struct rpc_xprt {
} stat; } stat;
struct net *xprt_net; struct net *xprt_net;
const char *servername;
const char *address_strings[RPC_DISPLAY_MAX]; const char *address_strings[RPC_DISPLAY_MAX];
}; };
@ -258,6 +259,7 @@ struct xprt_create {
struct sockaddr * srcaddr; /* optional local address */ struct sockaddr * srcaddr; /* optional local address */
struct sockaddr * dstaddr; /* remote peer address */ struct sockaddr * dstaddr; /* remote peer address */
size_t addrlen; size_t addrlen;
const char *servername;
struct svc_xprt *bc_xprt; /* NFSv4.1 backchannel */ struct svc_xprt *bc_xprt; /* NFSv4.1 backchannel */
}; };

88
net/sunrpc/clnt.c
View File

@ -265,15 +265,8 @@ static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args, stru
struct rpc_clnt *clnt = NULL; struct rpc_clnt *clnt = NULL;
struct rpc_auth *auth; struct rpc_auth *auth;
int err; int err;
size_t len;
/* sanity check the name before trying to print it */ /* sanity check the name before trying to print it */
err = -EINVAL;
len = strlen(args->servername);
if (len > RPC_MAXNETNAMELEN)
goto out_no_rpciod;
len++;
dprintk("RPC: creating %s client for %s (xprt %p)\n", dprintk("RPC: creating %s client for %s (xprt %p)\n",
program->name, args->servername, xprt); program->name, args->servername, xprt);
@ -296,10 +289,6 @@ static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args, stru
goto out_err; goto out_err;
clnt->cl_parent = clnt; clnt->cl_parent = clnt;
clnt->cl_server = kstrdup(args->servername, GFP_KERNEL);
if (clnt->cl_server == NULL)
goto out_no_server;
rcu_assign_pointer(clnt->cl_xprt, xprt); rcu_assign_pointer(clnt->cl_xprt, xprt);
clnt->cl_procinfo = version->procs; clnt->cl_procinfo = version->procs;
clnt->cl_maxproc = version->nrprocs; clnt->cl_maxproc = version->nrprocs;
@ -363,8 +352,6 @@ out_no_path:
out_no_principal: out_no_principal:
rpc_free_iostats(clnt->cl_metrics); rpc_free_iostats(clnt->cl_metrics);
out_no_stats: out_no_stats:
kfree(clnt->cl_server);
out_no_server:
kfree(clnt); kfree(clnt);
out_err: out_err:
xprt_put(xprt); xprt_put(xprt);
@ -394,6 +381,7 @@ struct rpc_clnt *rpc_create(struct rpc_create_args *args)
.srcaddr = args->saddress, .srcaddr = args->saddress,
.dstaddr = args->address, .dstaddr = args->address,
.addrlen = args->addrsize, .addrlen = args->addrsize,
.servername = args->servername,
.bc_xprt = args->bc_xprt, .bc_xprt = args->bc_xprt,
}; };
char servername[48]; char servername[48];
@ -402,7 +390,7 @@ struct rpc_clnt *rpc_create(struct rpc_create_args *args)
* If the caller chooses not to specify a hostname, whip * If the caller chooses not to specify a hostname, whip
* up a string representation of the passed-in address. * up a string representation of the passed-in address.
*/ */
if (args->servername == NULL) { if (xprtargs.servername == NULL) {
struct sockaddr_un *sun = struct sockaddr_un *sun =
(struct sockaddr_un *)args->address; (struct sockaddr_un *)args->address;
struct sockaddr_in *sin = struct sockaddr_in *sin =
@ -429,7 +417,7 @@ struct rpc_clnt *rpc_create(struct rpc_create_args *args)
* address family isn't recognized. */ * address family isn't recognized. */
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
} }
args->servername = servername; xprtargs.servername = servername;
} }
xprt = xprt_create_transport(&xprtargs); xprt = xprt_create_transport(&xprtargs);
@ -488,9 +476,6 @@ rpc_clone_client(struct rpc_clnt *clnt)
new = kmemdup(clnt, sizeof(*new), GFP_KERNEL); new = kmemdup(clnt, sizeof(*new), GFP_KERNEL);
if (!new) if (!new)
goto out_no_clnt; goto out_no_clnt;
new->cl_server = kstrdup(clnt->cl_server, GFP_KERNEL);
if (new->cl_server == NULL)
goto out_no_server;
new->cl_parent = clnt; new->cl_parent = clnt;
/* Turn off autobind on clones */ /* Turn off autobind on clones */
new->cl_autobind = 0; new->cl_autobind = 0;
@ -528,8 +513,6 @@ out_no_transport:
out_no_principal: out_no_principal:
rpc_free_iostats(new->cl_metrics); rpc_free_iostats(new->cl_metrics);
out_no_stats: out_no_stats:
kfree(new->cl_server);
out_no_server:
kfree(new); kfree(new);
out_no_clnt: out_no_clnt:
dprintk("RPC: %s: returned error %d\n", __func__, err); dprintk("RPC: %s: returned error %d\n", __func__, err);
@ -574,8 +557,9 @@ EXPORT_SYMBOL_GPL(rpc_killall_tasks);
*/ */
void rpc_shutdown_client(struct rpc_clnt *clnt) void rpc_shutdown_client(struct rpc_clnt *clnt)
{ {
dprintk("RPC: shutting down %s client for %s\n", dprintk_rcu("RPC: shutting down %s client for %s\n",
clnt->cl_protname, clnt->cl_server); clnt->cl_protname,
rcu_dereference(clnt->cl_xprt)->servername);
while (!list_empty(&clnt->cl_tasks)) { while (!list_empty(&clnt->cl_tasks)) {
rpc_killall_tasks(clnt); rpc_killall_tasks(clnt);
@ -593,11 +577,11 @@ EXPORT_SYMBOL_GPL(rpc_shutdown_client);
static void static void
rpc_free_client(struct rpc_clnt *clnt) rpc_free_client(struct rpc_clnt *clnt)
{ {
dprintk("RPC: destroying %s client for %s\n", dprintk_rcu("RPC: destroying %s client for %s\n",
clnt->cl_protname, clnt->cl_server); clnt->cl_protname,
rcu_dereference(clnt->cl_xprt)->servername);
if (clnt->cl_parent != clnt) if (clnt->cl_parent != clnt)
rpc_release_client(clnt->cl_parent); rpc_release_client(clnt->cl_parent);
kfree(clnt->cl_server);
rpc_unregister_client(clnt); rpc_unregister_client(clnt);
rpc_clnt_remove_pipedir(clnt); rpc_clnt_remove_pipedir(clnt);
rpc_free_iostats(clnt->cl_metrics); rpc_free_iostats(clnt->cl_metrics);
@ -1685,8 +1669,11 @@ call_timeout(struct rpc_task *task)
} }
if (RPC_IS_SOFT(task)) { if (RPC_IS_SOFT(task)) {
if (clnt->cl_chatty) if (clnt->cl_chatty)
rcu_read_lock();
printk(KERN_NOTICE "%s: server %s not responding, timed out\n", printk(KERN_NOTICE "%s: server %s not responding, timed out\n",
clnt->cl_protname, clnt->cl_server); clnt->cl_protname,
rcu_dereference(clnt->cl_xprt)->servername);
rcu_read_unlock();
if (task->tk_flags & RPC_TASK_TIMEOUT) if (task->tk_flags & RPC_TASK_TIMEOUT)
rpc_exit(task, -ETIMEDOUT); rpc_exit(task, -ETIMEDOUT);
else else
@ -1696,9 +1683,13 @@ call_timeout(struct rpc_task *task)
if (!(task->tk_flags & RPC_CALL_MAJORSEEN)) { if (!(task->tk_flags & RPC_CALL_MAJORSEEN)) {
task->tk_flags |= RPC_CALL_MAJORSEEN; task->tk_flags |= RPC_CALL_MAJORSEEN;
if (clnt->cl_chatty) if (clnt->cl_chatty) {
rcu_read_lock();
printk(KERN_NOTICE "%s: server %s not responding, still trying\n", printk(KERN_NOTICE "%s: server %s not responding, still trying\n",
clnt->cl_protname, clnt->cl_server); clnt->cl_protname,
rcu_dereference(clnt->cl_xprt)->servername);
rcu_read_unlock();
}
} }
rpc_force_rebind(clnt); rpc_force_rebind(clnt);
/* /*
@ -1727,9 +1718,13 @@ call_decode(struct rpc_task *task)
dprint_status(task); dprint_status(task);
if (task->tk_flags & RPC_CALL_MAJORSEEN) { if (task->tk_flags & RPC_CALL_MAJORSEEN) {
if (clnt->cl_chatty) if (clnt->cl_chatty) {
rcu_read_lock();
printk(KERN_NOTICE "%s: server %s OK\n", printk(KERN_NOTICE "%s: server %s OK\n",
clnt->cl_protname, clnt->cl_server); clnt->cl_protname,
rcu_dereference(clnt->cl_xprt)->servername);
rcu_read_unlock();
}
task->tk_flags &= ~RPC_CALL_MAJORSEEN; task->tk_flags &= ~RPC_CALL_MAJORSEEN;
} }
@ -1807,6 +1802,7 @@ rpc_encode_header(struct rpc_task *task)
static __be32 * static __be32 *
rpc_verify_header(struct rpc_task *task) rpc_verify_header(struct rpc_task *task)
{ {
struct rpc_clnt *clnt = task->tk_client;
struct kvec *iov = &task->tk_rqstp->rq_rcv_buf.head[0]; struct kvec *iov = &task->tk_rqstp->rq_rcv_buf.head[0];
int len = task->tk_rqstp->rq_rcv_buf.len >> 2; int len = task->tk_rqstp->rq_rcv_buf.len >> 2;
__be32 *p = iov->iov_base; __be32 *p = iov->iov_base;
@ -1879,8 +1875,11 @@ rpc_verify_header(struct rpc_task *task)
task->tk_action = call_bind; task->tk_action = call_bind;
goto out_retry; goto out_retry;
case RPC_AUTH_TOOWEAK: case RPC_AUTH_TOOWEAK:
rcu_read_lock();
printk(KERN_NOTICE "RPC: server %s requires stronger " printk(KERN_NOTICE "RPC: server %s requires stronger "
"authentication.\n", task->tk_client->cl_server); "authentication.\n",
rcu_dereference(clnt->cl_xprt)->servername);
rcu_read_unlock();
break; break;
default: default:
dprintk("RPC: %5u %s: unknown auth error: %x\n", dprintk("RPC: %5u %s: unknown auth error: %x\n",
@ -1903,28 +1902,27 @@ rpc_verify_header(struct rpc_task *task)
case RPC_SUCCESS: case RPC_SUCCESS:
return p; return p;
case RPC_PROG_UNAVAIL: case RPC_PROG_UNAVAIL:
dprintk("RPC: %5u %s: program %u is unsupported by server %s\n", dprintk_rcu("RPC: %5u %s: program %u is unsupported "
task->tk_pid, __func__, "by server %s\n", task->tk_pid, __func__,
(unsigned int)task->tk_client->cl_prog, (unsigned int)clnt->cl_prog,
task->tk_client->cl_server); rcu_dereference(clnt->cl_xprt)->servername);
error = -EPFNOSUPPORT; error = -EPFNOSUPPORT;
goto out_err; goto out_err;
case RPC_PROG_MISMATCH: case RPC_PROG_MISMATCH:
dprintk("RPC: %5u %s: program %u, version %u unsupported by " dprintk_rcu("RPC: %5u %s: program %u, version %u unsupported "
"server %s\n", task->tk_pid, __func__, "by server %s\n", task->tk_pid, __func__,
(unsigned int)task->tk_client->cl_prog, (unsigned int)clnt->cl_prog,
(unsigned int)task->tk_client->cl_vers, (unsigned int)clnt->cl_vers,
task->tk_client->cl_server); rcu_dereference(clnt->cl_xprt)->servername);
error = -EPROTONOSUPPORT; error = -EPROTONOSUPPORT;
goto out_err; goto out_err;
case RPC_PROC_UNAVAIL: case RPC_PROC_UNAVAIL:
dprintk("RPC: %5u %s: proc %s unsupported by program %u, " dprintk_rcu("RPC: %5u %s: proc %s unsupported by program %u, "
"version %u on server %s\n", "version %u on server %s\n",
task->tk_pid, __func__, task->tk_pid, __func__,
rpc_proc_name(task), rpc_proc_name(task),
task->tk_client->cl_prog, clnt->cl_prog, clnt->cl_vers,
task->tk_client->cl_vers, rcu_dereference(clnt->cl_xprt)->servername);
task->tk_client->cl_server);
error = -EOPNOTSUPP; error = -EOPNOTSUPP;
goto out_err; goto out_err;
case RPC_GARBAGE_ARGS: case RPC_GARBAGE_ARGS:
@ -1938,7 +1936,7 @@ rpc_verify_header(struct rpc_task *task)
} }
out_garbage: out_garbage:
task->tk_client->cl_stats->rpcgarbage++; clnt->cl_stats->rpcgarbage++;
if (task->tk_garb_retry) { if (task->tk_garb_retry) {
task->tk_garb_retry--; task->tk_garb_retry--;
dprintk("RPC: %5u %s: retrying\n", dprintk("RPC: %5u %s: retrying\n",

3
net/sunrpc/rpc_pipe.c
View File

@ -404,7 +404,8 @@ rpc_show_info(struct seq_file *m, void *v)
struct rpc_clnt *clnt = m->private; struct rpc_clnt *clnt = m->private;
rcu_read_lock(); rcu_read_lock();
seq_printf(m, "RPC server: %s\n", clnt->cl_server); seq_printf(m, "RPC server: %s\n",
rcu_dereference(clnt->cl_xprt)->servername);
seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_protname, seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_protname,
clnt->cl_prog, clnt->cl_vers); clnt->cl_prog, clnt->cl_vers);
seq_printf(m, "address: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_ADDR)); seq_printf(m, "address: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_ADDR));

4
net/sunrpc/rpcb_clnt.c
View File

@ -663,7 +663,7 @@ void rpcb_getport_async(struct rpc_task *task)
dprintk("RPC: %5u %s(%s, %u, %u, %d)\n", dprintk("RPC: %5u %s(%s, %u, %u, %d)\n",
task->tk_pid, __func__, task->tk_pid, __func__,
clnt->cl_server, clnt->cl_prog, clnt->cl_vers, xprt->prot); xprt->servername, clnt->cl_prog, clnt->cl_vers, xprt->prot);
/* Put self on the wait queue to ensure we get notified if /* Put self on the wait queue to ensure we get notified if
* some other task is already attempting to bind the port */ * some other task is already attempting to bind the port */
@ -714,7 +714,7 @@ void rpcb_getport_async(struct rpc_task *task)
dprintk("RPC: %5u %s: trying rpcbind version %u\n", dprintk("RPC: %5u %s: trying rpcbind version %u\n",
task->tk_pid, __func__, bind_version); task->tk_pid, __func__, bind_version);
rpcb_clnt = rpcb_create(xprt->xprt_net, clnt->cl_server, sap, salen, rpcb_clnt = rpcb_create(xprt->xprt_net, xprt->servername, sap, salen,
xprt->prot, bind_version); xprt->prot, bind_version);
if (IS_ERR(rpcb_clnt)) { if (IS_ERR(rpcb_clnt)) {
status = PTR_ERR(rpcb_clnt); status = PTR_ERR(rpcb_clnt);

15
net/sunrpc/xprt.c
View File

@ -66,6 +66,7 @@ static void xprt_init(struct rpc_xprt *xprt, struct net *net);
static void xprt_request_init(struct rpc_task *, struct rpc_xprt *); static void xprt_request_init(struct rpc_task *, struct rpc_xprt *);
static void xprt_connect_status(struct rpc_task *task); static void xprt_connect_status(struct rpc_task *task);
static int __xprt_get_cong(struct rpc_xprt *, struct rpc_task *); static int __xprt_get_cong(struct rpc_xprt *, struct rpc_task *);
static void xprt_destroy(struct rpc_xprt *xprt);
static DEFINE_SPINLOCK(xprt_list_lock); static DEFINE_SPINLOCK(xprt_list_lock);
static LIST_HEAD(xprt_list); static LIST_HEAD(xprt_list);
@ -751,7 +752,7 @@ static void xprt_connect_status(struct rpc_task *task)
default: default:
dprintk("RPC: %5u xprt_connect_status: error %d connecting to " dprintk("RPC: %5u xprt_connect_status: error %d connecting to "
"server %s\n", task->tk_pid, -task->tk_status, "server %s\n", task->tk_pid, -task->tk_status,
task->tk_client->cl_server); xprt->servername);
xprt_release_write(xprt, task); xprt_release_write(xprt, task);
task->tk_status = -EIO; task->tk_status = -EIO;
} }
@ -1229,6 +1230,17 @@ found:
(unsigned long)xprt); (unsigned long)xprt);
else else
init_timer(&xprt->timer); init_timer(&xprt->timer);
if (strlen(args->servername) > RPC_MAXNETNAMELEN) {
xprt_destroy(xprt);
return ERR_PTR(-EINVAL);
}
xprt->servername = kstrdup(args->servername, GFP_KERNEL);
if (xprt->servername == NULL) {
xprt_destroy(xprt);
return ERR_PTR(-ENOMEM);
}
dprintk("RPC: created transport %p with %u slots\n", xprt, dprintk("RPC: created transport %p with %u slots\n", xprt,
xprt->max_reqs); xprt->max_reqs);
out: out:
@ -1251,6 +1263,7 @@ static void xprt_destroy(struct rpc_xprt *xprt)
rpc_destroy_wait_queue(&xprt->sending); rpc_destroy_wait_queue(&xprt->sending);
rpc_destroy_wait_queue(&xprt->backlog); rpc_destroy_wait_queue(&xprt->backlog);
cancel_work_sync(&xprt->task_cleanup); cancel_work_sync(&xprt->task_cleanup);
kfree(xprt->servername);
/* /*
* Tear down transport state and free the rpc_xprt * Tear down transport state and free the rpc_xprt
*/ */