git.oblomov.eu Git - linux-2.6/blob - fs/nfs/client.c

   1 /* client.c: NFS client sharing and management code
   2  *
   3  * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
   4  * Written by David Howells (dhowells@redhat.com)
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the License, or (at your option) any later version.
  10  */
  11
  12
  13 #include <linux/module.h>
  14 #include <linux/init.h>
  15 #include <linux/sched.h>
  16 #include <linux/time.h>
  17 #include <linux/kernel.h>
  18 #include <linux/mm.h>
  19 #include <linux/string.h>
  20 #include <linux/stat.h>
  21 #include <linux/errno.h>
  22 #include <linux/unistd.h>
  23 #include <linux/sunrpc/clnt.h>
  24 #include <linux/sunrpc/stats.h>
  25 #include <linux/sunrpc/metrics.h>
  26 #include <linux/nfs_fs.h>
  27 #include <linux/nfs_mount.h>
  28 #include <linux/nfs4_mount.h>
  29 #include <linux/lockd/bind.h>
  30 #include <linux/seq_file.h>
  31 #include <linux/mount.h>
  32 #include <linux/nfs_idmap.h>
  33 #include <linux/vfs.h>
  34 #include <linux/inet.h>
  35 #include <linux/nfs_xdr.h>
  36
  37 #include <asm/system.h>
  38
  39 #include "nfs4_fs.h"
  40 #include "callback.h"
  41 #include "delegation.h"
  42 #include "iostat.h"
  43 #include "internal.h"
  44
  45 #define NFSDBG_FACILITY         NFSDBG_CLIENT
  46
  47 static DEFINE_SPINLOCK(nfs_client_lock);
  48 static LIST_HEAD(nfs_client_list);
  49 static LIST_HEAD(nfs_volume_list);
  50 static DECLARE_WAIT_QUEUE_HEAD(nfs_client_active_wq);
  51
  52 /*
  53  * RPC cruft for NFS
  54  */
  55 static struct rpc_version *nfs_version[5] = {
  56         [2]                     = &nfs_version2,
  57 #ifdef CONFIG_NFS_V3
  58         [3]                     = &nfs_version3,
  59 #endif
  60 #ifdef CONFIG_NFS_V4
  61         [4]                     = &nfs_version4,
  62 #endif
  63 };
  64
  65 struct rpc_program nfs_program = {
  66         .name                   = "nfs",
  67         .number                 = NFS_PROGRAM,
  68         .nrvers                 = ARRAY_SIZE(nfs_version),
  69         .version                = nfs_version,
  70         .stats                  = &nfs_rpcstat,
  71         .pipe_dir_name          = "/nfs",
  72 };
  73
  74 struct rpc_stat nfs_rpcstat = {
  75         .program                = &nfs_program
  76 };
  77
  78
  79 #ifdef CONFIG_NFS_V3_ACL
  80 static struct rpc_stat          nfsacl_rpcstat = { &nfsacl_program };
  81 static struct rpc_version *     nfsacl_version[] = {
  82         [3]                     = &nfsacl_version3,
  83 };
  84
  85 struct rpc_program              nfsacl_program = {
  86         .name                   = "nfsacl",
  87         .number                 = NFS_ACL_PROGRAM,
  88         .nrvers                 = ARRAY_SIZE(nfsacl_version),
  89         .version                = nfsacl_version,
  90         .stats                  = &nfsacl_rpcstat,
  91 };
  92 #endif  /* CONFIG_NFS_V3_ACL */
  93
  94 /*
  95  * Allocate a shared client record
  96  *
  97  * Since these are allocated/deallocated very rarely, we don't
  98  * bother putting them in a slab cache...
  99  */
 100 static struct nfs_client *nfs_alloc_client(const char *hostname,
 101                                            const struct sockaddr_in *addr,
 102                                            int nfsversion)
 103 {
 104         struct nfs_client *clp;
 105
 106         if ((clp = kzalloc(sizeof(*clp), GFP_KERNEL)) == NULL)
 107                 goto error_0;
 108
 109         if (nfsversion == 4) {
 110                 if (nfs_callback_up() < 0)
 111                         goto error_2;
 112                 __set_bit(NFS_CS_CALLBACK, &clp->cl_res_state);
 113         }
 114
 115         atomic_set(&clp->cl_count, 1);
 116         clp->cl_cons_state = NFS_CS_INITING;
 117
 118         clp->cl_nfsversion = nfsversion;
 119         memcpy(&clp->cl_addr, addr, sizeof(clp->cl_addr));
 120
 121         if (hostname) {
 122                 clp->cl_hostname = kstrdup(hostname, GFP_KERNEL);
 123                 if (!clp->cl_hostname)
 124                         goto error_3;
 125         }
 126
 127         INIT_LIST_HEAD(&clp->cl_superblocks);
 128         clp->cl_rpcclient = ERR_PTR(-EINVAL);
 129
 130 #ifdef CONFIG_NFS_V4
 131         init_rwsem(&clp->cl_sem);
 132         INIT_LIST_HEAD(&clp->cl_delegations);
 133         INIT_LIST_HEAD(&clp->cl_state_owners);
 134         INIT_LIST_HEAD(&clp->cl_unused);
 135         spin_lock_init(&clp->cl_lock);
 136         INIT_DELAYED_WORK(&clp->cl_renewd, nfs4_renew_state);
 137         rpc_init_wait_queue(&clp->cl_rpcwaitq, "NFS client");
 138         clp->cl_boot_time = CURRENT_TIME;
 139         clp->cl_state = 1 << NFS4CLNT_LEASE_EXPIRED;
 140 #endif
 141
 142         return clp;
 143
 144 error_3:
 145         if (__test_and_clear_bit(NFS_CS_CALLBACK, &clp->cl_res_state))
 146                 nfs_callback_down();
 147 error_2:
 148         kfree(clp);
 149 error_0:
 150         return NULL;
 151 }
 152
 153 static void nfs4_shutdown_client(struct nfs_client *clp)
 154 {
 155 #ifdef CONFIG_NFS_V4
 156         if (__test_and_clear_bit(NFS_CS_RENEWD, &clp->cl_res_state))
 157                 nfs4_kill_renewd(clp);
 158         while (!list_empty(&clp->cl_unused)) {
 159                 struct nfs4_state_owner *sp;
 160
 161                 sp = list_entry(clp->cl_unused.next,
 162                                 struct nfs4_state_owner,
 163                                 so_list);
 164                 list_del(&sp->so_list);
 165                 kfree(sp);
 166         }
 167         BUG_ON(!list_empty(&clp->cl_state_owners));
 168         if (__test_and_clear_bit(NFS_CS_IDMAP, &clp->cl_res_state))
 169                 nfs_idmap_delete(clp);
 170 #endif
 171 }
 172
 173 /*
 174  * Destroy a shared client record
 175  */
 176 static void nfs_free_client(struct nfs_client *clp)
 177 {
 178         dprintk("--> nfs_free_client(%d)\n", clp->cl_nfsversion);
 179
 180         nfs4_shutdown_client(clp);
 181
 182         /* -EIO all pending I/O */
 183         if (!IS_ERR(clp->cl_rpcclient))
 184                 rpc_shutdown_client(clp->cl_rpcclient);
 185
 186         if (__test_and_clear_bit(NFS_CS_CALLBACK, &clp->cl_res_state))
 187                 nfs_callback_down();
 188
 189         kfree(clp->cl_hostname);
 190         kfree(clp);
 191
 192         dprintk("<-- nfs_free_client()\n");
 193 }
 194
 195 /*
 196  * Release a reference to a shared client record
 197  */
 198 void nfs_put_client(struct nfs_client *clp)
 199 {
 200         if (!clp)
 201                 return;
 202
 203         dprintk("--> nfs_put_client({%d})\n", atomic_read(&clp->cl_count));
 204
 205         if (atomic_dec_and_lock(&clp->cl_count, &nfs_client_lock)) {
 206                 list_del(&clp->cl_share_link);
 207                 spin_unlock(&nfs_client_lock);
 208
 209                 BUG_ON(!list_empty(&clp->cl_superblocks));
 210
 211                 nfs_free_client(clp);
 212         }
 213 }
 214
 215 /*
 216  * Find a client by address
 217  * - caller must hold nfs_client_lock
 218  */
 219 static struct nfs_client *__nfs_find_client(const struct sockaddr_in *addr, int nfsversion, int match_port)
 220 {
 221         struct nfs_client *clp;
 222
 223         list_for_each_entry(clp, &nfs_client_list, cl_share_link) {
 224                 /* Don't match clients that failed to initialise properly */
 225                 if (clp->cl_cons_state < 0)
 226                         continue;
 227
 228                 /* Different NFS versions cannot share the same nfs_client */
 229                 if (clp->cl_nfsversion != nfsversion)
 230                         continue;
 231
 232                 if (memcmp(&clp->cl_addr.sin_addr, &addr->sin_addr,
 233                            sizeof(clp->cl_addr.sin_addr)) != 0)
 234                         continue;
 235
 236                 if (!match_port || clp->cl_addr.sin_port == addr->sin_port)
 237                         goto found;
 238         }
 239
 240         return NULL;
 241
 242 found:
 243         atomic_inc(&clp->cl_count);
 244         return clp;
 245 }
 246
 247 /*
 248  * Find a client by IP address and protocol version
 249  * - returns NULL if no such client
 250  */
 251 struct nfs_client *nfs_find_client(const struct sockaddr_in *addr, int nfsversion)
 252 {
 253         struct nfs_client *clp;
 254
 255         spin_lock(&nfs_client_lock);
 256         clp = __nfs_find_client(addr, nfsversion, 0);
 257         spin_unlock(&nfs_client_lock);
 258         if (clp != NULL && clp->cl_cons_state != NFS_CS_READY) {
 259                 nfs_put_client(clp);
 260                 clp = NULL;
 261         }
 262         return clp;
 263 }
 264
 265 /*
 266  * Look up a client by IP address and protocol version
 267  * - creates a new record if one doesn't yet exist
 268  */
 269 static struct nfs_client *nfs_get_client(const char *hostname,
 270                                          const struct sockaddr_in *addr,
 271                                          int nfsversion)
 272 {
 273         struct nfs_client *clp, *new = NULL;
 274         int error;
 275
 276         dprintk("--> nfs_get_client(%s,"NIPQUAD_FMT":%d,%d)\n",
 277                 hostname ?: "", NIPQUAD(addr->sin_addr),
 278                 addr->sin_port, nfsversion);
 279
 280         /* see if the client already exists */
 281         do {
 282                 spin_lock(&nfs_client_lock);
 283
 284                 clp = __nfs_find_client(addr, nfsversion, 1);
 285                 if (clp)
 286                         goto found_client;
 287                 if (new)
 288                         goto install_client;
 289
 290                 spin_unlock(&nfs_client_lock);
 291
 292                 new = nfs_alloc_client(hostname, addr, nfsversion);
 293         } while (new);
 294
 295         return ERR_PTR(-ENOMEM);
 296
 297         /* install a new client and return with it unready */
 298 install_client:
 299         clp = new;
 300         list_add(&clp->cl_share_link, &nfs_client_list);
 301         spin_unlock(&nfs_client_lock);
 302         dprintk("--> nfs_get_client() = %p [new]\n", clp);
 303         return clp;
 304
 305         /* found an existing client
 306          * - make sure it's ready before returning
 307          */
 308 found_client:
 309         spin_unlock(&nfs_client_lock);
 310
 311         if (new)
 312                 nfs_free_client(new);
 313
 314         error = wait_event_interruptible(nfs_client_active_wq,
 315                                 clp->cl_cons_state != NFS_CS_INITING);
 316         if (error < 0) {
 317                 nfs_put_client(clp);
 318                 return ERR_PTR(-ERESTARTSYS);
 319         }
 320
 321         if (clp->cl_cons_state < NFS_CS_READY) {
 322                 error = clp->cl_cons_state;
 323                 nfs_put_client(clp);
 324                 return ERR_PTR(error);
 325         }
 326
 327         BUG_ON(clp->cl_cons_state != NFS_CS_READY);
 328
 329         dprintk("--> nfs_get_client() = %p [share]\n", clp);
 330         return clp;
 331 }
 332
 333 /*
 334  * Mark a server as ready or failed
 335  */
 336 static void nfs_mark_client_ready(struct nfs_client *clp, int state)
 337 {
 338         clp->cl_cons_state = state;
 339         wake_up_all(&nfs_client_active_wq);
 340 }
 341
 342 /*
 343  * Initialise the timeout values for a connection
 344  */
 345 static void nfs_init_timeout_values(struct rpc_timeout *to, int proto,
 346                                     unsigned int timeo, unsigned int retrans)
 347 {
 348         to->to_initval = timeo * HZ / 10;
 349         to->to_retries = retrans;
 350         if (!to->to_retries)
 351                 to->to_retries = 2;
 352
 353         switch (proto) {
 354         case IPPROTO_TCP:
 355                 if (!to->to_initval)
 356                         to->to_initval = 60 * HZ;
 357                 if (to->to_initval > NFS_MAX_TCP_TIMEOUT)
 358                         to->to_initval = NFS_MAX_TCP_TIMEOUT;
 359                 to->to_increment = to->to_initval;
 360                 to->to_maxval = to->to_initval + (to->to_increment * to->to_retries);
 361                 to->to_exponential = 0;
 362                 break;
 363         case IPPROTO_UDP:
 364         default:
 365                 if (!to->to_initval)
 366                         to->to_initval = 11 * HZ / 10;
 367                 if (to->to_initval > NFS_MAX_UDP_TIMEOUT)
 368                         to->to_initval = NFS_MAX_UDP_TIMEOUT;
 369                 to->to_maxval = NFS_MAX_UDP_TIMEOUT;
 370                 to->to_exponential = 1;
 371                 break;
 372         }
 373 }
 374
 375 /*
 376  * Create an RPC client handle
 377  */
 378 static int nfs_create_rpc_client(struct nfs_client *clp, int proto,
 379                                                 unsigned int timeo,
 380                                                 unsigned int retrans,
 381                                                 rpc_authflavor_t flavor,
 382                                                 int flags)
 383 {
 384         struct rpc_timeout      timeparms;
 385         struct rpc_clnt         *clnt = NULL;
 386         struct rpc_create_args args = {
 387                 .protocol       = proto,
 388                 .address        = (struct sockaddr *)&clp->cl_addr,
 389                 .addrsize       = sizeof(clp->cl_addr),
 390                 .timeout        = &timeparms,
 391                 .servername     = clp->cl_hostname,
 392                 .program        = &nfs_program,
 393                 .version        = clp->rpc_ops->version,
 394                 .authflavor     = flavor,
 395                 .flags          = flags,
 396         };
 397
 398         if (!IS_ERR(clp->cl_rpcclient))
 399                 return 0;
 400
 401         nfs_init_timeout_values(&timeparms, proto, timeo, retrans);
 402         clp->retrans_timeo = timeparms.to_initval;
 403         clp->retrans_count = timeparms.to_retries;
 404
 405         clnt = rpc_create(&args);
 406         if (IS_ERR(clnt)) {
 407                 dprintk("%s: cannot create RPC client. Error = %ld\n",
 408                                 __FUNCTION__, PTR_ERR(clnt));
 409                 return PTR_ERR(clnt);
 410         }
 411
 412         clp->cl_rpcclient = clnt;
 413         return 0;
 414 }
 415
 416 /*
 417  * Version 2 or 3 client destruction
 418  */
 419 static void nfs_destroy_server(struct nfs_server *server)
 420 {
 421         if (!IS_ERR(server->client_acl))
 422                 rpc_shutdown_client(server->client_acl);
 423
 424         if (!(server->flags & NFS_MOUNT_NONLM))
 425                 lockd_down();   /* release rpc.lockd */
 426 }
 427
 428 /*
 429  * Version 2 or 3 lockd setup
 430  */
 431 static int nfs_start_lockd(struct nfs_server *server)
 432 {
 433         int error = 0;
 434
 435         if (server->nfs_client->cl_nfsversion > 3)
 436                 goto out;
 437         if (server->flags & NFS_MOUNT_NONLM)
 438                 goto out;
 439         error = lockd_up((server->flags & NFS_MOUNT_TCP) ?
 440                         IPPROTO_TCP : IPPROTO_UDP);
 441         if (error < 0)
 442                 server->flags |= NFS_MOUNT_NONLM;
 443         else
 444                 server->destroy = nfs_destroy_server;
 445 out:
 446         return error;
 447 }
 448
 449 /*
 450  * Initialise an NFSv3 ACL client connection
 451  */
 452 #ifdef CONFIG_NFS_V3_ACL
 453 static void nfs_init_server_aclclient(struct nfs_server *server)
 454 {
 455         if (server->nfs_client->cl_nfsversion != 3)
 456                 goto out_noacl;
 457         if (server->flags & NFS_MOUNT_NOACL)
 458                 goto out_noacl;
 459
 460         server->client_acl = rpc_bind_new_program(server->client, &nfsacl_program, 3);
 461         if (IS_ERR(server->client_acl))
 462                 goto out_noacl;
 463
 464         /* No errors! Assume that Sun nfsacls are supported */
 465         server->caps |= NFS_CAP_ACLS;
 466         return;
 467
 468 out_noacl:
 469         server->caps &= ~NFS_CAP_ACLS;
 470 }
 471 #else
 472 static inline void nfs_init_server_aclclient(struct nfs_server *server)
 473 {
 474         server->flags &= ~NFS_MOUNT_NOACL;
 475         server->caps &= ~NFS_CAP_ACLS;
 476 }
 477 #endif
 478
 479 /*
 480  * Create a general RPC client
 481  */
 482 static int nfs_init_server_rpcclient(struct nfs_server *server, rpc_authflavor_t pseudoflavour)
 483 {
 484         struct nfs_client *clp = server->nfs_client;
 485
 486         server->client = rpc_clone_client(clp->cl_rpcclient);
 487         if (IS_ERR(server->client)) {
 488                 dprintk("%s: couldn't create rpc_client!\n", __FUNCTION__);
 489                 return PTR_ERR(server->client);
 490         }
 491
 492         if (pseudoflavour != clp->cl_rpcclient->cl_auth->au_flavor) {
 493                 struct rpc_auth *auth;
 494
 495                 auth = rpcauth_create(pseudoflavour, server->client);
 496                 if (IS_ERR(auth)) {
 497                         dprintk("%s: couldn't create credcache!\n", __FUNCTION__);
 498                         return PTR_ERR(auth);
 499                 }
 500         }
 501         server->client->cl_softrtry = 0;
 502         if (server->flags & NFS_MOUNT_SOFT)
 503                 server->client->cl_softrtry = 1;
 504
 505         server->client->cl_intr = 0;
 506         if (server->flags & NFS4_MOUNT_INTR)
 507                 server->client->cl_intr = 1;
 508
 509         return 0;
 510 }
 511
 512 /*
 513  * Initialise an NFS2 or NFS3 client
 514  */
 515 static int nfs_init_client(struct nfs_client *clp, const struct nfs_mount_data *data)
 516 {
 517         int proto = (data->flags & NFS_MOUNT_TCP) ? IPPROTO_TCP : IPPROTO_UDP;
 518         int error;
 519
 520         if (clp->cl_cons_state == NFS_CS_READY) {
 521                 /* the client is already initialised */
 522                 dprintk("<-- nfs_init_client() = 0 [already %p]\n", clp);
 523                 return 0;
 524         }
 525
 526         /* Check NFS protocol revision and initialize RPC op vector */
 527         clp->rpc_ops = &nfs_v2_clientops;
 528 #ifdef CONFIG_NFS_V3
 529         if (clp->cl_nfsversion == 3)
 530                 clp->rpc_ops = &nfs_v3_clientops;
 531 #endif
 532         /*
 533          * Create a client RPC handle for doing FSSTAT with UNIX auth only
 534          * - RFC 2623, sec 2.3.2
 535          */
 536         error = nfs_create_rpc_client(clp, proto, data->timeo, data->retrans,
 537                                         RPC_AUTH_UNIX, 0);
 538         if (error < 0)
 539                 goto error;
 540         nfs_mark_client_ready(clp, NFS_CS_READY);
 541         return 0;
 542
 543 error:
 544         nfs_mark_client_ready(clp, error);
 545         dprintk("<-- nfs_init_client() = xerror %d\n", error);
 546         return error;
 547 }
 548
 549 /*
 550  * Create a version 2 or 3 client
 551  */
 552 static int nfs_init_server(struct nfs_server *server, const struct nfs_mount_data *data)
 553 {
 554         struct nfs_client *clp;
 555         int error, nfsvers = 2;
 556
 557         dprintk("--> nfs_init_server()\n");
 558
 559 #ifdef CONFIG_NFS_V3
 560         if (data->flags & NFS_MOUNT_VER3)
 561                 nfsvers = 3;
 562 #endif
 563
 564         /* Allocate or find a client reference we can use */
 565         clp = nfs_get_client(data->hostname, &data->addr, nfsvers);
 566         if (IS_ERR(clp)) {
 567                 dprintk("<-- nfs_init_server() = error %ld\n", PTR_ERR(clp));
 568                 return PTR_ERR(clp);
 569         }
 570
 571         error = nfs_init_client(clp, data);
 572         if (error < 0)
 573                 goto error;
 574
 575         server->nfs_client = clp;
 576
 577         /* Initialise the client representation from the mount data */
 578         server->flags = data->flags & NFS_MOUNT_FLAGMASK;
 579
 580         if (data->rsize)
 581                 server->rsize = nfs_block_size(data->rsize, NULL);
 582         if (data->wsize)
 583                 server->wsize = nfs_block_size(data->wsize, NULL);
 584
 585         server->acregmin = data->acregmin * HZ;
 586         server->acregmax = data->acregmax * HZ;
 587         server->acdirmin = data->acdirmin * HZ;
 588         server->acdirmax = data->acdirmax * HZ;
 589
 590         /* Start lockd here, before we might error out */
 591         error = nfs_start_lockd(server);
 592         if (error < 0)
 593                 goto error;
 594
 595         error = nfs_init_server_rpcclient(server, data->pseudoflavor);
 596         if (error < 0)
 597                 goto error;
 598
 599         server->namelen  = data->namlen;
 600         /* Create a client RPC handle for the NFSv3 ACL management interface */
 601         nfs_init_server_aclclient(server);
 602         if (clp->cl_nfsversion == 3) {
 603                 if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN)
 604                         server->namelen = NFS3_MAXNAMLEN;
 605                 if (!(data->flags & NFS_MOUNT_NORDIRPLUS))
 606                         server->caps |= NFS_CAP_READDIRPLUS;
 607         } else {
 608                 if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)
 609                         server->namelen = NFS2_MAXNAMLEN;
 610         }
 611
 612         dprintk("<-- nfs_init_server() = 0 [new %p]\n", clp);
 613         return 0;
 614
 615 error:
 616         server->nfs_client = NULL;
 617         nfs_put_client(clp);
 618         dprintk("<-- nfs_init_server() = xerror %d\n", error);
 619         return error;
 620 }
 621
 622 /*
 623  * Load up the server record from information gained in an fsinfo record
 624  */
 625 static void nfs_server_set_fsinfo(struct nfs_server *server, struct nfs_fsinfo *fsinfo)
 626 {
 627         unsigned long max_rpc_payload;
 628
 629         /* Work out a lot of parameters */
 630         if (server->rsize == 0)
 631                 server->rsize = nfs_block_size(fsinfo->rtpref, NULL);
 632         if (server->wsize == 0)
 633                 server->wsize = nfs_block_size(fsinfo->wtpref, NULL);
 634
 635         if (fsinfo->rtmax >= 512 && server->rsize > fsinfo->rtmax)
 636                 server->rsize = nfs_block_size(fsinfo->rtmax, NULL);
 637         if (fsinfo->wtmax >= 512 && server->wsize > fsinfo->wtmax)
 638                 server->wsize = nfs_block_size(fsinfo->wtmax, NULL);
 639
 640         max_rpc_payload = nfs_block_size(rpc_max_payload(server->client), NULL);
 641         if (server->rsize > max_rpc_payload)
 642                 server->rsize = max_rpc_payload;
 643         if (server->rsize > NFS_MAX_FILE_IO_SIZE)
 644                 server->rsize = NFS_MAX_FILE_IO_SIZE;
 645         server->rpages = (server->rsize + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
 646         server->backing_dev_info.ra_pages = server->rpages * NFS_MAX_READAHEAD;
 647
 648         if (server->wsize > max_rpc_payload)
 649                 server->wsize = max_rpc_payload;
 650         if (server->wsize > NFS_MAX_FILE_IO_SIZE)
 651                 server->wsize = NFS_MAX_FILE_IO_SIZE;
 652         server->wpages = (server->wsize + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
 653         server->wtmult = nfs_block_bits(fsinfo->wtmult, NULL);
 654
 655         server->dtsize = nfs_block_size(fsinfo->dtpref, NULL);
 656         if (server->dtsize > PAGE_CACHE_SIZE)
 657                 server->dtsize = PAGE_CACHE_SIZE;
 658         if (server->dtsize > server->rsize)
 659                 server->dtsize = server->rsize;
 660
 661         if (server->flags & NFS_MOUNT_NOAC) {
 662                 server->acregmin = server->acregmax = 0;
 663                 server->acdirmin = server->acdirmax = 0;
 664         }
 665
 666         server->maxfilesize = fsinfo->maxfilesize;
 667
 668         /* We're airborne Set socket buffersize */
 669         rpc_setbufsize(server->client, server->wsize + 100, server->rsize + 100);
 670 }
 671
 672 /*
 673  * Probe filesystem information, including the FSID on v2/v3
 674  */
 675 static int nfs_probe_fsinfo(struct nfs_server *server, struct nfs_fh *mntfh, struct nfs_fattr *fattr)
 676 {
 677         struct nfs_fsinfo fsinfo;
 678         struct nfs_client *clp = server->nfs_client;
 679         int error;
 680
 681         dprintk("--> nfs_probe_fsinfo()\n");
 682
 683         if (clp->rpc_ops->set_capabilities != NULL) {
 684                 error = clp->rpc_ops->set_capabilities(server, mntfh);
 685                 if (error < 0)
 686                         goto out_error;
 687         }
 688
 689         fsinfo.fattr = fattr;
 690         nfs_fattr_init(fattr);
 691         error = clp->rpc_ops->fsinfo(server, mntfh, &fsinfo);
 692         if (error < 0)
 693                 goto out_error;
 694
 695         nfs_server_set_fsinfo(server, &fsinfo);
 696
 697         /* Get some general file system info */
 698         if (server->namelen == 0) {
 699                 struct nfs_pathconf pathinfo;
 700
 701                 pathinfo.fattr = fattr;
 702                 nfs_fattr_init(fattr);
 703
 704                 if (clp->rpc_ops->pathconf(server, mntfh, &pathinfo) >= 0)
 705                         server->namelen = pathinfo.max_namelen;
 706         }
 707
 708         dprintk("<-- nfs_probe_fsinfo() = 0\n");
 709         return 0;
 710
 711 out_error:
 712         dprintk("nfs_probe_fsinfo: error = %d\n", -error);
 713         return error;
 714 }
 715
 716 /*
 717  * Copy useful information when duplicating a server record
 718  */
 719 static void nfs_server_copy_userdata(struct nfs_server *target, struct nfs_server *source)
 720 {
 721         target->flags = source->flags;
 722         target->acregmin = source->acregmin;
 723         target->acregmax = source->acregmax;
 724         target->acdirmin = source->acdirmin;
 725         target->acdirmax = source->acdirmax;
 726         target->caps = source->caps;
 727 }
 728
 729 /*
 730  * Allocate and initialise a server record
 731  */
 732 static struct nfs_server *nfs_alloc_server(void)
 733 {
 734         struct nfs_server *server;
 735
 736         server = kzalloc(sizeof(struct nfs_server), GFP_KERNEL);
 737         if (!server)
 738                 return NULL;
 739
 740         server->client = server->client_acl = ERR_PTR(-EINVAL);
 741
 742         /* Zero out the NFS state stuff */
 743         INIT_LIST_HEAD(&server->client_link);
 744         INIT_LIST_HEAD(&server->master_link);
 745
 746         server->io_stats = nfs_alloc_iostats();
 747         if (!server->io_stats) {
 748                 kfree(server);
 749                 return NULL;
 750         }
 751
 752         return server;
 753 }
 754
 755 /*
 756  * Free up a server record
 757  */
 758 void nfs_free_server(struct nfs_server *server)
 759 {
 760         dprintk("--> nfs_free_server()\n");
 761
 762         spin_lock(&nfs_client_lock);
 763         list_del(&server->client_link);
 764         list_del(&server->master_link);
 765         spin_unlock(&nfs_client_lock);
 766
 767         if (server->destroy != NULL)
 768                 server->destroy(server);
 769         if (!IS_ERR(server->client))
 770                 rpc_shutdown_client(server->client);
 771
 772         nfs_put_client(server->nfs_client);
 773
 774         nfs_free_iostats(server->io_stats);
 775         kfree(server);
 776         nfs_release_automount_timer();
 777         dprintk("<-- nfs_free_server()\n");
 778 }
 779
 780 /*
 781  * Create a version 2 or 3 volume record
 782  * - keyed on server and FSID
 783  */
 784 struct nfs_server *nfs_create_server(const struct nfs_mount_data *data,
 785                                      struct nfs_fh *mntfh)
 786 {
 787         struct nfs_server *server;
 788         struct nfs_fattr fattr;
 789         int error;
 790
 791         server = nfs_alloc_server();
 792         if (!server)
 793                 return ERR_PTR(-ENOMEM);
 794
 795         /* Get a client representation */
 796         error = nfs_init_server(server, data);
 797         if (error < 0)
 798                 goto error;
 799
 800         BUG_ON(!server->nfs_client);
 801         BUG_ON(!server->nfs_client->rpc_ops);
 802         BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
 803
 804         /* Probe the root fh to retrieve its FSID */
 805         error = nfs_probe_fsinfo(server, mntfh, &fattr);
 806         if (error < 0)
 807                 goto error;
 808         if (!(fattr.valid & NFS_ATTR_FATTR)) {
 809                 error = server->nfs_client->rpc_ops->getattr(server, mntfh, &fattr);
 810                 if (error < 0) {
 811                         dprintk("nfs_create_server: getattr error = %d\n", -error);
 812                         goto error;
 813                 }
 814         }
 815         memcpy(&server->fsid, &fattr.fsid, sizeof(server->fsid));
 816
 817         dprintk("Server FSID: %llx:%llx\n",
 818                 (unsigned long long) server->fsid.major,
 819                 (unsigned long long) server->fsid.minor);
 820
 821         BUG_ON(!server->nfs_client);
 822         BUG_ON(!server->nfs_client->rpc_ops);
 823         BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
 824
 825         spin_lock(&nfs_client_lock);
 826         list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks);
 827         list_add_tail(&server->master_link, &nfs_volume_list);
 828         spin_unlock(&nfs_client_lock);
 829
 830         server->mount_time = jiffies;
 831         return server;
 832
 833 error:
 834         nfs_free_server(server);
 835         return ERR_PTR(error);
 836 }
 837
 838 #ifdef CONFIG_NFS_V4
 839 /*
 840  * Initialise an NFS4 client record
 841  */
 842 static int nfs4_init_client(struct nfs_client *clp,
 843                 int proto, int timeo, int retrans,
 844                 const char *ip_addr,
 845                 rpc_authflavor_t authflavour)
 846 {
 847         int error;
 848
 849         if (clp->cl_cons_state == NFS_CS_READY) {
 850                 /* the client is initialised already */
 851                 dprintk("<-- nfs4_init_client() = 0 [already %p]\n", clp);
 852                 return 0;
 853         }
 854
 855         /* Check NFS protocol revision and initialize RPC op vector */
 856         clp->rpc_ops = &nfs_v4_clientops;
 857
 858         error = nfs_create_rpc_client(clp, proto, timeo, retrans, authflavour,
 859                                         RPC_CLNT_CREATE_DISCRTRY);
 860         if (error < 0)
 861                 goto error;
 862         memcpy(clp->cl_ipaddr, ip_addr, sizeof(clp->cl_ipaddr));
 863
 864         error = nfs_idmap_new(clp);
 865         if (error < 0) {
 866                 dprintk("%s: failed to create idmapper. Error = %d\n",
 867                         __FUNCTION__, error);
 868                 goto error;
 869         }
 870         __set_bit(NFS_CS_IDMAP, &clp->cl_res_state);
 871
 872         nfs_mark_client_ready(clp, NFS_CS_READY);
 873         return 0;
 874
 875 error:
 876         nfs_mark_client_ready(clp, error);
 877         dprintk("<-- nfs4_init_client() = xerror %d\n", error);
 878         return error;
 879 }
 880
 881 /*
 882  * Set up an NFS4 client
 883  */
 884 static int nfs4_set_client(struct nfs_server *server,
 885                 const char *hostname, const struct sockaddr_in *addr,
 886                 const char *ip_addr,
 887                 rpc_authflavor_t authflavour,
 888                 int proto, int timeo, int retrans)
 889 {
 890         struct nfs_client *clp;
 891         int error;
 892
 893         dprintk("--> nfs4_set_client()\n");
 894
 895         /* Allocate or find a client reference we can use */
 896         clp = nfs_get_client(hostname, addr, 4);
 897         if (IS_ERR(clp)) {
 898                 error = PTR_ERR(clp);
 899                 goto error;
 900         }
 901         error = nfs4_init_client(clp, proto, timeo, retrans, ip_addr, authflavour);
 902         if (error < 0)
 903                 goto error_put;
 904
 905         server->nfs_client = clp;
 906         dprintk("<-- nfs4_set_client() = 0 [new %p]\n", clp);
 907         return 0;
 908
 909 error_put:
 910         nfs_put_client(clp);
 911 error:
 912         dprintk("<-- nfs4_set_client() = xerror %d\n", error);
 913         return error;
 914 }
 915
 916 /*
 917  * Create a version 4 volume record
 918  */
 919 static int nfs4_init_server(struct nfs_server *server,
 920                 const struct nfs4_mount_data *data, rpc_authflavor_t authflavour)
 921 {
 922         int error;
 923
 924         dprintk("--> nfs4_init_server()\n");
 925
 926         /* Initialise the client representation from the mount data */
 927         server->flags = data->flags & NFS_MOUNT_FLAGMASK;
 928         server->caps |= NFS_CAP_ATOMIC_OPEN;
 929
 930         if (data->rsize)
 931                 server->rsize = nfs_block_size(data->rsize, NULL);
 932         if (data->wsize)
 933                 server->wsize = nfs_block_size(data->wsize, NULL);
 934
 935         server->acregmin = data->acregmin * HZ;
 936         server->acregmax = data->acregmax * HZ;
 937         server->acdirmin = data->acdirmin * HZ;
 938         server->acdirmax = data->acdirmax * HZ;
 939
 940         error = nfs_init_server_rpcclient(server, authflavour);
 941
 942         /* Done */
 943         dprintk("<-- nfs4_init_server() = %d\n", error);
 944         return error;
 945 }
 946
 947 /*
 948  * Create a version 4 volume record
 949  * - keyed on server and FSID
 950  */
 951 struct nfs_server *nfs4_create_server(const struct nfs4_mount_data *data,
 952                                       const char *hostname,
 953                                       const struct sockaddr_in *addr,
 954                                       const char *mntpath,
 955                                       const char *ip_addr,
 956                                       rpc_authflavor_t authflavour,
 957                                       struct nfs_fh *mntfh)
 958 {
 959         struct nfs_fattr fattr;
 960         struct nfs_server *server;
 961         int error;
 962
 963         dprintk("--> nfs4_create_server()\n");
 964
 965         server = nfs_alloc_server();
 966         if (!server)
 967                 return ERR_PTR(-ENOMEM);
 968
 969         /* Get a client record */
 970         error = nfs4_set_client(server, hostname, addr, ip_addr, authflavour,
 971                         data->proto, data->timeo, data->retrans);
 972         if (error < 0)
 973                 goto error;
 974
 975         /* set up the general RPC client */
 976         error = nfs4_init_server(server, data, authflavour);
 977         if (error < 0)
 978                 goto error;
 979
 980         BUG_ON(!server->nfs_client);
 981         BUG_ON(!server->nfs_client->rpc_ops);
 982         BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
 983
 984         /* Probe the root fh to retrieve its FSID */
 985         error = nfs4_path_walk(server, mntfh, mntpath);
 986         if (error < 0)
 987                 goto error;
 988
 989         dprintk("Server FSID: %llx:%llx\n",
 990                 (unsigned long long) server->fsid.major,
 991                 (unsigned long long) server->fsid.minor);
 992         dprintk("Mount FH: %d\n", mntfh->size);
 993
 994         error = nfs_probe_fsinfo(server, mntfh, &fattr);
 995         if (error < 0)
 996                 goto error;
 997
 998         BUG_ON(!server->nfs_client);
 999         BUG_ON(!server->nfs_client->rpc_ops);
1000         BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
1001
1002         spin_lock(&nfs_client_lock);
1003         list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks);
1004         list_add_tail(&server->master_link, &nfs_volume_list);
1005         spin_unlock(&nfs_client_lock);
1006
1007         server->mount_time = jiffies;
1008         dprintk("<-- nfs4_create_server() = %p\n", server);
1009         return server;
1010
1011 error:
1012         nfs_free_server(server);
1013         dprintk("<-- nfs4_create_server() = error %d\n", error);
1014         return ERR_PTR(error);
1015 }
1016
1017 /*
1018  * Create an NFS4 referral server record
1019  */
1020 struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *data,
1021                                                struct nfs_fh *mntfh)
1022 {
1023         struct nfs_client *parent_client;
1024         struct nfs_server *server, *parent_server;
1025         struct nfs_fattr fattr;
1026         int error;
1027
1028         dprintk("--> nfs4_create_referral_server()\n");
1029
1030         server = nfs_alloc_server();
1031         if (!server)
1032                 return ERR_PTR(-ENOMEM);
1033
1034         parent_server = NFS_SB(data->sb);
1035         parent_client = parent_server->nfs_client;
1036
1037         /* Get a client representation.
1038          * Note: NFSv4 always uses TCP, */
1039         error = nfs4_set_client(server, data->hostname, data->addr,
1040                         parent_client->cl_ipaddr,
1041                         data->authflavor,
1042                         parent_server->client->cl_xprt->prot,
1043                         parent_client->retrans_timeo,
1044                         parent_client->retrans_count);
1045         if (error < 0)
1046                 goto error;
1047
1048         /* Initialise the client representation from the parent server */
1049         nfs_server_copy_userdata(server, parent_server);
1050         server->caps |= NFS_CAP_ATOMIC_OPEN;
1051
1052         error = nfs_init_server_rpcclient(server, data->authflavor);
1053         if (error < 0)
1054                 goto error;
1055
1056         BUG_ON(!server->nfs_client);
1057         BUG_ON(!server->nfs_client->rpc_ops);
1058         BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
1059
1060         /* Probe the root fh to retrieve its FSID and filehandle */
1061         error = nfs4_path_walk(server, mntfh, data->mnt_path);
1062         if (error < 0)
1063                 goto error;
1064
1065         /* probe the filesystem info for this server filesystem */
1066         error = nfs_probe_fsinfo(server, mntfh, &fattr);
1067         if (error < 0)
1068                 goto error;
1069
1070         dprintk("Referral FSID: %llx:%llx\n",
1071                 (unsigned long long) server->fsid.major,
1072                 (unsigned long long) server->fsid.minor);
1073
1074         spin_lock(&nfs_client_lock);
1075         list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks);
1076         list_add_tail(&server->master_link, &nfs_volume_list);
1077         spin_unlock(&nfs_client_lock);
1078
1079         server->mount_time = jiffies;
1080
1081         dprintk("<-- nfs_create_referral_server() = %p\n", server);
1082         return server;
1083
1084 error:
1085         nfs_free_server(server);
1086         dprintk("<-- nfs4_create_referral_server() = error %d\n", error);
1087         return ERR_PTR(error);
1088 }
1089
1090 #endif /* CONFIG_NFS_V4 */
1091
1092 /*
1093  * Clone an NFS2, NFS3 or NFS4 server record
1094  */
1095 struct nfs_server *nfs_clone_server(struct nfs_server *source,
1096                                     struct nfs_fh *fh,
1097                                     struct nfs_fattr *fattr)
1098 {
1099         struct nfs_server *server;
1100         struct nfs_fattr fattr_fsinfo;
1101         int error;
1102
1103         dprintk("--> nfs_clone_server(,%llx:%llx,)\n",
1104                 (unsigned long long) fattr->fsid.major,
1105                 (unsigned long long) fattr->fsid.minor);
1106
1107         server = nfs_alloc_server();
1108         if (!server)
1109                 return ERR_PTR(-ENOMEM);
1110
1111         /* Copy data from the source */
1112         server->nfs_client = source->nfs_client;
1113         atomic_inc(&server->nfs_client->cl_count);
1114         nfs_server_copy_userdata(server, source);
1115
1116         server->fsid = fattr->fsid;
1117
1118         error = nfs_init_server_rpcclient(server, source->client->cl_auth->au_flavor);
1119         if (error < 0)
1120                 goto out_free_server;
1121         if (!IS_ERR(source->client_acl))
1122                 nfs_init_server_aclclient(server);
1123
1124         /* probe the filesystem info for this server filesystem */
1125         error = nfs_probe_fsinfo(server, fh, &fattr_fsinfo);
1126         if (error < 0)
1127                 goto out_free_server;
1128
1129         dprintk("Cloned FSID: %llx:%llx\n",
1130                 (unsigned long long) server->fsid.major,
1131                 (unsigned long long) server->fsid.minor);
1132
1133         error = nfs_start_lockd(server);
1134         if (error < 0)
1135                 goto out_free_server;
1136
1137         spin_lock(&nfs_client_lock);
1138         list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks);
1139         list_add_tail(&server->master_link, &nfs_volume_list);
1140         spin_unlock(&nfs_client_lock);
1141
1142         server->mount_time = jiffies;
1143
1144         dprintk("<-- nfs_clone_server() = %p\n", server);
1145         return server;
1146
1147 out_free_server:
1148         nfs_free_server(server);
1149         dprintk("<-- nfs_clone_server() = error %d\n", error);
1150         return ERR_PTR(error);
1151 }
1152
1153 #ifdef CONFIG_PROC_FS
1154 static struct proc_dir_entry *proc_fs_nfs;
1155
1156 static int nfs_server_list_open(struct inode *inode, struct file *file);
1157 static void *nfs_server_list_start(struct seq_file *p, loff_t *pos);
1158 static void *nfs_server_list_next(struct seq_file *p, void *v, loff_t *pos);
1159 static void nfs_server_list_stop(struct seq_file *p, void *v);
1160 static int nfs_server_list_show(struct seq_file *m, void *v);
1161
1162 static struct seq_operations nfs_server_list_ops = {
1163         .start  = nfs_server_list_start,
1164         .next   = nfs_server_list_next,
1165         .stop   = nfs_server_list_stop,
1166         .show   = nfs_server_list_show,
1167 };
1168
1169 static const struct file_operations nfs_server_list_fops = {
1170         .open           = nfs_server_list_open,
1171         .read           = seq_read,
1172         .llseek         = seq_lseek,
1173         .release        = seq_release,
1174 };
1175
1176 static int nfs_volume_list_open(struct inode *inode, struct file *file);
1177 static void *nfs_volume_list_start(struct seq_file *p, loff_t *pos);
1178 static void *nfs_volume_list_next(struct seq_file *p, void *v, loff_t *pos);
1179 static void nfs_volume_list_stop(struct seq_file *p, void *v);
1180 static int nfs_volume_list_show(struct seq_file *m, void *v);
1181
1182 static struct seq_operations nfs_volume_list_ops = {
1183         .start  = nfs_volume_list_start,
1184         .next   = nfs_volume_list_next,
1185         .stop   = nfs_volume_list_stop,
1186         .show   = nfs_volume_list_show,
1187 };
1188
1189 static const struct file_operations nfs_volume_list_fops = {
1190         .open           = nfs_volume_list_open,
1191         .read           = seq_read,
1192         .llseek         = seq_lseek,
1193         .release        = seq_release,
1194 };
1195
1196 /*
1197  * open "/proc/fs/nfsfs/servers" which provides a summary of servers with which
1198  * we're dealing
1199  */
1200 static int nfs_server_list_open(struct inode *inode, struct file *file)
1201 {
1202         struct seq_file *m;
1203         int ret;
1204
1205         ret = seq_open(file, &nfs_server_list_ops);
1206         if (ret < 0)
1207                 return ret;
1208
1209         m = file->private_data;
1210         m->private = PDE(inode)->data;
1211
1212         return 0;
1213 }
1214
1215 /*
1216  * set up the iterator to start reading from the server list and return the first item
1217  */
1218 static void *nfs_server_list_start(struct seq_file *m, loff_t *_pos)
1219 {
1220         struct list_head *_p;
1221         loff_t pos = *_pos;
1222
1223         /* lock the list against modification */
1224         spin_lock(&nfs_client_lock);
1225
1226         /* allow for the header line */
1227         if (!pos)
1228                 return SEQ_START_TOKEN;
1229         pos--;
1230
1231         /* find the n'th element in the list */
1232         list_for_each(_p, &nfs_client_list)
1233                 if (!pos--)
1234                         break;
1235
1236         return _p != &nfs_client_list ? _p : NULL;
1237 }
1238
1239 /*
1240  * move to next server
1241  */
1242 static void *nfs_server_list_next(struct seq_file *p, void *v, loff_t *pos)
1243 {
1244         struct list_head *_p;
1245
1246         (*pos)++;
1247
1248         _p = v;
1249         _p = (v == SEQ_START_TOKEN) ? nfs_client_list.next : _p->next;
1250
1251         return _p != &nfs_client_list ? _p : NULL;
1252 }
1253
1254 /*
1255  * clean up after reading from the transports list
1256  */
1257 static void nfs_server_list_stop(struct seq_file *p, void *v)
1258 {
1259         spin_unlock(&nfs_client_lock);
1260 }
1261
1262 /*
1263  * display a header line followed by a load of call lines
1264  */
1265 static int nfs_server_list_show(struct seq_file *m, void *v)
1266 {
1267         struct nfs_client *clp;
1268
1269         /* display header on line 1 */
1270         if (v == SEQ_START_TOKEN) {
1271                 seq_puts(m, "NV SERVER   PORT USE HOSTNAME\n");
1272                 return 0;
1273         }
1274
1275         /* display one transport per line on subsequent lines */
1276         clp = list_entry(v, struct nfs_client, cl_share_link);
1277
1278         seq_printf(m, "v%d %02x%02x%02x%02x %4hx %3d %s\n",
1279                    clp->cl_nfsversion,
1280                    NIPQUAD(clp->cl_addr.sin_addr),
1281                    ntohs(clp->cl_addr.sin_port),
1282                    atomic_read(&clp->cl_count),
1283                    clp->cl_hostname);
1284
1285         return 0;
1286 }
1287
1288 /*
1289  * open "/proc/fs/nfsfs/volumes" which provides a summary of extant volumes
1290  */
1291 static int nfs_volume_list_open(struct inode *inode, struct file *file)
1292 {
1293         struct seq_file *m;
1294         int ret;
1295
1296         ret = seq_open(file, &nfs_volume_list_ops);
1297         if (ret < 0)
1298                 return ret;
1299
1300         m = file->private_data;
1301         m->private = PDE(inode)->data;
1302
1303         return 0;
1304 }
1305
1306 /*
1307  * set up the iterator to start reading from the volume list and return the first item
1308  */
1309 static void *nfs_volume_list_start(struct seq_file *m, loff_t *_pos)
1310 {
1311         struct list_head *_p;
1312         loff_t pos = *_pos;
1313
1314         /* lock the list against modification */
1315         spin_lock(&nfs_client_lock);
1316
1317         /* allow for the header line */
1318         if (!pos)
1319                 return SEQ_START_TOKEN;
1320         pos--;
1321
1322         /* find the n'th element in the list */
1323         list_for_each(_p, &nfs_volume_list)
1324                 if (!pos--)
1325                         break;
1326
1327         return _p != &nfs_volume_list ? _p : NULL;
1328 }
1329
1330 /*
1331  * move to next volume
1332  */
1333 static void *nfs_volume_list_next(struct seq_file *p, void *v, loff_t *pos)
1334 {
1335         struct list_head *_p;
1336
1337         (*pos)++;
1338
1339         _p = v;
1340         _p = (v == SEQ_START_TOKEN) ? nfs_volume_list.next : _p->next;
1341
1342         return _p != &nfs_volume_list ? _p : NULL;
1343 }
1344
1345 /*
1346  * clean up after reading from the transports list
1347  */
1348 static void nfs_volume_list_stop(struct seq_file *p, void *v)
1349 {
1350         spin_unlock(&nfs_client_lock);
1351 }
1352
1353 /*
1354  * display a header line followed by a load of call lines
1355  */
1356 static int nfs_volume_list_show(struct seq_file *m, void *v)
1357 {
1358         struct nfs_server *server;
1359         struct nfs_client *clp;
1360         char dev[8], fsid[17];
1361
1362         /* display header on line 1 */
1363         if (v == SEQ_START_TOKEN) {
1364                 seq_puts(m, "NV SERVER   PORT DEV     FSID\n");
1365                 return 0;
1366         }
1367         /* display one transport per line on subsequent lines */
1368         server = list_entry(v, struct nfs_server, master_link);
1369         clp = server->nfs_client;
1370
1371         snprintf(dev, 8, "%u:%u",
1372                  MAJOR(server->s_dev), MINOR(server->s_dev));
1373
1374         snprintf(fsid, 17, "%llx:%llx",
1375                  (unsigned long long) server->fsid.major,
1376                  (unsigned long long) server->fsid.minor);
1377
1378         seq_printf(m, "v%d %02x%02x%02x%02x %4hx %-7s %-17s\n",
1379                    clp->cl_nfsversion,
1380                    NIPQUAD(clp->cl_addr.sin_addr),
1381                    ntohs(clp->cl_addr.sin_port),
1382                    dev,
1383                    fsid);
1384
1385         return 0;
1386 }
1387
1388 /*
1389  * initialise the /proc/fs/nfsfs/ directory
1390  */
1391 int __init nfs_fs_proc_init(void)
1392 {
1393         struct proc_dir_entry *p;
1394
1395         proc_fs_nfs = proc_mkdir("nfsfs", proc_root_fs);
1396         if (!proc_fs_nfs)
1397                 goto error_0;
1398
1399         proc_fs_nfs->owner = THIS_MODULE;
1400
1401         /* a file of servers with which we're dealing */
1402         p = create_proc_entry("servers", S_IFREG|S_IRUGO, proc_fs_nfs);
1403         if (!p)
1404                 goto error_1;
1405
1406         p->proc_fops = &nfs_server_list_fops;
1407         p->owner = THIS_MODULE;
1408
1409         /* a file of volumes that we have mounted */
1410         p = create_proc_entry("volumes", S_IFREG|S_IRUGO, proc_fs_nfs);
1411         if (!p)
1412                 goto error_2;
1413
1414         p->proc_fops = &nfs_volume_list_fops;
1415         p->owner = THIS_MODULE;
1416         return 0;
1417
1418 error_2:
1419         remove_proc_entry("servers", proc_fs_nfs);
1420 error_1:
1421         remove_proc_entry("nfsfs", proc_root_fs);
1422 error_0:
1423         return -ENOMEM;
1424 }
1425
1426 /*
1427  * clean up the /proc/fs/nfsfs/ directory
1428  */
1429 void nfs_fs_proc_exit(void)
1430 {
1431         remove_proc_entry("volumes", proc_fs_nfs);
1432         remove_proc_entry("servers", proc_fs_nfs);
1433         remove_proc_entry("nfsfs", proc_root_fs);
1434 }
1435
1436 #endif /* CONFIG_PROC_FS */