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