fs/nfs/nfs3proc.c

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