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