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/time.h>
  33 #include <linux/mm.h>
  34 #include <linux/errno.h>
  35 #include <linux/string.h>
  36 #include <linux/in.h>
  37 #include <linux/pagemap.h>
  38 #include <linux/sunrpc/clnt.h>
  39 #include <linux/nfs.h>
  40 #include <linux/nfs2.h>
  41 #include <linux/nfs_fs.h>
  42 #include <linux/nfs_page.h>
  43 #include <linux/lockd/bind.h>
  44 #include <linux/freezer.h>
  45 #include "internal.h"
  46
  47 #define NFSDBG_FACILITY         NFSDBG_PROC
  48
  49 /*
  50  * Bare-bones access to getattr: this is for nfs_read_super.
  51  */
  52 static int
  53 nfs_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
  54                   struct nfs_fsinfo *info)
  55 {
  56         struct nfs_fattr *fattr = info->fattr;
  57         struct nfs2_fsstat fsinfo;
  58         struct rpc_message msg = {
  59                 .rpc_proc       = &nfs_procedures[NFSPROC_GETATTR],
  60                 .rpc_argp       = fhandle,
  61                 .rpc_resp       = fattr,
  62         };
  63         int status;
  64
  65         dprintk("%s: call getattr\n", __func__);
  66         nfs_fattr_init(fattr);
  67         status = rpc_call_sync(server->client, &msg, 0);
  68         /* Retry with default authentication if different */
  69         if (status && server->nfs_client->cl_rpcclient != server->client)
  70                 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
  71         dprintk("%s: reply getattr: %d\n", __func__, status);
  72         if (status)
  73                 return status;
  74         dprintk("%s: call statfs\n", __func__);
  75         msg.rpc_proc = &nfs_procedures[NFSPROC_STATFS];
  76         msg.rpc_resp = &fsinfo;
  77         status = rpc_call_sync(server->client, &msg, 0);
  78         /* Retry with default authentication if different */
  79         if (status && server->nfs_client->cl_rpcclient != server->client)
  80                 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
  81         dprintk("%s: reply statfs: %d\n", __func__, status);
  82         if (status)
  83                 return status;
  84         info->rtmax  = NFS_MAXDATA;
  85         info->rtpref = fsinfo.tsize;
  86         info->rtmult = fsinfo.bsize;
  87         info->wtmax  = NFS_MAXDATA;
  88         info->wtpref = fsinfo.tsize;
  89         info->wtmult = fsinfo.bsize;
  90         info->dtpref = fsinfo.tsize;
  91         info->maxfilesize = 0x7FFFFFFF;
  92         info->lease_time = 0;
  93         return 0;
  94 }
  95
  96 /*
  97  * One function for each procedure in the NFS protocol.
  98  */
  99 static int
 100 nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
 101                 struct nfs_fattr *fattr)
 102 {
 103         struct rpc_message msg = {
 104                 .rpc_proc       = &nfs_procedures[NFSPROC_GETATTR],
 105                 .rpc_argp       = fhandle,
 106                 .rpc_resp       = fattr,
 107         };
 108         int     status;
 109
 110         dprintk("NFS call  getattr\n");
 111         nfs_fattr_init(fattr);
 112         status = rpc_call_sync(server->client, &msg, 0);
 113         dprintk("NFS reply getattr: %d\n", status);
 114         return status;
 115 }
 116
 117 static int
 118 nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
 119                  struct iattr *sattr)
 120 {
 121         struct inode *inode = dentry->d_inode;
 122         struct nfs_sattrargs    arg = {
 123                 .fh     = NFS_FH(inode),
 124                 .sattr  = sattr
 125         };
 126         struct rpc_message msg = {
 127                 .rpc_proc       = &nfs_procedures[NFSPROC_SETATTR],
 128                 .rpc_argp       = &arg,
 129                 .rpc_resp       = fattr,
 130         };
 131         int     status;
 132
 133         /* Mask out the non-modebit related stuff from attr->ia_mode */
 134         sattr->ia_mode &= S_IALLUGO;
 135
 136         dprintk("NFS call  setattr\n");
 137         if (sattr->ia_valid & ATTR_FILE)
 138                 msg.rpc_cred = nfs_file_cred(sattr->ia_file);
 139         nfs_fattr_init(fattr);
 140         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
 141         if (status == 0)
 142                 nfs_setattr_update_inode(inode, sattr);
 143         dprintk("NFS reply setattr: %d\n", status);
 144         return status;
 145 }
 146
 147 static int
 148 nfs_proc_lookup(struct inode *dir, struct qstr *name,
 149                 struct nfs_fh *fhandle, struct nfs_fattr *fattr)
 150 {
 151         struct nfs_diropargs    arg = {
 152                 .fh             = NFS_FH(dir),
 153                 .name           = name->name,
 154                 .len            = name->len
 155         };
 156         struct nfs_diropok      res = {
 157                 .fh             = fhandle,
 158                 .fattr          = fattr
 159         };
 160         struct rpc_message msg = {
 161                 .rpc_proc       = &nfs_procedures[NFSPROC_LOOKUP],
 162                 .rpc_argp       = &arg,
 163                 .rpc_resp       = &res,
 164         };
 165         int                     status;
 166
 167         dprintk("NFS call  lookup %s\n", name->name);
 168         nfs_fattr_init(fattr);
 169         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 170         dprintk("NFS reply lookup: %d\n", status);
 171         return status;
 172 }
 173
 174 static int nfs_proc_readlink(struct inode *inode, struct page *page,
 175                 unsigned int pgbase, unsigned int pglen)
 176 {
 177         struct nfs_readlinkargs args = {
 178                 .fh             = NFS_FH(inode),
 179                 .pgbase         = pgbase,
 180                 .pglen          = pglen,
 181                 .pages          = &page
 182         };
 183         struct rpc_message msg = {
 184                 .rpc_proc       = &nfs_procedures[NFSPROC_READLINK],
 185                 .rpc_argp       = &args,
 186         };
 187         int                     status;
 188
 189         dprintk("NFS call  readlink\n");
 190         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
 191         dprintk("NFS reply readlink: %d\n", status);
 192         return status;
 193 }
 194
 195 struct nfs_createdata {
 196         struct nfs_createargs arg;
 197         struct nfs_diropok res;
 198         struct nfs_fh fhandle;
 199         struct nfs_fattr fattr;
 200 };
 201
 202 static struct nfs_createdata *nfs_alloc_createdata(struct inode *dir,
 203                 struct dentry *dentry, struct iattr *sattr)
 204 {
 205         struct nfs_createdata *data;
 206
 207         data = kmalloc(sizeof(*data), GFP_KERNEL);
 208
 209         if (data != NULL) {
 210                 data->arg.fh = NFS_FH(dir);
 211                 data->arg.name = dentry->d_name.name;
 212                 data->arg.len = dentry->d_name.len;
 213                 data->arg.sattr = sattr;
 214                 nfs_fattr_init(&data->fattr);
 215                 data->fhandle.size = 0;
 216                 data->res.fh = &data->fhandle;
 217                 data->res.fattr = &data->fattr;
 218         }
 219         return data;
 220 };
 221
 222 static void nfs_free_createdata(const struct nfs_createdata *data)
 223 {
 224         kfree(data);
 225 }
 226
 227 static int
 228 nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
 229                 int flags)
 230 {
 231         struct nfs_createdata *data;
 232         struct rpc_message msg = {
 233                 .rpc_proc       = &nfs_procedures[NFSPROC_CREATE],
 234         };
 235         int status = -ENOMEM;
 236
 237         dprintk("NFS call  create %s\n", dentry->d_name.name);
 238         data = nfs_alloc_createdata(dir, dentry, sattr);
 239         if (data == NULL)
 240                 goto out;
 241         msg.rpc_argp = &data->arg;
 242         msg.rpc_resp = &data->res;
 243         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 244         nfs_mark_for_revalidate(dir);
 245         if (status == 0)
 246                 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
 247         nfs_free_createdata(data);
 248 out:
 249         dprintk("NFS reply create: %d\n", status);
 250         return status;
 251 }
 252
 253 /*
 254  * In NFSv2, mknod is grafted onto the create call.
 255  */
 256 static int
 257 nfs_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
 258                dev_t rdev)
 259 {
 260         struct nfs_createdata *data;
 261         struct rpc_message msg = {
 262                 .rpc_proc       = &nfs_procedures[NFSPROC_CREATE],
 263         };
 264         umode_t mode;
 265         int status = -ENOMEM;
 266
 267         dprintk("NFS call  mknod %s\n", dentry->d_name.name);
 268
 269         mode = sattr->ia_mode;
 270         if (S_ISFIFO(mode)) {
 271                 sattr->ia_mode = (mode & ~S_IFMT) | S_IFCHR;
 272                 sattr->ia_valid &= ~ATTR_SIZE;
 273         } else if (S_ISCHR(mode) || S_ISBLK(mode)) {
 274                 sattr->ia_valid |= ATTR_SIZE;
 275                 sattr->ia_size = new_encode_dev(rdev);/* get out your barf bag */
 276         }
 277
 278         data = nfs_alloc_createdata(dir, dentry, sattr);
 279         if (data == NULL)
 280                 goto out;
 281         msg.rpc_argp = &data->arg;
 282         msg.rpc_resp = &data->res;
 283
 284         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 285         nfs_mark_for_revalidate(dir);
 286
 287         if (status == -EINVAL && S_ISFIFO(mode)) {
 288                 sattr->ia_mode = mode;
 289                 nfs_fattr_init(data->res.fattr);
 290                 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 291         }
 292         if (status == 0)
 293                 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
 294         nfs_free_createdata(data);
 295 out:
 296         dprintk("NFS reply mknod: %d\n", status);
 297         return status;
 298 }
 299
 300 static int
 301 nfs_proc_remove(struct inode *dir, struct qstr *name)
 302 {
 303         struct nfs_removeargs arg = {
 304                 .fh = NFS_FH(dir),
 305                 .name = *name,
 306         };
 307         struct rpc_message msg = {
 308                 .rpc_proc = &nfs_procedures[NFSPROC_REMOVE],
 309                 .rpc_argp = &arg,
 310         };
 311         int                     status;
 312
 313         dprintk("NFS call  remove %s\n", name->name);
 314         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 315         nfs_mark_for_revalidate(dir);
 316
 317         dprintk("NFS reply remove: %d\n", status);
 318         return status;
 319 }
 320
 321 static void
 322 nfs_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
 323 {
 324         msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE];
 325 }
 326
 327 static void nfs_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
 328 {
 329         rpc_call_start(task);
 330 }
 331
 332 static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir)
 333 {
 334         nfs_mark_for_revalidate(dir);
 335         return 1;
 336 }
 337
 338 static void
 339 nfs_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
 340 {
 341         msg->rpc_proc = &nfs_procedures[NFSPROC_RENAME];
 342 }
 343
 344 static void nfs_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
 345 {
 346         rpc_call_start(task);
 347 }
 348
 349 static int
 350 nfs_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
 351                      struct inode *new_dir)
 352 {
 353         nfs_mark_for_revalidate(old_dir);
 354         nfs_mark_for_revalidate(new_dir);
 355         return 1;
 356 }
 357
 358 static int
 359 nfs_proc_rename(struct inode *old_dir, struct qstr *old_name,
 360                 struct inode *new_dir, struct qstr *new_name)
 361 {
 362         struct nfs_renameargs   arg = {
 363                 .old_dir        = NFS_FH(old_dir),
 364                 .old_name       = old_name,
 365                 .new_dir        = NFS_FH(new_dir),
 366                 .new_name       = new_name,
 367         };
 368         struct rpc_message msg = {
 369                 .rpc_proc       = &nfs_procedures[NFSPROC_RENAME],
 370                 .rpc_argp       = &arg,
 371         };
 372         int                     status;
 373
 374         dprintk("NFS call  rename %s -> %s\n", old_name->name, new_name->name);
 375         status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0);
 376         nfs_mark_for_revalidate(old_dir);
 377         nfs_mark_for_revalidate(new_dir);
 378         dprintk("NFS reply rename: %d\n", status);
 379         return status;
 380 }
 381
 382 static int
 383 nfs_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
 384 {
 385         struct nfs_linkargs     arg = {
 386                 .fromfh         = NFS_FH(inode),
 387                 .tofh           = NFS_FH(dir),
 388                 .toname         = name->name,
 389                 .tolen          = name->len
 390         };
 391         struct rpc_message msg = {
 392                 .rpc_proc       = &nfs_procedures[NFSPROC_LINK],
 393                 .rpc_argp       = &arg,
 394         };
 395         int                     status;
 396
 397         dprintk("NFS call  link %s\n", name->name);
 398         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
 399         nfs_mark_for_revalidate(inode);
 400         nfs_mark_for_revalidate(dir);
 401         dprintk("NFS reply link: %d\n", status);
 402         return status;
 403 }
 404
 405 static int
 406 nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
 407                  unsigned int len, struct iattr *sattr)
 408 {
 409         struct nfs_fh *fh;
 410         struct nfs_fattr *fattr;
 411         struct nfs_symlinkargs  arg = {
 412                 .fromfh         = NFS_FH(dir),
 413                 .fromname       = dentry->d_name.name,
 414                 .fromlen        = dentry->d_name.len,
 415                 .pages          = &page,
 416                 .pathlen        = len,
 417                 .sattr          = sattr
 418         };
 419         struct rpc_message msg = {
 420                 .rpc_proc       = &nfs_procedures[NFSPROC_SYMLINK],
 421                 .rpc_argp       = &arg,
 422         };
 423         int status = -ENAMETOOLONG;
 424
 425         dprintk("NFS call  symlink %s\n", dentry->d_name.name);
 426
 427         if (len > NFS2_MAXPATHLEN)
 428                 goto out;
 429
 430         fh = nfs_alloc_fhandle();
 431         fattr = nfs_alloc_fattr();
 432         status = -ENOMEM;
 433         if (fh == NULL || fattr == NULL)
 434                 goto out_free;
 435
 436         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 437         nfs_mark_for_revalidate(dir);
 438
 439         /*
 440          * V2 SYMLINK requests don't return any attributes.  Setting the
 441          * filehandle size to zero indicates to nfs_instantiate that it
 442          * should fill in the data with a LOOKUP call on the wire.
 443          */
 444         if (status == 0)
 445                 status = nfs_instantiate(dentry, fh, fattr);
 446
 447 out_free:
 448         nfs_free_fattr(fattr);
 449         nfs_free_fhandle(fh);
 450 out:
 451         dprintk("NFS reply symlink: %d\n", status);
 452         return status;
 453 }
 454
 455 static int
 456 nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
 457 {
 458         struct nfs_createdata *data;
 459         struct rpc_message msg = {
 460                 .rpc_proc       = &nfs_procedures[NFSPROC_MKDIR],
 461         };
 462         int status = -ENOMEM;
 463
 464         dprintk("NFS call  mkdir %s\n", dentry->d_name.name);
 465         data = nfs_alloc_createdata(dir, dentry, sattr);
 466         if (data == NULL)
 467                 goto out;
 468         msg.rpc_argp = &data->arg;
 469         msg.rpc_resp = &data->res;
 470
 471         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 472         nfs_mark_for_revalidate(dir);
 473         if (status == 0)
 474                 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
 475         nfs_free_createdata(data);
 476 out:
 477         dprintk("NFS reply mkdir: %d\n", status);
 478         return status;
 479 }
 480
 481 static int
 482 nfs_proc_rmdir(struct inode *dir, struct qstr *name)
 483 {
 484         struct nfs_diropargs    arg = {
 485                 .fh             = NFS_FH(dir),
 486                 .name           = name->name,
 487                 .len            = name->len
 488         };
 489         struct rpc_message msg = {
 490                 .rpc_proc       = &nfs_procedures[NFSPROC_RMDIR],
 491                 .rpc_argp       = &arg,
 492         };
 493         int                     status;
 494
 495         dprintk("NFS call  rmdir %s\n", name->name);
 496         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 497         nfs_mark_for_revalidate(dir);
 498         dprintk("NFS reply rmdir: %d\n", status);
 499         return status;
 500 }
 501
 502 /*
 503  * The READDIR implementation is somewhat hackish - we pass a temporary
 504  * buffer to the encode function, which installs it in the receive
 505  * the receive iovec. The decode function just parses the reply to make
 506  * sure it is syntactically correct; the entries itself are decoded
 507  * from nfs_readdir by calling the decode_entry function directly.
 508  */
 509 static int
 510 nfs_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
 511                  u64 cookie, struct page **pages, unsigned int count, int plus)
 512 {
 513         struct inode            *dir = dentry->d_inode;
 514         struct nfs_readdirargs  arg = {
 515                 .fh             = NFS_FH(dir),
 516                 .cookie         = cookie,
 517                 .count          = count,
 518                 .pages          = pages,
 519         };
 520         struct rpc_message      msg = {
 521                 .rpc_proc       = &nfs_procedures[NFSPROC_READDIR],
 522                 .rpc_argp       = &arg,
 523                 .rpc_cred       = cred,
 524         };
 525         int                     status;
 526
 527         dprintk("NFS call  readdir %d\n", (unsigned int)cookie);
 528         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 529
 530         nfs_invalidate_atime(dir);
 531
 532         dprintk("NFS reply readdir: %d\n", status);
 533         return status;
 534 }
 535
 536 static int
 537 nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
 538                         struct nfs_fsstat *stat)
 539 {
 540         struct nfs2_fsstat fsinfo;
 541         struct rpc_message msg = {
 542                 .rpc_proc       = &nfs_procedures[NFSPROC_STATFS],
 543                 .rpc_argp       = fhandle,
 544                 .rpc_resp       = &fsinfo,
 545         };
 546         int     status;
 547
 548         dprintk("NFS call  statfs\n");
 549         nfs_fattr_init(stat->fattr);
 550         status = rpc_call_sync(server->client, &msg, 0);
 551         dprintk("NFS reply statfs: %d\n", status);
 552         if (status)
 553                 goto out;
 554         stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize;
 555         stat->fbytes = (u64)fsinfo.bfree  * fsinfo.bsize;
 556         stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize;
 557         stat->tfiles = 0;
 558         stat->ffiles = 0;
 559         stat->afiles = 0;
 560 out:
 561         return status;
 562 }
 563
 564 static int
 565 nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
 566                         struct nfs_fsinfo *info)
 567 {
 568         struct nfs2_fsstat fsinfo;
 569         struct rpc_message msg = {
 570                 .rpc_proc       = &nfs_procedures[NFSPROC_STATFS],
 571                 .rpc_argp       = fhandle,
 572                 .rpc_resp       = &fsinfo,
 573         };
 574         int     status;
 575
 576         dprintk("NFS call  fsinfo\n");
 577         nfs_fattr_init(info->fattr);
 578         status = rpc_call_sync(server->client, &msg, 0);
 579         dprintk("NFS reply fsinfo: %d\n", status);
 580         if (status)
 581                 goto out;
 582         info->rtmax  = NFS_MAXDATA;
 583         info->rtpref = fsinfo.tsize;
 584         info->rtmult = fsinfo.bsize;
 585         info->wtmax  = NFS_MAXDATA;
 586         info->wtpref = fsinfo.tsize;
 587         info->wtmult = fsinfo.bsize;
 588         info->dtpref = fsinfo.tsize;
 589         info->maxfilesize = 0x7FFFFFFF;
 590         info->lease_time = 0;
 591 out:
 592         return status;
 593 }
 594
 595 static int
 596 nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
 597                   struct nfs_pathconf *info)
 598 {
 599         info->max_link = 0;
 600         info->max_namelen = NFS2_MAXNAMLEN;
 601         return 0;
 602 }
 603
 604 static int nfs_read_done(struct rpc_task *task, struct nfs_read_data *data)
 605 {
 606         struct inode *inode = data->header->inode;
 607
 608         nfs_invalidate_atime(inode);
 609         if (task->tk_status >= 0) {
 610                 nfs_refresh_inode(inode, data->res.fattr);
 611                 /* Emulate the eof flag, which isn't normally needed in NFSv2
 612                  * as it is guaranteed to always return the file attributes
 613                  */
 614                 if (data->args.offset + data->res.count >= data->res.fattr->size)
 615                         data->res.eof = 1;
 616         }
 617         return 0;
 618 }
 619
 620 static void nfs_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)
 621 {
 622         msg->rpc_proc = &nfs_procedures[NFSPROC_READ];
 623 }
 624
 625 static void nfs_proc_read_rpc_prepare(struct rpc_task *task, struct nfs_read_data *data)
 626 {
 627         rpc_call_start(task);
 628 }
 629
 630 static int nfs_write_done(struct rpc_task *task, struct nfs_write_data *data)
 631 {
 632         struct inode *inode = data->header->inode;
 633
 634         if (task->tk_status >= 0)
 635                 nfs_post_op_update_inode_force_wcc(inode, data->res.fattr);
 636         return 0;
 637 }
 638
 639 static void nfs_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)
 640 {
 641         /* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */
 642         data->args.stable = NFS_FILE_SYNC;
 643         msg->rpc_proc = &nfs_procedures[NFSPROC_WRITE];
 644 }
 645
 646 static void nfs_proc_write_rpc_prepare(struct rpc_task *task, struct nfs_write_data *data)
 647 {
 648         rpc_call_start(task);
 649 }
 650
 651 static void nfs_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
 652 {
 653         BUG();
 654 }
 655
 656 static void
 657 nfs_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
 658 {
 659         BUG();
 660 }
 661
 662 static int
 663 nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
 664 {
 665         struct inode *inode = file_inode(filp);
 666
 667         return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl);
 668 }
 669
 670 /* Helper functions for NFS lock bounds checking */
 671 #define NFS_LOCK32_OFFSET_MAX ((__s32)0x7fffffffUL)
 672 static int nfs_lock_check_bounds(const struct file_lock *fl)
 673 {
 674         __s32 start, end;
 675
 676         start = (__s32)fl->fl_start;
 677         if ((loff_t)start != fl->fl_start)
 678                 goto out_einval;
 679
 680         if (fl->fl_end != OFFSET_MAX) {
 681                 end = (__s32)fl->fl_end;
 682                 if ((loff_t)end != fl->fl_end)
 683                         goto out_einval;
 684         } else
 685                 end = NFS_LOCK32_OFFSET_MAX;
 686
 687         if (start < 0 || start > end)
 688                 goto out_einval;
 689         return 0;
 690 out_einval:
 691         return -EINVAL;
 692 }
 693
 694 static int nfs_have_delegation(struct inode *inode, fmode_t flags)
 695 {
 696         return 0;
 697 }
 698
 699 static int nfs_return_delegation(struct inode *inode)
 700 {
 701         nfs_wb_all(inode);
 702         return 0;
 703 }
 704
 705 static const struct inode_operations nfs_dir_inode_operations = {
 706         .create         = nfs_create,
 707         .lookup         = nfs_lookup,
 708         .link           = nfs_link,
 709         .unlink         = nfs_unlink,
 710         .symlink        = nfs_symlink,
 711         .mkdir          = nfs_mkdir,
 712         .rmdir          = nfs_rmdir,
 713         .mknod          = nfs_mknod,
 714         .rename         = nfs_rename,
 715         .permission     = nfs_permission,
 716         .getattr        = nfs_getattr,
 717         .setattr        = nfs_setattr,
 718 };
 719
 720 static const struct inode_operations nfs_file_inode_operations = {
 721         .permission     = nfs_permission,
 722         .getattr        = nfs_getattr,
 723         .setattr        = nfs_setattr,
 724 };
 725
 726 const struct nfs_rpc_ops nfs_v2_clientops = {
 727         .version        = 2,                   /* protocol version */
 728         .dentry_ops     = &nfs_dentry_operations,
 729         .dir_inode_ops  = &nfs_dir_inode_operations,
 730         .file_inode_ops = &nfs_file_inode_operations,
 731         .file_ops       = &nfs_file_operations,
 732         .getroot        = nfs_proc_get_root,
 733         .submount       = nfs_submount,
 734         .try_mount      = nfs_try_mount,
 735         .getattr        = nfs_proc_getattr,
 736         .setattr        = nfs_proc_setattr,
 737         .lookup         = nfs_proc_lookup,
 738         .access         = NULL,                /* access */
 739         .readlink       = nfs_proc_readlink,
 740         .create         = nfs_proc_create,
 741         .remove         = nfs_proc_remove,
 742         .unlink_setup   = nfs_proc_unlink_setup,
 743         .unlink_rpc_prepare = nfs_proc_unlink_rpc_prepare,
 744         .unlink_done    = nfs_proc_unlink_done,
 745         .rename         = nfs_proc_rename,
 746         .rename_setup   = nfs_proc_rename_setup,
 747         .rename_rpc_prepare = nfs_proc_rename_rpc_prepare,
 748         .rename_done    = nfs_proc_rename_done,
 749         .link           = nfs_proc_link,
 750         .symlink        = nfs_proc_symlink,
 751         .mkdir          = nfs_proc_mkdir,
 752         .rmdir          = nfs_proc_rmdir,
 753         .readdir        = nfs_proc_readdir,
 754         .mknod          = nfs_proc_mknod,
 755         .statfs         = nfs_proc_statfs,
 756         .fsinfo         = nfs_proc_fsinfo,
 757         .pathconf       = nfs_proc_pathconf,
 758         .decode_dirent  = nfs2_decode_dirent,
 759         .read_setup     = nfs_proc_read_setup,
 760         .read_pageio_init = nfs_pageio_init_read,
 761         .read_rpc_prepare = nfs_proc_read_rpc_prepare,
 762         .read_done      = nfs_read_done,
 763         .write_setup    = nfs_proc_write_setup,
 764         .write_pageio_init = nfs_pageio_init_write,
 765         .write_rpc_prepare = nfs_proc_write_rpc_prepare,
 766         .write_done     = nfs_write_done,
 767         .commit_setup   = nfs_proc_commit_setup,
 768         .commit_rpc_prepare = nfs_proc_commit_rpc_prepare,
 769         .lock           = nfs_proc_lock,
 770         .lock_check_bounds = nfs_lock_check_bounds,
 771         .close_context  = nfs_close_context,
 772         .have_delegation = nfs_have_delegation,
 773         .return_delegation = nfs_return_delegation,
 774         .alloc_client   = nfs_alloc_client,
 775         .init_client    = nfs_init_client,
 776         .free_client    = nfs_free_client,
 777         .create_server  = nfs_create_server,
 778         .clone_server   = nfs_clone_server,
 779 };