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