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