fs/nfs/nfs3proc.c

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