1 /* 2 * linux/net/sunrpc/clnt.c 3 * 4 * This file contains the high-level RPC interface. 5 * It is modeled as a finite state machine to support both synchronous 6 * and asynchronous requests. 7 * 8 * - RPC header generation and argument serialization. 9 * - Credential refresh. 10 * - TCP connect handling. 11 * - Retry of operation when it is suspected the operation failed because 12 * of uid squashing on the server, or when the credentials were stale 13 * and need to be refreshed, or when a packet was damaged in transit. 14 * This may be have to be moved to the VFS layer. 15 * 16 * Copyright (C) 1992,1993 Rick Sladkey <jrs@world.std.com> 17 * Copyright (C) 1995,1996 Olaf Kirch <okir@monad.swb.de> 18 */ 19 20 21 #include <linux/module.h> 22 #include <linux/types.h> 23 #include <linux/kallsyms.h> 24 #include <linux/mm.h> 25 #include <linux/namei.h> 26 #include <linux/mount.h> 27 #include <linux/slab.h> 28 #include <linux/rcupdate.h> 29 #include <linux/utsname.h> 30 #include <linux/workqueue.h> 31 #include <linux/in.h> 32 #include <linux/in6.h> 33 #include <linux/un.h> 34 35 #include <linux/sunrpc/clnt.h> 36 #include <linux/sunrpc/addr.h> 37 #include <linux/sunrpc/rpc_pipe_fs.h> 38 #include <linux/sunrpc/metrics.h> 39 #include <linux/sunrpc/bc_xprt.h> 40 #include <trace/events/sunrpc.h> 41 42 #include "sunrpc.h" 43 #include "netns.h" 44 45 #if IS_ENABLED(CONFIG_SUNRPC_DEBUG) 46 # define RPCDBG_FACILITY RPCDBG_CALL 47 #endif 48 49 #define dprint_status(t) \ 50 dprintk("RPC: %5u %s (status %d)\n", t->tk_pid, \ 51 __func__, t->tk_status) 52 53 /* 54 * All RPC clients are linked into this list 55 */ 56 57 static DECLARE_WAIT_QUEUE_HEAD(destroy_wait); 58 59 60 static void call_start(struct rpc_task *task); 61 static void call_reserve(struct rpc_task *task); 62 static void call_reserveresult(struct rpc_task *task); 63 static void call_allocate(struct rpc_task *task); 64 static void call_encode(struct rpc_task *task); 65 static void call_decode(struct rpc_task *task); 66 static void call_bind(struct rpc_task *task); 67 static void call_bind_status(struct rpc_task *task); 68 static void call_transmit(struct rpc_task *task); 69 static void call_status(struct rpc_task *task); 70 static void call_transmit_status(struct rpc_task *task); 71 static void call_refresh(struct rpc_task *task); 72 static void call_refreshresult(struct rpc_task *task); 73 static void call_connect(struct rpc_task *task); 74 static void call_connect_status(struct rpc_task *task); 75 76 static int rpc_encode_header(struct rpc_task *task, 77 struct xdr_stream *xdr); 78 static int rpc_decode_header(struct rpc_task *task, 79 struct xdr_stream *xdr); 80 static int rpc_ping(struct rpc_clnt *clnt); 81 static void rpc_check_timeout(struct rpc_task *task); 82 83 static void rpc_register_client(struct rpc_clnt *clnt) 84 { 85 struct net *net = rpc_net_ns(clnt); 86 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id); 87 88 spin_lock(&sn->rpc_client_lock); 89 list_add(&clnt->cl_clients, &sn->all_clients); 90 spin_unlock(&sn->rpc_client_lock); 91 } 92 93 static void rpc_unregister_client(struct rpc_clnt *clnt) 94 { 95 struct net *net = rpc_net_ns(clnt); 96 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id); 97 98 spin_lock(&sn->rpc_client_lock); 99 list_del(&clnt->cl_clients); 100 spin_unlock(&sn->rpc_client_lock); 101 } 102 103 static void __rpc_clnt_remove_pipedir(struct rpc_clnt *clnt) 104 { 105 rpc_remove_client_dir(clnt); 106 } 107 108 static void rpc_clnt_remove_pipedir(struct rpc_clnt *clnt) 109 { 110 struct net *net = rpc_net_ns(clnt); 111 struct super_block *pipefs_sb; 112 113 pipefs_sb = rpc_get_sb_net(net); 114 if (pipefs_sb) { 115 __rpc_clnt_remove_pipedir(clnt); 116 rpc_put_sb_net(net); 117 } 118 } 119 120 static struct dentry *rpc_setup_pipedir_sb(struct super_block *sb, 121 struct rpc_clnt *clnt) 122 { 123 static uint32_t clntid; 124 const char *dir_name = clnt->cl_program->pipe_dir_name; 125 char name[15]; 126 struct dentry *dir, *dentry; 127 128 dir = rpc_d_lookup_sb(sb, dir_name); 129 if (dir == NULL) { 130 pr_info("RPC: pipefs directory doesn't exist: %s\n", dir_name); 131 return dir; 132 } 133 for (;;) { 134 snprintf(name, sizeof(name), "clnt%x", (unsigned int)clntid++); 135 name[sizeof(name) - 1] = '\0'; 136 dentry = rpc_create_client_dir(dir, name, clnt); 137 if (!IS_ERR(dentry)) 138 break; 139 if (dentry == ERR_PTR(-EEXIST)) 140 continue; 141 printk(KERN_INFO "RPC: Couldn't create pipefs entry" 142 " %s/%s, error %ld\n", 143 dir_name, name, PTR_ERR(dentry)); 144 break; 145 } 146 dput(dir); 147 return dentry; 148 } 149 150 static int 151 rpc_setup_pipedir(struct super_block *pipefs_sb, struct rpc_clnt *clnt) 152 { 153 struct dentry *dentry; 154 155 if (clnt->cl_program->pipe_dir_name != NULL) { 156 dentry = rpc_setup_pipedir_sb(pipefs_sb, clnt); 157 if (IS_ERR(dentry)) 158 return PTR_ERR(dentry); 159 } 160 return 0; 161 } 162 163 static int rpc_clnt_skip_event(struct rpc_clnt *clnt, unsigned long event) 164 { 165 if (clnt->cl_program->pipe_dir_name == NULL) 166 return 1; 167 168 switch (event) { 169 case RPC_PIPEFS_MOUNT: 170 if (clnt->cl_pipedir_objects.pdh_dentry != NULL) 171 return 1; 172 if (atomic_read(&clnt->cl_count) == 0) 173 return 1; 174 break; 175 case RPC_PIPEFS_UMOUNT: 176 if (clnt->cl_pipedir_objects.pdh_dentry == NULL) 177 return 1; 178 break; 179 } 180 return 0; 181 } 182 183 static int __rpc_clnt_handle_event(struct rpc_clnt *clnt, unsigned long event, 184 struct super_block *sb) 185 { 186 struct dentry *dentry; 187 188 switch (event) { 189 case RPC_PIPEFS_MOUNT: 190 dentry = rpc_setup_pipedir_sb(sb, clnt); 191 if (!dentry) 192 return -ENOENT; 193 if (IS_ERR(dentry)) 194 return PTR_ERR(dentry); 195 break; 196 case RPC_PIPEFS_UMOUNT: 197 __rpc_clnt_remove_pipedir(clnt); 198 break; 199 default: 200 printk(KERN_ERR "%s: unknown event: %ld\n", __func__, event); 201 return -ENOTSUPP; 202 } 203 return 0; 204 } 205 206 static int __rpc_pipefs_event(struct rpc_clnt *clnt, unsigned long event, 207 struct super_block *sb) 208 { 209 int error = 0; 210 211 for (;; clnt = clnt->cl_parent) { 212 if (!rpc_clnt_skip_event(clnt, event)) 213 error = __rpc_clnt_handle_event(clnt, event, sb); 214 if (error || clnt == clnt->cl_parent) 215 break; 216 } 217 return error; 218 } 219 220 static struct rpc_clnt *rpc_get_client_for_event(struct net *net, int event) 221 { 222 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id); 223 struct rpc_clnt *clnt; 224 225 spin_lock(&sn->rpc_client_lock); 226 list_for_each_entry(clnt, &sn->all_clients, cl_clients) { 227 if (rpc_clnt_skip_event(clnt, event)) 228 continue; 229 spin_unlock(&sn->rpc_client_lock); 230 return clnt; 231 } 232 spin_unlock(&sn->rpc_client_lock); 233 return NULL; 234 } 235 236 static int rpc_pipefs_event(struct notifier_block *nb, unsigned long event, 237 void *ptr) 238 { 239 struct super_block *sb = ptr; 240 struct rpc_clnt *clnt; 241 int error = 0; 242 243 while ((clnt = rpc_get_client_for_event(sb->s_fs_info, event))) { 244 error = __rpc_pipefs_event(clnt, event, sb); 245 if (error) 246 break; 247 } 248 return error; 249 } 250 251 static struct notifier_block rpc_clients_block = { 252 .notifier_call = rpc_pipefs_event, 253 .priority = SUNRPC_PIPEFS_RPC_PRIO, 254 }; 255 256 int rpc_clients_notifier_register(void) 257 { 258 return rpc_pipefs_notifier_register(&rpc_clients_block); 259 } 260 261 void rpc_clients_notifier_unregister(void) 262 { 263 return rpc_pipefs_notifier_unregister(&rpc_clients_block); 264 } 265 266 static struct rpc_xprt *rpc_clnt_set_transport(struct rpc_clnt *clnt, 267 struct rpc_xprt *xprt, 268 const struct rpc_timeout *timeout) 269 { 270 struct rpc_xprt *old; 271 272 spin_lock(&clnt->cl_lock); 273 old = rcu_dereference_protected(clnt->cl_xprt, 274 lockdep_is_held(&clnt->cl_lock)); 275 276 if (!xprt_bound(xprt)) 277 clnt->cl_autobind = 1; 278 279 clnt->cl_timeout = timeout; 280 rcu_assign_pointer(clnt->cl_xprt, xprt); 281 spin_unlock(&clnt->cl_lock); 282 283 return old; 284 } 285 286 static void rpc_clnt_set_nodename(struct rpc_clnt *clnt, const char *nodename) 287 { 288 clnt->cl_nodelen = strlcpy(clnt->cl_nodename, 289 nodename, sizeof(clnt->cl_nodename)); 290 } 291 292 static int rpc_client_register(struct rpc_clnt *clnt, 293 rpc_authflavor_t pseudoflavor, 294 const char *client_name) 295 { 296 struct rpc_auth_create_args auth_args = { 297 .pseudoflavor = pseudoflavor, 298 .target_name = client_name, 299 }; 300 struct rpc_auth *auth; 301 struct net *net = rpc_net_ns(clnt); 302 struct super_block *pipefs_sb; 303 int err; 304 305 rpc_clnt_debugfs_register(clnt); 306 307 pipefs_sb = rpc_get_sb_net(net); 308 if (pipefs_sb) { 309 err = rpc_setup_pipedir(pipefs_sb, clnt); 310 if (err) 311 goto out; 312 } 313 314 rpc_register_client(clnt); 315 if (pipefs_sb) 316 rpc_put_sb_net(net); 317 318 auth = rpcauth_create(&auth_args, clnt); 319 if (IS_ERR(auth)) { 320 dprintk("RPC: Couldn't create auth handle (flavor %u)\n", 321 pseudoflavor); 322 err = PTR_ERR(auth); 323 goto err_auth; 324 } 325 return 0; 326 err_auth: 327 pipefs_sb = rpc_get_sb_net(net); 328 rpc_unregister_client(clnt); 329 __rpc_clnt_remove_pipedir(clnt); 330 out: 331 if (pipefs_sb) 332 rpc_put_sb_net(net); 333 rpc_clnt_debugfs_unregister(clnt); 334 return err; 335 } 336 337 static DEFINE_IDA(rpc_clids); 338 339 void rpc_cleanup_clids(void) 340 { 341 ida_destroy(&rpc_clids); 342 } 343 344 static int rpc_alloc_clid(struct rpc_clnt *clnt) 345 { 346 int clid; 347 348 clid = ida_simple_get(&rpc_clids, 0, 0, GFP_KERNEL); 349 if (clid < 0) 350 return clid; 351 clnt->cl_clid = clid; 352 return 0; 353 } 354 355 static void rpc_free_clid(struct rpc_clnt *clnt) 356 { 357 ida_simple_remove(&rpc_clids, clnt->cl_clid); 358 } 359 360 static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args, 361 struct rpc_xprt_switch *xps, 362 struct rpc_xprt *xprt, 363 struct rpc_clnt *parent) 364 { 365 const struct rpc_program *program = args->program; 366 const struct rpc_version *version; 367 struct rpc_clnt *clnt = NULL; 368 const struct rpc_timeout *timeout; 369 const char *nodename = args->nodename; 370 int err; 371 372 /* sanity check the name before trying to print it */ 373 dprintk("RPC: creating %s client for %s (xprt %p)\n", 374 program->name, args->servername, xprt); 375 376 err = rpciod_up(); 377 if (err) 378 goto out_no_rpciod; 379 380 err = -EINVAL; 381 if (args->version >= program->nrvers) 382 goto out_err; 383 version = program->version[args->version]; 384 if (version == NULL) 385 goto out_err; 386 387 err = -ENOMEM; 388 clnt = kzalloc(sizeof(*clnt), GFP_KERNEL); 389 if (!clnt) 390 goto out_err; 391 clnt->cl_parent = parent ? : clnt; 392 393 err = rpc_alloc_clid(clnt); 394 if (err) 395 goto out_no_clid; 396 397 clnt->cl_procinfo = version->procs; 398 clnt->cl_maxproc = version->nrprocs; 399 clnt->cl_prog = args->prognumber ? : program->number; 400 clnt->cl_vers = version->number; 401 clnt->cl_stats = program->stats; 402 clnt->cl_metrics = rpc_alloc_iostats(clnt); 403 rpc_init_pipe_dir_head(&clnt->cl_pipedir_objects); 404 err = -ENOMEM; 405 if (clnt->cl_metrics == NULL) 406 goto out_no_stats; 407 clnt->cl_program = program; 408 INIT_LIST_HEAD(&clnt->cl_tasks); 409 spin_lock_init(&clnt->cl_lock); 410 411 timeout = xprt->timeout; 412 if (args->timeout != NULL) { 413 memcpy(&clnt->cl_timeout_default, args->timeout, 414 sizeof(clnt->cl_timeout_default)); 415 timeout = &clnt->cl_timeout_default; 416 } 417 418 rpc_clnt_set_transport(clnt, xprt, timeout); 419 xprt_iter_init(&clnt->cl_xpi, xps); 420 xprt_switch_put(xps); 421 422 clnt->cl_rtt = &clnt->cl_rtt_default; 423 rpc_init_rtt(&clnt->cl_rtt_default, clnt->cl_timeout->to_initval); 424 425 atomic_set(&clnt->cl_count, 1); 426 427 if (nodename == NULL) 428 nodename = utsname()->nodename; 429 /* save the nodename */ 430 rpc_clnt_set_nodename(clnt, nodename); 431 432 err = rpc_client_register(clnt, args->authflavor, args->client_name); 433 if (err) 434 goto out_no_path; 435 if (parent) 436 atomic_inc(&parent->cl_count); 437 return clnt; 438 439 out_no_path: 440 rpc_free_iostats(clnt->cl_metrics); 441 out_no_stats: 442 rpc_free_clid(clnt); 443 out_no_clid: 444 kfree(clnt); 445 out_err: 446 rpciod_down(); 447 out_no_rpciod: 448 xprt_switch_put(xps); 449 xprt_put(xprt); 450 return ERR_PTR(err); 451 } 452 453 static struct rpc_clnt *rpc_create_xprt(struct rpc_create_args *args, 454 struct rpc_xprt *xprt) 455 { 456 struct rpc_clnt *clnt = NULL; 457 struct rpc_xprt_switch *xps; 458 459 if (args->bc_xprt && args->bc_xprt->xpt_bc_xps) { 460 WARN_ON_ONCE(!(args->protocol & XPRT_TRANSPORT_BC)); 461 xps = args->bc_xprt->xpt_bc_xps; 462 xprt_switch_get(xps); 463 } else { 464 xps = xprt_switch_alloc(xprt, GFP_KERNEL); 465 if (xps == NULL) { 466 xprt_put(xprt); 467 return ERR_PTR(-ENOMEM); 468 } 469 if (xprt->bc_xprt) { 470 xprt_switch_get(xps); 471 xprt->bc_xprt->xpt_bc_xps = xps; 472 } 473 } 474 clnt = rpc_new_client(args, xps, xprt, NULL); 475 if (IS_ERR(clnt)) 476 return clnt; 477 478 if (!(args->flags & RPC_CLNT_CREATE_NOPING)) { 479 int err = rpc_ping(clnt); 480 if (err != 0) { 481 rpc_shutdown_client(clnt); 482 return ERR_PTR(err); 483 } 484 } 485 486 clnt->cl_softrtry = 1; 487 if (args->flags & RPC_CLNT_CREATE_HARDRTRY) 488 clnt->cl_softrtry = 0; 489 490 if (args->flags & RPC_CLNT_CREATE_AUTOBIND) 491 clnt->cl_autobind = 1; 492 if (args->flags & RPC_CLNT_CREATE_NO_RETRANS_TIMEOUT) 493 clnt->cl_noretranstimeo = 1; 494 if (args->flags & RPC_CLNT_CREATE_DISCRTRY) 495 clnt->cl_discrtry = 1; 496 if (!(args->flags & RPC_CLNT_CREATE_QUIET)) 497 clnt->cl_chatty = 1; 498 499 return clnt; 500 } 501 502 /** 503 * rpc_create - create an RPC client and transport with one call 504 * @args: rpc_clnt create argument structure 505 * 506 * Creates and initializes an RPC transport and an RPC client. 507 * 508 * It can ping the server in order to determine if it is up, and to see if 509 * it supports this program and version. RPC_CLNT_CREATE_NOPING disables 510 * this behavior so asynchronous tasks can also use rpc_create. 511 */ 512 struct rpc_clnt *rpc_create(struct rpc_create_args *args) 513 { 514 struct rpc_xprt *xprt; 515 struct xprt_create xprtargs = { 516 .net = args->net, 517 .ident = args->protocol, 518 .srcaddr = args->saddress, 519 .dstaddr = args->address, 520 .addrlen = args->addrsize, 521 .servername = args->servername, 522 .bc_xprt = args->bc_xprt, 523 }; 524 char servername[48]; 525 526 if (args->bc_xprt) { 527 WARN_ON_ONCE(!(args->protocol & XPRT_TRANSPORT_BC)); 528 xprt = args->bc_xprt->xpt_bc_xprt; 529 if (xprt) { 530 xprt_get(xprt); 531 return rpc_create_xprt(args, xprt); 532 } 533 } 534 535 if (args->flags & RPC_CLNT_CREATE_INFINITE_SLOTS) 536 xprtargs.flags |= XPRT_CREATE_INFINITE_SLOTS; 537 if (args->flags & RPC_CLNT_CREATE_NO_IDLE_TIMEOUT) 538 xprtargs.flags |= XPRT_CREATE_NO_IDLE_TIMEOUT; 539 /* 540 * If the caller chooses not to specify a hostname, whip 541 * up a string representation of the passed-in address. 542 */ 543 if (xprtargs.servername == NULL) { 544 struct sockaddr_un *sun = 545 (struct sockaddr_un *)args->address; 546 struct sockaddr_in *sin = 547 (struct sockaddr_in *)args->address; 548 struct sockaddr_in6 *sin6 = 549 (struct sockaddr_in6 *)args->address; 550 551 servername[0] = '\0'; 552 switch (args->address->sa_family) { 553 case AF_LOCAL: 554 snprintf(servername, sizeof(servername), "%s", 555 sun->sun_path); 556 break; 557 case AF_INET: 558 snprintf(servername, sizeof(servername), "%pI4", 559 &sin->sin_addr.s_addr); 560 break; 561 case AF_INET6: 562 snprintf(servername, sizeof(servername), "%pI6", 563 &sin6->sin6_addr); 564 break; 565 default: 566 /* caller wants default server name, but 567 * address family isn't recognized. */ 568 return ERR_PTR(-EINVAL); 569 } 570 xprtargs.servername = servername; 571 } 572 573 xprt = xprt_create_transport(&xprtargs); 574 if (IS_ERR(xprt)) 575 return (struct rpc_clnt *)xprt; 576 577 /* 578 * By default, kernel RPC client connects from a reserved port. 579 * CAP_NET_BIND_SERVICE will not be set for unprivileged requesters, 580 * but it is always enabled for rpciod, which handles the connect 581 * operation. 582 */ 583 xprt->resvport = 1; 584 if (args->flags & RPC_CLNT_CREATE_NONPRIVPORT) 585 xprt->resvport = 0; 586 587 return rpc_create_xprt(args, xprt); 588 } 589 EXPORT_SYMBOL_GPL(rpc_create); 590 591 /* 592 * This function clones the RPC client structure. It allows us to share the 593 * same transport while varying parameters such as the authentication 594 * flavour. 595 */ 596 static struct rpc_clnt *__rpc_clone_client(struct rpc_create_args *args, 597 struct rpc_clnt *clnt) 598 { 599 struct rpc_xprt_switch *xps; 600 struct rpc_xprt *xprt; 601 struct rpc_clnt *new; 602 int err; 603 604 err = -ENOMEM; 605 rcu_read_lock(); 606 xprt = xprt_get(rcu_dereference(clnt->cl_xprt)); 607 xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch)); 608 rcu_read_unlock(); 609 if (xprt == NULL || xps == NULL) { 610 xprt_put(xprt); 611 xprt_switch_put(xps); 612 goto out_err; 613 } 614 args->servername = xprt->servername; 615 args->nodename = clnt->cl_nodename; 616 617 new = rpc_new_client(args, xps, xprt, clnt); 618 if (IS_ERR(new)) { 619 err = PTR_ERR(new); 620 goto out_err; 621 } 622 623 /* Turn off autobind on clones */ 624 new->cl_autobind = 0; 625 new->cl_softrtry = clnt->cl_softrtry; 626 new->cl_noretranstimeo = clnt->cl_noretranstimeo; 627 new->cl_discrtry = clnt->cl_discrtry; 628 new->cl_chatty = clnt->cl_chatty; 629 new->cl_principal = clnt->cl_principal; 630 return new; 631 632 out_err: 633 dprintk("RPC: %s: returned error %d\n", __func__, err); 634 return ERR_PTR(err); 635 } 636 637 /** 638 * rpc_clone_client - Clone an RPC client structure 639 * 640 * @clnt: RPC client whose parameters are copied 641 * 642 * Returns a fresh RPC client or an ERR_PTR. 643 */ 644 struct rpc_clnt *rpc_clone_client(struct rpc_clnt *clnt) 645 { 646 struct rpc_create_args args = { 647 .program = clnt->cl_program, 648 .prognumber = clnt->cl_prog, 649 .version = clnt->cl_vers, 650 .authflavor = clnt->cl_auth->au_flavor, 651 }; 652 return __rpc_clone_client(&args, clnt); 653 } 654 EXPORT_SYMBOL_GPL(rpc_clone_client); 655 656 /** 657 * rpc_clone_client_set_auth - Clone an RPC client structure and set its auth 658 * 659 * @clnt: RPC client whose parameters are copied 660 * @flavor: security flavor for new client 661 * 662 * Returns a fresh RPC client or an ERR_PTR. 663 */ 664 struct rpc_clnt * 665 rpc_clone_client_set_auth(struct rpc_clnt *clnt, rpc_authflavor_t flavor) 666 { 667 struct rpc_create_args args = { 668 .program = clnt->cl_program, 669 .prognumber = clnt->cl_prog, 670 .version = clnt->cl_vers, 671 .authflavor = flavor, 672 }; 673 return __rpc_clone_client(&args, clnt); 674 } 675 EXPORT_SYMBOL_GPL(rpc_clone_client_set_auth); 676 677 /** 678 * rpc_switch_client_transport: switch the RPC transport on the fly 679 * @clnt: pointer to a struct rpc_clnt 680 * @args: pointer to the new transport arguments 681 * @timeout: pointer to the new timeout parameters 682 * 683 * This function allows the caller to switch the RPC transport for the 684 * rpc_clnt structure 'clnt' to allow it to connect to a mirrored NFS 685 * server, for instance. It assumes that the caller has ensured that 686 * there are no active RPC tasks by using some form of locking. 687 * 688 * Returns zero if "clnt" is now using the new xprt. Otherwise a 689 * negative errno is returned, and "clnt" continues to use the old 690 * xprt. 691 */ 692 int rpc_switch_client_transport(struct rpc_clnt *clnt, 693 struct xprt_create *args, 694 const struct rpc_timeout *timeout) 695 { 696 const struct rpc_timeout *old_timeo; 697 rpc_authflavor_t pseudoflavor; 698 struct rpc_xprt_switch *xps, *oldxps; 699 struct rpc_xprt *xprt, *old; 700 struct rpc_clnt *parent; 701 int err; 702 703 xprt = xprt_create_transport(args); 704 if (IS_ERR(xprt)) { 705 dprintk("RPC: failed to create new xprt for clnt %p\n", 706 clnt); 707 return PTR_ERR(xprt); 708 } 709 710 xps = xprt_switch_alloc(xprt, GFP_KERNEL); 711 if (xps == NULL) { 712 xprt_put(xprt); 713 return -ENOMEM; 714 } 715 716 pseudoflavor = clnt->cl_auth->au_flavor; 717 718 old_timeo = clnt->cl_timeout; 719 old = rpc_clnt_set_transport(clnt, xprt, timeout); 720 oldxps = xprt_iter_xchg_switch(&clnt->cl_xpi, xps); 721 722 rpc_unregister_client(clnt); 723 __rpc_clnt_remove_pipedir(clnt); 724 rpc_clnt_debugfs_unregister(clnt); 725 726 /* 727 * A new transport was created. "clnt" therefore 728 * becomes the root of a new cl_parent tree. clnt's 729 * children, if it has any, still point to the old xprt. 730 */ 731 parent = clnt->cl_parent; 732 clnt->cl_parent = clnt; 733 734 /* 735 * The old rpc_auth cache cannot be re-used. GSS 736 * contexts in particular are between a single 737 * client and server. 738 */ 739 err = rpc_client_register(clnt, pseudoflavor, NULL); 740 if (err) 741 goto out_revert; 742 743 synchronize_rcu(); 744 if (parent != clnt) 745 rpc_release_client(parent); 746 xprt_switch_put(oldxps); 747 xprt_put(old); 748 dprintk("RPC: replaced xprt for clnt %p\n", clnt); 749 return 0; 750 751 out_revert: 752 xps = xprt_iter_xchg_switch(&clnt->cl_xpi, oldxps); 753 rpc_clnt_set_transport(clnt, old, old_timeo); 754 clnt->cl_parent = parent; 755 rpc_client_register(clnt, pseudoflavor, NULL); 756 xprt_switch_put(xps); 757 xprt_put(xprt); 758 dprintk("RPC: failed to switch xprt for clnt %p\n", clnt); 759 return err; 760 } 761 EXPORT_SYMBOL_GPL(rpc_switch_client_transport); 762 763 static 764 int rpc_clnt_xprt_iter_init(struct rpc_clnt *clnt, struct rpc_xprt_iter *xpi) 765 { 766 struct rpc_xprt_switch *xps; 767 768 rcu_read_lock(); 769 xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch)); 770 rcu_read_unlock(); 771 if (xps == NULL) 772 return -EAGAIN; 773 xprt_iter_init_listall(xpi, xps); 774 xprt_switch_put(xps); 775 return 0; 776 } 777 778 /** 779 * rpc_clnt_iterate_for_each_xprt - Apply a function to all transports 780 * @clnt: pointer to client 781 * @fn: function to apply 782 * @data: void pointer to function data 783 * 784 * Iterates through the list of RPC transports currently attached to the 785 * client and applies the function fn(clnt, xprt, data). 786 * 787 * On error, the iteration stops, and the function returns the error value. 788 */ 789 int rpc_clnt_iterate_for_each_xprt(struct rpc_clnt *clnt, 790 int (*fn)(struct rpc_clnt *, struct rpc_xprt *, void *), 791 void *data) 792 { 793 struct rpc_xprt_iter xpi; 794 int ret; 795 796 ret = rpc_clnt_xprt_iter_init(clnt, &xpi); 797 if (ret) 798 return ret; 799 for (;;) { 800 struct rpc_xprt *xprt = xprt_iter_get_next(&xpi); 801 802 if (!xprt) 803 break; 804 ret = fn(clnt, xprt, data); 805 xprt_put(xprt); 806 if (ret < 0) 807 break; 808 } 809 xprt_iter_destroy(&xpi); 810 return ret; 811 } 812 EXPORT_SYMBOL_GPL(rpc_clnt_iterate_for_each_xprt); 813 814 /* 815 * Kill all tasks for the given client. 816 * XXX: kill their descendants as well? 817 */ 818 void rpc_killall_tasks(struct rpc_clnt *clnt) 819 { 820 struct rpc_task *rovr; 821 822 823 if (list_empty(&clnt->cl_tasks)) 824 return; 825 dprintk("RPC: killing all tasks for client %p\n", clnt); 826 /* 827 * Spin lock all_tasks to prevent changes... 828 */ 829 spin_lock(&clnt->cl_lock); 830 list_for_each_entry(rovr, &clnt->cl_tasks, tk_task) { 831 if (!RPC_IS_ACTIVATED(rovr)) 832 continue; 833 if (!(rovr->tk_flags & RPC_TASK_KILLED)) { 834 rovr->tk_flags |= RPC_TASK_KILLED; 835 rpc_exit(rovr, -EIO); 836 } 837 } 838 spin_unlock(&clnt->cl_lock); 839 } 840 EXPORT_SYMBOL_GPL(rpc_killall_tasks); 841 842 /* 843 * Properly shut down an RPC client, terminating all outstanding 844 * requests. 845 */ 846 void rpc_shutdown_client(struct rpc_clnt *clnt) 847 { 848 might_sleep(); 849 850 dprintk_rcu("RPC: shutting down %s client for %s\n", 851 clnt->cl_program->name, 852 rcu_dereference(clnt->cl_xprt)->servername); 853 854 while (!list_empty(&clnt->cl_tasks)) { 855 rpc_killall_tasks(clnt); 856 wait_event_timeout(destroy_wait, 857 list_empty(&clnt->cl_tasks), 1*HZ); 858 } 859 860 rpc_release_client(clnt); 861 } 862 EXPORT_SYMBOL_GPL(rpc_shutdown_client); 863 864 /* 865 * Free an RPC client 866 */ 867 static struct rpc_clnt * 868 rpc_free_client(struct rpc_clnt *clnt) 869 { 870 struct rpc_clnt *parent = NULL; 871 872 dprintk_rcu("RPC: destroying %s client for %s\n", 873 clnt->cl_program->name, 874 rcu_dereference(clnt->cl_xprt)->servername); 875 if (clnt->cl_parent != clnt) 876 parent = clnt->cl_parent; 877 rpc_clnt_debugfs_unregister(clnt); 878 rpc_clnt_remove_pipedir(clnt); 879 rpc_unregister_client(clnt); 880 rpc_free_iostats(clnt->cl_metrics); 881 clnt->cl_metrics = NULL; 882 xprt_put(rcu_dereference_raw(clnt->cl_xprt)); 883 xprt_iter_destroy(&clnt->cl_xpi); 884 rpciod_down(); 885 rpc_free_clid(clnt); 886 kfree(clnt); 887 return parent; 888 } 889 890 /* 891 * Free an RPC client 892 */ 893 static struct rpc_clnt * 894 rpc_free_auth(struct rpc_clnt *clnt) 895 { 896 if (clnt->cl_auth == NULL) 897 return rpc_free_client(clnt); 898 899 /* 900 * Note: RPCSEC_GSS may need to send NULL RPC calls in order to 901 * release remaining GSS contexts. This mechanism ensures 902 * that it can do so safely. 903 */ 904 atomic_inc(&clnt->cl_count); 905 rpcauth_release(clnt->cl_auth); 906 clnt->cl_auth = NULL; 907 if (atomic_dec_and_test(&clnt->cl_count)) 908 return rpc_free_client(clnt); 909 return NULL; 910 } 911 912 /* 913 * Release reference to the RPC client 914 */ 915 void 916 rpc_release_client(struct rpc_clnt *clnt) 917 { 918 dprintk("RPC: rpc_release_client(%p)\n", clnt); 919 920 do { 921 if (list_empty(&clnt->cl_tasks)) 922 wake_up(&destroy_wait); 923 if (!atomic_dec_and_test(&clnt->cl_count)) 924 break; 925 clnt = rpc_free_auth(clnt); 926 } while (clnt != NULL); 927 } 928 EXPORT_SYMBOL_GPL(rpc_release_client); 929 930 /** 931 * rpc_bind_new_program - bind a new RPC program to an existing client 932 * @old: old rpc_client 933 * @program: rpc program to set 934 * @vers: rpc program version 935 * 936 * Clones the rpc client and sets up a new RPC program. This is mainly 937 * of use for enabling different RPC programs to share the same transport. 938 * The Sun NFSv2/v3 ACL protocol can do this. 939 */ 940 struct rpc_clnt *rpc_bind_new_program(struct rpc_clnt *old, 941 const struct rpc_program *program, 942 u32 vers) 943 { 944 struct rpc_create_args args = { 945 .program = program, 946 .prognumber = program->number, 947 .version = vers, 948 .authflavor = old->cl_auth->au_flavor, 949 }; 950 struct rpc_clnt *clnt; 951 int err; 952 953 clnt = __rpc_clone_client(&args, old); 954 if (IS_ERR(clnt)) 955 goto out; 956 err = rpc_ping(clnt); 957 if (err != 0) { 958 rpc_shutdown_client(clnt); 959 clnt = ERR_PTR(err); 960 } 961 out: 962 return clnt; 963 } 964 EXPORT_SYMBOL_GPL(rpc_bind_new_program); 965 966 void rpc_task_release_transport(struct rpc_task *task) 967 { 968 struct rpc_xprt *xprt = task->tk_xprt; 969 970 if (xprt) { 971 task->tk_xprt = NULL; 972 xprt_put(xprt); 973 } 974 } 975 EXPORT_SYMBOL_GPL(rpc_task_release_transport); 976 977 void rpc_task_release_client(struct rpc_task *task) 978 { 979 struct rpc_clnt *clnt = task->tk_client; 980 981 if (clnt != NULL) { 982 /* Remove from client task list */ 983 spin_lock(&clnt->cl_lock); 984 list_del(&task->tk_task); 985 spin_unlock(&clnt->cl_lock); 986 task->tk_client = NULL; 987 988 rpc_release_client(clnt); 989 } 990 rpc_task_release_transport(task); 991 } 992 993 static 994 void rpc_task_set_transport(struct rpc_task *task, struct rpc_clnt *clnt) 995 { 996 if (!task->tk_xprt) 997 task->tk_xprt = xprt_iter_get_next(&clnt->cl_xpi); 998 } 999 1000 static 1001 void rpc_task_set_client(struct rpc_task *task, struct rpc_clnt *clnt) 1002 { 1003 1004 if (clnt != NULL) { 1005 rpc_task_set_transport(task, clnt); 1006 task->tk_client = clnt; 1007 atomic_inc(&clnt->cl_count); 1008 if (clnt->cl_softrtry) 1009 task->tk_flags |= RPC_TASK_SOFT; 1010 if (clnt->cl_noretranstimeo) 1011 task->tk_flags |= RPC_TASK_NO_RETRANS_TIMEOUT; 1012 if (atomic_read(&clnt->cl_swapper)) 1013 task->tk_flags |= RPC_TASK_SWAPPER; 1014 /* Add to the client's list of all tasks */ 1015 spin_lock(&clnt->cl_lock); 1016 list_add_tail(&task->tk_task, &clnt->cl_tasks); 1017 spin_unlock(&clnt->cl_lock); 1018 } 1019 } 1020 1021 static void 1022 rpc_task_set_rpc_message(struct rpc_task *task, const struct rpc_message *msg) 1023 { 1024 if (msg != NULL) { 1025 task->tk_msg.rpc_proc = msg->rpc_proc; 1026 task->tk_msg.rpc_argp = msg->rpc_argp; 1027 task->tk_msg.rpc_resp = msg->rpc_resp; 1028 if (msg->rpc_cred != NULL) 1029 task->tk_msg.rpc_cred = get_cred(msg->rpc_cred); 1030 } 1031 } 1032 1033 /* 1034 * Default callback for async RPC calls 1035 */ 1036 static void 1037 rpc_default_callback(struct rpc_task *task, void *data) 1038 { 1039 } 1040 1041 static const struct rpc_call_ops rpc_default_ops = { 1042 .rpc_call_done = rpc_default_callback, 1043 }; 1044 1045 /** 1046 * rpc_run_task - Allocate a new RPC task, then run rpc_execute against it 1047 * @task_setup_data: pointer to task initialisation data 1048 */ 1049 struct rpc_task *rpc_run_task(const struct rpc_task_setup *task_setup_data) 1050 { 1051 struct rpc_task *task; 1052 1053 task = rpc_new_task(task_setup_data); 1054 1055 rpc_task_set_client(task, task_setup_data->rpc_client); 1056 rpc_task_set_rpc_message(task, task_setup_data->rpc_message); 1057 1058 if (task->tk_action == NULL) 1059 rpc_call_start(task); 1060 1061 atomic_inc(&task->tk_count); 1062 rpc_execute(task); 1063 return task; 1064 } 1065 EXPORT_SYMBOL_GPL(rpc_run_task); 1066 1067 /** 1068 * rpc_call_sync - Perform a synchronous RPC call 1069 * @clnt: pointer to RPC client 1070 * @msg: RPC call parameters 1071 * @flags: RPC call flags 1072 */ 1073 int rpc_call_sync(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags) 1074 { 1075 struct rpc_task *task; 1076 struct rpc_task_setup task_setup_data = { 1077 .rpc_client = clnt, 1078 .rpc_message = msg, 1079 .callback_ops = &rpc_default_ops, 1080 .flags = flags, 1081 }; 1082 int status; 1083 1084 WARN_ON_ONCE(flags & RPC_TASK_ASYNC); 1085 if (flags & RPC_TASK_ASYNC) { 1086 rpc_release_calldata(task_setup_data.callback_ops, 1087 task_setup_data.callback_data); 1088 return -EINVAL; 1089 } 1090 1091 task = rpc_run_task(&task_setup_data); 1092 if (IS_ERR(task)) 1093 return PTR_ERR(task); 1094 status = task->tk_status; 1095 rpc_put_task(task); 1096 return status; 1097 } 1098 EXPORT_SYMBOL_GPL(rpc_call_sync); 1099 1100 /** 1101 * rpc_call_async - Perform an asynchronous RPC call 1102 * @clnt: pointer to RPC client 1103 * @msg: RPC call parameters 1104 * @flags: RPC call flags 1105 * @tk_ops: RPC call ops 1106 * @data: user call data 1107 */ 1108 int 1109 rpc_call_async(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags, 1110 const struct rpc_call_ops *tk_ops, void *data) 1111 { 1112 struct rpc_task *task; 1113 struct rpc_task_setup task_setup_data = { 1114 .rpc_client = clnt, 1115 .rpc_message = msg, 1116 .callback_ops = tk_ops, 1117 .callback_data = data, 1118 .flags = flags|RPC_TASK_ASYNC, 1119 }; 1120 1121 task = rpc_run_task(&task_setup_data); 1122 if (IS_ERR(task)) 1123 return PTR_ERR(task); 1124 rpc_put_task(task); 1125 return 0; 1126 } 1127 EXPORT_SYMBOL_GPL(rpc_call_async); 1128 1129 #if defined(CONFIG_SUNRPC_BACKCHANNEL) 1130 static void call_bc_encode(struct rpc_task *task); 1131 1132 /** 1133 * rpc_run_bc_task - Allocate a new RPC task for backchannel use, then run 1134 * rpc_execute against it 1135 * @req: RPC request 1136 */ 1137 struct rpc_task *rpc_run_bc_task(struct rpc_rqst *req) 1138 { 1139 struct rpc_task *task; 1140 struct rpc_task_setup task_setup_data = { 1141 .callback_ops = &rpc_default_ops, 1142 .flags = RPC_TASK_SOFTCONN | 1143 RPC_TASK_NO_RETRANS_TIMEOUT, 1144 }; 1145 1146 dprintk("RPC: rpc_run_bc_task req= %p\n", req); 1147 /* 1148 * Create an rpc_task to send the data 1149 */ 1150 task = rpc_new_task(&task_setup_data); 1151 xprt_init_bc_request(req, task); 1152 1153 task->tk_action = call_bc_encode; 1154 atomic_inc(&task->tk_count); 1155 WARN_ON_ONCE(atomic_read(&task->tk_count) != 2); 1156 rpc_execute(task); 1157 1158 dprintk("RPC: rpc_run_bc_task: task= %p\n", task); 1159 return task; 1160 } 1161 #endif /* CONFIG_SUNRPC_BACKCHANNEL */ 1162 1163 /** 1164 * rpc_prepare_reply_pages - Prepare to receive a reply data payload into pages 1165 * @req: RPC request to prepare 1166 * @pages: vector of struct page pointers 1167 * @base: offset in first page where receive should start, in bytes 1168 * @len: expected size of the upper layer data payload, in bytes 1169 * @hdrsize: expected size of upper layer reply header, in XDR words 1170 * 1171 */ 1172 void rpc_prepare_reply_pages(struct rpc_rqst *req, struct page **pages, 1173 unsigned int base, unsigned int len, 1174 unsigned int hdrsize) 1175 { 1176 /* Subtract one to force an extra word of buffer space for the 1177 * payload's XDR pad to fall into the rcv_buf's tail iovec. 1178 */ 1179 hdrsize += RPC_REPHDRSIZE + req->rq_cred->cr_auth->au_ralign - 1; 1180 1181 xdr_inline_pages(&req->rq_rcv_buf, hdrsize << 2, pages, base, len); 1182 trace_rpc_reply_pages(req); 1183 } 1184 EXPORT_SYMBOL_GPL(rpc_prepare_reply_pages); 1185 1186 void 1187 rpc_call_start(struct rpc_task *task) 1188 { 1189 task->tk_action = call_start; 1190 } 1191 EXPORT_SYMBOL_GPL(rpc_call_start); 1192 1193 /** 1194 * rpc_peeraddr - extract remote peer address from clnt's xprt 1195 * @clnt: RPC client structure 1196 * @buf: target buffer 1197 * @bufsize: length of target buffer 1198 * 1199 * Returns the number of bytes that are actually in the stored address. 1200 */ 1201 size_t rpc_peeraddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t bufsize) 1202 { 1203 size_t bytes; 1204 struct rpc_xprt *xprt; 1205 1206 rcu_read_lock(); 1207 xprt = rcu_dereference(clnt->cl_xprt); 1208 1209 bytes = xprt->addrlen; 1210 if (bytes > bufsize) 1211 bytes = bufsize; 1212 memcpy(buf, &xprt->addr, bytes); 1213 rcu_read_unlock(); 1214 1215 return bytes; 1216 } 1217 EXPORT_SYMBOL_GPL(rpc_peeraddr); 1218 1219 /** 1220 * rpc_peeraddr2str - return remote peer address in printable format 1221 * @clnt: RPC client structure 1222 * @format: address format 1223 * 1224 * NB: the lifetime of the memory referenced by the returned pointer is 1225 * the same as the rpc_xprt itself. As long as the caller uses this 1226 * pointer, it must hold the RCU read lock. 1227 */ 1228 const char *rpc_peeraddr2str(struct rpc_clnt *clnt, 1229 enum rpc_display_format_t format) 1230 { 1231 struct rpc_xprt *xprt; 1232 1233 xprt = rcu_dereference(clnt->cl_xprt); 1234 1235 if (xprt->address_strings[format] != NULL) 1236 return xprt->address_strings[format]; 1237 else 1238 return "unprintable"; 1239 } 1240 EXPORT_SYMBOL_GPL(rpc_peeraddr2str); 1241 1242 static const struct sockaddr_in rpc_inaddr_loopback = { 1243 .sin_family = AF_INET, 1244 .sin_addr.s_addr = htonl(INADDR_ANY), 1245 }; 1246 1247 static const struct sockaddr_in6 rpc_in6addr_loopback = { 1248 .sin6_family = AF_INET6, 1249 .sin6_addr = IN6ADDR_ANY_INIT, 1250 }; 1251 1252 /* 1253 * Try a getsockname() on a connected datagram socket. Using a 1254 * connected datagram socket prevents leaving a socket in TIME_WAIT. 1255 * This conserves the ephemeral port number space. 1256 * 1257 * Returns zero and fills in "buf" if successful; otherwise, a 1258 * negative errno is returned. 1259 */ 1260 static int rpc_sockname(struct net *net, struct sockaddr *sap, size_t salen, 1261 struct sockaddr *buf) 1262 { 1263 struct socket *sock; 1264 int err; 1265 1266 err = __sock_create(net, sap->sa_family, 1267 SOCK_DGRAM, IPPROTO_UDP, &sock, 1); 1268 if (err < 0) { 1269 dprintk("RPC: can't create UDP socket (%d)\n", err); 1270 goto out; 1271 } 1272 1273 switch (sap->sa_family) { 1274 case AF_INET: 1275 err = kernel_bind(sock, 1276 (struct sockaddr *)&rpc_inaddr_loopback, 1277 sizeof(rpc_inaddr_loopback)); 1278 break; 1279 case AF_INET6: 1280 err = kernel_bind(sock, 1281 (struct sockaddr *)&rpc_in6addr_loopback, 1282 sizeof(rpc_in6addr_loopback)); 1283 break; 1284 default: 1285 err = -EAFNOSUPPORT; 1286 goto out; 1287 } 1288 if (err < 0) { 1289 dprintk("RPC: can't bind UDP socket (%d)\n", err); 1290 goto out_release; 1291 } 1292 1293 err = kernel_connect(sock, sap, salen, 0); 1294 if (err < 0) { 1295 dprintk("RPC: can't connect UDP socket (%d)\n", err); 1296 goto out_release; 1297 } 1298 1299 err = kernel_getsockname(sock, buf); 1300 if (err < 0) { 1301 dprintk("RPC: getsockname failed (%d)\n", err); 1302 goto out_release; 1303 } 1304 1305 err = 0; 1306 if (buf->sa_family == AF_INET6) { 1307 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)buf; 1308 sin6->sin6_scope_id = 0; 1309 } 1310 dprintk("RPC: %s succeeded\n", __func__); 1311 1312 out_release: 1313 sock_release(sock); 1314 out: 1315 return err; 1316 } 1317 1318 /* 1319 * Scraping a connected socket failed, so we don't have a useable 1320 * local address. Fallback: generate an address that will prevent 1321 * the server from calling us back. 1322 * 1323 * Returns zero and fills in "buf" if successful; otherwise, a 1324 * negative errno is returned. 1325 */ 1326 static int rpc_anyaddr(int family, struct sockaddr *buf, size_t buflen) 1327 { 1328 switch (family) { 1329 case AF_INET: 1330 if (buflen < sizeof(rpc_inaddr_loopback)) 1331 return -EINVAL; 1332 memcpy(buf, &rpc_inaddr_loopback, 1333 sizeof(rpc_inaddr_loopback)); 1334 break; 1335 case AF_INET6: 1336 if (buflen < sizeof(rpc_in6addr_loopback)) 1337 return -EINVAL; 1338 memcpy(buf, &rpc_in6addr_loopback, 1339 sizeof(rpc_in6addr_loopback)); 1340 break; 1341 default: 1342 dprintk("RPC: %s: address family not supported\n", 1343 __func__); 1344 return -EAFNOSUPPORT; 1345 } 1346 dprintk("RPC: %s: succeeded\n", __func__); 1347 return 0; 1348 } 1349 1350 /** 1351 * rpc_localaddr - discover local endpoint address for an RPC client 1352 * @clnt: RPC client structure 1353 * @buf: target buffer 1354 * @buflen: size of target buffer, in bytes 1355 * 1356 * Returns zero and fills in "buf" and "buflen" if successful; 1357 * otherwise, a negative errno is returned. 1358 * 1359 * This works even if the underlying transport is not currently connected, 1360 * or if the upper layer never previously provided a source address. 1361 * 1362 * The result of this function call is transient: multiple calls in 1363 * succession may give different results, depending on how local 1364 * networking configuration changes over time. 1365 */ 1366 int rpc_localaddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t buflen) 1367 { 1368 struct sockaddr_storage address; 1369 struct sockaddr *sap = (struct sockaddr *)&address; 1370 struct rpc_xprt *xprt; 1371 struct net *net; 1372 size_t salen; 1373 int err; 1374 1375 rcu_read_lock(); 1376 xprt = rcu_dereference(clnt->cl_xprt); 1377 salen = xprt->addrlen; 1378 memcpy(sap, &xprt->addr, salen); 1379 net = get_net(xprt->xprt_net); 1380 rcu_read_unlock(); 1381 1382 rpc_set_port(sap, 0); 1383 err = rpc_sockname(net, sap, salen, buf); 1384 put_net(net); 1385 if (err != 0) 1386 /* Couldn't discover local address, return ANYADDR */ 1387 return rpc_anyaddr(sap->sa_family, buf, buflen); 1388 return 0; 1389 } 1390 EXPORT_SYMBOL_GPL(rpc_localaddr); 1391 1392 void 1393 rpc_setbufsize(struct rpc_clnt *clnt, unsigned int sndsize, unsigned int rcvsize) 1394 { 1395 struct rpc_xprt *xprt; 1396 1397 rcu_read_lock(); 1398 xprt = rcu_dereference(clnt->cl_xprt); 1399 if (xprt->ops->set_buffer_size) 1400 xprt->ops->set_buffer_size(xprt, sndsize, rcvsize); 1401 rcu_read_unlock(); 1402 } 1403 EXPORT_SYMBOL_GPL(rpc_setbufsize); 1404 1405 /** 1406 * rpc_net_ns - Get the network namespace for this RPC client 1407 * @clnt: RPC client to query 1408 * 1409 */ 1410 struct net *rpc_net_ns(struct rpc_clnt *clnt) 1411 { 1412 struct net *ret; 1413 1414 rcu_read_lock(); 1415 ret = rcu_dereference(clnt->cl_xprt)->xprt_net; 1416 rcu_read_unlock(); 1417 return ret; 1418 } 1419 EXPORT_SYMBOL_GPL(rpc_net_ns); 1420 1421 /** 1422 * rpc_max_payload - Get maximum payload size for a transport, in bytes 1423 * @clnt: RPC client to query 1424 * 1425 * For stream transports, this is one RPC record fragment (see RFC 1426 * 1831), as we don't support multi-record requests yet. For datagram 1427 * transports, this is the size of an IP packet minus the IP, UDP, and 1428 * RPC header sizes. 1429 */ 1430 size_t rpc_max_payload(struct rpc_clnt *clnt) 1431 { 1432 size_t ret; 1433 1434 rcu_read_lock(); 1435 ret = rcu_dereference(clnt->cl_xprt)->max_payload; 1436 rcu_read_unlock(); 1437 return ret; 1438 } 1439 EXPORT_SYMBOL_GPL(rpc_max_payload); 1440 1441 /** 1442 * rpc_max_bc_payload - Get maximum backchannel payload size, in bytes 1443 * @clnt: RPC client to query 1444 */ 1445 size_t rpc_max_bc_payload(struct rpc_clnt *clnt) 1446 { 1447 struct rpc_xprt *xprt; 1448 size_t ret; 1449 1450 rcu_read_lock(); 1451 xprt = rcu_dereference(clnt->cl_xprt); 1452 ret = xprt->ops->bc_maxpayload(xprt); 1453 rcu_read_unlock(); 1454 return ret; 1455 } 1456 EXPORT_SYMBOL_GPL(rpc_max_bc_payload); 1457 1458 /** 1459 * rpc_force_rebind - force transport to check that remote port is unchanged 1460 * @clnt: client to rebind 1461 * 1462 */ 1463 void rpc_force_rebind(struct rpc_clnt *clnt) 1464 { 1465 if (clnt->cl_autobind) { 1466 rcu_read_lock(); 1467 xprt_clear_bound(rcu_dereference(clnt->cl_xprt)); 1468 rcu_read_unlock(); 1469 } 1470 } 1471 EXPORT_SYMBOL_GPL(rpc_force_rebind); 1472 1473 /* 1474 * Restart an (async) RPC call from the call_prepare state. 1475 * Usually called from within the exit handler. 1476 */ 1477 int 1478 rpc_restart_call_prepare(struct rpc_task *task) 1479 { 1480 if (RPC_ASSASSINATED(task)) 1481 return 0; 1482 task->tk_action = call_start; 1483 task->tk_status = 0; 1484 if (task->tk_ops->rpc_call_prepare != NULL) 1485 task->tk_action = rpc_prepare_task; 1486 return 1; 1487 } 1488 EXPORT_SYMBOL_GPL(rpc_restart_call_prepare); 1489 1490 /* 1491 * Restart an (async) RPC call. Usually called from within the 1492 * exit handler. 1493 */ 1494 int 1495 rpc_restart_call(struct rpc_task *task) 1496 { 1497 if (RPC_ASSASSINATED(task)) 1498 return 0; 1499 task->tk_action = call_start; 1500 task->tk_status = 0; 1501 return 1; 1502 } 1503 EXPORT_SYMBOL_GPL(rpc_restart_call); 1504 1505 const char 1506 *rpc_proc_name(const struct rpc_task *task) 1507 { 1508 const struct rpc_procinfo *proc = task->tk_msg.rpc_proc; 1509 1510 if (proc) { 1511 if (proc->p_name) 1512 return proc->p_name; 1513 else 1514 return "NULL"; 1515 } else 1516 return "no proc"; 1517 } 1518 1519 /* 1520 * 0. Initial state 1521 * 1522 * Other FSM states can be visited zero or more times, but 1523 * this state is visited exactly once for each RPC. 1524 */ 1525 static void 1526 call_start(struct rpc_task *task) 1527 { 1528 struct rpc_clnt *clnt = task->tk_client; 1529 int idx = task->tk_msg.rpc_proc->p_statidx; 1530 1531 trace_rpc_request(task); 1532 dprintk("RPC: %5u call_start %s%d proc %s (%s)\n", task->tk_pid, 1533 clnt->cl_program->name, clnt->cl_vers, 1534 rpc_proc_name(task), 1535 (RPC_IS_ASYNC(task) ? "async" : "sync")); 1536 1537 /* Increment call count (version might not be valid for ping) */ 1538 if (clnt->cl_program->version[clnt->cl_vers]) 1539 clnt->cl_program->version[clnt->cl_vers]->counts[idx]++; 1540 clnt->cl_stats->rpccnt++; 1541 task->tk_action = call_reserve; 1542 rpc_task_set_transport(task, clnt); 1543 } 1544 1545 /* 1546 * 1. Reserve an RPC call slot 1547 */ 1548 static void 1549 call_reserve(struct rpc_task *task) 1550 { 1551 dprint_status(task); 1552 1553 task->tk_status = 0; 1554 task->tk_action = call_reserveresult; 1555 xprt_reserve(task); 1556 } 1557 1558 static void call_retry_reserve(struct rpc_task *task); 1559 1560 /* 1561 * 1b. Grok the result of xprt_reserve() 1562 */ 1563 static void 1564 call_reserveresult(struct rpc_task *task) 1565 { 1566 int status = task->tk_status; 1567 1568 dprint_status(task); 1569 1570 /* 1571 * After a call to xprt_reserve(), we must have either 1572 * a request slot or else an error status. 1573 */ 1574 task->tk_status = 0; 1575 if (status >= 0) { 1576 if (task->tk_rqstp) { 1577 task->tk_action = call_refresh; 1578 return; 1579 } 1580 1581 printk(KERN_ERR "%s: status=%d, but no request slot, exiting\n", 1582 __func__, status); 1583 rpc_exit(task, -EIO); 1584 return; 1585 } 1586 1587 /* 1588 * Even though there was an error, we may have acquired 1589 * a request slot somehow. Make sure not to leak it. 1590 */ 1591 if (task->tk_rqstp) { 1592 printk(KERN_ERR "%s: status=%d, request allocated anyway\n", 1593 __func__, status); 1594 xprt_release(task); 1595 } 1596 1597 switch (status) { 1598 case -ENOMEM: 1599 rpc_delay(task, HZ >> 2); 1600 /* fall through */ 1601 case -EAGAIN: /* woken up; retry */ 1602 task->tk_action = call_retry_reserve; 1603 return; 1604 case -EIO: /* probably a shutdown */ 1605 break; 1606 default: 1607 printk(KERN_ERR "%s: unrecognized error %d, exiting\n", 1608 __func__, status); 1609 break; 1610 } 1611 rpc_exit(task, status); 1612 } 1613 1614 /* 1615 * 1c. Retry reserving an RPC call slot 1616 */ 1617 static void 1618 call_retry_reserve(struct rpc_task *task) 1619 { 1620 dprint_status(task); 1621 1622 task->tk_status = 0; 1623 task->tk_action = call_reserveresult; 1624 xprt_retry_reserve(task); 1625 } 1626 1627 /* 1628 * 2. Bind and/or refresh the credentials 1629 */ 1630 static void 1631 call_refresh(struct rpc_task *task) 1632 { 1633 dprint_status(task); 1634 1635 task->tk_action = call_refreshresult; 1636 task->tk_status = 0; 1637 task->tk_client->cl_stats->rpcauthrefresh++; 1638 rpcauth_refreshcred(task); 1639 } 1640 1641 /* 1642 * 2a. Process the results of a credential refresh 1643 */ 1644 static void 1645 call_refreshresult(struct rpc_task *task) 1646 { 1647 int status = task->tk_status; 1648 1649 dprint_status(task); 1650 1651 task->tk_status = 0; 1652 task->tk_action = call_refresh; 1653 switch (status) { 1654 case 0: 1655 if (rpcauth_uptodatecred(task)) { 1656 task->tk_action = call_allocate; 1657 return; 1658 } 1659 /* Use rate-limiting and a max number of retries if refresh 1660 * had status 0 but failed to update the cred. 1661 */ 1662 /* fall through */ 1663 case -ETIMEDOUT: 1664 rpc_delay(task, 3*HZ); 1665 /* fall through */ 1666 case -EAGAIN: 1667 status = -EACCES; 1668 /* fall through */ 1669 case -EKEYEXPIRED: 1670 if (!task->tk_cred_retry) 1671 break; 1672 task->tk_cred_retry--; 1673 dprintk("RPC: %5u %s: retry refresh creds\n", 1674 task->tk_pid, __func__); 1675 return; 1676 } 1677 dprintk("RPC: %5u %s: refresh creds failed with error %d\n", 1678 task->tk_pid, __func__, status); 1679 rpc_exit(task, status); 1680 } 1681 1682 /* 1683 * 2b. Allocate the buffer. For details, see sched.c:rpc_malloc. 1684 * (Note: buffer memory is freed in xprt_release). 1685 */ 1686 static void 1687 call_allocate(struct rpc_task *task) 1688 { 1689 const struct rpc_auth *auth = task->tk_rqstp->rq_cred->cr_auth; 1690 struct rpc_rqst *req = task->tk_rqstp; 1691 struct rpc_xprt *xprt = req->rq_xprt; 1692 const struct rpc_procinfo *proc = task->tk_msg.rpc_proc; 1693 int status; 1694 1695 dprint_status(task); 1696 1697 task->tk_status = 0; 1698 task->tk_action = call_encode; 1699 1700 if (req->rq_buffer) 1701 return; 1702 1703 if (proc->p_proc != 0) { 1704 BUG_ON(proc->p_arglen == 0); 1705 if (proc->p_decode != NULL) 1706 BUG_ON(proc->p_replen == 0); 1707 } 1708 1709 /* 1710 * Calculate the size (in quads) of the RPC call 1711 * and reply headers, and convert both values 1712 * to byte sizes. 1713 */ 1714 req->rq_callsize = RPC_CALLHDRSIZE + (auth->au_cslack << 1) + 1715 proc->p_arglen; 1716 req->rq_callsize <<= 2; 1717 /* 1718 * Note: the reply buffer must at minimum allocate enough space 1719 * for the 'struct accepted_reply' from RFC5531. 1720 */ 1721 req->rq_rcvsize = RPC_REPHDRSIZE + auth->au_rslack + \ 1722 max_t(size_t, proc->p_replen, 2); 1723 req->rq_rcvsize <<= 2; 1724 1725 status = xprt->ops->buf_alloc(task); 1726 xprt_inject_disconnect(xprt); 1727 if (status == 0) 1728 return; 1729 if (status != -ENOMEM) { 1730 rpc_exit(task, status); 1731 return; 1732 } 1733 1734 dprintk("RPC: %5u rpc_buffer allocation failed\n", task->tk_pid); 1735 1736 if (RPC_IS_ASYNC(task) || !fatal_signal_pending(current)) { 1737 task->tk_action = call_allocate; 1738 rpc_delay(task, HZ>>4); 1739 return; 1740 } 1741 1742 rpc_exit(task, -ERESTARTSYS); 1743 } 1744 1745 static int 1746 rpc_task_need_encode(struct rpc_task *task) 1747 { 1748 return test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate) == 0 && 1749 (!(task->tk_flags & RPC_TASK_SENT) || 1750 !(task->tk_flags & RPC_TASK_NO_RETRANS_TIMEOUT) || 1751 xprt_request_need_retransmit(task)); 1752 } 1753 1754 static void 1755 rpc_xdr_encode(struct rpc_task *task) 1756 { 1757 struct rpc_rqst *req = task->tk_rqstp; 1758 struct xdr_stream xdr; 1759 1760 xdr_buf_init(&req->rq_snd_buf, 1761 req->rq_buffer, 1762 req->rq_callsize); 1763 xdr_buf_init(&req->rq_rcv_buf, 1764 req->rq_rbuffer, 1765 req->rq_rcvsize); 1766 1767 req->rq_snd_buf.head[0].iov_len = 0; 1768 xdr_init_encode(&xdr, &req->rq_snd_buf, 1769 req->rq_snd_buf.head[0].iov_base, req); 1770 if (rpc_encode_header(task, &xdr)) 1771 return; 1772 1773 task->tk_status = rpcauth_wrap_req(task, &xdr); 1774 } 1775 1776 /* 1777 * 3. Encode arguments of an RPC call 1778 */ 1779 static void 1780 call_encode(struct rpc_task *task) 1781 { 1782 if (!rpc_task_need_encode(task)) 1783 goto out; 1784 dprint_status(task); 1785 /* Encode here so that rpcsec_gss can use correct sequence number. */ 1786 rpc_xdr_encode(task); 1787 /* Did the encode result in an error condition? */ 1788 if (task->tk_status != 0) { 1789 /* Was the error nonfatal? */ 1790 switch (task->tk_status) { 1791 case -EAGAIN: 1792 case -ENOMEM: 1793 rpc_delay(task, HZ >> 4); 1794 break; 1795 case -EKEYEXPIRED: 1796 task->tk_action = call_refresh; 1797 break; 1798 default: 1799 rpc_exit(task, task->tk_status); 1800 } 1801 return; 1802 } else { 1803 xprt_request_prepare(task->tk_rqstp); 1804 } 1805 1806 /* Add task to reply queue before transmission to avoid races */ 1807 if (rpc_reply_expected(task)) 1808 xprt_request_enqueue_receive(task); 1809 xprt_request_enqueue_transmit(task); 1810 out: 1811 task->tk_action = call_transmit; 1812 /* Check that the connection is OK */ 1813 if (!xprt_bound(task->tk_xprt)) 1814 task->tk_action = call_bind; 1815 else if (!xprt_connected(task->tk_xprt)) 1816 task->tk_action = call_connect; 1817 } 1818 1819 /* 1820 * Helpers to check if the task was already transmitted, and 1821 * to take action when that is the case. 1822 */ 1823 static bool 1824 rpc_task_transmitted(struct rpc_task *task) 1825 { 1826 return !test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate); 1827 } 1828 1829 static void 1830 rpc_task_handle_transmitted(struct rpc_task *task) 1831 { 1832 xprt_end_transmit(task); 1833 task->tk_action = call_transmit_status; 1834 } 1835 1836 /* 1837 * 4. Get the server port number if not yet set 1838 */ 1839 static void 1840 call_bind(struct rpc_task *task) 1841 { 1842 struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt; 1843 1844 if (rpc_task_transmitted(task)) { 1845 rpc_task_handle_transmitted(task); 1846 return; 1847 } 1848 1849 if (xprt_bound(xprt)) { 1850 task->tk_action = call_connect; 1851 return; 1852 } 1853 1854 dprint_status(task); 1855 1856 task->tk_action = call_bind_status; 1857 if (!xprt_prepare_transmit(task)) 1858 return; 1859 1860 task->tk_timeout = xprt->bind_timeout; 1861 xprt->ops->rpcbind(task); 1862 } 1863 1864 /* 1865 * 4a. Sort out bind result 1866 */ 1867 static void 1868 call_bind_status(struct rpc_task *task) 1869 { 1870 int status = -EIO; 1871 1872 if (rpc_task_transmitted(task)) { 1873 rpc_task_handle_transmitted(task); 1874 return; 1875 } 1876 1877 if (task->tk_status >= 0) { 1878 dprint_status(task); 1879 task->tk_status = 0; 1880 task->tk_action = call_connect; 1881 return; 1882 } 1883 1884 trace_rpc_bind_status(task); 1885 switch (task->tk_status) { 1886 case -ENOMEM: 1887 dprintk("RPC: %5u rpcbind out of memory\n", task->tk_pid); 1888 rpc_delay(task, HZ >> 2); 1889 goto retry_timeout; 1890 case -EACCES: 1891 dprintk("RPC: %5u remote rpcbind: RPC program/version " 1892 "unavailable\n", task->tk_pid); 1893 /* fail immediately if this is an RPC ping */ 1894 if (task->tk_msg.rpc_proc->p_proc == 0) { 1895 status = -EOPNOTSUPP; 1896 break; 1897 } 1898 if (task->tk_rebind_retry == 0) 1899 break; 1900 task->tk_rebind_retry--; 1901 rpc_delay(task, 3*HZ); 1902 goto retry_timeout; 1903 case -EAGAIN: 1904 goto retry_timeout; 1905 case -ETIMEDOUT: 1906 dprintk("RPC: %5u rpcbind request timed out\n", 1907 task->tk_pid); 1908 goto retry_timeout; 1909 case -EPFNOSUPPORT: 1910 /* server doesn't support any rpcbind version we know of */ 1911 dprintk("RPC: %5u unrecognized remote rpcbind service\n", 1912 task->tk_pid); 1913 break; 1914 case -EPROTONOSUPPORT: 1915 dprintk("RPC: %5u remote rpcbind version unavailable, retrying\n", 1916 task->tk_pid); 1917 goto retry_timeout; 1918 case -ECONNREFUSED: /* connection problems */ 1919 case -ECONNRESET: 1920 case -ECONNABORTED: 1921 case -ENOTCONN: 1922 case -EHOSTDOWN: 1923 case -ENETDOWN: 1924 case -EHOSTUNREACH: 1925 case -ENETUNREACH: 1926 case -ENOBUFS: 1927 case -EPIPE: 1928 dprintk("RPC: %5u remote rpcbind unreachable: %d\n", 1929 task->tk_pid, task->tk_status); 1930 if (!RPC_IS_SOFTCONN(task)) { 1931 rpc_delay(task, 5*HZ); 1932 goto retry_timeout; 1933 } 1934 status = task->tk_status; 1935 break; 1936 default: 1937 dprintk("RPC: %5u unrecognized rpcbind error (%d)\n", 1938 task->tk_pid, -task->tk_status); 1939 } 1940 1941 rpc_exit(task, status); 1942 return; 1943 1944 retry_timeout: 1945 task->tk_status = 0; 1946 task->tk_action = call_bind; 1947 rpc_check_timeout(task); 1948 } 1949 1950 /* 1951 * 4b. Connect to the RPC server 1952 */ 1953 static void 1954 call_connect(struct rpc_task *task) 1955 { 1956 struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt; 1957 1958 if (rpc_task_transmitted(task)) { 1959 rpc_task_handle_transmitted(task); 1960 return; 1961 } 1962 1963 if (xprt_connected(xprt)) { 1964 task->tk_action = call_transmit; 1965 return; 1966 } 1967 1968 dprintk("RPC: %5u call_connect xprt %p %s connected\n", 1969 task->tk_pid, xprt, 1970 (xprt_connected(xprt) ? "is" : "is not")); 1971 1972 task->tk_action = call_connect_status; 1973 if (task->tk_status < 0) 1974 return; 1975 if (task->tk_flags & RPC_TASK_NOCONNECT) { 1976 rpc_exit(task, -ENOTCONN); 1977 return; 1978 } 1979 if (!xprt_prepare_transmit(task)) 1980 return; 1981 xprt_connect(task); 1982 } 1983 1984 /* 1985 * 4c. Sort out connect result 1986 */ 1987 static void 1988 call_connect_status(struct rpc_task *task) 1989 { 1990 struct rpc_clnt *clnt = task->tk_client; 1991 int status = task->tk_status; 1992 1993 if (rpc_task_transmitted(task)) { 1994 rpc_task_handle_transmitted(task); 1995 return; 1996 } 1997 1998 dprint_status(task); 1999 2000 trace_rpc_connect_status(task); 2001 task->tk_status = 0; 2002 switch (status) { 2003 case -ECONNREFUSED: 2004 /* A positive refusal suggests a rebind is needed. */ 2005 if (RPC_IS_SOFTCONN(task)) 2006 break; 2007 if (clnt->cl_autobind) { 2008 rpc_force_rebind(clnt); 2009 goto out_retry; 2010 } 2011 /* fall through */ 2012 case -ECONNRESET: 2013 case -ECONNABORTED: 2014 case -ENETDOWN: 2015 case -ENETUNREACH: 2016 case -EHOSTUNREACH: 2017 case -EADDRINUSE: 2018 case -ENOBUFS: 2019 case -EPIPE: 2020 xprt_conditional_disconnect(task->tk_rqstp->rq_xprt, 2021 task->tk_rqstp->rq_connect_cookie); 2022 if (RPC_IS_SOFTCONN(task)) 2023 break; 2024 /* retry with existing socket, after a delay */ 2025 rpc_delay(task, 3*HZ); 2026 /* fall through */ 2027 case -ENOTCONN: 2028 case -EAGAIN: 2029 case -ETIMEDOUT: 2030 goto out_retry; 2031 case 0: 2032 clnt->cl_stats->netreconn++; 2033 task->tk_action = call_transmit; 2034 return; 2035 } 2036 rpc_exit(task, status); 2037 return; 2038 out_retry: 2039 /* Check for timeouts before looping back to call_bind */ 2040 task->tk_action = call_bind; 2041 rpc_check_timeout(task); 2042 } 2043 2044 /* 2045 * 5. Transmit the RPC request, and wait for reply 2046 */ 2047 static void 2048 call_transmit(struct rpc_task *task) 2049 { 2050 if (rpc_task_transmitted(task)) { 2051 rpc_task_handle_transmitted(task); 2052 return; 2053 } 2054 2055 dprint_status(task); 2056 2057 task->tk_action = call_transmit_status; 2058 if (!xprt_prepare_transmit(task)) 2059 return; 2060 task->tk_status = 0; 2061 if (test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate)) { 2062 if (!xprt_connected(task->tk_xprt)) { 2063 task->tk_status = -ENOTCONN; 2064 return; 2065 } 2066 xprt_transmit(task); 2067 } 2068 xprt_end_transmit(task); 2069 } 2070 2071 /* 2072 * 5a. Handle cleanup after a transmission 2073 */ 2074 static void 2075 call_transmit_status(struct rpc_task *task) 2076 { 2077 task->tk_action = call_status; 2078 2079 /* 2080 * Common case: success. Force the compiler to put this 2081 * test first. 2082 */ 2083 if (rpc_task_transmitted(task)) { 2084 task->tk_status = 0; 2085 xprt_request_wait_receive(task); 2086 return; 2087 } 2088 2089 switch (task->tk_status) { 2090 default: 2091 dprint_status(task); 2092 break; 2093 case -EBADMSG: 2094 task->tk_status = 0; 2095 task->tk_action = call_encode; 2096 break; 2097 /* 2098 * Special cases: if we've been waiting on the 2099 * socket's write_space() callback, or if the 2100 * socket just returned a connection error, 2101 * then hold onto the transport lock. 2102 */ 2103 case -ENOBUFS: 2104 rpc_delay(task, HZ>>2); 2105 /* fall through */ 2106 case -EBADSLT: 2107 case -EAGAIN: 2108 task->tk_action = call_transmit; 2109 task->tk_status = 0; 2110 break; 2111 case -ECONNREFUSED: 2112 case -EHOSTDOWN: 2113 case -ENETDOWN: 2114 case -EHOSTUNREACH: 2115 case -ENETUNREACH: 2116 case -EPERM: 2117 if (RPC_IS_SOFTCONN(task)) { 2118 if (!task->tk_msg.rpc_proc->p_proc) 2119 trace_xprt_ping(task->tk_xprt, 2120 task->tk_status); 2121 rpc_exit(task, task->tk_status); 2122 return; 2123 } 2124 /* fall through */ 2125 case -ECONNRESET: 2126 case -ECONNABORTED: 2127 case -EADDRINUSE: 2128 case -ENOTCONN: 2129 case -EPIPE: 2130 task->tk_action = call_bind; 2131 task->tk_status = 0; 2132 break; 2133 } 2134 rpc_check_timeout(task); 2135 } 2136 2137 #if defined(CONFIG_SUNRPC_BACKCHANNEL) 2138 static void call_bc_transmit(struct rpc_task *task); 2139 static void call_bc_transmit_status(struct rpc_task *task); 2140 2141 static void 2142 call_bc_encode(struct rpc_task *task) 2143 { 2144 xprt_request_enqueue_transmit(task); 2145 task->tk_action = call_bc_transmit; 2146 } 2147 2148 /* 2149 * 5b. Send the backchannel RPC reply. On error, drop the reply. In 2150 * addition, disconnect on connectivity errors. 2151 */ 2152 static void 2153 call_bc_transmit(struct rpc_task *task) 2154 { 2155 task->tk_action = call_bc_transmit_status; 2156 if (test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate)) { 2157 if (!xprt_prepare_transmit(task)) 2158 return; 2159 task->tk_status = 0; 2160 xprt_transmit(task); 2161 } 2162 xprt_end_transmit(task); 2163 } 2164 2165 static void 2166 call_bc_transmit_status(struct rpc_task *task) 2167 { 2168 struct rpc_rqst *req = task->tk_rqstp; 2169 2170 if (rpc_task_transmitted(task)) 2171 task->tk_status = 0; 2172 2173 dprint_status(task); 2174 2175 switch (task->tk_status) { 2176 case 0: 2177 /* Success */ 2178 case -ENETDOWN: 2179 case -EHOSTDOWN: 2180 case -EHOSTUNREACH: 2181 case -ENETUNREACH: 2182 case -ECONNRESET: 2183 case -ECONNREFUSED: 2184 case -EADDRINUSE: 2185 case -ENOTCONN: 2186 case -EPIPE: 2187 break; 2188 case -ENOBUFS: 2189 rpc_delay(task, HZ>>2); 2190 /* fall through */ 2191 case -EBADSLT: 2192 case -EAGAIN: 2193 task->tk_status = 0; 2194 task->tk_action = call_bc_transmit; 2195 return; 2196 case -ETIMEDOUT: 2197 /* 2198 * Problem reaching the server. Disconnect and let the 2199 * forechannel reestablish the connection. The server will 2200 * have to retransmit the backchannel request and we'll 2201 * reprocess it. Since these ops are idempotent, there's no 2202 * need to cache our reply at this time. 2203 */ 2204 printk(KERN_NOTICE "RPC: Could not send backchannel reply " 2205 "error: %d\n", task->tk_status); 2206 xprt_conditional_disconnect(req->rq_xprt, 2207 req->rq_connect_cookie); 2208 break; 2209 default: 2210 /* 2211 * We were unable to reply and will have to drop the 2212 * request. The server should reconnect and retransmit. 2213 */ 2214 printk(KERN_NOTICE "RPC: Could not send backchannel reply " 2215 "error: %d\n", task->tk_status); 2216 break; 2217 } 2218 task->tk_action = rpc_exit_task; 2219 } 2220 #endif /* CONFIG_SUNRPC_BACKCHANNEL */ 2221 2222 /* 2223 * 6. Sort out the RPC call status 2224 */ 2225 static void 2226 call_status(struct rpc_task *task) 2227 { 2228 struct rpc_clnt *clnt = task->tk_client; 2229 int status; 2230 2231 if (!task->tk_msg.rpc_proc->p_proc) 2232 trace_xprt_ping(task->tk_xprt, task->tk_status); 2233 2234 dprint_status(task); 2235 2236 status = task->tk_status; 2237 if (status >= 0) { 2238 task->tk_action = call_decode; 2239 return; 2240 } 2241 2242 trace_rpc_call_status(task); 2243 task->tk_status = 0; 2244 switch(status) { 2245 case -EHOSTDOWN: 2246 case -ENETDOWN: 2247 case -EHOSTUNREACH: 2248 case -ENETUNREACH: 2249 case -EPERM: 2250 if (RPC_IS_SOFTCONN(task)) 2251 goto out_exit; 2252 /* 2253 * Delay any retries for 3 seconds, then handle as if it 2254 * were a timeout. 2255 */ 2256 rpc_delay(task, 3*HZ); 2257 /* fall through */ 2258 case -ETIMEDOUT: 2259 break; 2260 case -ECONNREFUSED: 2261 case -ECONNRESET: 2262 case -ECONNABORTED: 2263 rpc_force_rebind(clnt); 2264 /* fall through */ 2265 case -EADDRINUSE: 2266 rpc_delay(task, 3*HZ); 2267 /* fall through */ 2268 case -EPIPE: 2269 case -ENOTCONN: 2270 case -EAGAIN: 2271 break; 2272 case -EIO: 2273 /* shutdown or soft timeout */ 2274 goto out_exit; 2275 default: 2276 if (clnt->cl_chatty) 2277 printk("%s: RPC call returned error %d\n", 2278 clnt->cl_program->name, -status); 2279 goto out_exit; 2280 } 2281 task->tk_action = call_encode; 2282 rpc_check_timeout(task); 2283 return; 2284 out_exit: 2285 rpc_exit(task, status); 2286 } 2287 2288 static bool 2289 rpc_check_connected(const struct rpc_rqst *req) 2290 { 2291 /* No allocated request or transport? return true */ 2292 if (!req || !req->rq_xprt) 2293 return true; 2294 return xprt_connected(req->rq_xprt); 2295 } 2296 2297 static void 2298 rpc_check_timeout(struct rpc_task *task) 2299 { 2300 struct rpc_clnt *clnt = task->tk_client; 2301 2302 if (xprt_adjust_timeout(task->tk_rqstp) == 0) 2303 return; 2304 2305 dprintk("RPC: %5u call_timeout (major)\n", task->tk_pid); 2306 task->tk_timeouts++; 2307 2308 if (RPC_IS_SOFTCONN(task) && !rpc_check_connected(task->tk_rqstp)) { 2309 rpc_exit(task, -ETIMEDOUT); 2310 return; 2311 } 2312 2313 if (RPC_IS_SOFT(task)) { 2314 if (clnt->cl_chatty) { 2315 printk(KERN_NOTICE "%s: server %s not responding, timed out\n", 2316 clnt->cl_program->name, 2317 task->tk_xprt->servername); 2318 } 2319 if (task->tk_flags & RPC_TASK_TIMEOUT) 2320 rpc_exit(task, -ETIMEDOUT); 2321 else 2322 rpc_exit(task, -EIO); 2323 return; 2324 } 2325 2326 if (!(task->tk_flags & RPC_CALL_MAJORSEEN)) { 2327 task->tk_flags |= RPC_CALL_MAJORSEEN; 2328 if (clnt->cl_chatty) { 2329 printk(KERN_NOTICE "%s: server %s not responding, still trying\n", 2330 clnt->cl_program->name, 2331 task->tk_xprt->servername); 2332 } 2333 } 2334 rpc_force_rebind(clnt); 2335 /* 2336 * Did our request time out due to an RPCSEC_GSS out-of-sequence 2337 * event? RFC2203 requires the server to drop all such requests. 2338 */ 2339 rpcauth_invalcred(task); 2340 } 2341 2342 /* 2343 * 7. Decode the RPC reply 2344 */ 2345 static void 2346 call_decode(struct rpc_task *task) 2347 { 2348 struct rpc_clnt *clnt = task->tk_client; 2349 struct rpc_rqst *req = task->tk_rqstp; 2350 struct xdr_stream xdr; 2351 2352 dprint_status(task); 2353 2354 if (!task->tk_msg.rpc_proc->p_decode) { 2355 task->tk_action = rpc_exit_task; 2356 return; 2357 } 2358 2359 if (task->tk_flags & RPC_CALL_MAJORSEEN) { 2360 if (clnt->cl_chatty) { 2361 printk(KERN_NOTICE "%s: server %s OK\n", 2362 clnt->cl_program->name, 2363 task->tk_xprt->servername); 2364 } 2365 task->tk_flags &= ~RPC_CALL_MAJORSEEN; 2366 } 2367 2368 /* 2369 * Ensure that we see all writes made by xprt_complete_rqst() 2370 * before it changed req->rq_reply_bytes_recvd. 2371 */ 2372 smp_rmb(); 2373 req->rq_rcv_buf.len = req->rq_private_buf.len; 2374 2375 /* Check that the softirq receive buffer is valid */ 2376 WARN_ON(memcmp(&req->rq_rcv_buf, &req->rq_private_buf, 2377 sizeof(req->rq_rcv_buf)) != 0); 2378 2379 xdr_init_decode(&xdr, &req->rq_rcv_buf, 2380 req->rq_rcv_buf.head[0].iov_base, req); 2381 switch (rpc_decode_header(task, &xdr)) { 2382 case 0: 2383 task->tk_action = rpc_exit_task; 2384 task->tk_status = rpcauth_unwrap_resp(task, &xdr); 2385 dprintk("RPC: %5u %s result %d\n", 2386 task->tk_pid, __func__, task->tk_status); 2387 return; 2388 case -EAGAIN: 2389 task->tk_status = 0; 2390 /* Note: rpc_decode_header() may have freed the RPC slot */ 2391 if (task->tk_rqstp == req) { 2392 xdr_free_bvec(&req->rq_rcv_buf); 2393 req->rq_reply_bytes_recvd = 0; 2394 req->rq_rcv_buf.len = 0; 2395 if (task->tk_client->cl_discrtry) 2396 xprt_conditional_disconnect(req->rq_xprt, 2397 req->rq_connect_cookie); 2398 } 2399 task->tk_action = call_encode; 2400 rpc_check_timeout(task); 2401 } 2402 } 2403 2404 static int 2405 rpc_encode_header(struct rpc_task *task, struct xdr_stream *xdr) 2406 { 2407 struct rpc_clnt *clnt = task->tk_client; 2408 struct rpc_rqst *req = task->tk_rqstp; 2409 __be32 *p; 2410 int error; 2411 2412 error = -EMSGSIZE; 2413 p = xdr_reserve_space(xdr, RPC_CALLHDRSIZE << 2); 2414 if (!p) 2415 goto out_fail; 2416 *p++ = req->rq_xid; 2417 *p++ = rpc_call; 2418 *p++ = cpu_to_be32(RPC_VERSION); 2419 *p++ = cpu_to_be32(clnt->cl_prog); 2420 *p++ = cpu_to_be32(clnt->cl_vers); 2421 *p = cpu_to_be32(task->tk_msg.rpc_proc->p_proc); 2422 2423 error = rpcauth_marshcred(task, xdr); 2424 if (error < 0) 2425 goto out_fail; 2426 return 0; 2427 out_fail: 2428 trace_rpc_bad_callhdr(task); 2429 rpc_exit(task, error); 2430 return error; 2431 } 2432 2433 static noinline int 2434 rpc_decode_header(struct rpc_task *task, struct xdr_stream *xdr) 2435 { 2436 struct rpc_clnt *clnt = task->tk_client; 2437 int error; 2438 __be32 *p; 2439 2440 /* RFC-1014 says that the representation of XDR data must be a 2441 * multiple of four bytes 2442 * - if it isn't pointer subtraction in the NFS client may give 2443 * undefined results 2444 */ 2445 if (task->tk_rqstp->rq_rcv_buf.len & 3) 2446 goto out_unparsable; 2447 2448 p = xdr_inline_decode(xdr, 3 * sizeof(*p)); 2449 if (!p) 2450 goto out_unparsable; 2451 p++; /* skip XID */ 2452 if (*p++ != rpc_reply) 2453 goto out_unparsable; 2454 if (*p++ != rpc_msg_accepted) 2455 goto out_msg_denied; 2456 2457 error = rpcauth_checkverf(task, xdr); 2458 if (error) 2459 goto out_verifier; 2460 2461 p = xdr_inline_decode(xdr, sizeof(*p)); 2462 if (!p) 2463 goto out_unparsable; 2464 switch (*p) { 2465 case rpc_success: 2466 return 0; 2467 case rpc_prog_unavail: 2468 trace_rpc__prog_unavail(task); 2469 error = -EPFNOSUPPORT; 2470 goto out_err; 2471 case rpc_prog_mismatch: 2472 trace_rpc__prog_mismatch(task); 2473 error = -EPROTONOSUPPORT; 2474 goto out_err; 2475 case rpc_proc_unavail: 2476 trace_rpc__proc_unavail(task); 2477 error = -EOPNOTSUPP; 2478 goto out_err; 2479 case rpc_garbage_args: 2480 case rpc_system_err: 2481 trace_rpc__garbage_args(task); 2482 error = -EIO; 2483 break; 2484 default: 2485 goto out_unparsable; 2486 } 2487 2488 out_garbage: 2489 clnt->cl_stats->rpcgarbage++; 2490 if (task->tk_garb_retry) { 2491 task->tk_garb_retry--; 2492 task->tk_action = call_encode; 2493 return -EAGAIN; 2494 } 2495 out_err: 2496 rpc_exit(task, error); 2497 return error; 2498 2499 out_unparsable: 2500 trace_rpc__unparsable(task); 2501 error = -EIO; 2502 goto out_garbage; 2503 2504 out_verifier: 2505 trace_rpc_bad_verifier(task); 2506 goto out_garbage; 2507 2508 out_msg_denied: 2509 error = -EACCES; 2510 p = xdr_inline_decode(xdr, sizeof(*p)); 2511 if (!p) 2512 goto out_unparsable; 2513 switch (*p++) { 2514 case rpc_auth_error: 2515 break; 2516 case rpc_mismatch: 2517 trace_rpc__mismatch(task); 2518 error = -EPROTONOSUPPORT; 2519 goto out_err; 2520 default: 2521 goto out_unparsable; 2522 } 2523 2524 p = xdr_inline_decode(xdr, sizeof(*p)); 2525 if (!p) 2526 goto out_unparsable; 2527 switch (*p++) { 2528 case rpc_autherr_rejectedcred: 2529 case rpc_autherr_rejectedverf: 2530 case rpcsec_gsserr_credproblem: 2531 case rpcsec_gsserr_ctxproblem: 2532 if (!task->tk_cred_retry) 2533 break; 2534 task->tk_cred_retry--; 2535 trace_rpc__stale_creds(task); 2536 rpcauth_invalcred(task); 2537 /* Ensure we obtain a new XID! */ 2538 xprt_release(task); 2539 task->tk_action = call_reserve; 2540 return -EAGAIN; 2541 case rpc_autherr_badcred: 2542 case rpc_autherr_badverf: 2543 /* possibly garbled cred/verf? */ 2544 if (!task->tk_garb_retry) 2545 break; 2546 task->tk_garb_retry--; 2547 trace_rpc__bad_creds(task); 2548 task->tk_action = call_encode; 2549 return -EAGAIN; 2550 case rpc_autherr_tooweak: 2551 trace_rpc__auth_tooweak(task); 2552 pr_warn("RPC: server %s requires stronger authentication.\n", 2553 task->tk_xprt->servername); 2554 break; 2555 default: 2556 goto out_unparsable; 2557 } 2558 goto out_err; 2559 } 2560 2561 static void rpcproc_encode_null(struct rpc_rqst *rqstp, struct xdr_stream *xdr, 2562 const void *obj) 2563 { 2564 } 2565 2566 static int rpcproc_decode_null(struct rpc_rqst *rqstp, struct xdr_stream *xdr, 2567 void *obj) 2568 { 2569 return 0; 2570 } 2571 2572 static const struct rpc_procinfo rpcproc_null = { 2573 .p_encode = rpcproc_encode_null, 2574 .p_decode = rpcproc_decode_null, 2575 }; 2576 2577 static int rpc_ping(struct rpc_clnt *clnt) 2578 { 2579 struct rpc_message msg = { 2580 .rpc_proc = &rpcproc_null, 2581 }; 2582 int err; 2583 err = rpc_call_sync(clnt, &msg, RPC_TASK_SOFT | RPC_TASK_SOFTCONN | 2584 RPC_TASK_NULLCREDS); 2585 return err; 2586 } 2587 2588 static 2589 struct rpc_task *rpc_call_null_helper(struct rpc_clnt *clnt, 2590 struct rpc_xprt *xprt, struct rpc_cred *cred, int flags, 2591 const struct rpc_call_ops *ops, void *data) 2592 { 2593 struct rpc_message msg = { 2594 .rpc_proc = &rpcproc_null, 2595 }; 2596 struct rpc_task_setup task_setup_data = { 2597 .rpc_client = clnt, 2598 .rpc_xprt = xprt, 2599 .rpc_message = &msg, 2600 .rpc_op_cred = cred, 2601 .callback_ops = (ops != NULL) ? ops : &rpc_default_ops, 2602 .callback_data = data, 2603 .flags = flags | RPC_TASK_NULLCREDS, 2604 }; 2605 2606 return rpc_run_task(&task_setup_data); 2607 } 2608 2609 struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred, int flags) 2610 { 2611 return rpc_call_null_helper(clnt, NULL, cred, flags, NULL, NULL); 2612 } 2613 EXPORT_SYMBOL_GPL(rpc_call_null); 2614 2615 struct rpc_cb_add_xprt_calldata { 2616 struct rpc_xprt_switch *xps; 2617 struct rpc_xprt *xprt; 2618 }; 2619 2620 static void rpc_cb_add_xprt_done(struct rpc_task *task, void *calldata) 2621 { 2622 struct rpc_cb_add_xprt_calldata *data = calldata; 2623 2624 if (task->tk_status == 0) 2625 rpc_xprt_switch_add_xprt(data->xps, data->xprt); 2626 } 2627 2628 static void rpc_cb_add_xprt_release(void *calldata) 2629 { 2630 struct rpc_cb_add_xprt_calldata *data = calldata; 2631 2632 xprt_put(data->xprt); 2633 xprt_switch_put(data->xps); 2634 kfree(data); 2635 } 2636 2637 static const struct rpc_call_ops rpc_cb_add_xprt_call_ops = { 2638 .rpc_call_done = rpc_cb_add_xprt_done, 2639 .rpc_release = rpc_cb_add_xprt_release, 2640 }; 2641 2642 /** 2643 * rpc_clnt_test_and_add_xprt - Test and add a new transport to a rpc_clnt 2644 * @clnt: pointer to struct rpc_clnt 2645 * @xps: pointer to struct rpc_xprt_switch, 2646 * @xprt: pointer struct rpc_xprt 2647 * @dummy: unused 2648 */ 2649 int rpc_clnt_test_and_add_xprt(struct rpc_clnt *clnt, 2650 struct rpc_xprt_switch *xps, struct rpc_xprt *xprt, 2651 void *dummy) 2652 { 2653 struct rpc_cb_add_xprt_calldata *data; 2654 struct rpc_task *task; 2655 2656 data = kmalloc(sizeof(*data), GFP_NOFS); 2657 if (!data) 2658 return -ENOMEM; 2659 data->xps = xprt_switch_get(xps); 2660 data->xprt = xprt_get(xprt); 2661 2662 task = rpc_call_null_helper(clnt, xprt, NULL, 2663 RPC_TASK_SOFT|RPC_TASK_SOFTCONN|RPC_TASK_ASYNC|RPC_TASK_NULLCREDS, 2664 &rpc_cb_add_xprt_call_ops, data); 2665 if (IS_ERR(task)) 2666 return PTR_ERR(task); 2667 rpc_put_task(task); 2668 return 1; 2669 } 2670 EXPORT_SYMBOL_GPL(rpc_clnt_test_and_add_xprt); 2671 2672 /** 2673 * rpc_clnt_setup_test_and_add_xprt() 2674 * 2675 * This is an rpc_clnt_add_xprt setup() function which returns 1 so: 2676 * 1) caller of the test function must dereference the rpc_xprt_switch 2677 * and the rpc_xprt. 2678 * 2) test function must call rpc_xprt_switch_add_xprt, usually in 2679 * the rpc_call_done routine. 2680 * 2681 * Upon success (return of 1), the test function adds the new 2682 * transport to the rpc_clnt xprt switch 2683 * 2684 * @clnt: struct rpc_clnt to get the new transport 2685 * @xps: the rpc_xprt_switch to hold the new transport 2686 * @xprt: the rpc_xprt to test 2687 * @data: a struct rpc_add_xprt_test pointer that holds the test function 2688 * and test function call data 2689 */ 2690 int rpc_clnt_setup_test_and_add_xprt(struct rpc_clnt *clnt, 2691 struct rpc_xprt_switch *xps, 2692 struct rpc_xprt *xprt, 2693 void *data) 2694 { 2695 struct rpc_task *task; 2696 struct rpc_add_xprt_test *xtest = (struct rpc_add_xprt_test *)data; 2697 int status = -EADDRINUSE; 2698 2699 xprt = xprt_get(xprt); 2700 xprt_switch_get(xps); 2701 2702 if (rpc_xprt_switch_has_addr(xps, (struct sockaddr *)&xprt->addr)) 2703 goto out_err; 2704 2705 /* Test the connection */ 2706 task = rpc_call_null_helper(clnt, xprt, NULL, 2707 RPC_TASK_SOFT | RPC_TASK_SOFTCONN | RPC_TASK_NULLCREDS, 2708 NULL, NULL); 2709 if (IS_ERR(task)) { 2710 status = PTR_ERR(task); 2711 goto out_err; 2712 } 2713 status = task->tk_status; 2714 rpc_put_task(task); 2715 2716 if (status < 0) 2717 goto out_err; 2718 2719 /* rpc_xprt_switch and rpc_xprt are deferrenced by add_xprt_test() */ 2720 xtest->add_xprt_test(clnt, xprt, xtest->data); 2721 2722 xprt_put(xprt); 2723 xprt_switch_put(xps); 2724 2725 /* so that rpc_clnt_add_xprt does not call rpc_xprt_switch_add_xprt */ 2726 return 1; 2727 out_err: 2728 xprt_put(xprt); 2729 xprt_switch_put(xps); 2730 pr_info("RPC: rpc_clnt_test_xprt failed: %d addr %s not added\n", 2731 status, xprt->address_strings[RPC_DISPLAY_ADDR]); 2732 return status; 2733 } 2734 EXPORT_SYMBOL_GPL(rpc_clnt_setup_test_and_add_xprt); 2735 2736 /** 2737 * rpc_clnt_add_xprt - Add a new transport to a rpc_clnt 2738 * @clnt: pointer to struct rpc_clnt 2739 * @xprtargs: pointer to struct xprt_create 2740 * @setup: callback to test and/or set up the connection 2741 * @data: pointer to setup function data 2742 * 2743 * Creates a new transport using the parameters set in args and 2744 * adds it to clnt. 2745 * If ping is set, then test that connectivity succeeds before 2746 * adding the new transport. 2747 * 2748 */ 2749 int rpc_clnt_add_xprt(struct rpc_clnt *clnt, 2750 struct xprt_create *xprtargs, 2751 int (*setup)(struct rpc_clnt *, 2752 struct rpc_xprt_switch *, 2753 struct rpc_xprt *, 2754 void *), 2755 void *data) 2756 { 2757 struct rpc_xprt_switch *xps; 2758 struct rpc_xprt *xprt; 2759 unsigned long connect_timeout; 2760 unsigned long reconnect_timeout; 2761 unsigned char resvport; 2762 int ret = 0; 2763 2764 rcu_read_lock(); 2765 xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch)); 2766 xprt = xprt_iter_xprt(&clnt->cl_xpi); 2767 if (xps == NULL || xprt == NULL) { 2768 rcu_read_unlock(); 2769 return -EAGAIN; 2770 } 2771 resvport = xprt->resvport; 2772 connect_timeout = xprt->connect_timeout; 2773 reconnect_timeout = xprt->max_reconnect_timeout; 2774 rcu_read_unlock(); 2775 2776 xprt = xprt_create_transport(xprtargs); 2777 if (IS_ERR(xprt)) { 2778 ret = PTR_ERR(xprt); 2779 goto out_put_switch; 2780 } 2781 xprt->resvport = resvport; 2782 if (xprt->ops->set_connect_timeout != NULL) 2783 xprt->ops->set_connect_timeout(xprt, 2784 connect_timeout, 2785 reconnect_timeout); 2786 2787 rpc_xprt_switch_set_roundrobin(xps); 2788 if (setup) { 2789 ret = setup(clnt, xps, xprt, data); 2790 if (ret != 0) 2791 goto out_put_xprt; 2792 } 2793 rpc_xprt_switch_add_xprt(xps, xprt); 2794 out_put_xprt: 2795 xprt_put(xprt); 2796 out_put_switch: 2797 xprt_switch_put(xps); 2798 return ret; 2799 } 2800 EXPORT_SYMBOL_GPL(rpc_clnt_add_xprt); 2801 2802 struct connect_timeout_data { 2803 unsigned long connect_timeout; 2804 unsigned long reconnect_timeout; 2805 }; 2806 2807 static int 2808 rpc_xprt_set_connect_timeout(struct rpc_clnt *clnt, 2809 struct rpc_xprt *xprt, 2810 void *data) 2811 { 2812 struct connect_timeout_data *timeo = data; 2813 2814 if (xprt->ops->set_connect_timeout) 2815 xprt->ops->set_connect_timeout(xprt, 2816 timeo->connect_timeout, 2817 timeo->reconnect_timeout); 2818 return 0; 2819 } 2820 2821 void 2822 rpc_set_connect_timeout(struct rpc_clnt *clnt, 2823 unsigned long connect_timeout, 2824 unsigned long reconnect_timeout) 2825 { 2826 struct connect_timeout_data timeout = { 2827 .connect_timeout = connect_timeout, 2828 .reconnect_timeout = reconnect_timeout, 2829 }; 2830 rpc_clnt_iterate_for_each_xprt(clnt, 2831 rpc_xprt_set_connect_timeout, 2832 &timeout); 2833 } 2834 EXPORT_SYMBOL_GPL(rpc_set_connect_timeout); 2835 2836 void rpc_clnt_xprt_switch_put(struct rpc_clnt *clnt) 2837 { 2838 rcu_read_lock(); 2839 xprt_switch_put(rcu_dereference(clnt->cl_xpi.xpi_xpswitch)); 2840 rcu_read_unlock(); 2841 } 2842 EXPORT_SYMBOL_GPL(rpc_clnt_xprt_switch_put); 2843 2844 void rpc_clnt_xprt_switch_add_xprt(struct rpc_clnt *clnt, struct rpc_xprt *xprt) 2845 { 2846 rcu_read_lock(); 2847 rpc_xprt_switch_add_xprt(rcu_dereference(clnt->cl_xpi.xpi_xpswitch), 2848 xprt); 2849 rcu_read_unlock(); 2850 } 2851 EXPORT_SYMBOL_GPL(rpc_clnt_xprt_switch_add_xprt); 2852 2853 bool rpc_clnt_xprt_switch_has_addr(struct rpc_clnt *clnt, 2854 const struct sockaddr *sap) 2855 { 2856 struct rpc_xprt_switch *xps; 2857 bool ret; 2858 2859 rcu_read_lock(); 2860 xps = rcu_dereference(clnt->cl_xpi.xpi_xpswitch); 2861 ret = rpc_xprt_switch_has_addr(xps, sap); 2862 rcu_read_unlock(); 2863 return ret; 2864 } 2865 EXPORT_SYMBOL_GPL(rpc_clnt_xprt_switch_has_addr); 2866 2867 #if IS_ENABLED(CONFIG_SUNRPC_DEBUG) 2868 static void rpc_show_header(void) 2869 { 2870 printk(KERN_INFO "-pid- flgs status -client- --rqstp- " 2871 "-timeout ---ops--\n"); 2872 } 2873 2874 static void rpc_show_task(const struct rpc_clnt *clnt, 2875 const struct rpc_task *task) 2876 { 2877 const char *rpc_waitq = "none"; 2878 2879 if (RPC_IS_QUEUED(task)) 2880 rpc_waitq = rpc_qname(task->tk_waitqueue); 2881 2882 printk(KERN_INFO "%5u %04x %6d %8p %8p %8ld %8p %sv%u %s a:%ps q:%s\n", 2883 task->tk_pid, task->tk_flags, task->tk_status, 2884 clnt, task->tk_rqstp, task->tk_timeout, task->tk_ops, 2885 clnt->cl_program->name, clnt->cl_vers, rpc_proc_name(task), 2886 task->tk_action, rpc_waitq); 2887 } 2888 2889 void rpc_show_tasks(struct net *net) 2890 { 2891 struct rpc_clnt *clnt; 2892 struct rpc_task *task; 2893 int header = 0; 2894 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id); 2895 2896 spin_lock(&sn->rpc_client_lock); 2897 list_for_each_entry(clnt, &sn->all_clients, cl_clients) { 2898 spin_lock(&clnt->cl_lock); 2899 list_for_each_entry(task, &clnt->cl_tasks, tk_task) { 2900 if (!header) { 2901 rpc_show_header(); 2902 header++; 2903 } 2904 rpc_show_task(clnt, task); 2905 } 2906 spin_unlock(&clnt->cl_lock); 2907 } 2908 spin_unlock(&sn->rpc_client_lock); 2909 } 2910 #endif 2911 2912 #if IS_ENABLED(CONFIG_SUNRPC_SWAP) 2913 static int 2914 rpc_clnt_swap_activate_callback(struct rpc_clnt *clnt, 2915 struct rpc_xprt *xprt, 2916 void *dummy) 2917 { 2918 return xprt_enable_swap(xprt); 2919 } 2920 2921 int 2922 rpc_clnt_swap_activate(struct rpc_clnt *clnt) 2923 { 2924 if (atomic_inc_return(&clnt->cl_swapper) == 1) 2925 return rpc_clnt_iterate_for_each_xprt(clnt, 2926 rpc_clnt_swap_activate_callback, NULL); 2927 return 0; 2928 } 2929 EXPORT_SYMBOL_GPL(rpc_clnt_swap_activate); 2930 2931 static int 2932 rpc_clnt_swap_deactivate_callback(struct rpc_clnt *clnt, 2933 struct rpc_xprt *xprt, 2934 void *dummy) 2935 { 2936 xprt_disable_swap(xprt); 2937 return 0; 2938 } 2939 2940 void 2941 rpc_clnt_swap_deactivate(struct rpc_clnt *clnt) 2942 { 2943 if (atomic_dec_if_positive(&clnt->cl_swapper) == 0) 2944 rpc_clnt_iterate_for_each_xprt(clnt, 2945 rpc_clnt_swap_deactivate_callback, NULL); 2946 } 2947 EXPORT_SYMBOL_GPL(rpc_clnt_swap_deactivate); 2948 #endif /* CONFIG_SUNRPC_SWAP */ 2949