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