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
  18 #define NFSDBG_FACILITY         NFSDBG_PROC
  19
  20 /*
  21  * Bare-bones access to getattr: this is for nfs_read_super.
  22  */
  23 static int
  24 nfs3_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
  25                    struct nfs_fattr *fattr)
  26 {
  27         int     status;
  28
  29         dprintk("NFS call  getroot\n");
  30         fattr->valid = 0;
  31         status = rpc_call(server->client, NFS3PROC_GETATTR, fhandle, fattr, 0);
  32         dprintk("NFS reply getroot\n");
  33         return status;
  34 }
  35
  36 /*
  37  * One function for each procedure in the NFS protocol.
  38  */
  39 static int
  40 nfs3_proc_getattr(struct inode *inode, struct nfs_fattr *fattr)
  41 {
  42         int     status;
  43
  44         dprintk("NFS call  getattr\n");
  45         fattr->valid = 0;
  46         status = rpc_call(NFS_CLIENT(inode), NFS3PROC_GETATTR,
  47                           NFS_FH(inode), fattr, 0);
  48         dprintk("NFS reply getattr\n");
  49         return status;
  50 }
  51
  52 static int
  53 nfs3_proc_setattr(struct inode *inode, struct nfs_fattr *fattr,
  54                         struct iattr *sattr)
  55 {
  56         struct nfs3_sattrargs   arg = { NFS_FH(inode), sattr, 0, 0 };
  57         int     status;
  58
  59         dprintk("NFS call  setattr\n");
  60         fattr->valid = 0;
  61         status = rpc_call(NFS_CLIENT(inode), NFS3PROC_SETATTR, &arg, fattr, 0);
  62         dprintk("NFS reply setattr\n");
  63         return status;
  64 }
  65
  66 static int
  67 nfs3_proc_lookup(struct inode *dir, struct qstr *name,
  68                  struct nfs_fh *fhandle, struct nfs_fattr *fattr)
  69 {
  70         struct nfs_fattr        dir_attr;
  71         struct nfs3_diropargs   arg = { NFS_FH(dir), name->name, name->len };
  72         struct nfs3_diropres    res = { &dir_attr, fhandle, fattr };
  73         int                     status;
  74
  75         dprintk("NFS call  lookup %s\n", name->name);
  76         dir_attr.valid = 0;
  77         fattr->valid = 0;
  78         status = rpc_call(NFS_CLIENT(dir), NFS3PROC_LOOKUP, &arg, &res, 0);
  79         if (status >= 0 && !(fattr->valid & NFS_ATTR_FATTR))
  80                 status = rpc_call(NFS_CLIENT(dir), NFS3PROC_GETATTR,
  81                          fhandle, fattr, 0);
  82         dprintk("NFS reply lookup: %d\n", status);
  83         nfs_refresh_inode(dir, &dir_attr);
  84         return status;
  85 }
  86
  87 static int
  88 nfs3_proc_access(struct inode *inode, int mode, int ruid)
  89 {
  90         struct nfs_fattr        fattr;
  91         struct nfs3_accessargs  arg = { NFS_FH(inode), 0 };
  92         struct nfs3_accessres   res = { &fattr, 0 };
  93         int     status, flags;
  94
  95         dprintk("NFS call  access\n");
  96         fattr.valid = 0;
  97
  98         if (mode & MAY_READ)
  99                 arg.access |= NFS3_ACCESS_READ;
 100         if (S_ISDIR(inode->i_mode)) {
 101                 if (mode & MAY_WRITE)
 102                         arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND | NFS3_ACCESS_DELETE;
 103                 if (mode & MAY_EXEC)
 104                         arg.access |= NFS3_ACCESS_LOOKUP;
 105         } else {
 106                 if (mode & MAY_WRITE)
 107                         arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND;
 108                 if (mode & MAY_EXEC)
 109                         arg.access |= NFS3_ACCESS_EXECUTE;
 110         }
 111         flags = (ruid) ? RPC_CALL_REALUID : 0;
 112         status = rpc_call(NFS_CLIENT(inode), NFS3PROC_ACCESS, &arg, &res, flags);
 113         nfs_refresh_inode(inode, &fattr);
 114         dprintk("NFS reply access\n");
 115
 116         if (status == 0 && (arg.access & res.access) != arg.access)
 117                 status = -EACCES;
 118         return status;
 119 }
 120
 121 static int
 122 nfs3_proc_readlink(struct inode *inode, void *buffer, unsigned int buflen)
 123 {
 124         struct nfs_fattr        fattr;
 125         struct nfs3_readlinkargs args = { NFS_FH(inode), buffer, buflen };
 126         struct nfs3_readlinkres res = { &fattr, buffer, buflen };
 127         int                     status;
 128
 129         dprintk("NFS call  readlink\n");
 130         fattr.valid = 0;
 131         status = rpc_call(NFS_CLIENT(inode), NFS3PROC_READLINK,
 132                           &args, &res, 0);
 133         nfs_refresh_inode(inode, &fattr);
 134         dprintk("NFS reply readlink: %d\n", status);
 135         return status;
 136 }
 137
 138 static int
 139 nfs3_proc_read(struct inode *inode, struct rpc_cred *cred,
 140                struct nfs_fattr *fattr, int flags,
 141                loff_t offset, unsigned int count, void *buffer, int *eofp)
 142 {
 143         struct nfs_readargs     arg = { NFS_FH(inode), offset, count, 1,
 144                                         {{buffer, count}, {0,0}, {0,0}, {0,0},
 145                                          {0,0}, {0,0}, {0,0}, {0,0}} };
 146         struct nfs_readres      res = { fattr, count, 0 };
 147         struct rpc_message      msg = { NFS3PROC_READ, &arg, &res, cred };
 148         int                     status;
 149
 150         dprintk("NFS call  read %d @ %Ld\n", count, (long long)offset);
 151         fattr->valid = 0;
 152         status = rpc_call_sync(NFS_CLIENT(inode), &msg, flags);
 153         dprintk("NFS reply read: %d\n", status);
 154         *eofp = res.eof;
 155         return status;
 156 }
 157
 158 static int
 159 nfs3_proc_write(struct inode *inode, struct rpc_cred *cred,
 160                 struct nfs_fattr *fattr, int flags,
 161                 loff_t offset, unsigned int count,
 162                 void *buffer, struct nfs_writeverf *verf)
 163 {
 164         struct nfs_writeargs    arg = { NFS_FH(inode), offset, count,
 165                                         NFS_FILE_SYNC, 1,
 166                                         {{buffer, count}, {0,0}, {0,0}, {0,0},
 167                                          {0,0}, {0,0}, {0,0}, {0,0}} };
 168         struct nfs_writeres     res = { fattr, verf, 0 };
 169         struct rpc_message      msg = { NFS3PROC_WRITE, &arg, &res, cred };
 170         int                     status, rpcflags = 0;
 171
 172         dprintk("NFS call  write %d @ %Ld\n", count, (long long)offset);
 173         fattr->valid = 0;
 174         if (flags & NFS_RW_SWAP)
 175                 rpcflags |= NFS_RPC_SWAPFLAGS;
 176         arg.stable = (flags & NFS_RW_SYNC) ? NFS_FILE_SYNC : NFS_UNSTABLE;
 177
 178         status = rpc_call_sync(NFS_CLIENT(inode), &msg, rpcflags);
 179
 180         dprintk("NFS reply read: %d\n", status);
 181         return status < 0? status : res.count;
 182 }
 183
 184 /*
 185  * Create a regular file.
 186  * For now, we don't implement O_EXCL.
 187  */
 188 static int
 189 nfs3_proc_create(struct inode *dir, struct qstr *name, struct iattr *sattr,
 190                  int flags, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
 191 {
 192         struct nfs_fattr        dir_attr;
 193         struct nfs3_createargs  arg = { NFS_FH(dir), name->name, name->len,
 194                                         sattr, 0, { 0, 0 } };
 195         struct nfs3_diropres    res = { &dir_attr, fhandle, fattr };
 196         int                     status;
 197
 198         dprintk("NFS call  create %s\n", name->name);
 199         arg.createmode = NFS3_CREATE_UNCHECKED;
 200         if (flags & O_EXCL) {
 201                 arg.createmode  = NFS3_CREATE_EXCLUSIVE;
 202                 arg.verifier[0] = jiffies;
 203                 arg.verifier[1] = current->pid;
 204         }
 205
 206 again:
 207         dir_attr.valid = 0;
 208         fattr->valid = 0;
 209         status = rpc_call(NFS_CLIENT(dir), NFS3PROC_CREATE, &arg, &res, 0);
 210         nfs_refresh_inode(dir, &dir_attr);
 211
 212         /* If the server doesn't support the exclusive creation semantics,
 213          * try again with simple 'guarded' mode. */
 214         if (status == NFSERR_NOTSUPP) {
 215                 switch (arg.createmode) {
 216                         case NFS3_CREATE_EXCLUSIVE:
 217                                 arg.createmode = NFS3_CREATE_GUARDED;
 218                                 break;
 219
 220                         case NFS3_CREATE_GUARDED:
 221                                 arg.createmode = NFS3_CREATE_UNCHECKED;
 222                                 break;
 223
 224                         case NFS3_CREATE_UNCHECKED:
 225                                 goto exit;
 226                 }
 227                 goto again;
 228         }
 229
 230 exit:
 231         dprintk("NFS reply create: %d\n", status);
 232
 233         /* When we created the file with exclusive semantics, make
 234          * sure we set the attributes afterwards. */
 235         if (status == 0 && arg.createmode == NFS3_CREATE_EXCLUSIVE) {
 236                 struct nfs3_sattrargs   arg = { fhandle, sattr, 0, 0 };
 237                 dprintk("NFS call  setattr (post-create)\n");
 238
 239                 /* Note: we could use a guarded setattr here, but I'm
 240                  * not sure this buys us anything (and I'd have
 241                  * to revamp the NFSv3 XDR code) */
 242                 fattr->valid = 0;
 243                 status = rpc_call(NFS_CLIENT(dir), NFS3PROC_SETATTR,
 244                                                 &arg, fattr, 0);
 245                 dprintk("NFS reply setattr (post-create): %d\n", status);
 246         }
 247
 248         return status;
 249 }
 250
 251 static int
 252 nfs3_proc_remove(struct inode *dir, struct qstr *name)
 253 {
 254         struct nfs_fattr        dir_attr;
 255         struct nfs3_diropargs   arg = { NFS_FH(dir), name->name, name->len };
 256         struct rpc_message      msg = { NFS3PROC_REMOVE, &arg, &dir_attr, NULL };
 257         int                     status;
 258
 259         dprintk("NFS call  remove %s\n", name->name);
 260         dir_attr.valid = 0;
 261         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 262         nfs_refresh_inode(dir, &dir_attr);
 263         dprintk("NFS reply remove: %d\n", status);
 264         return status;
 265 }
 266
 267 static int
 268 nfs3_proc_unlink_setup(struct rpc_message *msg, struct dentry *dir, struct qstr *name)
 269 {
 270         struct nfs3_diropargs   *arg;
 271         struct nfs_fattr        *res;
 272
 273         arg = (struct nfs3_diropargs *)kmalloc(sizeof(*arg)+sizeof(*res), GFP_KERNEL);
 274         if (!arg)
 275                 return -ENOMEM;
 276         res = (struct nfs_fattr*)(arg + 1);
 277         arg->fh = NFS_FH(dir->d_inode);
 278         arg->name = name->name;
 279         arg->len = name->len;
 280         res->valid = 0;
 281         msg->rpc_proc = NFS3PROC_REMOVE;
 282         msg->rpc_argp = arg;
 283         msg->rpc_resp = res;
 284         return 0;
 285 }
 286
 287 static void
 288 nfs3_proc_unlink_done(struct dentry *dir, struct rpc_message *msg)
 289 {
 290         struct nfs_fattr        *dir_attr;
 291
 292         if (msg->rpc_argp) {
 293                 dir_attr = (struct nfs_fattr*)msg->rpc_resp;
 294                 nfs_refresh_inode(dir->d_inode, dir_attr);
 295                 kfree(msg->rpc_argp);
 296         }
 297 }
 298
 299 static int
 300 nfs3_proc_rename(struct inode *old_dir, struct qstr *old_name,
 301                  struct inode *new_dir, struct qstr *new_name)
 302 {
 303         struct nfs_fattr        old_dir_attr, new_dir_attr;
 304         struct nfs3_renameargs  arg = { NFS_FH(old_dir),
 305                                         old_name->name, old_name->len,
 306                                         NFS_FH(new_dir),
 307                                         new_name->name, new_name->len };
 308         struct nfs3_renameres   res = { &old_dir_attr, &new_dir_attr };
 309         int                     status;
 310
 311         dprintk("NFS call  rename %s -> %s\n", old_name->name, new_name->name);
 312         old_dir_attr.valid = 0;
 313         new_dir_attr.valid = 0;
 314         status = rpc_call(NFS_CLIENT(old_dir), NFS3PROC_RENAME, &arg, &res, 0);
 315         nfs_refresh_inode(old_dir, &old_dir_attr);
 316         nfs_refresh_inode(new_dir, &new_dir_attr);
 317         dprintk("NFS reply rename: %d\n", status);
 318         return status;
 319 }
 320
 321 static int
 322 nfs3_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
 323 {
 324         struct nfs_fattr        dir_attr, fattr;
 325         struct nfs3_linkargs    arg = { NFS_FH(inode), NFS_FH(dir),
 326                                         name->name, name->len };
 327         struct nfs3_linkres     res = { &dir_attr, &fattr };
 328         int                     status;
 329
 330         dprintk("NFS call  link %s\n", name->name);
 331         dir_attr.valid = 0;
 332         fattr.valid = 0;
 333         status = rpc_call(NFS_CLIENT(inode), NFS3PROC_LINK, &arg, &res, 0);
 334         nfs_refresh_inode(dir, &dir_attr);
 335         nfs_refresh_inode(inode, &fattr);
 336         dprintk("NFS reply link: %d\n", status);
 337         return status;
 338 }
 339
 340 static int
 341 nfs3_proc_symlink(struct inode *dir, struct qstr *name, struct qstr *path,
 342                   struct iattr *sattr, struct nfs_fh *fhandle,
 343                   struct nfs_fattr *fattr)
 344 {
 345         struct nfs_fattr        dir_attr;
 346         struct nfs3_symlinkargs arg = { NFS_FH(dir), name->name, name->len,
 347                                         path->name, path->len, sattr };
 348         struct nfs3_diropres    res = { &dir_attr, fhandle, fattr };
 349         int                     status;
 350
 351         dprintk("NFS call  symlink %s -> %s\n", name->name, path->name);
 352         dir_attr.valid = 0;
 353         fattr->valid = 0;
 354         status = rpc_call(NFS_CLIENT(dir), NFS3PROC_SYMLINK, &arg, &res, 0);
 355         nfs_refresh_inode(dir, &dir_attr);
 356         dprintk("NFS reply symlink: %d\n", status);
 357         return status;
 358 }
 359
 360 static int
 361 nfs3_proc_mkdir(struct inode *dir, struct qstr *name, struct iattr *sattr,
 362                 struct nfs_fh *fhandle, struct nfs_fattr *fattr)
 363 {
 364         struct nfs_fattr        dir_attr;
 365         struct nfs3_createargs  arg = { NFS_FH(dir), name->name, name->len,
 366                                         sattr, 0, { 0, 0 } };
 367         struct nfs3_diropres    res = { &dir_attr, fhandle, fattr };
 368         int                     status;
 369
 370         dprintk("NFS call  mkdir %s\n", name->name);
 371         dir_attr.valid = 0;
 372         fattr->valid = 0;
 373         status = rpc_call(NFS_CLIENT(dir), NFS3PROC_MKDIR, &arg, &res, 0);
 374         nfs_refresh_inode(dir, &dir_attr);
 375         dprintk("NFS reply mkdir: %d\n", status);
 376         return status;
 377 }
 378
 379 static int
 380 nfs3_proc_rmdir(struct inode *dir, struct qstr *name)
 381 {
 382         struct nfs_fattr        dir_attr;
 383         struct nfs3_diropargs   arg = { NFS_FH(dir), name->name, name->len };
 384         int                     status;
 385
 386         dprintk("NFS call  rmdir %s\n", name->name);
 387         dir_attr.valid = 0;
 388         status = rpc_call(NFS_CLIENT(dir), NFS3PROC_RMDIR, &arg, &dir_attr, 0);
 389         nfs_refresh_inode(dir, &dir_attr);
 390         dprintk("NFS reply rmdir: %d\n", status);
 391         return status;
 392 }
 393
 394 /*
 395  * The READDIR implementation is somewhat hackish - we pass the user buffer
 396  * to the encode function, which installs it in the receive iovec.
 397  * The decode function itself doesn't perform any decoding, it just makes
 398  * sure the reply is syntactically correct.
 399  *
 400  * Also note that this implementation handles both plain readdir and
 401  * readdirplus.
 402  */
 403 static int
 404 nfs3_proc_readdir(struct inode *dir, struct rpc_cred *cred,
 405                   u64 cookie, void *entry,
 406                   unsigned int size, int plus)
 407 {
 408         struct nfs_fattr        dir_attr;
 409         struct nfs3_readdirargs arg = { NFS_FH(dir), cookie, {0, 0}, 0, 0, 0 };
 410         struct nfs3_readdirres  res = { &dir_attr, 0, 0, 0, 0 };
 411         struct rpc_message      msg = { NFS3PROC_READDIR, &arg, &res, cred };
 412         u32                     *verf = NFS_COOKIEVERF(dir);
 413         int                     status;
 414
 415         arg.buffer  = entry;
 416         arg.bufsiz  = size;
 417         arg.verf[0] = verf[0];
 418         arg.verf[1] = verf[1];
 419         arg.plus    = plus;
 420         res.buffer  = entry;
 421         res.bufsiz  = size;
 422         res.verf    = verf;
 423         res.plus    = plus;
 424
 425         if (plus)
 426                 msg.rpc_proc = NFS3PROC_READDIRPLUS;
 427
 428         dprintk("NFS call  readdir%s %d\n",
 429                         plus? "plus" : "", (unsigned int) cookie);
 430
 431         dir_attr.valid = 0;
 432         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 433         nfs_refresh_inode(dir, &dir_attr);
 434         dprintk("NFS reply readdir: %d\n", status);
 435         return status;
 436 }
 437
 438 static int
 439 nfs3_proc_mknod(struct inode *dir, struct qstr *name, struct iattr *sattr,
 440                 dev_t rdev, struct nfs_fh *fh, struct nfs_fattr *fattr)
 441 {
 442         struct nfs_fattr        dir_attr;
 443         struct nfs3_mknodargs   arg = { NFS_FH(dir), name->name, name->len, 0,
 444                                         sattr, rdev };
 445         struct nfs3_diropres    res = { &dir_attr, fh, fattr };
 446         int                     status;
 447
 448         switch (sattr->ia_mode & S_IFMT) {
 449         case S_IFBLK:   arg.type = NF3BLK;  break;
 450         case S_IFCHR:   arg.type = NF3CHR;  break;
 451         case S_IFIFO:   arg.type = NF3FIFO; break;
 452         case S_IFSOCK:  arg.type = NF3SOCK; break;
 453         default:        return -EINVAL;
 454         }
 455
 456         dprintk("NFS call  mknod %s %x\n", name->name, rdev);
 457         dir_attr.valid = 0;
 458         fattr->valid = 0;
 459         status = rpc_call(NFS_CLIENT(dir), NFS3PROC_MKNOD, &arg, &res, 0);
 460         nfs_refresh_inode(dir, &dir_attr);
 461         dprintk("NFS reply mknod: %d\n", status);
 462         return status;
 463 }
 464
 465 /*
 466  * This is a combo call of fsstat and fsinfo
 467  */
 468 static int
 469 nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
 470                  struct nfs_fsinfo *info)
 471 {
 472         int     status;
 473
 474         dprintk("NFS call  fsstat\n");
 475         memset((char *)info, 0, sizeof(*info));
 476         status = rpc_call(server->client, NFS3PROC_FSSTAT, fhandle, info, 0);
 477         if (status < 0)
 478                 goto error;
 479         status = rpc_call(server->client, NFS3PROC_FSINFO, fhandle, info, 0);
 480
 481 error:
 482         dprintk("NFS reply statfs: %d\n", status);
 483         return status;
 484 }
 485
 486 extern u32 *nfs3_decode_dirent(u32 *, struct nfs_entry *, int);
 487
 488 struct nfs_rpc_ops      nfs_v3_clientops = {
 489         3,                      /* protocol version */
 490         nfs3_proc_get_root,
 491         nfs3_proc_getattr,
 492         nfs3_proc_setattr,
 493         nfs3_proc_lookup,
 494         nfs3_proc_access,
 495         nfs3_proc_readlink,
 496         nfs3_proc_read,
 497         nfs3_proc_write,
 498         NULL,                   /* commit */
 499         nfs3_proc_create,
 500         nfs3_proc_remove,
 501         nfs3_proc_unlink_setup,
 502         nfs3_proc_unlink_done,
 503         nfs3_proc_rename,
 504         nfs3_proc_link,
 505         nfs3_proc_symlink,
 506         nfs3_proc_mkdir,
 507         nfs3_proc_rmdir,
 508         nfs3_proc_readdir,
 509         nfs3_proc_mknod,
 510         nfs3_proc_statfs,
 511         nfs3_decode_dirent,
 512 };