fs/nfs/nfs3proc.c

   1 /*
   2  *  linux/fs/nfs/nfs3proc.c
   3  *
   4  *  Client-side NFSv3 procedures stubs.
   5  *
   6  *  Copyright (C) 1997, Olaf Kirch
   7  */
   8
   9 #include <linux/mm.h>
  10 #include <linux/utsname.h>
  11 #include <linux/errno.h>
  12 #include <linux/string.h>
  13 #include <linux/sunrpc/clnt.h>
  14 #include <linux/nfs.h>
  15 #include <linux/nfs3.h>
  16 #include <linux/nfs_fs.h>
  17 #include <linux/nfs_page.h>
  18 #include <linux/lockd/bind.h>
  19 #include <linux/smp_lock.h>
  20 #include <linux/nfs_mount.h>
  21
  22 #include "iostat.h"
  23 #include "internal.h"
  24
  25 #define NFSDBG_FACILITY         NFSDBG_PROC
  26
  27 /* A wrapper to handle the EJUKEBOX error message */
  28 static int
  29 nfs3_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
  30 {
  31         sigset_t oldset;
  32         int res;
  33         rpc_clnt_sigmask(clnt, &oldset);
  34         do {
  35                 res = rpc_call_sync(clnt, msg, flags);
  36                 if (res != -EJUKEBOX)
  37                         break;
  38                 schedule_timeout_interruptible(NFS_JUKEBOX_RETRY_TIME);
  39                 res = -ERESTARTSYS;
  40         } while (!signalled());
  41         rpc_clnt_sigunmask(clnt, &oldset);
  42         return res;
  43 }
  44
  45 #define rpc_call_sync(clnt, msg, flags) nfs3_rpc_wrapper(clnt, msg, flags)
  46
  47 static int
  48 nfs3_async_handle_jukebox(struct rpc_task *task, struct inode *inode)
  49 {
  50         if (task->tk_status != -EJUKEBOX)
  51                 return 0;
  52         nfs_inc_stats(inode, NFSIOS_DELAY);
  53         task->tk_status = 0;
  54         rpc_restart_call(task);
  55         rpc_delay(task, NFS_JUKEBOX_RETRY_TIME);
  56         return 1;
  57 }
  58
  59 static int
  60 do_proc_get_root(struct rpc_clnt *client, struct nfs_fh *fhandle,
  61                  struct nfs_fsinfo *info)
  62 {
  63         struct rpc_message msg = {
  64                 .rpc_proc       = &nfs3_procedures[NFS3PROC_FSINFO],
  65                 .rpc_argp       = fhandle,
  66                 .rpc_resp       = info,
  67         };
  68         int     status;
  69
  70         dprintk("%s: call  fsinfo\n", __FUNCTION__);
  71         nfs_fattr_init(info->fattr);
  72         status = rpc_call_sync(client, &msg, 0);
  73         dprintk("%s: reply fsinfo: %d\n", __FUNCTION__, status);
  74         if (!(info->fattr->valid & NFS_ATTR_FATTR)) {
  75                 msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR];
  76                 msg.rpc_resp = info->fattr;
  77                 status = rpc_call_sync(client, &msg, 0);
  78                 dprintk("%s: reply getattr: %d\n", __FUNCTION__, status);
  79         }
  80         return status;
  81 }
  82
  83 /*
  84  * Bare-bones access to getattr: this is for nfs_get_root/nfs_get_sb
  85  */
  86 static int
  87 nfs3_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
  88                    struct nfs_fsinfo *info)
  89 {
  90         int     status;
  91
  92         status = do_proc_get_root(server->client, fhandle, info);
  93         if (status && server->nfs_client->cl_rpcclient != server->client)
  94                 status = do_proc_get_root(server->nfs_client->cl_rpcclient, fhandle, info);
  95         return status;
  96 }
  97
  98 /*
  99  * One function for each procedure in the NFS protocol.
 100  */
 101 static int
 102 nfs3_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
 103                 struct nfs_fattr *fattr)
 104 {
 105         struct rpc_message msg = {
 106                 .rpc_proc       = &nfs3_procedures[NFS3PROC_GETATTR],
 107                 .rpc_argp       = fhandle,
 108                 .rpc_resp       = fattr,
 109         };
 110         int     status;
 111
 112         dprintk("NFS call  getattr\n");
 113         nfs_fattr_init(fattr);
 114         status = rpc_call_sync(server->client, &msg, 0);
 115         dprintk("NFS reply getattr: %d\n", status);
 116         return status;
 117 }
 118
 119 static int
 120 nfs3_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
 121                         struct iattr *sattr)
 122 {
 123         struct inode *inode = dentry->d_inode;
 124         struct nfs3_sattrargs   arg = {
 125                 .fh             = NFS_FH(inode),
 126                 .sattr          = sattr,
 127         };
 128         struct rpc_message msg = {
 129                 .rpc_proc       = &nfs3_procedures[NFS3PROC_SETATTR],
 130                 .rpc_argp       = &arg,
 131                 .rpc_resp       = fattr,
 132         };
 133         int     status;
 134
 135         dprintk("NFS call  setattr\n");
 136         nfs_fattr_init(fattr);
 137         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
 138         if (status == 0)
 139                 nfs_setattr_update_inode(inode, sattr);
 140         dprintk("NFS reply setattr: %d\n", status);
 141         return status;
 142 }
 143
 144 static int
 145 nfs3_proc_lookup(struct inode *dir, struct qstr *name,
 146                  struct nfs_fh *fhandle, struct nfs_fattr *fattr)
 147 {
 148         struct nfs_fattr        dir_attr;
 149         struct nfs3_diropargs   arg = {
 150                 .fh             = NFS_FH(dir),
 151                 .name           = name->name,
 152                 .len            = name->len
 153         };
 154         struct nfs3_diropres    res = {
 155                 .dir_attr       = &dir_attr,
 156                 .fh             = fhandle,
 157                 .fattr          = fattr
 158         };
 159         struct rpc_message msg = {
 160                 .rpc_proc       = &nfs3_procedures[NFS3PROC_LOOKUP],
 161                 .rpc_argp       = &arg,
 162                 .rpc_resp       = &res,
 163         };
 164         int                     status;
 165
 166         dprintk("NFS call  lookup %s\n", name->name);
 167         nfs_fattr_init(&dir_attr);
 168         nfs_fattr_init(fattr);
 169         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 170         if (status >= 0 && !(fattr->valid & NFS_ATTR_FATTR)) {
 171                 msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR];
 172                 msg.rpc_argp = fhandle;
 173                 msg.rpc_resp = fattr;
 174                 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 175         }
 176         dprintk("NFS reply lookup: %d\n", status);
 177         if (status >= 0)
 178                 status = nfs_refresh_inode(dir, &dir_attr);
 179         return status;
 180 }
 181
 182 static int nfs3_proc_access(struct inode *inode, struct nfs_access_entry *entry)
 183 {
 184         struct nfs_fattr        fattr;
 185         struct nfs3_accessargs  arg = {
 186                 .fh             = NFS_FH(inode),
 187         };
 188         struct nfs3_accessres   res = {
 189                 .fattr          = &fattr,
 190         };
 191         struct rpc_message msg = {
 192                 .rpc_proc       = &nfs3_procedures[NFS3PROC_ACCESS],
 193                 .rpc_argp       = &arg,
 194                 .rpc_resp       = &res,
 195                 .rpc_cred       = entry->cred,
 196         };
 197         int mode = entry->mask;
 198         int status;
 199
 200         dprintk("NFS call  access\n");
 201
 202         if (mode & MAY_READ)
 203                 arg.access |= NFS3_ACCESS_READ;
 204         if (S_ISDIR(inode->i_mode)) {
 205                 if (mode & MAY_WRITE)
 206                         arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND | NFS3_ACCESS_DELETE;
 207                 if (mode & MAY_EXEC)
 208                         arg.access |= NFS3_ACCESS_LOOKUP;
 209         } else {
 210                 if (mode & MAY_WRITE)
 211                         arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND;
 212                 if (mode & MAY_EXEC)
 213                         arg.access |= NFS3_ACCESS_EXECUTE;
 214         }
 215         nfs_fattr_init(&fattr);
 216         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
 217         nfs_refresh_inode(inode, &fattr);
 218         if (status == 0) {
 219                 entry->mask = 0;
 220                 if (res.access & NFS3_ACCESS_READ)
 221                         entry->mask |= MAY_READ;
 222                 if (res.access & (NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND | NFS3_ACCESS_DELETE))
 223                         entry->mask |= MAY_WRITE;
 224                 if (res.access & (NFS3_ACCESS_LOOKUP|NFS3_ACCESS_EXECUTE))
 225                         entry->mask |= MAY_EXEC;
 226         }
 227         dprintk("NFS reply access: %d\n", status);
 228         return status;
 229 }
 230
 231 static int nfs3_proc_readlink(struct inode *inode, struct page *page,
 232                 unsigned int pgbase, unsigned int pglen)
 233 {
 234         struct nfs_fattr        fattr;
 235         struct nfs3_readlinkargs args = {
 236                 .fh             = NFS_FH(inode),
 237                 .pgbase         = pgbase,
 238                 .pglen          = pglen,
 239                 .pages          = &page
 240         };
 241         struct rpc_message msg = {
 242                 .rpc_proc       = &nfs3_procedures[NFS3PROC_READLINK],
 243                 .rpc_argp       = &args,
 244                 .rpc_resp       = &fattr,
 245         };
 246         int                     status;
 247
 248         dprintk("NFS call  readlink\n");
 249         nfs_fattr_init(&fattr);
 250         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
 251         nfs_refresh_inode(inode, &fattr);
 252         dprintk("NFS reply readlink: %d\n", status);
 253         return status;
 254 }
 255
 256 /*
 257  * Create a regular file.
 258  * For now, we don't implement O_EXCL.
 259  */
 260 static int
 261 nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
 262                  int flags, struct nameidata *nd)
 263 {
 264         struct nfs_fh           fhandle;
 265         struct nfs_fattr        fattr;
 266         struct nfs_fattr        dir_attr;
 267         struct nfs3_createargs  arg = {
 268                 .fh             = NFS_FH(dir),
 269                 .name           = dentry->d_name.name,
 270                 .len            = dentry->d_name.len,
 271                 .sattr          = sattr,
 272         };
 273         struct nfs3_diropres    res = {
 274                 .dir_attr       = &dir_attr,
 275                 .fh             = &fhandle,
 276                 .fattr          = &fattr
 277         };
 278         struct rpc_message msg = {
 279                 .rpc_proc       = &nfs3_procedures[NFS3PROC_CREATE],
 280                 .rpc_argp       = &arg,
 281                 .rpc_resp       = &res,
 282         };
 283         mode_t mode = sattr->ia_mode;
 284         int status;
 285
 286         dprintk("NFS call  create %s\n", dentry->d_name.name);
 287         arg.createmode = NFS3_CREATE_UNCHECKED;
 288         if (flags & O_EXCL) {
 289                 arg.createmode  = NFS3_CREATE_EXCLUSIVE;
 290                 arg.verifier[0] = jiffies;
 291                 arg.verifier[1] = current->pid;
 292         }
 293
 294         sattr->ia_mode &= ~current->fs->umask;
 295
 296 again:
 297         nfs_fattr_init(&dir_attr);
 298         nfs_fattr_init(&fattr);
 299         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 300         nfs_refresh_inode(dir, &dir_attr);
 301
 302         /* If the server doesn't support the exclusive creation semantics,
 303          * try again with simple 'guarded' mode. */
 304         if (status == -ENOTSUPP) {
 305                 switch (arg.createmode) {
 306                         case NFS3_CREATE_EXCLUSIVE:
 307                                 arg.createmode = NFS3_CREATE_GUARDED;
 308                                 break;
 309
 310                         case NFS3_CREATE_GUARDED:
 311                                 arg.createmode = NFS3_CREATE_UNCHECKED;
 312                                 break;
 313
 314                         case NFS3_CREATE_UNCHECKED:
 315                                 goto out;
 316                 }
 317                 goto again;
 318         }
 319
 320         if (status == 0)
 321                 status = nfs_instantiate(dentry, &fhandle, &fattr);
 322         if (status != 0)
 323                 goto out;
 324
 325         /* When we created the file with exclusive semantics, make
 326          * sure we set the attributes afterwards. */
 327         if (arg.createmode == NFS3_CREATE_EXCLUSIVE) {
 328                 dprintk("NFS call  setattr (post-create)\n");
 329
 330                 if (!(sattr->ia_valid & ATTR_ATIME_SET))
 331                         sattr->ia_valid |= ATTR_ATIME;
 332                 if (!(sattr->ia_valid & ATTR_MTIME_SET))
 333                         sattr->ia_valid |= ATTR_MTIME;
 334
 335                 /* Note: we could use a guarded setattr here, but I'm
 336                  * not sure this buys us anything (and I'd have
 337                  * to revamp the NFSv3 XDR code) */
 338                 status = nfs3_proc_setattr(dentry, &fattr, sattr);
 339                 if (status == 0)
 340                         nfs_setattr_update_inode(dentry->d_inode, sattr);
 341                 nfs_refresh_inode(dentry->d_inode, &fattr);
 342                 dprintk("NFS reply setattr (post-create): %d\n", status);
 343         }
 344         if (status != 0)
 345                 goto out;
 346         status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
 347 out:
 348         dprintk("NFS reply create: %d\n", status);
 349         return status;
 350 }
 351
 352 static int
 353 nfs3_proc_remove(struct inode *dir, struct qstr *name)
 354 {
 355         struct nfs_fattr        dir_attr;
 356         struct nfs3_diropargs   arg = {
 357                 .fh             = NFS_FH(dir),
 358                 .name           = name->name,
 359                 .len            = name->len
 360         };
 361         struct rpc_message      msg = {
 362                 .rpc_proc       = &nfs3_procedures[NFS3PROC_REMOVE],
 363                 .rpc_argp       = &arg,
 364                 .rpc_resp       = &dir_attr,
 365         };
 366         int                     status;
 367
 368         dprintk("NFS call  remove %s\n", name->name);
 369         nfs_fattr_init(&dir_attr);
 370         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 371         nfs_post_op_update_inode(dir, &dir_attr);
 372         dprintk("NFS reply remove: %d\n", status);
 373         return status;
 374 }
 375
 376 static int
 377 nfs3_proc_unlink_setup(struct rpc_message *msg, struct dentry *dir, struct qstr *name)
 378 {
 379         struct unlinkxdr {
 380                 struct nfs3_diropargs arg;
 381                 struct nfs_fattr res;
 382         } *ptr;
 383
 384         ptr = kmalloc(sizeof(*ptr), GFP_KERNEL);
 385         if (!ptr)
 386                 return -ENOMEM;
 387         ptr->arg.fh = NFS_FH(dir->d_inode);
 388         ptr->arg.name = name->name;
 389         ptr->arg.len = name->len;
 390         nfs_fattr_init(&ptr->res);
 391         msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE];
 392         msg->rpc_argp = &ptr->arg;
 393         msg->rpc_resp = &ptr->res;
 394         return 0;
 395 }
 396
 397 static int
 398 nfs3_proc_unlink_done(struct dentry *dir, struct rpc_task *task)
 399 {
 400         struct rpc_message *msg = &task->tk_msg;
 401         struct nfs_fattr        *dir_attr;
 402
 403         if (nfs3_async_handle_jukebox(task, dir->d_inode))
 404                 return 1;
 405         if (msg->rpc_argp) {
 406                 dir_attr = (struct nfs_fattr*)msg->rpc_resp;
 407                 nfs_post_op_update_inode(dir->d_inode, dir_attr);
 408                 kfree(msg->rpc_argp);
 409         }
 410         return 0;
 411 }
 412
 413 static int
 414 nfs3_proc_rename(struct inode *old_dir, struct qstr *old_name,
 415                  struct inode *new_dir, struct qstr *new_name)
 416 {
 417         struct nfs_fattr        old_dir_attr, new_dir_attr;
 418         struct nfs3_renameargs  arg = {
 419                 .fromfh         = NFS_FH(old_dir),
 420                 .fromname       = old_name->name,
 421                 .fromlen        = old_name->len,
 422                 .tofh           = NFS_FH(new_dir),
 423                 .toname         = new_name->name,
 424                 .tolen          = new_name->len
 425         };
 426         struct nfs3_renameres   res = {
 427                 .fromattr       = &old_dir_attr,
 428                 .toattr         = &new_dir_attr
 429         };
 430         struct rpc_message msg = {
 431                 .rpc_proc       = &nfs3_procedures[NFS3PROC_RENAME],
 432                 .rpc_argp       = &arg,
 433                 .rpc_resp       = &res,
 434         };
 435         int                     status;
 436
 437         dprintk("NFS call  rename %s -> %s\n", old_name->name, new_name->name);
 438         nfs_fattr_init(&old_dir_attr);
 439         nfs_fattr_init(&new_dir_attr);
 440         status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0);
 441         nfs_post_op_update_inode(old_dir, &old_dir_attr);
 442         nfs_post_op_update_inode(new_dir, &new_dir_attr);
 443         dprintk("NFS reply rename: %d\n", status);
 444         return status;
 445 }
 446
 447 static int
 448 nfs3_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
 449 {
 450         struct nfs_fattr        dir_attr, fattr;
 451         struct nfs3_linkargs    arg = {
 452                 .fromfh         = NFS_FH(inode),
 453                 .tofh           = NFS_FH(dir),
 454                 .toname         = name->name,
 455                 .tolen          = name->len
 456         };
 457         struct nfs3_linkres     res = {
 458                 .dir_attr       = &dir_attr,
 459                 .fattr          = &fattr
 460         };
 461         struct rpc_message msg = {
 462                 .rpc_proc       = &nfs3_procedures[NFS3PROC_LINK],
 463                 .rpc_argp       = &arg,
 464                 .rpc_resp       = &res,
 465         };
 466         int                     status;
 467
 468         dprintk("NFS call  link %s\n", name->name);
 469         nfs_fattr_init(&dir_attr);
 470         nfs_fattr_init(&fattr);
 471         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
 472         nfs_post_op_update_inode(dir, &dir_attr);
 473         nfs_post_op_update_inode(inode, &fattr);
 474         dprintk("NFS reply link: %d\n", status);
 475         return status;
 476 }
 477
 478 static int
 479 nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
 480                   unsigned int len, struct iattr *sattr)
 481 {
 482         struct nfs_fh fhandle;
 483         struct nfs_fattr fattr, dir_attr;
 484         struct nfs3_symlinkargs arg = {
 485                 .fromfh         = NFS_FH(dir),
 486                 .fromname       = dentry->d_name.name,
 487                 .fromlen        = dentry->d_name.len,
 488                 .pages          = &page,
 489                 .pathlen        = len,
 490                 .sattr          = sattr
 491         };
 492         struct nfs3_diropres    res = {
 493                 .dir_attr       = &dir_attr,
 494                 .fh             = &fhandle,
 495                 .fattr          = &fattr
 496         };
 497         struct rpc_message msg = {
 498                 .rpc_proc       = &nfs3_procedures[NFS3PROC_SYMLINK],
 499                 .rpc_argp       = &arg,
 500                 .rpc_resp       = &res,
 501         };
 502         int                     status;
 503
 504         if (len > NFS3_MAXPATHLEN)
 505                 return -ENAMETOOLONG;
 506
 507         dprintk("NFS call  symlink %s\n", dentry->d_name.name);
 508
 509         nfs_fattr_init(&dir_attr);
 510         nfs_fattr_init(&fattr);
 511         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 512         nfs_post_op_update_inode(dir, &dir_attr);
 513         if (status != 0)
 514                 goto out;
 515         status = nfs_instantiate(dentry, &fhandle, &fattr);
 516 out:
 517         dprintk("NFS reply symlink: %d\n", status);
 518         return status;
 519 }
 520
 521 static int
 522 nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
 523 {
 524         struct nfs_fh fhandle;
 525         struct nfs_fattr fattr, dir_attr;
 526         struct nfs3_mkdirargs   arg = {
 527                 .fh             = NFS_FH(dir),
 528                 .name           = dentry->d_name.name,
 529                 .len            = dentry->d_name.len,
 530                 .sattr          = sattr
 531         };
 532         struct nfs3_diropres    res = {
 533                 .dir_attr       = &dir_attr,
 534                 .fh             = &fhandle,
 535                 .fattr          = &fattr
 536         };
 537         struct rpc_message msg = {
 538                 .rpc_proc       = &nfs3_procedures[NFS3PROC_MKDIR],
 539                 .rpc_argp       = &arg,
 540                 .rpc_resp       = &res,
 541         };
 542         int mode = sattr->ia_mode;
 543         int status;
 544
 545         dprintk("NFS call  mkdir %s\n", dentry->d_name.name);
 546
 547         sattr->ia_mode &= ~current->fs->umask;
 548
 549         nfs_fattr_init(&dir_attr);
 550         nfs_fattr_init(&fattr);
 551         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 552         nfs_post_op_update_inode(dir, &dir_attr);
 553         if (status != 0)
 554                 goto out;
 555         status = nfs_instantiate(dentry, &fhandle, &fattr);
 556         if (status != 0)
 557                 goto out;
 558         status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
 559 out:
 560         dprintk("NFS reply mkdir: %d\n", status);
 561         return status;
 562 }
 563
 564 static int
 565 nfs3_proc_rmdir(struct inode *dir, struct qstr *name)
 566 {
 567         struct nfs_fattr        dir_attr;
 568         struct nfs3_diropargs   arg = {
 569                 .fh             = NFS_FH(dir),
 570                 .name           = name->name,
 571                 .len            = name->len
 572         };
 573         struct rpc_message msg = {
 574                 .rpc_proc       = &nfs3_procedures[NFS3PROC_RMDIR],
 575                 .rpc_argp       = &arg,
 576                 .rpc_resp       = &dir_attr,
 577         };
 578         int                     status;
 579
 580         dprintk("NFS call  rmdir %s\n", name->name);
 581         nfs_fattr_init(&dir_attr);
 582         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 583         nfs_post_op_update_inode(dir, &dir_attr);
 584         dprintk("NFS reply rmdir: %d\n", status);
 585         return status;
 586 }
 587
 588 /*
 589  * The READDIR implementation is somewhat hackish - we pass the user buffer
 590  * to the encode function, which installs it in the receive iovec.
 591  * The decode function itself doesn't perform any decoding, it just makes
 592  * sure the reply is syntactically correct.
 593  *
 594  * Also note that this implementation handles both plain readdir and
 595  * readdirplus.
 596  */
 597 static int
 598 nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
 599                   u64 cookie, struct page *page, unsigned int count, int plus)
 600 {
 601         struct inode            *dir = dentry->d_inode;
 602         struct nfs_fattr        dir_attr;
 603         __be32                  *verf = NFS_COOKIEVERF(dir);
 604         struct nfs3_readdirargs arg = {
 605                 .fh             = NFS_FH(dir),
 606                 .cookie         = cookie,
 607                 .verf           = {verf[0], verf[1]},
 608                 .plus           = plus,
 609                 .count          = count,
 610                 .pages          = &page
 611         };
 612         struct nfs3_readdirres  res = {
 613                 .dir_attr       = &dir_attr,
 614                 .verf           = verf,
 615                 .plus           = plus
 616         };
 617         struct rpc_message      msg = {
 618                 .rpc_proc       = &nfs3_procedures[NFS3PROC_READDIR],
 619                 .rpc_argp       = &arg,
 620                 .rpc_resp       = &res,
 621                 .rpc_cred       = cred
 622         };
 623         int                     status;
 624
 625         if (plus)
 626                 msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS];
 627
 628         dprintk("NFS call  readdir%s %d\n",
 629                         plus? "plus" : "", (unsigned int) cookie);
 630
 631         nfs_fattr_init(&dir_attr);
 632         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 633         nfs_refresh_inode(dir, &dir_attr);
 634         dprintk("NFS reply readdir: %d\n", status);
 635         return status;
 636 }
 637
 638 static int
 639 nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
 640                 dev_t rdev)
 641 {
 642         struct nfs_fh fh;
 643         struct nfs_fattr fattr, dir_attr;
 644         struct nfs3_mknodargs   arg = {
 645                 .fh             = NFS_FH(dir),
 646                 .name           = dentry->d_name.name,
 647                 .len            = dentry->d_name.len,
 648                 .sattr          = sattr,
 649                 .rdev           = rdev
 650         };
 651         struct nfs3_diropres    res = {
 652                 .dir_attr       = &dir_attr,
 653                 .fh             = &fh,
 654                 .fattr          = &fattr
 655         };
 656         struct rpc_message msg = {
 657                 .rpc_proc       = &nfs3_procedures[NFS3PROC_MKNOD],
 658                 .rpc_argp       = &arg,
 659                 .rpc_resp       = &res,
 660         };
 661         mode_t mode = sattr->ia_mode;
 662         int status;
 663
 664         switch (sattr->ia_mode & S_IFMT) {
 665         case S_IFBLK:   arg.type = NF3BLK;  break;
 666         case S_IFCHR:   arg.type = NF3CHR;  break;
 667         case S_IFIFO:   arg.type = NF3FIFO; break;
 668         case S_IFSOCK:  arg.type = NF3SOCK; break;
 669         default:        return -EINVAL;
 670         }
 671
 672         dprintk("NFS call  mknod %s %u:%u\n", dentry->d_name.name,
 673                         MAJOR(rdev), MINOR(rdev));
 674
 675         sattr->ia_mode &= ~current->fs->umask;
 676
 677         nfs_fattr_init(&dir_attr);
 678         nfs_fattr_init(&fattr);
 679         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 680         nfs_post_op_update_inode(dir, &dir_attr);
 681         if (status != 0)
 682                 goto out;
 683         status = nfs_instantiate(dentry, &fh, &fattr);
 684         if (status != 0)
 685                 goto out;
 686         status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
 687 out:
 688         dprintk("NFS reply mknod: %d\n", status);
 689         return status;
 690 }
 691
 692 static int
 693 nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
 694                  struct nfs_fsstat *stat)
 695 {
 696         struct rpc_message msg = {
 697                 .rpc_proc       = &nfs3_procedures[NFS3PROC_FSSTAT],
 698                 .rpc_argp       = fhandle,
 699                 .rpc_resp       = stat,
 700         };
 701         int     status;
 702
 703         dprintk("NFS call  fsstat\n");
 704         nfs_fattr_init(stat->fattr);
 705         status = rpc_call_sync(server->client, &msg, 0);
 706         dprintk("NFS reply statfs: %d\n", status);
 707         return status;
 708 }
 709
 710 static int
 711 nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
 712                  struct nfs_fsinfo *info)
 713 {
 714         struct rpc_message msg = {
 715                 .rpc_proc       = &nfs3_procedures[NFS3PROC_FSINFO],
 716                 .rpc_argp       = fhandle,
 717                 .rpc_resp       = info,
 718         };
 719         int     status;
 720
 721         dprintk("NFS call  fsinfo\n");
 722         nfs_fattr_init(info->fattr);
 723         status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
 724         dprintk("NFS reply fsinfo: %d\n", status);
 725         return status;
 726 }
 727
 728 static int
 729 nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
 730                    struct nfs_pathconf *info)
 731 {
 732         struct rpc_message msg = {
 733                 .rpc_proc       = &nfs3_procedures[NFS3PROC_PATHCONF],
 734                 .rpc_argp       = fhandle,
 735                 .rpc_resp       = info,
 736         };
 737         int     status;
 738
 739         dprintk("NFS call  pathconf\n");
 740         nfs_fattr_init(info->fattr);
 741         status = rpc_call_sync(server->client, &msg, 0);
 742         dprintk("NFS reply pathconf: %d\n", status);
 743         return status;
 744 }
 745
 746 static int nfs3_read_done(struct rpc_task *task, struct nfs_read_data *data)
 747 {
 748         if (nfs3_async_handle_jukebox(task, data->inode))
 749                 return -EAGAIN;
 750         /* Call back common NFS readpage processing */
 751         if (task->tk_status >= 0)
 752                 nfs_refresh_inode(data->inode, &data->fattr);
 753         return 0;
 754 }
 755
 756 static void nfs3_proc_read_setup(struct nfs_read_data *data)
 757 {
 758         struct rpc_message      msg = {
 759                 .rpc_proc       = &nfs3_procedures[NFS3PROC_READ],
 760                 .rpc_argp       = &data->args,
 761                 .rpc_resp       = &data->res,
 762                 .rpc_cred       = data->cred,
 763         };
 764
 765         rpc_call_setup(&data->task, &msg, 0);
 766 }
 767
 768 static int nfs3_write_done(struct rpc_task *task, struct nfs_write_data *data)
 769 {
 770         if (nfs3_async_handle_jukebox(task, data->inode))
 771                 return -EAGAIN;
 772         if (task->tk_status >= 0)
 773                 nfs_post_op_update_inode(data->inode, data->res.fattr);
 774         return 0;
 775 }
 776
 777 static void nfs3_proc_write_setup(struct nfs_write_data *data, int how)
 778 {
 779         struct rpc_message      msg = {
 780                 .rpc_proc       = &nfs3_procedures[NFS3PROC_WRITE],
 781                 .rpc_argp       = &data->args,
 782                 .rpc_resp       = &data->res,
 783                 .rpc_cred       = data->cred,
 784         };
 785
 786         data->args.stable = NFS_UNSTABLE;
 787         if (how & FLUSH_STABLE) {
 788                 data->args.stable = NFS_FILE_SYNC;
 789                 if (NFS_I(data->inode)->ncommit)
 790                         data->args.stable = NFS_DATA_SYNC;
 791         }
 792
 793         /* Finalize the task. */
 794         rpc_call_setup(&data->task, &msg, 0);
 795 }
 796
 797 static int nfs3_commit_done(struct rpc_task *task, struct nfs_write_data *data)
 798 {
 799         if (nfs3_async_handle_jukebox(task, data->inode))
 800                 return -EAGAIN;
 801         if (task->tk_status >= 0)
 802                 nfs_post_op_update_inode(data->inode, data->res.fattr);
 803         return 0;
 804 }
 805
 806 static void nfs3_proc_commit_setup(struct nfs_write_data *data, int how)
 807 {
 808         struct rpc_message      msg = {
 809                 .rpc_proc       = &nfs3_procedures[NFS3PROC_COMMIT],
 810                 .rpc_argp       = &data->args,
 811                 .rpc_resp       = &data->res,
 812                 .rpc_cred       = data->cred,
 813         };
 814
 815         rpc_call_setup(&data->task, &msg, 0);
 816 }
 817
 818 static int
 819 nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
 820 {
 821         return nlmclnt_proc(filp->f_path.dentry->d_inode, cmd, fl);
 822 }
 823
 824 const struct nfs_rpc_ops nfs_v3_clientops = {
 825         .version        = 3,                    /* protocol version */
 826         .dentry_ops     = &nfs_dentry_operations,
 827         .dir_inode_ops  = &nfs3_dir_inode_operations,
 828         .file_inode_ops = &nfs3_file_inode_operations,
 829         .getroot        = nfs3_proc_get_root,
 830         .getattr        = nfs3_proc_getattr,
 831         .setattr        = nfs3_proc_setattr,
 832         .lookup         = nfs3_proc_lookup,
 833         .access         = nfs3_proc_access,
 834         .readlink       = nfs3_proc_readlink,
 835         .create         = nfs3_proc_create,
 836         .remove         = nfs3_proc_remove,
 837         .unlink_setup   = nfs3_proc_unlink_setup,
 838         .unlink_done    = nfs3_proc_unlink_done,
 839         .rename         = nfs3_proc_rename,
 840         .link           = nfs3_proc_link,
 841         .symlink        = nfs3_proc_symlink,
 842         .mkdir          = nfs3_proc_mkdir,
 843         .rmdir          = nfs3_proc_rmdir,
 844         .readdir        = nfs3_proc_readdir,
 845         .mknod          = nfs3_proc_mknod,
 846         .statfs         = nfs3_proc_statfs,
 847         .fsinfo         = nfs3_proc_fsinfo,
 848         .pathconf       = nfs3_proc_pathconf,
 849         .decode_dirent  = nfs3_decode_dirent,
 850         .read_setup     = nfs3_proc_read_setup,
 851         .read_done      = nfs3_read_done,
 852         .write_setup    = nfs3_proc_write_setup,
 853         .write_done     = nfs3_write_done,
 854         .commit_setup   = nfs3_proc_commit_setup,
 855         .commit_done    = nfs3_commit_done,
 856         .file_open      = nfs_open,
 857         .file_release   = nfs_release,
 858         .lock           = nfs3_proc_lock,
 859         .clear_acl_cache = nfs3_forget_cached_acls,
 860 };