1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved. 4 * Written by David Howells (dhowells@redhat.com) 5 */ 6 #include <linux/module.h> 7 #include <linux/nfs_fs.h> 8 #include <linux/nfs_mount.h> 9 #include <linux/sunrpc/addr.h> 10 #include <linux/sunrpc/auth.h> 11 #include <linux/sunrpc/xprt.h> 12 #include <linux/sunrpc/bc_xprt.h> 13 #include <linux/sunrpc/rpc_pipe_fs.h> 14 #include "internal.h" 15 #include "callback.h" 16 #include "delegation.h" 17 #include "nfs4session.h" 18 #include "nfs4idmap.h" 19 #include "pnfs.h" 20 #include "netns.h" 21 #include "sysfs.h" 22 23 #define NFSDBG_FACILITY NFSDBG_CLIENT 24 25 /* 26 * Get a unique NFSv4.0 callback identifier which will be used 27 * by the V4.0 callback service to lookup the nfs_client struct 28 */ 29 static int nfs_get_cb_ident_idr(struct nfs_client *clp, int minorversion) 30 { 31 int ret = 0; 32 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); 33 34 if (clp->rpc_ops->version != 4 || minorversion != 0) 35 return ret; 36 idr_preload(GFP_KERNEL); 37 spin_lock(&nn->nfs_client_lock); 38 ret = idr_alloc(&nn->cb_ident_idr, clp, 1, 0, GFP_NOWAIT); 39 if (ret >= 0) 40 clp->cl_cb_ident = ret; 41 spin_unlock(&nn->nfs_client_lock); 42 idr_preload_end(); 43 return ret < 0 ? ret : 0; 44 } 45 46 #ifdef CONFIG_NFS_V4_1 47 /* 48 * Per auth flavor data server rpc clients 49 */ 50 struct nfs4_ds_server { 51 struct list_head list; /* ds_clp->cl_ds_clients */ 52 struct rpc_clnt *rpc_clnt; 53 }; 54 55 /** 56 * nfs4_find_ds_client - Common lookup case for DS I/O 57 * @ds_clp: pointer to the DS's nfs_client 58 * @flavor: rpc auth flavour to match 59 */ 60 static struct nfs4_ds_server * 61 nfs4_find_ds_client(struct nfs_client *ds_clp, rpc_authflavor_t flavor) 62 { 63 struct nfs4_ds_server *dss; 64 65 rcu_read_lock(); 66 list_for_each_entry_rcu(dss, &ds_clp->cl_ds_clients, list) { 67 if (dss->rpc_clnt->cl_auth->au_flavor != flavor) 68 continue; 69 goto out; 70 } 71 dss = NULL; 72 out: 73 rcu_read_unlock(); 74 return dss; 75 } 76 77 static struct nfs4_ds_server * 78 nfs4_add_ds_client(struct nfs_client *ds_clp, rpc_authflavor_t flavor, 79 struct nfs4_ds_server *new) 80 { 81 struct nfs4_ds_server *dss; 82 83 spin_lock(&ds_clp->cl_lock); 84 list_for_each_entry(dss, &ds_clp->cl_ds_clients, list) { 85 if (dss->rpc_clnt->cl_auth->au_flavor != flavor) 86 continue; 87 goto out; 88 } 89 if (new) 90 list_add_rcu(&new->list, &ds_clp->cl_ds_clients); 91 dss = new; 92 out: 93 spin_unlock(&ds_clp->cl_lock); /* need some lock to protect list */ 94 return dss; 95 } 96 97 static struct nfs4_ds_server * 98 nfs4_alloc_ds_server(struct nfs_client *ds_clp, rpc_authflavor_t flavor) 99 { 100 struct nfs4_ds_server *dss; 101 102 dss = kmalloc(sizeof(*dss), GFP_NOFS); 103 if (dss == NULL) 104 return ERR_PTR(-ENOMEM); 105 106 dss->rpc_clnt = rpc_clone_client_set_auth(ds_clp->cl_rpcclient, flavor); 107 if (IS_ERR(dss->rpc_clnt)) { 108 int err = PTR_ERR(dss->rpc_clnt); 109 kfree (dss); 110 return ERR_PTR(err); 111 } 112 INIT_LIST_HEAD(&dss->list); 113 114 return dss; 115 } 116 117 static void 118 nfs4_free_ds_server(struct nfs4_ds_server *dss) 119 { 120 rpc_release_client(dss->rpc_clnt); 121 kfree(dss); 122 } 123 124 /** 125 * nfs4_find_or_create_ds_client - Find or create a DS rpc client 126 * @ds_clp: pointer to the DS's nfs_client 127 * @inode: pointer to the inode 128 * 129 * Find or create a DS rpc client with th MDS server rpc client auth flavor 130 * in the nfs_client cl_ds_clients list. 131 */ 132 struct rpc_clnt * 133 nfs4_find_or_create_ds_client(struct nfs_client *ds_clp, struct inode *inode) 134 { 135 struct nfs4_ds_server *dss, *new; 136 rpc_authflavor_t flavor = NFS_SERVER(inode)->client->cl_auth->au_flavor; 137 138 dss = nfs4_find_ds_client(ds_clp, flavor); 139 if (dss != NULL) 140 goto out; 141 new = nfs4_alloc_ds_server(ds_clp, flavor); 142 if (IS_ERR(new)) 143 return ERR_CAST(new); 144 dss = nfs4_add_ds_client(ds_clp, flavor, new); 145 if (dss != new) 146 nfs4_free_ds_server(new); 147 out: 148 return dss->rpc_clnt; 149 } 150 EXPORT_SYMBOL_GPL(nfs4_find_or_create_ds_client); 151 152 static void 153 nfs4_shutdown_ds_clients(struct nfs_client *clp) 154 { 155 struct nfs4_ds_server *dss; 156 157 while (!list_empty(&clp->cl_ds_clients)) { 158 dss = list_entry(clp->cl_ds_clients.next, 159 struct nfs4_ds_server, list); 160 list_del(&dss->list); 161 rpc_shutdown_client(dss->rpc_clnt); 162 kfree (dss); 163 } 164 } 165 166 static void 167 nfs4_cleanup_callback(struct nfs_client *clp) 168 { 169 struct nfs4_copy_state *cp_state; 170 171 while (!list_empty(&clp->pending_cb_stateids)) { 172 cp_state = list_entry(clp->pending_cb_stateids.next, 173 struct nfs4_copy_state, copies); 174 list_del(&cp_state->copies); 175 kfree(cp_state); 176 } 177 } 178 179 void nfs41_shutdown_client(struct nfs_client *clp) 180 { 181 if (nfs4_has_session(clp)) { 182 nfs4_cleanup_callback(clp); 183 nfs4_shutdown_ds_clients(clp); 184 nfs4_destroy_session(clp->cl_session); 185 nfs4_destroy_clientid(clp); 186 } 187 188 } 189 #endif /* CONFIG_NFS_V4_1 */ 190 191 void nfs40_shutdown_client(struct nfs_client *clp) 192 { 193 if (clp->cl_slot_tbl) { 194 nfs4_shutdown_slot_table(clp->cl_slot_tbl); 195 kfree(clp->cl_slot_tbl); 196 } 197 } 198 199 struct nfs_client *nfs4_alloc_client(const struct nfs_client_initdata *cl_init) 200 { 201 char buf[INET6_ADDRSTRLEN + 1]; 202 const char *ip_addr = cl_init->ip_addr; 203 struct nfs_client *clp = nfs_alloc_client(cl_init); 204 int err; 205 206 if (IS_ERR(clp)) 207 return clp; 208 209 err = nfs_get_cb_ident_idr(clp, cl_init->minorversion); 210 if (err) 211 goto error; 212 213 if (cl_init->minorversion > NFS4_MAX_MINOR_VERSION) { 214 err = -EINVAL; 215 goto error; 216 } 217 218 spin_lock_init(&clp->cl_lock); 219 INIT_DELAYED_WORK(&clp->cl_renewd, nfs4_renew_state); 220 INIT_LIST_HEAD(&clp->cl_ds_clients); 221 rpc_init_wait_queue(&clp->cl_rpcwaitq, "NFS client"); 222 clp->cl_state = 1 << NFS4CLNT_LEASE_EXPIRED; 223 clp->cl_mvops = nfs_v4_minor_ops[cl_init->minorversion]; 224 clp->cl_mig_gen = 1; 225 #if IS_ENABLED(CONFIG_NFS_V4_1) 226 init_waitqueue_head(&clp->cl_lock_waitq); 227 #endif 228 INIT_LIST_HEAD(&clp->pending_cb_stateids); 229 230 if (cl_init->minorversion != 0) 231 __set_bit(NFS_CS_INFINITE_SLOTS, &clp->cl_flags); 232 __set_bit(NFS_CS_DISCRTRY, &clp->cl_flags); 233 __set_bit(NFS_CS_NO_RETRANS_TIMEOUT, &clp->cl_flags); 234 235 if (test_bit(NFS_CS_DS, &cl_init->init_flags)) 236 __set_bit(NFS_CS_DS, &clp->cl_flags); 237 /* 238 * Set up the connection to the server before we add add to the 239 * global list. 240 */ 241 err = nfs_create_rpc_client(clp, cl_init, RPC_AUTH_GSS_KRB5I); 242 if (err == -EINVAL) 243 err = nfs_create_rpc_client(clp, cl_init, RPC_AUTH_UNIX); 244 if (err < 0) 245 goto error; 246 247 /* If no clientaddr= option was specified, find a usable cb address */ 248 if (ip_addr == NULL) { 249 struct sockaddr_storage cb_addr; 250 struct sockaddr *sap = (struct sockaddr *)&cb_addr; 251 252 err = rpc_localaddr(clp->cl_rpcclient, sap, sizeof(cb_addr)); 253 if (err < 0) 254 goto error; 255 err = rpc_ntop(sap, buf, sizeof(buf)); 256 if (err < 0) 257 goto error; 258 ip_addr = (const char *)buf; 259 } 260 strscpy(clp->cl_ipaddr, ip_addr, sizeof(clp->cl_ipaddr)); 261 262 err = nfs_idmap_new(clp); 263 if (err < 0) { 264 dprintk("%s: failed to create idmapper. Error = %d\n", 265 __func__, err); 266 goto error; 267 } 268 __set_bit(NFS_CS_IDMAP, &clp->cl_res_state); 269 return clp; 270 271 error: 272 nfs_free_client(clp); 273 return ERR_PTR(err); 274 } 275 276 /* 277 * Destroy the NFS4 callback service 278 */ 279 static void nfs4_destroy_callback(struct nfs_client *clp) 280 { 281 if (__test_and_clear_bit(NFS_CS_CALLBACK, &clp->cl_res_state)) 282 nfs_callback_down(clp->cl_mvops->minor_version, clp->cl_net); 283 } 284 285 static void nfs4_shutdown_client(struct nfs_client *clp) 286 { 287 if (__test_and_clear_bit(NFS_CS_RENEWD, &clp->cl_res_state)) 288 nfs4_kill_renewd(clp); 289 clp->cl_mvops->shutdown_client(clp); 290 nfs4_destroy_callback(clp); 291 if (__test_and_clear_bit(NFS_CS_IDMAP, &clp->cl_res_state)) 292 nfs_idmap_delete(clp); 293 294 rpc_destroy_wait_queue(&clp->cl_rpcwaitq); 295 kfree(clp->cl_serverowner); 296 kfree(clp->cl_serverscope); 297 kfree(clp->cl_implid); 298 kfree(clp->cl_owner_id); 299 } 300 301 void nfs4_free_client(struct nfs_client *clp) 302 { 303 nfs4_shutdown_client(clp); 304 nfs_free_client(clp); 305 } 306 307 /* 308 * Initialize the NFS4 callback service 309 */ 310 static int nfs4_init_callback(struct nfs_client *clp) 311 { 312 struct rpc_xprt *xprt; 313 int error; 314 315 xprt = rcu_dereference_raw(clp->cl_rpcclient->cl_xprt); 316 317 if (nfs4_has_session(clp)) { 318 error = xprt_setup_backchannel(xprt, NFS41_BC_MIN_CALLBACKS); 319 if (error < 0) 320 return error; 321 } 322 323 error = nfs_callback_up(clp->cl_mvops->minor_version, xprt); 324 if (error < 0) { 325 dprintk("%s: failed to start callback. Error = %d\n", 326 __func__, error); 327 return error; 328 } 329 __set_bit(NFS_CS_CALLBACK, &clp->cl_res_state); 330 331 return 0; 332 } 333 334 /** 335 * nfs40_init_client - nfs_client initialization tasks for NFSv4.0 336 * @clp: nfs_client to initialize 337 * 338 * Returns zero on success, or a negative errno if some error occurred. 339 */ 340 int nfs40_init_client(struct nfs_client *clp) 341 { 342 struct nfs4_slot_table *tbl; 343 int ret; 344 345 tbl = kzalloc(sizeof(*tbl), GFP_NOFS); 346 if (tbl == NULL) 347 return -ENOMEM; 348 349 ret = nfs4_setup_slot_table(tbl, NFS4_MAX_SLOT_TABLE, 350 "NFSv4.0 transport Slot table"); 351 if (ret) { 352 nfs4_shutdown_slot_table(tbl); 353 kfree(tbl); 354 return ret; 355 } 356 357 clp->cl_slot_tbl = tbl; 358 return 0; 359 } 360 361 #if defined(CONFIG_NFS_V4_1) 362 363 /** 364 * nfs41_init_client - nfs_client initialization tasks for NFSv4.1+ 365 * @clp: nfs_client to initialize 366 * 367 * Returns zero on success, or a negative errno if some error occurred. 368 */ 369 int nfs41_init_client(struct nfs_client *clp) 370 { 371 struct nfs4_session *session = NULL; 372 373 /* 374 * Create the session and mark it expired. 375 * When a SEQUENCE operation encounters the expired session 376 * it will do session recovery to initialize it. 377 */ 378 session = nfs4_alloc_session(clp); 379 if (!session) 380 return -ENOMEM; 381 382 clp->cl_session = session; 383 384 /* 385 * The create session reply races with the server back 386 * channel probe. Mark the client NFS_CS_SESSION_INITING 387 * so that the client back channel can find the 388 * nfs_client struct 389 */ 390 nfs_mark_client_ready(clp, NFS_CS_SESSION_INITING); 391 return 0; 392 } 393 394 #endif /* CONFIG_NFS_V4_1 */ 395 396 /* 397 * Initialize the minor version specific parts of an NFS4 client record 398 */ 399 static int nfs4_init_client_minor_version(struct nfs_client *clp) 400 { 401 int ret; 402 403 ret = clp->cl_mvops->init_client(clp); 404 if (ret) 405 return ret; 406 return nfs4_init_callback(clp); 407 } 408 409 static void nfs4_add_trunk(struct nfs_client *clp, struct nfs_client *old) 410 { 411 struct sockaddr_storage clp_addr, old_addr; 412 struct sockaddr *clp_sap = (struct sockaddr *)&clp_addr; 413 struct sockaddr *old_sap = (struct sockaddr *)&old_addr; 414 size_t clp_salen; 415 struct xprt_create xprt_args = { 416 .ident = old->cl_proto, 417 .net = old->cl_net, 418 .servername = old->cl_hostname, 419 }; 420 421 if (clp->cl_proto != old->cl_proto) 422 return; 423 clp_salen = rpc_peeraddr(clp->cl_rpcclient, clp_sap, sizeof(clp_addr)); 424 rpc_peeraddr(old->cl_rpcclient, old_sap, sizeof(old_addr)); 425 426 if (clp_addr.ss_family != old_addr.ss_family) 427 return; 428 429 xprt_args.dstaddr = clp_sap; 430 xprt_args.addrlen = clp_salen; 431 432 rpc_clnt_add_xprt(old->cl_rpcclient, &xprt_args, 433 rpc_clnt_test_and_add_xprt, NULL); 434 } 435 436 /** 437 * nfs4_init_client - Initialise an NFS4 client record 438 * 439 * @clp: nfs_client to initialise 440 * @cl_init: pointer to nfs_client_initdata 441 * 442 * Returns pointer to an NFS client, or an ERR_PTR value. 443 */ 444 struct nfs_client *nfs4_init_client(struct nfs_client *clp, 445 const struct nfs_client_initdata *cl_init) 446 { 447 struct nfs_client *old; 448 int error; 449 450 if (clp->cl_cons_state == NFS_CS_READY) 451 /* the client is initialised already */ 452 return clp; 453 454 error = nfs4_init_client_minor_version(clp); 455 if (error < 0) 456 goto error; 457 458 error = nfs4_discover_server_trunking(clp, &old); 459 if (error < 0) 460 goto error; 461 462 if (clp != old) { 463 clp->cl_preserve_clid = true; 464 /* 465 * Mark the client as having failed initialization so other 466 * processes walking the nfs_client_list in nfs_match_client() 467 * won't try to use it. 468 */ 469 nfs_mark_client_ready(clp, -EPERM); 470 if (old->cl_mvops->session_trunk) 471 nfs4_add_trunk(clp, old); 472 } 473 clear_bit(NFS_CS_TSM_POSSIBLE, &clp->cl_flags); 474 nfs_put_client(clp); 475 return old; 476 477 error: 478 nfs_mark_client_ready(clp, error); 479 nfs_put_client(clp); 480 return ERR_PTR(error); 481 } 482 483 /* 484 * SETCLIENTID just did a callback update with the callback ident in 485 * "drop," but server trunking discovery claims "drop" and "keep" are 486 * actually the same server. Swap the callback IDs so that "keep" 487 * will continue to use the callback ident the server now knows about, 488 * and so that "keep"'s original callback ident is destroyed when 489 * "drop" is freed. 490 */ 491 static void nfs4_swap_callback_idents(struct nfs_client *keep, 492 struct nfs_client *drop) 493 { 494 struct nfs_net *nn = net_generic(keep->cl_net, nfs_net_id); 495 unsigned int save = keep->cl_cb_ident; 496 497 if (keep->cl_cb_ident == drop->cl_cb_ident) 498 return; 499 500 dprintk("%s: keeping callback ident %u and dropping ident %u\n", 501 __func__, keep->cl_cb_ident, drop->cl_cb_ident); 502 503 spin_lock(&nn->nfs_client_lock); 504 505 idr_replace(&nn->cb_ident_idr, keep, drop->cl_cb_ident); 506 keep->cl_cb_ident = drop->cl_cb_ident; 507 508 idr_replace(&nn->cb_ident_idr, drop, save); 509 drop->cl_cb_ident = save; 510 511 spin_unlock(&nn->nfs_client_lock); 512 } 513 514 static bool nfs4_match_client_owner_id(const struct nfs_client *clp1, 515 const struct nfs_client *clp2) 516 { 517 if (clp1->cl_owner_id == NULL || clp2->cl_owner_id == NULL) 518 return true; 519 return strcmp(clp1->cl_owner_id, clp2->cl_owner_id) == 0; 520 } 521 522 static bool nfs4_same_verifier(nfs4_verifier *v1, nfs4_verifier *v2) 523 { 524 return memcmp(v1->data, v2->data, sizeof(v1->data)) == 0; 525 } 526 527 static int nfs4_match_client(struct nfs_client *pos, struct nfs_client *new, 528 struct nfs_client **prev, struct nfs_net *nn) 529 { 530 int status; 531 532 if (pos->rpc_ops != new->rpc_ops) 533 return 1; 534 535 if (pos->cl_minorversion != new->cl_minorversion) 536 return 1; 537 538 /* If "pos" isn't marked ready, we can't trust the 539 * remaining fields in "pos", especially the client 540 * ID and serverowner fields. Wait for CREATE_SESSION 541 * to finish. */ 542 if (pos->cl_cons_state > NFS_CS_READY) { 543 refcount_inc(&pos->cl_count); 544 spin_unlock(&nn->nfs_client_lock); 545 546 nfs_put_client(*prev); 547 *prev = pos; 548 549 status = nfs_wait_client_init_complete(pos); 550 spin_lock(&nn->nfs_client_lock); 551 552 if (status < 0) 553 return status; 554 } 555 556 if (pos->cl_cons_state != NFS_CS_READY) 557 return 1; 558 559 if (pos->cl_clientid != new->cl_clientid) 560 return 1; 561 562 /* NFSv4.1 always uses the uniform string, however someone 563 * might switch the uniquifier string on us. 564 */ 565 if (!nfs4_match_client_owner_id(pos, new)) 566 return 1; 567 568 return 0; 569 } 570 571 /** 572 * nfs40_walk_client_list - Find server that recognizes a client ID 573 * 574 * @new: nfs_client with client ID to test 575 * @result: OUT: found nfs_client, or new 576 * @cred: credential to use for trunking test 577 * 578 * Returns zero, a negative errno, or a negative NFS4ERR status. 579 * If zero is returned, an nfs_client pointer is planted in "result." 580 * 581 * NB: nfs40_walk_client_list() relies on the new nfs_client being 582 * the last nfs_client on the list. 583 */ 584 int nfs40_walk_client_list(struct nfs_client *new, 585 struct nfs_client **result, 586 const struct cred *cred) 587 { 588 struct nfs_net *nn = net_generic(new->cl_net, nfs_net_id); 589 struct nfs_client *pos, *prev = NULL; 590 struct nfs4_setclientid_res clid = { 591 .clientid = new->cl_clientid, 592 .confirm = new->cl_confirm, 593 }; 594 int status = -NFS4ERR_STALE_CLIENTID; 595 596 spin_lock(&nn->nfs_client_lock); 597 list_for_each_entry(pos, &nn->nfs_client_list, cl_share_link) { 598 599 if (pos == new) 600 goto found; 601 602 status = nfs4_match_client(pos, new, &prev, nn); 603 if (status < 0) 604 goto out_unlock; 605 if (status != 0) 606 continue; 607 /* 608 * We just sent a new SETCLIENTID, which should have 609 * caused the server to return a new cl_confirm. So if 610 * cl_confirm is the same, then this is a different 611 * server that just returned the same cl_confirm by 612 * coincidence: 613 */ 614 if ((new != pos) && nfs4_same_verifier(&pos->cl_confirm, 615 &new->cl_confirm)) 616 continue; 617 /* 618 * But if the cl_confirm's are different, then the only 619 * way that a SETCLIENTID_CONFIRM to pos can succeed is 620 * if new and pos point to the same server: 621 */ 622 found: 623 refcount_inc(&pos->cl_count); 624 spin_unlock(&nn->nfs_client_lock); 625 626 nfs_put_client(prev); 627 prev = pos; 628 629 status = nfs4_proc_setclientid_confirm(pos, &clid, cred); 630 switch (status) { 631 case -NFS4ERR_STALE_CLIENTID: 632 break; 633 case 0: 634 nfs4_swap_callback_idents(pos, new); 635 pos->cl_confirm = new->cl_confirm; 636 nfs_mark_client_ready(pos, NFS_CS_READY); 637 638 prev = NULL; 639 *result = pos; 640 goto out; 641 case -ERESTARTSYS: 642 case -ETIMEDOUT: 643 /* The callback path may have been inadvertently 644 * changed. Schedule recovery! 645 */ 646 nfs4_schedule_path_down_recovery(pos); 647 goto out; 648 default: 649 goto out; 650 } 651 652 spin_lock(&nn->nfs_client_lock); 653 } 654 out_unlock: 655 spin_unlock(&nn->nfs_client_lock); 656 657 /* No match found. The server lost our clientid */ 658 out: 659 nfs_put_client(prev); 660 return status; 661 } 662 663 #ifdef CONFIG_NFS_V4_1 664 /* 665 * Returns true if the server major ids match 666 */ 667 bool 668 nfs4_check_serverowner_major_id(struct nfs41_server_owner *o1, 669 struct nfs41_server_owner *o2) 670 { 671 if (o1->major_id_sz != o2->major_id_sz) 672 return false; 673 return memcmp(o1->major_id, o2->major_id, o1->major_id_sz) == 0; 674 } 675 676 /* 677 * Returns true if the server scopes match 678 */ 679 static bool 680 nfs4_check_server_scope(struct nfs41_server_scope *s1, 681 struct nfs41_server_scope *s2) 682 { 683 if (s1->server_scope_sz != s2->server_scope_sz) 684 return false; 685 return memcmp(s1->server_scope, s2->server_scope, 686 s1->server_scope_sz) == 0; 687 } 688 689 /** 690 * nfs4_detect_session_trunking - Checks for session trunking. 691 * @clp: original mount nfs_client 692 * @res: result structure from an exchange_id using the original mount 693 * nfs_client with a new multi_addr transport 694 * @xprt: pointer to the transport to add. 695 * 696 * Called after a successful EXCHANGE_ID on a multi-addr connection. 697 * Upon success, add the transport. 698 * 699 * Returns zero on success, otherwise -EINVAL 700 * 701 * Note: since the exchange_id for the new multi_addr transport uses the 702 * same nfs_client from the original mount, the cl_owner_id is reused, 703 * so eir_clientowner is the same. 704 */ 705 int nfs4_detect_session_trunking(struct nfs_client *clp, 706 struct nfs41_exchange_id_res *res, 707 struct rpc_xprt *xprt) 708 { 709 /* Check eir_clientid */ 710 if (clp->cl_clientid != res->clientid) 711 goto out_err; 712 713 /* Check eir_server_owner so_major_id */ 714 if (!nfs4_check_serverowner_major_id(clp->cl_serverowner, 715 res->server_owner)) 716 goto out_err; 717 718 /* Check eir_server_owner so_minor_id */ 719 if (clp->cl_serverowner->minor_id != res->server_owner->minor_id) 720 goto out_err; 721 722 /* Check eir_server_scope */ 723 if (!nfs4_check_server_scope(clp->cl_serverscope, res->server_scope)) 724 goto out_err; 725 726 pr_info("NFS: %s: Session trunking succeeded for %s\n", 727 clp->cl_hostname, 728 xprt->address_strings[RPC_DISPLAY_ADDR]); 729 730 return 0; 731 out_err: 732 pr_info("NFS: %s: Session trunking failed for %s\n", clp->cl_hostname, 733 xprt->address_strings[RPC_DISPLAY_ADDR]); 734 735 return -EINVAL; 736 } 737 738 /** 739 * nfs41_walk_client_list - Find nfs_client that matches a client/server owner 740 * 741 * @new: nfs_client with client ID to test 742 * @result: OUT: found nfs_client, or new 743 * @cred: credential to use for trunking test 744 * 745 * Returns zero, a negative errno, or a negative NFS4ERR status. 746 * If zero is returned, an nfs_client pointer is planted in "result." 747 * 748 * NB: nfs41_walk_client_list() relies on the new nfs_client being 749 * the last nfs_client on the list. 750 */ 751 int nfs41_walk_client_list(struct nfs_client *new, 752 struct nfs_client **result, 753 const struct cred *cred) 754 { 755 struct nfs_net *nn = net_generic(new->cl_net, nfs_net_id); 756 struct nfs_client *pos, *prev = NULL; 757 int status = -NFS4ERR_STALE_CLIENTID; 758 759 spin_lock(&nn->nfs_client_lock); 760 list_for_each_entry(pos, &nn->nfs_client_list, cl_share_link) { 761 762 if (pos == new) 763 goto found; 764 765 status = nfs4_match_client(pos, new, &prev, nn); 766 if (status < 0) 767 goto out; 768 if (status != 0) 769 continue; 770 771 /* 772 * Note that session trunking is just a special subcase of 773 * client id trunking. In either case, we want to fall back 774 * to using the existing nfs_client. 775 */ 776 if (!nfs4_check_serverowner_major_id(pos->cl_serverowner, 777 new->cl_serverowner)) 778 continue; 779 780 found: 781 refcount_inc(&pos->cl_count); 782 *result = pos; 783 status = 0; 784 break; 785 } 786 787 out: 788 spin_unlock(&nn->nfs_client_lock); 789 nfs_put_client(prev); 790 return status; 791 } 792 #endif /* CONFIG_NFS_V4_1 */ 793 794 static void nfs4_destroy_server(struct nfs_server *server) 795 { 796 LIST_HEAD(freeme); 797 798 nfs_server_return_all_delegations(server); 799 unset_pnfs_layoutdriver(server); 800 nfs4_purge_state_owners(server, &freeme); 801 nfs4_free_state_owners(&freeme); 802 } 803 804 /* 805 * NFSv4.0 callback thread helper 806 * 807 * Find a client by callback identifier 808 */ 809 struct nfs_client * 810 nfs4_find_client_ident(struct net *net, int cb_ident) 811 { 812 struct nfs_client *clp; 813 struct nfs_net *nn = net_generic(net, nfs_net_id); 814 815 spin_lock(&nn->nfs_client_lock); 816 clp = idr_find(&nn->cb_ident_idr, cb_ident); 817 if (clp) 818 refcount_inc(&clp->cl_count); 819 spin_unlock(&nn->nfs_client_lock); 820 return clp; 821 } 822 823 #if defined(CONFIG_NFS_V4_1) 824 /* Common match routine for v4.0 and v4.1 callback services */ 825 static bool nfs4_cb_match_client(const struct sockaddr *addr, 826 struct nfs_client *clp, u32 minorversion) 827 { 828 struct sockaddr *clap = (struct sockaddr *)&clp->cl_addr; 829 830 /* Don't match clients that failed to initialise */ 831 if (!(clp->cl_cons_state == NFS_CS_READY || 832 clp->cl_cons_state == NFS_CS_SESSION_INITING)) 833 return false; 834 835 smp_rmb(); 836 837 /* Match the version and minorversion */ 838 if (clp->rpc_ops->version != 4 || 839 clp->cl_minorversion != minorversion) 840 return false; 841 842 /* Match only the IP address, not the port number */ 843 return rpc_cmp_addr(addr, clap); 844 } 845 846 /* 847 * NFSv4.1 callback thread helper 848 * For CB_COMPOUND calls, find a client by IP address, protocol version, 849 * minorversion, and sessionID 850 * 851 * Returns NULL if no such client 852 */ 853 struct nfs_client * 854 nfs4_find_client_sessionid(struct net *net, const struct sockaddr *addr, 855 struct nfs4_sessionid *sid, u32 minorversion) 856 { 857 struct nfs_client *clp; 858 struct nfs_net *nn = net_generic(net, nfs_net_id); 859 860 spin_lock(&nn->nfs_client_lock); 861 list_for_each_entry(clp, &nn->nfs_client_list, cl_share_link) { 862 if (!nfs4_cb_match_client(addr, clp, minorversion)) 863 continue; 864 865 if (!nfs4_has_session(clp)) 866 continue; 867 868 /* Match sessionid*/ 869 if (memcmp(clp->cl_session->sess_id.data, 870 sid->data, NFS4_MAX_SESSIONID_LEN) != 0) 871 continue; 872 873 refcount_inc(&clp->cl_count); 874 spin_unlock(&nn->nfs_client_lock); 875 return clp; 876 } 877 spin_unlock(&nn->nfs_client_lock); 878 return NULL; 879 } 880 881 #else /* CONFIG_NFS_V4_1 */ 882 883 struct nfs_client * 884 nfs4_find_client_sessionid(struct net *net, const struct sockaddr *addr, 885 struct nfs4_sessionid *sid, u32 minorversion) 886 { 887 return NULL; 888 } 889 #endif /* CONFIG_NFS_V4_1 */ 890 891 /* 892 * Set up an NFS4 client 893 */ 894 static int nfs4_set_client(struct nfs_server *server, 895 const char *hostname, 896 const struct sockaddr_storage *addr, 897 const size_t addrlen, 898 const char *ip_addr, 899 int proto, const struct rpc_timeout *timeparms, 900 u32 minorversion, unsigned int nconnect, 901 unsigned int max_connect, 902 struct net *net, 903 struct xprtsec_parms *xprtsec) 904 { 905 struct nfs_client_initdata cl_init = { 906 .hostname = hostname, 907 .addr = addr, 908 .addrlen = addrlen, 909 .ip_addr = ip_addr, 910 .nfs_mod = &nfs_v4, 911 .proto = proto, 912 .minorversion = minorversion, 913 .net = net, 914 .timeparms = timeparms, 915 .cred = server->cred, 916 .xprtsec = *xprtsec, 917 }; 918 struct nfs_client *clp; 919 920 if (minorversion == 0) 921 __set_bit(NFS_CS_REUSEPORT, &cl_init.init_flags); 922 else 923 cl_init.max_connect = max_connect; 924 switch (proto) { 925 case XPRT_TRANSPORT_TCP: 926 case XPRT_TRANSPORT_TCP_TLS: 927 cl_init.nconnect = nconnect; 928 } 929 930 if (server->flags & NFS_MOUNT_NORESVPORT) 931 __set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags); 932 if (server->options & NFS_OPTION_MIGRATION) 933 __set_bit(NFS_CS_MIGRATION, &cl_init.init_flags); 934 if (test_bit(NFS_MIG_TSM_POSSIBLE, &server->mig_status)) 935 __set_bit(NFS_CS_TSM_POSSIBLE, &cl_init.init_flags); 936 server->port = rpc_get_port((struct sockaddr *)addr); 937 938 /* Allocate or find a client reference we can use */ 939 clp = nfs_get_client(&cl_init); 940 if (IS_ERR(clp)) 941 return PTR_ERR(clp); 942 943 if (server->nfs_client == clp) { 944 nfs_put_client(clp); 945 return -ELOOP; 946 } 947 948 /* 949 * Query for the lease time on clientid setup or renewal 950 * 951 * Note that this will be set on nfs_clients that were created 952 * only for the DS role and did not set this bit, but now will 953 * serve a dual role. 954 */ 955 set_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state); 956 957 server->nfs_client = clp; 958 nfs_sysfs_add_server(server); 959 nfs_sysfs_link_rpc_client(server, clp->cl_rpcclient, "_state"); 960 961 return 0; 962 } 963 964 /* 965 * Set up a pNFS Data Server client. 966 * 967 * Return any existing nfs_client that matches server address,port,version 968 * and minorversion. 969 * 970 * For a new nfs_client, use a soft mount (default), a low retrans and a 971 * low timeout interval so that if a connection is lost, we retry through 972 * the MDS. 973 */ 974 struct nfs_client *nfs4_set_ds_client(struct nfs_server *mds_srv, 975 const struct sockaddr_storage *ds_addr, int ds_addrlen, 976 int ds_proto, unsigned int ds_timeo, unsigned int ds_retrans, 977 u32 minor_version) 978 { 979 struct rpc_timeout ds_timeout; 980 struct nfs_client *mds_clp = mds_srv->nfs_client; 981 struct nfs_client_initdata cl_init = { 982 .addr = ds_addr, 983 .addrlen = ds_addrlen, 984 .nodename = mds_clp->cl_rpcclient->cl_nodename, 985 .ip_addr = mds_clp->cl_ipaddr, 986 .nfs_mod = &nfs_v4, 987 .proto = ds_proto, 988 .minorversion = minor_version, 989 .net = mds_clp->cl_net, 990 .timeparms = &ds_timeout, 991 .cred = mds_srv->cred, 992 .xprtsec = mds_srv->nfs_client->cl_xprtsec, 993 }; 994 char buf[INET6_ADDRSTRLEN + 1]; 995 996 if (rpc_ntop((struct sockaddr *)ds_addr, buf, sizeof(buf)) <= 0) 997 return ERR_PTR(-EINVAL); 998 cl_init.hostname = buf; 999 1000 switch (ds_proto) { 1001 case XPRT_TRANSPORT_TCP: 1002 case XPRT_TRANSPORT_TCP_TLS: 1003 if (mds_clp->cl_nconnect > 1) { 1004 cl_init.nconnect = mds_clp->cl_nconnect; 1005 cl_init.max_connect = NFS_MAX_TRANSPORTS; 1006 } 1007 } 1008 1009 if (mds_srv->flags & NFS_MOUNT_NORESVPORT) 1010 __set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags); 1011 1012 __set_bit(NFS_CS_DS, &cl_init.init_flags); 1013 /* 1014 * Set an authflavor equual to the MDS value. Use the MDS nfs_client 1015 * cl_ipaddr so as to use the same EXCHANGE_ID co_ownerid as the MDS 1016 * (section 13.1 RFC 5661). 1017 */ 1018 nfs_init_timeout_values(&ds_timeout, ds_proto, ds_timeo, ds_retrans); 1019 return nfs_get_client(&cl_init); 1020 } 1021 EXPORT_SYMBOL_GPL(nfs4_set_ds_client); 1022 1023 /* 1024 * Session has been established, and the client marked ready. 1025 * Limit the mount rsize, wsize and dtsize using negotiated fore 1026 * channel attributes. 1027 */ 1028 static void nfs4_session_limit_rwsize(struct nfs_server *server) 1029 { 1030 #ifdef CONFIG_NFS_V4_1 1031 struct nfs4_session *sess; 1032 u32 server_resp_sz; 1033 u32 server_rqst_sz; 1034 1035 if (!nfs4_has_session(server->nfs_client)) 1036 return; 1037 sess = server->nfs_client->cl_session; 1038 server_resp_sz = sess->fc_attrs.max_resp_sz - nfs41_maxread_overhead; 1039 server_rqst_sz = sess->fc_attrs.max_rqst_sz - nfs41_maxwrite_overhead; 1040 1041 if (server->dtsize > server_resp_sz) 1042 server->dtsize = server_resp_sz; 1043 if (server->rsize > server_resp_sz) 1044 server->rsize = server_resp_sz; 1045 if (server->wsize > server_rqst_sz) 1046 server->wsize = server_rqst_sz; 1047 #endif /* CONFIG_NFS_V4_1 */ 1048 } 1049 1050 /* 1051 * Limit xattr sizes using the channel attributes. 1052 */ 1053 static void nfs4_session_limit_xasize(struct nfs_server *server) 1054 { 1055 #ifdef CONFIG_NFS_V4_2 1056 struct nfs4_session *sess; 1057 u32 server_gxa_sz; 1058 u32 server_sxa_sz; 1059 u32 server_lxa_sz; 1060 1061 if (!nfs4_has_session(server->nfs_client)) 1062 return; 1063 1064 sess = server->nfs_client->cl_session; 1065 1066 server_gxa_sz = sess->fc_attrs.max_resp_sz - nfs42_maxgetxattr_overhead; 1067 server_sxa_sz = sess->fc_attrs.max_rqst_sz - nfs42_maxsetxattr_overhead; 1068 server_lxa_sz = sess->fc_attrs.max_resp_sz - 1069 nfs42_maxlistxattrs_overhead; 1070 1071 if (server->gxasize > server_gxa_sz) 1072 server->gxasize = server_gxa_sz; 1073 if (server->sxasize > server_sxa_sz) 1074 server->sxasize = server_sxa_sz; 1075 if (server->lxasize > server_lxa_sz) 1076 server->lxasize = server_lxa_sz; 1077 #endif 1078 } 1079 1080 void nfs4_server_set_init_caps(struct nfs_server *server) 1081 { 1082 /* Set the basic capabilities */ 1083 server->caps |= server->nfs_client->cl_mvops->init_caps; 1084 if (server->flags & NFS_MOUNT_NORDIRPLUS) 1085 server->caps &= ~NFS_CAP_READDIRPLUS; 1086 if (server->nfs_client->cl_proto == XPRT_TRANSPORT_RDMA) 1087 server->caps &= ~NFS_CAP_READ_PLUS; 1088 1089 /* 1090 * Don't use NFS uid/gid mapping if we're using AUTH_SYS or lower 1091 * authentication. 1092 */ 1093 if (nfs4_disable_idmapping && 1094 server->client->cl_auth->au_flavor == RPC_AUTH_UNIX) 1095 server->caps |= NFS_CAP_UIDGID_NOMAP; 1096 } 1097 1098 static int nfs4_server_common_setup(struct nfs_server *server, 1099 struct nfs_fh *mntfh, bool auth_probe) 1100 { 1101 int error; 1102 1103 /* data servers support only a subset of NFSv4.1 */ 1104 if (is_ds_only_client(server->nfs_client)) 1105 return -EPROTONOSUPPORT; 1106 1107 /* We must ensure the session is initialised first */ 1108 error = nfs4_init_session(server->nfs_client); 1109 if (error < 0) 1110 goto out; 1111 1112 nfs4_server_set_init_caps(server); 1113 1114 /* Probe the root fh to retrieve its FSID and filehandle */ 1115 error = nfs4_get_rootfh(server, mntfh, auth_probe); 1116 if (error < 0) 1117 goto out; 1118 1119 dprintk("Server FSID: %llx:%llx\n", 1120 (unsigned long long) server->fsid.major, 1121 (unsigned long long) server->fsid.minor); 1122 nfs_display_fhandle(mntfh, "Pseudo-fs root FH"); 1123 1124 error = nfs_probe_server(server, mntfh); 1125 if (error < 0) 1126 goto out; 1127 1128 nfs4_session_limit_rwsize(server); 1129 nfs4_session_limit_xasize(server); 1130 1131 if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN) 1132 server->namelen = NFS4_MAXNAMLEN; 1133 1134 nfs_server_insert_lists(server); 1135 server->mount_time = jiffies; 1136 server->destroy = nfs4_destroy_server; 1137 out: 1138 return error; 1139 } 1140 1141 /* 1142 * Create a version 4 volume record 1143 */ 1144 static int nfs4_init_server(struct nfs_server *server, struct fs_context *fc) 1145 { 1146 struct nfs_fs_context *ctx = nfs_fc2context(fc); 1147 struct rpc_timeout timeparms; 1148 int error; 1149 1150 nfs_init_timeout_values(&timeparms, ctx->nfs_server.protocol, 1151 ctx->timeo, ctx->retrans); 1152 1153 /* Initialise the client representation from the mount data */ 1154 server->flags = ctx->flags; 1155 server->options = ctx->options; 1156 server->auth_info = ctx->auth_info; 1157 1158 /* Use the first specified auth flavor. If this flavor isn't 1159 * allowed by the server, use the SECINFO path to try the 1160 * other specified flavors */ 1161 if (ctx->auth_info.flavor_len >= 1) 1162 ctx->selected_flavor = ctx->auth_info.flavors[0]; 1163 else 1164 ctx->selected_flavor = RPC_AUTH_UNIX; 1165 1166 /* Get a client record */ 1167 error = nfs4_set_client(server, 1168 ctx->nfs_server.hostname, 1169 &ctx->nfs_server._address, 1170 ctx->nfs_server.addrlen, 1171 ctx->client_address, 1172 ctx->nfs_server.protocol, 1173 &timeparms, 1174 ctx->minorversion, 1175 ctx->nfs_server.nconnect, 1176 ctx->nfs_server.max_connect, 1177 fc->net_ns, 1178 &ctx->xprtsec); 1179 if (error < 0) 1180 return error; 1181 1182 if (ctx->rsize) 1183 server->rsize = nfs_io_size(ctx->rsize, server->nfs_client->cl_proto); 1184 if (ctx->wsize) 1185 server->wsize = nfs_io_size(ctx->wsize, server->nfs_client->cl_proto); 1186 1187 server->acregmin = ctx->acregmin * HZ; 1188 server->acregmax = ctx->acregmax * HZ; 1189 server->acdirmin = ctx->acdirmin * HZ; 1190 server->acdirmax = ctx->acdirmax * HZ; 1191 server->port = ctx->nfs_server.port; 1192 1193 return nfs_init_server_rpcclient(server, &timeparms, 1194 ctx->selected_flavor); 1195 } 1196 1197 /* 1198 * Create a version 4 volume record 1199 * - keyed on server and FSID 1200 */ 1201 struct nfs_server *nfs4_create_server(struct fs_context *fc) 1202 { 1203 struct nfs_fs_context *ctx = nfs_fc2context(fc); 1204 struct nfs_server *server; 1205 bool auth_probe; 1206 int error; 1207 1208 server = nfs_alloc_server(); 1209 if (!server) 1210 return ERR_PTR(-ENOMEM); 1211 1212 server->cred = get_cred(fc->cred); 1213 1214 auth_probe = ctx->auth_info.flavor_len < 1; 1215 1216 /* set up the general RPC client */ 1217 error = nfs4_init_server(server, fc); 1218 if (error < 0) 1219 goto error; 1220 1221 error = nfs4_server_common_setup(server, ctx->mntfh, auth_probe); 1222 if (error < 0) 1223 goto error; 1224 1225 return server; 1226 1227 error: 1228 nfs_free_server(server); 1229 return ERR_PTR(error); 1230 } 1231 1232 /* 1233 * Create an NFS4 referral server record 1234 */ 1235 struct nfs_server *nfs4_create_referral_server(struct fs_context *fc) 1236 { 1237 struct nfs_fs_context *ctx = nfs_fc2context(fc); 1238 struct nfs_client *parent_client; 1239 struct nfs_server *server, *parent_server; 1240 int proto, error; 1241 bool auth_probe; 1242 1243 server = nfs_alloc_server(); 1244 if (!server) 1245 return ERR_PTR(-ENOMEM); 1246 1247 parent_server = NFS_SB(ctx->clone_data.sb); 1248 parent_client = parent_server->nfs_client; 1249 1250 server->cred = get_cred(parent_server->cred); 1251 1252 /* Initialise the client representation from the parent server */ 1253 nfs_server_copy_userdata(server, parent_server); 1254 1255 /* Get a client representation */ 1256 #if IS_ENABLED(CONFIG_SUNRPC_XPRT_RDMA) 1257 rpc_set_port(&ctx->nfs_server.address, NFS_RDMA_PORT); 1258 error = nfs4_set_client(server, 1259 ctx->nfs_server.hostname, 1260 &ctx->nfs_server._address, 1261 ctx->nfs_server.addrlen, 1262 parent_client->cl_ipaddr, 1263 XPRT_TRANSPORT_RDMA, 1264 parent_server->client->cl_timeout, 1265 parent_client->cl_mvops->minor_version, 1266 parent_client->cl_nconnect, 1267 parent_client->cl_max_connect, 1268 parent_client->cl_net, 1269 &parent_client->cl_xprtsec); 1270 if (!error) 1271 goto init_server; 1272 #endif /* IS_ENABLED(CONFIG_SUNRPC_XPRT_RDMA) */ 1273 1274 proto = XPRT_TRANSPORT_TCP; 1275 if (parent_client->cl_xprtsec.policy != RPC_XPRTSEC_NONE) 1276 proto = XPRT_TRANSPORT_TCP_TLS; 1277 rpc_set_port(&ctx->nfs_server.address, NFS_PORT); 1278 error = nfs4_set_client(server, 1279 ctx->nfs_server.hostname, 1280 &ctx->nfs_server._address, 1281 ctx->nfs_server.addrlen, 1282 parent_client->cl_ipaddr, 1283 proto, 1284 parent_server->client->cl_timeout, 1285 parent_client->cl_mvops->minor_version, 1286 parent_client->cl_nconnect, 1287 parent_client->cl_max_connect, 1288 parent_client->cl_net, 1289 &parent_client->cl_xprtsec); 1290 if (error < 0) 1291 goto error; 1292 1293 #if IS_ENABLED(CONFIG_SUNRPC_XPRT_RDMA) 1294 init_server: 1295 #endif 1296 error = nfs_init_server_rpcclient(server, parent_server->client->cl_timeout, 1297 ctx->selected_flavor); 1298 if (error < 0) 1299 goto error; 1300 1301 auth_probe = parent_server->auth_info.flavor_len < 1; 1302 1303 error = nfs4_server_common_setup(server, ctx->mntfh, auth_probe); 1304 if (error < 0) 1305 goto error; 1306 1307 return server; 1308 1309 error: 1310 nfs_free_server(server); 1311 return ERR_PTR(error); 1312 } 1313 1314 /** 1315 * nfs4_update_server - Move an nfs_server to a different nfs_client 1316 * 1317 * @server: represents FSID to be moved 1318 * @hostname: new end-point's hostname 1319 * @sap: new end-point's socket address 1320 * @salen: size of "sap" 1321 * @net: net namespace 1322 * 1323 * The nfs_server must be quiescent before this function is invoked. 1324 * Either its session is drained (NFSv4.1+), or its transport is 1325 * plugged and drained (NFSv4.0). 1326 * 1327 * Returns zero on success, or a negative errno value. 1328 */ 1329 int nfs4_update_server(struct nfs_server *server, const char *hostname, 1330 struct sockaddr_storage *sap, size_t salen, struct net *net) 1331 { 1332 struct nfs_client *clp = server->nfs_client; 1333 struct rpc_clnt *clnt = server->client; 1334 struct xprt_create xargs = { 1335 .ident = clp->cl_proto, 1336 .net = net, 1337 .dstaddr = (struct sockaddr *)sap, 1338 .addrlen = salen, 1339 .servername = hostname, 1340 /* cel: bleh. We might need to pass TLS parameters here */ 1341 }; 1342 char buf[INET6_ADDRSTRLEN + 1]; 1343 struct sockaddr_storage address; 1344 struct sockaddr *localaddr = (struct sockaddr *)&address; 1345 int error; 1346 1347 error = rpc_switch_client_transport(clnt, &xargs, clnt->cl_timeout); 1348 if (error != 0) 1349 return error; 1350 1351 error = rpc_localaddr(clnt, localaddr, sizeof(address)); 1352 if (error != 0) 1353 return error; 1354 1355 if (rpc_ntop(localaddr, buf, sizeof(buf)) == 0) 1356 return -EAFNOSUPPORT; 1357 1358 nfs_server_remove_lists(server); 1359 set_bit(NFS_MIG_TSM_POSSIBLE, &server->mig_status); 1360 error = nfs4_set_client(server, hostname, sap, salen, buf, 1361 clp->cl_proto, clnt->cl_timeout, 1362 clp->cl_minorversion, 1363 clp->cl_nconnect, clp->cl_max_connect, 1364 net, &clp->cl_xprtsec); 1365 clear_bit(NFS_MIG_TSM_POSSIBLE, &server->mig_status); 1366 if (error != 0) { 1367 nfs_server_insert_lists(server); 1368 return error; 1369 } 1370 nfs_put_client(clp); 1371 1372 if (server->nfs_client->cl_hostname == NULL) { 1373 server->nfs_client->cl_hostname = kstrdup(hostname, GFP_KERNEL); 1374 if (server->nfs_client->cl_hostname == NULL) 1375 return -ENOMEM; 1376 } 1377 nfs_server_insert_lists(server); 1378 1379 return nfs_probe_server(server, NFS_FH(d_inode(server->super->s_root))); 1380 } 1381