linux/fs/nfs/nfs4client.c
<<
>>
Prefs
   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 */
  28static 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 */
  49struct 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 */
  59static struct nfs4_ds_server *
  60nfs4_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;
  71out:
  72        rcu_read_unlock();
  73        return dss;
  74}
  75
  76static struct nfs4_ds_server *
  77nfs4_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;
  91out:
  92        spin_unlock(&ds_clp->cl_lock); /* need some lock to protect list */
  93        return dss;
  94}
  95
  96static struct nfs4_ds_server *
  97nfs4_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
 116static void
 117nfs4_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 */
 131struct rpc_clnt *
 132nfs4_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);
 146out:
 147        return dss->rpc_clnt;
 148}
 149EXPORT_SYMBOL_GPL(nfs4_find_or_create_ds_client);
 150
 151static void
 152nfs4_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
 165static void
 166nfs4_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
 178void 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
 190void 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
 198struct 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
 268error:
 269        nfs_free_client(clp);
 270        return ERR_PTR(err);
 271}
 272
 273/*
 274 * Destroy the NFS4 callback service
 275 */
 276static 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
 282static 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
 298void 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 */
 307static 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 */
 337int 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                kfree(tbl);
 350                return ret;
 351        }
 352
 353        clp->cl_slot_tbl = tbl;
 354        return 0;
 355}
 356
 357#if defined(CONFIG_NFS_V4_1)
 358
 359/**
 360 * nfs41_init_client - nfs_client initialization tasks for NFSv4.1+
 361 * @clp: nfs_client to initialize
 362 *
 363 * Returns zero on success, or a negative errno if some error occurred.
 364 */
 365int nfs41_init_client(struct nfs_client *clp)
 366{
 367        struct nfs4_session *session = NULL;
 368
 369        /*
 370         * Create the session and mark it expired.
 371         * When a SEQUENCE operation encounters the expired session
 372         * it will do session recovery to initialize it.
 373         */
 374        session = nfs4_alloc_session(clp);
 375        if (!session)
 376                return -ENOMEM;
 377
 378        clp->cl_session = session;
 379
 380        /*
 381         * The create session reply races with the server back
 382         * channel probe. Mark the client NFS_CS_SESSION_INITING
 383         * so that the client back channel can find the
 384         * nfs_client struct
 385         */
 386        nfs_mark_client_ready(clp, NFS_CS_SESSION_INITING);
 387        return 0;
 388}
 389
 390#endif  /* CONFIG_NFS_V4_1 */
 391
 392/*
 393 * Initialize the minor version specific parts of an NFS4 client record
 394 */
 395static int nfs4_init_client_minor_version(struct nfs_client *clp)
 396{
 397        int ret;
 398
 399        ret = clp->cl_mvops->init_client(clp);
 400        if (ret)
 401                return ret;
 402        return nfs4_init_callback(clp);
 403}
 404
 405/**
 406 * nfs4_init_client - Initialise an NFS4 client record
 407 *
 408 * @clp: nfs_client to initialise
 409 * @cl_init: pointer to nfs_client_initdata
 410 *
 411 * Returns pointer to an NFS client, or an ERR_PTR value.
 412 */
 413struct nfs_client *nfs4_init_client(struct nfs_client *clp,
 414                                    const struct nfs_client_initdata *cl_init)
 415{
 416        struct nfs_client *old;
 417        int error;
 418
 419        if (clp->cl_cons_state == NFS_CS_READY)
 420                /* the client is initialised already */
 421                return clp;
 422
 423        error = nfs4_init_client_minor_version(clp);
 424        if (error < 0)
 425                goto error;
 426
 427        error = nfs4_discover_server_trunking(clp, &old);
 428        if (error < 0)
 429                goto error;
 430
 431        if (clp != old) {
 432                clp->cl_preserve_clid = true;
 433                /*
 434                 * Mark the client as having failed initialization so other
 435                 * processes walking the nfs_client_list in nfs_match_client()
 436                 * won't try to use it.
 437                 */
 438                nfs_mark_client_ready(clp, -EPERM);
 439        }
 440        clear_bit(NFS_CS_TSM_POSSIBLE, &clp->cl_flags);
 441        nfs_put_client(clp);
 442        return old;
 443
 444error:
 445        nfs_mark_client_ready(clp, error);
 446        nfs_put_client(clp);
 447        return ERR_PTR(error);
 448}
 449
 450/*
 451 * SETCLIENTID just did a callback update with the callback ident in
 452 * "drop," but server trunking discovery claims "drop" and "keep" are
 453 * actually the same server.  Swap the callback IDs so that "keep"
 454 * will continue to use the callback ident the server now knows about,
 455 * and so that "keep"'s original callback ident is destroyed when
 456 * "drop" is freed.
 457 */
 458static void nfs4_swap_callback_idents(struct nfs_client *keep,
 459                                      struct nfs_client *drop)
 460{
 461        struct nfs_net *nn = net_generic(keep->cl_net, nfs_net_id);
 462        unsigned int save = keep->cl_cb_ident;
 463
 464        if (keep->cl_cb_ident == drop->cl_cb_ident)
 465                return;
 466
 467        dprintk("%s: keeping callback ident %u and dropping ident %u\n",
 468                __func__, keep->cl_cb_ident, drop->cl_cb_ident);
 469
 470        spin_lock(&nn->nfs_client_lock);
 471
 472        idr_replace(&nn->cb_ident_idr, keep, drop->cl_cb_ident);
 473        keep->cl_cb_ident = drop->cl_cb_ident;
 474
 475        idr_replace(&nn->cb_ident_idr, drop, save);
 476        drop->cl_cb_ident = save;
 477
 478        spin_unlock(&nn->nfs_client_lock);
 479}
 480
 481static bool nfs4_match_client_owner_id(const struct nfs_client *clp1,
 482                const struct nfs_client *clp2)
 483{
 484        if (clp1->cl_owner_id == NULL || clp2->cl_owner_id == NULL)
 485                return true;
 486        return strcmp(clp1->cl_owner_id, clp2->cl_owner_id) == 0;
 487}
 488
 489static bool nfs4_same_verifier(nfs4_verifier *v1, nfs4_verifier *v2)
 490{
 491        return memcmp(v1->data, v2->data, sizeof(v1->data)) == 0;
 492}
 493
 494static int nfs4_match_client(struct nfs_client  *pos,  struct nfs_client *new,
 495                             struct nfs_client **prev, struct nfs_net *nn)
 496{
 497        int status;
 498
 499        if (pos->rpc_ops != new->rpc_ops)
 500                return 1;
 501
 502        if (pos->cl_minorversion != new->cl_minorversion)
 503                return 1;
 504
 505        /* If "pos" isn't marked ready, we can't trust the
 506         * remaining fields in "pos", especially the client
 507         * ID and serverowner fields.  Wait for CREATE_SESSION
 508         * to finish. */
 509        if (pos->cl_cons_state > NFS_CS_READY) {
 510                refcount_inc(&pos->cl_count);
 511                spin_unlock(&nn->nfs_client_lock);
 512
 513                nfs_put_client(*prev);
 514                *prev = pos;
 515
 516                status = nfs_wait_client_init_complete(pos);
 517                spin_lock(&nn->nfs_client_lock);
 518
 519                if (status < 0)
 520                        return status;
 521        }
 522
 523        if (pos->cl_cons_state != NFS_CS_READY)
 524                return 1;
 525
 526        if (pos->cl_clientid != new->cl_clientid)
 527                return 1;
 528
 529        /* NFSv4.1 always uses the uniform string, however someone
 530         * might switch the uniquifier string on us.
 531         */
 532        if (!nfs4_match_client_owner_id(pos, new))
 533                return 1;
 534
 535        return 0;
 536}
 537
 538/**
 539 * nfs40_walk_client_list - Find server that recognizes a client ID
 540 *
 541 * @new: nfs_client with client ID to test
 542 * @result: OUT: found nfs_client, or new
 543 * @cred: credential to use for trunking test
 544 *
 545 * Returns zero, a negative errno, or a negative NFS4ERR status.
 546 * If zero is returned, an nfs_client pointer is planted in "result."
 547 *
 548 * NB: nfs40_walk_client_list() relies on the new nfs_client being
 549 *     the last nfs_client on the list.
 550 */
 551int nfs40_walk_client_list(struct nfs_client *new,
 552                           struct nfs_client **result,
 553                           const struct cred *cred)
 554{
 555        struct nfs_net *nn = net_generic(new->cl_net, nfs_net_id);
 556        struct nfs_client *pos, *prev = NULL;
 557        struct nfs4_setclientid_res clid = {
 558                .clientid       = new->cl_clientid,
 559                .confirm        = new->cl_confirm,
 560        };
 561        int status = -NFS4ERR_STALE_CLIENTID;
 562
 563        spin_lock(&nn->nfs_client_lock);
 564        list_for_each_entry(pos, &nn->nfs_client_list, cl_share_link) {
 565
 566                if (pos == new)
 567                        goto found;
 568
 569                status = nfs4_match_client(pos, new, &prev, nn);
 570                if (status < 0)
 571                        goto out_unlock;
 572                if (status != 0)
 573                        continue;
 574                /*
 575                 * We just sent a new SETCLIENTID, which should have
 576                 * caused the server to return a new cl_confirm.  So if
 577                 * cl_confirm is the same, then this is a different
 578                 * server that just returned the same cl_confirm by
 579                 * coincidence:
 580                 */
 581                if ((new != pos) && nfs4_same_verifier(&pos->cl_confirm,
 582                                                       &new->cl_confirm))
 583                        continue;
 584                /*
 585                 * But if the cl_confirm's are different, then the only
 586                 * way that a SETCLIENTID_CONFIRM to pos can succeed is
 587                 * if new and pos point to the same server:
 588                 */
 589found:
 590                refcount_inc(&pos->cl_count);
 591                spin_unlock(&nn->nfs_client_lock);
 592
 593                nfs_put_client(prev);
 594                prev = pos;
 595
 596                status = nfs4_proc_setclientid_confirm(pos, &clid, cred);
 597                switch (status) {
 598                case -NFS4ERR_STALE_CLIENTID:
 599                        break;
 600                case 0:
 601                        nfs4_swap_callback_idents(pos, new);
 602                        pos->cl_confirm = new->cl_confirm;
 603                        nfs_mark_client_ready(pos, NFS_CS_READY);
 604
 605                        prev = NULL;
 606                        *result = pos;
 607                        goto out;
 608                case -ERESTARTSYS:
 609                case -ETIMEDOUT:
 610                        /* The callback path may have been inadvertently
 611                         * changed. Schedule recovery!
 612                         */
 613                        nfs4_schedule_path_down_recovery(pos);
 614                        goto out;
 615                default:
 616                        goto out;
 617                }
 618
 619                spin_lock(&nn->nfs_client_lock);
 620        }
 621out_unlock:
 622        spin_unlock(&nn->nfs_client_lock);
 623
 624        /* No match found. The server lost our clientid */
 625out:
 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 */
 634bool
 635nfs4_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 */
 646static bool
 647nfs4_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 */
 672int 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;
 698out_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 */
 718int 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
 747found:
 748                refcount_inc(&pos->cl_count);
 749                *result = pos;
 750                status = 0;
 751                break;
 752        }
 753
 754out:
 755        spin_unlock(&nn->nfs_client_lock);
 756        nfs_put_client(prev);
 757        return status;
 758}
 759#endif  /* CONFIG_NFS_V4_1 */
 760
 761static 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 */
 776struct nfs_client *
 777nfs4_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 */
 792static 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 */
 820struct nfs_client *
 821nfs4_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
 850struct nfs_client *
 851nfs4_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 */
 861static 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)
 885                __set_bit(NFS_CS_REUSEPORT, &cl_init.init_flags);
 886        if (proto == XPRT_TRANSPORT_TCP)
 887                cl_init.nconnect = nconnect;
 888
 889        if (server->flags & NFS_MOUNT_NORESVPORT)
 890                __set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags);
 891        if (server->options & NFS_OPTION_MIGRATION)
 892                __set_bit(NFS_CS_MIGRATION, &cl_init.init_flags);
 893        if (test_bit(NFS_MIG_TSM_POSSIBLE, &server->mig_status))
 894                __set_bit(NFS_CS_TSM_POSSIBLE, &cl_init.init_flags);
 895        server->port = rpc_get_port(addr);
 896
 897        /* Allocate or find a client reference we can use */
 898        clp = nfs_get_client(&cl_init);
 899        if (IS_ERR(clp))
 900                return PTR_ERR(clp);
 901
 902        if (server->nfs_client == clp) {
 903                nfs_put_client(clp);
 904                return -ELOOP;
 905        }
 906
 907        /*
 908         * Query for the lease time on clientid setup or renewal
 909         *
 910         * Note that this will be set on nfs_clients that were created
 911         * only for the DS role and did not set this bit, but now will
 912         * serve a dual role.
 913         */
 914        set_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state);
 915
 916        server->nfs_client = clp;
 917        return 0;
 918}
 919
 920/*
 921 * Set up a pNFS Data Server client.
 922 *
 923 * Return any existing nfs_client that matches server address,port,version
 924 * and minorversion.
 925 *
 926 * For a new nfs_client, use a soft mount (default), a low retrans and a
 927 * low timeout interval so that if a connection is lost, we retry through
 928 * the MDS.
 929 */
 930struct nfs_client *nfs4_set_ds_client(struct nfs_server *mds_srv,
 931                const struct sockaddr *ds_addr, int ds_addrlen,
 932                int ds_proto, unsigned int ds_timeo, unsigned int ds_retrans,
 933                u32 minor_version)
 934{
 935        struct rpc_timeout ds_timeout;
 936        struct nfs_client *mds_clp = mds_srv->nfs_client;
 937        struct nfs_client_initdata cl_init = {
 938                .addr = ds_addr,
 939                .addrlen = ds_addrlen,
 940                .nodename = mds_clp->cl_rpcclient->cl_nodename,
 941                .ip_addr = mds_clp->cl_ipaddr,
 942                .nfs_mod = &nfs_v4,
 943                .proto = ds_proto,
 944                .minorversion = minor_version,
 945                .net = mds_clp->cl_net,
 946                .timeparms = &ds_timeout,
 947                .cred = mds_srv->cred,
 948        };
 949        char buf[INET6_ADDRSTRLEN + 1];
 950
 951        if (rpc_ntop(ds_addr, buf, sizeof(buf)) <= 0)
 952                return ERR_PTR(-EINVAL);
 953        cl_init.hostname = buf;
 954
 955        if (mds_clp->cl_nconnect > 1 && ds_proto == XPRT_TRANSPORT_TCP)
 956                cl_init.nconnect = mds_clp->cl_nconnect;
 957
 958        if (mds_srv->flags & NFS_MOUNT_NORESVPORT)
 959                __set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags);
 960
 961        /*
 962         * Set an authflavor equual to the MDS value. Use the MDS nfs_client
 963         * cl_ipaddr so as to use the same EXCHANGE_ID co_ownerid as the MDS
 964         * (section 13.1 RFC 5661).
 965         */
 966        nfs_init_timeout_values(&ds_timeout, ds_proto, ds_timeo, ds_retrans);
 967        return nfs_get_client(&cl_init);
 968}
 969EXPORT_SYMBOL_GPL(nfs4_set_ds_client);
 970
 971/*
 972 * Session has been established, and the client marked ready.
 973 * Limit the mount rsize, wsize and dtsize using negotiated fore
 974 * channel attributes.
 975 */
 976static void nfs4_session_limit_rwsize(struct nfs_server *server)
 977{
 978#ifdef CONFIG_NFS_V4_1
 979        struct nfs4_session *sess;
 980        u32 server_resp_sz;
 981        u32 server_rqst_sz;
 982
 983        if (!nfs4_has_session(server->nfs_client))
 984                return;
 985        sess = server->nfs_client->cl_session;
 986        server_resp_sz = sess->fc_attrs.max_resp_sz - nfs41_maxread_overhead;
 987        server_rqst_sz = sess->fc_attrs.max_rqst_sz - nfs41_maxwrite_overhead;
 988
 989        if (server->dtsize > server_resp_sz)
 990                server->dtsize = server_resp_sz;
 991        if (server->rsize > server_resp_sz)
 992                server->rsize = server_resp_sz;
 993        if (server->wsize > server_rqst_sz)
 994                server->wsize = server_rqst_sz;
 995#endif /* CONFIG_NFS_V4_1 */
 996}
 997
 998/*
 999 * Limit xattr sizes using the channel attributes.
1000 */
1001static void nfs4_session_limit_xasize(struct nfs_server *server)
1002{
1003#ifdef CONFIG_NFS_V4_2
1004        struct nfs4_session *sess;
1005        u32 server_gxa_sz;
1006        u32 server_sxa_sz;
1007        u32 server_lxa_sz;
1008
1009        if (!nfs4_has_session(server->nfs_client))
1010                return;
1011
1012        sess = server->nfs_client->cl_session;
1013
1014        server_gxa_sz = sess->fc_attrs.max_resp_sz - nfs42_maxgetxattr_overhead;
1015        server_sxa_sz = sess->fc_attrs.max_rqst_sz - nfs42_maxsetxattr_overhead;
1016        server_lxa_sz = sess->fc_attrs.max_resp_sz -
1017            nfs42_maxlistxattrs_overhead;
1018
1019        if (server->gxasize > server_gxa_sz)
1020                server->gxasize = server_gxa_sz;
1021        if (server->sxasize > server_sxa_sz)
1022                server->sxasize = server_sxa_sz;
1023        if (server->lxasize > server_lxa_sz)
1024                server->lxasize = server_lxa_sz;
1025#endif
1026}
1027
1028static int nfs4_server_common_setup(struct nfs_server *server,
1029                struct nfs_fh *mntfh, bool auth_probe)
1030{
1031        struct nfs_fattr *fattr;
1032        int error;
1033
1034        /* data servers support only a subset of NFSv4.1 */
1035        if (is_ds_only_client(server->nfs_client))
1036                return -EPROTONOSUPPORT;
1037
1038        fattr = nfs_alloc_fattr();
1039        if (fattr == NULL)
1040                return -ENOMEM;
1041
1042        /* We must ensure the session is initialised first */
1043        error = nfs4_init_session(server->nfs_client);
1044        if (error < 0)
1045                goto out;
1046
1047        /* Set the basic capabilities */
1048        server->caps |= server->nfs_client->cl_mvops->init_caps;
1049        if (server->flags & NFS_MOUNT_NORDIRPLUS)
1050                        server->caps &= ~NFS_CAP_READDIRPLUS;
1051        if (server->nfs_client->cl_proto == XPRT_TRANSPORT_RDMA)
1052                server->caps &= ~NFS_CAP_READ_PLUS;
1053        /*
1054         * Don't use NFS uid/gid mapping if we're using AUTH_SYS or lower
1055         * authentication.
1056         */
1057        if (nfs4_disable_idmapping &&
1058                        server->client->cl_auth->au_flavor == RPC_AUTH_UNIX)
1059                server->caps |= NFS_CAP_UIDGID_NOMAP;
1060
1061
1062        /* Probe the root fh to retrieve its FSID and filehandle */
1063        error = nfs4_get_rootfh(server, mntfh, auth_probe);
1064        if (error < 0)
1065                goto out;
1066
1067        dprintk("Server FSID: %llx:%llx\n",
1068                        (unsigned long long) server->fsid.major,
1069                        (unsigned long long) server->fsid.minor);
1070        nfs_display_fhandle(mntfh, "Pseudo-fs root FH");
1071
1072        error = nfs_probe_fsinfo(server, mntfh, fattr);
1073        if (error < 0)
1074                goto out;
1075
1076        nfs4_session_limit_rwsize(server);
1077        nfs4_session_limit_xasize(server);
1078
1079        if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN)
1080                server->namelen = NFS4_MAXNAMLEN;
1081
1082        nfs_server_insert_lists(server);
1083        server->mount_time = jiffies;
1084        server->destroy = nfs4_destroy_server;
1085out:
1086        nfs_free_fattr(fattr);
1087        return error;
1088}
1089
1090/*
1091 * Create a version 4 volume record
1092 */
1093static int nfs4_init_server(struct nfs_server *server, struct fs_context *fc)
1094{
1095        struct nfs_fs_context *ctx = nfs_fc2context(fc);
1096        struct rpc_timeout timeparms;
1097        int error;
1098
1099        nfs_init_timeout_values(&timeparms, ctx->nfs_server.protocol,
1100                                ctx->timeo, ctx->retrans);
1101
1102        /* Initialise the client representation from the mount data */
1103        server->flags = ctx->flags;
1104        server->options = ctx->options;
1105        server->auth_info = ctx->auth_info;
1106
1107        /* Use the first specified auth flavor. If this flavor isn't
1108         * allowed by the server, use the SECINFO path to try the
1109         * other specified flavors */
1110        if (ctx->auth_info.flavor_len >= 1)
1111                ctx->selected_flavor = ctx->auth_info.flavors[0];
1112        else
1113                ctx->selected_flavor = RPC_AUTH_UNIX;
1114
1115        /* Get a client record */
1116        error = nfs4_set_client(server,
1117                                ctx->nfs_server.hostname,
1118                                &ctx->nfs_server.address,
1119                                ctx->nfs_server.addrlen,
1120                                ctx->client_address,
1121                                ctx->nfs_server.protocol,
1122                                &timeparms,
1123                                ctx->minorversion,
1124                                ctx->nfs_server.nconnect,
1125                                fc->net_ns);
1126        if (error < 0)
1127                return error;
1128
1129        if (ctx->rsize)
1130                server->rsize = nfs_block_size(ctx->rsize, NULL);
1131        if (ctx->wsize)
1132                server->wsize = nfs_block_size(ctx->wsize, NULL);
1133
1134        server->acregmin = ctx->acregmin * HZ;
1135        server->acregmax = ctx->acregmax * HZ;
1136        server->acdirmin = ctx->acdirmin * HZ;
1137        server->acdirmax = ctx->acdirmax * HZ;
1138        server->port     = ctx->nfs_server.port;
1139
1140        return nfs_init_server_rpcclient(server, &timeparms,
1141                                         ctx->selected_flavor);
1142}
1143
1144/*
1145 * Create a version 4 volume record
1146 * - keyed on server and FSID
1147 */
1148struct nfs_server *nfs4_create_server(struct fs_context *fc)
1149{
1150        struct nfs_fs_context *ctx = nfs_fc2context(fc);
1151        struct nfs_server *server;
1152        bool auth_probe;
1153        int error;
1154
1155        server = nfs_alloc_server();
1156        if (!server)
1157                return ERR_PTR(-ENOMEM);
1158
1159        server->cred = get_cred(fc->cred);
1160
1161        auth_probe = ctx->auth_info.flavor_len < 1;
1162
1163        /* set up the general RPC client */
1164        error = nfs4_init_server(server, fc);
1165        if (error < 0)
1166                goto error;
1167
1168        error = nfs4_server_common_setup(server, ctx->mntfh, auth_probe);
1169        if (error < 0)
1170                goto error;
1171
1172        return server;
1173
1174error:
1175        nfs_free_server(server);
1176        return ERR_PTR(error);
1177}
1178
1179/*
1180 * Create an NFS4 referral server record
1181 */
1182struct nfs_server *nfs4_create_referral_server(struct fs_context *fc)
1183{
1184        struct nfs_fs_context *ctx = nfs_fc2context(fc);
1185        struct nfs_client *parent_client;
1186        struct nfs_server *server, *parent_server;
1187        bool auth_probe;
1188        int error;
1189
1190        server = nfs_alloc_server();
1191        if (!server)
1192                return ERR_PTR(-ENOMEM);
1193
1194        parent_server = NFS_SB(ctx->clone_data.sb);
1195        parent_client = parent_server->nfs_client;
1196
1197        server->cred = get_cred(parent_server->cred);
1198
1199        /* Initialise the client representation from the parent server */
1200        nfs_server_copy_userdata(server, parent_server);
1201
1202        /* Get a client representation */
1203#if IS_ENABLED(CONFIG_SUNRPC_XPRT_RDMA)
1204        rpc_set_port(&ctx->nfs_server.address, NFS_RDMA_PORT);
1205        error = nfs4_set_client(server,
1206                                ctx->nfs_server.hostname,
1207                                &ctx->nfs_server.address,
1208                                ctx->nfs_server.addrlen,
1209                                parent_client->cl_ipaddr,
1210                                XPRT_TRANSPORT_RDMA,
1211                                parent_server->client->cl_timeout,
1212                                parent_client->cl_mvops->minor_version,
1213                                parent_client->cl_nconnect,
1214                                parent_client->cl_net);
1215        if (!error)
1216                goto init_server;
1217#endif  /* IS_ENABLED(CONFIG_SUNRPC_XPRT_RDMA) */
1218
1219        rpc_set_port(&ctx->nfs_server.address, NFS_PORT);
1220        error = nfs4_set_client(server,
1221                                ctx->nfs_server.hostname,
1222                                &ctx->nfs_server.address,
1223                                ctx->nfs_server.addrlen,
1224                                parent_client->cl_ipaddr,
1225                                XPRT_TRANSPORT_TCP,
1226                                parent_server->client->cl_timeout,
1227                                parent_client->cl_mvops->minor_version,
1228                                parent_client->cl_nconnect,
1229                                parent_client->cl_net);
1230        if (error < 0)
1231                goto error;
1232
1233#if IS_ENABLED(CONFIG_SUNRPC_XPRT_RDMA)
1234init_server:
1235#endif
1236        error = nfs_init_server_rpcclient(server, parent_server->client->cl_timeout,
1237                                          ctx->selected_flavor);
1238        if (error < 0)
1239                goto error;
1240
1241        auth_probe = parent_server->auth_info.flavor_len < 1;
1242
1243        error = nfs4_server_common_setup(server, ctx->mntfh, auth_probe);
1244        if (error < 0)
1245                goto error;
1246
1247        return server;
1248
1249error:
1250        nfs_free_server(server);
1251        return ERR_PTR(error);
1252}
1253
1254/*
1255 * Grab the destination's particulars, including lease expiry time.
1256 *
1257 * Returns zero if probe succeeded and retrieved FSID matches the FSID
1258 * we have cached.
1259 */
1260static int nfs_probe_destination(struct nfs_server *server)
1261{
1262        struct inode *inode = d_inode(server->super->s_root);
1263        struct nfs_fattr *fattr;
1264        int error;
1265
1266        fattr = nfs_alloc_fattr();
1267        if (fattr == NULL)
1268                return -ENOMEM;
1269
1270        /* Sanity: the probe won't work if the destination server
1271         * does not recognize the migrated FH. */
1272        error = nfs_probe_fsinfo(server, NFS_FH(inode), fattr);
1273
1274        nfs_free_fattr(fattr);
1275        return error;
1276}
1277
1278/**
1279 * nfs4_update_server - Move an nfs_server to a different nfs_client
1280 *
1281 * @server: represents FSID to be moved
1282 * @hostname: new end-point's hostname
1283 * @sap: new end-point's socket address
1284 * @salen: size of "sap"
1285 * @net: net namespace
1286 *
1287 * The nfs_server must be quiescent before this function is invoked.
1288 * Either its session is drained (NFSv4.1+), or its transport is
1289 * plugged and drained (NFSv4.0).
1290 *
1291 * Returns zero on success, or a negative errno value.
1292 */
1293int nfs4_update_server(struct nfs_server *server, const char *hostname,
1294                       struct sockaddr *sap, size_t salen, struct net *net)
1295{
1296        struct nfs_client *clp = server->nfs_client;
1297        struct rpc_clnt *clnt = server->client;
1298        struct xprt_create xargs = {
1299                .ident          = clp->cl_proto,
1300                .net            = net,
1301                .dstaddr        = sap,
1302                .addrlen        = salen,
1303                .servername     = hostname,
1304        };
1305        char buf[INET6_ADDRSTRLEN + 1];
1306        struct sockaddr_storage address;
1307        struct sockaddr *localaddr = (struct sockaddr *)&address;
1308        int error;
1309
1310        error = rpc_switch_client_transport(clnt, &xargs, clnt->cl_timeout);
1311        if (error != 0)
1312                return error;
1313
1314        error = rpc_localaddr(clnt, localaddr, sizeof(address));
1315        if (error != 0)
1316                return error;
1317
1318        if (rpc_ntop(localaddr, buf, sizeof(buf)) == 0)
1319                return -EAFNOSUPPORT;
1320
1321        nfs_server_remove_lists(server);
1322        set_bit(NFS_MIG_TSM_POSSIBLE, &server->mig_status);
1323        error = nfs4_set_client(server, hostname, sap, salen, buf,
1324                                clp->cl_proto, clnt->cl_timeout,
1325                                clp->cl_minorversion,
1326                                clp->cl_nconnect, net);
1327        clear_bit(NFS_MIG_TSM_POSSIBLE, &server->mig_status);
1328        if (error != 0) {
1329                nfs_server_insert_lists(server);
1330                return error;
1331        }
1332        nfs_put_client(clp);
1333
1334        if (server->nfs_client->cl_hostname == NULL)
1335                server->nfs_client->cl_hostname = kstrdup(hostname, GFP_KERNEL);
1336        nfs_server_insert_lists(server);
1337
1338        return nfs_probe_destination(server);
1339}
1340