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