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/slab.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 #include <linux/freezer.h>
  21 #include <linux/xattr.h>
  22
  23 #include "iostat.h"
  24 #include "internal.h"
  25
  26 #define NFSDBG_FACILITY         NFSDBG_PROC
  27
  28 /* A wrapper to handle the EJUKEBOX error messages */
  29 static int
  30 nfs3_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
  31 {
  32         int res;
  33         do {
  34                 res = rpc_call_sync(clnt, msg, flags);
  35                 if (res != -EJUKEBOX)
  36                         break;
  37                 freezable_schedule_timeout_killable_unsafe(NFS_JUKEBOX_RETRY_TIME);
  38                 res = -ERESTARTSYS;
  39         } while (!fatal_signal_pending(current));
  40         return res;
  41 }
  42
  43 #define rpc_call_sync(clnt, msg, flags) nfs3_rpc_wrapper(clnt, msg, flags)
  44
  45 static int
  46 nfs3_async_handle_jukebox(struct rpc_task *task, struct inode *inode)
  47 {
  48         if (task->tk_status != -EJUKEBOX)
  49                 return 0;
  50         if (task->tk_status == -EJUKEBOX)
  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", __func__);
  70         nfs_fattr_init(info->fattr);
  71         status = rpc_call_sync(client, &msg, 0);
  72         dprintk("%s: reply fsinfo: %d\n", __func__, status);
  73         if (status == 0 && !(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", __func__, 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, struct nfs4_label *label)
 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         if (sattr->ia_valid & ATTR_FILE)
 136                 msg.rpc_cred = nfs_file_cred(sattr->ia_file);
 137         nfs_fattr_init(fattr);
 138         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
 139         if (status == 0)
 140                 nfs_setattr_update_inode(inode, sattr);
 141         dprintk("NFS reply setattr: %d\n", status);
 142         return status;
 143 }
 144
 145 static int
 146 nfs3_proc_lookup(struct inode *dir, struct qstr *name,
 147                  struct nfs_fh *fhandle, struct nfs_fattr *fattr,
 148                  struct nfs4_label *label)
 149 {
 150         struct nfs3_diropargs   arg = {
 151                 .fh             = NFS_FH(dir),
 152                 .name           = name->name,
 153                 .len            = name->len
 154         };
 155         struct nfs3_diropres    res = {
 156                 .fh             = fhandle,
 157                 .fattr          = fattr
 158         };
 159         struct rpc_message msg = {
 160                 .rpc_proc       = &nfs3_procedures[NFS3PROC_LOOKUP],
 161                 .rpc_argp       = &arg,
 162                 .rpc_resp       = &res,
 163         };
 164         int                     status;
 165
 166         dprintk("NFS call  lookup %s\n", name->name);
 167         res.dir_attr = nfs_alloc_fattr();
 168         if (res.dir_attr == NULL)
 169                 return -ENOMEM;
 170
 171         nfs_fattr_init(fattr);
 172         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 173         nfs_refresh_inode(dir, res.dir_attr);
 174         if (status >= 0 && !(fattr->valid & NFS_ATTR_FATTR)) {
 175                 msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR];
 176                 msg.rpc_argp = fhandle;
 177                 msg.rpc_resp = fattr;
 178                 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 179         }
 180         nfs_free_fattr(res.dir_attr);
 181         dprintk("NFS reply lookup: %d\n", status);
 182         return status;
 183 }
 184
 185 static int nfs3_proc_access(struct inode *inode, struct nfs_access_entry *entry)
 186 {
 187         struct nfs3_accessargs  arg = {
 188                 .fh             = NFS_FH(inode),
 189         };
 190         struct nfs3_accessres   res;
 191         struct rpc_message msg = {
 192                 .rpc_proc       = &nfs3_procedures[NFS3PROC_ACCESS],
 193                 .rpc_argp       = &arg,
 194                 .rpc_resp       = &res,
 195                 .rpc_cred       = entry->cred,
 196         };
 197         int mode = entry->mask;
 198         int status = -ENOMEM;
 199
 200         dprintk("NFS call  access\n");
 201
 202         if (mode & MAY_READ)
 203                 arg.access |= NFS3_ACCESS_READ;
 204         if (S_ISDIR(inode->i_mode)) {
 205                 if (mode & MAY_WRITE)
 206                         arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND | NFS3_ACCESS_DELETE;
 207                 if (mode & MAY_EXEC)
 208                         arg.access |= NFS3_ACCESS_LOOKUP;
 209         } else {
 210                 if (mode & MAY_WRITE)
 211                         arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND;
 212                 if (mode & MAY_EXEC)
 213                         arg.access |= NFS3_ACCESS_EXECUTE;
 214         }
 215
 216         res.fattr = nfs_alloc_fattr();
 217         if (res.fattr == NULL)
 218                 goto out;
 219
 220         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
 221         nfs_refresh_inode(inode, res.fattr);
 222         if (status == 0) {
 223                 entry->mask = 0;
 224                 if (res.access & NFS3_ACCESS_READ)
 225                         entry->mask |= MAY_READ;
 226                 if (res.access & (NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND | NFS3_ACCESS_DELETE))
 227                         entry->mask |= MAY_WRITE;
 228                 if (res.access & (NFS3_ACCESS_LOOKUP|NFS3_ACCESS_EXECUTE))
 229                         entry->mask |= MAY_EXEC;
 230         }
 231         nfs_free_fattr(res.fattr);
 232 out:
 233         dprintk("NFS reply access: %d\n", status);
 234         return status;
 235 }
 236
 237 static int nfs3_proc_readlink(struct inode *inode, struct page *page,
 238                 unsigned int pgbase, unsigned int pglen)
 239 {
 240         struct nfs_fattr        *fattr;
 241         struct nfs3_readlinkargs args = {
 242                 .fh             = NFS_FH(inode),
 243                 .pgbase         = pgbase,
 244                 .pglen          = pglen,
 245                 .pages          = &page
 246         };
 247         struct rpc_message msg = {
 248                 .rpc_proc       = &nfs3_procedures[NFS3PROC_READLINK],
 249                 .rpc_argp       = &args,
 250         };
 251         int status = -ENOMEM;
 252
 253         dprintk("NFS call  readlink\n");
 254         fattr = nfs_alloc_fattr();
 255         if (fattr == NULL)
 256                 goto out;
 257         msg.rpc_resp = fattr;
 258
 259         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
 260         nfs_refresh_inode(inode, fattr);
 261         nfs_free_fattr(fattr);
 262 out:
 263         dprintk("NFS reply readlink: %d\n", status);
 264         return status;
 265 }
 266
 267 struct nfs3_createdata {
 268         struct rpc_message msg;
 269         union {
 270                 struct nfs3_createargs create;
 271                 struct nfs3_mkdirargs mkdir;
 272                 struct nfs3_symlinkargs symlink;
 273                 struct nfs3_mknodargs mknod;
 274         } arg;
 275         struct nfs3_diropres res;
 276         struct nfs_fh fh;
 277         struct nfs_fattr fattr;
 278         struct nfs_fattr dir_attr;
 279 };
 280
 281 static struct nfs3_createdata *nfs3_alloc_createdata(void)
 282 {
 283         struct nfs3_createdata *data;
 284
 285         data = kzalloc(sizeof(*data), GFP_KERNEL);
 286         if (data != NULL) {
 287                 data->msg.rpc_argp = &data->arg;
 288                 data->msg.rpc_resp = &data->res;
 289                 data->res.fh = &data->fh;
 290                 data->res.fattr = &data->fattr;
 291                 data->res.dir_attr = &data->dir_attr;
 292                 nfs_fattr_init(data->res.fattr);
 293                 nfs_fattr_init(data->res.dir_attr);
 294         }
 295         return data;
 296 }
 297
 298 static int nfs3_do_create(struct inode *dir, struct dentry *dentry, struct nfs3_createdata *data)
 299 {
 300         int status;
 301
 302         status = rpc_call_sync(NFS_CLIENT(dir), &data->msg, 0);
 303         nfs_post_op_update_inode(dir, data->res.dir_attr);
 304         if (status == 0)
 305                 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
 306         return status;
 307 }
 308
 309 static void nfs3_free_createdata(struct nfs3_createdata *data)
 310 {
 311         kfree(data);
 312 }
 313
 314 /*
 315  * Create a regular file.
 316  */
 317 static int
 318 nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
 319                  int flags)
 320 {
 321         struct posix_acl *default_acl, *acl;
 322         struct nfs3_createdata *data;
 323         int status = -ENOMEM;
 324
 325         dprintk("NFS call  create %pd\n", dentry);
 326
 327         data = nfs3_alloc_createdata();
 328         if (data == NULL)
 329                 goto out;
 330
 331         data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_CREATE];
 332         data->arg.create.fh = NFS_FH(dir);
 333         data->arg.create.name = dentry->d_name.name;
 334         data->arg.create.len = dentry->d_name.len;
 335         data->arg.create.sattr = sattr;
 336
 337         data->arg.create.createmode = NFS3_CREATE_UNCHECKED;
 338         if (flags & O_EXCL) {
 339                 data->arg.create.createmode  = NFS3_CREATE_EXCLUSIVE;
 340                 data->arg.create.verifier[0] = cpu_to_be32(jiffies);
 341                 data->arg.create.verifier[1] = cpu_to_be32(current->pid);
 342         }
 343
 344         status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl);
 345         if (status)
 346                 goto out;
 347
 348         for (;;) {
 349                 status = nfs3_do_create(dir, dentry, data);
 350
 351                 if (status != -ENOTSUPP)
 352                         break;
 353                 /* If the server doesn't support the exclusive creation
 354                  * semantics, try again with simple 'guarded' mode. */
 355                 switch (data->arg.create.createmode) {
 356                         case NFS3_CREATE_EXCLUSIVE:
 357                                 data->arg.create.createmode = NFS3_CREATE_GUARDED;
 358                                 break;
 359
 360                         case NFS3_CREATE_GUARDED:
 361                                 data->arg.create.createmode = NFS3_CREATE_UNCHECKED;
 362                                 break;
 363
 364                         case NFS3_CREATE_UNCHECKED:
 365                                 goto out;
 366                 }
 367                 nfs_fattr_init(data->res.dir_attr);
 368                 nfs_fattr_init(data->res.fattr);
 369         }
 370
 371         if (status != 0)
 372                 goto out_release_acls;
 373
 374         /* When we created the file with exclusive semantics, make
 375          * sure we set the attributes afterwards. */
 376         if (data->arg.create.createmode == NFS3_CREATE_EXCLUSIVE) {
 377                 dprintk("NFS call  setattr (post-create)\n");
 378
 379                 if (!(sattr->ia_valid & ATTR_ATIME_SET))
 380                         sattr->ia_valid |= ATTR_ATIME;
 381                 if (!(sattr->ia_valid & ATTR_MTIME_SET))
 382                         sattr->ia_valid |= ATTR_MTIME;
 383
 384                 /* Note: we could use a guarded setattr here, but I'm
 385                  * not sure this buys us anything (and I'd have
 386                  * to revamp the NFSv3 XDR code) */
 387                 status = nfs3_proc_setattr(dentry, data->res.fattr, sattr);
 388                 nfs_post_op_update_inode(dentry->d_inode, data->res.fattr);
 389                 dprintk("NFS reply setattr (post-create): %d\n", status);
 390                 if (status != 0)
 391                         goto out_release_acls;
 392         }
 393
 394         status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl);
 395
 396 out_release_acls:
 397         posix_acl_release(acl);
 398         posix_acl_release(default_acl);
 399 out:
 400         nfs3_free_createdata(data);
 401         dprintk("NFS reply create: %d\n", status);
 402         return status;
 403 }
 404
 405 static int
 406 nfs3_proc_remove(struct inode *dir, struct qstr *name)
 407 {
 408         struct nfs_removeargs arg = {
 409                 .fh = NFS_FH(dir),
 410                 .name = *name,
 411         };
 412         struct nfs_removeres res;
 413         struct rpc_message msg = {
 414                 .rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE],
 415                 .rpc_argp = &arg,
 416                 .rpc_resp = &res,
 417         };
 418         int status = -ENOMEM;
 419
 420         dprintk("NFS call  remove %s\n", name->name);
 421         res.dir_attr = nfs_alloc_fattr();
 422         if (res.dir_attr == NULL)
 423                 goto out;
 424
 425         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 426         nfs_post_op_update_inode(dir, res.dir_attr);
 427         nfs_free_fattr(res.dir_attr);
 428 out:
 429         dprintk("NFS reply remove: %d\n", status);
 430         return status;
 431 }
 432
 433 static void
 434 nfs3_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
 435 {
 436         msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE];
 437 }
 438
 439 static void nfs3_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
 440 {
 441         rpc_call_start(task);
 442 }
 443
 444 static int
 445 nfs3_proc_unlink_done(struct rpc_task *task, struct inode *dir)
 446 {
 447         struct nfs_removeres *res;
 448         if (nfs3_async_handle_jukebox(task, dir))
 449                 return 0;
 450         res = task->tk_msg.rpc_resp;
 451         nfs_post_op_update_inode(dir, res->dir_attr);
 452         return 1;
 453 }
 454
 455 static void
 456 nfs3_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
 457 {
 458         msg->rpc_proc = &nfs3_procedures[NFS3PROC_RENAME];
 459 }
 460
 461 static void nfs3_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
 462 {
 463         rpc_call_start(task);
 464 }
 465
 466 static int
 467 nfs3_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
 468                       struct inode *new_dir)
 469 {
 470         struct nfs_renameres *res;
 471
 472         if (nfs3_async_handle_jukebox(task, old_dir))
 473                 return 0;
 474         res = task->tk_msg.rpc_resp;
 475
 476         nfs_post_op_update_inode(old_dir, res->old_fattr);
 477         nfs_post_op_update_inode(new_dir, res->new_fattr);
 478         return 1;
 479 }
 480
 481 static int
 482 nfs3_proc_rename(struct inode *old_dir, struct qstr *old_name,
 483                  struct inode *new_dir, struct qstr *new_name)
 484 {
 485         struct nfs_renameargs   arg = {
 486                 .old_dir        = NFS_FH(old_dir),
 487                 .old_name       = old_name,
 488                 .new_dir        = NFS_FH(new_dir),
 489                 .new_name       = new_name,
 490         };
 491         struct nfs_renameres res;
 492         struct rpc_message msg = {
 493                 .rpc_proc       = &nfs3_procedures[NFS3PROC_RENAME],
 494                 .rpc_argp       = &arg,
 495                 .rpc_resp       = &res,
 496         };
 497         int status = -ENOMEM;
 498
 499         dprintk("NFS call  rename %s -> %s\n", old_name->name, new_name->name);
 500
 501         res.old_fattr = nfs_alloc_fattr();
 502         res.new_fattr = nfs_alloc_fattr();
 503         if (res.old_fattr == NULL || res.new_fattr == NULL)
 504                 goto out;
 505
 506         status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0);
 507         nfs_post_op_update_inode(old_dir, res.old_fattr);
 508         nfs_post_op_update_inode(new_dir, res.new_fattr);
 509 out:
 510         nfs_free_fattr(res.old_fattr);
 511         nfs_free_fattr(res.new_fattr);
 512         dprintk("NFS reply rename: %d\n", status);
 513         return status;
 514 }
 515
 516 static int
 517 nfs3_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
 518 {
 519         struct nfs3_linkargs    arg = {
 520                 .fromfh         = NFS_FH(inode),
 521                 .tofh           = NFS_FH(dir),
 522                 .toname         = name->name,
 523                 .tolen          = name->len
 524         };
 525         struct nfs3_linkres     res;
 526         struct rpc_message msg = {
 527                 .rpc_proc       = &nfs3_procedures[NFS3PROC_LINK],
 528                 .rpc_argp       = &arg,
 529                 .rpc_resp       = &res,
 530         };
 531         int status = -ENOMEM;
 532
 533         dprintk("NFS call  link %s\n", name->name);
 534         res.fattr = nfs_alloc_fattr();
 535         res.dir_attr = nfs_alloc_fattr();
 536         if (res.fattr == NULL || res.dir_attr == NULL)
 537                 goto out;
 538
 539         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
 540         nfs_post_op_update_inode(dir, res.dir_attr);
 541         nfs_post_op_update_inode(inode, res.fattr);
 542 out:
 543         nfs_free_fattr(res.dir_attr);
 544         nfs_free_fattr(res.fattr);
 545         dprintk("NFS reply link: %d\n", status);
 546         return status;
 547 }
 548
 549 static int
 550 nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
 551                   unsigned int len, struct iattr *sattr)
 552 {
 553         struct nfs3_createdata *data;
 554         int status = -ENOMEM;
 555
 556         if (len > NFS3_MAXPATHLEN)
 557                 return -ENAMETOOLONG;
 558
 559         dprintk("NFS call  symlink %pd\n", dentry);
 560
 561         data = nfs3_alloc_createdata();
 562         if (data == NULL)
 563                 goto out;
 564         data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_SYMLINK];
 565         data->arg.symlink.fromfh = NFS_FH(dir);
 566         data->arg.symlink.fromname = dentry->d_name.name;
 567         data->arg.symlink.fromlen = dentry->d_name.len;
 568         data->arg.symlink.pages = &page;
 569         data->arg.symlink.pathlen = len;
 570         data->arg.symlink.sattr = sattr;
 571
 572         status = nfs3_do_create(dir, dentry, data);
 573
 574         nfs3_free_createdata(data);
 575 out:
 576         dprintk("NFS reply symlink: %d\n", status);
 577         return status;
 578 }
 579
 580 static int
 581 nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
 582 {
 583         struct posix_acl *default_acl, *acl;
 584         struct nfs3_createdata *data;
 585         int status = -ENOMEM;
 586
 587         dprintk("NFS call  mkdir %pd\n", dentry);
 588
 589         data = nfs3_alloc_createdata();
 590         if (data == NULL)
 591                 goto out;
 592
 593         status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl);
 594         if (status)
 595                 goto out;
 596
 597         data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKDIR];
 598         data->arg.mkdir.fh = NFS_FH(dir);
 599         data->arg.mkdir.name = dentry->d_name.name;
 600         data->arg.mkdir.len = dentry->d_name.len;
 601         data->arg.mkdir.sattr = sattr;
 602
 603         status = nfs3_do_create(dir, dentry, data);
 604         if (status != 0)
 605                 goto out_release_acls;
 606
 607         status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl);
 608
 609 out_release_acls:
 610         posix_acl_release(acl);
 611         posix_acl_release(default_acl);
 612 out:
 613         nfs3_free_createdata(data);
 614         dprintk("NFS reply mkdir: %d\n", status);
 615         return status;
 616 }
 617
 618 static int
 619 nfs3_proc_rmdir(struct inode *dir, struct qstr *name)
 620 {
 621         struct nfs_fattr        *dir_attr;
 622         struct nfs3_diropargs   arg = {
 623                 .fh             = NFS_FH(dir),
 624                 .name           = name->name,
 625                 .len            = name->len
 626         };
 627         struct rpc_message msg = {
 628                 .rpc_proc       = &nfs3_procedures[NFS3PROC_RMDIR],
 629                 .rpc_argp       = &arg,
 630         };
 631         int status = -ENOMEM;
 632
 633         dprintk("NFS call  rmdir %s\n", name->name);
 634         dir_attr = nfs_alloc_fattr();
 635         if (dir_attr == NULL)
 636                 goto out;
 637
 638         msg.rpc_resp = dir_attr;
 639         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 640         nfs_post_op_update_inode(dir, dir_attr);
 641         nfs_free_fattr(dir_attr);
 642 out:
 643         dprintk("NFS reply rmdir: %d\n", status);
 644         return status;
 645 }
 646
 647 /*
 648  * The READDIR implementation is somewhat hackish - we pass the user buffer
 649  * to the encode function, which installs it in the receive iovec.
 650  * The decode function itself doesn't perform any decoding, it just makes
 651  * sure the reply is syntactically correct.
 652  *
 653  * Also note that this implementation handles both plain readdir and
 654  * readdirplus.
 655  */
 656 static int
 657 nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
 658                   u64 cookie, struct page **pages, unsigned int count, int plus)
 659 {
 660         struct inode            *dir = dentry->d_inode;
 661         __be32                  *verf = NFS_I(dir)->cookieverf;
 662         struct nfs3_readdirargs arg = {
 663                 .fh             = NFS_FH(dir),
 664                 .cookie         = cookie,
 665                 .verf           = {verf[0], verf[1]},
 666                 .plus           = plus,
 667                 .count          = count,
 668                 .pages          = pages
 669         };
 670         struct nfs3_readdirres  res = {
 671                 .verf           = verf,
 672                 .plus           = plus
 673         };
 674         struct rpc_message      msg = {
 675                 .rpc_proc       = &nfs3_procedures[NFS3PROC_READDIR],
 676                 .rpc_argp       = &arg,
 677                 .rpc_resp       = &res,
 678                 .rpc_cred       = cred
 679         };
 680         int status = -ENOMEM;
 681
 682         if (plus)
 683                 msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS];
 684
 685         dprintk("NFS call  readdir%s %d\n",
 686                         plus? "plus" : "", (unsigned int) cookie);
 687
 688         res.dir_attr = nfs_alloc_fattr();
 689         if (res.dir_attr == NULL)
 690                 goto out;
 691
 692         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 693
 694         nfs_invalidate_atime(dir);
 695         nfs_refresh_inode(dir, res.dir_attr);
 696
 697         nfs_free_fattr(res.dir_attr);
 698 out:
 699         dprintk("NFS reply readdir%s: %d\n",
 700                         plus? "plus" : "", status);
 701         return status;
 702 }
 703
 704 static int
 705 nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
 706                 dev_t rdev)
 707 {
 708         struct posix_acl *default_acl, *acl;
 709         struct nfs3_createdata *data;
 710         int status = -ENOMEM;
 711
 712         dprintk("NFS call  mknod %pd %u:%u\n", dentry,
 713                         MAJOR(rdev), MINOR(rdev));
 714
 715         data = nfs3_alloc_createdata();
 716         if (data == NULL)
 717                 goto out;
 718
 719         status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl);
 720         if (status)
 721                 goto out;
 722
 723         data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKNOD];
 724         data->arg.mknod.fh = NFS_FH(dir);
 725         data->arg.mknod.name = dentry->d_name.name;
 726         data->arg.mknod.len = dentry->d_name.len;
 727         data->arg.mknod.sattr = sattr;
 728         data->arg.mknod.rdev = rdev;
 729
 730         switch (sattr->ia_mode & S_IFMT) {
 731         case S_IFBLK:
 732                 data->arg.mknod.type = NF3BLK;
 733                 break;
 734         case S_IFCHR:
 735                 data->arg.mknod.type = NF3CHR;
 736                 break;
 737         case S_IFIFO:
 738                 data->arg.mknod.type = NF3FIFO;
 739                 break;
 740         case S_IFSOCK:
 741                 data->arg.mknod.type = NF3SOCK;
 742                 break;
 743         default:
 744                 status = -EINVAL;
 745                 goto out;
 746         }
 747
 748         status = nfs3_do_create(dir, dentry, data);
 749         if (status != 0)
 750                 goto out_release_acls;
 751
 752         status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl);
 753
 754 out_release_acls:
 755         posix_acl_release(acl);
 756         posix_acl_release(default_acl);
 757 out:
 758         nfs3_free_createdata(data);
 759         dprintk("NFS reply mknod: %d\n", status);
 760         return status;
 761 }
 762
 763 static int
 764 nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
 765                  struct nfs_fsstat *stat)
 766 {
 767         struct rpc_message msg = {
 768                 .rpc_proc       = &nfs3_procedures[NFS3PROC_FSSTAT],
 769                 .rpc_argp       = fhandle,
 770                 .rpc_resp       = stat,
 771         };
 772         int     status;
 773
 774         dprintk("NFS call  fsstat\n");
 775         nfs_fattr_init(stat->fattr);
 776         status = rpc_call_sync(server->client, &msg, 0);
 777         dprintk("NFS reply fsstat: %d\n", status);
 778         return status;
 779 }
 780
 781 static int
 782 do_proc_fsinfo(struct rpc_clnt *client, struct nfs_fh *fhandle,
 783                  struct nfs_fsinfo *info)
 784 {
 785         struct rpc_message msg = {
 786                 .rpc_proc       = &nfs3_procedures[NFS3PROC_FSINFO],
 787                 .rpc_argp       = fhandle,
 788                 .rpc_resp       = info,
 789         };
 790         int     status;
 791
 792         dprintk("NFS call  fsinfo\n");
 793         nfs_fattr_init(info->fattr);
 794         status = rpc_call_sync(client, &msg, 0);
 795         dprintk("NFS reply fsinfo: %d\n", status);
 796         return status;
 797 }
 798
 799 /*
 800  * Bare-bones access to fsinfo: this is for nfs_get_root/nfs_get_sb via
 801  * nfs_create_server
 802  */
 803 static int
 804 nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
 805                    struct nfs_fsinfo *info)
 806 {
 807         int     status;
 808
 809         status = do_proc_fsinfo(server->client, fhandle, info);
 810         if (status && server->nfs_client->cl_rpcclient != server->client)
 811                 status = do_proc_fsinfo(server->nfs_client->cl_rpcclient, fhandle, info);
 812         return status;
 813 }
 814
 815 static int
 816 nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
 817                    struct nfs_pathconf *info)
 818 {
 819         struct rpc_message msg = {
 820                 .rpc_proc       = &nfs3_procedures[NFS3PROC_PATHCONF],
 821                 .rpc_argp       = fhandle,
 822                 .rpc_resp       = info,
 823         };
 824         int     status;
 825
 826         dprintk("NFS call  pathconf\n");
 827         nfs_fattr_init(info->fattr);
 828         status = rpc_call_sync(server->client, &msg, 0);
 829         dprintk("NFS reply pathconf: %d\n", status);
 830         return status;
 831 }
 832
 833 static int nfs3_read_done(struct rpc_task *task, struct nfs_read_data *data)
 834 {
 835         struct inode *inode = data->header->inode;
 836
 837         if (nfs3_async_handle_jukebox(task, inode))
 838                 return -EAGAIN;
 839
 840         nfs_invalidate_atime(inode);
 841         nfs_refresh_inode(inode, &data->fattr);
 842         return 0;
 843 }
 844
 845 static void nfs3_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)
 846 {
 847         msg->rpc_proc = &nfs3_procedures[NFS3PROC_READ];
 848 }
 849
 850 static int nfs3_proc_read_rpc_prepare(struct rpc_task *task, struct nfs_read_data *data)
 851 {
 852         rpc_call_start(task);
 853         return 0;
 854 }
 855
 856 static int nfs3_write_done(struct rpc_task *task, struct nfs_write_data *data)
 857 {
 858         struct inode *inode = data->header->inode;
 859
 860         if (nfs3_async_handle_jukebox(task, inode))
 861                 return -EAGAIN;
 862         if (task->tk_status >= 0)
 863                 nfs_post_op_update_inode_force_wcc(inode, data->res.fattr);
 864         return 0;
 865 }
 866
 867 static void nfs3_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)
 868 {
 869         msg->rpc_proc = &nfs3_procedures[NFS3PROC_WRITE];
 870 }
 871
 872 static int nfs3_proc_write_rpc_prepare(struct rpc_task *task, struct nfs_write_data *data)
 873 {
 874         rpc_call_start(task);
 875         return 0;
 876 }
 877
 878 static void nfs3_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
 879 {
 880         rpc_call_start(task);
 881 }
 882
 883 static int nfs3_commit_done(struct rpc_task *task, struct nfs_commit_data *data)
 884 {
 885         if (nfs3_async_handle_jukebox(task, data->inode))
 886                 return -EAGAIN;
 887         nfs_refresh_inode(data->inode, data->res.fattr);
 888         return 0;
 889 }
 890
 891 static void nfs3_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
 892 {
 893         msg->rpc_proc = &nfs3_procedures[NFS3PROC_COMMIT];
 894 }
 895
 896 static int
 897 nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
 898 {
 899         struct inode *inode = file_inode(filp);
 900
 901         return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl);
 902 }
 903
 904 static int nfs3_have_delegation(struct inode *inode, fmode_t flags)
 905 {
 906         return 0;
 907 }
 908
 909 static int nfs3_return_delegation(struct inode *inode)
 910 {
 911         nfs_wb_all(inode);
 912         return 0;
 913 }
 914
 915 static const struct inode_operations nfs3_dir_inode_operations = {
 916         .create         = nfs_create,
 917         .lookup         = nfs_lookup,
 918         .link           = nfs_link,
 919         .unlink         = nfs_unlink,
 920         .symlink        = nfs_symlink,
 921         .mkdir          = nfs_mkdir,
 922         .rmdir          = nfs_rmdir,
 923         .mknod          = nfs_mknod,
 924         .rename         = nfs_rename,
 925         .permission     = nfs_permission,
 926         .getattr        = nfs_getattr,
 927         .setattr        = nfs_setattr,
 928 #ifdef CONFIG_NFS_V3_ACL
 929         .listxattr      = generic_listxattr,
 930         .getxattr       = generic_getxattr,
 931         .setxattr       = generic_setxattr,
 932         .removexattr    = generic_removexattr,
 933         .get_acl        = nfs3_get_acl,
 934         .set_acl        = nfs3_set_acl,
 935 #endif
 936 };
 937
 938 static const struct inode_operations nfs3_file_inode_operations = {
 939         .permission     = nfs_permission,
 940         .getattr        = nfs_getattr,
 941         .setattr        = nfs_setattr,
 942 #ifdef CONFIG_NFS_V3_ACL
 943         .listxattr      = generic_listxattr,
 944         .getxattr       = generic_getxattr,
 945         .setxattr       = generic_setxattr,
 946         .removexattr    = generic_removexattr,
 947         .get_acl        = nfs3_get_acl,
 948         .set_acl        = nfs3_set_acl,
 949 #endif
 950 };
 951
 952 const struct nfs_rpc_ops nfs_v3_clientops = {
 953         .version        = 3,                    /* protocol version */
 954         .dentry_ops     = &nfs_dentry_operations,
 955         .dir_inode_ops  = &nfs3_dir_inode_operations,
 956         .file_inode_ops = &nfs3_file_inode_operations,
 957         .file_ops       = &nfs_file_operations,
 958         .getroot        = nfs3_proc_get_root,
 959         .submount       = nfs_submount,
 960         .try_mount      = nfs_try_mount,
 961         .getattr        = nfs3_proc_getattr,
 962         .setattr        = nfs3_proc_setattr,
 963         .lookup         = nfs3_proc_lookup,
 964         .access         = nfs3_proc_access,
 965         .readlink       = nfs3_proc_readlink,
 966         .create         = nfs3_proc_create,
 967         .remove         = nfs3_proc_remove,
 968         .unlink_setup   = nfs3_proc_unlink_setup,
 969         .unlink_rpc_prepare = nfs3_proc_unlink_rpc_prepare,
 970         .unlink_done    = nfs3_proc_unlink_done,
 971         .rename         = nfs3_proc_rename,
 972         .rename_setup   = nfs3_proc_rename_setup,
 973         .rename_rpc_prepare = nfs3_proc_rename_rpc_prepare,
 974         .rename_done    = nfs3_proc_rename_done,
 975         .link           = nfs3_proc_link,
 976         .symlink        = nfs3_proc_symlink,
 977         .mkdir          = nfs3_proc_mkdir,
 978         .rmdir          = nfs3_proc_rmdir,
 979         .readdir        = nfs3_proc_readdir,
 980         .mknod          = nfs3_proc_mknod,
 981         .statfs         = nfs3_proc_statfs,
 982         .fsinfo         = nfs3_proc_fsinfo,
 983         .pathconf       = nfs3_proc_pathconf,
 984         .decode_dirent  = nfs3_decode_dirent,
 985         .read_setup     = nfs3_proc_read_setup,
 986         .read_pageio_init = nfs_pageio_init_read,
 987         .read_rpc_prepare = nfs3_proc_read_rpc_prepare,
 988         .read_done      = nfs3_read_done,
 989         .write_setup    = nfs3_proc_write_setup,
 990         .write_pageio_init = nfs_pageio_init_write,
 991         .write_rpc_prepare = nfs3_proc_write_rpc_prepare,
 992         .write_done     = nfs3_write_done,
 993         .commit_setup   = nfs3_proc_commit_setup,
 994         .commit_rpc_prepare = nfs3_proc_commit_rpc_prepare,
 995         .commit_done    = nfs3_commit_done,
 996         .lock           = nfs3_proc_lock,
 997         .clear_acl_cache = forget_all_cached_acls,
 998         .close_context  = nfs_close_context,
 999         .have_delegation = nfs3_have_delegation,
1000         .return_delegation = nfs3_return_delegation,
1001         .alloc_client   = nfs_alloc_client,
1002         .init_client    = nfs_init_client,
1003         .free_client    = nfs_free_client,
1004         .create_server  = nfs3_create_server,
1005         .clone_server   = nfs3_clone_server,
1006 };