fs/nfs/proc.c

   1 /*
   2  *  linux/fs/nfs/proc.c
   3  *
   4  *  Copyright (C) 1992, 1993, 1994  Rick Sladkey
   5  *
   6  *  OS-independent nfs remote procedure call functions
   7  *
   8  *  Tuned by Alan Cox <A.Cox@swansea.ac.uk> for >3K buffers
   9  *  so at last we can have decent(ish) throughput off a
  10  *  Sun server.
  11  *
  12  *  Coding optimized and cleaned up by Florian La Roche.
  13  *  Note: Error returns are optimized for NFS_OK, which isn't translated via
  14  *  nfs_stat_to_errno(), but happens to be already the right return code.
  15  *
  16  *  Also, the code currently doesn't check the size of the packet, when
  17  *  it decodes the packet.
  18  *
  19  *  Feel free to fix it and mail me the diffs if it worries you.
  20  *
  21  *  Completely rewritten to support the new RPC call interface;
  22  *  rewrote and moved the entire XDR stuff to xdr.c
  23  *  --Olaf Kirch June 1996
  24  *
  25  *  The code below initializes all auto variables explicitly, otherwise
  26  *  it will fail to work as a module (gcc generates a memset call for an
  27  *  incomplete struct).
  28  */
  29
  30 #include <linux/types.h>
  31 #include <linux/param.h>
  32 #include <linux/slab.h>
  33 #include <linux/time.h>
  34 #include <linux/mm.h>
  35 #include <linux/utsname.h>
  36 #include <linux/errno.h>
  37 #include <linux/string.h>
  38 #include <linux/in.h>
  39 #include <linux/pagemap.h>
  40 #include <linux/sunrpc/clnt.h>
  41 #include <linux/nfs.h>
  42 #include <linux/nfs2.h>
  43 #include <linux/nfs_fs.h>
  44 #include <linux/nfs_page.h>
  45 #include <linux/lockd/bind.h>
  46 #include "internal.h"
  47
  48 #define NFSDBG_FACILITY         NFSDBG_PROC
  49
  50 /*
  51  * Bare-bones access to getattr: this is for nfs_read_super.
  52  */
  53 static int
  54 nfs_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
  55                   struct nfs_fsinfo *info)
  56 {
  57         struct nfs_fattr *fattr = info->fattr;
  58         struct nfs2_fsstat fsinfo;
  59         struct rpc_message msg = {
  60                 .rpc_proc       = &nfs_procedures[NFSPROC_GETATTR],
  61                 .rpc_argp       = fhandle,
  62                 .rpc_resp       = fattr,
  63         };
  64         int status;
  65
  66         dprintk("%s: call getattr\n", __func__);
  67         nfs_fattr_init(fattr);
  68         status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
  69         dprintk("%s: reply getattr: %d\n", __func__, status);
  70         if (status)
  71                 return status;
  72         dprintk("%s: call statfs\n", __func__);
  73         msg.rpc_proc = &nfs_procedures[NFSPROC_STATFS];
  74         msg.rpc_resp = &fsinfo;
  75         status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
  76         dprintk("%s: reply statfs: %d\n", __func__, status);
  77         if (status)
  78                 return status;
  79         info->rtmax  = NFS_MAXDATA;
  80         info->rtpref = fsinfo.tsize;
  81         info->rtmult = fsinfo.bsize;
  82         info->wtmax  = NFS_MAXDATA;
  83         info->wtpref = fsinfo.tsize;
  84         info->wtmult = fsinfo.bsize;
  85         info->dtpref = fsinfo.tsize;
  86         info->maxfilesize = 0x7FFFFFFF;
  87         info->lease_time = 0;
  88         return 0;
  89 }
  90
  91 /*
  92  * One function for each procedure in the NFS protocol.
  93  */
  94 static int
  95 nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
  96                 struct nfs_fattr *fattr)
  97 {
  98         struct rpc_message msg = {
  99                 .rpc_proc       = &nfs_procedures[NFSPROC_GETATTR],
 100                 .rpc_argp       = fhandle,
 101                 .rpc_resp       = fattr,
 102         };
 103         int     status;
 104
 105         dprintk("NFS call  getattr\n");
 106         nfs_fattr_init(fattr);
 107         status = rpc_call_sync(server->client, &msg, 0);
 108         dprintk("NFS reply getattr: %d\n", status);
 109         return status;
 110 }
 111
 112 static int
 113 nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
 114                  struct iattr *sattr)
 115 {
 116         struct inode *inode = dentry->d_inode;
 117         struct nfs_sattrargs    arg = {
 118                 .fh     = NFS_FH(inode),
 119                 .sattr  = sattr
 120         };
 121         struct rpc_message msg = {
 122                 .rpc_proc       = &nfs_procedures[NFSPROC_SETATTR],
 123                 .rpc_argp       = &arg,
 124                 .rpc_resp       = fattr,
 125         };
 126         int     status;
 127
 128         /* Mask out the non-modebit related stuff from attr->ia_mode */
 129         sattr->ia_mode &= S_IALLUGO;
 130
 131         dprintk("NFS call  setattr\n");
 132         nfs_fattr_init(fattr);
 133         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
 134         if (status == 0)
 135                 nfs_setattr_update_inode(inode, sattr);
 136         dprintk("NFS reply setattr: %d\n", status);
 137         return status;
 138 }
 139
 140 static int
 141 nfs_proc_lookup(struct inode *dir, struct qstr *name,
 142                 struct nfs_fh *fhandle, struct nfs_fattr *fattr)
 143 {
 144         struct nfs_diropargs    arg = {
 145                 .fh             = NFS_FH(dir),
 146                 .name           = name->name,
 147                 .len            = name->len
 148         };
 149         struct nfs_diropok      res = {
 150                 .fh             = fhandle,
 151                 .fattr          = fattr
 152         };
 153         struct rpc_message msg = {
 154                 .rpc_proc       = &nfs_procedures[NFSPROC_LOOKUP],
 155                 .rpc_argp       = &arg,
 156                 .rpc_resp       = &res,
 157         };
 158         int                     status;
 159
 160         dprintk("NFS call  lookup %s\n", name->name);
 161         nfs_fattr_init(fattr);
 162         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 163         dprintk("NFS reply lookup: %d\n", status);
 164         return status;
 165 }
 166
 167 static int nfs_proc_readlink(struct inode *inode, struct page *page,
 168                 unsigned int pgbase, unsigned int pglen)
 169 {
 170         struct nfs_readlinkargs args = {
 171                 .fh             = NFS_FH(inode),
 172                 .pgbase         = pgbase,
 173                 .pglen          = pglen,
 174                 .pages          = &page
 175         };
 176         struct rpc_message msg = {
 177                 .rpc_proc       = &nfs_procedures[NFSPROC_READLINK],
 178                 .rpc_argp       = &args,
 179         };
 180         int                     status;
 181
 182         dprintk("NFS call  readlink\n");
 183         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
 184         dprintk("NFS reply readlink: %d\n", status);
 185         return status;
 186 }
 187
 188 static int
 189 nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
 190                 int flags, struct nameidata *nd)
 191 {
 192         struct nfs_fh           fhandle;
 193         struct nfs_fattr        fattr;
 194         struct nfs_createargs   arg = {
 195                 .fh             = NFS_FH(dir),
 196                 .name           = dentry->d_name.name,
 197                 .len            = dentry->d_name.len,
 198                 .sattr          = sattr
 199         };
 200         struct nfs_diropok      res = {
 201                 .fh             = &fhandle,
 202                 .fattr          = &fattr
 203         };
 204         struct rpc_message msg = {
 205                 .rpc_proc       = &nfs_procedures[NFSPROC_CREATE],
 206                 .rpc_argp       = &arg,
 207                 .rpc_resp       = &res,
 208         };
 209         int                     status;
 210
 211         nfs_fattr_init(&fattr);
 212         dprintk("NFS call  create %s\n", dentry->d_name.name);
 213         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 214         nfs_mark_for_revalidate(dir);
 215         if (status == 0)
 216                 status = nfs_instantiate(dentry, &fhandle, &fattr);
 217         dprintk("NFS reply create: %d\n", status);
 218         return status;
 219 }
 220
 221 /*
 222  * In NFSv2, mknod is grafted onto the create call.
 223  */
 224 static int
 225 nfs_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
 226                dev_t rdev)
 227 {
 228         struct nfs_fh fhandle;
 229         struct nfs_fattr fattr;
 230         struct nfs_createargs   arg = {
 231                 .fh             = NFS_FH(dir),
 232                 .name           = dentry->d_name.name,
 233                 .len            = dentry->d_name.len,
 234                 .sattr          = sattr
 235         };
 236         struct nfs_diropok      res = {
 237                 .fh             = &fhandle,
 238                 .fattr          = &fattr
 239         };
 240         struct rpc_message msg = {
 241                 .rpc_proc       = &nfs_procedures[NFSPROC_CREATE],
 242                 .rpc_argp       = &arg,
 243                 .rpc_resp       = &res,
 244         };
 245         int status, mode;
 246
 247         dprintk("NFS call  mknod %s\n", dentry->d_name.name);
 248
 249         mode = sattr->ia_mode;
 250         if (S_ISFIFO(mode)) {
 251                 sattr->ia_mode = (mode & ~S_IFMT) | S_IFCHR;
 252                 sattr->ia_valid &= ~ATTR_SIZE;
 253         } else if (S_ISCHR(mode) || S_ISBLK(mode)) {
 254                 sattr->ia_valid |= ATTR_SIZE;
 255                 sattr->ia_size = new_encode_dev(rdev);/* get out your barf bag */
 256         }
 257
 258         nfs_fattr_init(&fattr);
 259         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 260         nfs_mark_for_revalidate(dir);
 261
 262         if (status == -EINVAL && S_ISFIFO(mode)) {
 263                 sattr->ia_mode = mode;
 264                 nfs_fattr_init(&fattr);
 265                 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 266         }
 267         if (status == 0)
 268                 status = nfs_instantiate(dentry, &fhandle, &fattr);
 269         dprintk("NFS reply mknod: %d\n", status);
 270         return status;
 271 }
 272
 273 static int
 274 nfs_proc_remove(struct inode *dir, struct qstr *name)
 275 {
 276         struct nfs_removeargs arg = {
 277                 .fh = NFS_FH(dir),
 278                 .name.len = name->len,
 279                 .name.name = name->name,
 280         };
 281         struct rpc_message msg = {
 282                 .rpc_proc = &nfs_procedures[NFSPROC_REMOVE],
 283                 .rpc_argp = &arg,
 284         };
 285         int                     status;
 286
 287         dprintk("NFS call  remove %s\n", name->name);
 288         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 289         nfs_mark_for_revalidate(dir);
 290
 291         dprintk("NFS reply remove: %d\n", status);
 292         return status;
 293 }
 294
 295 static void
 296 nfs_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
 297 {
 298         msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE];
 299 }
 300
 301 static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir)
 302 {
 303         nfs_mark_for_revalidate(dir);
 304         return 1;
 305 }
 306
 307 static int
 308 nfs_proc_rename(struct inode *old_dir, struct qstr *old_name,
 309                 struct inode *new_dir, struct qstr *new_name)
 310 {
 311         struct nfs_renameargs   arg = {
 312                 .fromfh         = NFS_FH(old_dir),
 313                 .fromname       = old_name->name,
 314                 .fromlen        = old_name->len,
 315                 .tofh           = NFS_FH(new_dir),
 316                 .toname         = new_name->name,
 317                 .tolen          = new_name->len
 318         };
 319         struct rpc_message msg = {
 320                 .rpc_proc       = &nfs_procedures[NFSPROC_RENAME],
 321                 .rpc_argp       = &arg,
 322         };
 323         int                     status;
 324
 325         dprintk("NFS call  rename %s -> %s\n", old_name->name, new_name->name);
 326         status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0);
 327         nfs_mark_for_revalidate(old_dir);
 328         nfs_mark_for_revalidate(new_dir);
 329         dprintk("NFS reply rename: %d\n", status);
 330         return status;
 331 }
 332
 333 static int
 334 nfs_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
 335 {
 336         struct nfs_linkargs     arg = {
 337                 .fromfh         = NFS_FH(inode),
 338                 .tofh           = NFS_FH(dir),
 339                 .toname         = name->name,
 340                 .tolen          = name->len
 341         };
 342         struct rpc_message msg = {
 343                 .rpc_proc       = &nfs_procedures[NFSPROC_LINK],
 344                 .rpc_argp       = &arg,
 345         };
 346         int                     status;
 347
 348         dprintk("NFS call  link %s\n", name->name);
 349         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
 350         nfs_mark_for_revalidate(inode);
 351         nfs_mark_for_revalidate(dir);
 352         dprintk("NFS reply link: %d\n", status);
 353         return status;
 354 }
 355
 356 static int
 357 nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
 358                  unsigned int len, struct iattr *sattr)
 359 {
 360         struct nfs_fh fhandle;
 361         struct nfs_fattr fattr;
 362         struct nfs_symlinkargs  arg = {
 363                 .fromfh         = NFS_FH(dir),
 364                 .fromname       = dentry->d_name.name,
 365                 .fromlen        = dentry->d_name.len,
 366                 .pages          = &page,
 367                 .pathlen        = len,
 368                 .sattr          = sattr
 369         };
 370         struct rpc_message msg = {
 371                 .rpc_proc       = &nfs_procedures[NFSPROC_SYMLINK],
 372                 .rpc_argp       = &arg,
 373         };
 374         int                     status;
 375
 376         if (len > NFS2_MAXPATHLEN)
 377                 return -ENAMETOOLONG;
 378
 379         dprintk("NFS call  symlink %s\n", dentry->d_name.name);
 380
 381         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 382         nfs_mark_for_revalidate(dir);
 383
 384         /*
 385          * V2 SYMLINK requests don't return any attributes.  Setting the
 386          * filehandle size to zero indicates to nfs_instantiate that it
 387          * should fill in the data with a LOOKUP call on the wire.
 388          */
 389         if (status == 0) {
 390                 nfs_fattr_init(&fattr);
 391                 fhandle.size = 0;
 392                 status = nfs_instantiate(dentry, &fhandle, &fattr);
 393         }
 394
 395         dprintk("NFS reply symlink: %d\n", status);
 396         return status;
 397 }
 398
 399 static int
 400 nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
 401 {
 402         struct nfs_fh fhandle;
 403         struct nfs_fattr fattr;
 404         struct nfs_createargs   arg = {
 405                 .fh             = NFS_FH(dir),
 406                 .name           = dentry->d_name.name,
 407                 .len            = dentry->d_name.len,
 408                 .sattr          = sattr
 409         };
 410         struct nfs_diropok      res = {
 411                 .fh             = &fhandle,
 412                 .fattr          = &fattr
 413         };
 414         struct rpc_message msg = {
 415                 .rpc_proc       = &nfs_procedures[NFSPROC_MKDIR],
 416                 .rpc_argp       = &arg,
 417                 .rpc_resp       = &res,
 418         };
 419         int                     status;
 420
 421         dprintk("NFS call  mkdir %s\n", dentry->d_name.name);
 422         nfs_fattr_init(&fattr);
 423         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 424         nfs_mark_for_revalidate(dir);
 425         if (status == 0)
 426                 status = nfs_instantiate(dentry, &fhandle, &fattr);
 427         dprintk("NFS reply mkdir: %d\n", status);
 428         return status;
 429 }
 430
 431 static int
 432 nfs_proc_rmdir(struct inode *dir, struct qstr *name)
 433 {
 434         struct nfs_diropargs    arg = {
 435                 .fh             = NFS_FH(dir),
 436                 .name           = name->name,
 437                 .len            = name->len
 438         };
 439         struct rpc_message msg = {
 440                 .rpc_proc       = &nfs_procedures[NFSPROC_RMDIR],
 441                 .rpc_argp       = &arg,
 442         };
 443         int                     status;
 444
 445         dprintk("NFS call  rmdir %s\n", name->name);
 446         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 447         nfs_mark_for_revalidate(dir);
 448         dprintk("NFS reply rmdir: %d\n", status);
 449         return status;
 450 }
 451
 452 /*
 453  * The READDIR implementation is somewhat hackish - we pass a temporary
 454  * buffer to the encode function, which installs it in the receive
 455  * the receive iovec. The decode function just parses the reply to make
 456  * sure it is syntactically correct; the entries itself are decoded
 457  * from nfs_readdir by calling the decode_entry function directly.
 458  */
 459 static int
 460 nfs_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
 461                  u64 cookie, struct page *page, unsigned int count, int plus)
 462 {
 463         struct inode            *dir = dentry->d_inode;
 464         struct nfs_readdirargs  arg = {
 465                 .fh             = NFS_FH(dir),
 466                 .cookie         = cookie,
 467                 .count          = count,
 468                 .pages          = &page,
 469         };
 470         struct rpc_message      msg = {
 471                 .rpc_proc       = &nfs_procedures[NFSPROC_READDIR],
 472                 .rpc_argp       = &arg,
 473                 .rpc_cred       = cred,
 474         };
 475         int                     status;
 476
 477         dprintk("NFS call  readdir %d\n", (unsigned int)cookie);
 478         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 479
 480         nfs_invalidate_atime(dir);
 481
 482         dprintk("NFS reply readdir: %d\n", status);
 483         return status;
 484 }
 485
 486 static int
 487 nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
 488                         struct nfs_fsstat *stat)
 489 {
 490         struct nfs2_fsstat fsinfo;
 491         struct rpc_message msg = {
 492                 .rpc_proc       = &nfs_procedures[NFSPROC_STATFS],
 493                 .rpc_argp       = fhandle,
 494                 .rpc_resp       = &fsinfo,
 495         };
 496         int     status;
 497
 498         dprintk("NFS call  statfs\n");
 499         nfs_fattr_init(stat->fattr);
 500         status = rpc_call_sync(server->client, &msg, 0);
 501         dprintk("NFS reply statfs: %d\n", status);
 502         if (status)
 503                 goto out;
 504         stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize;
 505         stat->fbytes = (u64)fsinfo.bfree  * fsinfo.bsize;
 506         stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize;
 507         stat->tfiles = 0;
 508         stat->ffiles = 0;
 509         stat->afiles = 0;
 510 out:
 511         return status;
 512 }
 513
 514 static int
 515 nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
 516                         struct nfs_fsinfo *info)
 517 {
 518         struct nfs2_fsstat fsinfo;
 519         struct rpc_message msg = {
 520                 .rpc_proc       = &nfs_procedures[NFSPROC_STATFS],
 521                 .rpc_argp       = fhandle,
 522                 .rpc_resp       = &fsinfo,
 523         };
 524         int     status;
 525
 526         dprintk("NFS call  fsinfo\n");
 527         nfs_fattr_init(info->fattr);
 528         status = rpc_call_sync(server->client, &msg, 0);
 529         dprintk("NFS reply fsinfo: %d\n", status);
 530         if (status)
 531                 goto out;
 532         info->rtmax  = NFS_MAXDATA;
 533         info->rtpref = fsinfo.tsize;
 534         info->rtmult = fsinfo.bsize;
 535         info->wtmax  = NFS_MAXDATA;
 536         info->wtpref = fsinfo.tsize;
 537         info->wtmult = fsinfo.bsize;
 538         info->dtpref = fsinfo.tsize;
 539         info->maxfilesize = 0x7FFFFFFF;
 540         info->lease_time = 0;
 541 out:
 542         return status;
 543 }
 544
 545 static int
 546 nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
 547                   struct nfs_pathconf *info)
 548 {
 549         info->max_link = 0;
 550         info->max_namelen = NFS2_MAXNAMLEN;
 551         return 0;
 552 }
 553
 554 static int nfs_read_done(struct rpc_task *task, struct nfs_read_data *data)
 555 {
 556         nfs_invalidate_atime(data->inode);
 557         if (task->tk_status >= 0) {
 558                 nfs_refresh_inode(data->inode, data->res.fattr);
 559                 /* Emulate the eof flag, which isn't normally needed in NFSv2
 560                  * as it is guaranteed to always return the file attributes
 561                  */
 562                 if (data->args.offset + data->args.count >= data->res.fattr->size)
 563                         data->res.eof = 1;
 564         }
 565         return 0;
 566 }
 567
 568 static void nfs_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)
 569 {
 570         msg->rpc_proc = &nfs_procedures[NFSPROC_READ];
 571 }
 572
 573 static int nfs_write_done(struct rpc_task *task, struct nfs_write_data *data)
 574 {
 575         if (task->tk_status >= 0)
 576                 nfs_post_op_update_inode_force_wcc(data->inode, data->res.fattr);
 577         return 0;
 578 }
 579
 580 static void nfs_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)
 581 {
 582         /* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */
 583         data->args.stable = NFS_FILE_SYNC;
 584         msg->rpc_proc = &nfs_procedures[NFSPROC_WRITE];
 585 }
 586
 587 static void
 588 nfs_proc_commit_setup(struct nfs_write_data *data, struct rpc_message *msg)
 589 {
 590         BUG();
 591 }
 592
 593 static int
 594 nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
 595 {
 596         struct inode *inode = filp->f_path.dentry->d_inode;
 597
 598         return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl);
 599 }
 600
 601
 602 const struct nfs_rpc_ops nfs_v2_clientops = {
 603         .version        = 2,                   /* protocol version */
 604         .dentry_ops     = &nfs_dentry_operations,
 605         .dir_inode_ops  = &nfs_dir_inode_operations,
 606         .file_inode_ops = &nfs_file_inode_operations,
 607         .getroot        = nfs_proc_get_root,
 608         .getattr        = nfs_proc_getattr,
 609         .setattr        = nfs_proc_setattr,
 610         .lookup         = nfs_proc_lookup,
 611         .access         = NULL,                /* access */
 612         .readlink       = nfs_proc_readlink,
 613         .create         = nfs_proc_create,
 614         .remove         = nfs_proc_remove,
 615         .unlink_setup   = nfs_proc_unlink_setup,
 616         .unlink_done    = nfs_proc_unlink_done,
 617         .rename         = nfs_proc_rename,
 618         .link           = nfs_proc_link,
 619         .symlink        = nfs_proc_symlink,
 620         .mkdir          = nfs_proc_mkdir,
 621         .rmdir          = nfs_proc_rmdir,
 622         .readdir        = nfs_proc_readdir,
 623         .mknod          = nfs_proc_mknod,
 624         .statfs         = nfs_proc_statfs,
 625         .fsinfo         = nfs_proc_fsinfo,
 626         .pathconf       = nfs_proc_pathconf,
 627         .decode_dirent  = nfs_decode_dirent,
 628         .read_setup     = nfs_proc_read_setup,
 629         .read_done      = nfs_read_done,
 630         .write_setup    = nfs_proc_write_setup,
 631         .write_done     = nfs_write_done,
 632         .commit_setup   = nfs_proc_commit_setup,
 633         .file_open      = nfs_open,
 634         .file_release   = nfs_release,
 635         .lock           = nfs_proc_lock,
 636 };