Lines Matching defs:clnt
2 * linux/net/sunrpc/clnt.c
37 #include <linux/sunrpc/clnt.h>
82 static int rpc_ping(struct rpc_clnt *clnt);
84 static void rpc_register_client(struct rpc_clnt *clnt)
87 list_add(&clnt->cl_clients, &all_clients);
91 static void rpc_unregister_client(struct rpc_clnt *clnt)
94 list_del(&clnt->cl_clients);
99 rpc_setup_pipedir(struct rpc_clnt *clnt, char *dir_name)
110 clnt->cl_path.mnt = ERR_PTR(-ENOENT);
111 clnt->cl_path.dentry = ERR_PTR(-ENOENT);
123 q.len = snprintf(name, sizeof(name), "clnt%x", (unsigned int)clntid++);
126 path.dentry = rpc_create_client_dir(nd.path.dentry, &q, clnt);
138 clnt->cl_path = path;
151 struct rpc_clnt *clnt = NULL;
180 clnt = kzalloc(sizeof(*clnt), GFP_KERNEL);
181 if (!clnt)
183 clnt->cl_parent = clnt;
185 clnt->cl_server = clnt->cl_inline_name;
186 if (len > sizeof(clnt->cl_inline_name)) {
189 clnt->cl_server = buf;
191 len = sizeof(clnt->cl_inline_name);
193 strlcpy(clnt->cl_server, args->servername, len);
195 clnt->cl_xprt = xprt;
196 clnt->cl_procinfo = version->procs;
197 clnt->cl_maxproc = version->nrprocs;
198 clnt->cl_protname = program->name;
199 clnt->cl_prog = args->prognumber ? : program->number;
200 clnt->cl_vers = version->number;
201 clnt->cl_stats = program->stats;
202 clnt->cl_metrics = rpc_alloc_iostats(clnt);
204 if (clnt->cl_metrics == NULL)
206 clnt->cl_program = program;
207 INIT_LIST_HEAD(&clnt->cl_tasks);
208 spin_lock_init(&clnt->cl_lock);
210 if (!xprt_bound(clnt->cl_xprt))
211 clnt->cl_autobind = 1;
213 clnt->cl_timeout = xprt->timeout;
215 memcpy(&clnt->cl_timeout_default, args->timeout,
216 sizeof(clnt->cl_timeout_default));
217 clnt->cl_timeout = &clnt->cl_timeout_default;
220 clnt->cl_rtt = &clnt->cl_rtt_default;
221 rpc_init_rtt(&clnt->cl_rtt_default, clnt->cl_timeout->to_initval);
222 clnt->cl_principal = NULL;
224 clnt->cl_principal = kstrdup(args->client_name, GFP_KERNEL);
225 if (!clnt->cl_principal)
229 atomic_set(&clnt->cl_count, 1);
231 err = rpc_setup_pipedir(clnt, program->pipe_dir_name);
235 auth = rpcauth_create(args->authflavor, clnt);
244 clnt->cl_nodelen = strlen(init_utsname()->nodename);
245 if (clnt->cl_nodelen > UNX_MAXNODENAME)
246 clnt->cl_nodelen = UNX_MAXNODENAME;
247 memcpy(clnt->cl_nodename, init_utsname()->nodename, clnt->cl_nodelen);
248 rpc_register_client(clnt);
249 return clnt;
252 if (!IS_ERR(clnt->cl_path.dentry)) {
253 rpc_remove_client_dir(clnt->cl_path.dentry);
257 kfree(clnt->cl_principal);
259 rpc_free_iostats(clnt->cl_metrics);
261 if (clnt->cl_server != clnt->cl_inline_name)
262 kfree(clnt->cl_server);
263 kfree(clnt);
285 struct rpc_clnt *clnt;
338 clnt = rpc_new_client(args, xprt);
339 if (IS_ERR(clnt))
340 return clnt;
343 int err = rpc_ping(clnt);
345 rpc_shutdown_client(clnt);
350 clnt->cl_softrtry = 1;
352 clnt->cl_softrtry = 0;
355 clnt->cl_autobind = 1;
357 clnt->cl_discrtry = 1;
359 clnt->cl_chatty = 1;
361 return clnt;
371 rpc_clone_client(struct rpc_clnt *clnt)
376 new = kmemdup(clnt, sizeof(*new), GFP_KERNEL);
379 new->cl_parent = clnt;
384 rpc_init_rtt(&new->cl_rtt_default, clnt->cl_timeout->to_initval);
385 new->cl_metrics = rpc_alloc_iostats(clnt);
388 if (clnt->cl_principal) {
389 new->cl_principal = kstrdup(clnt->cl_principal, GFP_KERNEL);
394 err = rpc_setup_pipedir(new, clnt->cl_program->pipe_dir_name);
399 xprt_get(clnt->cl_xprt);
400 atomic_inc(&clnt->cl_count);
416 void rpc_killall_tasks(struct rpc_clnt *clnt)
421 if (list_empty(&clnt->cl_tasks))
423 dprintk("RPC: killing all tasks for client %p\n", clnt);
427 spin_lock(&clnt->cl_lock);
428 list_for_each_entry(rovr, &clnt->cl_tasks, tk_task) {
437 spin_unlock(&clnt->cl_lock);
445 void rpc_shutdown_client(struct rpc_clnt *clnt)
448 clnt->cl_protname, clnt->cl_server);
450 while (!list_empty(&clnt->cl_tasks)) {
451 rpc_killall_tasks(clnt);
453 list_empty(&clnt->cl_tasks), 1*HZ);
456 rpc_release_client(clnt);
464 rpc_free_client(struct rpc_clnt *clnt)
467 clnt->cl_protname, clnt->cl_server);
468 if (!IS_ERR(clnt->cl_path.dentry)) {
469 rpc_remove_client_dir(clnt->cl_path.dentry);
472 if (clnt->cl_parent != clnt) {
473 rpc_release_client(clnt->cl_parent);
476 if (clnt->cl_server != clnt->cl_inline_name)
477 kfree(clnt->cl_server);
479 rpc_unregister_client(clnt);
480 rpc_free_iostats(clnt->cl_metrics);
481 kfree(clnt->cl_principal);
482 clnt->cl_metrics = NULL;
483 xprt_put(clnt->cl_xprt);
485 kfree(clnt);
492 rpc_free_auth(struct rpc_clnt *clnt)
494 if (clnt->cl_auth == NULL) {
495 rpc_free_client(clnt);
504 atomic_inc(&clnt->cl_count);
505 rpcauth_release(clnt->cl_auth);
506 clnt->cl_auth = NULL;
507 if (atomic_dec_and_test(&clnt->cl_count))
508 rpc_free_client(clnt);
515 rpc_release_client(struct rpc_clnt *clnt)
517 dprintk("RPC: rpc_release_client(%p)\n", clnt);
519 if (list_empty(&clnt->cl_tasks))
521 if (atomic_dec_and_test(&clnt->cl_count))
522 rpc_free_auth(clnt);
539 struct rpc_clnt *clnt;
545 clnt = rpc_clone_client(old);
546 if (IS_ERR(clnt))
548 clnt->cl_procinfo = version->procs;
549 clnt->cl_maxproc = version->nrprocs;
550 clnt->cl_protname = program->name;
551 clnt->cl_prog = program->number;
552 clnt->cl_vers = version->number;
553 clnt->cl_stats = program->stats;
554 err = rpc_ping(clnt);
556 rpc_shutdown_client(clnt);
557 clnt = ERR_PTR(err);
560 return clnt;
566 struct rpc_clnt *clnt = task->tk_client;
568 if (clnt != NULL) {
570 spin_lock(&clnt->cl_lock);
572 spin_unlock(&clnt->cl_lock);
575 rpc_release_client(clnt);
580 void rpc_task_set_client(struct rpc_task *task, struct rpc_clnt *clnt)
582 if (clnt != NULL) {
584 task->tk_client = clnt;
585 atomic_inc(&clnt->cl_count);
586 if (clnt->cl_softrtry)
589 spin_lock(&clnt->cl_lock);
590 list_add_tail(&task->tk_task, &clnt->cl_tasks);
591 spin_unlock(&clnt->cl_lock);
652 * @clnt: pointer to RPC client
656 int rpc_call_sync(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags)
660 .rpc_client = clnt,
680 * @clnt: pointer to RPC client
687 rpc_call_async(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags,
692 .rpc_client = clnt,
760 * rpc_peeraddr - extract remote peer address from clnt's xprt
761 * @clnt: RPC client structure
767 size_t rpc_peeraddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t bufsize)
770 struct rpc_xprt *xprt = clnt->cl_xprt;
775 memcpy(buf, &clnt->cl_xprt->addr, bytes);
782 * @clnt: RPC client structure
786 const char *rpc_peeraddr2str(struct rpc_clnt *clnt,
789 struct rpc_xprt *xprt = clnt->cl_xprt;
799 rpc_setbufsize(struct rpc_clnt *clnt, unsigned int sndsize, unsigned int rcvsize)
801 struct rpc_xprt *xprt = clnt->cl_xprt;
815 size_t rpc_max_payload(struct rpc_clnt *clnt)
817 return clnt->cl_xprt->max_payload;
823 * @clnt: client to rebind
826 void rpc_force_rebind(struct rpc_clnt *clnt)
828 if (clnt->cl_autobind)
829 xprt_clear_bound(clnt->cl_xprt);
885 struct rpc_clnt *clnt = task->tk_client;
888 clnt->cl_protname, clnt->cl_vers,
894 clnt->cl_stats->rpccnt++;
1231 struct rpc_clnt *clnt = task->tk_client;
1238 clnt->cl_stats->netreconn++;
1416 struct rpc_clnt *clnt = task->tk_client;
1449 rpc_force_rebind(clnt);
1463 if (clnt->cl_chatty)
1465 clnt->cl_protname, -status);
1478 struct rpc_clnt *clnt = task->tk_client;
1493 if (clnt->cl_chatty)
1495 clnt->cl_protname, clnt->cl_server);
1502 if (clnt->cl_chatty)
1504 clnt->cl_protname, clnt->cl_server);
1506 rpc_force_rebind(clnt);
1514 clnt->cl_stats->rpcretrans++;
1525 struct rpc_clnt *clnt = task->tk_client;
1534 if (clnt->cl_chatty)
1536 clnt->cl_protname, clnt->cl_server);
1554 clnt->cl_stats->rpcretrans++;
1558 clnt->cl_protname, task->tk_status);
1593 struct rpc_clnt *clnt = task->tk_client;
1602 *p++ = htonl(clnt->cl_prog); /* program number */
1603 *p++ = htonl(clnt->cl_vers); /* program version */
1782 static int rpc_ping(struct rpc_clnt *clnt)
1789 err = rpc_call_sync(clnt, &msg, RPC_TASK_SOFT | RPC_TASK_SOFTCONN);
1794 struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred, int flags)
1801 .rpc_client = clnt,
1817 static void rpc_show_task(const struct rpc_clnt *clnt,
1835 clnt, task->tk_rqstp, task->tk_timeout, task->tk_ops,
1836 clnt->cl_protname, clnt->cl_vers, rpc_proc_name(task),
1842 struct rpc_clnt *clnt;
1847 list_for_each_entry(clnt, &all_clients, cl_clients) {
1848 spin_lock(&clnt->cl_lock);
1849 list_for_each_entry(task, &clnt->cl_tasks, tk_task) {
1854 rpc_show_task(clnt, task);
1856 spin_unlock(&clnt->cl_lock);