SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/nfs/nfs4proc.c

   1 /*
   2  *  fs/nfs/nfs4proc.c
   3  *
   4  *  Client-side procedure declarations for NFSv4.
   5  *
   6  *  Copyright (c) 2002 The Regents of the University of Michigan.
   7  *  All rights reserved.
   8  *
   9  *  Kendrick Smith <kmsmith@umich.edu>
  10  *  Andy Adamson   <andros@umich.edu>
  11  *
  12  *  Redistribution and use in source and binary forms, with or without
  13  *  modification, are permitted provided that the following conditions
  14  *  are met:
  15  *
  16  *  1. Redistributions of source code must retain the above copyright
  17  *     notice, this list of conditions and the following disclaimer.
  18  *  2. Redistributions in binary form must reproduce the above copyright
  19  *     notice, this list of conditions and the following disclaimer in the
  20  *     documentation and/or other materials provided with the distribution.
  21  *  3. Neither the name of the University nor the names of its
  22  *     contributors may be used to endorse or promote products derived
  23  *     from this software without specific prior written permission.
  24  *
  25  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  26  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  27  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  28  *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  30  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  31  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  32  *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  33  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  34  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  35  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  */
  37
  38 #include <linux/mm.h>
  39 #include <linux/utsname.h>
  40 #include <linux/delay.h>
  41 #include <linux/errno.h>
  42 #include <linux/string.h>
  43 #include <linux/sunrpc/clnt.h>
  44 #include <linux/nfs.h>
  45 #include <linux/nfs4.h>
  46 #include <linux/nfs_fs.h>
  47 #include <linux/nfs_page.h>
  48 #include <linux/smp_lock.h>
  49 #include <linux/namei.h>
  50 #include <linux/mount.h>
  51
  52 #include "nfs4_fs.h"
  53 #include "delegation.h"
  54 #include "internal.h"
  55 #include "iostat.h"
  56
  57 #define NFSDBG_FACILITY         NFSDBG_PROC
  58
  59 #define NFS4_POLL_RETRY_MIN     (HZ/10)
  60 #define NFS4_POLL_RETRY_MAX     (15*HZ)
  61
  62 struct nfs4_opendata;
  63 static int _nfs4_proc_open(struct nfs4_opendata *data);
  64 static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *);
  65 static int nfs4_async_handle_error(struct rpc_task *, const struct nfs_server *);
  66 static int nfs4_handle_exception(const struct nfs_server *server, int errorcode, struct nfs4_exception *exception);
  67 static int nfs4_wait_clnt_recover(struct rpc_clnt *clnt, struct nfs_client *clp);
  68 static int _nfs4_proc_lookup(struct inode *dir, const struct qstr *name, struct nfs_fh *fhandle, struct nfs_fattr *fattr);
  69 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr);
  70
  71 /* Prevent leaks of NFSv4 errors into userland */
  72 int nfs4_map_errors(int err)
  73 {
  74         if (err < -1000) {
  75                 dprintk("%s could not handle NFSv4 error %d\n",
  76                                 __func__, -err);
  77                 return -EIO;
  78         }
  79         return err;
  80 }
  81
  82 /*
  83  * This is our standard bitmap for GETATTR requests.
  84  */
  85 const u32 nfs4_fattr_bitmap[2] = {
  86         FATTR4_WORD0_TYPE
  87         | FATTR4_WORD0_CHANGE
  88         | FATTR4_WORD0_SIZE
  89         | FATTR4_WORD0_FSID
  90         | FATTR4_WORD0_FILEID,
  91         FATTR4_WORD1_MODE
  92         | FATTR4_WORD1_NUMLINKS
  93         | FATTR4_WORD1_OWNER
  94         | FATTR4_WORD1_OWNER_GROUP
  95         | FATTR4_WORD1_RAWDEV
  96         | FATTR4_WORD1_SPACE_USED
  97         | FATTR4_WORD1_TIME_ACCESS
  98         | FATTR4_WORD1_TIME_METADATA
  99         | FATTR4_WORD1_TIME_MODIFY
 100 };
 101
 102 const u32 nfs4_statfs_bitmap[2] = {
 103         FATTR4_WORD0_FILES_AVAIL
 104         | FATTR4_WORD0_FILES_FREE
 105         | FATTR4_WORD0_FILES_TOTAL,
 106         FATTR4_WORD1_SPACE_AVAIL
 107         | FATTR4_WORD1_SPACE_FREE
 108         | FATTR4_WORD1_SPACE_TOTAL
 109 };
 110
 111 const u32 nfs4_pathconf_bitmap[2] = {
 112         FATTR4_WORD0_MAXLINK
 113         | FATTR4_WORD0_MAXNAME,
 114         0
 115 };
 116
 117 const u32 nfs4_fsinfo_bitmap[2] = { FATTR4_WORD0_MAXFILESIZE
 118                         | FATTR4_WORD0_MAXREAD
 119                         | FATTR4_WORD0_MAXWRITE
 120                         | FATTR4_WORD0_LEASE_TIME,
 121                         0
 122 };
 123
 124 const u32 nfs4_fs_locations_bitmap[2] = {
 125         FATTR4_WORD0_TYPE
 126         | FATTR4_WORD0_CHANGE
 127         | FATTR4_WORD0_SIZE
 128         | FATTR4_WORD0_FSID
 129         | FATTR4_WORD0_FILEID
 130         | FATTR4_WORD0_FS_LOCATIONS,
 131         FATTR4_WORD1_MODE
 132         | FATTR4_WORD1_NUMLINKS
 133         | FATTR4_WORD1_OWNER
 134         | FATTR4_WORD1_OWNER_GROUP
 135         | FATTR4_WORD1_RAWDEV
 136         | FATTR4_WORD1_SPACE_USED
 137         | FATTR4_WORD1_TIME_ACCESS
 138         | FATTR4_WORD1_TIME_METADATA
 139         | FATTR4_WORD1_TIME_MODIFY
 140         | FATTR4_WORD1_MOUNTED_ON_FILEID
 141 };
 142
 143 static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dentry,
 144                 struct nfs4_readdir_arg *readdir)
 145 {
 146         __be32 *start, *p;
 147
 148         BUG_ON(readdir->count < 80);
 149         if (cookie > 2) {
 150                 readdir->cookie = cookie;
 151                 memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier));
 152                 return;
 153         }
 154
 155         readdir->cookie = 0;
 156         memset(&readdir->verifier, 0, sizeof(readdir->verifier));
 157         if (cookie == 2)
 158                 return;
 159
 160         /*
 161          * NFSv4 servers do not return entries for '.' and '..'
 162          * Therefore, we fake these entries here.  We let '.'
 163          * have cookie 0 and '..' have cookie 1.  Note that
 164          * when talking to the server, we always send cookie 0
 165          * instead of 1 or 2.
 166          */
 167         start = p = kmap_atomic(*readdir->pages, KM_USER0);
 168
 169         if (cookie == 0) {
 170                 *p++ = xdr_one;                                  /* next */
 171                 *p++ = xdr_zero;                   /* cookie, first word */
 172                 *p++ = xdr_one;                   /* cookie, second word */
 173                 *p++ = xdr_one;                             /* entry len */
 174                 memcpy(p, ".\0\0\0", 4);                        /* entry */
 175                 p++;
 176                 *p++ = xdr_one;                         /* bitmap length */
 177                 *p++ = htonl(FATTR4_WORD0_FILEID);             /* bitmap */
 178                 *p++ = htonl(8);              /* attribute buffer length */
 179                 p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_inode));
 180         }
 181
 182         *p++ = xdr_one;                                  /* next */
 183         *p++ = xdr_zero;                   /* cookie, first word */
 184         *p++ = xdr_two;                   /* cookie, second word */
 185         *p++ = xdr_two;                             /* entry len */
 186         memcpy(p, "..\0\0", 4);                         /* entry */
 187         p++;
 188         *p++ = xdr_one;                         /* bitmap length */
 189         *p++ = htonl(FATTR4_WORD0_FILEID);             /* bitmap */
 190         *p++ = htonl(8);              /* attribute buffer length */
 191         p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_parent->d_inode));
 192
 193         readdir->pgbase = (char *)p - (char *)start;
 194         readdir->count -= readdir->pgbase;
 195         kunmap_atomic(start, KM_USER0);
 196 }
 197
 198 static void renew_lease(const struct nfs_server *server, unsigned long timestamp)
 199 {
 200         struct nfs_client *clp = server->nfs_client;
 201         spin_lock(&clp->cl_lock);
 202         if (time_before(clp->cl_last_renewal,timestamp))
 203                 clp->cl_last_renewal = timestamp;
 204         spin_unlock(&clp->cl_lock);
 205 }
 206
 207 static void update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo)
 208 {
 209         struct nfs_inode *nfsi = NFS_I(dir);
 210
 211         spin_lock(&dir->i_lock);
 212         nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_DATA;
 213         if (!cinfo->atomic || cinfo->before != nfsi->change_attr)
 214                 nfs_force_lookup_revalidate(dir);
 215         nfsi->change_attr = cinfo->after;
 216         spin_unlock(&dir->i_lock);
 217 }
 218
 219 struct nfs4_opendata {
 220         struct kref kref;
 221         struct nfs_openargs o_arg;
 222         struct nfs_openres o_res;
 223         struct nfs_open_confirmargs c_arg;
 224         struct nfs_open_confirmres c_res;
 225         struct nfs_fattr f_attr;
 226         struct nfs_fattr dir_attr;
 227         struct path path;
 228         struct dentry *dir;
 229         struct nfs4_state_owner *owner;
 230         struct nfs4_state *state;
 231         struct iattr attrs;
 232         unsigned long timestamp;
 233         unsigned int rpc_done : 1;
 234         int rpc_status;
 235         int cancelled;
 236 };
 237
 238
 239 static void nfs4_init_opendata_res(struct nfs4_opendata *p)
 240 {
 241         p->o_res.f_attr = &p->f_attr;
 242         p->o_res.dir_attr = &p->dir_attr;
 243         p->o_res.seqid = p->o_arg.seqid;
 244         p->c_res.seqid = p->c_arg.seqid;
 245         p->o_res.server = p->o_arg.server;
 246         nfs_fattr_init(&p->f_attr);
 247         nfs_fattr_init(&p->dir_attr);
 248 }
 249
 250 static struct nfs4_opendata *nfs4_opendata_alloc(struct path *path,
 251                 struct nfs4_state_owner *sp, int flags,
 252                 const struct iattr *attrs)
 253 {
 254         struct dentry *parent = dget_parent(path->dentry);
 255         struct inode *dir = parent->d_inode;
 256         struct nfs_server *server = NFS_SERVER(dir);
 257         struct nfs4_opendata *p;
 258
 259         p = kzalloc(sizeof(*p), GFP_KERNEL);
 260         if (p == NULL)
 261                 goto err;
 262         p->o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid);
 263         if (p->o_arg.seqid == NULL)
 264                 goto err_free;
 265         p->path.mnt = mntget(path->mnt);
 266         p->path.dentry = dget(path->dentry);
 267         p->dir = parent;
 268         p->owner = sp;
 269         atomic_inc(&sp->so_count);
 270         p->o_arg.fh = NFS_FH(dir);
 271         p->o_arg.open_flags = flags,
 272         p->o_arg.clientid = server->nfs_client->cl_clientid;
 273         p->o_arg.id = sp->so_owner_id.id;
 274         p->o_arg.name = &p->path.dentry->d_name;
 275         p->o_arg.server = server;
 276         p->o_arg.bitmask = server->attr_bitmask;
 277         p->o_arg.claim = NFS4_OPEN_CLAIM_NULL;
 278         if (flags & O_EXCL) {
 279                 u32 *s = (u32 *) p->o_arg.u.verifier.data;
 280                 s[0] = jiffies;
 281                 s[1] = current->pid;
 282         } else if (flags & O_CREAT) {
 283                 p->o_arg.u.attrs = &p->attrs;
 284                 memcpy(&p->attrs, attrs, sizeof(p->attrs));
 285         }
 286         p->c_arg.fh = &p->o_res.fh;
 287         p->c_arg.stateid = &p->o_res.stateid;
 288         p->c_arg.seqid = p->o_arg.seqid;
 289         nfs4_init_opendata_res(p);
 290         kref_init(&p->kref);
 291         return p;
 292 err_free:
 293         kfree(p);
 294 err:
 295         dput(parent);
 296         return NULL;
 297 }
 298
 299 static void nfs4_opendata_free(struct kref *kref)
 300 {
 301         struct nfs4_opendata *p = container_of(kref,
 302                         struct nfs4_opendata, kref);
 303
 304         nfs_free_seqid(p->o_arg.seqid);
 305         if (p->state != NULL)
 306                 nfs4_put_open_state(p->state);
 307         nfs4_put_state_owner(p->owner);
 308         dput(p->dir);
 309         path_put(&p->path);
 310         kfree(p);
 311 }
 312
 313 static void nfs4_opendata_put(struct nfs4_opendata *p)
 314 {
 315         if (p != NULL)
 316                 kref_put(&p->kref, nfs4_opendata_free);
 317 }
 318
 319 static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task)
 320 {
 321         int ret;
 322
 323         ret = rpc_wait_for_completion_task(task);
 324         return ret;
 325 }
 326
 327 static int can_open_cached(struct nfs4_state *state, int mode)
 328 {
 329         int ret = 0;
 330         switch (mode & (FMODE_READ|FMODE_WRITE|O_EXCL)) {
 331                 case FMODE_READ:
 332                         ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0;
 333                         break;
 334                 case FMODE_WRITE:
 335                         ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0;
 336                         break;
 337                 case FMODE_READ|FMODE_WRITE:
 338                         ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0;
 339         }
 340         return ret;
 341 }
 342
 343 static int can_open_delegated(struct nfs_delegation *delegation, mode_t open_flags)
 344 {
 345         if ((delegation->type & open_flags) != open_flags)
 346                 return 0;
 347         if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags))
 348                 return 0;
 349         return 1;
 350 }
 351
 352 static void update_open_stateflags(struct nfs4_state *state, mode_t open_flags)
 353 {
 354         switch (open_flags) {
 355                 case FMODE_WRITE:
 356                         state->n_wronly++;
 357                         break;
 358                 case FMODE_READ:
 359                         state->n_rdonly++;
 360                         break;
 361                 case FMODE_READ|FMODE_WRITE:
 362                         state->n_rdwr++;
 363         }
 364         nfs4_state_set_mode_locked(state, state->state | open_flags);
 365 }
 366
 367 static void nfs_set_open_stateid_locked(struct nfs4_state *state, nfs4_stateid *stateid, int open_flags)
 368 {
 369         if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
 370                 memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data));
 371         memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data));
 372         switch (open_flags) {
 373                 case FMODE_READ:
 374                         set_bit(NFS_O_RDONLY_STATE, &state->flags);
 375                         break;
 376                 case FMODE_WRITE:
 377                         set_bit(NFS_O_WRONLY_STATE, &state->flags);
 378                         break;
 379                 case FMODE_READ|FMODE_WRITE:
 380                         set_bit(NFS_O_RDWR_STATE, &state->flags);
 381         }
 382 }
 383
 384 static void nfs_set_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid, int open_flags)
 385 {
 386         write_seqlock(&state->seqlock);
 387         nfs_set_open_stateid_locked(state, stateid, open_flags);
 388         write_sequnlock(&state->seqlock);
 389 }
 390
 391 static void __update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, const nfs4_stateid *deleg_stateid, int open_flags)
 392 {
 393         /*
 394          * Protect the call to nfs4_state_set_mode_locked and
 395          * serialise the stateid update
 396          */
 397         write_seqlock(&state->seqlock);
 398         if (deleg_stateid != NULL) {
 399                 memcpy(state->stateid.data, deleg_stateid->data, sizeof(state->stateid.data));
 400                 set_bit(NFS_DELEGATED_STATE, &state->flags);
 401         }
 402         if (open_stateid != NULL)
 403                 nfs_set_open_stateid_locked(state, open_stateid, open_flags);
 404         write_sequnlock(&state->seqlock);
 405         spin_lock(&state->owner->so_lock);
 406         update_open_stateflags(state, open_flags);
 407         spin_unlock(&state->owner->so_lock);
 408 }
 409
 410 static int update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, nfs4_stateid *delegation, int open_flags)
 411 {
 412         struct nfs_inode *nfsi = NFS_I(state->inode);
 413         struct nfs_delegation *deleg_cur;
 414         int ret = 0;
 415
 416         open_flags &= (FMODE_READ|FMODE_WRITE);
 417
 418         rcu_read_lock();
 419         deleg_cur = rcu_dereference(nfsi->delegation);
 420         if (deleg_cur == NULL)
 421                 goto no_delegation;
 422
 423         spin_lock(&deleg_cur->lock);
 424         if (nfsi->delegation != deleg_cur ||
 425             (deleg_cur->type & open_flags) != open_flags)
 426                 goto no_delegation_unlock;
 427
 428         if (delegation == NULL)
 429                 delegation = &deleg_cur->stateid;
 430         else if (memcmp(deleg_cur->stateid.data, delegation->data, NFS4_STATEID_SIZE) != 0)
 431                 goto no_delegation_unlock;
 432
 433         __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags);
 434         ret = 1;
 435 no_delegation_unlock:
 436         spin_unlock(&deleg_cur->lock);
 437 no_delegation:
 438         rcu_read_unlock();
 439
 440         if (!ret && open_stateid != NULL) {
 441                 __update_open_stateid(state, open_stateid, NULL, open_flags);
 442                 ret = 1;
 443         }
 444
 445         return ret;
 446 }
 447
 448
 449 static void nfs4_return_incompatible_delegation(struct inode *inode, mode_t open_flags)
 450 {
 451         struct nfs_delegation *delegation;
 452
 453         rcu_read_lock();
 454         delegation = rcu_dereference(NFS_I(inode)->delegation);
 455         if (delegation == NULL || (delegation->type & open_flags) == open_flags) {
 456                 rcu_read_unlock();
 457                 return;
 458         }
 459         rcu_read_unlock();
 460         nfs_inode_return_delegation(inode);
 461 }
 462
 463 static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata)
 464 {
 465         struct nfs4_state *state = opendata->state;
 466         struct nfs_inode *nfsi = NFS_I(state->inode);
 467         struct nfs_delegation *delegation;
 468         int open_mode = opendata->o_arg.open_flags & (FMODE_READ|FMODE_WRITE|O_EXCL);
 469         nfs4_stateid stateid;
 470         int ret = -EAGAIN;
 471
 472         for (;;) {
 473                 if (can_open_cached(state, open_mode)) {
 474                         spin_lock(&state->owner->so_lock);
 475                         if (can_open_cached(state, open_mode)) {
 476                                 update_open_stateflags(state, open_mode);
 477                                 spin_unlock(&state->owner->so_lock);
 478                                 goto out_return_state;
 479                         }
 480                         spin_unlock(&state->owner->so_lock);
 481                 }
 482                 rcu_read_lock();
 483                 delegation = rcu_dereference(nfsi->delegation);
 484                 if (delegation == NULL ||
 485                     !can_open_delegated(delegation, open_mode)) {
 486                         rcu_read_unlock();
 487                         break;
 488                 }
 489                 /* Save the delegation */
 490                 memcpy(stateid.data, delegation->stateid.data, sizeof(stateid.data));
 491                 rcu_read_unlock();
 492                 ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode);
 493                 if (ret != 0)
 494                         goto out;
 495                 ret = -EAGAIN;
 496
 497                 /* Try to update the stateid using the delegation */
 498                 if (update_open_stateid(state, NULL, &stateid, open_mode))
 499                         goto out_return_state;
 500         }
 501 out:
 502         return ERR_PTR(ret);
 503 out_return_state:
 504         atomic_inc(&state->count);
 505         return state;
 506 }
 507
 508 static struct nfs4_state *nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
 509 {
 510         struct inode *inode;
 511         struct nfs4_state *state = NULL;
 512         struct nfs_delegation *delegation;
 513         int ret;
 514
 515         if (!data->rpc_done) {
 516                 state = nfs4_try_open_cached(data);
 517                 goto out;
 518         }
 519
 520         ret = -EAGAIN;
 521         if (!(data->f_attr.valid & NFS_ATTR_FATTR))
 522                 goto err;
 523         inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr);
 524         ret = PTR_ERR(inode);
 525         if (IS_ERR(inode))
 526                 goto err;
 527         ret = -ENOMEM;
 528         state = nfs4_get_open_state(inode, data->owner);
 529         if (state == NULL)
 530                 goto err_put_inode;
 531         if (data->o_res.delegation_type != 0) {
 532                 int delegation_flags = 0;
 533
 534                 rcu_read_lock();
 535                 delegation = rcu_dereference(NFS_I(inode)->delegation);
 536                 if (delegation)
 537                         delegation_flags = delegation->flags;
 538                 rcu_read_unlock();
 539                 if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0)
 540                         nfs_inode_set_delegation(state->inode,
 541                                         data->owner->so_cred,
 542                                         &data->o_res);
 543                 else
 544                         nfs_inode_reclaim_delegation(state->inode,
 545                                         data->owner->so_cred,
 546                                         &data->o_res);
 547         }
 548
 549         update_open_stateid(state, &data->o_res.stateid, NULL,
 550                         data->o_arg.open_flags);
 551         iput(inode);
 552 out:
 553         return state;
 554 err_put_inode:
 555         iput(inode);
 556 err:
 557         return ERR_PTR(ret);
 558 }
 559
 560 static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *state)
 561 {
 562         struct nfs_inode *nfsi = NFS_I(state->inode);
 563         struct nfs_open_context *ctx;
 564
 565         spin_lock(&state->inode->i_lock);
 566         list_for_each_entry(ctx, &nfsi->open_files, list) {
 567                 if (ctx->state != state)
 568                         continue;
 569                 get_nfs_open_context(ctx);
 570                 spin_unlock(&state->inode->i_lock);
 571                 return ctx;
 572         }
 573         spin_unlock(&state->inode->i_lock);
 574         return ERR_PTR(-ENOENT);
 575 }
 576
 577 static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context *ctx, struct nfs4_state *state)
 578 {
 579         struct nfs4_opendata *opendata;
 580
 581         opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL);
 582         if (opendata == NULL)
 583                 return ERR_PTR(-ENOMEM);
 584         opendata->state = state;
 585         atomic_inc(&state->count);
 586         return opendata;
 587 }
 588
 589 static int nfs4_open_recover_helper(struct nfs4_opendata *opendata, mode_t openflags, struct nfs4_state **res)
 590 {
 591         struct nfs4_state *newstate;
 592         int ret;
 593
 594         opendata->o_arg.open_flags = openflags;
 595         memset(&opendata->o_res, 0, sizeof(opendata->o_res));
 596         memset(&opendata->c_res, 0, sizeof(opendata->c_res));
 597         nfs4_init_opendata_res(opendata);
 598         ret = _nfs4_proc_open(opendata);
 599         if (ret != 0)
 600                 return ret;
 601         newstate = nfs4_opendata_to_nfs4_state(opendata);
 602         if (IS_ERR(newstate))
 603                 return PTR_ERR(newstate);
 604         nfs4_close_state(&opendata->path, newstate, openflags);
 605         *res = newstate;
 606         return 0;
 607 }
 608
 609 static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *state)
 610 {
 611         struct nfs4_state *newstate;
 612         int ret;
 613
 614         /* memory barrier prior to reading state->n_* */
 615         clear_bit(NFS_DELEGATED_STATE, &state->flags);
 616         smp_rmb();
 617         if (state->n_rdwr != 0) {
 618                 ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE, &newstate);
 619                 if (ret != 0)
 620                         return ret;
 621                 if (newstate != state)
 622                         return -ESTALE;
 623         }
 624         if (state->n_wronly != 0) {
 625                 ret = nfs4_open_recover_helper(opendata, FMODE_WRITE, &newstate);
 626                 if (ret != 0)
 627                         return ret;
 628                 if (newstate != state)
 629                         return -ESTALE;
 630         }
 631         if (state->n_rdonly != 0) {
 632                 ret = nfs4_open_recover_helper(opendata, FMODE_READ, &newstate);
 633                 if (ret != 0)
 634                         return ret;
 635                 if (newstate != state)
 636                         return -ESTALE;
 637         }
 638         /*
 639          * We may have performed cached opens for all three recoveries.
 640          * Check if we need to update the current stateid.
 641          */
 642         if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 &&
 643             memcmp(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data)) != 0) {
 644                 write_seqlock(&state->seqlock);
 645                 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
 646                         memcpy(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data));
 647                 write_sequnlock(&state->seqlock);
 648         }
 649         return 0;
 650 }
 651
 652 /*
 653  * OPEN_RECLAIM:
 654  *      reclaim state on the server after a reboot.
 655  */
 656 static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
 657 {
 658         struct nfs_delegation *delegation;
 659         struct nfs4_opendata *opendata;
 660         int delegation_type = 0;
 661         int status;
 662
 663         opendata = nfs4_open_recoverdata_alloc(ctx, state);
 664         if (IS_ERR(opendata))
 665                 return PTR_ERR(opendata);
 666         opendata->o_arg.claim = NFS4_OPEN_CLAIM_PREVIOUS;
 667         opendata->o_arg.fh = NFS_FH(state->inode);
 668         rcu_read_lock();
 669         delegation = rcu_dereference(NFS_I(state->inode)->delegation);
 670         if (delegation != NULL && test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) != 0)
 671                 delegation_type = delegation->type;
 672         rcu_read_unlock();
 673         opendata->o_arg.u.delegation_type = delegation_type;
 674         status = nfs4_open_recover(opendata, state);
 675         nfs4_opendata_put(opendata);
 676         return status;
 677 }
 678
 679 static int nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
 680 {
 681         struct nfs_server *server = NFS_SERVER(state->inode);
 682         struct nfs4_exception exception = { };
 683         int err;
 684         do {
 685                 err = _nfs4_do_open_reclaim(ctx, state);
 686                 if (err != -NFS4ERR_DELAY)
 687                         break;
 688                 nfs4_handle_exception(server, err, &exception);
 689         } while (exception.retry);
 690         return err;
 691 }
 692
 693 static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state)
 694 {
 695         struct nfs_open_context *ctx;
 696         int ret;
 697
 698         ctx = nfs4_state_find_open_context(state);
 699         if (IS_ERR(ctx))
 700                 return PTR_ERR(ctx);
 701         ret = nfs4_do_open_reclaim(ctx, state);
 702         put_nfs_open_context(ctx);
 703         return ret;
 704 }
 705
 706 static int _nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)
 707 {
 708         struct nfs4_opendata *opendata;
 709         int ret;
 710
 711         opendata = nfs4_open_recoverdata_alloc(ctx, state);
 712         if (IS_ERR(opendata))
 713                 return PTR_ERR(opendata);
 714         opendata->o_arg.claim = NFS4_OPEN_CLAIM_DELEGATE_CUR;
 715         memcpy(opendata->o_arg.u.delegation.data, stateid->data,
 716                         sizeof(opendata->o_arg.u.delegation.data));
 717         ret = nfs4_open_recover(opendata, state);
 718         nfs4_opendata_put(opendata);
 719         return ret;
 720 }
 721
 722 int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)
 723 {
 724         struct nfs4_exception exception = { };
 725         struct nfs_server *server = NFS_SERVER(state->inode);
 726         int err;
 727         do {
 728                 err = _nfs4_open_delegation_recall(ctx, state, stateid);
 729                 switch (err) {
 730                         case 0:
 731                                 return err;
 732                         case -NFS4ERR_STALE_CLIENTID:
 733                         case -NFS4ERR_STALE_STATEID:
 734                         case -NFS4ERR_EXPIRED:
 735                                 /* Don't recall a delegation if it was lost */
 736                                 nfs4_schedule_state_recovery(server->nfs_client);
 737                                 return err;
 738                 }
 739                 err = nfs4_handle_exception(server, err, &exception);
 740         } while (exception.retry);
 741         return err;
 742 }
 743
 744 static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata)
 745 {
 746         struct nfs4_opendata *data = calldata;
 747
 748         data->rpc_status = task->tk_status;
 749         if (RPC_ASSASSINATED(task))
 750                 return;
 751         if (data->rpc_status == 0) {
 752                 memcpy(data->o_res.stateid.data, data->c_res.stateid.data,
 753                                 sizeof(data->o_res.stateid.data));
 754                 nfs_confirm_seqid(&data->owner->so_seqid, 0);
 755                 renew_lease(data->o_res.server, data->timestamp);
 756                 data->rpc_done = 1;
 757         }
 758 }
 759
 760 static void nfs4_open_confirm_release(void *calldata)
 761 {
 762         struct nfs4_opendata *data = calldata;
 763         struct nfs4_state *state = NULL;
 764
 765         /* If this request hasn't been cancelled, do nothing */
 766         if (data->cancelled == 0)
 767                 goto out_free;
 768         /* In case of error, no cleanup! */
 769         if (!data->rpc_done)
 770                 goto out_free;
 771         state = nfs4_opendata_to_nfs4_state(data);
 772         if (!IS_ERR(state))
 773                 nfs4_close_state(&data->path, state, data->o_arg.open_flags);
 774 out_free:
 775         nfs4_opendata_put(data);
 776 }
 777
 778 static const struct rpc_call_ops nfs4_open_confirm_ops = {
 779         .rpc_call_done = nfs4_open_confirm_done,
 780         .rpc_release = nfs4_open_confirm_release,
 781 };
 782
 783 /*
 784  * Note: On error, nfs4_proc_open_confirm will free the struct nfs4_opendata
 785  */
 786 static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)
 787 {
 788         struct nfs_server *server = NFS_SERVER(data->dir->d_inode);
 789         struct rpc_task *task;
 790         struct  rpc_message msg = {
 791                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM],
 792                 .rpc_argp = &data->c_arg,
 793                 .rpc_resp = &data->c_res,
 794                 .rpc_cred = data->owner->so_cred,
 795         };
 796         struct rpc_task_setup task_setup_data = {
 797                 .rpc_client = server->client,
 798                 .rpc_message = &msg,
 799                 .callback_ops = &nfs4_open_confirm_ops,
 800                 .callback_data = data,
 801                 .workqueue = nfsiod_workqueue,
 802                 .flags = RPC_TASK_ASYNC,
 803         };
 804         int status;
 805
 806         kref_get(&data->kref);
 807         data->rpc_done = 0;
 808         data->rpc_status = 0;
 809         data->timestamp = jiffies;
 810         task = rpc_run_task(&task_setup_data);
 811         if (IS_ERR(task))
 812                 return PTR_ERR(task);
 813         status = nfs4_wait_for_completion_rpc_task(task);
 814         if (status != 0) {
 815                 data->cancelled = 1;
 816                 smp_wmb();
 817         } else
 818                 status = data->rpc_status;
 819         rpc_put_task(task);
 820         return status;
 821 }
 822
 823 static void nfs4_open_prepare(struct rpc_task *task, void *calldata)
 824 {
 825         struct nfs4_opendata *data = calldata;
 826         struct nfs4_state_owner *sp = data->owner;
 827
 828         if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0)
 829                 return;
 830         /*
 831          * Check if we still need to send an OPEN call, or if we can use
 832          * a delegation instead.
 833          */
 834         if (data->state != NULL) {
 835                 struct nfs_delegation *delegation;
 836
 837                 if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ|FMODE_WRITE|O_EXCL)))
 838                         goto out_no_action;
 839                 rcu_read_lock();
 840                 delegation = rcu_dereference(NFS_I(data->state->inode)->delegation);
 841                 if (delegation != NULL &&
 842                     test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) == 0) {
 843                         rcu_read_unlock();
 844                         goto out_no_action;
 845                 }
 846                 rcu_read_unlock();
 847         }
 848         /* Update sequence id. */
 849         data->o_arg.id = sp->so_owner_id.id;
 850         data->o_arg.clientid = sp->so_client->cl_clientid;
 851         if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS) {
 852                 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR];
 853                 nfs_copy_fh(&data->o_res.fh, data->o_arg.fh);
 854         }
 855         data->timestamp = jiffies;
 856         rpc_call_start(task);
 857         return;
 858 out_no_action:
 859         task->tk_action = NULL;
 860
 861 }
 862
 863 static void nfs4_open_done(struct rpc_task *task, void *calldata)
 864 {
 865         struct nfs4_opendata *data = calldata;
 866
 867         data->rpc_status = task->tk_status;
 868         if (RPC_ASSASSINATED(task))
 869                 return;
 870         if (task->tk_status == 0) {
 871                 switch (data->o_res.f_attr->mode & S_IFMT) {
 872                         case S_IFREG:
 873                                 break;
 874                         case S_IFLNK:
 875                                 data->rpc_status = -ELOOP;
 876                                 break;
 877                         case S_IFDIR:
 878                                 data->rpc_status = -EISDIR;
 879                                 break;
 880                         default:
 881                                 data->rpc_status = -ENOTDIR;
 882                 }
 883                 renew_lease(data->o_res.server, data->timestamp);
 884                 if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM))
 885                         nfs_confirm_seqid(&data->owner->so_seqid, 0);
 886         }
 887         data->rpc_done = 1;
 888 }
 889
 890 static void nfs4_open_release(void *calldata)
 891 {
 892         struct nfs4_opendata *data = calldata;
 893         struct nfs4_state *state = NULL;
 894
 895         /* If this request hasn't been cancelled, do nothing */
 896         if (data->cancelled == 0)
 897                 goto out_free;
 898         /* In case of error, no cleanup! */
 899         if (data->rpc_status != 0 || !data->rpc_done)
 900                 goto out_free;
 901         /* In case we need an open_confirm, no cleanup! */
 902         if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)
 903                 goto out_free;
 904         state = nfs4_opendata_to_nfs4_state(data);
 905         if (!IS_ERR(state))
 906                 nfs4_close_state(&data->path, state, data->o_arg.open_flags);
 907 out_free:
 908         nfs4_opendata_put(data);
 909 }
 910
 911 static const struct rpc_call_ops nfs4_open_ops = {
 912         .rpc_call_prepare = nfs4_open_prepare,
 913         .rpc_call_done = nfs4_open_done,
 914         .rpc_release = nfs4_open_release,
 915 };
 916
 917 /*
 918  * Note: On error, nfs4_proc_open will free the struct nfs4_opendata
 919  */
 920 static int _nfs4_proc_open(struct nfs4_opendata *data)
 921 {
 922         struct inode *dir = data->dir->d_inode;
 923         struct nfs_server *server = NFS_SERVER(dir);
 924         struct nfs_openargs *o_arg = &data->o_arg;
 925         struct nfs_openres *o_res = &data->o_res;
 926         struct rpc_task *task;
 927         struct rpc_message msg = {
 928                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN],
 929                 .rpc_argp = o_arg,
 930                 .rpc_resp = o_res,
 931                 .rpc_cred = data->owner->so_cred,
 932         };
 933         struct rpc_task_setup task_setup_data = {
 934                 .rpc_client = server->client,
 935                 .rpc_message = &msg,
 936                 .callback_ops = &nfs4_open_ops,
 937                 .callback_data = data,
 938                 .workqueue = nfsiod_workqueue,
 939                 .flags = RPC_TASK_ASYNC,
 940         };
 941         int status;
 942
 943         kref_get(&data->kref);
 944         data->rpc_done = 0;
 945         data->rpc_status = 0;
 946         data->cancelled = 0;
 947         task = rpc_run_task(&task_setup_data);
 948         if (IS_ERR(task))
 949                 return PTR_ERR(task);
 950         status = nfs4_wait_for_completion_rpc_task(task);
 951         if (status != 0) {
 952                 data->cancelled = 1;
 953                 smp_wmb();
 954         } else
 955                 status = data->rpc_status;
 956         rpc_put_task(task);
 957         if (status != 0 || !data->rpc_done)
 958                 return status;
 959
 960         if (o_res->fh.size == 0)
 961                 _nfs4_proc_lookup(dir, o_arg->name, &o_res->fh, o_res->f_attr);
 962
 963         if (o_arg->open_flags & O_CREAT) {
 964                 update_changeattr(dir, &o_res->cinfo);
 965                 nfs_post_op_update_inode(dir, o_res->dir_attr);
 966         } else
 967                 nfs_refresh_inode(dir, o_res->dir_attr);
 968         if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
 969                 status = _nfs4_proc_open_confirm(data);
 970                 if (status != 0)
 971                         return status;
 972         }
 973         if (!(o_res->f_attr->valid & NFS_ATTR_FATTR))
 974                 _nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr);
 975         return 0;
 976 }
 977
 978 static int nfs4_recover_expired_lease(struct nfs_server *server)
 979 {
 980         struct nfs_client *clp = server->nfs_client;
 981         int ret;
 982
 983         for (;;) {
 984                 ret = nfs4_wait_clnt_recover(server->client, clp);
 985                 if (ret != 0)
 986                         return ret;
 987                 if (!test_and_clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
 988                         break;
 989                 nfs4_schedule_state_recovery(clp);
 990         }
 991         return 0;
 992 }
 993
 994 /*
 995  * OPEN_EXPIRED:
 996  *      reclaim state on the server after a network partition.
 997  *      Assumes caller holds the appropriate lock
 998  */
 999 static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
1000 {
1001         struct nfs4_opendata *opendata;
1002         int ret;
1003
1004         opendata = nfs4_open_recoverdata_alloc(ctx, state);
1005         if (IS_ERR(opendata))
1006                 return PTR_ERR(opendata);
1007         ret = nfs4_open_recover(opendata, state);
1008         if (ret == -ESTALE)
1009                 d_drop(ctx->path.dentry);
1010         nfs4_opendata_put(opendata);
1011         return ret;
1012 }
1013
1014 static inline int nfs4_do_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
1015 {
1016         struct nfs_server *server = NFS_SERVER(state->inode);
1017         struct nfs4_exception exception = { };
1018         int err;
1019
1020         do {
1021                 err = _nfs4_open_expired(ctx, state);
1022                 if (err == -NFS4ERR_DELAY)
1023                         nfs4_handle_exception(server, err, &exception);
1024         } while (exception.retry);
1025         return err;
1026 }
1027
1028 static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
1029 {
1030         struct nfs_open_context *ctx;
1031         int ret;
1032
1033         ctx = nfs4_state_find_open_context(state);
1034         if (IS_ERR(ctx))
1035                 return PTR_ERR(ctx);
1036         ret = nfs4_do_open_expired(ctx, state);
1037         put_nfs_open_context(ctx);
1038         return ret;
1039 }
1040
1041 /*
1042  * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*
1043  * fields corresponding to attributes that were used to store the verifier.
1044  * Make sure we clobber those fields in the later setattr call
1045  */
1046 static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata, struct iattr *sattr)
1047 {
1048         if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_ACCESS) &&
1049             !(sattr->ia_valid & ATTR_ATIME_SET))
1050                 sattr->ia_valid |= ATTR_ATIME;
1051
1052         if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_MODIFY) &&
1053             !(sattr->ia_valid & ATTR_MTIME_SET))
1054                 sattr->ia_valid |= ATTR_MTIME;
1055 }
1056
1057 /*
1058  * Returns a referenced nfs4_state
1059  */
1060 static int _nfs4_do_open(struct inode *dir, struct path *path, int flags, struct iattr *sattr, struct rpc_cred *cred, struct nfs4_state **res)
1061 {
1062         struct nfs4_state_owner  *sp;
1063         struct nfs4_state     *state = NULL;
1064         struct nfs_server       *server = NFS_SERVER(dir);
1065         struct nfs_client *clp = server->nfs_client;
1066         struct nfs4_opendata *opendata;
1067         int status;
1068
1069         /* Protect against reboot recovery conflicts */
1070         status = -ENOMEM;
1071         if (!(sp = nfs4_get_state_owner(server, cred))) {
1072                 dprintk("nfs4_do_open: nfs4_get_state_owner failed!\n");
1073                 goto out_err;
1074         }
1075         status = nfs4_recover_expired_lease(server);
1076         if (status != 0)
1077                 goto err_put_state_owner;
1078         if (path->dentry->d_inode != NULL)
1079                 nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ|FMODE_WRITE));
1080         down_read(&clp->cl_sem);
1081         status = -ENOMEM;
1082         opendata = nfs4_opendata_alloc(path, sp, flags, sattr);
1083         if (opendata == NULL)
1084                 goto err_release_rwsem;
1085
1086         if (path->dentry->d_inode != NULL)
1087                 opendata->state = nfs4_get_open_state(path->dentry->d_inode, sp);
1088
1089         status = _nfs4_proc_open(opendata);
1090         if (status != 0)
1091                 goto err_opendata_put;
1092
1093         if (opendata->o_arg.open_flags & O_EXCL)
1094                 nfs4_exclusive_attrset(opendata, sattr);
1095
1096         state = nfs4_opendata_to_nfs4_state(opendata);
1097         status = PTR_ERR(state);
1098         if (IS_ERR(state))
1099                 goto err_opendata_put;
1100         nfs4_opendata_put(opendata);
1101         nfs4_put_state_owner(sp);
1102         up_read(&clp->cl_sem);
1103         *res = state;
1104         return 0;
1105 err_opendata_put:
1106         nfs4_opendata_put(opendata);
1107 err_release_rwsem:
1108         up_read(&clp->cl_sem);
1109 err_put_state_owner:
1110         nfs4_put_state_owner(sp);
1111 out_err:
1112         *res = NULL;
1113         return status;
1114 }
1115
1116
1117 static struct nfs4_state *nfs4_do_open(struct inode *dir, struct path *path, int flags, struct iattr *sattr, struct rpc_cred *cred)
1118 {
1119         struct nfs4_exception exception = { };
1120         struct nfs4_state *res;
1121         int status;
1122
1123         do {
1124                 status = _nfs4_do_open(dir, path, flags, sattr, cred, &res);
1125                 if (status == 0)
1126                         break;
1127                 /* NOTE: BAD_SEQID means the server and client disagree about the
1128                  * book-keeping w.r.t. state-changing operations
1129                  * (OPEN/CLOSE/LOCK/LOCKU...)
1130                  * It is actually a sign of a bug on the client or on the server.
1131                  *
1132                  * If we receive a BAD_SEQID error in the particular case of
1133                  * doing an OPEN, we assume that nfs_increment_open_seqid() will
1134                  * have unhashed the old state_owner for us, and that we can
1135                  * therefore safely retry using a new one. We should still warn
1136                  * the user though...
1137                  */
1138                 if (status == -NFS4ERR_BAD_SEQID) {
1139                         printk(KERN_WARNING "NFS: v4 server %s "
1140                                         " returned a bad sequence-id error!\n",
1141                                         NFS_SERVER(dir)->nfs_client->cl_hostname);
1142                         exception.retry = 1;
1143                         continue;
1144                 }
1145                 /*
1146                  * BAD_STATEID on OPEN means that the server cancelled our
1147                  * state before it received the OPEN_CONFIRM.
1148                  * Recover by retrying the request as per the discussion
1149                  * on Page 181 of RFC3530.
1150                  */
1151                 if (status == -NFS4ERR_BAD_STATEID) {
1152                         exception.retry = 1;
1153                         continue;
1154                 }
1155                 if (status == -EAGAIN) {
1156                         /* We must have found a delegation */
1157                         exception.retry = 1;
1158                         continue;
1159                 }
1160                 res = ERR_PTR(nfs4_handle_exception(NFS_SERVER(dir),
1161                                         status, &exception));
1162         } while (exception.retry);
1163         return res;
1164 }
1165
1166 static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
1167                             struct nfs_fattr *fattr, struct iattr *sattr,
1168                             struct nfs4_state *state)
1169 {
1170         struct nfs_server *server = NFS_SERVER(inode);
1171         struct nfs_setattrargs  arg = {
1172                 .fh             = NFS_FH(inode),
1173                 .iap            = sattr,
1174                 .server         = server,
1175                 .bitmask = server->attr_bitmask,
1176         };
1177         struct nfs_setattrres  res = {
1178                 .fattr          = fattr,
1179                 .server         = server,
1180         };
1181         struct rpc_message msg = {
1182                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
1183                 .rpc_argp       = &arg,
1184                 .rpc_resp       = &res,
1185                 .rpc_cred       = cred,
1186         };
1187         unsigned long timestamp = jiffies;
1188         int status;
1189
1190         nfs_fattr_init(fattr);
1191
1192         if (nfs4_copy_delegation_stateid(&arg.stateid, inode)) {
1193                 /* Use that stateid */
1194         } else if (state != NULL) {
1195                 nfs4_copy_stateid(&arg.stateid, state, current->files);
1196         } else
1197                 memcpy(&arg.stateid, &zero_stateid, sizeof(arg.stateid));
1198
1199         status = rpc_call_sync(server->client, &msg, 0);
1200         if (status == 0 && state != NULL)
1201                 renew_lease(server, timestamp);
1202         return status;
1203 }
1204
1205 static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
1206                            struct nfs_fattr *fattr, struct iattr *sattr,
1207                            struct nfs4_state *state)
1208 {
1209         struct nfs_server *server = NFS_SERVER(inode);
1210         struct nfs4_exception exception = { };
1211         int err;
1212         do {
1213                 err = nfs4_handle_exception(server,
1214                                 _nfs4_do_setattr(inode, cred, fattr, sattr, state),
1215                                 &exception);
1216         } while (exception.retry);
1217         return err;
1218 }
1219
1220 struct nfs4_closedata {
1221         struct path path;
1222         struct inode *inode;
1223         struct nfs4_state *state;
1224         struct nfs_closeargs arg;
1225         struct nfs_closeres res;
1226         struct nfs_fattr fattr;
1227         unsigned long timestamp;
1228 };
1229
1230 static void nfs4_free_closedata(void *data)
1231 {
1232         struct nfs4_closedata *calldata = data;
1233         struct nfs4_state_owner *sp = calldata->state->owner;
1234
1235         nfs4_put_open_state(calldata->state);
1236         nfs_free_seqid(calldata->arg.seqid);
1237         nfs4_put_state_owner(sp);
1238         path_put(&calldata->path);
1239         kfree(calldata);
1240 }
1241
1242 static void nfs4_close_done(struct rpc_task *task, void *data)
1243 {
1244         struct nfs4_closedata *calldata = data;
1245         struct nfs4_state *state = calldata->state;
1246         struct nfs_server *server = NFS_SERVER(calldata->inode);
1247
1248         if (RPC_ASSASSINATED(task))
1249                 return;
1250         /* hmm. we are done with the inode, and in the process of freeing
1251          * the state_owner. we keep this around to process errors
1252          */
1253         switch (task->tk_status) {
1254                 case 0:
1255                         nfs_set_open_stateid(state, &calldata->res.stateid, 0);
1256                         renew_lease(server, calldata->timestamp);
1257                         break;
1258                 case -NFS4ERR_STALE_STATEID:
1259                 case -NFS4ERR_EXPIRED:
1260                         break;
1261                 default:
1262                         if (nfs4_async_handle_error(task, server) == -EAGAIN) {
1263                                 rpc_restart_call(task);
1264                                 return;
1265                         }
1266         }
1267         nfs_refresh_inode(calldata->inode, calldata->res.fattr);
1268 }
1269
1270 static void nfs4_close_prepare(struct rpc_task *task, void *data)
1271 {
1272         struct nfs4_closedata *calldata = data;
1273         struct nfs4_state *state = calldata->state;
1274         int clear_rd, clear_wr, clear_rdwr;
1275
1276         if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
1277                 return;
1278
1279         clear_rd = clear_wr = clear_rdwr = 0;
1280         spin_lock(&state->owner->so_lock);
1281         /* Calculate the change in open mode */
1282         if (state->n_rdwr == 0) {
1283                 if (state->n_rdonly == 0) {
1284                         clear_rd |= test_and_clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1285                         clear_rdwr |= test_and_clear_bit(NFS_O_RDWR_STATE, &state->flags);
1286                 }
1287                 if (state->n_wronly == 0) {
1288                         clear_wr |= test_and_clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1289                         clear_rdwr |= test_and_clear_bit(NFS_O_RDWR_STATE, &state->flags);
1290                 }
1291         }
1292         spin_unlock(&state->owner->so_lock);
1293         if (!clear_rd && !clear_wr && !clear_rdwr) {
1294                 /* Note: exit _without_ calling nfs4_close_done */
1295                 task->tk_action = NULL;
1296                 return;
1297         }
1298         nfs_fattr_init(calldata->res.fattr);
1299         if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) {
1300                 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE];
1301                 calldata->arg.open_flags = FMODE_READ;
1302         } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) {
1303                 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE];
1304                 calldata->arg.open_flags = FMODE_WRITE;
1305         }
1306         calldata->timestamp = jiffies;
1307         rpc_call_start(task);
1308 }
1309
1310 static const struct rpc_call_ops nfs4_close_ops = {
1311         .rpc_call_prepare = nfs4_close_prepare,
1312         .rpc_call_done = nfs4_close_done,
1313         .rpc_release = nfs4_free_closedata,
1314 };
1315
1316 /*
1317  * It is possible for data to be read/written from a mem-mapped file
1318  * after the sys_close call (which hits the vfs layer as a flush).
1319  * This means that we can't safely call nfsv4 close on a file until
1320  * the inode is cleared. This in turn means that we are not good
1321  * NFSv4 citizens - we do not indicate to the server to update the file's
1322  * share state even when we are done with one of the three share
1323  * stateid's in the inode.
1324  *
1325  * NOTE: Caller must be holding the sp->so_owner semaphore!
1326  */
1327 int nfs4_do_close(struct path *path, struct nfs4_state *state, int wait)
1328 {
1329         struct nfs_server *server = NFS_SERVER(state->inode);
1330         struct nfs4_closedata *calldata;
1331         struct nfs4_state_owner *sp = state->owner;
1332         struct rpc_task *task;
1333         struct rpc_message msg = {
1334                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE],
1335                 .rpc_cred = state->owner->so_cred,
1336         };
1337         struct rpc_task_setup task_setup_data = {
1338                 .rpc_client = server->client,
1339                 .rpc_message = &msg,
1340                 .callback_ops = &nfs4_close_ops,
1341                 .workqueue = nfsiod_workqueue,
1342                 .flags = RPC_TASK_ASYNC,
1343         };
1344         int status = -ENOMEM;
1345
1346         calldata = kmalloc(sizeof(*calldata), GFP_KERNEL);
1347         if (calldata == NULL)
1348                 goto out;
1349         calldata->inode = state->inode;
1350         calldata->state = state;
1351         calldata->arg.fh = NFS_FH(state->inode);
1352         calldata->arg.stateid = &state->open_stateid;
1353         /* Serialization for the sequence id */
1354         calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid);
1355         if (calldata->arg.seqid == NULL)
1356                 goto out_free_calldata;
1357         calldata->arg.bitmask = server->attr_bitmask;
1358         calldata->res.fattr = &calldata->fattr;
1359         calldata->res.seqid = calldata->arg.seqid;
1360         calldata->res.server = server;
1361         calldata->path.mnt = mntget(path->mnt);
1362         calldata->path.dentry = dget(path->dentry);
1363
1364         msg.rpc_argp = &calldata->arg,
1365         msg.rpc_resp = &calldata->res,
1366         task_setup_data.callback_data = calldata;
1367         task = rpc_run_task(&task_setup_data);
1368         if (IS_ERR(task))
1369                 return PTR_ERR(task);
1370         status = 0;
1371         if (wait)
1372                 status = rpc_wait_for_completion_task(task);
1373         rpc_put_task(task);
1374         return status;
1375 out_free_calldata:
1376         kfree(calldata);
1377 out:
1378         nfs4_put_open_state(state);
1379         nfs4_put_state_owner(sp);
1380         return status;
1381 }
1382
1383 static int nfs4_intent_set_file(struct nameidata *nd, struct path *path, struct nfs4_state *state)
1384 {
1385         struct file *filp;
1386         int ret;
1387
1388         /* If the open_intent is for execute, we have an extra check to make */
1389         if (nd->intent.open.flags & FMODE_EXEC) {
1390                 ret = nfs_may_open(state->inode,
1391                                 state->owner->so_cred,
1392                                 nd->intent.open.flags);
1393                 if (ret < 0)
1394                         goto out_close;
1395         }
1396         filp = lookup_instantiate_filp(nd, path->dentry, NULL);
1397         if (!IS_ERR(filp)) {
1398                 struct nfs_open_context *ctx;
1399                 ctx = nfs_file_open_context(filp);
1400                 ctx->state = state;
1401                 return 0;
1402         }
1403         ret = PTR_ERR(filp);
1404 out_close:
1405         nfs4_close_sync(path, state, nd->intent.open.flags);
1406         return ret;
1407 }
1408
1409 struct dentry *
1410 nfs4_atomic_open(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
1411 {
1412         struct path path = {
1413                 .mnt = nd->path.mnt,
1414                 .dentry = dentry,
1415         };
1416         struct dentry *parent;
1417         struct iattr attr;
1418         struct rpc_cred *cred;
1419         struct nfs4_state *state;
1420         struct dentry *res;
1421
1422         if (nd->flags & LOOKUP_CREATE) {
1423                 attr.ia_mode = nd->intent.open.create_mode;
1424                 attr.ia_valid = ATTR_MODE;
1425                 if (!IS_POSIXACL(dir))
1426                         attr.ia_mode &= ~current->fs->umask;
1427         } else {
1428                 attr.ia_valid = 0;
1429                 BUG_ON(nd->intent.open.flags & O_CREAT);
1430         }
1431
1432         cred = rpc_lookup_cred();
1433         if (IS_ERR(cred))
1434                 return (struct dentry *)cred;
1435         parent = dentry->d_parent;
1436         /* Protect against concurrent sillydeletes */
1437         nfs_block_sillyrename(parent);
1438         state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred);
1439         put_rpccred(cred);
1440         if (IS_ERR(state)) {
1441                 if (PTR_ERR(state) == -ENOENT) {
1442                         d_add(dentry, NULL);
1443                         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1444                 }
1445                 nfs_unblock_sillyrename(parent);
1446                 return (struct dentry *)state;
1447         }
1448         res = d_add_unique(dentry, igrab(state->inode));
1449         if (res != NULL)
1450                 path.dentry = res;
1451         nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir));
1452         nfs_unblock_sillyrename(parent);
1453         nfs4_intent_set_file(nd, &path, state);
1454         return res;
1455 }
1456
1457 int
1458 nfs4_open_revalidate(struct inode *dir, struct dentry *dentry, int openflags, struct nameidata *nd)
1459 {
1460         struct path path = {
1461                 .mnt = nd->path.mnt,
1462                 .dentry = dentry,
1463         };
1464         struct rpc_cred *cred;
1465         struct nfs4_state *state;
1466
1467         cred = rpc_lookup_cred();
1468         if (IS_ERR(cred))
1469                 return PTR_ERR(cred);
1470         state = nfs4_do_open(dir, &path, openflags, NULL, cred);
1471         put_rpccred(cred);
1472         if (IS_ERR(state)) {
1473                 switch (PTR_ERR(state)) {
1474                         case -EPERM:
1475                         case -EACCES:
1476                         case -EDQUOT:
1477                         case -ENOSPC:
1478                         case -EROFS:
1479                                 lookup_instantiate_filp(nd, (struct dentry *)state, NULL);
1480                                 return 1;
1481                         default:
1482                                 goto out_drop;
1483                 }
1484         }
1485         if (state->inode == dentry->d_inode) {
1486                 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1487                 nfs4_intent_set_file(nd, &path, state);
1488                 return 1;
1489         }
1490         nfs4_close_sync(&path, state, openflags);
1491 out_drop:
1492         d_drop(dentry);
1493         return 0;
1494 }
1495
1496
1497 static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
1498 {
1499         struct nfs4_server_caps_res res = {};
1500         struct rpc_message msg = {
1501                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS],
1502                 .rpc_argp = fhandle,
1503                 .rpc_resp = &res,
1504         };
1505         int status;
1506
1507         status = rpc_call_sync(server->client, &msg, 0);
1508         if (status == 0) {
1509                 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask));
1510                 if (res.attr_bitmask[0] & FATTR4_WORD0_ACL)
1511                         server->caps |= NFS_CAP_ACLS;
1512                 if (res.has_links != 0)
1513                         server->caps |= NFS_CAP_HARDLINKS;
1514                 if (res.has_symlinks != 0)
1515                         server->caps |= NFS_CAP_SYMLINKS;
1516                 server->acl_bitmask = res.acl_bitmask;
1517         }
1518         return status;
1519 }
1520
1521 int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
1522 {
1523         struct nfs4_exception exception = { };
1524         int err;
1525         do {
1526                 err = nfs4_handle_exception(server,
1527                                 _nfs4_server_capabilities(server, fhandle),
1528                                 &exception);
1529         } while (exception.retry);
1530         return err;
1531 }
1532
1533 static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
1534                 struct nfs_fsinfo *info)
1535 {
1536         struct nfs4_lookup_root_arg args = {
1537                 .bitmask = nfs4_fattr_bitmap,
1538         };
1539         struct nfs4_lookup_res res = {
1540                 .server = server,
1541                 .fattr = info->fattr,
1542                 .fh = fhandle,
1543         };
1544         struct rpc_message msg = {
1545                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP_ROOT],
1546                 .rpc_argp = &args,
1547                 .rpc_resp = &res,
1548         };
1549         nfs_fattr_init(info->fattr);
1550         return rpc_call_sync(server->client, &msg, 0);
1551 }
1552
1553 static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
1554                 struct nfs_fsinfo *info)
1555 {
1556         struct nfs4_exception exception = { };
1557         int err;
1558         do {
1559                 err = nfs4_handle_exception(server,
1560                                 _nfs4_lookup_root(server, fhandle, info),
1561                                 &exception);
1562         } while (exception.retry);
1563         return err;
1564 }
1565
1566 /*
1567  * get the file handle for the "/" directory on the server
1568  */
1569 static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
1570                               struct nfs_fsinfo *info)
1571 {
1572         int status;
1573
1574         status = nfs4_lookup_root(server, fhandle, info);
1575         if (status == 0)
1576                 status = nfs4_server_capabilities(server, fhandle);
1577         if (status == 0)
1578                 status = nfs4_do_fsinfo(server, fhandle, info);
1579         return nfs4_map_errors(status);
1580 }
1581
1582 /*
1583  * Get locations and (maybe) other attributes of a referral.
1584  * Note that we'll actually follow the referral later when
1585  * we detect fsid mismatch in inode revalidation
1586  */
1587 static int nfs4_get_referral(struct inode *dir, const struct qstr *name, struct nfs_fattr *fattr, struct nfs_fh *fhandle)
1588 {
1589         int status = -ENOMEM;
1590         struct page *page = NULL;
1591         struct nfs4_fs_locations *locations = NULL;
1592
1593         page = alloc_page(GFP_KERNEL);
1594         if (page == NULL)
1595                 goto out;
1596         locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
1597         if (locations == NULL)
1598                 goto out;
1599
1600         status = nfs4_proc_fs_locations(dir, name, locations, page);
1601         if (status != 0)
1602                 goto out;
1603         /* Make sure server returned a different fsid for the referral */
1604         if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) {
1605                 dprintk("%s: server did not return a different fsid for a referral at %s\n", __func__, name->name);
1606                 status = -EIO;
1607                 goto out;
1608         }
1609
1610         memcpy(fattr, &locations->fattr, sizeof(struct nfs_fattr));
1611         fattr->valid |= NFS_ATTR_FATTR_V4_REFERRAL;
1612         if (!fattr->mode)
1613                 fattr->mode = S_IFDIR;
1614         memset(fhandle, 0, sizeof(struct nfs_fh));
1615 out:
1616         if (page)
1617                 __free_page(page);
1618         if (locations)
1619                 kfree(locations);
1620         return status;
1621 }
1622
1623 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
1624 {
1625         struct nfs4_getattr_arg args = {
1626                 .fh = fhandle,
1627                 .bitmask = server->attr_bitmask,
1628         };
1629         struct nfs4_getattr_res res = {
1630                 .fattr = fattr,
1631                 .server = server,
1632         };
1633         struct rpc_message msg = {
1634                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
1635                 .rpc_argp = &args,
1636                 .rpc_resp = &res,
1637         };
1638
1639         nfs_fattr_init(fattr);
1640         return rpc_call_sync(server->client, &msg, 0);
1641 }
1642
1643 static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
1644 {
1645         struct nfs4_exception exception = { };
1646         int err;
1647         do {
1648                 err = nfs4_handle_exception(server,
1649                                 _nfs4_proc_getattr(server, fhandle, fattr),
1650                                 &exception);
1651         } while (exception.retry);
1652         return err;
1653 }
1654
1655 /*
1656  * The file is not closed if it is opened due to the a request to change
1657  * the size of the file. The open call will not be needed once the
1658  * VFS layer lookup-intents are implemented.
1659  *
1660  * Close is called when the inode is destroyed.
1661  * If we haven't opened the file for O_WRONLY, we
1662  * need to in the size_change case to obtain a stateid.
1663  *
1664  * Got race?
1665  * Because OPEN is always done by name in nfsv4, it is
1666  * possible that we opened a different file by the same
1667  * name.  We can recognize this race condition, but we
1668  * can't do anything about it besides returning an error.
1669  *
1670  * This will be fixed with VFS changes (lookup-intent).
1671  */
1672 static int
1673 nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
1674                   struct iattr *sattr)
1675 {
1676         struct inode *inode = dentry->d_inode;
1677         struct rpc_cred *cred = NULL;
1678         struct nfs4_state *state = NULL;
1679         int status;
1680
1681         nfs_fattr_init(fattr);
1682
1683         /* Search for an existing open(O_WRITE) file */
1684         if (sattr->ia_valid & ATTR_FILE) {
1685                 struct nfs_open_context *ctx;
1686
1687                 ctx = nfs_file_open_context(sattr->ia_file);
1688                 if (ctx) {
1689                         cred = ctx->cred;
1690                         state = ctx->state;
1691                 }
1692         }
1693
1694         status = nfs4_do_setattr(inode, cred, fattr, sattr, state);
1695         if (status == 0)
1696                 nfs_setattr_update_inode(inode, sattr);
1697         return status;
1698 }
1699
1700 static int _nfs4_proc_lookupfh(struct nfs_server *server, const struct nfs_fh *dirfh,
1701                 const struct qstr *name, struct nfs_fh *fhandle,
1702                 struct nfs_fattr *fattr)
1703 {
1704         int                    status;
1705         struct nfs4_lookup_arg args = {
1706                 .bitmask = server->attr_bitmask,
1707                 .dir_fh = dirfh,
1708                 .name = name,
1709         };
1710         struct nfs4_lookup_res res = {
1711                 .server = server,
1712                 .fattr = fattr,
1713                 .fh = fhandle,
1714         };
1715         struct rpc_message msg = {
1716                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP],
1717                 .rpc_argp = &args,
1718                 .rpc_resp = &res,
1719         };
1720
1721         nfs_fattr_init(fattr);
1722
1723         dprintk("NFS call  lookupfh %s\n", name->name);
1724         status = rpc_call_sync(server->client, &msg, 0);
1725         dprintk("NFS reply lookupfh: %d\n", status);
1726         return status;
1727 }
1728
1729 static int nfs4_proc_lookupfh(struct nfs_server *server, struct nfs_fh *dirfh,
1730                               struct qstr *name, struct nfs_fh *fhandle,
1731                               struct nfs_fattr *fattr)
1732 {
1733         struct nfs4_exception exception = { };
1734         int err;
1735         do {
1736                 err = _nfs4_proc_lookupfh(server, dirfh, name, fhandle, fattr);
1737                 /* FIXME: !!!! */
1738                 if (err == -NFS4ERR_MOVED) {
1739                         err = -EREMOTE;
1740                         break;
1741                 }
1742                 err = nfs4_handle_exception(server, err, &exception);
1743         } while (exception.retry);
1744         return err;
1745 }
1746
1747 static int _nfs4_proc_lookup(struct inode *dir, const struct qstr *name,
1748                 struct nfs_fh *fhandle, struct nfs_fattr *fattr)
1749 {
1750         int status;
1751
1752         dprintk("NFS call  lookup %s\n", name->name);
1753         status = _nfs4_proc_lookupfh(NFS_SERVER(dir), NFS_FH(dir), name, fhandle, fattr);
1754         if (status == -NFS4ERR_MOVED)
1755                 status = nfs4_get_referral(dir, name, fattr, fhandle);
1756         dprintk("NFS reply lookup: %d\n", status);
1757         return status;
1758 }
1759
1760 static int nfs4_proc_lookup(struct inode *dir, struct qstr *name, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
1761 {
1762         struct nfs4_exception exception = { };
1763         int err;
1764         do {
1765                 err = nfs4_handle_exception(NFS_SERVER(dir),
1766                                 _nfs4_proc_lookup(dir, name, fhandle, fattr),
1767                                 &exception);
1768         } while (exception.retry);
1769         return err;
1770 }
1771
1772 static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
1773 {
1774         struct nfs_server *server = NFS_SERVER(inode);
1775         struct nfs_fattr fattr;
1776         struct nfs4_accessargs args = {
1777                 .fh = NFS_FH(inode),
1778                 .bitmask = server->attr_bitmask,
1779         };
1780         struct nfs4_accessres res = {
1781                 .server = server,
1782                 .fattr = &fattr,
1783         };
1784         struct rpc_message msg = {
1785                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS],
1786                 .rpc_argp = &args,
1787                 .rpc_resp = &res,
1788                 .rpc_cred = entry->cred,
1789         };
1790         int mode = entry->mask;
1791         int status;
1792
1793         /*
1794          * Determine which access bits we want to ask for...
1795          */
1796         if (mode & MAY_READ)
1797                 args.access |= NFS4_ACCESS_READ;
1798         if (S_ISDIR(inode->i_mode)) {
1799                 if (mode & MAY_WRITE)
1800                         args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE;
1801                 if (mode & MAY_EXEC)
1802                         args.access |= NFS4_ACCESS_LOOKUP;
1803         } else {
1804                 if (mode & MAY_WRITE)
1805                         args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND;
1806                 if (mode & MAY_EXEC)
1807                         args.access |= NFS4_ACCESS_EXECUTE;
1808         }
1809         nfs_fattr_init(&fattr);
1810         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
1811         if (!status) {
1812                 entry->mask = 0;
1813                 if (res.access & NFS4_ACCESS_READ)
1814                         entry->mask |= MAY_READ;
1815                 if (res.access & (NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE))
1816                         entry->mask |= MAY_WRITE;
1817                 if (res.access & (NFS4_ACCESS_LOOKUP|NFS4_ACCESS_EXECUTE))
1818                         entry->mask |= MAY_EXEC;
1819                 nfs_refresh_inode(inode, &fattr);
1820         }
1821         return status;
1822 }
1823
1824 static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
1825 {
1826         struct nfs4_exception exception = { };
1827         int err;
1828         do {
1829                 err = nfs4_handle_exception(NFS_SERVER(inode),
1830                                 _nfs4_proc_access(inode, entry),
1831                                 &exception);
1832         } while (exception.retry);
1833         return err;
1834 }
1835
1836 /*
1837  * TODO: For the time being, we don't try to get any attributes
1838  * along with any of the zero-copy operations READ, READDIR,
1839  * READLINK, WRITE.
1840  *
1841  * In the case of the first three, we want to put the GETATTR
1842  * after the read-type operation -- this is because it is hard
1843  * to predict the length of a GETATTR response in v4, and thus
1844  * align the READ data correctly.  This means that the GETATTR
1845  * may end up partially falling into the page cache, and we should
1846  * shift it into the 'tail' of the xdr_buf before processing.
1847  * To do this efficiently, we need to know the total length
1848  * of data received, which doesn't seem to be available outside
1849  * of the RPC layer.
1850  *
1851  * In the case of WRITE, we also want to put the GETATTR after
1852  * the operation -- in this case because we want to make sure
1853  * we get the post-operation mtime and size.  This means that
1854  * we can't use xdr_encode_pages() as written: we need a variant
1855  * of it which would leave room in the 'tail' iovec.
1856  *
1857  * Both of these changes to the XDR layer would in fact be quite
1858  * minor, but I decided to leave them for a subsequent patch.
1859  */
1860 static int _nfs4_proc_readlink(struct inode *inode, struct page *page,
1861                 unsigned int pgbase, unsigned int pglen)
1862 {
1863         struct nfs4_readlink args = {
1864                 .fh       = NFS_FH(inode),
1865                 .pgbase   = pgbase,
1866                 .pglen    = pglen,
1867                 .pages    = &page,
1868         };
1869         struct rpc_message msg = {
1870                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK],
1871                 .rpc_argp = &args,
1872                 .rpc_resp = NULL,
1873         };
1874
1875         return rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
1876 }
1877
1878 static int nfs4_proc_readlink(struct inode *inode, struct page *page,
1879                 unsigned int pgbase, unsigned int pglen)
1880 {
1881         struct nfs4_exception exception = { };
1882         int err;
1883         do {
1884                 err = nfs4_handle_exception(NFS_SERVER(inode),
1885                                 _nfs4_proc_readlink(inode, page, pgbase, pglen),
1886                                 &exception);
1887         } while (exception.retry);
1888         return err;
1889 }
1890
1891 /*
1892  * Got race?
1893  * We will need to arrange for the VFS layer to provide an atomic open.
1894  * Until then, this create/open method is prone to inefficiency and race
1895  * conditions due to the lookup, create, and open VFS calls from sys_open()
1896  * placed on the wire.
1897  *
1898  * Given the above sorry state of affairs, I'm simply sending an OPEN.
1899  * The file will be opened again in the subsequent VFS open call
1900  * (nfs4_proc_file_open).
1901  *
1902  * The open for read will just hang around to be used by any process that
1903  * opens the file O_RDONLY. This will all be resolved with the VFS changes.
1904  */
1905
1906 static int
1907 nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
1908                  int flags, struct nameidata *nd)
1909 {
1910         struct path path = {
1911                 .mnt = nd->path.mnt,
1912                 .dentry = dentry,
1913         };
1914         struct nfs4_state *state;
1915         struct rpc_cred *cred;
1916         int status = 0;
1917
1918         cred = rpc_lookup_cred();
1919         if (IS_ERR(cred)) {
1920                 status = PTR_ERR(cred);
1921                 goto out;
1922         }
1923         state = nfs4_do_open(dir, &path, flags, sattr, cred);
1924         d_drop(dentry);
1925         if (IS_ERR(state)) {
1926                 status = PTR_ERR(state);
1927                 goto out_putcred;
1928         }
1929         d_add(dentry, igrab(state->inode));
1930         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1931         if (flags & O_EXCL) {
1932                 struct nfs_fattr fattr;
1933                 status = nfs4_do_setattr(state->inode, cred, &fattr, sattr, state);
1934                 if (status == 0)
1935                         nfs_setattr_update_inode(state->inode, sattr);
1936                 nfs_post_op_update_inode(state->inode, &fattr);
1937         }
1938         if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0)
1939                 status = nfs4_intent_set_file(nd, &path, state);
1940         else
1941                 nfs4_close_sync(&path, state, flags);
1942 out_putcred:
1943         put_rpccred(cred);
1944 out:
1945         return status;
1946 }
1947
1948 static int _nfs4_proc_remove(struct inode *dir, struct qstr *name)
1949 {
1950         struct nfs_server *server = NFS_SERVER(dir);
1951         struct nfs_removeargs args = {
1952                 .fh = NFS_FH(dir),
1953                 .name.len = name->len,
1954                 .name.name = name->name,
1955                 .bitmask = server->attr_bitmask,
1956         };
1957         struct nfs_removeres res = {
1958                 .server = server,
1959         };
1960         struct rpc_message msg = {
1961                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE],
1962                 .rpc_argp = &args,
1963                 .rpc_resp = &res,
1964         };
1965         int                     status;
1966
1967         nfs_fattr_init(&res.dir_attr);
1968         status = rpc_call_sync(server->client, &msg, 0);
1969         if (status == 0) {
1970                 update_changeattr(dir, &res.cinfo);
1971                 nfs_post_op_update_inode(dir, &res.dir_attr);
1972         }
1973         return status;
1974 }
1975
1976 static int nfs4_proc_remove(struct inode *dir, struct qstr *name)
1977 {
1978         struct nfs4_exception exception = { };
1979         int err;
1980         do {
1981                 err = nfs4_handle_exception(NFS_SERVER(dir),
1982                                 _nfs4_proc_remove(dir, name),
1983                                 &exception);
1984         } while (exception.retry);
1985         return err;
1986 }
1987
1988 static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
1989 {
1990         struct nfs_server *server = NFS_SERVER(dir);
1991         struct nfs_removeargs *args = msg->rpc_argp;
1992         struct nfs_removeres *res = msg->rpc_resp;
1993
1994         args->bitmask = server->attr_bitmask;
1995         res->server = server;
1996         msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE];
1997 }
1998
1999 static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir)
2000 {
2001         struct nfs_removeres *res = task->tk_msg.rpc_resp;
2002
2003         if (nfs4_async_handle_error(task, res->server) == -EAGAIN)
2004                 return 0;
2005         update_changeattr(dir, &res->cinfo);
2006         nfs_post_op_update_inode(dir, &res->dir_attr);
2007         return 1;
2008 }
2009
2010 static int _nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
2011                 struct inode *new_dir, struct qstr *new_name)
2012 {
2013         struct nfs_server *server = NFS_SERVER(old_dir);
2014         struct nfs4_rename_arg arg = {
2015                 .old_dir = NFS_FH(old_dir),
2016                 .new_dir = NFS_FH(new_dir),
2017                 .old_name = old_name,
2018                 .new_name = new_name,
2019                 .bitmask = server->attr_bitmask,
2020         };
2021         struct nfs_fattr old_fattr, new_fattr;
2022         struct nfs4_rename_res res = {
2023                 .server = server,
2024                 .old_fattr = &old_fattr,
2025                 .new_fattr = &new_fattr,
2026         };
2027         struct rpc_message msg = {
2028                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME],
2029                 .rpc_argp = &arg,
2030                 .rpc_resp = &res,
2031         };
2032         int                     status;
2033
2034         nfs_fattr_init(res.old_fattr);
2035         nfs_fattr_init(res.new_fattr);
2036         status = rpc_call_sync(server->client, &msg, 0);
2037
2038         if (!status) {
2039                 update_changeattr(old_dir, &res.old_cinfo);
2040                 nfs_post_op_update_inode(old_dir, res.old_fattr);
2041                 update_changeattr(new_dir, &res.new_cinfo);
2042                 nfs_post_op_update_inode(new_dir, res.new_fattr);
2043         }
2044         return status;
2045 }
2046
2047 static int nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
2048                 struct inode *new_dir, struct qstr *new_name)
2049 {
2050         struct nfs4_exception exception = { };
2051         int err;
2052         do {
2053                 err = nfs4_handle_exception(NFS_SERVER(old_dir),
2054                                 _nfs4_proc_rename(old_dir, old_name,
2055                                         new_dir, new_name),
2056                                 &exception);
2057         } while (exception.retry);
2058         return err;
2059 }
2060
2061 static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
2062 {
2063         struct nfs_server *server = NFS_SERVER(inode);
2064         struct nfs4_link_arg arg = {
2065                 .fh     = NFS_FH(inode),
2066                 .dir_fh = NFS_FH(dir),
2067                 .name   = name,
2068                 .bitmask = server->attr_bitmask,
2069         };
2070         struct nfs_fattr fattr, dir_attr;
2071         struct nfs4_link_res res = {
2072                 .server = server,
2073                 .fattr = &fattr,
2074                 .dir_attr = &dir_attr,
2075         };
2076         struct rpc_message msg = {
2077                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK],
2078                 .rpc_argp = &arg,
2079                 .rpc_resp = &res,
2080         };
2081         int                     status;
2082
2083         nfs_fattr_init(res.fattr);
2084         nfs_fattr_init(res.dir_attr);
2085         status = rpc_call_sync(server->client, &msg, 0);
2086         if (!status) {
2087                 update_changeattr(dir, &res.cinfo);
2088                 nfs_post_op_update_inode(dir, res.dir_attr);
2089                 nfs_post_op_update_inode(inode, res.fattr);
2090         }
2091
2092         return status;
2093 }
2094
2095 static int nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
2096 {
2097         struct nfs4_exception exception = { };
2098         int err;
2099         do {
2100                 err = nfs4_handle_exception(NFS_SERVER(inode),
2101                                 _nfs4_proc_link(inode, dir, name),
2102                                 &exception);
2103         } while (exception.retry);
2104         return err;
2105 }
2106
2107 struct nfs4_createdata {
2108         struct rpc_message msg;
2109         struct nfs4_create_arg arg;
2110         struct nfs4_create_res res;
2111         struct nfs_fh fh;
2112         struct nfs_fattr fattr;
2113         struct nfs_fattr dir_fattr;
2114 };
2115
2116 static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,
2117                 struct qstr *name, struct iattr *sattr, u32 ftype)
2118 {
2119         struct nfs4_createdata *data;
2120
2121         data = kzalloc(sizeof(*data), GFP_KERNEL);
2122         if (data != NULL) {
2123                 struct nfs_server *server = NFS_SERVER(dir);
2124
2125                 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE];
2126                 data->msg.rpc_argp = &data->arg;
2127                 data->msg.rpc_resp = &data->res;
2128                 data->arg.dir_fh = NFS_FH(dir);
2129                 data->arg.server = server;
2130                 data->arg.name = name;
2131                 data->arg.attrs = sattr;
2132                 data->arg.ftype = ftype;
2133                 data->arg.bitmask = server->attr_bitmask;
2134                 data->res.server = server;
2135                 data->res.fh = &data->fh;
2136                 data->res.fattr = &data->fattr;
2137                 data->res.dir_fattr = &data->dir_fattr;
2138                 nfs_fattr_init(data->res.fattr);
2139                 nfs_fattr_init(data->res.dir_fattr);
2140         }
2141         return data;
2142 }
2143
2144 static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data)
2145 {
2146         int status = rpc_call_sync(NFS_CLIENT(dir), &data->msg, 0);
2147         if (status == 0) {
2148                 update_changeattr(dir, &data->res.dir_cinfo);
2149                 nfs_post_op_update_inode(dir, data->res.dir_fattr);
2150                 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
2151         }
2152         return status;
2153 }
2154
2155 static void nfs4_free_createdata(struct nfs4_createdata *data)
2156 {
2157         kfree(data);
2158 }
2159
2160 static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
2161                 struct page *page, unsigned int len, struct iattr *sattr)
2162 {
2163         struct nfs4_createdata *data;
2164         int status = -ENAMETOOLONG;
2165
2166         if (len > NFS4_MAXPATHLEN)
2167                 goto out;
2168
2169         status = -ENOMEM;
2170         data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK);
2171         if (data == NULL)
2172                 goto out;
2173
2174         data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK];
2175         data->arg.u.symlink.pages = &page;
2176         data->arg.u.symlink.len = len;
2177
2178         status = nfs4_do_create(dir, dentry, data);
2179
2180         nfs4_free_createdata(data);
2181 out:
2182         return status;
2183 }
2184
2185 static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
2186                 struct page *page, unsigned int len, struct iattr *sattr)
2187 {
2188         struct nfs4_exception exception = { };
2189         int err;
2190         do {
2191                 err = nfs4_handle_exception(NFS_SERVER(dir),
2192                                 _nfs4_proc_symlink(dir, dentry, page,
2193                                                         len, sattr),
2194                                 &exception);
2195         } while (exception.retry);
2196         return err;
2197 }
2198
2199 static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
2200                 struct iattr *sattr)
2201 {
2202         struct nfs4_createdata *data;
2203         int status = -ENOMEM;
2204
2205         data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR);
2206         if (data == NULL)
2207                 goto out;
2208
2209         status = nfs4_do_create(dir, dentry, data);
2210
2211         nfs4_free_createdata(data);
2212 out:
2213         return status;
2214 }
2215
2216 static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
2217                 struct iattr *sattr)
2218 {
2219         struct nfs4_exception exception = { };
2220         int err;
2221         do {
2222                 err = nfs4_handle_exception(NFS_SERVER(dir),
2223                                 _nfs4_proc_mkdir(dir, dentry, sattr),
2224                                 &exception);
2225         } while (exception.retry);
2226         return err;
2227 }
2228
2229 static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
2230                   u64 cookie, struct page *page, unsigned int count, int plus)
2231 {
2232         struct inode            *dir = dentry->d_inode;
2233         struct nfs4_readdir_arg args = {
2234                 .fh = NFS_FH(dir),
2235                 .pages = &page,
2236                 .pgbase = 0,
2237                 .count = count,
2238                 .bitmask = NFS_SERVER(dentry->d_inode)->attr_bitmask,
2239         };
2240         struct nfs4_readdir_res res;
2241         struct rpc_message msg = {
2242                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR],
2243                 .rpc_argp = &args,
2244                 .rpc_resp = &res,
2245                 .rpc_cred = cred,
2246         };
2247         int                     status;
2248
2249         dprintk("%s: dentry = %s/%s, cookie = %Lu\n", __func__,
2250                         dentry->d_parent->d_name.name,
2251                         dentry->d_name.name,
2252                         (unsigned long long)cookie);
2253         nfs4_setup_readdir(cookie, NFS_COOKIEVERF(dir), dentry, &args);
2254         res.pgbase = args.pgbase;
2255         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
2256         if (status == 0)
2257                 memcpy(NFS_COOKIEVERF(dir), res.verifier.data, NFS4_VERIFIER_SIZE);
2258
2259         nfs_invalidate_atime(dir);
2260
2261         dprintk("%s: returns %d\n", __func__, status);
2262         return status;
2263 }
2264
2265 static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
2266                   u64 cookie, struct page *page, unsigned int count, int plus)
2267 {
2268         struct nfs4_exception exception = { };
2269         int err;
2270         do {
2271                 err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode),
2272                                 _nfs4_proc_readdir(dentry, cred, cookie,
2273                                         page, count, plus),
2274                                 &exception);
2275         } while (exception.retry);
2276         return err;
2277 }
2278
2279 static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
2280                 struct iattr *sattr, dev_t rdev)
2281 {
2282         struct nfs4_createdata *data;
2283         int mode = sattr->ia_mode;
2284         int status = -ENOMEM;
2285
2286         BUG_ON(!(sattr->ia_valid & ATTR_MODE));
2287         BUG_ON(!S_ISFIFO(mode) && !S_ISBLK(mode) && !S_ISCHR(mode) && !S_ISSOCK(mode));
2288
2289         data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK);
2290         if (data == NULL)
2291                 goto out;
2292
2293         if (S_ISFIFO(mode))
2294                 data->arg.ftype = NF4FIFO;
2295         else if (S_ISBLK(mode)) {
2296                 data->arg.ftype = NF4BLK;
2297                 data->arg.u.device.specdata1 = MAJOR(rdev);
2298                 data->arg.u.device.specdata2 = MINOR(rdev);
2299         }
2300         else if (S_ISCHR(mode)) {
2301                 data->arg.ftype = NF4CHR;
2302                 data->arg.u.device.specdata1 = MAJOR(rdev);
2303                 data->arg.u.device.specdata2 = MINOR(rdev);
2304         }
2305
2306         status = nfs4_do_create(dir, dentry, data);
2307
2308         nfs4_free_createdata(data);
2309 out:
2310         return status;
2311 }
2312
2313 static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
2314                 struct iattr *sattr, dev_t rdev)
2315 {
2316         struct nfs4_exception exception = { };
2317         int err;
2318         do {
2319                 err = nfs4_handle_exception(NFS_SERVER(dir),
2320                                 _nfs4_proc_mknod(dir, dentry, sattr, rdev),
2321                                 &exception);
2322         } while (exception.retry);
2323         return err;
2324 }
2325
2326 static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
2327                  struct nfs_fsstat *fsstat)
2328 {
2329         struct nfs4_statfs_arg args = {
2330                 .fh = fhandle,
2331                 .bitmask = server->attr_bitmask,
2332         };
2333         struct rpc_message msg = {
2334                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS],
2335                 .rpc_argp = &args,
2336                 .rpc_resp = fsstat,
2337         };
2338
2339         nfs_fattr_init(fsstat->fattr);
2340         return rpc_call_sync(server->client, &msg, 0);
2341 }
2342
2343 static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat)
2344 {
2345         struct nfs4_exception exception = { };
2346         int err;
2347         do {
2348                 err = nfs4_handle_exception(server,
2349                                 _nfs4_proc_statfs(server, fhandle, fsstat),
2350                                 &exception);
2351         } while (exception.retry);
2352         return err;
2353 }
2354
2355 static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
2356                 struct nfs_fsinfo *fsinfo)
2357 {
2358         struct nfs4_fsinfo_arg args = {
2359                 .fh = fhandle,
2360                 .bitmask = server->attr_bitmask,
2361         };
2362         struct rpc_message msg = {
2363                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO],
2364                 .rpc_argp = &args,
2365                 .rpc_resp = fsinfo,
2366         };
2367
2368         return rpc_call_sync(server->client, &msg, 0);
2369 }
2370
2371 static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
2372 {
2373         struct nfs4_exception exception = { };
2374         int err;
2375
2376         do {
2377                 err = nfs4_handle_exception(server,
2378                                 _nfs4_do_fsinfo(server, fhandle, fsinfo),
2379                                 &exception);
2380         } while (exception.retry);
2381         return err;
2382 }
2383
2384 static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
2385 {
2386         nfs_fattr_init(fsinfo->fattr);
2387         return nfs4_do_fsinfo(server, fhandle, fsinfo);
2388 }
2389
2390 static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
2391                 struct nfs_pathconf *pathconf)
2392 {
2393         struct nfs4_pathconf_arg args = {
2394                 .fh = fhandle,
2395                 .bitmask = server->attr_bitmask,
2396         };
2397         struct rpc_message msg = {
2398                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF],
2399                 .rpc_argp = &args,
2400                 .rpc_resp = pathconf,
2401         };
2402
2403         /* None of the pathconf attributes are mandatory to implement */
2404         if ((args.bitmask[0] & nfs4_pathconf_bitmap[0]) == 0) {
2405                 memset(pathconf, 0, sizeof(*pathconf));
2406                 return 0;
2407         }
2408
2409         nfs_fattr_init(pathconf->fattr);
2410         return rpc_call_sync(server->client, &msg, 0);
2411 }
2412
2413 static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
2414                 struct nfs_pathconf *pathconf)
2415 {
2416         struct nfs4_exception exception = { };
2417         int err;
2418
2419         do {
2420                 err = nfs4_handle_exception(server,
2421                                 _nfs4_proc_pathconf(server, fhandle, pathconf),
2422                                 &exception);
2423         } while (exception.retry);
2424         return err;
2425 }
2426
2427 static int nfs4_read_done(struct rpc_task *task, struct nfs_read_data *data)
2428 {
2429         struct nfs_server *server = NFS_SERVER(data->inode);
2430
2431         if (nfs4_async_handle_error(task, server) == -EAGAIN) {
2432                 rpc_restart_call(task);
2433                 return -EAGAIN;
2434         }
2435
2436         nfs_invalidate_atime(data->inode);
2437         if (task->tk_status > 0)
2438                 renew_lease(server, data->timestamp);
2439         return 0;
2440 }
2441
2442 static void nfs4_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)
2443 {
2444         data->timestamp   = jiffies;
2445         msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ];
2446 }
2447
2448 static int nfs4_write_done(struct rpc_task *task, struct nfs_write_data *data)
2449 {
2450         struct inode *inode = data->inode;
2451
2452         if (nfs4_async_handle_error(task, NFS_SERVER(inode)) == -EAGAIN) {
2453                 rpc_restart_call(task);
2454                 return -EAGAIN;
2455         }
2456         if (task->tk_status >= 0) {
2457                 renew_lease(NFS_SERVER(inode), data->timestamp);
2458                 nfs_post_op_update_inode_force_wcc(inode, data->res.fattr);
2459         }
2460         return 0;
2461 }
2462
2463 static void nfs4_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)
2464 {
2465         struct nfs_server *server = NFS_SERVER(data->inode);
2466
2467         data->args.bitmask = server->attr_bitmask;
2468         data->res.server = server;
2469         data->timestamp   = jiffies;
2470
2471         msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE];
2472 }
2473
2474 static int nfs4_commit_done(struct rpc_task *task, struct nfs_write_data *data)
2475 {
2476         struct inode *inode = data->inode;
2477
2478         if (nfs4_async_handle_error(task, NFS_SERVER(inode)) == -EAGAIN) {
2479                 rpc_restart_call(task);
2480                 return -EAGAIN;
2481         }
2482         nfs_refresh_inode(inode, data->res.fattr);
2483         return 0;
2484 }
2485
2486 static void nfs4_proc_commit_setup(struct nfs_write_data *data, struct rpc_message *msg)
2487 {
2488         struct nfs_server *server = NFS_SERVER(data->inode);
2489
2490         data->args.bitmask = server->attr_bitmask;
2491         data->res.server = server;
2492         msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT];
2493 }
2494
2495 /*
2496  * nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special
2497  * standalone procedure for queueing an asynchronous RENEW.
2498  */
2499 static void nfs4_renew_done(struct rpc_task *task, void *data)
2500 {
2501         struct nfs_client *clp = (struct nfs_client *)task->tk_msg.rpc_argp;
2502         unsigned long timestamp = (unsigned long)data;
2503
2504         if (task->tk_status < 0) {
2505                 switch (task->tk_status) {
2506                         case -NFS4ERR_STALE_CLIENTID:
2507                         case -NFS4ERR_EXPIRED:
2508                         case -NFS4ERR_CB_PATH_DOWN:
2509                                 nfs4_schedule_state_recovery(clp);
2510                 }
2511                 return;
2512         }
2513         spin_lock(&clp->cl_lock);
2514         if (time_before(clp->cl_last_renewal,timestamp))
2515                 clp->cl_last_renewal = timestamp;
2516         spin_unlock(&clp->cl_lock);
2517 }
2518
2519 static const struct rpc_call_ops nfs4_renew_ops = {
2520         .rpc_call_done = nfs4_renew_done,
2521 };
2522
2523 int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred)
2524 {
2525         struct rpc_message msg = {
2526                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
2527                 .rpc_argp       = clp,
2528                 .rpc_cred       = cred,
2529         };
2530
2531         return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_SOFT,
2532                         &nfs4_renew_ops, (void *)jiffies);
2533 }
2534
2535 int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred)
2536 {
2537         struct rpc_message msg = {
2538                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
2539                 .rpc_argp       = clp,
2540                 .rpc_cred       = cred,
2541         };
2542         unsigned long now = jiffies;
2543         int status;
2544
2545         status = rpc_call_sync(clp->cl_rpcclient, &msg, 0);
2546         if (status < 0)
2547                 return status;
2548         spin_lock(&clp->cl_lock);
2549         if (time_before(clp->cl_last_renewal,now))
2550                 clp->cl_last_renewal = now;
2551         spin_unlock(&clp->cl_lock);
2552         return 0;
2553 }
2554
2555 static inline int nfs4_server_supports_acls(struct nfs_server *server)
2556 {
2557         return (server->caps & NFS_CAP_ACLS)
2558                 && (server->acl_bitmask & ACL4_SUPPORT_ALLOW_ACL)
2559                 && (server->acl_bitmask & ACL4_SUPPORT_DENY_ACL);
2560 }
2561
2562 /* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_CACHE_SIZE, and that
2563  * it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_CACHE_SIZE) bytes on
2564  * the stack.
2565  */
2566 #define NFS4ACL_MAXPAGES (XATTR_SIZE_MAX >> PAGE_CACHE_SHIFT)
2567
2568 static void buf_to_pages(const void *buf, size_t buflen,
2569                 struct page **pages, unsigned int *pgbase)
2570 {
2571         const void *p = buf;
2572
2573         *pgbase = offset_in_page(buf);
2574         p -= *pgbase;
2575         while (p < buf + buflen) {
2576                 *(pages++) = virt_to_page(p);
2577                 p += PAGE_CACHE_SIZE;
2578         }
2579 }
2580
2581 struct nfs4_cached_acl {
2582         int cached;
2583         size_t len;
2584         char data[0];
2585 };
2586
2587 static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl)
2588 {
2589         struct nfs_inode *nfsi = NFS_I(inode);
2590
2591         spin_lock(&inode->i_lock);
2592         kfree(nfsi->nfs4_acl);
2593         nfsi->nfs4_acl = acl;
2594         spin_unlock(&inode->i_lock);
2595 }
2596
2597 static void nfs4_zap_acl_attr(struct inode *inode)
2598 {
2599         nfs4_set_cached_acl(inode, NULL);
2600 }
2601
2602 static inline ssize_t nfs4_read_cached_acl(struct inode *inode, char *buf, size_t buflen)
2603 {
2604         struct nfs_inode *nfsi = NFS_I(inode);
2605         struct nfs4_cached_acl *acl;
2606         int ret = -ENOENT;
2607
2608         spin_lock(&inode->i_lock);
2609         acl = nfsi->nfs4_acl;
2610         if (acl == NULL)
2611                 goto out;
2612         if (buf == NULL) /* user is just asking for length */
2613                 goto out_len;
2614         if (acl->cached == 0)
2615                 goto out;
2616         ret = -ERANGE; /* see getxattr(2) man page */
2617         if (acl->len > buflen)
2618                 goto out;
2619         memcpy(buf, acl->data, acl->len);
2620 out_len:
2621         ret = acl->len;
2622 out:
2623         spin_unlock(&inode->i_lock);
2624         return ret;
2625 }
2626
2627 static void nfs4_write_cached_acl(struct inode *inode, const char *buf, size_t acl_len)
2628 {
2629         struct nfs4_cached_acl *acl;
2630
2631         if (buf && acl_len <= PAGE_SIZE) {
2632                 acl = kmalloc(sizeof(*acl) + acl_len, GFP_KERNEL);
2633                 if (acl == NULL)
2634                         goto out;
2635                 acl->cached = 1;
2636                 memcpy(acl->data, buf, acl_len);
2637         } else {
2638                 acl = kmalloc(sizeof(*acl), GFP_KERNEL);
2639                 if (acl == NULL)
2640                         goto out;
2641                 acl->cached = 0;
2642         }
2643         acl->len = acl_len;
2644 out:
2645         nfs4_set_cached_acl(inode, acl);
2646 }
2647
2648 static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
2649 {
2650         struct page *pages[NFS4ACL_MAXPAGES];
2651         struct nfs_getaclargs args = {
2652                 .fh = NFS_FH(inode),
2653                 .acl_pages = pages,
2654                 .acl_len = buflen,
2655         };
2656         size_t resp_len = buflen;
2657         void *resp_buf;
2658         struct rpc_message msg = {
2659                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL],
2660                 .rpc_argp = &args,
2661                 .rpc_resp = &resp_len,
2662         };
2663         struct page *localpage = NULL;
2664         int ret;
2665
2666         if (buflen < PAGE_SIZE) {
2667                 /* As long as we're doing a round trip to the server anyway,
2668                  * let's be prepared for a page of acl data. */
2669                 localpage = alloc_page(GFP_KERNEL);
2670                 resp_buf = page_address(localpage);
2671                 if (localpage == NULL)
2672                         return -ENOMEM;
2673                 args.acl_pages[0] = localpage;
2674                 args.acl_pgbase = 0;
2675                 resp_len = args.acl_len = PAGE_SIZE;
2676         } else {
2677                 resp_buf = buf;
2678                 buf_to_pages(buf, buflen, args.acl_pages, &args.acl_pgbase);
2679         }
2680         ret = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
2681         if (ret)
2682                 goto out_free;
2683         if (resp_len > args.acl_len)
2684                 nfs4_write_cached_acl(inode, NULL, resp_len);
2685         else
2686                 nfs4_write_cached_acl(inode, resp_buf, resp_len);
2687         if (buf) {
2688                 ret = -ERANGE;
2689                 if (resp_len > buflen)
2690                         goto out_free;
2691                 if (localpage)
2692                         memcpy(buf, resp_buf, resp_len);
2693         }
2694         ret = resp_len;
2695 out_free:
2696         if (localpage)
2697                 __free_page(localpage);
2698         return ret;
2699 }
2700
2701 static ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
2702 {
2703         struct nfs4_exception exception = { };
2704         ssize_t ret;
2705         do {
2706                 ret = __nfs4_get_acl_uncached(inode, buf, buflen);
2707                 if (ret >= 0)
2708                         break;
2709                 ret = nfs4_handle_exception(NFS_SERVER(inode), ret, &exception);
2710         } while (exception.retry);
2711         return ret;
2712 }
2713
2714 static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen)
2715 {
2716         struct nfs_server *server = NFS_SERVER(inode);
2717         int ret;
2718
2719         if (!nfs4_server_supports_acls(server))
2720                 return -EOPNOTSUPP;
2721         ret = nfs_revalidate_inode(server, inode);
2722         if (ret < 0)
2723                 return ret;
2724         if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL)
2725                 nfs_zap_acl_cache(inode);
2726         ret = nfs4_read_cached_acl(inode, buf, buflen);
2727         if (ret != -ENOENT)
2728                 return ret;
2729         return nfs4_get_acl_uncached(inode, buf, buflen);
2730 }
2731
2732 static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
2733 {
2734         struct nfs_server *server = NFS_SERVER(inode);
2735         struct page *pages[NFS4ACL_MAXPAGES];
2736         struct nfs_setaclargs arg = {
2737                 .fh             = NFS_FH(inode),
2738                 .acl_pages      = pages,
2739                 .acl_len        = buflen,
2740         };
2741         struct rpc_message msg = {
2742                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_SETACL],
2743                 .rpc_argp       = &arg,
2744                 .rpc_resp       = NULL,
2745         };
2746         int ret;
2747
2748         if (!nfs4_server_supports_acls(server))
2749                 return -EOPNOTSUPP;
2750         nfs_inode_return_delegation(inode);
2751         buf_to_pages(buf, buflen, arg.acl_pages, &arg.acl_pgbase);
2752         ret = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
2753         nfs_access_zap_cache(inode);
2754         nfs_zap_acl_cache(inode);
2755         return ret;
2756 }
2757
2758 static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
2759 {
2760         struct nfs4_exception exception = { };
2761         int err;
2762         do {
2763                 err = nfs4_handle_exception(NFS_SERVER(inode),
2764                                 __nfs4_proc_set_acl(inode, buf, buflen),
2765                                 &exception);
2766         } while (exception.retry);
2767         return err;
2768 }
2769
2770 static int
2771 nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server)
2772 {
2773         struct nfs_client *clp = server->nfs_client;
2774
2775         if (!clp || task->tk_status >= 0)
2776                 return 0;
2777         switch(task->tk_status) {
2778                 case -NFS4ERR_STALE_CLIENTID:
2779                 case -NFS4ERR_STALE_STATEID:
2780                 case -NFS4ERR_EXPIRED:
2781                         rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL);
2782                         nfs4_schedule_state_recovery(clp);
2783                         if (test_bit(NFS4CLNT_STATE_RECOVER, &clp->cl_state) == 0)
2784                                 rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task);
2785                         task->tk_status = 0;
2786                         return -EAGAIN;
2787                 case -NFS4ERR_DELAY:
2788                         nfs_inc_server_stats(server, NFSIOS_DELAY);
2789                 case -NFS4ERR_GRACE:
2790                         rpc_delay(task, NFS4_POLL_RETRY_MAX);
2791                         task->tk_status = 0;
2792                         return -EAGAIN;
2793                 case -NFS4ERR_OLD_STATEID:
2794                         task->tk_status = 0;
2795                         return -EAGAIN;
2796         }
2797         task->tk_status = nfs4_map_errors(task->tk_status);
2798         return 0;
2799 }
2800
2801 static int nfs4_wait_bit_killable(void *word)
2802 {
2803         if (fatal_signal_pending(current))
2804                 return -ERESTARTSYS;
2805         schedule();
2806         return 0;
2807 }
2808
2809 static int nfs4_wait_clnt_recover(struct rpc_clnt *clnt, struct nfs_client *clp)
2810 {
2811         int res;
2812
2813         might_sleep();
2814
2815         rwsem_acquire(&clp->cl_sem.dep_map, 0, 0, _RET_IP_);
2816
2817         res = wait_on_bit(&clp->cl_state, NFS4CLNT_STATE_RECOVER,
2818                         nfs4_wait_bit_killable, TASK_KILLABLE);
2819
2820         rwsem_release(&clp->cl_sem.dep_map, 1, _RET_IP_);
2821         return res;
2822 }
2823
2824 static int nfs4_delay(struct rpc_clnt *clnt, long *timeout)
2825 {
2826         int res = 0;
2827
2828         might_sleep();
2829
2830         if (*timeout <= 0)
2831                 *timeout = NFS4_POLL_RETRY_MIN;
2832         if (*timeout > NFS4_POLL_RETRY_MAX)
2833                 *timeout = NFS4_POLL_RETRY_MAX;
2834         schedule_timeout_killable(*timeout);
2835         if (fatal_signal_pending(current))
2836                 res = -ERESTARTSYS;
2837         *timeout <<= 1;
2838         return res;
2839 }
2840
2841 /* This is the error handling routine for processes that are allowed
2842  * to sleep.
2843  */
2844 static int nfs4_handle_exception(const struct nfs_server *server, int errorcode, struct nfs4_exception *exception)
2845 {
2846         struct nfs_client *clp = server->nfs_client;
2847         int ret = errorcode;
2848
2849         exception->retry = 0;
2850         switch(errorcode) {
2851                 case 0:
2852                         return 0;
2853                 case -NFS4ERR_STALE_CLIENTID:
2854                 case -NFS4ERR_STALE_STATEID:
2855                 case -NFS4ERR_EXPIRED:
2856                         nfs4_schedule_state_recovery(clp);
2857                         ret = nfs4_wait_clnt_recover(server->client, clp);
2858                         if (ret == 0)
2859                                 exception->retry = 1;
2860                         break;
2861                 case -NFS4ERR_FILE_OPEN:
2862                 case -NFS4ERR_GRACE:
2863                 case -NFS4ERR_DELAY:
2864                         ret = nfs4_delay(server->client, &exception->timeout);
2865                         if (ret != 0)
2866                                 break;
2867                 case -NFS4ERR_OLD_STATEID:
2868                         exception->retry = 1;
2869         }
2870         /* We failed to handle the error */
2871         return nfs4_map_errors(ret);
2872 }
2873
2874 int nfs4_proc_setclientid(struct nfs_client *clp, u32 program, unsigned short port, struct rpc_cred *cred)
2875 {
2876         nfs4_verifier sc_verifier;
2877         struct nfs4_setclientid setclientid = {
2878                 .sc_verifier = &sc_verifier,
2879                 .sc_prog = program,
2880         };
2881         struct rpc_message msg = {
2882                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID],
2883                 .rpc_argp = &setclientid,
2884                 .rpc_resp = clp,
2885                 .rpc_cred = cred,
2886         };
2887         __be32 *p;
2888         int loop = 0;
2889         int status;
2890
2891         p = (__be32*)sc_verifier.data;
2892         *p++ = htonl((u32)clp->cl_boot_time.tv_sec);
2893         *p = htonl((u32)clp->cl_boot_time.tv_nsec);
2894
2895         for(;;) {
2896                 setclientid.sc_name_len = scnprintf(setclientid.sc_name,
2897                                 sizeof(setclientid.sc_name), "%s/%s %s %s %u",
2898                                 clp->cl_ipaddr,
2899                                 rpc_peeraddr2str(clp->cl_rpcclient,
2900                                                         RPC_DISPLAY_ADDR),
2901                                 rpc_peeraddr2str(clp->cl_rpcclient,
2902                                                         RPC_DISPLAY_PROTO),
2903                                 clp->cl_rpcclient->cl_auth->au_ops->au_name,
2904                                 clp->cl_id_uniquifier);
2905                 setclientid.sc_netid_len = scnprintf(setclientid.sc_netid,
2906                                 sizeof(setclientid.sc_netid),
2907                                 rpc_peeraddr2str(clp->cl_rpcclient,
2908                                                         RPC_DISPLAY_NETID));
2909                 setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr,
2910                                 sizeof(setclientid.sc_uaddr), "%s.%u.%u",
2911                                 clp->cl_ipaddr, port >> 8, port & 255);
2912
2913                 status = rpc_call_sync(clp->cl_rpcclient, &msg, 0);
2914                 if (status != -NFS4ERR_CLID_INUSE)
2915                         break;
2916                 if (signalled())
2917                         break;
2918                 if (loop++ & 1)
2919                         ssleep(clp->cl_lease_time + 1);
2920                 else
2921                         if (++clp->cl_id_uniquifier == 0)
2922                                 break;
2923         }
2924         return status;
2925 }
2926
2927 static int _nfs4_proc_setclientid_confirm(struct nfs_client *clp, struct rpc_cred *cred)
2928 {
2929         struct nfs_fsinfo fsinfo;
2930         struct rpc_message msg = {
2931                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM],
2932                 .rpc_argp = clp,
2933                 .rpc_resp = &fsinfo,
2934                 .rpc_cred = cred,
2935         };
2936         unsigned long now;
2937         int status;
2938
2939         now = jiffies;
2940         status = rpc_call_sync(clp->cl_rpcclient, &msg, 0);
2941         if (status == 0) {
2942                 spin_lock(&clp->cl_lock);
2943                 clp->cl_lease_time = fsinfo.lease_time * HZ;
2944                 clp->cl_last_renewal = now;
2945                 clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
2946                 spin_unlock(&clp->cl_lock);
2947         }
2948         return status;
2949 }
2950
2951 int nfs4_proc_setclientid_confirm(struct nfs_client *clp, struct rpc_cred *cred)
2952 {
2953         long timeout = 0;
2954         int err;
2955         do {
2956                 err = _nfs4_proc_setclientid_confirm(clp, cred);
2957                 switch (err) {
2958                         case 0:
2959                                 return err;
2960                         case -NFS4ERR_RESOURCE:
2961                                 /* The IBM lawyers misread another document! */
2962                         case -NFS4ERR_DELAY:
2963                                 err = nfs4_delay(clp->cl_rpcclient, &timeout);
2964                 }
2965         } while (err == 0);
2966         return err;
2967 }
2968
2969 struct nfs4_delegreturndata {
2970         struct nfs4_delegreturnargs args;
2971         struct nfs4_delegreturnres res;
2972         struct nfs_fh fh;
2973         nfs4_stateid stateid;
2974         unsigned long timestamp;
2975         struct nfs_fattr fattr;
2976         int rpc_status;
2977 };
2978
2979 static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata)
2980 {
2981         struct nfs4_delegreturndata *data = calldata;
2982         data->rpc_status = task->tk_status;
2983         if (data->rpc_status == 0)
2984                 renew_lease(data->res.server, data->timestamp);
2985 }
2986
2987 static void nfs4_delegreturn_release(void *calldata)
2988 {
2989         kfree(calldata);
2990 }
2991
2992 static const struct rpc_call_ops nfs4_delegreturn_ops = {
2993         .rpc_call_done = nfs4_delegreturn_done,
2994         .rpc_release = nfs4_delegreturn_release,
2995 };
2996
2997 static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
2998 {
2999         struct nfs4_delegreturndata *data;
3000         struct nfs_server *server = NFS_SERVER(inode);
3001         struct rpc_task *task;
3002         struct rpc_message msg = {
3003                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN],
3004                 .rpc_cred = cred,
3005         };
3006         struct rpc_task_setup task_setup_data = {
3007                 .rpc_client = server->client,
3008                 .rpc_message = &msg,
3009                 .callback_ops = &nfs4_delegreturn_ops,
3010                 .flags = RPC_TASK_ASYNC,
3011         };
3012         int status = 0;
3013
3014         data = kmalloc(sizeof(*data), GFP_KERNEL);
3015         if (data == NULL)
3016                 return -ENOMEM;
3017         data->args.fhandle = &data->fh;
3018         data->args.stateid = &data->stateid;
3019         data->args.bitmask = server->attr_bitmask;
3020         nfs_copy_fh(&data->fh, NFS_FH(inode));
3021         memcpy(&data->stateid, stateid, sizeof(data->stateid));
3022         data->res.fattr = &data->fattr;
3023         data->res.server = server;
3024         nfs_fattr_init(data->res.fattr);
3025         data->timestamp = jiffies;
3026         data->rpc_status = 0;
3027
3028         task_setup_data.callback_data = data;
3029         msg.rpc_argp = &data->args,
3030         msg.rpc_resp = &data->res,
3031         task = rpc_run_task(&task_setup_data);
3032         if (IS_ERR(task))
3033                 return PTR_ERR(task);
3034         if (!issync)
3035                 goto out;
3036         status = nfs4_wait_for_completion_rpc_task(task);
3037         if (status != 0)
3038                 goto out;
3039         status = data->rpc_status;
3040         if (status != 0)
3041                 goto out;
3042         nfs_refresh_inode(inode, &data->fattr);
3043 out:
3044         rpc_put_task(task);
3045         return status;
3046 }
3047
3048 int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
3049 {
3050         struct nfs_server *server = NFS_SERVER(inode);
3051         struct nfs4_exception exception = { };
3052         int err;
3053         do {
3054                 err = _nfs4_proc_delegreturn(inode, cred, stateid, issync);
3055                 switch (err) {
3056                         case -NFS4ERR_STALE_STATEID:
3057                         case -NFS4ERR_EXPIRED:
3058                         case 0:
3059                                 return 0;
3060                 }
3061                 err = nfs4_handle_exception(server, err, &exception);
3062         } while (exception.retry);
3063         return err;
3064 }
3065
3066 #define NFS4_LOCK_MINTIMEOUT (1 * HZ)
3067 #define NFS4_LOCK_MAXTIMEOUT (30 * HZ)
3068
3069 /*
3070  * sleep, with exponential backoff, and retry the LOCK operation.
3071  */
3072 static unsigned long
3073 nfs4_set_lock_task_retry(unsigned long timeout)
3074 {
3075         schedule_timeout_killable(timeout);
3076         timeout <<= 1;
3077         if (timeout > NFS4_LOCK_MAXTIMEOUT)
3078                 return NFS4_LOCK_MAXTIMEOUT;
3079         return timeout;
3080 }
3081
3082 static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
3083 {
3084         struct inode *inode = state->inode;
3085         struct nfs_server *server = NFS_SERVER(inode);
3086         struct nfs_client *clp = server->nfs_client;
3087         struct nfs_lockt_args arg = {
3088                 .fh = NFS_FH(inode),
3089                 .fl = request,
3090         };
3091         struct nfs_lockt_res res = {
3092                 .denied = request,
3093         };
3094         struct rpc_message msg = {
3095                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_LOCKT],
3096                 .rpc_argp       = &arg,
3097                 .rpc_resp       = &res,
3098                 .rpc_cred       = state->owner->so_cred,
3099         };
3100         struct nfs4_lock_state *lsp;
3101         int status;
3102
3103         down_read(&clp->cl_sem);
3104         arg.lock_owner.clientid = clp->cl_clientid;
3105         status = nfs4_set_lock_state(state, request);
3106         if (status != 0)
3107                 goto out;
3108         lsp = request->fl_u.nfs4_fl.owner;
3109         arg.lock_owner.id = lsp->ls_id.id;
3110         status = rpc_call_sync(server->client, &msg, 0);
3111         switch (status) {
3112                 case 0:
3113                         request->fl_type = F_UNLCK;
3114                         break;
3115                 case -NFS4ERR_DENIED:
3116                         status = 0;
3117         }
3118         request->fl_ops->fl_release_private(request);
3119 out:
3120         up_read(&clp->cl_sem);
3121         return status;
3122 }
3123
3124 static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
3125 {
3126         struct nfs4_exception exception = { };
3127         int err;
3128
3129         do {
3130                 err = nfs4_handle_exception(NFS_SERVER(state->inode),
3131                                 _nfs4_proc_getlk(state, cmd, request),
3132                                 &exception);
3133         } while (exception.retry);
3134         return err;
3135 }
3136
3137 static int do_vfs_lock(struct file *file, struct file_lock *fl)
3138 {
3139         int res = 0;
3140         switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
3141                 case FL_POSIX:
3142                         res = posix_lock_file_wait(file, fl);
3143                         break;
3144                 case FL_FLOCK:
3145                         res = flock_lock_file_wait(file, fl);
3146                         break;
3147                 default:
3148                         BUG();
3149         }
3150         return res;
3151 }
3152
3153 struct nfs4_unlockdata {
3154         struct nfs_locku_args arg;
3155         struct nfs_locku_res res;
3156         struct nfs4_lock_state *lsp;
3157         struct nfs_open_context *ctx;
3158         struct file_lock fl;
3159         const struct nfs_server *server;
3160         unsigned long timestamp;
3161 };
3162
3163 static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,
3164                 struct nfs_open_context *ctx,
3165                 struct nfs4_lock_state *lsp,
3166                 struct nfs_seqid *seqid)
3167 {
3168         struct nfs4_unlockdata *p;
3169         struct inode *inode = lsp->ls_state->inode;
3170
3171         p = kmalloc(sizeof(*p), GFP_KERNEL);
3172         if (p == NULL)
3173                 return NULL;
3174         p->arg.fh = NFS_FH(inode);
3175         p->arg.fl = &p->fl;
3176         p->arg.seqid = seqid;
3177         p->res.seqid = seqid;
3178         p->arg.stateid = &lsp->ls_stateid;
3179         p->lsp = lsp;
3180         atomic_inc(&lsp->ls_count);
3181         /* Ensure we don't close file until we're done freeing locks! */
3182         p->ctx = get_nfs_open_context(ctx);
3183         memcpy(&p->fl, fl, sizeof(p->fl));
3184         p->server = NFS_SERVER(inode);
3185         return p;
3186 }
3187
3188 static void nfs4_locku_release_calldata(void *data)
3189 {
3190         struct nfs4_unlockdata *calldata = data;
3191         nfs_free_seqid(calldata->arg.seqid);
3192         nfs4_put_lock_state(calldata->lsp);
3193         put_nfs_open_context(calldata->ctx);
3194         kfree(calldata);
3195 }
3196
3197 static void nfs4_locku_done(struct rpc_task *task, void *data)
3198 {
3199         struct nfs4_unlockdata *calldata = data;
3200
3201         if (RPC_ASSASSINATED(task))
3202                 return;
3203         switch (task->tk_status) {
3204                 case 0:
3205                         memcpy(calldata->lsp->ls_stateid.data,
3206                                         calldata->res.stateid.data,
3207                                         sizeof(calldata->lsp->ls_stateid.data));
3208                         renew_lease(calldata->server, calldata->timestamp);
3209                         break;
3210                 case -NFS4ERR_STALE_STATEID:
3211                 case -NFS4ERR_EXPIRED:
3212                         break;
3213                 default:
3214                         if (nfs4_async_handle_error(task, calldata->server) == -EAGAIN)
3215                                 rpc_restart_call(task);
3216         }
3217 }
3218
3219 static void nfs4_locku_prepare(struct rpc_task *task, void *data)
3220 {
3221         struct nfs4_unlockdata *calldata = data;
3222
3223         if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
3224                 return;
3225         if ((calldata->lsp->ls_flags & NFS_LOCK_INITIALIZED) == 0) {
3226                 /* Note: exit _without_ running nfs4_locku_done */
3227                 task->tk_action = NULL;
3228                 return;
3229         }
3230         calldata->timestamp = jiffies;
3231         rpc_call_start(task);
3232 }
3233
3234 static const struct rpc_call_ops nfs4_locku_ops = {
3235         .rpc_call_prepare = nfs4_locku_prepare,
3236         .rpc_call_done = nfs4_locku_done,
3237         .rpc_release = nfs4_locku_release_calldata,
3238 };
3239
3240 static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,
3241                 struct nfs_open_context *ctx,
3242                 struct nfs4_lock_state *lsp,
3243                 struct nfs_seqid *seqid)
3244 {
3245         struct nfs4_unlockdata *data;
3246         struct rpc_message msg = {
3247                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU],
3248                 .rpc_cred = ctx->cred,
3249         };
3250         struct rpc_task_setup task_setup_data = {
3251                 .rpc_client = NFS_CLIENT(lsp->ls_state->inode),
3252                 .rpc_message = &msg,
3253                 .callback_ops = &nfs4_locku_ops,
3254                 .workqueue = nfsiod_workqueue,
3255                 .flags = RPC_TASK_ASYNC,
3256         };
3257
3258         /* Ensure this is an unlock - when canceling a lock, the
3259          * canceled lock is passed in, and it won't be an unlock.
3260          */
3261         fl->fl_type = F_UNLCK;
3262
3263         data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid);
3264         if (data == NULL) {
3265                 nfs_free_seqid(seqid);
3266                 return ERR_PTR(-ENOMEM);
3267         }
3268
3269         msg.rpc_argp = &data->arg,
3270         msg.rpc_resp = &data->res,
3271         task_setup_data.callback_data = data;
3272         return rpc_run_task(&task_setup_data);
3273 }
3274
3275 static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request)
3276 {
3277         struct nfs_seqid *seqid;
3278         struct nfs4_lock_state *lsp;
3279         struct rpc_task *task;
3280         int status = 0;
3281         unsigned char fl_flags = request->fl_flags;
3282
3283         status = nfs4_set_lock_state(state, request);
3284         /* Unlock _before_ we do the RPC call */
3285         request->fl_flags |= FL_EXISTS;
3286         if (do_vfs_lock(request->fl_file, request) == -ENOENT)
3287                 goto out;
3288         if (status != 0)
3289                 goto out;
3290         /* Is this a delegated lock? */
3291         if (test_bit(NFS_DELEGATED_STATE, &state->flags))
3292                 goto out;
3293         lsp = request->fl_u.nfs4_fl.owner;
3294         seqid = nfs_alloc_seqid(&lsp->ls_seqid);
3295         status = -ENOMEM;
3296         if (seqid == NULL)
3297                 goto out;
3298         task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid);
3299         status = PTR_ERR(task);
3300         if (IS_ERR(task))
3301                 goto out;
3302         status = nfs4_wait_for_completion_rpc_task(task);
3303         rpc_put_task(task);
3304 out:
3305         request->fl_flags = fl_flags;
3306         return status;
3307 }
3308
3309 struct nfs4_lockdata {
3310         struct nfs_lock_args arg;
3311         struct nfs_lock_res res;
3312         struct nfs4_lock_state *lsp;
3313         struct nfs_open_context *ctx;
3314         struct file_lock fl;
3315         unsigned long timestamp;
3316         int rpc_status;
3317         int cancelled;
3318 };
3319
3320 static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl,
3321                 struct nfs_open_context *ctx, struct nfs4_lock_state *lsp)
3322 {
3323         struct nfs4_lockdata *p;
3324         struct inode *inode = lsp->ls_state->inode;
3325         struct nfs_server *server = NFS_SERVER(inode);
3326
3327         p = kzalloc(sizeof(*p), GFP_KERNEL);
3328         if (p == NULL)
3329                 return NULL;
3330
3331         p->arg.fh = NFS_FH(inode);
3332         p->arg.fl = &p->fl;
3333         p->arg.open_seqid = nfs_alloc_seqid(&lsp->ls_state->owner->so_seqid);
3334         if (p->arg.open_seqid == NULL)
3335                 goto out_free;
3336         p->arg.lock_seqid = nfs_alloc_seqid(&lsp->ls_seqid);
3337         if (p->arg.lock_seqid == NULL)
3338                 goto out_free_seqid;
3339         p->arg.lock_stateid = &lsp->ls_stateid;
3340         p->arg.lock_owner.clientid = server->nfs_client->cl_clientid;
3341         p->arg.lock_owner.id = lsp->ls_id.id;
3342         p->res.lock_seqid = p->arg.lock_seqid;
3343         p->lsp = lsp;
3344         atomic_inc(&lsp->ls_count);
3345         p->ctx = get_nfs_open_context(ctx);
3346         memcpy(&p->fl, fl, sizeof(p->fl));
3347         return p;
3348 out_free_seqid:
3349         nfs_free_seqid(p->arg.open_seqid);
3350 out_free:
3351         kfree(p);
3352         return NULL;
3353 }
3354
3355 static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)
3356 {
3357         struct nfs4_lockdata *data = calldata;
3358         struct nfs4_state *state = data->lsp->ls_state;
3359
3360         dprintk("%s: begin!\n", __func__);
3361         if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0)
3362                 return;
3363         /* Do we need to do an open_to_lock_owner? */
3364         if (!(data->arg.lock_seqid->sequence->flags & NFS_SEQID_CONFIRMED)) {
3365                 if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0)
3366                         return;
3367                 data->arg.open_stateid = &state->stateid;
3368                 data->arg.new_lock_owner = 1;
3369                 data->res.open_seqid = data->arg.open_seqid;
3370         } else
3371                 data->arg.new_lock_owner = 0;
3372         data->timestamp = jiffies;
3373         rpc_call_start(task);
3374         dprintk("%s: done!, ret = %d\n", __func__, data->rpc_status);
3375 }
3376
3377 static void nfs4_lock_done(struct rpc_task *task, void *calldata)
3378 {
3379         struct nfs4_lockdata *data = calldata;
3380
3381         dprintk("%s: begin!\n", __func__);
3382
3383         data->rpc_status = task->tk_status;
3384         if (RPC_ASSASSINATED(task))
3385                 goto out;
3386         if (data->arg.new_lock_owner != 0) {
3387                 if (data->rpc_status == 0)
3388                         nfs_confirm_seqid(&data->lsp->ls_seqid, 0);
3389                 else
3390                         goto out;
3391         }
3392         if (data->rpc_status == 0) {
3393                 memcpy(data->lsp->ls_stateid.data, data->res.stateid.data,
3394                                         sizeof(data->lsp->ls_stateid.data));
3395                 data->lsp->ls_flags |= NFS_LOCK_INITIALIZED;
3396                 renew_lease(NFS_SERVER(data->ctx->path.dentry->d_inode), data->timestamp);
3397         }
3398 out:
3399         dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status);
3400 }
3401
3402 static void nfs4_lock_release(void *calldata)
3403 {
3404         struct nfs4_lockdata *data = calldata;
3405
3406         dprintk("%s: begin!\n", __func__);
3407         nfs_free_seqid(data->arg.open_seqid);
3408         if (data->cancelled != 0) {
3409                 struct rpc_task *task;
3410                 task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp,
3411                                 data->arg.lock_seqid);
3412                 if (!IS_ERR(task))
3413                         rpc_put_task(task);
3414                 dprintk("%s: cancelling lock!\n", __func__);
3415         } else
3416                 nfs_free_seqid(data->arg.lock_seqid);
3417         nfs4_put_lock_state(data->lsp);
3418         put_nfs_open_context(data->ctx);
3419         kfree(data);
3420         dprintk("%s: done!\n", __func__);
3421 }
3422
3423 static const struct rpc_call_ops nfs4_lock_ops = {
3424         .rpc_call_prepare = nfs4_lock_prepare,
3425         .rpc_call_done = nfs4_lock_done,
3426         .rpc_release = nfs4_lock_release,
3427 };
3428
3429 static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int reclaim)
3430 {
3431         struct nfs4_lockdata *data;
3432         struct rpc_task *task;
3433         struct rpc_message msg = {
3434                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK],
3435                 .rpc_cred = state->owner->so_cred,
3436         };
3437         struct rpc_task_setup task_setup_data = {
3438                 .rpc_client = NFS_CLIENT(state->inode),
3439                 .rpc_message = &msg,
3440                 .callback_ops = &nfs4_lock_ops,
3441                 .workqueue = nfsiod_workqueue,
3442                 .flags = RPC_TASK_ASYNC,
3443         };
3444         int ret;
3445
3446         dprintk("%s: begin!\n", __func__);
3447         data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file),
3448                         fl->fl_u.nfs4_fl.owner);
3449         if (data == NULL)
3450                 return -ENOMEM;
3451         if (IS_SETLKW(cmd))
3452                 data->arg.block = 1;
3453         if (reclaim != 0)
3454                 data->arg.reclaim = 1;
3455         msg.rpc_argp = &data->arg,
3456         msg.rpc_resp = &data->res,
3457         task_setup_data.callback_data = data;
3458         task = rpc_run_task(&task_setup_data);
3459         if (IS_ERR(task))
3460                 return PTR_ERR(task);
3461         ret = nfs4_wait_for_completion_rpc_task(task);
3462         if (ret == 0) {
3463                 ret = data->rpc_status;
3464                 if (ret == -NFS4ERR_DENIED)
3465                         ret = -EAGAIN;
3466         } else
3467                 data->cancelled = 1;
3468         rpc_put_task(task);
3469         dprintk("%s: done, ret = %d!\n", __func__, ret);
3470         return ret;
3471 }
3472
3473 static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request)
3474 {
3475         struct nfs_server *server = NFS_SERVER(state->inode);
3476         struct nfs4_exception exception = { };
3477         int err;
3478
3479         do {
3480                 /* Cache the lock if possible... */
3481                 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
3482                         return 0;
3483                 err = _nfs4_do_setlk(state, F_SETLK, request, 1);
3484                 if (err != -NFS4ERR_DELAY)
3485                         break;
3486                 nfs4_handle_exception(server, err, &exception);
3487         } while (exception.retry);
3488         return err;
3489 }
3490
3491 static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request)
3492 {
3493         struct nfs_server *server = NFS_SERVER(state->inode);
3494         struct nfs4_exception exception = { };
3495         int err;
3496
3497         err = nfs4_set_lock_state(state, request);
3498         if (err != 0)
3499                 return err;
3500         do {
3501                 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
3502                         return 0;
3503                 err = _nfs4_do_setlk(state, F_SETLK, request, 0);
3504                 if (err != -NFS4ERR_DELAY)
3505                         break;
3506                 nfs4_handle_exception(server, err, &exception);
3507         } while (exception.retry);
3508         return err;
3509 }
3510
3511 static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
3512 {
3513         struct nfs_client *clp = state->owner->so_client;
3514         unsigned char fl_flags = request->fl_flags;
3515         int status;
3516
3517         /* Is this a delegated open? */
3518         status = nfs4_set_lock_state(state, request);
3519         if (status != 0)
3520                 goto out;
3521         request->fl_flags |= FL_ACCESS;
3522         status = do_vfs_lock(request->fl_file, request);
3523         if (status < 0)
3524                 goto out;
3525         down_read(&clp->cl_sem);
3526         if (test_bit(NFS_DELEGATED_STATE, &state->flags)) {
3527                 struct nfs_inode *nfsi = NFS_I(state->inode);
3528                 /* Yes: cache locks! */
3529                 down_read(&nfsi->rwsem);
3530                 /* ...but avoid races with delegation recall... */
3531                 if (test_bit(NFS_DELEGATED_STATE, &state->flags)) {
3532                         request->fl_flags = fl_flags & ~FL_SLEEP;
3533                         status = do_vfs_lock(request->fl_file, request);
3534                         up_read(&nfsi->rwsem);
3535                         goto out_unlock;
3536                 }
3537                 up_read(&nfsi->rwsem);
3538         }
3539         status = _nfs4_do_setlk(state, cmd, request, 0);
3540         if (status != 0)
3541                 goto out_unlock;
3542         /* Note: we always want to sleep here! */
3543         request->fl_flags = fl_flags | FL_SLEEP;
3544         if (do_vfs_lock(request->fl_file, request) < 0)
3545                 printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n", __func__);
3546 out_unlock:
3547         up_read(&clp->cl_sem);
3548 out:
3549         request->fl_flags = fl_flags;
3550         return status;
3551 }
3552
3553 static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
3554 {
3555         struct nfs4_exception exception = { };
3556         int err;
3557
3558         do {
3559                 err = nfs4_handle_exception(NFS_SERVER(state->inode),
3560                                 _nfs4_proc_setlk(state, cmd, request),
3561                                 &exception);
3562         } while (exception.retry);
3563         return err;
3564 }
3565
3566 static int
3567 nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request)
3568 {
3569         struct nfs_open_context *ctx;
3570         struct nfs4_state *state;
3571         unsigned long timeout = NFS4_LOCK_MINTIMEOUT;
3572         int status;
3573
3574         /* verify open state */
3575         ctx = nfs_file_open_context(filp);
3576         state = ctx->state;
3577
3578         if (request->fl_start < 0 || request->fl_end < 0)
3579                 return -EINVAL;
3580
3581         if (IS_GETLK(cmd))
3582                 return nfs4_proc_getlk(state, F_GETLK, request);
3583
3584         if (!(IS_SETLK(cmd) || IS_SETLKW(cmd)))
3585                 return -EINVAL;
3586
3587         if (request->fl_type == F_UNLCK)
3588                 return nfs4_proc_unlck(state, cmd, request);
3589
3590         do {
3591                 status = nfs4_proc_setlk(state, cmd, request);
3592                 if ((status != -EAGAIN) || IS_SETLK(cmd))
3593                         break;
3594                 timeout = nfs4_set_lock_task_retry(timeout);
3595                 status = -ERESTARTSYS;
3596                 if (signalled())
3597                         break;
3598         } while(status < 0);
3599         return status;
3600 }
3601
3602 int nfs4_lock_delegation_recall(struct nfs4_state *state, struct file_lock *fl)
3603 {
3604         struct nfs_server *server = NFS_SERVER(state->inode);
3605         struct nfs4_exception exception = { };
3606         int err;
3607
3608         err = nfs4_set_lock_state(state, fl);
3609         if (err != 0)
3610                 goto out;
3611         do {
3612                 err = _nfs4_do_setlk(state, F_SETLK, fl, 0);
3613                 if (err != -NFS4ERR_DELAY)
3614                         break;
3615                 err = nfs4_handle_exception(server, err, &exception);
3616         } while (exception.retry);
3617 out:
3618         return err;
3619 }
3620
3621 #define XATTR_NAME_NFSV4_ACL "system.nfs4_acl"
3622
3623 int nfs4_setxattr(struct dentry *dentry, const char *key, const void *buf,
3624                 size_t buflen, int flags)
3625 {
3626         struct inode *inode = dentry->d_inode;
3627
3628         if (strcmp(key, XATTR_NAME_NFSV4_ACL) != 0)
3629                 return -EOPNOTSUPP;
3630
3631         return nfs4_proc_set_acl(inode, buf, buflen);
3632 }
3633
3634 /* The getxattr man page suggests returning -ENODATA for unknown attributes,
3635  * and that's what we'll do for e.g. user attributes that haven't been set.
3636  * But we'll follow ext2/ext3's lead by returning -EOPNOTSUPP for unsupported
3637  * attributes in kernel-managed attribute namespaces. */
3638 ssize_t nfs4_getxattr(struct dentry *dentry, const char *key, void *buf,
3639                 size_t buflen)
3640 {
3641         struct inode *inode = dentry->d_inode;
3642
3643         if (strcmp(key, XATTR_NAME_NFSV4_ACL) != 0)
3644                 return -EOPNOTSUPP;
3645
3646         return nfs4_proc_get_acl(inode, buf, buflen);
3647 }
3648
3649 ssize_t nfs4_listxattr(struct dentry *dentry, char *buf, size_t buflen)
3650 {
3651         size_t len = strlen(XATTR_NAME_NFSV4_ACL) + 1;
3652
3653         if (!nfs4_server_supports_acls(NFS_SERVER(dentry->d_inode)))
3654                 return 0;
3655         if (buf && buflen < len)
3656                 return -ERANGE;
3657         if (buf)
3658                 memcpy(buf, XATTR_NAME_NFSV4_ACL, len);
3659         return len;
3660 }
3661
3662 int nfs4_proc_fs_locations(struct inode *dir, const struct qstr *name,
3663                 struct nfs4_fs_locations *fs_locations, struct page *page)
3664 {
3665         struct nfs_server *server = NFS_SERVER(dir);
3666         u32 bitmask[2] = {
3667                 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
3668                 [1] = FATTR4_WORD1_MOUNTED_ON_FILEID,
3669         };
3670         struct nfs4_fs_locations_arg args = {
3671                 .dir_fh = NFS_FH(dir),
3672                 .name = name,
3673                 .page = page,
3674                 .bitmask = bitmask,
3675         };
3676         struct rpc_message msg = {
3677                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
3678                 .rpc_argp = &args,
3679                 .rpc_resp = fs_locations,
3680         };
3681         int status;
3682
3683         dprintk("%s: start\n", __func__);
3684         nfs_fattr_init(&fs_locations->fattr);
3685         fs_locations->server = server;
3686         fs_locations->nlocations = 0;
3687         status = rpc_call_sync(server->client, &msg, 0);
3688         dprintk("%s: returned status = %d\n", __func__, status);
3689         return status;
3690 }
3691
3692 struct nfs4_state_recovery_ops nfs4_reboot_recovery_ops = {
3693         .recover_open   = nfs4_open_reclaim,
3694         .recover_lock   = nfs4_lock_reclaim,
3695 };
3696
3697 struct nfs4_state_recovery_ops nfs4_network_partition_recovery_ops = {
3698         .recover_open   = nfs4_open_expired,
3699         .recover_lock   = nfs4_lock_expired,
3700 };
3701
3702 static const struct inode_operations nfs4_file_inode_operations = {
3703         .permission     = nfs_permission,
3704         .getattr        = nfs_getattr,
3705         .setattr        = nfs_setattr,
3706         .getxattr       = nfs4_getxattr,
3707         .setxattr       = nfs4_setxattr,
3708         .listxattr      = nfs4_listxattr,
3709 };
3710
3711 const struct nfs_rpc_ops nfs_v4_clientops = {
3712         .version        = 4,                    /* protocol version */
3713         .dentry_ops     = &nfs4_dentry_operations,
3714         .dir_inode_ops  = &nfs4_dir_inode_operations,
3715         .file_inode_ops = &nfs4_file_inode_operations,
3716         .getroot        = nfs4_proc_get_root,
3717         .getattr        = nfs4_proc_getattr,
3718         .setattr        = nfs4_proc_setattr,
3719         .lookupfh       = nfs4_proc_lookupfh,
3720         .lookup         = nfs4_proc_lookup,
3721         .access         = nfs4_proc_access,
3722         .readlink       = nfs4_proc_readlink,
3723         .create         = nfs4_proc_create,
3724         .remove         = nfs4_proc_remove,
3725         .unlink_setup   = nfs4_proc_unlink_setup,
3726         .unlink_done    = nfs4_proc_unlink_done,
3727         .rename         = nfs4_proc_rename,
3728         .link           = nfs4_proc_link,
3729         .symlink        = nfs4_proc_symlink,
3730         .mkdir          = nfs4_proc_mkdir,
3731         .rmdir          = nfs4_proc_remove,
3732         .readdir        = nfs4_proc_readdir,
3733         .mknod          = nfs4_proc_mknod,
3734         .statfs         = nfs4_proc_statfs,
3735         .fsinfo         = nfs4_proc_fsinfo,
3736         .pathconf       = nfs4_proc_pathconf,
3737         .set_capabilities = nfs4_server_capabilities,
3738         .decode_dirent  = nfs4_decode_dirent,
3739         .read_setup     = nfs4_proc_read_setup,
3740         .read_done      = nfs4_read_done,
3741         .write_setup    = nfs4_proc_write_setup,
3742         .write_done     = nfs4_write_done,
3743         .commit_setup   = nfs4_proc_commit_setup,
3744         .commit_done    = nfs4_commit_done,
3745         .lock           = nfs4_proc_lock,
3746         .clear_acl_cache = nfs4_zap_acl_attr,
3747 };
3748
3749 /*
3750  * Local variables:
3751  *  c-basic-offset: 8
3752  * End:
3753  */