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