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