fs/nfs/client.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* client.c: NFS client sharing and management code
   3  *
   4  * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
   5  * Written by David Howells ([email protected])
   6  */
   7
   8
   9 #include <linux/module.h>
  10 #include <linux/init.h>
  11 #include <linux/sched.h>
  12 #include <linux/time.h>
  13 #include <linux/kernel.h>
  14 #include <linux/mm.h>
  15 #include <linux/string.h>
  16 #include <linux/stat.h>
  17 #include <linux/errno.h>
  18 #include <linux/unistd.h>
  19 #include <linux/sunrpc/addr.h>
  20 #include <linux/sunrpc/clnt.h>
  21 #include <linux/sunrpc/stats.h>
  22 #include <linux/sunrpc/metrics.h>
  23 #include <linux/sunrpc/xprtsock.h>
  24 #include <linux/sunrpc/xprtrdma.h>
  25 #include <linux/nfs_fs.h>
  26 #include <linux/nfs_mount.h>
  27 #include <linux/nfs4_mount.h>
  28 #include <linux/lockd/bind.h>
  29 #include <linux/seq_file.h>
  30 #include <linux/mount.h>
  31 #include <linux/vfs.h>
  32 #include <linux/inet.h>
  33 #include <linux/in6.h>
  34 #include <linux/slab.h>
  35 #include <linux/idr.h>
  36 #include <net/ipv6.h>
  37 #include <linux/nfs_xdr.h>
  38 #include <linux/sunrpc/bc_xprt.h>
  39 #include <linux/nsproxy.h>
  40 #include <linux/pid_namespace.h>
  41
  42
  43 #include "nfs4_fs.h"
  44 #include "callback.h"
  45 #include "delegation.h"
  46 #include "iostat.h"
  47 #include "internal.h"
  48 #include "fscache.h"
  49 #include "pnfs.h"
  50 #include "nfs.h"
  51 #include "netns.h"
  52 #include "sysfs.h"
  53 #include "nfs42.h"
  54
  55 #define NFSDBG_FACILITY         NFSDBG_CLIENT
  56
  57 static DECLARE_WAIT_QUEUE_HEAD(nfs_client_active_wq);
  58 static DEFINE_RWLOCK(nfs_version_lock);
  59
  60 static struct nfs_subversion *nfs_version_mods[5] = {
  61         [2] = NULL,
  62         [3] = NULL,
  63         [4] = NULL,
  64 };
  65
  66 /*
  67  * RPC cruft for NFS
  68  */
  69 static const struct rpc_version *nfs_version[5] = {
  70         [2] = NULL,
  71         [3] = NULL,
  72         [4] = NULL,
  73 };
  74
  75 const struct rpc_program nfs_program = {
  76         .name                   = "nfs",
  77         .number                 = NFS_PROGRAM,
  78         .nrvers                 = ARRAY_SIZE(nfs_version),
  79         .version                = nfs_version,
  80         .pipe_dir_name          = NFS_PIPE_DIRNAME,
  81 };
  82
  83 static struct nfs_subversion *__find_nfs_version(unsigned int version)
  84 {
  85         struct nfs_subversion *nfs;
  86
  87         read_lock(&nfs_version_lock);
  88         nfs = nfs_version_mods[version];
  89         read_unlock(&nfs_version_lock);
  90         return nfs;
  91 }
  92
  93 struct nfs_subversion *find_nfs_version(unsigned int version)
  94 {
  95         struct nfs_subversion *nfs = __find_nfs_version(version);
  96
  97         if (!nfs && request_module("nfsv%d", version) == 0)
  98                 nfs = __find_nfs_version(version);
  99
 100         if (!nfs)
 101                 return ERR_PTR(-EPROTONOSUPPORT);
 102
 103         if (!get_nfs_version(nfs))
 104                 return ERR_PTR(-EAGAIN);
 105
 106         return nfs;
 107 }
 108
 109 int get_nfs_version(struct nfs_subversion *nfs)
 110 {
 111         return try_module_get(nfs->owner);
 112 }
 113 EXPORT_SYMBOL_GPL(get_nfs_version);
 114
 115 void put_nfs_version(struct nfs_subversion *nfs)
 116 {
 117         module_put(nfs->owner);
 118 }
 119
 120 void register_nfs_version(struct nfs_subversion *nfs)
 121 {
 122         write_lock(&nfs_version_lock);
 123
 124         nfs_version_mods[nfs->rpc_ops->version] = nfs;
 125         nfs_version[nfs->rpc_ops->version] = nfs->rpc_vers;
 126
 127         write_unlock(&nfs_version_lock);
 128 }
 129 EXPORT_SYMBOL_GPL(register_nfs_version);
 130
 131 void unregister_nfs_version(struct nfs_subversion *nfs)
 132 {
 133         write_lock(&nfs_version_lock);
 134
 135         nfs_version[nfs->rpc_ops->version] = NULL;
 136         nfs_version_mods[nfs->rpc_ops->version] = NULL;
 137
 138         write_unlock(&nfs_version_lock);
 139 }
 140 EXPORT_SYMBOL_GPL(unregister_nfs_version);
 141
 142 /*
 143  * Allocate a shared client record
 144  *
 145  * Since these are allocated/deallocated very rarely, we don't
 146  * bother putting them in a slab cache...
 147  */
 148 struct nfs_client *nfs_alloc_client(const struct nfs_client_initdata *cl_init)
 149 {
 150         struct nfs_client *clp;
 151         int err = -ENOMEM;
 152
 153         if ((clp = kzalloc(sizeof(*clp), GFP_KERNEL)) == NULL)
 154                 goto error_0;
 155
 156         clp->cl_minorversion = cl_init->minorversion;
 157         clp->cl_nfs_mod = cl_init->nfs_mod;
 158         if (!get_nfs_version(clp->cl_nfs_mod))
 159                 goto error_dealloc;
 160
 161         clp->rpc_ops = clp->cl_nfs_mod->rpc_ops;
 162
 163         refcount_set(&clp->cl_count, 1);
 164         clp->cl_cons_state = NFS_CS_INITING;
 165
 166         memcpy(&clp->cl_addr, cl_init->addr, cl_init->addrlen);
 167         clp->cl_addrlen = cl_init->addrlen;
 168
 169         if (cl_init->hostname) {
 170                 err = -ENOMEM;
 171                 clp->cl_hostname = kstrdup(cl_init->hostname, GFP_KERNEL);
 172                 if (!clp->cl_hostname)
 173                         goto error_cleanup;
 174         }
 175
 176         INIT_LIST_HEAD(&clp->cl_superblocks);
 177         clp->cl_rpcclient = ERR_PTR(-EINVAL);
 178
 179         clp->cl_flags = cl_init->init_flags;
 180         clp->cl_proto = cl_init->proto;
 181         clp->cl_nconnect = cl_init->nconnect;
 182         clp->cl_max_connect = cl_init->max_connect ? cl_init->max_connect : 1;
 183         clp->cl_net = get_net(cl_init->net);
 184
 185 #if IS_ENABLED(CONFIG_NFS_LOCALIO)
 186         seqlock_init(&clp->cl_boot_lock);
 187         ktime_get_real_ts64(&clp->cl_nfssvc_boot);
 188         nfs_uuid_init(&clp->cl_uuid);
 189         spin_lock_init(&clp->cl_localio_lock);
 190 #endif /* CONFIG_NFS_LOCALIO */
 191
 192         clp->cl_principal = "*";
 193         clp->cl_xprtsec = cl_init->xprtsec;
 194         return clp;
 195
 196 error_cleanup:
 197         put_nfs_version(clp->cl_nfs_mod);
 198 error_dealloc:
 199         kfree(clp);
 200 error_0:
 201         return ERR_PTR(err);
 202 }
 203 EXPORT_SYMBOL_GPL(nfs_alloc_client);
 204
 205 #if IS_ENABLED(CONFIG_NFS_V4)
 206 static void nfs_cleanup_cb_ident_idr(struct net *net)
 207 {
 208         struct nfs_net *nn = net_generic(net, nfs_net_id);
 209
 210         idr_destroy(&nn->cb_ident_idr);
 211 }
 212
 213 /* nfs_client_lock held */
 214 static void nfs_cb_idr_remove_locked(struct nfs_client *clp)
 215 {
 216         struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
 217
 218         if (clp->cl_cb_ident)
 219                 idr_remove(&nn->cb_ident_idr, clp->cl_cb_ident);
 220 }
 221
 222 static void pnfs_init_server(struct nfs_server *server)
 223 {
 224         rpc_init_wait_queue(&server->roc_rpcwaitq, "pNFS ROC");
 225 }
 226
 227 #else
 228 static void nfs_cleanup_cb_ident_idr(struct net *net)
 229 {
 230 }
 231
 232 static void nfs_cb_idr_remove_locked(struct nfs_client *clp)
 233 {
 234 }
 235
 236 static void pnfs_init_server(struct nfs_server *server)
 237 {
 238 }
 239
 240 #endif /* CONFIG_NFS_V4 */
 241
 242 /*
 243  * Destroy a shared client record
 244  */
 245 void nfs_free_client(struct nfs_client *clp)
 246 {
 247         nfs_local_disable(clp);
 248
 249         /* -EIO all pending I/O */
 250         if (!IS_ERR(clp->cl_rpcclient))
 251                 rpc_shutdown_client(clp->cl_rpcclient);
 252
 253         put_net(clp->cl_net);
 254         put_nfs_version(clp->cl_nfs_mod);
 255         kfree(clp->cl_hostname);
 256         kfree(clp->cl_acceptor);
 257         kfree_rcu(clp, rcu);
 258 }
 259 EXPORT_SYMBOL_GPL(nfs_free_client);
 260
 261 /*
 262  * Release a reference to a shared client record
 263  */
 264 void nfs_put_client(struct nfs_client *clp)
 265 {
 266         struct nfs_net *nn;
 267
 268         if (!clp)
 269                 return;
 270
 271         nn = net_generic(clp->cl_net, nfs_net_id);
 272
 273         if (refcount_dec_and_lock(&clp->cl_count, &nn->nfs_client_lock)) {
 274                 list_del(&clp->cl_share_link);
 275                 nfs_cb_idr_remove_locked(clp);
 276                 spin_unlock(&nn->nfs_client_lock);
 277
 278                 WARN_ON_ONCE(!list_empty(&clp->cl_superblocks));
 279
 280                 clp->rpc_ops->free_client(clp);
 281         }
 282 }
 283 EXPORT_SYMBOL_GPL(nfs_put_client);
 284
 285 /*
 286  * Find an nfs_client on the list that matches the initialisation data
 287  * that is supplied.
 288  */
 289 static struct nfs_client *nfs_match_client(const struct nfs_client_initdata *data)
 290 {
 291         struct nfs_client *clp;
 292         const struct sockaddr *sap = (struct sockaddr *)data->addr;
 293         struct nfs_net *nn = net_generic(data->net, nfs_net_id);
 294         int error;
 295
 296 again:
 297         list_for_each_entry(clp, &nn->nfs_client_list, cl_share_link) {
 298                 const struct sockaddr *clap = (struct sockaddr *)&clp->cl_addr;
 299                 /* Don't match clients that failed to initialise properly */
 300                 if (clp->cl_cons_state < 0)
 301                         continue;
 302
 303                 /* If a client is still initializing then we need to wait */
 304                 if (clp->cl_cons_state > NFS_CS_READY) {
 305                         refcount_inc(&clp->cl_count);
 306                         spin_unlock(&nn->nfs_client_lock);
 307                         error = nfs_wait_client_init_complete(clp);
 308                         nfs_put_client(clp);
 309                         spin_lock(&nn->nfs_client_lock);
 310                         if (error < 0)
 311                                 return ERR_PTR(error);
 312                         goto again;
 313                 }
 314
 315                 /* Different NFS versions cannot share the same nfs_client */
 316                 if (clp->rpc_ops != data->nfs_mod->rpc_ops)
 317                         continue;
 318
 319                 if (clp->cl_proto != data->proto)
 320                         continue;
 321                 /* Match nfsv4 minorversion */
 322                 if (clp->cl_minorversion != data->minorversion)
 323                         continue;
 324
 325                 /* Match request for a dedicated DS */
 326                 if (test_bit(NFS_CS_DS, &data->init_flags) !=
 327                     test_bit(NFS_CS_DS, &clp->cl_flags))
 328                         continue;
 329
 330                 /* Match the full socket address */
 331                 if (!rpc_cmp_addr_port(sap, clap))
 332                         /* Match all xprt_switch full socket addresses */
 333                         if (IS_ERR(clp->cl_rpcclient) ||
 334                             !rpc_clnt_xprt_switch_has_addr(clp->cl_rpcclient,
 335                                                            sap))
 336                                 continue;
 337
 338                 /* Match the xprt security policy */
 339                 if (clp->cl_xprtsec.policy != data->xprtsec.policy)
 340                         continue;
 341
 342                 refcount_inc(&clp->cl_count);
 343                 return clp;
 344         }
 345         return NULL;
 346 }
 347
 348 /*
 349  * Return true if @clp is done initializing, false if still working on it.
 350  *
 351  * Use nfs_client_init_status to check if it was successful.
 352  */
 353 bool nfs_client_init_is_complete(const struct nfs_client *clp)
 354 {
 355         return clp->cl_cons_state <= NFS_CS_READY;
 356 }
 357 EXPORT_SYMBOL_GPL(nfs_client_init_is_complete);
 358
 359 /*
 360  * Return 0 if @clp was successfully initialized, -errno otherwise.
 361  *
 362  * This must be called *after* nfs_client_init_is_complete() returns true,
 363  * otherwise it will pop WARN_ON_ONCE and return -EINVAL
 364  */
 365 int nfs_client_init_status(const struct nfs_client *clp)
 366 {
 367         /* called without checking nfs_client_init_is_complete */
 368         if (clp->cl_cons_state > NFS_CS_READY) {
 369                 WARN_ON_ONCE(1);
 370                 return -EINVAL;
 371         }
 372         return clp->cl_cons_state;
 373 }
 374 EXPORT_SYMBOL_GPL(nfs_client_init_status);
 375
 376 int nfs_wait_client_init_complete(const struct nfs_client *clp)
 377 {
 378         return wait_event_killable(nfs_client_active_wq,
 379                         nfs_client_init_is_complete(clp));
 380 }
 381 EXPORT_SYMBOL_GPL(nfs_wait_client_init_complete);
 382
 383 /*
 384  * Found an existing client.  Make sure it's ready before returning.
 385  */
 386 static struct nfs_client *
 387 nfs_found_client(const struct nfs_client_initdata *cl_init,
 388                  struct nfs_client *clp)
 389 {
 390         int error;
 391
 392         error = nfs_wait_client_init_complete(clp);
 393         if (error < 0) {
 394                 nfs_put_client(clp);
 395                 return ERR_PTR(-ERESTARTSYS);
 396         }
 397
 398         if (clp->cl_cons_state < NFS_CS_READY) {
 399                 error = clp->cl_cons_state;
 400                 nfs_put_client(clp);
 401                 return ERR_PTR(error);
 402         }
 403
 404         smp_rmb();
 405         return clp;
 406 }
 407
 408 /*
 409  * Look up a client by IP address and protocol version
 410  * - creates a new record if one doesn't yet exist
 411  */
 412 struct nfs_client *nfs_get_client(const struct nfs_client_initdata *cl_init)
 413 {
 414         struct nfs_client *clp, *new = NULL;
 415         struct nfs_net *nn = net_generic(cl_init->net, nfs_net_id);
 416         const struct nfs_rpc_ops *rpc_ops = cl_init->nfs_mod->rpc_ops;
 417
 418         if (cl_init->hostname == NULL) {
 419                 WARN_ON(1);
 420                 return ERR_PTR(-EINVAL);
 421         }
 422
 423         /* see if the client already exists */
 424         do {
 425                 spin_lock(&nn->nfs_client_lock);
 426
 427                 clp = nfs_match_client(cl_init);
 428                 if (clp) {
 429                         spin_unlock(&nn->nfs_client_lock);
 430                         if (new)
 431                                 new->rpc_ops->free_client(new);
 432                         if (IS_ERR(clp))
 433                                 return clp;
 434                         return nfs_found_client(cl_init, clp);
 435                 }
 436                 if (new) {
 437                         list_add_tail(&new->cl_share_link,
 438                                         &nn->nfs_client_list);
 439                         spin_unlock(&nn->nfs_client_lock);
 440                         new = rpc_ops->init_client(new, cl_init);
 441                         if (!IS_ERR(new))
 442                                  nfs_local_probe(new);
 443                         return new;
 444                 }
 445
 446                 spin_unlock(&nn->nfs_client_lock);
 447
 448                 new = rpc_ops->alloc_client(cl_init);
 449         } while (!IS_ERR(new));
 450
 451         return new;
 452 }
 453 EXPORT_SYMBOL_GPL(nfs_get_client);
 454
 455 /*
 456  * Mark a server as ready or failed
 457  */
 458 void nfs_mark_client_ready(struct nfs_client *clp, int state)
 459 {
 460         smp_wmb();
 461         clp->cl_cons_state = state;
 462         wake_up_all(&nfs_client_active_wq);
 463 }
 464 EXPORT_SYMBOL_GPL(nfs_mark_client_ready);
 465
 466 /*
 467  * Initialise the timeout values for a connection
 468  */
 469 void nfs_init_timeout_values(struct rpc_timeout *to, int proto,
 470                                     int timeo, int retrans)
 471 {
 472         to->to_initval = timeo * HZ / 10;
 473         to->to_retries = retrans;
 474
 475         switch (proto) {
 476         case XPRT_TRANSPORT_TCP:
 477         case XPRT_TRANSPORT_TCP_TLS:
 478         case XPRT_TRANSPORT_RDMA:
 479                 if (retrans == NFS_UNSPEC_RETRANS)
 480                         to->to_retries = NFS_DEF_TCP_RETRANS;
 481                 if (timeo == NFS_UNSPEC_TIMEO || to->to_initval == 0)
 482                         to->to_initval = NFS_DEF_TCP_TIMEO * HZ / 10;
 483                 if (to->to_initval > NFS_MAX_TCP_TIMEOUT)
 484                         to->to_initval = NFS_MAX_TCP_TIMEOUT;
 485                 to->to_increment = to->to_initval;
 486                 to->to_maxval = to->to_initval + (to->to_increment * to->to_retries);
 487                 if (to->to_maxval > NFS_MAX_TCP_TIMEOUT)
 488                         to->to_maxval = NFS_MAX_TCP_TIMEOUT;
 489                 if (to->to_maxval < to->to_initval)
 490                         to->to_maxval = to->to_initval;
 491                 to->to_exponential = 0;
 492                 break;
 493         case XPRT_TRANSPORT_UDP:
 494                 if (retrans == NFS_UNSPEC_RETRANS)
 495                         to->to_retries = NFS_DEF_UDP_RETRANS;
 496                 if (timeo == NFS_UNSPEC_TIMEO || to->to_initval == 0)
 497                         to->to_initval = NFS_DEF_UDP_TIMEO * HZ / 10;
 498                 if (to->to_initval > NFS_MAX_UDP_TIMEOUT)
 499                         to->to_initval = NFS_MAX_UDP_TIMEOUT;
 500                 to->to_maxval = NFS_MAX_UDP_TIMEOUT;
 501                 to->to_exponential = 1;
 502                 break;
 503         default:
 504                 BUG();
 505         }
 506 }
 507 EXPORT_SYMBOL_GPL(nfs_init_timeout_values);
 508
 509 /*
 510  * Create an RPC client handle
 511  */
 512 int nfs_create_rpc_client(struct nfs_client *clp,
 513                           const struct nfs_client_initdata *cl_init,
 514                           rpc_authflavor_t flavor)
 515 {
 516         struct nfs_net          *nn = net_generic(clp->cl_net, nfs_net_id);
 517         struct rpc_clnt         *clnt = NULL;
 518         struct rpc_create_args args = {
 519                 .net            = clp->cl_net,
 520                 .protocol       = clp->cl_proto,
 521                 .nconnect       = clp->cl_nconnect,
 522                 .address        = (struct sockaddr *)&clp->cl_addr,
 523                 .addrsize       = clp->cl_addrlen,
 524                 .timeout        = cl_init->timeparms,
 525                 .servername     = clp->cl_hostname,
 526                 .nodename       = cl_init->nodename,
 527                 .program        = &nfs_program,
 528                 .stats          = &nn->rpcstats,
 529                 .version        = clp->rpc_ops->version,
 530                 .authflavor     = flavor,
 531                 .cred           = cl_init->cred,
 532                 .xprtsec        = cl_init->xprtsec,
 533                 .connect_timeout = cl_init->connect_timeout,
 534                 .reconnect_timeout = cl_init->reconnect_timeout,
 535         };
 536
 537         if (test_bit(NFS_CS_DISCRTRY, &clp->cl_flags))
 538                 args.flags |= RPC_CLNT_CREATE_DISCRTRY;
 539         if (test_bit(NFS_CS_NO_RETRANS_TIMEOUT, &clp->cl_flags))
 540                 args.flags |= RPC_CLNT_CREATE_NO_RETRANS_TIMEOUT;
 541         if (test_bit(NFS_CS_NORESVPORT, &clp->cl_flags))
 542                 args.flags |= RPC_CLNT_CREATE_NONPRIVPORT;
 543         if (test_bit(NFS_CS_INFINITE_SLOTS, &clp->cl_flags))
 544                 args.flags |= RPC_CLNT_CREATE_INFINITE_SLOTS;
 545         if (test_bit(NFS_CS_NOPING, &clp->cl_flags))
 546                 args.flags |= RPC_CLNT_CREATE_NOPING;
 547         if (test_bit(NFS_CS_REUSEPORT, &clp->cl_flags))
 548                 args.flags |= RPC_CLNT_CREATE_REUSEPORT;
 549
 550         if (!IS_ERR(clp->cl_rpcclient))
 551                 return 0;
 552
 553         clnt = rpc_create(&args);
 554         if (IS_ERR(clnt)) {
 555                 dprintk("%s: cannot create RPC client. Error = %ld\n",
 556                                 __func__, PTR_ERR(clnt));
 557                 return PTR_ERR(clnt);
 558         }
 559
 560         clnt->cl_principal = clp->cl_principal;
 561         clp->cl_rpcclient = clnt;
 562         clnt->cl_max_connect = clp->cl_max_connect;
 563         return 0;
 564 }
 565 EXPORT_SYMBOL_GPL(nfs_create_rpc_client);
 566
 567 /*
 568  * Version 2 or 3 client destruction
 569  */
 570 static void nfs_destroy_server(struct nfs_server *server)
 571 {
 572         if (server->nlm_host)
 573                 nlmclnt_done(server->nlm_host);
 574 }
 575
 576 /*
 577  * Version 2 or 3 lockd setup
 578  */
 579 static int nfs_start_lockd(struct nfs_server *server)
 580 {
 581         struct nlm_host *host;
 582         struct nfs_client *clp = server->nfs_client;
 583         struct nlmclnt_initdata nlm_init = {
 584                 .hostname       = clp->cl_hostname,
 585                 .address        = (struct sockaddr *)&clp->cl_addr,
 586                 .addrlen        = clp->cl_addrlen,
 587                 .nfs_version    = clp->rpc_ops->version,
 588                 .noresvport     = server->flags & NFS_MOUNT_NORESVPORT ?
 589                                         1 : 0,
 590                 .net            = clp->cl_net,
 591                 .nlmclnt_ops    = clp->cl_nfs_mod->rpc_ops->nlmclnt_ops,
 592                 .cred           = server->cred,
 593         };
 594
 595         if (nlm_init.nfs_version > 3)
 596                 return 0;
 597         if ((server->flags & NFS_MOUNT_LOCAL_FLOCK) &&
 598                         (server->flags & NFS_MOUNT_LOCAL_FCNTL))
 599                 return 0;
 600
 601         switch (clp->cl_proto) {
 602                 default:
 603                         nlm_init.protocol = IPPROTO_TCP;
 604                         break;
 605 #ifndef CONFIG_NFS_DISABLE_UDP_SUPPORT
 606                 case XPRT_TRANSPORT_UDP:
 607                         nlm_init.protocol = IPPROTO_UDP;
 608 #endif
 609         }
 610
 611         host = nlmclnt_init(&nlm_init);
 612         if (IS_ERR(host))
 613                 return PTR_ERR(host);
 614
 615         server->nlm_host = host;
 616         server->destroy = nfs_destroy_server;
 617         nfs_sysfs_link_rpc_client(server, nlmclnt_rpc_clnt(host), NULL);
 618         return 0;
 619 }
 620
 621 /*
 622  * Create a general RPC client
 623  */
 624 int nfs_init_server_rpcclient(struct nfs_server *server,
 625                 const struct rpc_timeout *timeo,
 626                 rpc_authflavor_t pseudoflavour)
 627 {
 628         struct nfs_client *clp = server->nfs_client;
 629
 630         server->client = rpc_clone_client_set_auth(clp->cl_rpcclient,
 631                                                         pseudoflavour);
 632         if (IS_ERR(server->client)) {
 633                 dprintk("%s: couldn't create rpc_client!\n", __func__);
 634                 return PTR_ERR(server->client);
 635         }
 636
 637         memcpy(&server->client->cl_timeout_default,
 638                         timeo,
 639                         sizeof(server->client->cl_timeout_default));
 640         server->client->cl_timeout = &server->client->cl_timeout_default;
 641         server->client->cl_softrtry = 0;
 642         if (server->flags & NFS_MOUNT_SOFTERR)
 643                 server->client->cl_softerr = 1;
 644         if (server->flags & NFS_MOUNT_SOFT)
 645                 server->client->cl_softrtry = 1;
 646
 647         nfs_sysfs_link_rpc_client(server, server->client, NULL);
 648         return 0;
 649 }
 650 EXPORT_SYMBOL_GPL(nfs_init_server_rpcclient);
 651
 652 /**
 653  * nfs_init_client - Initialise an NFS2 or NFS3 client
 654  *
 655  * @clp: nfs_client to initialise
 656  * @cl_init: Initialisation parameters
 657  *
 658  * Returns pointer to an NFS client, or an ERR_PTR value.
 659  */
 660 struct nfs_client *nfs_init_client(struct nfs_client *clp,
 661                                    const struct nfs_client_initdata *cl_init)
 662 {
 663         int error;
 664
 665         /* the client is already initialised */
 666         if (clp->cl_cons_state == NFS_CS_READY)
 667                 return clp;
 668
 669         /*
 670          * Create a client RPC handle for doing FSSTAT with UNIX auth only
 671          * - RFC 2623, sec 2.3.2
 672          */
 673         error = nfs_create_rpc_client(clp, cl_init, RPC_AUTH_UNIX);
 674         nfs_mark_client_ready(clp, error == 0 ? NFS_CS_READY : error);
 675         if (error < 0) {
 676                 nfs_put_client(clp);
 677                 clp = ERR_PTR(error);
 678         }
 679         return clp;
 680 }
 681 EXPORT_SYMBOL_GPL(nfs_init_client);
 682
 683 /*
 684  * Create a version 2 or 3 client
 685  */
 686 static int nfs_init_server(struct nfs_server *server,
 687                            const struct fs_context *fc)
 688 {
 689         const struct nfs_fs_context *ctx = nfs_fc2context(fc);
 690         struct rpc_timeout timeparms;
 691         struct nfs_client_initdata cl_init = {
 692                 .hostname = ctx->nfs_server.hostname,
 693                 .addr = &ctx->nfs_server._address,
 694                 .addrlen = ctx->nfs_server.addrlen,
 695                 .nfs_mod = ctx->nfs_mod,
 696                 .proto = ctx->nfs_server.protocol,
 697                 .net = fc->net_ns,
 698                 .timeparms = &timeparms,
 699                 .cred = server->cred,
 700                 .nconnect = ctx->nfs_server.nconnect,
 701                 .init_flags = (1UL << NFS_CS_REUSEPORT),
 702                 .xprtsec = ctx->xprtsec,
 703         };
 704         struct nfs_client *clp;
 705         int error;
 706
 707         nfs_init_timeout_values(&timeparms, ctx->nfs_server.protocol,
 708                                 ctx->timeo, ctx->retrans);
 709         if (ctx->flags & NFS_MOUNT_NORESVPORT)
 710                 set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags);
 711
 712         /* Allocate or find a client reference we can use */
 713         clp = nfs_get_client(&cl_init);
 714         if (IS_ERR(clp))
 715                 return PTR_ERR(clp);
 716
 717         server->nfs_client = clp;
 718         nfs_sysfs_add_server(server);
 719         nfs_sysfs_link_rpc_client(server, clp->cl_rpcclient, "_state");
 720
 721         /* Initialise the client representation from the mount data */
 722         server->flags = ctx->flags;
 723         server->options = ctx->options;
 724         server->caps |= NFS_CAP_HARDLINKS | NFS_CAP_SYMLINKS;
 725
 726         switch (clp->rpc_ops->version) {
 727         case 2:
 728                 server->fattr_valid = NFS_ATTR_FATTR_V2;
 729                 break;
 730         case 3:
 731                 server->fattr_valid = NFS_ATTR_FATTR_V3;
 732                 break;
 733         default:
 734                 server->fattr_valid = NFS_ATTR_FATTR_V4;
 735         }
 736
 737         if (ctx->rsize)
 738                 server->rsize = nfs_io_size(ctx->rsize, clp->cl_proto);
 739         if (ctx->wsize)
 740                 server->wsize = nfs_io_size(ctx->wsize, clp->cl_proto);
 741
 742         server->acregmin = ctx->acregmin * HZ;
 743         server->acregmax = ctx->acregmax * HZ;
 744         server->acdirmin = ctx->acdirmin * HZ;
 745         server->acdirmax = ctx->acdirmax * HZ;
 746
 747         /* Start lockd here, before we might error out */
 748         error = nfs_start_lockd(server);
 749         if (error < 0)
 750                 goto error;
 751
 752         server->port = ctx->nfs_server.port;
 753         server->auth_info = ctx->auth_info;
 754
 755         error = nfs_init_server_rpcclient(server, &timeparms,
 756                                           ctx->selected_flavor);
 757         if (error < 0)
 758                 goto error;
 759
 760         /* Preserve the values of mount_server-related mount options */
 761         if (ctx->mount_server.addrlen) {
 762                 memcpy(&server->mountd_address, &ctx->mount_server.address,
 763                         ctx->mount_server.addrlen);
 764                 server->mountd_addrlen = ctx->mount_server.addrlen;
 765         }
 766         server->mountd_version = ctx->mount_server.version;
 767         server->mountd_port = ctx->mount_server.port;
 768         server->mountd_protocol = ctx->mount_server.protocol;
 769
 770         server->namelen  = ctx->namlen;
 771         return 0;
 772
 773 error:
 774         server->nfs_client = NULL;
 775         nfs_put_client(clp);
 776         return error;
 777 }
 778
 779 /*
 780  * Load up the server record from information gained in an fsinfo record
 781  */
 782 static void nfs_server_set_fsinfo(struct nfs_server *server,
 783                                   struct nfs_fsinfo *fsinfo)
 784 {
 785         struct nfs_client *clp = server->nfs_client;
 786         unsigned long max_rpc_payload, raw_max_rpc_payload;
 787
 788         /* Work out a lot of parameters */
 789         if (server->rsize == 0)
 790                 server->rsize = nfs_io_size(fsinfo->rtpref, clp->cl_proto);
 791         if (server->wsize == 0)
 792                 server->wsize = nfs_io_size(fsinfo->wtpref, clp->cl_proto);
 793
 794         if (fsinfo->rtmax >= 512 && server->rsize > fsinfo->rtmax)
 795                 server->rsize = nfs_io_size(fsinfo->rtmax, clp->cl_proto);
 796         if (fsinfo->wtmax >= 512 && server->wsize > fsinfo->wtmax)
 797                 server->wsize = nfs_io_size(fsinfo->wtmax, clp->cl_proto);
 798
 799         raw_max_rpc_payload = rpc_max_payload(server->client);
 800         max_rpc_payload = nfs_block_size(raw_max_rpc_payload, NULL);
 801
 802         if (server->rsize > max_rpc_payload)
 803                 server->rsize = max_rpc_payload;
 804         if (server->rsize > NFS_MAX_FILE_IO_SIZE)
 805                 server->rsize = NFS_MAX_FILE_IO_SIZE;
 806         server->rpages = (server->rsize + PAGE_SIZE - 1) >> PAGE_SHIFT;
 807
 808         if (server->wsize > max_rpc_payload)
 809                 server->wsize = max_rpc_payload;
 810         if (server->wsize > NFS_MAX_FILE_IO_SIZE)
 811                 server->wsize = NFS_MAX_FILE_IO_SIZE;
 812         server->wpages = (server->wsize + PAGE_SIZE - 1) >> PAGE_SHIFT;
 813
 814         server->wtmult = nfs_block_bits(fsinfo->wtmult, NULL);
 815
 816         server->dtsize = nfs_block_size(fsinfo->dtpref, NULL);
 817         if (server->dtsize > NFS_MAX_FILE_IO_SIZE)
 818                 server->dtsize = NFS_MAX_FILE_IO_SIZE;
 819         if (server->dtsize > server->rsize)
 820                 server->dtsize = server->rsize;
 821
 822         if (server->flags & NFS_MOUNT_NOAC) {
 823                 server->acregmin = server->acregmax = 0;
 824                 server->acdirmin = server->acdirmax = 0;
 825         }
 826
 827         server->maxfilesize = fsinfo->maxfilesize;
 828
 829         server->time_delta = fsinfo->time_delta;
 830         server->change_attr_type = fsinfo->change_attr_type;
 831
 832         server->clone_blksize = fsinfo->clone_blksize;
 833         /* We're airborne Set socket buffersize */
 834         rpc_setbufsize(server->client, server->wsize + 100, server->rsize + 100);
 835
 836 #ifdef CONFIG_NFS_V4_2
 837         /*
 838          * Defaults until limited by the session parameters.
 839          */
 840         server->gxasize = min_t(unsigned int, raw_max_rpc_payload,
 841                                 XATTR_SIZE_MAX);
 842         server->sxasize = min_t(unsigned int, raw_max_rpc_payload,
 843                                 XATTR_SIZE_MAX);
 844         server->lxasize = min_t(unsigned int, raw_max_rpc_payload,
 845                                 nfs42_listxattr_xdrsize(XATTR_LIST_MAX));
 846
 847         if (fsinfo->xattr_support)
 848                 server->caps |= NFS_CAP_XATTR;
 849 #endif
 850 }
 851
 852 /*
 853  * Probe filesystem information, including the FSID on v2/v3
 854  */
 855 static int nfs_probe_fsinfo(struct nfs_server *server, struct nfs_fh *mntfh, struct nfs_fattr *fattr)
 856 {
 857         struct nfs_fsinfo fsinfo;
 858         struct nfs_client *clp = server->nfs_client;
 859         int error;
 860
 861         if (clp->rpc_ops->set_capabilities != NULL) {
 862                 error = clp->rpc_ops->set_capabilities(server, mntfh);
 863                 if (error < 0)
 864                         return error;
 865         }
 866
 867         fsinfo.fattr = fattr;
 868         fsinfo.nlayouttypes = 0;
 869         memset(fsinfo.layouttype, 0, sizeof(fsinfo.layouttype));
 870         error = clp->rpc_ops->fsinfo(server, mntfh, &fsinfo);
 871         if (error < 0)
 872                 return error;
 873
 874         nfs_server_set_fsinfo(server, &fsinfo);
 875
 876         /* Get some general file system info */
 877         if (server->namelen == 0) {
 878                 struct nfs_pathconf pathinfo;
 879
 880                 pathinfo.fattr = fattr;
 881                 nfs_fattr_init(fattr);
 882
 883                 if (clp->rpc_ops->pathconf(server, mntfh, &pathinfo) >= 0)
 884                         server->namelen = pathinfo.max_namelen;
 885         }
 886
 887         if (clp->rpc_ops->discover_trunking != NULL &&
 888                         (server->caps & NFS_CAP_FS_LOCATIONS &&
 889                          (server->flags & NFS_MOUNT_TRUNK_DISCOVERY))) {
 890                 error = clp->rpc_ops->discover_trunking(server, mntfh);
 891                 if (error < 0)
 892                         return error;
 893         }
 894
 895         return 0;
 896 }
 897
 898 /*
 899  * Grab the destination's particulars, including lease expiry time.
 900  *
 901  * Returns zero if probe succeeded and retrieved FSID matches the FSID
 902  * we have cached.
 903  */
 904 int nfs_probe_server(struct nfs_server *server, struct nfs_fh *mntfh)
 905 {
 906         struct nfs_fattr *fattr;
 907         int error;
 908
 909         fattr = nfs_alloc_fattr();
 910         if (fattr == NULL)
 911                 return -ENOMEM;
 912
 913         /* Sanity: the probe won't work if the destination server
 914          * does not recognize the migrated FH. */
 915         error = nfs_probe_fsinfo(server, mntfh, fattr);
 916
 917         nfs_free_fattr(fattr);
 918         return error;
 919 }
 920 EXPORT_SYMBOL_GPL(nfs_probe_server);
 921
 922 /*
 923  * Copy useful information when duplicating a server record
 924  */
 925 void nfs_server_copy_userdata(struct nfs_server *target, struct nfs_server *source)
 926 {
 927         target->flags = source->flags;
 928         target->rsize = source->rsize;
 929         target->wsize = source->wsize;
 930         target->acregmin = source->acregmin;
 931         target->acregmax = source->acregmax;
 932         target->acdirmin = source->acdirmin;
 933         target->acdirmax = source->acdirmax;
 934         target->caps = source->caps;
 935         target->options = source->options;
 936         target->auth_info = source->auth_info;
 937         target->port = source->port;
 938 }
 939 EXPORT_SYMBOL_GPL(nfs_server_copy_userdata);
 940
 941 void nfs_server_insert_lists(struct nfs_server *server)
 942 {
 943         struct nfs_client *clp = server->nfs_client;
 944         struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
 945
 946         spin_lock(&nn->nfs_client_lock);
 947         list_add_tail_rcu(&server->client_link, &clp->cl_superblocks);
 948         list_add_tail(&server->master_link, &nn->nfs_volume_list);
 949         clear_bit(NFS_CS_STOP_RENEW, &clp->cl_res_state);
 950         spin_unlock(&nn->nfs_client_lock);
 951
 952 }
 953 EXPORT_SYMBOL_GPL(nfs_server_insert_lists);
 954
 955 void nfs_server_remove_lists(struct nfs_server *server)
 956 {
 957         struct nfs_client *clp = server->nfs_client;
 958         struct nfs_net *nn;
 959
 960         if (clp == NULL)
 961                 return;
 962         nn = net_generic(clp->cl_net, nfs_net_id);
 963         spin_lock(&nn->nfs_client_lock);
 964         list_del_rcu(&server->client_link);
 965         if (list_empty(&clp->cl_superblocks))
 966                 set_bit(NFS_CS_STOP_RENEW, &clp->cl_res_state);
 967         list_del(&server->master_link);
 968         spin_unlock(&nn->nfs_client_lock);
 969
 970         synchronize_rcu();
 971 }
 972 EXPORT_SYMBOL_GPL(nfs_server_remove_lists);
 973
 974 static DEFINE_IDA(s_sysfs_ids);
 975
 976 /*
 977  * Allocate and initialise a server record
 978  */
 979 struct nfs_server *nfs_alloc_server(void)
 980 {
 981         struct nfs_server *server;
 982
 983         server = kzalloc(sizeof(struct nfs_server), GFP_KERNEL);
 984         if (!server)
 985                 return NULL;
 986
 987         server->s_sysfs_id = ida_alloc(&s_sysfs_ids, GFP_KERNEL);
 988         if (server->s_sysfs_id < 0) {
 989                 kfree(server);
 990                 return NULL;
 991         }
 992
 993         server->client = server->client_acl = ERR_PTR(-EINVAL);
 994
 995         /* Zero out the NFS state stuff */
 996         INIT_LIST_HEAD(&server->client_link);
 997         INIT_LIST_HEAD(&server->master_link);
 998         INIT_LIST_HEAD(&server->delegations);
 999         INIT_LIST_HEAD(&server->layouts);
1000         INIT_LIST_HEAD(&server->state_owners_lru);
1001         INIT_LIST_HEAD(&server->ss_copies);
1002         INIT_LIST_HEAD(&server->ss_src_copies);
1003
1004         atomic_set(&server->active, 0);
1005
1006         server->io_stats = nfs_alloc_iostats();
1007         if (!server->io_stats) {
1008                 kfree(server);
1009                 return NULL;
1010         }
1011
1012         server->change_attr_type = NFS4_CHANGE_TYPE_IS_UNDEFINED;
1013
1014         init_waitqueue_head(&server->write_congestion_wait);
1015         atomic_long_set(&server->writeback, 0);
1016
1017         atomic64_set(&server->owner_ctr, 0);
1018
1019         pnfs_init_server(server);
1020         rpc_init_wait_queue(&server->uoc_rpcwaitq, "NFS UOC");
1021
1022         return server;
1023 }
1024 EXPORT_SYMBOL_GPL(nfs_alloc_server);
1025
1026 static void delayed_free(struct rcu_head *p)
1027 {
1028         struct nfs_server *server = container_of(p, struct nfs_server, rcu);
1029
1030         nfs_free_iostats(server->io_stats);
1031         kfree(server);
1032 }
1033
1034 /*
1035  * Free up a server record
1036  */
1037 void nfs_free_server(struct nfs_server *server)
1038 {
1039         nfs_server_remove_lists(server);
1040
1041         if (server->destroy != NULL)
1042                 server->destroy(server);
1043
1044         if (!IS_ERR(server->client_acl))
1045                 rpc_shutdown_client(server->client_acl);
1046         if (!IS_ERR(server->client))
1047                 rpc_shutdown_client(server->client);
1048
1049         nfs_put_client(server->nfs_client);
1050
1051         if (server->kobj.state_initialized) {
1052                 nfs_sysfs_remove_server(server);
1053                 kobject_put(&server->kobj);
1054         }
1055         ida_free(&s_sysfs_ids, server->s_sysfs_id);
1056
1057         put_cred(server->cred);
1058         nfs_release_automount_timer();
1059         call_rcu(&server->rcu, delayed_free);
1060 }
1061 EXPORT_SYMBOL_GPL(nfs_free_server);
1062
1063 /*
1064  * Create a version 2 or 3 volume record
1065  * - keyed on server and FSID
1066  */
1067 struct nfs_server *nfs_create_server(struct fs_context *fc)
1068 {
1069         struct nfs_fs_context *ctx = nfs_fc2context(fc);
1070         struct nfs_server *server;
1071         struct nfs_fattr *fattr;
1072         int error;
1073
1074         server = nfs_alloc_server();
1075         if (!server)
1076                 return ERR_PTR(-ENOMEM);
1077
1078         server->cred = get_cred(fc->cred);
1079
1080         error = -ENOMEM;
1081         fattr = nfs_alloc_fattr();
1082         if (fattr == NULL)
1083                 goto error;
1084
1085         /* Get a client representation */
1086         error = nfs_init_server(server, fc);
1087         if (error < 0)
1088                 goto error;
1089
1090         /* Probe the root fh to retrieve its FSID */
1091         error = nfs_probe_fsinfo(server, ctx->mntfh, fattr);
1092         if (error < 0)
1093                 goto error;
1094         if (server->nfs_client->rpc_ops->version == 3) {
1095                 if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN)
1096                         server->namelen = NFS3_MAXNAMLEN;
1097                 if (!(ctx->flags & NFS_MOUNT_NORDIRPLUS))
1098                         server->caps |= NFS_CAP_READDIRPLUS;
1099         } else {
1100                 if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)
1101                         server->namelen = NFS2_MAXNAMLEN;
1102         }
1103
1104         if (!(fattr->valid & NFS_ATTR_FATTR)) {
1105                 error = ctx->nfs_mod->rpc_ops->getattr(server, ctx->mntfh,
1106                                                        fattr, NULL);
1107                 if (error < 0) {
1108                         dprintk("nfs_create_server: getattr error = %d\n", -error);
1109                         goto error;
1110                 }
1111         }
1112         memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));
1113
1114         dprintk("Server FSID: %llx:%llx\n",
1115                 (unsigned long long) server->fsid.major,
1116                 (unsigned long long) server->fsid.minor);
1117
1118         nfs_server_insert_lists(server);
1119         server->mount_time = jiffies;
1120         nfs_free_fattr(fattr);
1121         return server;
1122
1123 error:
1124         nfs_free_fattr(fattr);
1125         nfs_free_server(server);
1126         return ERR_PTR(error);
1127 }
1128 EXPORT_SYMBOL_GPL(nfs_create_server);
1129
1130 /*
1131  * Clone an NFS2, NFS3 or NFS4 server record
1132  */
1133 struct nfs_server *nfs_clone_server(struct nfs_server *source,
1134                                     struct nfs_fh *fh,
1135                                     struct nfs_fattr *fattr,
1136                                     rpc_authflavor_t flavor)
1137 {
1138         struct nfs_server *server;
1139         int error;
1140
1141         server = nfs_alloc_server();
1142         if (!server)
1143                 return ERR_PTR(-ENOMEM);
1144
1145         server->cred = get_cred(source->cred);
1146
1147         /* Copy data from the source */
1148         server->nfs_client = source->nfs_client;
1149         server->destroy = source->destroy;
1150         refcount_inc(&server->nfs_client->cl_count);
1151         nfs_server_copy_userdata(server, source);
1152
1153         server->fsid = fattr->fsid;
1154
1155         nfs_sysfs_add_server(server);
1156
1157         nfs_sysfs_link_rpc_client(server,
1158                 server->nfs_client->cl_rpcclient, "_state");
1159
1160         error = nfs_init_server_rpcclient(server,
1161                         source->client->cl_timeout,
1162                         flavor);
1163         if (error < 0)
1164                 goto out_free_server;
1165
1166         /* probe the filesystem info for this server filesystem */
1167         error = nfs_probe_server(server, fh);
1168         if (error < 0)
1169                 goto out_free_server;
1170
1171         if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN)
1172                 server->namelen = NFS4_MAXNAMLEN;
1173
1174         error = nfs_start_lockd(server);
1175         if (error < 0)
1176                 goto out_free_server;
1177
1178         nfs_server_insert_lists(server);
1179         server->mount_time = jiffies;
1180
1181         return server;
1182
1183 out_free_server:
1184         nfs_free_server(server);
1185         return ERR_PTR(error);
1186 }
1187 EXPORT_SYMBOL_GPL(nfs_clone_server);
1188
1189 void nfs_clients_init(struct net *net)
1190 {
1191         struct nfs_net *nn = net_generic(net, nfs_net_id);
1192
1193         INIT_LIST_HEAD(&nn->nfs_client_list);
1194         INIT_LIST_HEAD(&nn->nfs_volume_list);
1195 #if IS_ENABLED(CONFIG_NFS_V4)
1196         idr_init(&nn->cb_ident_idr);
1197 #endif
1198         spin_lock_init(&nn->nfs_client_lock);
1199         nn->boot_time = ktime_get_real();
1200         memset(&nn->rpcstats, 0, sizeof(nn->rpcstats));
1201         nn->rpcstats.program = &nfs_program;
1202
1203         nfs_netns_sysfs_setup(nn, net);
1204 }
1205
1206 void nfs_clients_exit(struct net *net)
1207 {
1208         struct nfs_net *nn = net_generic(net, nfs_net_id);
1209
1210         nfs_netns_sysfs_destroy(nn);
1211         nfs_cleanup_cb_ident_idr(net);
1212         WARN_ON_ONCE(!list_empty(&nn->nfs_client_list));
1213         WARN_ON_ONCE(!list_empty(&nn->nfs_volume_list));
1214 }
1215
1216 #ifdef CONFIG_PROC_FS
1217 static void *nfs_server_list_start(struct seq_file *p, loff_t *pos);
1218 static void *nfs_server_list_next(struct seq_file *p, void *v, loff_t *pos);
1219 static void nfs_server_list_stop(struct seq_file *p, void *v);
1220 static int nfs_server_list_show(struct seq_file *m, void *v);
1221
1222 static const struct seq_operations nfs_server_list_ops = {
1223         .start  = nfs_server_list_start,
1224         .next   = nfs_server_list_next,
1225         .stop   = nfs_server_list_stop,
1226         .show   = nfs_server_list_show,
1227 };
1228
1229 static void *nfs_volume_list_start(struct seq_file *p, loff_t *pos);
1230 static void *nfs_volume_list_next(struct seq_file *p, void *v, loff_t *pos);
1231 static void nfs_volume_list_stop(struct seq_file *p, void *v);
1232 static int nfs_volume_list_show(struct seq_file *m, void *v);
1233
1234 static const struct seq_operations nfs_volume_list_ops = {
1235         .start  = nfs_volume_list_start,
1236         .next   = nfs_volume_list_next,
1237         .stop   = nfs_volume_list_stop,
1238         .show   = nfs_volume_list_show,
1239 };
1240
1241 /*
1242  * set up the iterator to start reading from the server list and return the first item
1243  */
1244 static void *nfs_server_list_start(struct seq_file *m, loff_t *_pos)
1245                                 __acquires(&nn->nfs_client_lock)
1246 {
1247         struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id);
1248
1249         /* lock the list against modification */
1250         spin_lock(&nn->nfs_client_lock);
1251         return seq_list_start_head(&nn->nfs_client_list, *_pos);
1252 }
1253
1254 /*
1255  * move to next server
1256  */
1257 static void *nfs_server_list_next(struct seq_file *p, void *v, loff_t *pos)
1258 {
1259         struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id);
1260
1261         return seq_list_next(v, &nn->nfs_client_list, pos);
1262 }
1263
1264 /*
1265  * clean up after reading from the transports list
1266  */
1267 static void nfs_server_list_stop(struct seq_file *p, void *v)
1268                                 __releases(&nn->nfs_client_lock)
1269 {
1270         struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id);
1271
1272         spin_unlock(&nn->nfs_client_lock);
1273 }
1274
1275 /*
1276  * display a header line followed by a load of call lines
1277  */
1278 static int nfs_server_list_show(struct seq_file *m, void *v)
1279 {
1280         struct nfs_client *clp;
1281         struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id);
1282
1283         /* display header on line 1 */
1284         if (v == &nn->nfs_client_list) {
1285                 seq_puts(m, "NV SERVER   PORT USE HOSTNAME\n");
1286                 return 0;
1287         }
1288
1289         /* display one transport per line on subsequent lines */
1290         clp = list_entry(v, struct nfs_client, cl_share_link);
1291
1292         /* Check if the client is initialized */
1293         if (clp->cl_cons_state != NFS_CS_READY)
1294                 return 0;
1295
1296         rcu_read_lock();
1297         seq_printf(m, "v%u %s %s %3d %s\n",
1298                    clp->rpc_ops->version,
1299                    rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_ADDR),
1300                    rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_PORT),
1301                    refcount_read(&clp->cl_count),
1302                    clp->cl_hostname);
1303         rcu_read_unlock();
1304
1305         return 0;
1306 }
1307
1308 /*
1309  * set up the iterator to start reading from the volume list and return the first item
1310  */
1311 static void *nfs_volume_list_start(struct seq_file *m, loff_t *_pos)
1312                                 __acquires(&nn->nfs_client_lock)
1313 {
1314         struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id);
1315
1316         /* lock the list against modification */
1317         spin_lock(&nn->nfs_client_lock);
1318         return seq_list_start_head(&nn->nfs_volume_list, *_pos);
1319 }
1320
1321 /*
1322  * move to next volume
1323  */
1324 static void *nfs_volume_list_next(struct seq_file *p, void *v, loff_t *pos)
1325 {
1326         struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id);
1327
1328         return seq_list_next(v, &nn->nfs_volume_list, pos);
1329 }
1330
1331 /*
1332  * clean up after reading from the transports list
1333  */
1334 static void nfs_volume_list_stop(struct seq_file *p, void *v)
1335                                 __releases(&nn->nfs_client_lock)
1336 {
1337         struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id);
1338
1339         spin_unlock(&nn->nfs_client_lock);
1340 }
1341
1342 /*
1343  * display a header line followed by a load of call lines
1344  */
1345 static int nfs_volume_list_show(struct seq_file *m, void *v)
1346 {
1347         struct nfs_server *server;
1348         struct nfs_client *clp;
1349         char dev[13];   // 8 for 2^24, 1 for ':', 3 for 2^8, 1 for '\0'
1350         char fsid[34];  // 2 * 16 for %llx, 1 for ':', 1 for '\0'
1351         struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id);
1352
1353         /* display header on line 1 */
1354         if (v == &nn->nfs_volume_list) {
1355                 seq_puts(m, "NV SERVER   PORT DEV          FSID"
1356                             "                              FSC\n");
1357                 return 0;
1358         }
1359         /* display one transport per line on subsequent lines */
1360         server = list_entry(v, struct nfs_server, master_link);
1361         clp = server->nfs_client;
1362
1363         snprintf(dev, sizeof(dev), "%u:%u",
1364                  MAJOR(server->s_dev), MINOR(server->s_dev));
1365
1366         snprintf(fsid, sizeof(fsid), "%llx:%llx",
1367                  (unsigned long long) server->fsid.major,
1368                  (unsigned long long) server->fsid.minor);
1369
1370         rcu_read_lock();
1371         seq_printf(m, "v%u %s %s %-12s %-33s %s\n",
1372                    clp->rpc_ops->version,
1373                    rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_ADDR),
1374                    rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_PORT),
1375                    dev,
1376                    fsid,
1377                    nfs_server_fscache_state(server));
1378         rcu_read_unlock();
1379
1380         return 0;
1381 }
1382
1383 int nfs_fs_proc_net_init(struct net *net)
1384 {
1385         struct nfs_net *nn = net_generic(net, nfs_net_id);
1386         struct proc_dir_entry *p;
1387
1388         nn->proc_nfsfs = proc_net_mkdir(net, "nfsfs", net->proc_net);
1389         if (!nn->proc_nfsfs)
1390                 goto error_0;
1391
1392         /* a file of servers with which we're dealing */
1393         p = proc_create_net("servers", S_IFREG|S_IRUGO, nn->proc_nfsfs,
1394                         &nfs_server_list_ops, sizeof(struct seq_net_private));
1395         if (!p)
1396                 goto error_1;
1397
1398         /* a file of volumes that we have mounted */
1399         p = proc_create_net("volumes", S_IFREG|S_IRUGO, nn->proc_nfsfs,
1400                         &nfs_volume_list_ops, sizeof(struct seq_net_private));
1401         if (!p)
1402                 goto error_1;
1403         return 0;
1404
1405 error_1:
1406         remove_proc_subtree("nfsfs", net->proc_net);
1407 error_0:
1408         return -ENOMEM;
1409 }
1410
1411 void nfs_fs_proc_net_exit(struct net *net)
1412 {
1413         remove_proc_subtree("nfsfs", net->proc_net);
1414 }
1415
1416 /*
1417  * initialise the /proc/fs/nfsfs/ directory
1418  */
1419 int __init nfs_fs_proc_init(void)
1420 {
1421         if (!proc_mkdir("fs/nfsfs", NULL))
1422                 goto error_0;
1423
1424         /* a file of servers with which we're dealing */
1425         if (!proc_symlink("fs/nfsfs/servers", NULL, "../../net/nfsfs/servers"))
1426                 goto error_1;
1427
1428         /* a file of volumes that we have mounted */
1429         if (!proc_symlink("fs/nfsfs/volumes", NULL, "../../net/nfsfs/volumes"))
1430                 goto error_1;
1431
1432         return 0;
1433 error_1:
1434         remove_proc_subtree("fs/nfsfs", NULL);
1435 error_0:
1436         return -ENOMEM;
1437 }
1438
1439 /*
1440  * clean up the /proc/fs/nfsfs/ directory
1441  */
1442 void nfs_fs_proc_exit(void)
1443 {
1444         remove_proc_subtree("fs/nfsfs", NULL);
1445         ida_destroy(&s_sysfs_ids);
1446 }
1447
1448 #endif /* CONFIG_PROC_FS */