fs/nfs/nfs4client.c

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