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