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/delay.h>
  40 #include <linux/errno.h>
  41 #include <linux/string.h>
  42 #include <linux/ratelimit.h>
  43 #include <linux/printk.h>
  44 #include <linux/slab.h>
  45 #include <linux/sunrpc/clnt.h>
  46 #include <linux/nfs.h>
  47 #include <linux/nfs4.h>
  48 #include <linux/nfs_fs.h>
  49 #include <linux/nfs_page.h>
  50 #include <linux/nfs_mount.h>
  51 #include <linux/namei.h>
  52 #include <linux/mount.h>
  53 #include <linux/module.h>
  54 #include <linux/nfs_idmap.h>
  55 #include <linux/xattr.h>
  56 #include <linux/utsname.h>
  57 #include <linux/freezer.h>
  58
  59 #include "nfs4_fs.h"
  60 #include "delegation.h"
  61 #include "internal.h"
  62 #include "iostat.h"
  63 #include "callback.h"
  64 #include "pnfs.h"
  65 #include "netns.h"
  66 #include "nfs4session.h"
  67 #include "fscache.h"
  68
  69 #define NFSDBG_FACILITY         NFSDBG_PROC
  70
  71 #define NFS4_POLL_RETRY_MIN     (HZ/10)
  72 #define NFS4_POLL_RETRY_MAX     (15*HZ)
  73
  74 struct nfs4_opendata;
  75 static int _nfs4_proc_open(struct nfs4_opendata *data);
  76 static int _nfs4_recover_proc_open(struct nfs4_opendata *data);
  77 static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *);
  78 static int nfs4_async_handle_error(struct rpc_task *, const struct nfs_server *, struct nfs4_state *);
  79 static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr);
  80 static int nfs4_proc_getattr(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *);
  81 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr);
  82 static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
  83                             struct nfs_fattr *fattr, struct iattr *sattr,
  84                             struct nfs4_state *state);
  85 #ifdef CONFIG_NFS_V4_1
  86 static int nfs41_test_stateid(struct nfs_server *, nfs4_stateid *);
  87 static int nfs41_free_stateid(struct nfs_server *, nfs4_stateid *);
  88 #endif
  89 /* Prevent leaks of NFSv4 errors into userland */
  90 static int nfs4_map_errors(int err)
  91 {
  92         if (err >= -1000)
  93                 return err;
  94         switch (err) {
  95         case -NFS4ERR_RESOURCE:
  96         case -NFS4ERR_LAYOUTTRYLATER:
  97         case -NFS4ERR_RECALLCONFLICT:
  98                 return -EREMOTEIO;
  99         case -NFS4ERR_WRONGSEC:
 100                 return -EPERM;
 101         case -NFS4ERR_BADOWNER:
 102         case -NFS4ERR_BADNAME:
 103                 return -EINVAL;
 104         case -NFS4ERR_SHARE_DENIED:
 105                 return -EACCES;
 106         case -NFS4ERR_MINOR_VERS_MISMATCH:
 107                 return -EPROTONOSUPPORT;
 108         case -NFS4ERR_ACCESS:
 109                 return -EACCES;
 110         default:
 111                 dprintk("%s could not handle NFSv4 error %d\n",
 112                                 __func__, -err);
 113                 break;
 114         }
 115         return -EIO;
 116 }
 117
 118 /*
 119  * This is our standard bitmap for GETATTR requests.
 120  */
 121 const u32 nfs4_fattr_bitmap[3] = {
 122         FATTR4_WORD0_TYPE
 123         | FATTR4_WORD0_CHANGE
 124         | FATTR4_WORD0_SIZE
 125         | FATTR4_WORD0_FSID
 126         | FATTR4_WORD0_FILEID,
 127         FATTR4_WORD1_MODE
 128         | FATTR4_WORD1_NUMLINKS
 129         | FATTR4_WORD1_OWNER
 130         | FATTR4_WORD1_OWNER_GROUP
 131         | FATTR4_WORD1_RAWDEV
 132         | FATTR4_WORD1_SPACE_USED
 133         | FATTR4_WORD1_TIME_ACCESS
 134         | FATTR4_WORD1_TIME_METADATA
 135         | FATTR4_WORD1_TIME_MODIFY
 136 };
 137
 138 static const u32 nfs4_pnfs_open_bitmap[3] = {
 139         FATTR4_WORD0_TYPE
 140         | FATTR4_WORD0_CHANGE
 141         | FATTR4_WORD0_SIZE
 142         | FATTR4_WORD0_FSID
 143         | FATTR4_WORD0_FILEID,
 144         FATTR4_WORD1_MODE
 145         | FATTR4_WORD1_NUMLINKS
 146         | FATTR4_WORD1_OWNER
 147         | FATTR4_WORD1_OWNER_GROUP
 148         | FATTR4_WORD1_RAWDEV
 149         | FATTR4_WORD1_SPACE_USED
 150         | FATTR4_WORD1_TIME_ACCESS
 151         | FATTR4_WORD1_TIME_METADATA
 152         | FATTR4_WORD1_TIME_MODIFY,
 153         FATTR4_WORD2_MDSTHRESHOLD
 154 };
 155
 156 static const u32 nfs4_open_noattr_bitmap[3] = {
 157         FATTR4_WORD0_TYPE
 158         | FATTR4_WORD0_CHANGE
 159         | FATTR4_WORD0_FILEID,
 160 };
 161
 162 const u32 nfs4_statfs_bitmap[2] = {
 163         FATTR4_WORD0_FILES_AVAIL
 164         | FATTR4_WORD0_FILES_FREE
 165         | FATTR4_WORD0_FILES_TOTAL,
 166         FATTR4_WORD1_SPACE_AVAIL
 167         | FATTR4_WORD1_SPACE_FREE
 168         | FATTR4_WORD1_SPACE_TOTAL
 169 };
 170
 171 const u32 nfs4_pathconf_bitmap[2] = {
 172         FATTR4_WORD0_MAXLINK
 173         | FATTR4_WORD0_MAXNAME,
 174         0
 175 };
 176
 177 const u32 nfs4_fsinfo_bitmap[3] = { FATTR4_WORD0_MAXFILESIZE
 178                         | FATTR4_WORD0_MAXREAD
 179                         | FATTR4_WORD0_MAXWRITE
 180                         | FATTR4_WORD0_LEASE_TIME,
 181                         FATTR4_WORD1_TIME_DELTA
 182                         | FATTR4_WORD1_FS_LAYOUT_TYPES,
 183                         FATTR4_WORD2_LAYOUT_BLKSIZE
 184 };
 185
 186 const u32 nfs4_fs_locations_bitmap[2] = {
 187         FATTR4_WORD0_TYPE
 188         | FATTR4_WORD0_CHANGE
 189         | FATTR4_WORD0_SIZE
 190         | FATTR4_WORD0_FSID
 191         | FATTR4_WORD0_FILEID
 192         | FATTR4_WORD0_FS_LOCATIONS,
 193         FATTR4_WORD1_MODE
 194         | FATTR4_WORD1_NUMLINKS
 195         | FATTR4_WORD1_OWNER
 196         | FATTR4_WORD1_OWNER_GROUP
 197         | FATTR4_WORD1_RAWDEV
 198         | FATTR4_WORD1_SPACE_USED
 199         | FATTR4_WORD1_TIME_ACCESS
 200         | FATTR4_WORD1_TIME_METADATA
 201         | FATTR4_WORD1_TIME_MODIFY
 202         | FATTR4_WORD1_MOUNTED_ON_FILEID
 203 };
 204
 205 static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dentry,
 206                 struct nfs4_readdir_arg *readdir)
 207 {
 208         __be32 *start, *p;
 209
 210         if (cookie > 2) {
 211                 readdir->cookie = cookie;
 212                 memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier));
 213                 return;
 214         }
 215
 216         readdir->cookie = 0;
 217         memset(&readdir->verifier, 0, sizeof(readdir->verifier));
 218         if (cookie == 2)
 219                 return;
 220
 221         /*
 222          * NFSv4 servers do not return entries for '.' and '..'
 223          * Therefore, we fake these entries here.  We let '.'
 224          * have cookie 0 and '..' have cookie 1.  Note that
 225          * when talking to the server, we always send cookie 0
 226          * instead of 1 or 2.
 227          */
 228         start = p = kmap_atomic(*readdir->pages);
 229
 230         if (cookie == 0) {
 231                 *p++ = xdr_one;                                  /* next */
 232                 *p++ = xdr_zero;                   /* cookie, first word */
 233                 *p++ = xdr_one;                   /* cookie, second word */
 234                 *p++ = xdr_one;                             /* entry len */
 235                 memcpy(p, ".\0\0\0", 4);                        /* entry */
 236                 p++;
 237                 *p++ = xdr_one;                         /* bitmap length */
 238                 *p++ = htonl(FATTR4_WORD0_FILEID);             /* bitmap */
 239                 *p++ = htonl(8);              /* attribute buffer length */
 240                 p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_inode));
 241         }
 242
 243         *p++ = xdr_one;                                  /* next */
 244         *p++ = xdr_zero;                   /* cookie, first word */
 245         *p++ = xdr_two;                   /* cookie, second word */
 246         *p++ = xdr_two;                             /* entry len */
 247         memcpy(p, "..\0\0", 4);                         /* entry */
 248         p++;
 249         *p++ = xdr_one;                         /* bitmap length */
 250         *p++ = htonl(FATTR4_WORD0_FILEID);             /* bitmap */
 251         *p++ = htonl(8);              /* attribute buffer length */
 252         p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_parent->d_inode));
 253
 254         readdir->pgbase = (char *)p - (char *)start;
 255         readdir->count -= readdir->pgbase;
 256         kunmap_atomic(start);
 257 }
 258
 259 static int nfs4_delay(struct rpc_clnt *clnt, long *timeout)
 260 {
 261         int res = 0;
 262
 263         might_sleep();
 264
 265         if (*timeout <= 0)
 266                 *timeout = NFS4_POLL_RETRY_MIN;
 267         if (*timeout > NFS4_POLL_RETRY_MAX)
 268                 *timeout = NFS4_POLL_RETRY_MAX;
 269         freezable_schedule_timeout_killable(*timeout);
 270         if (fatal_signal_pending(current))
 271                 res = -ERESTARTSYS;
 272         *timeout <<= 1;
 273         return res;
 274 }
 275
 276 /* This is the error handling routine for processes that are allowed
 277  * to sleep.
 278  */
 279 static int nfs4_handle_exception(struct nfs_server *server, int errorcode, struct nfs4_exception *exception)
 280 {
 281         struct nfs_client *clp = server->nfs_client;
 282         struct nfs4_state *state = exception->state;
 283         struct inode *inode = exception->inode;
 284         int ret = errorcode;
 285
 286         exception->retry = 0;
 287         switch(errorcode) {
 288                 case 0:
 289                         return 0;
 290                 case -NFS4ERR_OPENMODE:
 291                         if (inode && nfs4_have_delegation(inode, FMODE_READ)) {
 292                                 nfs4_inode_return_delegation(inode);
 293                                 exception->retry = 1;
 294                                 return 0;
 295                         }
 296                         if (state == NULL)
 297                                 break;
 298                         ret = nfs4_schedule_stateid_recovery(server, state);
 299                         if (ret < 0)
 300                                 break;
 301                         goto wait_on_recovery;
 302                 case -NFS4ERR_DELEG_REVOKED:
 303                 case -NFS4ERR_ADMIN_REVOKED:
 304                 case -NFS4ERR_BAD_STATEID:
 305                         if (state == NULL)
 306                                 break;
 307                         nfs_remove_bad_delegation(state->inode);
 308                         ret = nfs4_schedule_stateid_recovery(server, state);
 309                         if (ret < 0)
 310                                 break;
 311                         goto wait_on_recovery;
 312                 case -NFS4ERR_EXPIRED:
 313                         if (state != NULL) {
 314                                 ret = nfs4_schedule_stateid_recovery(server, state);
 315                                 if (ret < 0)
 316                                         break;
 317                         }
 318                 case -NFS4ERR_STALE_STATEID:
 319                 case -NFS4ERR_STALE_CLIENTID:
 320                         nfs4_schedule_lease_recovery(clp);
 321                         goto wait_on_recovery;
 322 #if defined(CONFIG_NFS_V4_1)
 323                 case -NFS4ERR_BADSESSION:
 324                 case -NFS4ERR_BADSLOT:
 325                 case -NFS4ERR_BAD_HIGH_SLOT:
 326                 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
 327                 case -NFS4ERR_DEADSESSION:
 328                 case -NFS4ERR_SEQ_FALSE_RETRY:
 329                 case -NFS4ERR_SEQ_MISORDERED:
 330                         dprintk("%s ERROR: %d Reset session\n", __func__,
 331                                 errorcode);
 332                         nfs4_schedule_session_recovery(clp->cl_session, errorcode);
 333                         goto wait_on_recovery;
 334 #endif /* defined(CONFIG_NFS_V4_1) */
 335                 case -NFS4ERR_FILE_OPEN:
 336                         if (exception->timeout > HZ) {
 337                                 /* We have retried a decent amount, time to
 338                                  * fail
 339                                  */
 340                                 ret = -EBUSY;
 341                                 break;
 342                         }
 343                 case -NFS4ERR_GRACE:
 344                 case -NFS4ERR_DELAY:
 345                         ret = nfs4_delay(server->client, &exception->timeout);
 346                         if (ret != 0)
 347                                 break;
 348                 case -NFS4ERR_RETRY_UNCACHED_REP:
 349                 case -NFS4ERR_OLD_STATEID:
 350                         exception->retry = 1;
 351                         break;
 352                 case -NFS4ERR_BADOWNER:
 353                         /* The following works around a Linux server bug! */
 354                 case -NFS4ERR_BADNAME:
 355                         if (server->caps & NFS_CAP_UIDGID_NOMAP) {
 356                                 server->caps &= ~NFS_CAP_UIDGID_NOMAP;
 357                                 exception->retry = 1;
 358                                 printk(KERN_WARNING "NFS: v4 server %s "
 359                                                 "does not accept raw "
 360                                                 "uid/gids. "
 361                                                 "Reenabling the idmapper.\n",
 362                                                 server->nfs_client->cl_hostname);
 363                         }
 364         }
 365         /* We failed to handle the error */
 366         return nfs4_map_errors(ret);
 367 wait_on_recovery:
 368         ret = nfs4_wait_clnt_recover(clp);
 369         if (ret == 0)
 370                 exception->retry = 1;
 371         return ret;
 372 }
 373
 374
 375 static void do_renew_lease(struct nfs_client *clp, unsigned long timestamp)
 376 {
 377         spin_lock(&clp->cl_lock);
 378         if (time_before(clp->cl_last_renewal,timestamp))
 379                 clp->cl_last_renewal = timestamp;
 380         spin_unlock(&clp->cl_lock);
 381 }
 382
 383 static void renew_lease(const struct nfs_server *server, unsigned long timestamp)
 384 {
 385         do_renew_lease(server->nfs_client, timestamp);
 386 }
 387
 388 #if defined(CONFIG_NFS_V4_1)
 389
 390 static void nfs41_sequence_free_slot(struct nfs4_sequence_res *res)
 391 {
 392         struct nfs4_session *session;
 393         struct nfs4_slot_table *tbl;
 394         bool send_new_highest_used_slotid = false;
 395
 396         if (!res->sr_slot) {
 397                 /* just wake up the next guy waiting since
 398                  * we may have not consumed a slot after all */
 399                 dprintk("%s: No slot\n", __func__);
 400                 return;
 401         }
 402         tbl = res->sr_slot->table;
 403         session = tbl->session;
 404
 405         spin_lock(&tbl->slot_tbl_lock);
 406         /* Be nice to the server: try to ensure that the last transmitted
 407          * value for highest_user_slotid <= target_highest_slotid
 408          */
 409         if (tbl->highest_used_slotid > tbl->target_highest_slotid)
 410                 send_new_highest_used_slotid = true;
 411
 412         if (nfs41_wake_and_assign_slot(tbl, res->sr_slot)) {
 413                 send_new_highest_used_slotid = false;
 414                 goto out_unlock;
 415         }
 416         nfs4_free_slot(tbl, res->sr_slot);
 417
 418         if (tbl->highest_used_slotid != NFS4_NO_SLOT)
 419                 send_new_highest_used_slotid = false;
 420 out_unlock:
 421         spin_unlock(&tbl->slot_tbl_lock);
 422         res->sr_slot = NULL;
 423         if (send_new_highest_used_slotid)
 424                 nfs41_server_notify_highest_slotid_update(session->clp);
 425 }
 426
 427 static int nfs41_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)
 428 {
 429         struct nfs4_session *session;
 430         struct nfs4_slot *slot;
 431         struct nfs_client *clp;
 432         bool interrupted = false;
 433         int ret = 1;
 434
 435         /* don't increment the sequence number if the task wasn't sent */
 436         if (!RPC_WAS_SENT(task))
 437                 goto out;
 438
 439         slot = res->sr_slot;
 440         session = slot->table->session;
 441
 442         if (slot->interrupted) {
 443                 slot->interrupted = 0;
 444                 interrupted = true;
 445         }
 446
 447         /* Check the SEQUENCE operation status */
 448         switch (res->sr_status) {
 449         case 0:
 450                 /* Update the slot's sequence and clientid lease timer */
 451                 ++slot->seq_nr;
 452                 clp = session->clp;
 453                 do_renew_lease(clp, res->sr_timestamp);
 454                 /* Check sequence flags */
 455                 if (res->sr_status_flags != 0)
 456                         nfs4_schedule_lease_recovery(clp);
 457                 nfs41_update_target_slotid(slot->table, slot, res);
 458                 break;
 459         case 1:
 460                 /*
 461                  * sr_status remains 1 if an RPC level error occurred.
 462                  * The server may or may not have processed the sequence
 463                  * operation..
 464                  * Mark the slot as having hosted an interrupted RPC call.
 465                  */
 466                 slot->interrupted = 1;
 467                 goto out;
 468         case -NFS4ERR_DELAY:
 469                 /* The server detected a resend of the RPC call and
 470                  * returned NFS4ERR_DELAY as per Section 2.10.6.2
 471                  * of RFC5661.
 472                  */
 473                 dprintk("%s: slot=%u seq=%u: Operation in progress\n",
 474                         __func__,
 475                         slot->slot_nr,
 476                         slot->seq_nr);
 477                 goto out_retry;
 478         case -NFS4ERR_BADSLOT:
 479                 /*
 480                  * The slot id we used was probably retired. Try again
 481                  * using a different slot id.
 482                  */
 483                 goto retry_nowait;
 484         case -NFS4ERR_SEQ_MISORDERED:
 485                 /*
 486                  * Was the last operation on this sequence interrupted?
 487                  * If so, retry after bumping the sequence number.
 488                  */
 489                 if (interrupted) {
 490                         ++slot->seq_nr;
 491                         goto retry_nowait;
 492                 }
 493                 /*
 494                  * Could this slot have been previously retired?
 495                  * If so, then the server may be expecting seq_nr = 1!
 496                  */
 497                 if (slot->seq_nr != 1) {
 498                         slot->seq_nr = 1;
 499                         goto retry_nowait;
 500                 }
 501                 break;
 502         case -NFS4ERR_SEQ_FALSE_RETRY:
 503                 ++slot->seq_nr;
 504                 goto retry_nowait;
 505         default:
 506                 /* Just update the slot sequence no. */
 507                 ++slot->seq_nr;
 508         }
 509 out:
 510         /* The session may be reset by one of the error handlers. */
 511         dprintk("%s: Error %d free the slot \n", __func__, res->sr_status);
 512         nfs41_sequence_free_slot(res);
 513         return ret;
 514 retry_nowait:
 515         if (rpc_restart_call_prepare(task)) {
 516                 task->tk_status = 0;
 517                 ret = 0;
 518         }
 519         goto out;
 520 out_retry:
 521         if (!rpc_restart_call(task))
 522                 goto out;
 523         rpc_delay(task, NFS4_POLL_RETRY_MAX);
 524         return 0;
 525 }
 526
 527 static int nfs4_sequence_done(struct rpc_task *task,
 528                                struct nfs4_sequence_res *res)
 529 {
 530         if (res->sr_slot == NULL)
 531                 return 1;
 532         return nfs41_sequence_done(task, res);
 533 }
 534
 535 static void nfs41_init_sequence(struct nfs4_sequence_args *args,
 536                 struct nfs4_sequence_res *res, int cache_reply)
 537 {
 538         args->sa_slot = NULL;
 539         args->sa_cache_this = 0;
 540         args->sa_privileged = 0;
 541         if (cache_reply)
 542                 args->sa_cache_this = 1;
 543         res->sr_slot = NULL;
 544 }
 545
 546 static void nfs4_set_sequence_privileged(struct nfs4_sequence_args *args)
 547 {
 548         args->sa_privileged = 1;
 549 }
 550
 551 int nfs41_setup_sequence(struct nfs4_session *session,
 552                                 struct nfs4_sequence_args *args,
 553                                 struct nfs4_sequence_res *res,
 554                                 struct rpc_task *task)
 555 {
 556         struct nfs4_slot *slot;
 557         struct nfs4_slot_table *tbl;
 558
 559         dprintk("--> %s\n", __func__);
 560         /* slot already allocated? */
 561         if (res->sr_slot != NULL)
 562                 goto out_success;
 563
 564         tbl = &session->fc_slot_table;
 565
 566         task->tk_timeout = 0;
 567
 568         spin_lock(&tbl->slot_tbl_lock);
 569         if (test_bit(NFS4_SESSION_DRAINING, &session->session_state) &&
 570             !args->sa_privileged) {
 571                 /* The state manager will wait until the slot table is empty */
 572                 dprintk("%s session is draining\n", __func__);
 573                 goto out_sleep;
 574         }
 575
 576         slot = nfs4_alloc_slot(tbl);
 577         if (IS_ERR(slot)) {
 578                 /* If out of memory, try again in 1/4 second */
 579                 if (slot == ERR_PTR(-ENOMEM))
 580                         task->tk_timeout = HZ >> 2;
 581                 dprintk("<-- %s: no free slots\n", __func__);
 582                 goto out_sleep;
 583         }
 584         spin_unlock(&tbl->slot_tbl_lock);
 585
 586         args->sa_slot = slot;
 587
 588         dprintk("<-- %s slotid=%d seqid=%d\n", __func__,
 589                         slot->slot_nr, slot->seq_nr);
 590
 591         res->sr_slot = slot;
 592         res->sr_timestamp = jiffies;
 593         res->sr_status_flags = 0;
 594         /*
 595          * sr_status is only set in decode_sequence, and so will remain
 596          * set to 1 if an rpc level failure occurs.
 597          */
 598         res->sr_status = 1;
 599 out_success:
 600         rpc_call_start(task);
 601         return 0;
 602 out_sleep:
 603         /* Privileged tasks are queued with top priority */
 604         if (args->sa_privileged)
 605                 rpc_sleep_on_priority(&tbl->slot_tbl_waitq, task,
 606                                 NULL, RPC_PRIORITY_PRIVILEGED);
 607         else
 608                 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);
 609         spin_unlock(&tbl->slot_tbl_lock);
 610         return -EAGAIN;
 611 }
 612 EXPORT_SYMBOL_GPL(nfs41_setup_sequence);
 613
 614 int nfs4_setup_sequence(const struct nfs_server *server,
 615                         struct nfs4_sequence_args *args,
 616                         struct nfs4_sequence_res *res,
 617                         struct rpc_task *task)
 618 {
 619         struct nfs4_session *session = nfs4_get_session(server);
 620         int ret = 0;
 621
 622         if (session == NULL) {
 623                 rpc_call_start(task);
 624                 goto out;
 625         }
 626
 627         dprintk("--> %s clp %p session %p sr_slot %d\n",
 628                 __func__, session->clp, session, res->sr_slot ?
 629                         res->sr_slot->slot_nr : -1);
 630
 631         ret = nfs41_setup_sequence(session, args, res, task);
 632 out:
 633         dprintk("<-- %s status=%d\n", __func__, ret);
 634         return ret;
 635 }
 636
 637 struct nfs41_call_sync_data {
 638         const struct nfs_server *seq_server;
 639         struct nfs4_sequence_args *seq_args;
 640         struct nfs4_sequence_res *seq_res;
 641 };
 642
 643 static void nfs41_call_sync_prepare(struct rpc_task *task, void *calldata)
 644 {
 645         struct nfs41_call_sync_data *data = calldata;
 646         struct nfs4_session *session = nfs4_get_session(data->seq_server);
 647
 648         dprintk("--> %s data->seq_server %p\n", __func__, data->seq_server);
 649
 650         nfs41_setup_sequence(session, data->seq_args, data->seq_res, task);
 651 }
 652
 653 static void nfs41_call_sync_done(struct rpc_task *task, void *calldata)
 654 {
 655         struct nfs41_call_sync_data *data = calldata;
 656
 657         nfs41_sequence_done(task, data->seq_res);
 658 }
 659
 660 static const struct rpc_call_ops nfs41_call_sync_ops = {
 661         .rpc_call_prepare = nfs41_call_sync_prepare,
 662         .rpc_call_done = nfs41_call_sync_done,
 663 };
 664
 665 static int nfs4_call_sync_sequence(struct rpc_clnt *clnt,
 666                                    struct nfs_server *server,
 667                                    struct rpc_message *msg,
 668                                    struct nfs4_sequence_args *args,
 669                                    struct nfs4_sequence_res *res)
 670 {
 671         int ret;
 672         struct rpc_task *task;
 673         struct nfs41_call_sync_data data = {
 674                 .seq_server = server,
 675                 .seq_args = args,
 676                 .seq_res = res,
 677         };
 678         struct rpc_task_setup task_setup = {
 679                 .rpc_client = clnt,
 680                 .rpc_message = msg,
 681                 .callback_ops = &nfs41_call_sync_ops,
 682                 .callback_data = &data
 683         };
 684
 685         task = rpc_run_task(&task_setup);
 686         if (IS_ERR(task))
 687                 ret = PTR_ERR(task);
 688         else {
 689                 ret = task->tk_status;
 690                 rpc_put_task(task);
 691         }
 692         return ret;
 693 }
 694
 695 #else
 696 static
 697 void nfs41_init_sequence(struct nfs4_sequence_args *args,
 698                 struct nfs4_sequence_res *res, int cache_reply)
 699 {
 700 }
 701
 702 static void nfs4_set_sequence_privileged(struct nfs4_sequence_args *args)
 703 {
 704 }
 705
 706
 707 static int nfs4_sequence_done(struct rpc_task *task,
 708                                struct nfs4_sequence_res *res)
 709 {
 710         return 1;
 711 }
 712 #endif /* CONFIG_NFS_V4_1 */
 713
 714 static
 715 int _nfs4_call_sync(struct rpc_clnt *clnt,
 716                     struct nfs_server *server,
 717                     struct rpc_message *msg,
 718                     struct nfs4_sequence_args *args,
 719                     struct nfs4_sequence_res *res)
 720 {
 721         return rpc_call_sync(clnt, msg, 0);
 722 }
 723
 724 static
 725 int nfs4_call_sync(struct rpc_clnt *clnt,
 726                    struct nfs_server *server,
 727                    struct rpc_message *msg,
 728                    struct nfs4_sequence_args *args,
 729                    struct nfs4_sequence_res *res,
 730                    int cache_reply)
 731 {
 732         nfs41_init_sequence(args, res, cache_reply);
 733         return server->nfs_client->cl_mvops->call_sync(clnt, server, msg,
 734                                                 args, res);
 735 }
 736
 737 static void update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo)
 738 {
 739         struct nfs_inode *nfsi = NFS_I(dir);
 740
 741         spin_lock(&dir->i_lock);
 742         nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
 743         if (!cinfo->atomic || cinfo->before != dir->i_version)
 744                 nfs_force_lookup_revalidate(dir);
 745         dir->i_version = cinfo->after;
 746         nfs_fscache_invalidate(dir);
 747         spin_unlock(&dir->i_lock);
 748 }
 749
 750 struct nfs4_opendata {
 751         struct kref kref;
 752         struct nfs_openargs o_arg;
 753         struct nfs_openres o_res;
 754         struct nfs_open_confirmargs c_arg;
 755         struct nfs_open_confirmres c_res;
 756         struct nfs4_string owner_name;
 757         struct nfs4_string group_name;
 758         struct nfs_fattr f_attr;
 759         struct dentry *dir;
 760         struct dentry *dentry;
 761         struct nfs4_state_owner *owner;
 762         struct nfs4_state *state;
 763         struct iattr attrs;
 764         unsigned long timestamp;
 765         unsigned int rpc_done : 1;
 766         int rpc_status;
 767         int cancelled;
 768 };
 769
 770 static bool nfs4_clear_cap_atomic_open_v1(struct nfs_server *server,
 771                 int err, struct nfs4_exception *exception)
 772 {
 773         if (err != -EINVAL)
 774                 return false;
 775         if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1))
 776                 return false;
 777         server->caps &= ~NFS_CAP_ATOMIC_OPEN_V1;
 778         exception->retry = 1;
 779         return true;
 780 }
 781
 782 static enum open_claim_type4
 783 nfs4_map_atomic_open_claim(struct nfs_server *server,
 784                 enum open_claim_type4 claim)
 785 {
 786         if (server->caps & NFS_CAP_ATOMIC_OPEN_V1)
 787                 return claim;
 788         switch (claim) {
 789         default:
 790                 return claim;
 791         case NFS4_OPEN_CLAIM_FH:
 792                 return NFS4_OPEN_CLAIM_NULL;
 793         case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
 794                 return NFS4_OPEN_CLAIM_DELEGATE_CUR;
 795         case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
 796                 return NFS4_OPEN_CLAIM_DELEGATE_PREV;
 797         }
 798 }
 799
 800 static void nfs4_init_opendata_res(struct nfs4_opendata *p)
 801 {
 802         p->o_res.f_attr = &p->f_attr;
 803         p->o_res.seqid = p->o_arg.seqid;
 804         p->c_res.seqid = p->c_arg.seqid;
 805         p->o_res.server = p->o_arg.server;
 806         p->o_res.access_request = p->o_arg.access;
 807         nfs_fattr_init(&p->f_attr);
 808         nfs_fattr_init_names(&p->f_attr, &p->owner_name, &p->group_name);
 809 }
 810
 811 static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
 812                 struct nfs4_state_owner *sp, fmode_t fmode, int flags,
 813                 const struct iattr *attrs,
 814                 enum open_claim_type4 claim,
 815                 gfp_t gfp_mask)
 816 {
 817         struct dentry *parent = dget_parent(dentry);
 818         struct inode *dir = parent->d_inode;
 819         struct nfs_server *server = NFS_SERVER(dir);
 820         struct nfs4_opendata *p;
 821
 822         p = kzalloc(sizeof(*p), gfp_mask);
 823         if (p == NULL)
 824                 goto err;
 825         p->o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid, gfp_mask);
 826         if (p->o_arg.seqid == NULL)
 827                 goto err_free;
 828         nfs_sb_active(dentry->d_sb);
 829         p->dentry = dget(dentry);
 830         p->dir = parent;
 831         p->owner = sp;
 832         atomic_inc(&sp->so_count);
 833         p->o_arg.open_flags = flags;
 834         p->o_arg.fmode = fmode & (FMODE_READ|FMODE_WRITE);
 835         /* don't put an ACCESS op in OPEN compound if O_EXCL, because ACCESS
 836          * will return permission denied for all bits until close */
 837         if (!(flags & O_EXCL)) {
 838                 /* ask server to check for all possible rights as results
 839                  * are cached */
 840                 p->o_arg.access = NFS4_ACCESS_READ | NFS4_ACCESS_MODIFY |
 841                                   NFS4_ACCESS_EXTEND | NFS4_ACCESS_EXECUTE;
 842         }
 843         p->o_arg.clientid = server->nfs_client->cl_clientid;
 844         p->o_arg.id.create_time = ktime_to_ns(sp->so_seqid.create_time);
 845         p->o_arg.id.uniquifier = sp->so_seqid.owner_id;
 846         p->o_arg.name = &dentry->d_name;
 847         p->o_arg.server = server;
 848         p->o_arg.bitmask = server->attr_bitmask;
 849         p->o_arg.open_bitmap = &nfs4_fattr_bitmap[0];
 850         p->o_arg.claim = nfs4_map_atomic_open_claim(server, claim);
 851         switch (p->o_arg.claim) {
 852         case NFS4_OPEN_CLAIM_NULL:
 853         case NFS4_OPEN_CLAIM_DELEGATE_CUR:
 854         case NFS4_OPEN_CLAIM_DELEGATE_PREV:
 855                 p->o_arg.fh = NFS_FH(dir);
 856                 break;
 857         case NFS4_OPEN_CLAIM_PREVIOUS:
 858         case NFS4_OPEN_CLAIM_FH:
 859         case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
 860         case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
 861                 p->o_arg.fh = NFS_FH(dentry->d_inode);
 862         }
 863         if (attrs != NULL && attrs->ia_valid != 0) {
 864                 __be32 verf[2];
 865
 866                 p->o_arg.u.attrs = &p->attrs;
 867                 memcpy(&p->attrs, attrs, sizeof(p->attrs));
 868
 869                 verf[0] = jiffies;
 870                 verf[1] = current->pid;
 871                 memcpy(p->o_arg.u.verifier.data, verf,
 872                                 sizeof(p->o_arg.u.verifier.data));
 873         }
 874         p->c_arg.fh = &p->o_res.fh;
 875         p->c_arg.stateid = &p->o_res.stateid;
 876         p->c_arg.seqid = p->o_arg.seqid;
 877         nfs4_init_opendata_res(p);
 878         kref_init(&p->kref);
 879         return p;
 880 err_free:
 881         kfree(p);
 882 err:
 883         dput(parent);
 884         return NULL;
 885 }
 886
 887 static void nfs4_opendata_free(struct kref *kref)
 888 {
 889         struct nfs4_opendata *p = container_of(kref,
 890                         struct nfs4_opendata, kref);
 891         struct super_block *sb = p->dentry->d_sb;
 892
 893         nfs_free_seqid(p->o_arg.seqid);
 894         if (p->state != NULL)
 895                 nfs4_put_open_state(p->state);
 896         nfs4_put_state_owner(p->owner);
 897         dput(p->dir);
 898         dput(p->dentry);
 899         nfs_sb_deactive(sb);
 900         nfs_fattr_free_names(&p->f_attr);
 901         kfree(p);
 902 }
 903
 904 static void nfs4_opendata_put(struct nfs4_opendata *p)
 905 {
 906         if (p != NULL)
 907                 kref_put(&p->kref, nfs4_opendata_free);
 908 }
 909
 910 static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task)
 911 {
 912         int ret;
 913
 914         ret = rpc_wait_for_completion_task(task);
 915         return ret;
 916 }
 917
 918 static int can_open_cached(struct nfs4_state *state, fmode_t mode, int open_mode)
 919 {
 920         int ret = 0;
 921
 922         if (open_mode & (O_EXCL|O_TRUNC))
 923                 goto out;
 924         switch (mode & (FMODE_READ|FMODE_WRITE)) {
 925                 case FMODE_READ:
 926                         ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0
 927                                 && state->n_rdonly != 0;
 928                         break;
 929                 case FMODE_WRITE:
 930                         ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0
 931                                 && state->n_wronly != 0;
 932                         break;
 933                 case FMODE_READ|FMODE_WRITE:
 934                         ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0
 935                                 && state->n_rdwr != 0;
 936         }
 937 out:
 938         return ret;
 939 }
 940
 941 static int can_open_delegated(struct nfs_delegation *delegation, fmode_t fmode)
 942 {
 943         if (delegation == NULL)
 944                 return 0;
 945         if ((delegation->type & fmode) != fmode)
 946                 return 0;
 947         if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags))
 948                 return 0;
 949         if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
 950                 return 0;
 951         nfs_mark_delegation_referenced(delegation);
 952         return 1;
 953 }
 954
 955 static void update_open_stateflags(struct nfs4_state *state, fmode_t fmode)
 956 {
 957         switch (fmode) {
 958                 case FMODE_WRITE:
 959                         state->n_wronly++;
 960                         break;
 961                 case FMODE_READ:
 962                         state->n_rdonly++;
 963                         break;
 964                 case FMODE_READ|FMODE_WRITE:
 965                         state->n_rdwr++;
 966         }
 967         nfs4_state_set_mode_locked(state, state->state | fmode);
 968 }
 969
 970 static void nfs_set_open_stateid_locked(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode)
 971 {
 972         if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
 973                 nfs4_stateid_copy(&state->stateid, stateid);
 974         nfs4_stateid_copy(&state->open_stateid, stateid);
 975         switch (fmode) {
 976                 case FMODE_READ:
 977                         set_bit(NFS_O_RDONLY_STATE, &state->flags);
 978                         break;
 979                 case FMODE_WRITE:
 980                         set_bit(NFS_O_WRONLY_STATE, &state->flags);
 981                         break;
 982                 case FMODE_READ|FMODE_WRITE:
 983                         set_bit(NFS_O_RDWR_STATE, &state->flags);
 984         }
 985 }
 986
 987 static void nfs_set_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode)
 988 {
 989         write_seqlock(&state->seqlock);
 990         nfs_set_open_stateid_locked(state, stateid, fmode);
 991         write_sequnlock(&state->seqlock);
 992 }
 993
 994 static void __update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, const nfs4_stateid *deleg_stateid, fmode_t fmode)
 995 {
 996         /*
 997          * Protect the call to nfs4_state_set_mode_locked and
 998          * serialise the stateid update
 999          */
1000         write_seqlock(&state->seqlock);
1001         if (deleg_stateid != NULL) {
1002                 nfs4_stateid_copy(&state->stateid, deleg_stateid);
1003                 set_bit(NFS_DELEGATED_STATE, &state->flags);
1004         }
1005         if (open_stateid != NULL)
1006                 nfs_set_open_stateid_locked(state, open_stateid, fmode);
1007         write_sequnlock(&state->seqlock);
1008         spin_lock(&state->owner->so_lock);
1009         update_open_stateflags(state, fmode);
1010         spin_unlock(&state->owner->so_lock);
1011 }
1012
1013 static int update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, nfs4_stateid *delegation, fmode_t fmode)
1014 {
1015         struct nfs_inode *nfsi = NFS_I(state->inode);
1016         struct nfs_delegation *deleg_cur;
1017         int ret = 0;
1018
1019         fmode &= (FMODE_READ|FMODE_WRITE);
1020
1021         rcu_read_lock();
1022         deleg_cur = rcu_dereference(nfsi->delegation);
1023         if (deleg_cur == NULL)
1024                 goto no_delegation;
1025
1026         spin_lock(&deleg_cur->lock);
1027         if (nfsi->delegation != deleg_cur ||
1028            test_bit(NFS_DELEGATION_RETURNING, &deleg_cur->flags) ||
1029             (deleg_cur->type & fmode) != fmode)
1030                 goto no_delegation_unlock;
1031
1032         if (delegation == NULL)
1033                 delegation = &deleg_cur->stateid;
1034         else if (!nfs4_stateid_match(&deleg_cur->stateid, delegation))
1035                 goto no_delegation_unlock;
1036
1037         nfs_mark_delegation_referenced(deleg_cur);
1038         __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode);
1039         ret = 1;
1040 no_delegation_unlock:
1041         spin_unlock(&deleg_cur->lock);
1042 no_delegation:
1043         rcu_read_unlock();
1044
1045         if (!ret && open_stateid != NULL) {
1046                 __update_open_stateid(state, open_stateid, NULL, fmode);
1047                 ret = 1;
1048         }
1049
1050         return ret;
1051 }
1052
1053
1054 static void nfs4_return_incompatible_delegation(struct inode *inode, fmode_t fmode)
1055 {
1056         struct nfs_delegation *delegation;
1057
1058         rcu_read_lock();
1059         delegation = rcu_dereference(NFS_I(inode)->delegation);
1060         if (delegation == NULL || (delegation->type & fmode) == fmode) {
1061                 rcu_read_unlock();
1062                 return;
1063         }
1064         rcu_read_unlock();
1065         nfs4_inode_return_delegation(inode);
1066 }
1067
1068 static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata)
1069 {
1070         struct nfs4_state *state = opendata->state;
1071         struct nfs_inode *nfsi = NFS_I(state->inode);
1072         struct nfs_delegation *delegation;
1073         int open_mode = opendata->o_arg.open_flags & (O_EXCL|O_TRUNC);
1074         fmode_t fmode = opendata->o_arg.fmode;
1075         nfs4_stateid stateid;
1076         int ret = -EAGAIN;
1077
1078         for (;;) {
1079                 if (can_open_cached(state, fmode, open_mode)) {
1080                         spin_lock(&state->owner->so_lock);
1081                         if (can_open_cached(state, fmode, open_mode)) {
1082                                 update_open_stateflags(state, fmode);
1083                                 spin_unlock(&state->owner->so_lock);
1084                                 goto out_return_state;
1085                         }
1086                         spin_unlock(&state->owner->so_lock);
1087                 }
1088                 rcu_read_lock();
1089                 delegation = rcu_dereference(nfsi->delegation);
1090                 if (!can_open_delegated(delegation, fmode)) {
1091                         rcu_read_unlock();
1092                         break;
1093                 }
1094                 /* Save the delegation */
1095                 nfs4_stateid_copy(&stateid, &delegation->stateid);
1096                 rcu_read_unlock();
1097                 ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode);
1098                 if (ret != 0)
1099                         goto out;
1100                 ret = -EAGAIN;
1101
1102                 /* Try to update the stateid using the delegation */
1103                 if (update_open_stateid(state, NULL, &stateid, fmode))
1104                         goto out_return_state;
1105         }
1106 out:
1107         return ERR_PTR(ret);
1108 out_return_state:
1109         atomic_inc(&state->count);
1110         return state;
1111 }
1112
1113 static void
1114 nfs4_opendata_check_deleg(struct nfs4_opendata *data, struct nfs4_state *state)
1115 {
1116         struct nfs_client *clp = NFS_SERVER(state->inode)->nfs_client;
1117         struct nfs_delegation *delegation;
1118         int delegation_flags = 0;
1119
1120         rcu_read_lock();
1121         delegation = rcu_dereference(NFS_I(state->inode)->delegation);
1122         if (delegation)
1123                 delegation_flags = delegation->flags;
1124         rcu_read_unlock();
1125         if (data->o_arg.claim == NFS4_OPEN_CLAIM_DELEGATE_CUR) {
1126                 pr_err_ratelimited("NFS: Broken NFSv4 server %s is "
1127                                    "returning a delegation for "
1128                                    "OPEN(CLAIM_DELEGATE_CUR)\n",
1129                                    clp->cl_hostname);
1130         } else if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0)
1131                 nfs_inode_set_delegation(state->inode,
1132                                          data->owner->so_cred,
1133                                          &data->o_res);
1134         else
1135                 nfs_inode_reclaim_delegation(state->inode,
1136                                              data->owner->so_cred,
1137                                              &data->o_res);
1138 }
1139
1140 /*
1141  * Check the inode attributes against the CLAIM_PREVIOUS returned attributes
1142  * and update the nfs4_state.
1143  */
1144 static struct nfs4_state *
1145 _nfs4_opendata_reclaim_to_nfs4_state(struct nfs4_opendata *data)
1146 {
1147         struct inode *inode = data->state->inode;
1148         struct nfs4_state *state = data->state;
1149         int ret;
1150
1151         if (!data->rpc_done) {
1152                 ret = data->rpc_status;
1153                 goto err;
1154         }
1155
1156         ret = -ESTALE;
1157         if (!(data->f_attr.valid & NFS_ATTR_FATTR_TYPE) ||
1158             !(data->f_attr.valid & NFS_ATTR_FATTR_FILEID) ||
1159             !(data->f_attr.valid & NFS_ATTR_FATTR_CHANGE))
1160                 goto err;
1161
1162         ret = -ENOMEM;
1163         state = nfs4_get_open_state(inode, data->owner);
1164         if (state == NULL)
1165                 goto err;
1166
1167         ret = nfs_refresh_inode(inode, &data->f_attr);
1168         if (ret)
1169                 goto err;
1170
1171         if (data->o_res.delegation_type != 0)
1172                 nfs4_opendata_check_deleg(data, state);
1173         update_open_stateid(state, &data->o_res.stateid, NULL,
1174                             data->o_arg.fmode);
1175
1176         return state;
1177 err:
1178         return ERR_PTR(ret);
1179
1180 }
1181
1182 static struct nfs4_state *
1183 _nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
1184 {
1185         struct inode *inode;
1186         struct nfs4_state *state = NULL;
1187         int ret;
1188
1189         if (!data->rpc_done) {
1190                 state = nfs4_try_open_cached(data);
1191                 goto out;
1192         }
1193
1194         ret = -EAGAIN;
1195         if (!(data->f_attr.valid & NFS_ATTR_FATTR))
1196                 goto err;
1197         inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr);
1198         ret = PTR_ERR(inode);
1199         if (IS_ERR(inode))
1200                 goto err;
1201         ret = -ENOMEM;
1202         state = nfs4_get_open_state(inode, data->owner);
1203         if (state == NULL)
1204                 goto err_put_inode;
1205         if (data->o_res.delegation_type != 0)
1206                 nfs4_opendata_check_deleg(data, state);
1207         update_open_stateid(state, &data->o_res.stateid, NULL,
1208                         data->o_arg.fmode);
1209         iput(inode);
1210 out:
1211         nfs_release_seqid(data->o_arg.seqid);
1212         return state;
1213 err_put_inode:
1214         iput(inode);
1215 err:
1216         return ERR_PTR(ret);
1217 }
1218
1219 static struct nfs4_state *
1220 nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
1221 {
1222         if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS)
1223                 return _nfs4_opendata_reclaim_to_nfs4_state(data);
1224         return _nfs4_opendata_to_nfs4_state(data);
1225 }
1226
1227 static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *state)
1228 {
1229         struct nfs_inode *nfsi = NFS_I(state->inode);
1230         struct nfs_open_context *ctx;
1231
1232         spin_lock(&state->inode->i_lock);
1233         list_for_each_entry(ctx, &nfsi->open_files, list) {
1234                 if (ctx->state != state)
1235                         continue;
1236                 get_nfs_open_context(ctx);
1237                 spin_unlock(&state->inode->i_lock);
1238                 return ctx;
1239         }
1240         spin_unlock(&state->inode->i_lock);
1241         return ERR_PTR(-ENOENT);
1242 }
1243
1244 static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context *ctx,
1245                 struct nfs4_state *state, enum open_claim_type4 claim)
1246 {
1247         struct nfs4_opendata *opendata;
1248
1249         opendata = nfs4_opendata_alloc(ctx->dentry, state->owner, 0, 0,
1250                         NULL, claim, GFP_NOFS);
1251         if (opendata == NULL)
1252                 return ERR_PTR(-ENOMEM);
1253         opendata->state = state;
1254         atomic_inc(&state->count);
1255         return opendata;
1256 }
1257
1258 static int nfs4_open_recover_helper(struct nfs4_opendata *opendata, fmode_t fmode, struct nfs4_state **res)
1259 {
1260         struct nfs4_state *newstate;
1261         int ret;
1262
1263         opendata->o_arg.open_flags = 0;
1264         opendata->o_arg.fmode = fmode;
1265         memset(&opendata->o_res, 0, sizeof(opendata->o_res));
1266         memset(&opendata->c_res, 0, sizeof(opendata->c_res));
1267         nfs4_init_opendata_res(opendata);
1268         ret = _nfs4_recover_proc_open(opendata);
1269         if (ret != 0)
1270                 return ret;
1271         newstate = nfs4_opendata_to_nfs4_state(opendata);
1272         if (IS_ERR(newstate))
1273                 return PTR_ERR(newstate);
1274         nfs4_close_state(newstate, fmode);
1275         *res = newstate;
1276         return 0;
1277 }
1278
1279 static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *state)
1280 {
1281         struct nfs4_state *newstate;
1282         int ret;
1283
1284         /* memory barrier prior to reading state->n_* */
1285         clear_bit(NFS_DELEGATED_STATE, &state->flags);
1286         smp_rmb();
1287         if (state->n_rdwr != 0) {
1288                 clear_bit(NFS_O_RDWR_STATE, &state->flags);
1289                 ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE, &newstate);
1290                 if (ret != 0)
1291                         return ret;
1292                 if (newstate != state)
1293                         return -ESTALE;
1294         }
1295         if (state->n_wronly != 0) {
1296                 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1297                 ret = nfs4_open_recover_helper(opendata, FMODE_WRITE, &newstate);
1298                 if (ret != 0)
1299                         return ret;
1300                 if (newstate != state)
1301                         return -ESTALE;
1302         }
1303         if (state->n_rdonly != 0) {
1304                 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1305                 ret = nfs4_open_recover_helper(opendata, FMODE_READ, &newstate);
1306                 if (ret != 0)
1307                         return ret;
1308                 if (newstate != state)
1309                         return -ESTALE;
1310         }
1311         /*
1312          * We may have performed cached opens for all three recoveries.
1313          * Check if we need to update the current stateid.
1314          */
1315         if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 &&
1316             !nfs4_stateid_match(&state->stateid, &state->open_stateid)) {
1317                 write_seqlock(&state->seqlock);
1318                 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
1319                         nfs4_stateid_copy(&state->stateid, &state->open_stateid);
1320                 write_sequnlock(&state->seqlock);
1321         }
1322         return 0;
1323 }
1324
1325 /*
1326  * OPEN_RECLAIM:
1327  *      reclaim state on the server after a reboot.
1328  */
1329 static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
1330 {
1331         struct nfs_delegation *delegation;
1332         struct nfs4_opendata *opendata;
1333         fmode_t delegation_type = 0;
1334         int status;
1335
1336         opendata = nfs4_open_recoverdata_alloc(ctx, state,
1337                         NFS4_OPEN_CLAIM_PREVIOUS);
1338         if (IS_ERR(opendata))
1339                 return PTR_ERR(opendata);
1340         rcu_read_lock();
1341         delegation = rcu_dereference(NFS_I(state->inode)->delegation);
1342         if (delegation != NULL && test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) != 0)
1343                 delegation_type = delegation->type;
1344         rcu_read_unlock();
1345         opendata->o_arg.u.delegation_type = delegation_type;
1346         status = nfs4_open_recover(opendata, state);
1347         nfs4_opendata_put(opendata);
1348         return status;
1349 }
1350
1351 static int nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
1352 {
1353         struct nfs_server *server = NFS_SERVER(state->inode);
1354         struct nfs4_exception exception = { };
1355         int err;
1356         do {
1357                 err = _nfs4_do_open_reclaim(ctx, state);
1358                 if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
1359                         continue;
1360                 if (err != -NFS4ERR_DELAY)
1361                         break;
1362                 nfs4_handle_exception(server, err, &exception);
1363         } while (exception.retry);
1364         return err;
1365 }
1366
1367 static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state)
1368 {
1369         struct nfs_open_context *ctx;
1370         int ret;
1371
1372         ctx = nfs4_state_find_open_context(state);
1373         if (IS_ERR(ctx))
1374                 return PTR_ERR(ctx);
1375         ret = nfs4_do_open_reclaim(ctx, state);
1376         put_nfs_open_context(ctx);
1377         return ret;
1378 }
1379
1380 static int _nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)
1381 {
1382         struct nfs4_opendata *opendata;
1383         int ret;
1384
1385         opendata = nfs4_open_recoverdata_alloc(ctx, state,
1386                         NFS4_OPEN_CLAIM_DELEGATE_CUR);
1387         if (IS_ERR(opendata))
1388                 return PTR_ERR(opendata);
1389         nfs4_stateid_copy(&opendata->o_arg.u.delegation, stateid);
1390         ret = nfs4_open_recover(opendata, state);
1391         nfs4_opendata_put(opendata);
1392         return ret;
1393 }
1394
1395 int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)
1396 {
1397         struct nfs4_exception exception = { };
1398         struct nfs_server *server = NFS_SERVER(state->inode);
1399         int err;
1400         do {
1401                 err = _nfs4_open_delegation_recall(ctx, state, stateid);
1402                 switch (err) {
1403                         case 0:
1404                         case -ENOENT:
1405                         case -ESTALE:
1406                                 goto out;
1407                         case -NFS4ERR_BADSESSION:
1408                         case -NFS4ERR_BADSLOT:
1409                         case -NFS4ERR_BAD_HIGH_SLOT:
1410                         case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1411                         case -NFS4ERR_DEADSESSION:
1412                                 set_bit(NFS_DELEGATED_STATE, &state->flags);
1413                                 nfs4_schedule_session_recovery(server->nfs_client->cl_session, err);
1414                                 err = -EAGAIN;
1415                                 goto out;
1416                         case -NFS4ERR_STALE_CLIENTID:
1417                         case -NFS4ERR_STALE_STATEID:
1418                                 set_bit(NFS_DELEGATED_STATE, &state->flags);
1419                         case -NFS4ERR_EXPIRED:
1420                                 /* Don't recall a delegation if it was lost */
1421                                 nfs4_schedule_lease_recovery(server->nfs_client);
1422                                 err = -EAGAIN;
1423                                 goto out;
1424                         case -NFS4ERR_DELEG_REVOKED:
1425                         case -NFS4ERR_ADMIN_REVOKED:
1426                         case -NFS4ERR_BAD_STATEID:
1427                                 nfs_inode_find_state_and_recover(state->inode,
1428                                                 stateid);
1429                                 nfs4_schedule_stateid_recovery(server, state);
1430                         case -ENOMEM:
1431                                 err = 0;
1432                                 goto out;
1433                 }
1434                 set_bit(NFS_DELEGATED_STATE, &state->flags);
1435                 err = nfs4_handle_exception(server, err, &exception);
1436         } while (exception.retry);
1437 out:
1438         return err;
1439 }
1440
1441 static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata)
1442 {
1443         struct nfs4_opendata *data = calldata;
1444
1445         data->rpc_status = task->tk_status;
1446         if (data->rpc_status == 0) {
1447                 nfs4_stateid_copy(&data->o_res.stateid, &data->c_res.stateid);
1448                 nfs_confirm_seqid(&data->owner->so_seqid, 0);
1449                 renew_lease(data->o_res.server, data->timestamp);
1450                 data->rpc_done = 1;
1451         }
1452 }
1453
1454 static void nfs4_open_confirm_release(void *calldata)
1455 {
1456         struct nfs4_opendata *data = calldata;
1457         struct nfs4_state *state = NULL;
1458
1459         /* If this request hasn't been cancelled, do nothing */
1460         if (data->cancelled == 0)
1461                 goto out_free;
1462         /* In case of error, no cleanup! */
1463         if (!data->rpc_done)
1464                 goto out_free;
1465         state = nfs4_opendata_to_nfs4_state(data);
1466         if (!IS_ERR(state))
1467                 nfs4_close_state(state, data->o_arg.fmode);
1468 out_free:
1469         nfs4_opendata_put(data);
1470 }
1471
1472 static const struct rpc_call_ops nfs4_open_confirm_ops = {
1473         .rpc_call_done = nfs4_open_confirm_done,
1474         .rpc_release = nfs4_open_confirm_release,
1475 };
1476
1477 /*
1478  * Note: On error, nfs4_proc_open_confirm will free the struct nfs4_opendata
1479  */
1480 static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)
1481 {
1482         struct nfs_server *server = NFS_SERVER(data->dir->d_inode);
1483         struct rpc_task *task;
1484         struct  rpc_message msg = {
1485                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM],
1486                 .rpc_argp = &data->c_arg,
1487                 .rpc_resp = &data->c_res,
1488                 .rpc_cred = data->owner->so_cred,
1489         };
1490         struct rpc_task_setup task_setup_data = {
1491                 .rpc_client = server->client,
1492                 .rpc_message = &msg,
1493                 .callback_ops = &nfs4_open_confirm_ops,
1494                 .callback_data = data,
1495                 .workqueue = nfsiod_workqueue,
1496                 .flags = RPC_TASK_ASYNC,
1497         };
1498         int status;
1499
1500         kref_get(&data->kref);
1501         data->rpc_done = 0;
1502         data->rpc_status = 0;
1503         data->timestamp = jiffies;
1504         task = rpc_run_task(&task_setup_data);
1505         if (IS_ERR(task))
1506                 return PTR_ERR(task);
1507         status = nfs4_wait_for_completion_rpc_task(task);
1508         if (status != 0) {
1509                 data->cancelled = 1;
1510                 smp_wmb();
1511         } else
1512                 status = data->rpc_status;
1513         rpc_put_task(task);
1514         return status;
1515 }
1516
1517 static void nfs4_open_prepare(struct rpc_task *task, void *calldata)
1518 {
1519         struct nfs4_opendata *data = calldata;
1520         struct nfs4_state_owner *sp = data->owner;
1521
1522         if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0)
1523                 goto out_wait;
1524         /*
1525          * Check if we still need to send an OPEN call, or if we can use
1526          * a delegation instead.
1527          */
1528         if (data->state != NULL) {
1529                 struct nfs_delegation *delegation;
1530
1531                 if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags))
1532                         goto out_no_action;
1533                 rcu_read_lock();
1534                 delegation = rcu_dereference(NFS_I(data->state->inode)->delegation);
1535                 if (data->o_arg.claim != NFS4_OPEN_CLAIM_DELEGATE_CUR &&
1536                     can_open_delegated(delegation, data->o_arg.fmode))
1537                         goto unlock_no_action;
1538                 rcu_read_unlock();
1539         }
1540         /* Update client id. */
1541         data->o_arg.clientid = sp->so_server->nfs_client->cl_clientid;
1542         if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS) {
1543                 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR];
1544                 data->o_arg.open_bitmap = &nfs4_open_noattr_bitmap[0];
1545                 nfs_copy_fh(&data->o_res.fh, data->o_arg.fh);
1546         }
1547         data->timestamp = jiffies;
1548         if (nfs4_setup_sequence(data->o_arg.server,
1549                                 &data->o_arg.seq_args,
1550                                 &data->o_res.seq_res,
1551                                 task) != 0)
1552                 nfs_release_seqid(data->o_arg.seqid);
1553         return;
1554 unlock_no_action:
1555         rcu_read_unlock();
1556 out_no_action:
1557         task->tk_action = NULL;
1558 out_wait:
1559         nfs4_sequence_done(task, &data->o_res.seq_res);
1560 }
1561
1562 static void nfs4_open_done(struct rpc_task *task, void *calldata)
1563 {
1564         struct nfs4_opendata *data = calldata;
1565
1566         data->rpc_status = task->tk_status;
1567
1568         if (!nfs4_sequence_done(task, &data->o_res.seq_res))
1569                 return;
1570
1571         if (task->tk_status == 0) {
1572                 if (data->o_res.f_attr->valid & NFS_ATTR_FATTR_TYPE) {
1573                         switch (data->o_res.f_attr->mode & S_IFMT) {
1574                         case S_IFREG:
1575                                 break;
1576                         case S_IFLNK:
1577                                 data->rpc_status = -ELOOP;
1578                                 break;
1579                         case S_IFDIR:
1580                                 data->rpc_status = -EISDIR;
1581                                 break;
1582                         default:
1583                                 data->rpc_status = -ENOTDIR;
1584                         }
1585                 }
1586                 renew_lease(data->o_res.server, data->timestamp);
1587                 if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM))
1588                         nfs_confirm_seqid(&data->owner->so_seqid, 0);
1589         }
1590         data->rpc_done = 1;
1591 }
1592
1593 static void nfs4_open_release(void *calldata)
1594 {
1595         struct nfs4_opendata *data = calldata;
1596         struct nfs4_state *state = NULL;
1597
1598         /* If this request hasn't been cancelled, do nothing */
1599         if (data->cancelled == 0)
1600                 goto out_free;
1601         /* In case of error, no cleanup! */
1602         if (data->rpc_status != 0 || !data->rpc_done)
1603                 goto out_free;
1604         /* In case we need an open_confirm, no cleanup! */
1605         if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)
1606                 goto out_free;
1607         state = nfs4_opendata_to_nfs4_state(data);
1608         if (!IS_ERR(state))
1609                 nfs4_close_state(state, data->o_arg.fmode);
1610 out_free:
1611         nfs4_opendata_put(data);
1612 }
1613
1614 static const struct rpc_call_ops nfs4_open_ops = {
1615         .rpc_call_prepare = nfs4_open_prepare,
1616         .rpc_call_done = nfs4_open_done,
1617         .rpc_release = nfs4_open_release,
1618 };
1619
1620 static int nfs4_run_open_task(struct nfs4_opendata *data, int isrecover)
1621 {
1622         struct inode *dir = data->dir->d_inode;
1623         struct nfs_server *server = NFS_SERVER(dir);
1624         struct nfs_openargs *o_arg = &data->o_arg;
1625         struct nfs_openres *o_res = &data->o_res;
1626         struct rpc_task *task;
1627         struct rpc_message msg = {
1628                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN],
1629                 .rpc_argp = o_arg,
1630                 .rpc_resp = o_res,
1631                 .rpc_cred = data->owner->so_cred,
1632         };
1633         struct rpc_task_setup task_setup_data = {
1634                 .rpc_client = server->client,
1635                 .rpc_message = &msg,
1636                 .callback_ops = &nfs4_open_ops,
1637                 .callback_data = data,
1638                 .workqueue = nfsiod_workqueue,
1639                 .flags = RPC_TASK_ASYNC,
1640         };
1641         int status;
1642
1643         nfs41_init_sequence(&o_arg->seq_args, &o_res->seq_res, 1);
1644         kref_get(&data->kref);
1645         data->rpc_done = 0;
1646         data->rpc_status = 0;
1647         data->cancelled = 0;
1648         if (isrecover)
1649                 nfs4_set_sequence_privileged(&o_arg->seq_args);
1650         task = rpc_run_task(&task_setup_data);
1651         if (IS_ERR(task))
1652                 return PTR_ERR(task);
1653         status = nfs4_wait_for_completion_rpc_task(task);
1654         if (status != 0) {
1655                 data->cancelled = 1;
1656                 smp_wmb();
1657         } else
1658                 status = data->rpc_status;
1659         rpc_put_task(task);
1660
1661         return status;
1662 }
1663
1664 static int _nfs4_recover_proc_open(struct nfs4_opendata *data)
1665 {
1666         struct inode *dir = data->dir->d_inode;
1667         struct nfs_openres *o_res = &data->o_res;
1668         int status;
1669
1670         status = nfs4_run_open_task(data, 1);
1671         if (status != 0 || !data->rpc_done)
1672                 return status;
1673
1674         nfs_fattr_map_and_free_names(NFS_SERVER(dir), &data->f_attr);
1675
1676         if (o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
1677                 status = _nfs4_proc_open_confirm(data);
1678                 if (status != 0)
1679                         return status;
1680         }
1681
1682         return status;
1683 }
1684
1685 static int nfs4_opendata_access(struct rpc_cred *cred,
1686                                 struct nfs4_opendata *opendata,
1687                                 struct nfs4_state *state, fmode_t fmode,
1688                                 int openflags)
1689 {
1690         struct nfs_access_entry cache;
1691         u32 mask;
1692
1693         /* access call failed or for some reason the server doesn't
1694          * support any access modes -- defer access call until later */
1695         if (opendata->o_res.access_supported == 0)
1696                 return 0;
1697
1698         mask = 0;
1699         /* don't check MAY_WRITE - a newly created file may not have
1700          * write mode bits, but POSIX allows the creating process to write.
1701          * use openflags to check for exec, because fmode won't
1702          * always have FMODE_EXEC set when file open for exec. */
1703         if (openflags & __FMODE_EXEC) {
1704                 /* ONLY check for exec rights */
1705                 mask = MAY_EXEC;
1706         } else if (fmode & FMODE_READ)
1707                 mask = MAY_READ;
1708
1709         cache.cred = cred;
1710         cache.jiffies = jiffies;
1711         nfs_access_set_mask(&cache, opendata->o_res.access_result);
1712         nfs_access_add_cache(state->inode, &cache);
1713
1714         if ((mask & ~cache.mask & (MAY_READ | MAY_EXEC)) == 0)
1715                 return 0;
1716
1717         /* even though OPEN succeeded, access is denied. Close the file */
1718         nfs4_close_state(state, fmode);
1719         return -EACCES;
1720 }
1721
1722 /*
1723  * Note: On error, nfs4_proc_open will free the struct nfs4_opendata
1724  */
1725 static int _nfs4_proc_open(struct nfs4_opendata *data)
1726 {
1727         struct inode *dir = data->dir->d_inode;
1728         struct nfs_server *server = NFS_SERVER(dir);
1729         struct nfs_openargs *o_arg = &data->o_arg;
1730         struct nfs_openres *o_res = &data->o_res;
1731         int status;
1732
1733         status = nfs4_run_open_task(data, 0);
1734         if (!data->rpc_done)
1735                 return status;
1736         if (status != 0) {
1737                 if (status == -NFS4ERR_BADNAME &&
1738                                 !(o_arg->open_flags & O_CREAT))
1739                         return -ENOENT;
1740                 return status;
1741         }
1742
1743         nfs_fattr_map_and_free_names(server, &data->f_attr);
1744
1745         if (o_arg->open_flags & O_CREAT)
1746                 update_changeattr(dir, &o_res->cinfo);
1747         if ((o_res->rflags & NFS4_OPEN_RESULT_LOCKTYPE_POSIX) == 0)
1748                 server->caps &= ~NFS_CAP_POSIX_LOCK;
1749         if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
1750                 status = _nfs4_proc_open_confirm(data);
1751                 if (status != 0)
1752                         return status;
1753         }
1754         if (!(o_res->f_attr->valid & NFS_ATTR_FATTR))
1755                 _nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr);
1756         return 0;
1757 }
1758
1759 static int nfs4_recover_expired_lease(struct nfs_server *server)
1760 {
1761         return nfs4_client_recover_expired_lease(server->nfs_client);
1762 }
1763
1764 /*
1765  * OPEN_EXPIRED:
1766  *      reclaim state on the server after a network partition.
1767  *      Assumes caller holds the appropriate lock
1768  */
1769 static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
1770 {
1771         struct nfs4_opendata *opendata;
1772         int ret;
1773
1774         opendata = nfs4_open_recoverdata_alloc(ctx, state,
1775                         NFS4_OPEN_CLAIM_FH);
1776         if (IS_ERR(opendata))
1777                 return PTR_ERR(opendata);
1778         ret = nfs4_open_recover(opendata, state);
1779         if (ret == -ESTALE)
1780                 d_drop(ctx->dentry);
1781         nfs4_opendata_put(opendata);
1782         return ret;
1783 }
1784
1785 static int nfs4_do_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
1786 {
1787         struct nfs_server *server = NFS_SERVER(state->inode);
1788         struct nfs4_exception exception = { };
1789         int err;
1790
1791         do {
1792                 err = _nfs4_open_expired(ctx, state);
1793                 if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
1794                         continue;
1795                 switch (err) {
1796                 default:
1797                         goto out;
1798                 case -NFS4ERR_GRACE:
1799                 case -NFS4ERR_DELAY:
1800                         nfs4_handle_exception(server, err, &exception);
1801                         err = 0;
1802                 }
1803         } while (exception.retry);
1804 out:
1805         return err;
1806 }
1807
1808 static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
1809 {
1810         struct nfs_open_context *ctx;
1811         int ret;
1812
1813         ctx = nfs4_state_find_open_context(state);
1814         if (IS_ERR(ctx))
1815                 return PTR_ERR(ctx);
1816         ret = nfs4_do_open_expired(ctx, state);
1817         put_nfs_open_context(ctx);
1818         return ret;
1819 }
1820
1821 #if defined(CONFIG_NFS_V4_1)
1822 static void nfs41_clear_delegation_stateid(struct nfs4_state *state)
1823 {
1824         struct nfs_server *server = NFS_SERVER(state->inode);
1825         nfs4_stateid *stateid = &state->stateid;
1826         int status;
1827
1828         /* If a state reset has been done, test_stateid is unneeded */
1829         if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
1830                 return;
1831
1832         status = nfs41_test_stateid(server, stateid);
1833         if (status != NFS_OK) {
1834                 /* Free the stateid unless the server explicitly
1835                  * informs us the stateid is unrecognized. */
1836                 if (status != -NFS4ERR_BAD_STATEID)
1837                         nfs41_free_stateid(server, stateid);
1838                 nfs_remove_bad_delegation(state->inode);
1839
1840                 write_seqlock(&state->seqlock);
1841                 nfs4_stateid_copy(&state->stateid, &state->open_stateid);
1842                 write_sequnlock(&state->seqlock);
1843                 clear_bit(NFS_DELEGATED_STATE, &state->flags);
1844         }
1845 }
1846
1847 /**
1848  * nfs41_check_open_stateid - possibly free an open stateid
1849  *
1850  * @state: NFSv4 state for an inode
1851  *
1852  * Returns NFS_OK if recovery for this stateid is now finished.
1853  * Otherwise a negative NFS4ERR value is returned.
1854  */
1855 static int nfs41_check_open_stateid(struct nfs4_state *state)
1856 {
1857         struct nfs_server *server = NFS_SERVER(state->inode);
1858         nfs4_stateid *stateid = &state->open_stateid;
1859         int status;
1860
1861         /* If a state reset has been done, test_stateid is unneeded */
1862         if ((test_bit(NFS_O_RDONLY_STATE, &state->flags) == 0) &&
1863             (test_bit(NFS_O_WRONLY_STATE, &state->flags) == 0) &&
1864             (test_bit(NFS_O_RDWR_STATE, &state->flags) == 0))
1865                 return -NFS4ERR_BAD_STATEID;
1866
1867         status = nfs41_test_stateid(server, stateid);
1868         if (status != NFS_OK) {
1869                 /* Free the stateid unless the server explicitly
1870                  * informs us the stateid is unrecognized. */
1871                 if (status != -NFS4ERR_BAD_STATEID)
1872                         nfs41_free_stateid(server, stateid);
1873
1874                 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1875                 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1876                 clear_bit(NFS_O_RDWR_STATE, &state->flags);
1877         }
1878         return status;
1879 }
1880
1881 static int nfs41_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
1882 {
1883         int status;
1884
1885         nfs41_clear_delegation_stateid(state);
1886         status = nfs41_check_open_stateid(state);
1887         if (status != NFS_OK)
1888                 status = nfs4_open_expired(sp, state);
1889         return status;
1890 }
1891 #endif
1892
1893 /*
1894  * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*
1895  * fields corresponding to attributes that were used to store the verifier.
1896  * Make sure we clobber those fields in the later setattr call
1897  */
1898 static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata, struct iattr *sattr)
1899 {
1900         if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_ACCESS) &&
1901             !(sattr->ia_valid & ATTR_ATIME_SET))
1902                 sattr->ia_valid |= ATTR_ATIME;
1903
1904         if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_MODIFY) &&
1905             !(sattr->ia_valid & ATTR_MTIME_SET))
1906                 sattr->ia_valid |= ATTR_MTIME;
1907 }
1908
1909 static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata,
1910                 fmode_t fmode,
1911                 int flags,
1912                 struct nfs4_state **res)
1913 {
1914         struct nfs4_state_owner *sp = opendata->owner;
1915         struct nfs_server *server = sp->so_server;
1916         struct nfs4_state *state;
1917         unsigned int seq;
1918         int ret;
1919
1920         seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
1921
1922         ret = _nfs4_proc_open(opendata);
1923         if (ret != 0)
1924                 goto out;
1925
1926         state = nfs4_opendata_to_nfs4_state(opendata);
1927         ret = PTR_ERR(state);
1928         if (IS_ERR(state))
1929                 goto out;
1930         if (server->caps & NFS_CAP_POSIX_LOCK)
1931                 set_bit(NFS_STATE_POSIX_LOCKS, &state->flags);
1932
1933         ret = nfs4_opendata_access(sp->so_cred, opendata, state, fmode, flags);
1934         if (ret != 0)
1935                 goto out;
1936
1937         if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq)) {
1938                 nfs4_schedule_stateid_recovery(server, state);
1939                 nfs4_wait_clnt_recover(server->nfs_client);
1940         }
1941         *res = state;
1942 out:
1943         return ret;
1944 }
1945
1946 /*
1947  * Returns a referenced nfs4_state
1948  */
1949 static int _nfs4_do_open(struct inode *dir,
1950                         struct dentry *dentry,
1951                         fmode_t fmode,
1952                         int flags,
1953                         struct iattr *sattr,
1954                         struct rpc_cred *cred,
1955                         struct nfs4_state **res,
1956                         struct nfs4_threshold **ctx_th)
1957 {
1958         struct nfs4_state_owner  *sp;
1959         struct nfs4_state     *state = NULL;
1960         struct nfs_server       *server = NFS_SERVER(dir);
1961         struct nfs4_opendata *opendata;
1962         enum open_claim_type4 claim = NFS4_OPEN_CLAIM_NULL;
1963         int status;
1964
1965         /* Protect against reboot recovery conflicts */
1966         status = -ENOMEM;
1967         sp = nfs4_get_state_owner(server, cred, GFP_KERNEL);
1968         if (sp == NULL) {
1969                 dprintk("nfs4_do_open: nfs4_get_state_owner failed!\n");
1970                 goto out_err;
1971         }
1972         status = nfs4_recover_expired_lease(server);
1973         if (status != 0)
1974                 goto err_put_state_owner;
1975         if (dentry->d_inode != NULL)
1976                 nfs4_return_incompatible_delegation(dentry->d_inode, fmode);
1977         status = -ENOMEM;
1978         if (dentry->d_inode)
1979                 claim = NFS4_OPEN_CLAIM_FH;
1980         opendata = nfs4_opendata_alloc(dentry, sp, fmode, flags, sattr,
1981                         claim, GFP_KERNEL);
1982         if (opendata == NULL)
1983                 goto err_put_state_owner;
1984
1985         if (ctx_th && server->attr_bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD) {
1986                 opendata->f_attr.mdsthreshold = pnfs_mdsthreshold_alloc();
1987                 if (!opendata->f_attr.mdsthreshold)
1988                         goto err_opendata_put;
1989                 opendata->o_arg.open_bitmap = &nfs4_pnfs_open_bitmap[0];
1990         }
1991         if (dentry->d_inode != NULL)
1992                 opendata->state = nfs4_get_open_state(dentry->d_inode, sp);
1993
1994         status = _nfs4_open_and_get_state(opendata, fmode, flags, &state);
1995         if (status != 0)
1996                 goto err_opendata_put;
1997
1998         if (opendata->o_arg.open_flags & O_EXCL) {
1999                 nfs4_exclusive_attrset(opendata, sattr);
2000
2001                 nfs_fattr_init(opendata->o_res.f_attr);
2002                 status = nfs4_do_setattr(state->inode, cred,
2003                                 opendata->o_res.f_attr, sattr,
2004                                 state);
2005                 if (status == 0)
2006                         nfs_setattr_update_inode(state->inode, sattr);
2007                 nfs_post_op_update_inode(state->inode, opendata->o_res.f_attr);
2008         }
2009
2010         if (pnfs_use_threshold(ctx_th, opendata->f_attr.mdsthreshold, server))
2011                 *ctx_th = opendata->f_attr.mdsthreshold;
2012         else
2013                 kfree(opendata->f_attr.mdsthreshold);
2014         opendata->f_attr.mdsthreshold = NULL;
2015
2016         nfs4_opendata_put(opendata);
2017         nfs4_put_state_owner(sp);
2018         *res = state;
2019         return 0;
2020 err_opendata_put:
2021         kfree(opendata->f_attr.mdsthreshold);
2022         nfs4_opendata_put(opendata);
2023 err_put_state_owner:
2024         nfs4_put_state_owner(sp);
2025 out_err:
2026         *res = NULL;
2027         return status;
2028 }
2029
2030
2031 static struct nfs4_state *nfs4_do_open(struct inode *dir,
2032                                         struct dentry *dentry,
2033                                         fmode_t fmode,
2034                                         int flags,
2035                                         struct iattr *sattr,
2036                                         struct rpc_cred *cred,
2037                                         struct nfs4_threshold **ctx_th)
2038 {
2039         struct nfs_server *server = NFS_SERVER(dir);
2040         struct nfs4_exception exception = { };
2041         struct nfs4_state *res;
2042         int status;
2043
2044         fmode &= FMODE_READ|FMODE_WRITE|FMODE_EXEC;
2045         do {
2046                 status = _nfs4_do_open(dir, dentry, fmode, flags, sattr, cred,
2047                                        &res, ctx_th);
2048                 if (status == 0)
2049                         break;
2050                 /* NOTE: BAD_SEQID means the server and client disagree about the
2051                  * book-keeping w.r.t. state-changing operations
2052                  * (OPEN/CLOSE/LOCK/LOCKU...)
2053                  * It is actually a sign of a bug on the client or on the server.
2054                  *
2055                  * If we receive a BAD_SEQID error in the particular case of
2056                  * doing an OPEN, we assume that nfs_increment_open_seqid() will
2057                  * have unhashed the old state_owner for us, and that we can
2058                  * therefore safely retry using a new one. We should still warn
2059                  * the user though...
2060                  */
2061                 if (status == -NFS4ERR_BAD_SEQID) {
2062                         pr_warn_ratelimited("NFS: v4 server %s "
2063                                         " returned a bad sequence-id error!\n",
2064                                         NFS_SERVER(dir)->nfs_client->cl_hostname);
2065                         exception.retry = 1;
2066                         continue;
2067                 }
2068                 /*
2069                  * BAD_STATEID on OPEN means that the server cancelled our
2070                  * state before it received the OPEN_CONFIRM.
2071                  * Recover by retrying the request as per the discussion
2072                  * on Page 181 of RFC3530.
2073                  */
2074                 if (status == -NFS4ERR_BAD_STATEID) {
2075                         exception.retry = 1;
2076                         continue;
2077                 }
2078                 if (status == -EAGAIN) {
2079                         /* We must have found a delegation */
2080                         exception.retry = 1;
2081                         continue;
2082                 }
2083                 if (nfs4_clear_cap_atomic_open_v1(server, status, &exception))
2084                         continue;
2085                 res = ERR_PTR(nfs4_handle_exception(server,
2086                                         status, &exception));
2087         } while (exception.retry);
2088         return res;
2089 }
2090
2091 static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
2092                             struct nfs_fattr *fattr, struct iattr *sattr,
2093                             struct nfs4_state *state)
2094 {
2095         struct nfs_server *server = NFS_SERVER(inode);
2096         struct nfs_setattrargs  arg = {
2097                 .fh             = NFS_FH(inode),
2098                 .iap            = sattr,
2099                 .server         = server,
2100                 .bitmask = server->attr_bitmask,
2101         };
2102         struct nfs_setattrres  res = {
2103                 .fattr          = fattr,
2104                 .server         = server,
2105         };
2106         struct rpc_message msg = {
2107                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
2108                 .rpc_argp       = &arg,
2109                 .rpc_resp       = &res,
2110                 .rpc_cred       = cred,
2111         };
2112         unsigned long timestamp = jiffies;
2113         int status;
2114
2115         nfs_fattr_init(fattr);
2116
2117         if (state != NULL && nfs4_valid_open_stateid(state)) {
2118                 struct nfs_lockowner lockowner = {
2119                         .l_owner = current->files,
2120                         .l_pid = current->tgid,
2121                 };
2122                 nfs4_select_rw_stateid(&arg.stateid, state, FMODE_WRITE,
2123                                 &lockowner);
2124         } else if (nfs4_copy_delegation_stateid(&arg.stateid, inode,
2125                                 FMODE_WRITE)) {
2126                 /* Use that stateid */
2127         } else
2128                 nfs4_stateid_copy(&arg.stateid, &zero_stateid);
2129
2130         status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
2131         if (status == 0 && state != NULL)
2132                 renew_lease(server, timestamp);
2133         return status;
2134 }
2135
2136 static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
2137                            struct nfs_fattr *fattr, struct iattr *sattr,
2138                            struct nfs4_state *state)
2139 {
2140         struct nfs_server *server = NFS_SERVER(inode);
2141         struct nfs4_exception exception = {
2142                 .state = state,
2143                 .inode = inode,
2144         };
2145         int err;
2146         do {
2147                 err = _nfs4_do_setattr(inode, cred, fattr, sattr, state);
2148                 switch (err) {
2149                 case -NFS4ERR_OPENMODE:
2150                         if (state && !(state->state & FMODE_WRITE)) {
2151                                 err = -EBADF;
2152                                 if (sattr->ia_valid & ATTR_OPEN)
2153                                         err = -EACCES;
2154                                 goto out;
2155                         }
2156                 }
2157                 err = nfs4_handle_exception(server, err, &exception);
2158         } while (exception.retry);
2159 out:
2160         return err;
2161 }
2162
2163 struct nfs4_closedata {
2164         struct inode *inode;
2165         struct nfs4_state *state;
2166         struct nfs_closeargs arg;
2167         struct nfs_closeres res;
2168         struct nfs_fattr fattr;
2169         unsigned long timestamp;
2170         bool roc;
2171         u32 roc_barrier;
2172 };
2173
2174 static void nfs4_free_closedata(void *data)
2175 {
2176         struct nfs4_closedata *calldata = data;
2177         struct nfs4_state_owner *sp = calldata->state->owner;
2178         struct super_block *sb = calldata->state->inode->i_sb;
2179
2180         if (calldata->roc)
2181                 pnfs_roc_release(calldata->state->inode);
2182         nfs4_put_open_state(calldata->state);
2183         nfs_free_seqid(calldata->arg.seqid);
2184         nfs4_put_state_owner(sp);
2185         nfs_sb_deactive(sb);
2186         kfree(calldata);
2187 }
2188
2189 static void nfs4_close_clear_stateid_flags(struct nfs4_state *state,
2190                 fmode_t fmode)
2191 {
2192         spin_lock(&state->owner->so_lock);
2193         if (!(fmode & FMODE_READ))
2194                 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
2195         if (!(fmode & FMODE_WRITE))
2196                 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
2197         clear_bit(NFS_O_RDWR_STATE, &state->flags);
2198         spin_unlock(&state->owner->so_lock);
2199 }
2200
2201 static void nfs4_close_done(struct rpc_task *task, void *data)
2202 {
2203         struct nfs4_closedata *calldata = data;
2204         struct nfs4_state *state = calldata->state;
2205         struct nfs_server *server = NFS_SERVER(calldata->inode);
2206
2207         dprintk("%s: begin!\n", __func__);
2208         if (!nfs4_sequence_done(task, &calldata->res.seq_res))
2209                 return;
2210         /* hmm. we are done with the inode, and in the process of freeing
2211          * the state_owner. we keep this around to process errors
2212          */
2213         switch (task->tk_status) {
2214                 case 0:
2215                         if (calldata->roc)
2216                                 pnfs_roc_set_barrier(state->inode,
2217                                                      calldata->roc_barrier);
2218                         nfs_set_open_stateid(state, &calldata->res.stateid, 0);
2219                         renew_lease(server, calldata->timestamp);
2220                         nfs4_close_clear_stateid_flags(state,
2221                                         calldata->arg.fmode);
2222                         break;
2223                 case -NFS4ERR_STALE_STATEID:
2224                 case -NFS4ERR_OLD_STATEID:
2225                 case -NFS4ERR_BAD_STATEID:
2226                 case -NFS4ERR_EXPIRED:
2227                         if (calldata->arg.fmode == 0)
2228                                 break;
2229                 default:
2230                         if (nfs4_async_handle_error(task, server, state) == -EAGAIN)
2231                                 rpc_restart_call_prepare(task);
2232         }
2233         nfs_release_seqid(calldata->arg.seqid);
2234         nfs_refresh_inode(calldata->inode, calldata->res.fattr);
2235         dprintk("%s: done, ret = %d!\n", __func__, task->tk_status);
2236 }
2237
2238 static void nfs4_close_prepare(struct rpc_task *task, void *data)
2239 {
2240         struct nfs4_closedata *calldata = data;
2241         struct nfs4_state *state = calldata->state;
2242         struct inode *inode = calldata->inode;
2243         int call_close = 0;
2244
2245         dprintk("%s: begin!\n", __func__);
2246         if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
2247                 goto out_wait;
2248
2249         task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE];
2250         calldata->arg.fmode = FMODE_READ|FMODE_WRITE;
2251         spin_lock(&state->owner->so_lock);
2252         /* Calculate the change in open mode */
2253         if (state->n_rdwr == 0) {
2254                 if (state->n_rdonly == 0) {
2255                         call_close |= test_bit(NFS_O_RDONLY_STATE, &state->flags);
2256                         call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
2257                         calldata->arg.fmode &= ~FMODE_READ;
2258                 }
2259                 if (state->n_wronly == 0) {
2260                         call_close |= test_bit(NFS_O_WRONLY_STATE, &state->flags);
2261                         call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
2262                         calldata->arg.fmode &= ~FMODE_WRITE;
2263                 }
2264         }
2265         if (!nfs4_valid_open_stateid(state))
2266                 call_close = 0;
2267         spin_unlock(&state->owner->so_lock);
2268
2269         if (!call_close) {
2270                 /* Note: exit _without_ calling nfs4_close_done */
2271                 goto out_no_action;
2272         }
2273
2274         if (calldata->arg.fmode == 0) {
2275                 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE];
2276                 if (calldata->roc &&
2277                     pnfs_roc_drain(inode, &calldata->roc_barrier, task))
2278                         goto out_wait;
2279         }
2280
2281         nfs_fattr_init(calldata->res.fattr);
2282         calldata->timestamp = jiffies;
2283         if (nfs4_setup_sequence(NFS_SERVER(inode),
2284                                 &calldata->arg.seq_args,
2285                                 &calldata->res.seq_res,
2286                                 task) != 0)
2287                 nfs_release_seqid(calldata->arg.seqid);
2288         dprintk("%s: done!\n", __func__);
2289         return;
2290 out_no_action:
2291         task->tk_action = NULL;
2292 out_wait:
2293         nfs4_sequence_done(task, &calldata->res.seq_res);
2294 }
2295
2296 static const struct rpc_call_ops nfs4_close_ops = {
2297         .rpc_call_prepare = nfs4_close_prepare,
2298         .rpc_call_done = nfs4_close_done,
2299         .rpc_release = nfs4_free_closedata,
2300 };
2301
2302 /*
2303  * It is possible for data to be read/written from a mem-mapped file
2304  * after the sys_close call (which hits the vfs layer as a flush).
2305  * This means that we can't safely call nfsv4 close on a file until
2306  * the inode is cleared. This in turn means that we are not good
2307  * NFSv4 citizens - we do not indicate to the server to update the file's
2308  * share state even when we are done with one of the three share
2309  * stateid's in the inode.
2310  *
2311  * NOTE: Caller must be holding the sp->so_owner semaphore!
2312  */
2313 int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait)
2314 {
2315         struct nfs_server *server = NFS_SERVER(state->inode);
2316         struct nfs4_closedata *calldata;
2317         struct nfs4_state_owner *sp = state->owner;
2318         struct rpc_task *task;
2319         struct rpc_message msg = {
2320                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE],
2321                 .rpc_cred = state->owner->so_cred,
2322         };
2323         struct rpc_task_setup task_setup_data = {
2324                 .rpc_client = server->client,
2325                 .rpc_message = &msg,
2326                 .callback_ops = &nfs4_close_ops,
2327                 .workqueue = nfsiod_workqueue,
2328                 .flags = RPC_TASK_ASYNC,
2329         };
2330         int status = -ENOMEM;
2331
2332         calldata = kzalloc(sizeof(*calldata), gfp_mask);
2333         if (calldata == NULL)
2334                 goto out;
2335         nfs41_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 1);
2336         calldata->inode = state->inode;
2337         calldata->state = state;
2338         calldata->arg.fh = NFS_FH(state->inode);
2339         calldata->arg.stateid = &state->open_stateid;
2340         /* Serialization for the sequence id */
2341         calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid, gfp_mask);
2342         if (calldata->arg.seqid == NULL)
2343                 goto out_free_calldata;
2344         calldata->arg.fmode = 0;
2345         calldata->arg.bitmask = server->cache_consistency_bitmask;
2346         calldata->res.fattr = &calldata->fattr;
2347         calldata->res.seqid = calldata->arg.seqid;
2348         calldata->res.server = server;
2349         calldata->roc = pnfs_roc(state->inode);
2350         nfs_sb_active(calldata->inode->i_sb);
2351
2352         msg.rpc_argp = &calldata->arg;
2353         msg.rpc_resp = &calldata->res;
2354         task_setup_data.callback_data = calldata;
2355         task = rpc_run_task(&task_setup_data);
2356         if (IS_ERR(task))
2357                 return PTR_ERR(task);
2358         status = 0;
2359         if (wait)
2360                 status = rpc_wait_for_completion_task(task);
2361         rpc_put_task(task);
2362         return status;
2363 out_free_calldata:
2364         kfree(calldata);
2365 out:
2366         nfs4_put_open_state(state);
2367         nfs4_put_state_owner(sp);
2368         return status;
2369 }
2370
2371 static struct inode *
2372 nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx, int open_flags, struct iattr *attr)
2373 {
2374         struct nfs4_state *state;
2375
2376         /* Protect against concurrent sillydeletes */
2377         state = nfs4_do_open(dir, ctx->dentry, ctx->mode, open_flags, attr,
2378                              ctx->cred, &ctx->mdsthreshold);
2379         if (IS_ERR(state))
2380                 return ERR_CAST(state);
2381         ctx->state = state;
2382         return igrab(state->inode);
2383 }
2384
2385 static void nfs4_close_context(struct nfs_open_context *ctx, int is_sync)
2386 {
2387         if (ctx->state == NULL)
2388                 return;
2389         if (is_sync)
2390                 nfs4_close_sync(ctx->state, ctx->mode);
2391         else
2392                 nfs4_close_state(ctx->state, ctx->mode);
2393 }
2394
2395 static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
2396 {
2397         struct nfs4_server_caps_arg args = {
2398                 .fhandle = fhandle,
2399         };
2400         struct nfs4_server_caps_res res = {};
2401         struct rpc_message msg = {
2402                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS],
2403                 .rpc_argp = &args,
2404                 .rpc_resp = &res,
2405         };
2406         int status;
2407
2408         status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
2409         if (status == 0) {
2410                 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask));
2411                 server->caps &= ~(NFS_CAP_ACLS|NFS_CAP_HARDLINKS|
2412                                 NFS_CAP_SYMLINKS|NFS_CAP_FILEID|
2413                                 NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|
2414                                 NFS_CAP_OWNER_GROUP|NFS_CAP_ATIME|
2415                                 NFS_CAP_CTIME|NFS_CAP_MTIME);
2416                 if (res.attr_bitmask[0] & FATTR4_WORD0_ACL)
2417                         server->caps |= NFS_CAP_ACLS;
2418                 if (res.has_links != 0)
2419                         server->caps |= NFS_CAP_HARDLINKS;
2420                 if (res.has_symlinks != 0)
2421                         server->caps |= NFS_CAP_SYMLINKS;
2422                 if (res.attr_bitmask[0] & FATTR4_WORD0_FILEID)
2423                         server->caps |= NFS_CAP_FILEID;
2424                 if (res.attr_bitmask[1] & FATTR4_WORD1_MODE)
2425                         server->caps |= NFS_CAP_MODE;
2426                 if (res.attr_bitmask[1] & FATTR4_WORD1_NUMLINKS)
2427                         server->caps |= NFS_CAP_NLINK;
2428                 if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER)
2429                         server->caps |= NFS_CAP_OWNER;
2430                 if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER_GROUP)
2431                         server->caps |= NFS_CAP_OWNER_GROUP;
2432                 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_ACCESS)
2433                         server->caps |= NFS_CAP_ATIME;
2434                 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_METADATA)
2435                         server->caps |= NFS_CAP_CTIME;
2436                 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY)
2437                         server->caps |= NFS_CAP_MTIME;
2438
2439                 memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask));
2440                 server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE;
2441                 server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY;
2442                 server->acl_bitmask = res.acl_bitmask;
2443                 server->fh_expire_type = res.fh_expire_type;
2444         }
2445
2446         return status;
2447 }
2448
2449 int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
2450 {
2451         struct nfs4_exception exception = { };
2452         int err;
2453         do {
2454                 err = nfs4_handle_exception(server,
2455                                 _nfs4_server_capabilities(server, fhandle),
2456                                 &exception);
2457         } while (exception.retry);
2458         return err;
2459 }
2460
2461 static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
2462                 struct nfs_fsinfo *info)
2463 {
2464         struct nfs4_lookup_root_arg args = {
2465                 .bitmask = nfs4_fattr_bitmap,
2466         };
2467         struct nfs4_lookup_res res = {
2468                 .server = server,
2469                 .fattr = info->fattr,
2470                 .fh = fhandle,
2471         };
2472         struct rpc_message msg = {
2473                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP_ROOT],
2474                 .rpc_argp = &args,
2475                 .rpc_resp = &res,
2476         };
2477
2478         nfs_fattr_init(info->fattr);
2479         return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
2480 }
2481
2482 static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
2483                 struct nfs_fsinfo *info)
2484 {
2485         struct nfs4_exception exception = { };
2486         int err;
2487         do {
2488                 err = _nfs4_lookup_root(server, fhandle, info);
2489                 switch (err) {
2490                 case 0:
2491                 case -NFS4ERR_WRONGSEC:
2492                         goto out;
2493                 default:
2494                         err = nfs4_handle_exception(server, err, &exception);
2495                 }
2496         } while (exception.retry);
2497 out:
2498         return err;
2499 }
2500
2501 static int nfs4_lookup_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
2502                                 struct nfs_fsinfo *info, rpc_authflavor_t flavor)
2503 {
2504         struct rpc_auth *auth;
2505         int ret;
2506
2507         auth = rpcauth_create(flavor, server->client);
2508         if (IS_ERR(auth)) {
2509                 ret = -EIO;
2510                 goto out;
2511         }
2512         ret = nfs4_lookup_root(server, fhandle, info);
2513 out:
2514         return ret;
2515 }
2516
2517 static int nfs4_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
2518                               struct nfs_fsinfo *info)
2519 {
2520         int i, len, status = 0;
2521         rpc_authflavor_t flav_array[NFS_MAX_SECFLAVORS];
2522
2523         len = rpcauth_list_flavors(flav_array, ARRAY_SIZE(flav_array));
2524         if (len < 0)
2525                 return len;
2526
2527         for (i = 0; i < len; i++) {
2528                 /* AUTH_UNIX is the default flavor if none was specified,
2529                  * thus has already been tried. */
2530                 if (flav_array[i] == RPC_AUTH_UNIX)
2531                         continue;
2532
2533                 status = nfs4_lookup_root_sec(server, fhandle, info, flav_array[i]);
2534                 if (status == -NFS4ERR_WRONGSEC || status == -EACCES)
2535                         continue;
2536                 break;
2537         }
2538         /*
2539          * -EACCESS could mean that the user doesn't have correct permissions
2540          * to access the mount.  It could also mean that we tried to mount
2541          * with a gss auth flavor, but rpc.gssd isn't running.  Either way,
2542          * existing mount programs don't handle -EACCES very well so it should
2543          * be mapped to -EPERM instead.
2544          */
2545         if (status == -EACCES)
2546                 status = -EPERM;
2547         return status;
2548 }
2549
2550 /*
2551  * get the file handle for the "/" directory on the server
2552  */
2553 int nfs4_proc_get_rootfh(struct nfs_server *server, struct nfs_fh *fhandle,
2554                          struct nfs_fsinfo *info)
2555 {
2556         int minor_version = server->nfs_client->cl_minorversion;
2557         int status = nfs4_lookup_root(server, fhandle, info);
2558         if ((status == -NFS4ERR_WRONGSEC) && !(server->flags & NFS_MOUNT_SECFLAVOUR))
2559                 /*
2560                  * A status of -NFS4ERR_WRONGSEC will be mapped to -EPERM
2561                  * by nfs4_map_errors() as this function exits.
2562                  */
2563                 status = nfs_v4_minor_ops[minor_version]->find_root_sec(server, fhandle, info);
2564         if (status == 0)
2565                 status = nfs4_server_capabilities(server, fhandle);
2566         if (status == 0)
2567                 status = nfs4_do_fsinfo(server, fhandle, info);
2568         return nfs4_map_errors(status);
2569 }
2570
2571 static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh,
2572                               struct nfs_fsinfo *info)
2573 {
2574         int error;
2575         struct nfs_fattr *fattr = info->fattr;
2576
2577         error = nfs4_server_capabilities(server, mntfh);
2578         if (error < 0) {
2579                 dprintk("nfs4_get_root: getcaps error = %d\n", -error);
2580                 return error;
2581         }
2582
2583         error = nfs4_proc_getattr(server, mntfh, fattr);
2584         if (error < 0) {
2585                 dprintk("nfs4_get_root: getattr error = %d\n", -error);
2586                 return error;
2587         }
2588
2589         if (fattr->valid & NFS_ATTR_FATTR_FSID &&
2590             !nfs_fsid_equal(&server->fsid, &fattr->fsid))
2591                 memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));
2592
2593         return error;
2594 }
2595
2596 /*
2597  * Get locations and (maybe) other attributes of a referral.
2598  * Note that we'll actually follow the referral later when
2599  * we detect fsid mismatch in inode revalidation
2600  */
2601 static int nfs4_get_referral(struct rpc_clnt *client, struct inode *dir,
2602                              const struct qstr *name, struct nfs_fattr *fattr,
2603                              struct nfs_fh *fhandle)
2604 {
2605         int status = -ENOMEM;
2606         struct page *page = NULL;
2607         struct nfs4_fs_locations *locations = NULL;
2608
2609         page = alloc_page(GFP_KERNEL);
2610         if (page == NULL)
2611                 goto out;
2612         locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
2613         if (locations == NULL)
2614                 goto out;
2615
2616         status = nfs4_proc_fs_locations(client, dir, name, locations, page);
2617         if (status != 0)
2618                 goto out;
2619         /* Make sure server returned a different fsid for the referral */
2620         if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) {
2621                 dprintk("%s: server did not return a different fsid for"
2622                         " a referral at %s\n", __func__, name->name);
2623                 status = -EIO;
2624                 goto out;
2625         }
2626         /* Fixup attributes for the nfs_lookup() call to nfs_fhget() */
2627         nfs_fixup_referral_attributes(&locations->fattr);
2628
2629         /* replace the lookup nfs_fattr with the locations nfs_fattr */
2630         memcpy(fattr, &locations->fattr, sizeof(struct nfs_fattr));
2631         memset(fhandle, 0, sizeof(struct nfs_fh));
2632 out:
2633         if (page)
2634                 __free_page(page);
2635         kfree(locations);
2636         return status;
2637 }
2638
2639 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
2640 {
2641         struct nfs4_getattr_arg args = {
2642                 .fh = fhandle,
2643                 .bitmask = server->attr_bitmask,
2644         };
2645         struct nfs4_getattr_res res = {
2646                 .fattr = fattr,
2647                 .server = server,
2648         };
2649         struct rpc_message msg = {
2650                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
2651                 .rpc_argp = &args,
2652                 .rpc_resp = &res,
2653         };
2654
2655         nfs_fattr_init(fattr);
2656         return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
2657 }
2658
2659 static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
2660 {
2661         struct nfs4_exception exception = { };
2662         int err;
2663         do {
2664                 err = nfs4_handle_exception(server,
2665                                 _nfs4_proc_getattr(server, fhandle, fattr),
2666                                 &exception);
2667         } while (exception.retry);
2668         return err;
2669 }
2670
2671 /*
2672  * The file is not closed if it is opened due to the a request to change
2673  * the size of the file. The open call will not be needed once the
2674  * VFS layer lookup-intents are implemented.
2675  *
2676  * Close is called when the inode is destroyed.
2677  * If we haven't opened the file for O_WRONLY, we
2678  * need to in the size_change case to obtain a stateid.
2679  *
2680  * Got race?
2681  * Because OPEN is always done by name in nfsv4, it is
2682  * possible that we opened a different file by the same
2683  * name.  We can recognize this race condition, but we
2684  * can't do anything about it besides returning an error.
2685  *
2686  * This will be fixed with VFS changes (lookup-intent).
2687  */
2688 static int
2689 nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
2690                   struct iattr *sattr)
2691 {
2692         struct inode *inode = dentry->d_inode;
2693         struct rpc_cred *cred = NULL;
2694         struct nfs4_state *state = NULL;
2695         int status;
2696
2697         if (pnfs_ld_layoutret_on_setattr(inode))
2698                 pnfs_commit_and_return_layout(inode);
2699
2700         nfs_fattr_init(fattr);
2701
2702         /* Deal with open(O_TRUNC) */
2703         if (sattr->ia_valid & ATTR_OPEN)
2704                 sattr->ia_valid &= ~(ATTR_MTIME|ATTR_CTIME|ATTR_OPEN);
2705
2706         /* Optimization: if the end result is no change, don't RPC */
2707         if ((sattr->ia_valid & ~(ATTR_FILE)) == 0)
2708                 return 0;
2709
2710         /* Search for an existing open(O_WRITE) file */
2711         if (sattr->ia_valid & ATTR_FILE) {
2712                 struct nfs_open_context *ctx;
2713
2714                 ctx = nfs_file_open_context(sattr->ia_file);
2715                 if (ctx) {
2716                         cred = ctx->cred;
2717                         state = ctx->state;
2718                 }
2719         }
2720
2721         status = nfs4_do_setattr(inode, cred, fattr, sattr, state);
2722         if (status == 0)
2723                 nfs_setattr_update_inode(inode, sattr);
2724         return status;
2725 }
2726
2727 static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,
2728                 const struct qstr *name, struct nfs_fh *fhandle,
2729                 struct nfs_fattr *fattr)
2730 {
2731         struct nfs_server *server = NFS_SERVER(dir);
2732         int                    status;
2733         struct nfs4_lookup_arg args = {
2734                 .bitmask = server->attr_bitmask,
2735                 .dir_fh = NFS_FH(dir),
2736                 .name = name,
2737         };
2738         struct nfs4_lookup_res res = {
2739                 .server = server,
2740                 .fattr = fattr,
2741                 .fh = fhandle,
2742         };
2743         struct rpc_message msg = {
2744                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP],
2745                 .rpc_argp = &args,
2746                 .rpc_resp = &res,
2747         };
2748
2749         nfs_fattr_init(fattr);
2750
2751         dprintk("NFS call  lookup %s\n", name->name);
2752         status = nfs4_call_sync(clnt, server, &msg, &args.seq_args, &res.seq_res, 0);
2753         dprintk("NFS reply lookup: %d\n", status);
2754         return status;
2755 }
2756
2757 static void nfs_fixup_secinfo_attributes(struct nfs_fattr *fattr)
2758 {
2759         fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |
2760                 NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_MOUNTPOINT;
2761         fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;
2762         fattr->nlink = 2;
2763 }
2764
2765 static int nfs4_proc_lookup_common(struct rpc_clnt **clnt, struct inode *dir,
2766                                    struct qstr *name, struct nfs_fh *fhandle,
2767                                    struct nfs_fattr *fattr)
2768 {
2769         struct nfs4_exception exception = { };
2770         struct rpc_clnt *client = *clnt;
2771         int err;
2772         do {
2773                 err = _nfs4_proc_lookup(client, dir, name, fhandle, fattr);
2774                 switch (err) {
2775                 case -NFS4ERR_BADNAME:
2776                         err = -ENOENT;
2777                         goto out;
2778                 case -NFS4ERR_MOVED:
2779                         err = nfs4_get_referral(client, dir, name, fattr, fhandle);
2780                         goto out;
2781                 case -NFS4ERR_WRONGSEC:
2782                         err = -EPERM;
2783                         if (client != *clnt)
2784                                 goto out;
2785
2786                         client = nfs4_create_sec_client(client, dir, name);
2787                         if (IS_ERR(client))
2788                                 return PTR_ERR(client);
2789
2790                         exception.retry = 1;
2791                         break;
2792                 default:
2793                         err = nfs4_handle_exception(NFS_SERVER(dir), err, &exception);
2794                 }
2795         } while (exception.retry);
2796
2797 out:
2798         if (err == 0)
2799                 *clnt = client;
2800         else if (client != *clnt)
2801                 rpc_shutdown_client(client);
2802
2803         return err;
2804 }
2805
2806 static int nfs4_proc_lookup(struct inode *dir, struct qstr *name,
2807                             struct nfs_fh *fhandle, struct nfs_fattr *fattr)
2808 {
2809         int status;
2810         struct rpc_clnt *client = NFS_CLIENT(dir);
2811
2812         status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr);
2813         if (client != NFS_CLIENT(dir)) {
2814                 rpc_shutdown_client(client);
2815                 nfs_fixup_secinfo_attributes(fattr);
2816         }
2817         return status;
2818 }
2819
2820 struct rpc_clnt *
2821 nfs4_proc_lookup_mountpoint(struct inode *dir, struct qstr *name,
2822                             struct nfs_fh *fhandle, struct nfs_fattr *fattr)
2823 {
2824         int status;
2825         struct rpc_clnt *client = rpc_clone_client(NFS_CLIENT(dir));
2826
2827         status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr);
2828         if (status < 0) {
2829                 rpc_shutdown_client(client);
2830                 return ERR_PTR(status);
2831         }
2832         return client;
2833 }
2834
2835 static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
2836 {
2837         struct nfs_server *server = NFS_SERVER(inode);
2838         struct nfs4_accessargs args = {
2839                 .fh = NFS_FH(inode),
2840                 .bitmask = server->cache_consistency_bitmask,
2841         };
2842         struct nfs4_accessres res = {
2843                 .server = server,
2844         };
2845         struct rpc_message msg = {
2846                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS],
2847                 .rpc_argp = &args,
2848                 .rpc_resp = &res,
2849                 .rpc_cred = entry->cred,
2850         };
2851         int mode = entry->mask;
2852         int status;
2853
2854         /*
2855          * Determine which access bits we want to ask for...
2856          */
2857         if (mode & MAY_READ)
2858                 args.access |= NFS4_ACCESS_READ;
2859         if (S_ISDIR(inode->i_mode)) {
2860                 if (mode & MAY_WRITE)
2861                         args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE;
2862                 if (mode & MAY_EXEC)
2863                         args.access |= NFS4_ACCESS_LOOKUP;
2864         } else {
2865                 if (mode & MAY_WRITE)
2866                         args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND;
2867                 if (mode & MAY_EXEC)
2868                         args.access |= NFS4_ACCESS_EXECUTE;
2869         }
2870
2871         res.fattr = nfs_alloc_fattr();
2872         if (res.fattr == NULL)
2873                 return -ENOMEM;
2874
2875         status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
2876         if (!status) {
2877                 nfs_access_set_mask(entry, res.access);
2878                 nfs_refresh_inode(inode, res.fattr);
2879         }
2880         nfs_free_fattr(res.fattr);
2881         return status;
2882 }
2883
2884 static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
2885 {
2886         struct nfs4_exception exception = { };
2887         int err;
2888         do {
2889                 err = nfs4_handle_exception(NFS_SERVER(inode),
2890                                 _nfs4_proc_access(inode, entry),
2891                                 &exception);
2892         } while (exception.retry);
2893         return err;
2894 }
2895
2896 /*
2897  * TODO: For the time being, we don't try to get any attributes
2898  * along with any of the zero-copy operations READ, READDIR,
2899  * READLINK, WRITE.
2900  *
2901  * In the case of the first three, we want to put the GETATTR
2902  * after the read-type operation -- this is because it is hard
2903  * to predict the length of a GETATTR response in v4, and thus
2904  * align the READ data correctly.  This means that the GETATTR
2905  * may end up partially falling into the page cache, and we should
2906  * shift it into the 'tail' of the xdr_buf before processing.
2907  * To do this efficiently, we need to know the total length
2908  * of data received, which doesn't seem to be available outside
2909  * of the RPC layer.
2910  *
2911  * In the case of WRITE, we also want to put the GETATTR after
2912  * the operation -- in this case because we want to make sure
2913  * we get the post-operation mtime and size.
2914  *
2915  * Both of these changes to the XDR layer would in fact be quite
2916  * minor, but I decided to leave them for a subsequent patch.
2917  */
2918 static int _nfs4_proc_readlink(struct inode *inode, struct page *page,
2919                 unsigned int pgbase, unsigned int pglen)
2920 {
2921         struct nfs4_readlink args = {
2922                 .fh       = NFS_FH(inode),
2923                 .pgbase   = pgbase,
2924                 .pglen    = pglen,
2925                 .pages    = &page,
2926         };
2927         struct nfs4_readlink_res res;
2928         struct rpc_message msg = {
2929                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK],
2930                 .rpc_argp = &args,
2931                 .rpc_resp = &res,
2932         };
2933
2934         return nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), &msg, &args.seq_args, &res.seq_res, 0);
2935 }
2936
2937 static int nfs4_proc_readlink(struct inode *inode, struct page *page,
2938                 unsigned int pgbase, unsigned int pglen)
2939 {
2940         struct nfs4_exception exception = { };
2941         int err;
2942         do {
2943                 err = nfs4_handle_exception(NFS_SERVER(inode),
2944                                 _nfs4_proc_readlink(inode, page, pgbase, pglen),
2945                                 &exception);
2946         } while (exception.retry);
2947         return err;
2948 }
2949
2950 /*
2951  * This is just for mknod.  open(O_CREAT) will always do ->open_context().
2952  */
2953 static int
2954 nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
2955                  int flags)
2956 {
2957         struct nfs_open_context *ctx;
2958         struct nfs4_state *state;
2959         int status = 0;
2960
2961         ctx = alloc_nfs_open_context(dentry, FMODE_READ);
2962         if (IS_ERR(ctx))
2963                 return PTR_ERR(ctx);
2964
2965         sattr->ia_mode &= ~current_umask();
2966         state = nfs4_do_open(dir, dentry, ctx->mode,
2967                         flags, sattr, ctx->cred,
2968                         &ctx->mdsthreshold);
2969         d_drop(dentry);
2970         if (IS_ERR(state)) {
2971                 status = PTR_ERR(state);
2972                 goto out;
2973         }
2974         d_add(dentry, igrab(state->inode));
2975         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
2976         ctx->state = state;
2977 out:
2978         put_nfs_open_context(ctx);
2979         return status;
2980 }
2981
2982 static int _nfs4_proc_remove(struct inode *dir, struct qstr *name)
2983 {
2984         struct nfs_server *server = NFS_SERVER(dir);
2985         struct nfs_removeargs args = {
2986                 .fh = NFS_FH(dir),
2987                 .name = *name,
2988         };
2989         struct nfs_removeres res = {
2990                 .server = server,
2991         };
2992         struct rpc_message msg = {
2993                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE],
2994                 .rpc_argp = &args,
2995                 .rpc_resp = &res,
2996         };
2997         int status;
2998
2999         status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1);
3000         if (status == 0)
3001                 update_changeattr(dir, &res.cinfo);
3002         return status;
3003 }
3004
3005 static int nfs4_proc_remove(struct inode *dir, struct qstr *name)
3006 {
3007         struct nfs4_exception exception = { };
3008         int err;
3009         do {
3010                 err = nfs4_handle_exception(NFS_SERVER(dir),
3011                                 _nfs4_proc_remove(dir, name),
3012                                 &exception);
3013         } while (exception.retry);
3014         return err;
3015 }
3016
3017 static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
3018 {
3019         struct nfs_server *server = NFS_SERVER(dir);
3020         struct nfs_removeargs *args = msg->rpc_argp;
3021         struct nfs_removeres *res = msg->rpc_resp;
3022
3023         res->server = server;
3024         msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE];
3025         nfs41_init_sequence(&args->seq_args, &res->seq_res, 1);
3026 }
3027
3028 static void nfs4_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
3029 {
3030         nfs4_setup_sequence(NFS_SERVER(data->dir),
3031                         &data->args.seq_args,
3032                         &data->res.seq_res,
3033                         task);
3034 }
3035
3036 static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir)
3037 {
3038         struct nfs_removeres *res = task->tk_msg.rpc_resp;
3039
3040         if (!nfs4_sequence_done(task, &res->seq_res))
3041                 return 0;
3042         if (nfs4_async_handle_error(task, res->server, NULL) == -EAGAIN)
3043                 return 0;
3044         update_changeattr(dir, &res->cinfo);
3045         return 1;
3046 }
3047
3048 static void nfs4_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
3049 {
3050         struct nfs_server *server = NFS_SERVER(dir);
3051         struct nfs_renameargs *arg = msg->rpc_argp;
3052         struct nfs_renameres *res = msg->rpc_resp;
3053
3054         msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME];
3055         res->server = server;
3056         nfs41_init_sequence(&arg->seq_args, &res->seq_res, 1);
3057 }
3058
3059 static void nfs4_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
3060 {
3061         nfs4_setup_sequence(NFS_SERVER(data->old_dir),
3062                         &data->args.seq_args,
3063                         &data->res.seq_res,
3064                         task);
3065 }
3066
3067 static int nfs4_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
3068                                  struct inode *new_dir)
3069 {
3070         struct nfs_renameres *res = task->tk_msg.rpc_resp;
3071
3072         if (!nfs4_sequence_done(task, &res->seq_res))
3073                 return 0;
3074         if (nfs4_async_handle_error(task, res->server, NULL) == -EAGAIN)
3075                 return 0;
3076
3077         update_changeattr(old_dir, &res->old_cinfo);
3078         update_changeattr(new_dir, &res->new_cinfo);
3079         return 1;
3080 }
3081
3082 static int _nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
3083                 struct inode *new_dir, struct qstr *new_name)
3084 {
3085         struct nfs_server *server = NFS_SERVER(old_dir);
3086         struct nfs_renameargs arg = {
3087                 .old_dir = NFS_FH(old_dir),
3088                 .new_dir = NFS_FH(new_dir),
3089                 .old_name = old_name,
3090                 .new_name = new_name,
3091         };
3092         struct nfs_renameres res = {
3093                 .server = server,
3094         };
3095         struct rpc_message msg = {
3096                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME],
3097                 .rpc_argp = &arg,
3098                 .rpc_resp = &res,
3099         };
3100         int status = -ENOMEM;
3101
3102         status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
3103         if (!status) {
3104                 update_changeattr(old_dir, &res.old_cinfo);
3105                 update_changeattr(new_dir, &res.new_cinfo);
3106         }
3107         return status;
3108 }
3109
3110 static int nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
3111                 struct inode *new_dir, struct qstr *new_name)
3112 {
3113         struct nfs4_exception exception = { };
3114         int err;
3115         do {
3116                 err = nfs4_handle_exception(NFS_SERVER(old_dir),
3117                                 _nfs4_proc_rename(old_dir, old_name,
3118                                         new_dir, new_name),
3119                                 &exception);
3120         } while (exception.retry);
3121         return err;
3122 }
3123
3124 static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
3125 {
3126         struct nfs_server *server = NFS_SERVER(inode);
3127         struct nfs4_link_arg arg = {
3128                 .fh     = NFS_FH(inode),
3129                 .dir_fh = NFS_FH(dir),
3130                 .name   = name,
3131                 .bitmask = server->attr_bitmask,
3132         };
3133         struct nfs4_link_res res = {
3134                 .server = server,
3135         };
3136         struct rpc_message msg = {
3137                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK],
3138                 .rpc_argp = &arg,
3139                 .rpc_resp = &res,
3140         };
3141         int status = -ENOMEM;
3142
3143         res.fattr = nfs_alloc_fattr();
3144         if (res.fattr == NULL)
3145                 goto out;
3146
3147         status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
3148         if (!status) {
3149                 update_changeattr(dir, &res.cinfo);
3150                 nfs_post_op_update_inode(inode, res.fattr);
3151         }
3152 out:
3153         nfs_free_fattr(res.fattr);
3154         return status;
3155 }
3156
3157 static int nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
3158 {
3159         struct nfs4_exception exception = { };
3160         int err;
3161         do {
3162                 err = nfs4_handle_exception(NFS_SERVER(inode),
3163                                 _nfs4_proc_link(inode, dir, name),
3164                                 &exception);
3165         } while (exception.retry);
3166         return err;
3167 }
3168
3169 struct nfs4_createdata {
3170         struct rpc_message msg;
3171         struct nfs4_create_arg arg;
3172         struct nfs4_create_res res;
3173         struct nfs_fh fh;
3174         struct nfs_fattr fattr;
3175 };
3176
3177 static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,
3178                 struct qstr *name, struct iattr *sattr, u32 ftype)
3179 {
3180         struct nfs4_createdata *data;
3181
3182         data = kzalloc(sizeof(*data), GFP_KERNEL);
3183         if (data != NULL) {
3184                 struct nfs_server *server = NFS_SERVER(dir);
3185
3186                 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE];
3187                 data->msg.rpc_argp = &data->arg;
3188                 data->msg.rpc_resp = &data->res;
3189                 data->arg.dir_fh = NFS_FH(dir);
3190                 data->arg.server = server;
3191                 data->arg.name = name;
3192                 data->arg.attrs = sattr;
3193                 data->arg.ftype = ftype;
3194                 data->arg.bitmask = server->attr_bitmask;
3195                 data->res.server = server;
3196                 data->res.fh = &data->fh;
3197                 data->res.fattr = &data->fattr;
3198                 nfs_fattr_init(data->res.fattr);
3199         }
3200         return data;
3201 }
3202
3203 static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data)
3204 {
3205         int status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &data->msg,
3206                                     &data->arg.seq_args, &data->res.seq_res, 1);
3207         if (status == 0) {
3208                 update_changeattr(dir, &data->res.dir_cinfo);
3209                 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
3210         }
3211         return status;
3212 }
3213
3214 static void nfs4_free_createdata(struct nfs4_createdata *data)
3215 {
3216         kfree(data);
3217 }
3218
3219 static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
3220                 struct page *page, unsigned int len, struct iattr *sattr)
3221 {
3222         struct nfs4_createdata *data;
3223         int status = -ENAMETOOLONG;
3224
3225         if (len > NFS4_MAXPATHLEN)
3226                 goto out;
3227
3228         status = -ENOMEM;
3229         data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK);
3230         if (data == NULL)
3231                 goto out;
3232
3233         data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK];
3234         data->arg.u.symlink.pages = &page;
3235         data->arg.u.symlink.len = len;
3236
3237         status = nfs4_do_create(dir, dentry, data);
3238
3239         nfs4_free_createdata(data);
3240 out:
3241         return status;
3242 }
3243
3244 static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
3245                 struct page *page, unsigned int len, struct iattr *sattr)
3246 {
3247         struct nfs4_exception exception = { };
3248         int err;
3249         do {
3250                 err = nfs4_handle_exception(NFS_SERVER(dir),
3251                                 _nfs4_proc_symlink(dir, dentry, page,
3252                                                         len, sattr),
3253                                 &exception);
3254         } while (exception.retry);
3255         return err;
3256 }
3257
3258 static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
3259                 struct iattr *sattr)
3260 {
3261         struct nfs4_createdata *data;
3262         int status = -ENOMEM;
3263
3264         data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR);
3265         if (data == NULL)
3266                 goto out;
3267
3268         status = nfs4_do_create(dir, dentry, data);
3269
3270         nfs4_free_createdata(data);
3271 out:
3272         return status;
3273 }
3274
3275 static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
3276                 struct iattr *sattr)
3277 {
3278         struct nfs4_exception exception = { };
3279         int err;
3280
3281         sattr->ia_mode &= ~current_umask();
3282         do {
3283                 err = nfs4_handle_exception(NFS_SERVER(dir),
3284                                 _nfs4_proc_mkdir(dir, dentry, sattr),
3285                                 &exception);
3286         } while (exception.retry);
3287         return err;
3288 }
3289
3290 static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
3291                 u64 cookie, struct page **pages, unsigned int count, int plus)
3292 {
3293         struct inode            *dir = dentry->d_inode;
3294         struct nfs4_readdir_arg args = {
3295                 .fh = NFS_FH(dir),
3296                 .pages = pages,
3297                 .pgbase = 0,
3298                 .count = count,
3299                 .bitmask = NFS_SERVER(dentry->d_inode)->attr_bitmask,
3300                 .plus = plus,
3301         };
3302         struct nfs4_readdir_res res;
3303         struct rpc_message msg = {
3304                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR],
3305                 .rpc_argp = &args,
3306                 .rpc_resp = &res,
3307                 .rpc_cred = cred,
3308         };
3309         int                     status;
3310
3311         dprintk("%s: dentry = %s/%s, cookie = %Lu\n", __func__,
3312                         dentry->d_parent->d_name.name,
3313                         dentry->d_name.name,
3314                         (unsigned long long)cookie);
3315         nfs4_setup_readdir(cookie, NFS_I(dir)->cookieverf, dentry, &args);
3316         res.pgbase = args.pgbase;
3317         status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &msg, &args.seq_args, &res.seq_res, 0);
3318         if (status >= 0) {
3319                 memcpy(NFS_I(dir)->cookieverf, res.verifier.data, NFS4_VERIFIER_SIZE);
3320                 status += args.pgbase;
3321         }
3322
3323         nfs_invalidate_atime(dir);
3324
3325         dprintk("%s: returns %d\n", __func__, status);
3326         return status;
3327 }
3328
3329 static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
3330                 u64 cookie, struct page **pages, unsigned int count, int plus)
3331 {
3332         struct nfs4_exception exception = { };
3333         int err;
3334         do {
3335                 err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode),
3336                                 _nfs4_proc_readdir(dentry, cred, cookie,
3337                                         pages, count, plus),
3338                                 &exception);
3339         } while (exception.retry);
3340         return err;
3341 }
3342
3343 static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
3344                 struct iattr *sattr, dev_t rdev)
3345 {
3346         struct nfs4_createdata *data;
3347         int mode = sattr->ia_mode;
3348         int status = -ENOMEM;
3349
3350         data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK);
3351         if (data == NULL)
3352                 goto out;
3353
3354         if (S_ISFIFO(mode))
3355                 data->arg.ftype = NF4FIFO;
3356         else if (S_ISBLK(mode)) {
3357                 data->arg.ftype = NF4BLK;
3358                 data->arg.u.device.specdata1 = MAJOR(rdev);
3359                 data->arg.u.device.specdata2 = MINOR(rdev);
3360         }
3361         else if (S_ISCHR(mode)) {
3362                 data->arg.ftype = NF4CHR;
3363                 data->arg.u.device.specdata1 = MAJOR(rdev);
3364                 data->arg.u.device.specdata2 = MINOR(rdev);
3365         } else if (!S_ISSOCK(mode)) {
3366                 status = -EINVAL;
3367                 goto out_free;
3368         }
3369
3370         status = nfs4_do_create(dir, dentry, data);
3371 out_free:
3372         nfs4_free_createdata(data);
3373 out:
3374         return status;
3375 }
3376
3377 static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
3378                 struct iattr *sattr, dev_t rdev)
3379 {
3380         struct nfs4_exception exception = { };
3381         int err;
3382
3383         sattr->ia_mode &= ~current_umask();
3384         do {
3385                 err = nfs4_handle_exception(NFS_SERVER(dir),
3386                                 _nfs4_proc_mknod(dir, dentry, sattr, rdev),
3387                                 &exception);
3388         } while (exception.retry);
3389         return err;
3390 }
3391
3392 static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
3393                  struct nfs_fsstat *fsstat)
3394 {
3395         struct nfs4_statfs_arg args = {
3396                 .fh = fhandle,
3397                 .bitmask = server->attr_bitmask,
3398         };
3399         struct nfs4_statfs_res res = {
3400                 .fsstat = fsstat,
3401         };
3402         struct rpc_message msg = {
3403                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS],
3404                 .rpc_argp = &args,
3405                 .rpc_resp = &res,
3406         };
3407
3408         nfs_fattr_init(fsstat->fattr);
3409         return  nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3410 }
3411
3412 static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat)
3413 {
3414         struct nfs4_exception exception = { };
3415         int err;
3416         do {
3417                 err = nfs4_handle_exception(server,
3418                                 _nfs4_proc_statfs(server, fhandle, fsstat),
3419                                 &exception);
3420         } while (exception.retry);
3421         return err;
3422 }
3423
3424 static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
3425                 struct nfs_fsinfo *fsinfo)
3426 {
3427         struct nfs4_fsinfo_arg args = {
3428                 .fh = fhandle,
3429                 .bitmask = server->attr_bitmask,
3430         };
3431         struct nfs4_fsinfo_res res = {
3432                 .fsinfo = fsinfo,
3433         };
3434         struct rpc_message msg = {
3435                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO],
3436                 .rpc_argp = &args,
3437                 .rpc_resp = &res,
3438         };
3439
3440         return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3441 }
3442
3443 static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
3444 {
3445         struct nfs4_exception exception = { };
3446         int err;
3447
3448         do {
3449                 err = nfs4_handle_exception(server,
3450                                 _nfs4_do_fsinfo(server, fhandle, fsinfo),
3451                                 &exception);
3452         } while (exception.retry);
3453         return err;
3454 }
3455
3456 static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
3457 {
3458         int error;
3459
3460         nfs_fattr_init(fsinfo->fattr);
3461         error = nfs4_do_fsinfo(server, fhandle, fsinfo);
3462         if (error == 0) {
3463                 /* block layout checks this! */
3464                 server->pnfs_blksize = fsinfo->blksize;
3465                 set_pnfs_layoutdriver(server, fhandle, fsinfo->layouttype);
3466         }
3467
3468         return error;
3469 }
3470
3471 static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
3472                 struct nfs_pathconf *pathconf)
3473 {
3474         struct nfs4_pathconf_arg args = {
3475                 .fh = fhandle,
3476                 .bitmask = server->attr_bitmask,
3477         };
3478         struct nfs4_pathconf_res res = {
3479                 .pathconf = pathconf,
3480         };
3481         struct rpc_message msg = {
3482                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF],
3483                 .rpc_argp = &args,
3484                 .rpc_resp = &res,
3485         };
3486
3487         /* None of the pathconf attributes are mandatory to implement */
3488         if ((args.bitmask[0] & nfs4_pathconf_bitmap[0]) == 0) {
3489                 memset(pathconf, 0, sizeof(*pathconf));
3490                 return 0;
3491         }
3492
3493         nfs_fattr_init(pathconf->fattr);
3494         return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3495 }
3496
3497 static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
3498                 struct nfs_pathconf *pathconf)
3499 {
3500         struct nfs4_exception exception = { };
3501         int err;
3502
3503         do {
3504                 err = nfs4_handle_exception(server,
3505                                 _nfs4_proc_pathconf(server, fhandle, pathconf),
3506                                 &exception);
3507         } while (exception.retry);
3508         return err;
3509 }
3510
3511 int nfs4_set_rw_stateid(nfs4_stateid *stateid,
3512                 const struct nfs_open_context *ctx,
3513                 const struct nfs_lock_context *l_ctx,
3514                 fmode_t fmode)
3515 {
3516         const struct nfs_lockowner *lockowner = NULL;
3517
3518         if (l_ctx != NULL)
3519                 lockowner = &l_ctx->lockowner;
3520         return nfs4_select_rw_stateid(stateid, ctx->state, fmode, lockowner);
3521 }
3522 EXPORT_SYMBOL_GPL(nfs4_set_rw_stateid);
3523
3524 static bool nfs4_stateid_is_current(nfs4_stateid *stateid,
3525                 const struct nfs_open_context *ctx,
3526                 const struct nfs_lock_context *l_ctx,
3527                 fmode_t fmode)
3528 {
3529         nfs4_stateid current_stateid;
3530
3531         if (nfs4_set_rw_stateid(&current_stateid, ctx, l_ctx, fmode))
3532                 return false;
3533         return nfs4_stateid_match(stateid, &current_stateid);
3534 }
3535
3536 static bool nfs4_error_stateid_expired(int err)
3537 {
3538         switch (err) {
3539         case -NFS4ERR_DELEG_REVOKED:
3540         case -NFS4ERR_ADMIN_REVOKED:
3541         case -NFS4ERR_BAD_STATEID:
3542         case -NFS4ERR_STALE_STATEID:
3543         case -NFS4ERR_OLD_STATEID:
3544         case -NFS4ERR_OPENMODE:
3545         case -NFS4ERR_EXPIRED:
3546                 return true;
3547         }
3548         return false;
3549 }
3550
3551 void __nfs4_read_done_cb(struct nfs_read_data *data)
3552 {
3553         nfs_invalidate_atime(data->header->inode);
3554 }
3555
3556 static int nfs4_read_done_cb(struct rpc_task *task, struct nfs_read_data *data)
3557 {
3558         struct nfs_server *server = NFS_SERVER(data->header->inode);
3559
3560         if (nfs4_async_handle_error(task, server, data->args.context->state) == -EAGAIN) {
3561                 rpc_restart_call_prepare(task);
3562                 return -EAGAIN;
3563         }
3564
3565         __nfs4_read_done_cb(data);
3566         if (task->tk_status > 0)
3567                 renew_lease(server, data->timestamp);
3568         return 0;
3569 }
3570
3571 static bool nfs4_read_stateid_changed(struct rpc_task *task,
3572                 struct nfs_readargs *args)
3573 {
3574
3575         if (!nfs4_error_stateid_expired(task->tk_status) ||
3576                 nfs4_stateid_is_current(&args->stateid,
3577                                 args->context,
3578                                 args->lock_context,
3579                                 FMODE_READ))
3580                 return false;
3581         rpc_restart_call_prepare(task);
3582         return true;
3583 }
3584
3585 static int nfs4_read_done(struct rpc_task *task, struct nfs_read_data *data)
3586 {
3587
3588         dprintk("--> %s\n", __func__);
3589
3590         if (!nfs4_sequence_done(task, &data->res.seq_res))
3591                 return -EAGAIN;
3592         if (nfs4_read_stateid_changed(task, &data->args))
3593                 return -EAGAIN;
3594         return data->read_done_cb ? data->read_done_cb(task, data) :
3595                                     nfs4_read_done_cb(task, data);
3596 }
3597
3598 static void nfs4_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)
3599 {
3600         data->timestamp   = jiffies;
3601         data->read_done_cb = nfs4_read_done_cb;
3602         msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ];
3603         nfs41_init_sequence(&data->args.seq_args, &data->res.seq_res, 0);
3604 }
3605
3606 static void nfs4_proc_read_rpc_prepare(struct rpc_task *task, struct nfs_read_data *data)
3607 {
3608         if (nfs4_setup_sequence(NFS_SERVER(data->header->inode),
3609                         &data->args.seq_args,
3610                         &data->res.seq_res,
3611                         task))
3612                 return;
3613         nfs4_set_rw_stateid(&data->args.stateid, data->args.context,
3614                         data->args.lock_context, FMODE_READ);
3615 }
3616
3617 static int nfs4_write_done_cb(struct rpc_task *task, struct nfs_write_data *data)
3618 {
3619         struct inode *inode = data->header->inode;
3620
3621         if (nfs4_async_handle_error(task, NFS_SERVER(inode), data->args.context->state) == -EAGAIN) {
3622                 rpc_restart_call_prepare(task);
3623                 return -EAGAIN;
3624         }
3625         if (task->tk_status >= 0) {
3626                 renew_lease(NFS_SERVER(inode), data->timestamp);
3627                 nfs_post_op_update_inode_force_wcc(inode, &data->fattr);
3628         }
3629         return 0;
3630 }
3631
3632 static bool nfs4_write_stateid_changed(struct rpc_task *task,
3633                 struct nfs_writeargs *args)
3634 {
3635
3636         if (!nfs4_error_stateid_expired(task->tk_status) ||
3637                 nfs4_stateid_is_current(&args->stateid,
3638                                 args->context,
3639                                 args->lock_context,
3640                                 FMODE_WRITE))
3641                 return false;
3642         rpc_restart_call_prepare(task);
3643         return true;
3644 }
3645
3646 static int nfs4_write_done(struct rpc_task *task, struct nfs_write_data *data)
3647 {
3648         if (!nfs4_sequence_done(task, &data->res.seq_res))
3649                 return -EAGAIN;
3650         if (nfs4_write_stateid_changed(task, &data->args))
3651                 return -EAGAIN;
3652         return data->write_done_cb ? data->write_done_cb(task, data) :
3653                 nfs4_write_done_cb(task, data);
3654 }
3655
3656 static
3657 bool nfs4_write_need_cache_consistency_data(const struct nfs_write_data *data)
3658 {
3659         const struct nfs_pgio_header *hdr = data->header;
3660
3661         /* Don't request attributes for pNFS or O_DIRECT writes */
3662         if (data->ds_clp != NULL || hdr->dreq != NULL)
3663                 return false;
3664         /* Otherwise, request attributes if and only if we don't hold
3665          * a delegation
3666          */
3667         return nfs4_have_delegation(hdr->inode, FMODE_READ) == 0;
3668 }
3669
3670 static void nfs4_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)
3671 {
3672         struct nfs_server *server = NFS_SERVER(data->header->inode);
3673
3674         if (!nfs4_write_need_cache_consistency_data(data)) {
3675                 data->args.bitmask = NULL;
3676                 data->res.fattr = NULL;
3677         } else
3678                 data->args.bitmask = server->cache_consistency_bitmask;
3679
3680         if (!data->write_done_cb)
3681                 data->write_done_cb = nfs4_write_done_cb;
3682         data->res.server = server;
3683         data->timestamp   = jiffies;
3684
3685         msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE];
3686         nfs41_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
3687 }
3688
3689 static void nfs4_proc_write_rpc_prepare(struct rpc_task *task, struct nfs_write_data *data)
3690 {
3691         if (nfs4_setup_sequence(NFS_SERVER(data->header->inode),
3692                         &data->args.seq_args,
3693                         &data->res.seq_res,
3694                         task))
3695                 return;
3696         nfs4_set_rw_stateid(&data->args.stateid, data->args.context,
3697                         data->args.lock_context, FMODE_WRITE);
3698 }
3699
3700 static void nfs4_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
3701 {
3702         nfs4_setup_sequence(NFS_SERVER(data->inode),
3703                         &data->args.seq_args,
3704                         &data->res.seq_res,
3705                         task);
3706 }
3707
3708 static int nfs4_commit_done_cb(struct rpc_task *task, struct nfs_commit_data *data)
3709 {
3710         struct inode *inode = data->inode;
3711
3712         if (nfs4_async_handle_error(task, NFS_SERVER(inode), NULL) == -EAGAIN) {
3713                 rpc_restart_call_prepare(task);
3714                 return -EAGAIN;
3715         }
3716         return 0;
3717 }
3718
3719 static int nfs4_commit_done(struct rpc_task *task, struct nfs_commit_data *data)
3720 {
3721         if (!nfs4_sequence_done(task, &data->res.seq_res))
3722                 return -EAGAIN;
3723         return data->commit_done_cb(task, data);
3724 }
3725
3726 static void nfs4_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
3727 {
3728         struct nfs_server *server = NFS_SERVER(data->inode);
3729
3730         if (data->commit_done_cb == NULL)
3731                 data->commit_done_cb = nfs4_commit_done_cb;
3732         data->res.server = server;
3733         msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT];
3734         nfs41_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
3735 }
3736
3737 struct nfs4_renewdata {
3738         struct nfs_client       *client;
3739         unsigned long           timestamp;
3740 };
3741
3742 /*
3743  * nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special
3744  * standalone procedure for queueing an asynchronous RENEW.
3745  */
3746 static void nfs4_renew_release(void *calldata)
3747 {
3748         struct nfs4_renewdata *data = calldata;
3749         struct nfs_client *clp = data->client;
3750
3751         if (atomic_read(&clp->cl_count) > 1)
3752                 nfs4_schedule_state_renewal(clp);
3753         nfs_put_client(clp);
3754         kfree(data);
3755 }
3756
3757 static void nfs4_renew_done(struct rpc_task *task, void *calldata)
3758 {
3759         struct nfs4_renewdata *data = calldata;
3760         struct nfs_client *clp = data->client;
3761         unsigned long timestamp = data->timestamp;
3762
3763         if (task->tk_status < 0) {
3764                 /* Unless we're shutting down, schedule state recovery! */
3765                 if (test_bit(NFS_CS_RENEWD, &clp->cl_res_state) == 0)
3766                         return;
3767                 if (task->tk_status != NFS4ERR_CB_PATH_DOWN) {
3768                         nfs4_schedule_lease_recovery(clp);
3769                         return;
3770                 }
3771                 nfs4_schedule_path_down_recovery(clp);
3772         }
3773         do_renew_lease(clp, timestamp);
3774 }
3775
3776 static const struct rpc_call_ops nfs4_renew_ops = {
3777         .rpc_call_done = nfs4_renew_done,
3778         .rpc_release = nfs4_renew_release,
3779 };
3780
3781 static int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags)
3782 {
3783         struct rpc_message msg = {
3784                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
3785                 .rpc_argp       = clp,
3786                 .rpc_cred       = cred,
3787         };
3788         struct nfs4_renewdata *data;
3789
3790         if (renew_flags == 0)
3791                 return 0;
3792         if (!atomic_inc_not_zero(&clp->cl_count))
3793                 return -EIO;
3794         data = kmalloc(sizeof(*data), GFP_NOFS);
3795         if (data == NULL)
3796                 return -ENOMEM;
3797         data->client = clp;
3798         data->timestamp = jiffies;
3799         return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_SOFT,
3800                         &nfs4_renew_ops, data);
3801 }
3802
3803 static int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred)
3804 {
3805         struct rpc_message msg = {
3806                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
3807                 .rpc_argp       = clp,
3808                 .rpc_cred       = cred,
3809         };
3810         unsigned long now = jiffies;
3811         int status;
3812
3813         status = rpc_call_sync(clp->cl_rpcclient, &msg, 0);
3814         if (status < 0)
3815                 return status;
3816         do_renew_lease(clp, now);
3817         return 0;
3818 }
3819
3820 static inline int nfs4_server_supports_acls(struct nfs_server *server)
3821 {
3822         return (server->caps & NFS_CAP_ACLS)
3823                 && (server->acl_bitmask & ACL4_SUPPORT_ALLOW_ACL)
3824                 && (server->acl_bitmask & ACL4_SUPPORT_DENY_ACL);
3825 }
3826
3827 /* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_SIZE, and that
3828  * it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_SIZE) bytes on
3829  * the stack.
3830  */
3831 #define NFS4ACL_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE)
3832
3833 static int buf_to_pages_noslab(const void *buf, size_t buflen,
3834                 struct page **pages, unsigned int *pgbase)
3835 {
3836         struct page *newpage, **spages;
3837         int rc = 0;
3838         size_t len;
3839         spages = pages;
3840
3841         do {
3842                 len = min_t(size_t, PAGE_SIZE, buflen);
3843                 newpage = alloc_page(GFP_KERNEL);
3844
3845                 if (newpage == NULL)
3846                         goto unwind;
3847                 memcpy(page_address(newpage), buf, len);
3848                 buf += len;
3849                 buflen -= len;
3850                 *pages++ = newpage;
3851                 rc++;
3852         } while (buflen != 0);
3853
3854         return rc;
3855
3856 unwind:
3857         for(; rc > 0; rc--)
3858                 __free_page(spages[rc-1]);
3859         return -ENOMEM;
3860 }
3861
3862 struct nfs4_cached_acl {
3863         int cached;
3864         size_t len;
3865         char data[0];
3866 };
3867
3868 static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl)
3869 {
3870         struct nfs_inode *nfsi = NFS_I(inode);
3871
3872         spin_lock(&inode->i_lock);
3873         kfree(nfsi->nfs4_acl);
3874         nfsi->nfs4_acl = acl;
3875         spin_unlock(&inode->i_lock);
3876 }
3877
3878 static void nfs4_zap_acl_attr(struct inode *inode)
3879 {
3880         nfs4_set_cached_acl(inode, NULL);
3881 }
3882
3883 static inline ssize_t nfs4_read_cached_acl(struct inode *inode, char *buf, size_t buflen)
3884 {
3885         struct nfs_inode *nfsi = NFS_I(inode);
3886         struct nfs4_cached_acl *acl;
3887         int ret = -ENOENT;
3888
3889         spin_lock(&inode->i_lock);
3890         acl = nfsi->nfs4_acl;
3891         if (acl == NULL)
3892                 goto out;
3893         if (buf == NULL) /* user is just asking for length */
3894                 goto out_len;
3895         if (acl->cached == 0)
3896                 goto out;
3897         ret = -ERANGE; /* see getxattr(2) man page */
3898         if (acl->len > buflen)
3899                 goto out;
3900         memcpy(buf, acl->data, acl->len);
3901 out_len:
3902         ret = acl->len;
3903 out:
3904         spin_unlock(&inode->i_lock);
3905         return ret;
3906 }
3907
3908 static void nfs4_write_cached_acl(struct inode *inode, struct page **pages, size_t pgbase, size_t acl_len)
3909 {
3910         struct nfs4_cached_acl *acl;
3911         size_t buflen = sizeof(*acl) + acl_len;
3912
3913         if (buflen <= PAGE_SIZE) {
3914                 acl = kmalloc(buflen, GFP_KERNEL);
3915                 if (acl == NULL)
3916                         goto out;
3917                 acl->cached = 1;
3918                 _copy_from_pages(acl->data, pages, pgbase, acl_len);
3919         } else {
3920                 acl = kmalloc(sizeof(*acl), GFP_KERNEL);
3921                 if (acl == NULL)
3922                         goto out;
3923                 acl->cached = 0;
3924         }
3925         acl->len = acl_len;
3926 out:
3927         nfs4_set_cached_acl(inode, acl);
3928 }
3929
3930 /*
3931  * The getxattr API returns the required buffer length when called with a
3932  * NULL buf. The NFSv4 acl tool then calls getxattr again after allocating
3933  * the required buf.  On a NULL buf, we send a page of data to the server
3934  * guessing that the ACL request can be serviced by a page. If so, we cache
3935  * up to the page of ACL data, and the 2nd call to getxattr is serviced by
3936  * the cache. If not so, we throw away the page, and cache the required
3937  * length. The next getxattr call will then produce another round trip to
3938  * the server, this time with the input buf of the required size.
3939  */
3940 static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
3941 {
3942         struct page *pages[NFS4ACL_MAXPAGES] = {NULL, };
3943         struct nfs_getaclargs args = {
3944                 .fh = NFS_FH(inode),
3945                 .acl_pages = pages,
3946                 .acl_len = buflen,
3947         };
3948         struct nfs_getaclres res = {
3949                 .acl_len = buflen,
3950         };
3951         struct rpc_message msg = {
3952                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL],
3953                 .rpc_argp = &args,
3954                 .rpc_resp = &res,
3955         };
3956         unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE);
3957         int ret = -ENOMEM, i;
3958
3959         /* As long as we're doing a round trip to the server anyway,
3960          * let's be prepared for a page of acl data. */
3961         if (npages == 0)
3962                 npages = 1;
3963         if (npages > ARRAY_SIZE(pages))
3964                 return -ERANGE;
3965
3966         for (i = 0; i < npages; i++) {
3967                 pages[i] = alloc_page(GFP_KERNEL);
3968                 if (!pages[i])
3969                         goto out_free;
3970         }
3971
3972         /* for decoding across pages */
3973         res.acl_scratch = alloc_page(GFP_KERNEL);
3974         if (!res.acl_scratch)
3975                 goto out_free;
3976
3977         args.acl_len = npages * PAGE_SIZE;
3978         args.acl_pgbase = 0;
3979
3980         dprintk("%s  buf %p buflen %zu npages %d args.acl_len %zu\n",
3981                 __func__, buf, buflen, npages, args.acl_len);
3982         ret = nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode),
3983                              &msg, &args.seq_args, &res.seq_res, 0);
3984         if (ret)
3985                 goto out_free;
3986
3987         /* Handle the case where the passed-in buffer is too short */
3988         if (res.acl_flags & NFS4_ACL_TRUNC) {
3989                 /* Did the user only issue a request for the acl length? */
3990                 if (buf == NULL)
3991                         goto out_ok;
3992                 ret = -ERANGE;
3993                 goto out_free;
3994         }
3995         nfs4_write_cached_acl(inode, pages, res.acl_data_offset, res.acl_len);
3996         if (buf) {
3997                 if (res.acl_len > buflen) {
3998                         ret = -ERANGE;
3999                         goto out_free;
4000                 }
4001                 _copy_from_pages(buf, pages, res.acl_data_offset, res.acl_len);
4002         }
4003 out_ok:
4004         ret = res.acl_len;
4005 out_free:
4006         for (i = 0; i < npages; i++)
4007                 if (pages[i])
4008                         __free_page(pages[i]);
4009         if (res.acl_scratch)
4010                 __free_page(res.acl_scratch);
4011         return ret;
4012 }
4013
4014 static ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
4015 {
4016         struct nfs4_exception exception = { };
4017         ssize_t ret;
4018         do {
4019                 ret = __nfs4_get_acl_uncached(inode, buf, buflen);
4020                 if (ret >= 0)
4021                         break;
4022                 ret = nfs4_handle_exception(NFS_SERVER(inode), ret, &exception);
4023         } while (exception.retry);
4024         return ret;
4025 }
4026
4027 static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen)
4028 {
4029         struct nfs_server *server = NFS_SERVER(inode);
4030         int ret;
4031
4032         if (!nfs4_server_supports_acls(server))
4033                 return -EOPNOTSUPP;
4034         ret = nfs_revalidate_inode(server, inode);
4035         if (ret < 0)
4036                 return ret;
4037         if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL)
4038                 nfs_zap_acl_cache(inode);
4039         ret = nfs4_read_cached_acl(inode, buf, buflen);
4040         if (ret != -ENOENT)
4041                 /* -ENOENT is returned if there is no ACL or if there is an ACL
4042                  * but no cached acl data, just the acl length */
4043                 return ret;
4044         return nfs4_get_acl_uncached(inode, buf, buflen);
4045 }
4046
4047 static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
4048 {
4049         struct nfs_server *server = NFS_SERVER(inode);
4050         struct page *pages[NFS4ACL_MAXPAGES];
4051         struct nfs_setaclargs arg = {
4052                 .fh             = NFS_FH(inode),
4053                 .acl_pages      = pages,
4054                 .acl_len        = buflen,
4055         };
4056         struct nfs_setaclres res;
4057         struct rpc_message msg = {
4058                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_SETACL],
4059                 .rpc_argp       = &arg,
4060                 .rpc_resp       = &res,
4061         };
4062         unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE);
4063         int ret, i;
4064
4065         if (!nfs4_server_supports_acls(server))
4066                 return -EOPNOTSUPP;
4067         if (npages > ARRAY_SIZE(pages))
4068                 return -ERANGE;
4069         i = buf_to_pages_noslab(buf, buflen, arg.acl_pages, &arg.acl_pgbase);
4070         if (i < 0)
4071                 return i;
4072         nfs4_inode_return_delegation(inode);
4073         ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
4074
4075         /*
4076          * Free each page after tx, so the only ref left is
4077          * held by the network stack
4078          */
4079         for (; i > 0; i--)
4080                 put_page(pages[i-1]);
4081
4082         /*
4083          * Acl update can result in inode attribute update.
4084          * so mark the attribute cache invalid.
4085          */
4086         spin_lock(&inode->i_lock);
4087         NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR;
4088         spin_unlock(&inode->i_lock);
4089         nfs_access_zap_cache(inode);
4090         nfs_zap_acl_cache(inode);
4091         return ret;
4092 }
4093
4094 static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
4095 {
4096         struct nfs4_exception exception = { };
4097         int err;
4098         do {
4099                 err = nfs4_handle_exception(NFS_SERVER(inode),
4100                                 __nfs4_proc_set_acl(inode, buf, buflen),
4101                                 &exception);
4102         } while (exception.retry);
4103         return err;
4104 }
4105
4106 static int
4107 nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server, struct nfs4_state *state)
4108 {
4109         struct nfs_client *clp = server->nfs_client;
4110
4111         if (task->tk_status >= 0)
4112                 return 0;
4113         switch(task->tk_status) {
4114                 case -NFS4ERR_DELEG_REVOKED:
4115                 case -NFS4ERR_ADMIN_REVOKED:
4116                 case -NFS4ERR_BAD_STATEID:
4117                         if (state == NULL)
4118                                 break;
4119                         nfs_remove_bad_delegation(state->inode);
4120                 case -NFS4ERR_OPENMODE:
4121                         if (state == NULL)
4122                                 break;
4123                         if (nfs4_schedule_stateid_recovery(server, state) < 0)
4124                                 goto stateid_invalid;
4125                         goto wait_on_recovery;
4126                 case -NFS4ERR_EXPIRED:
4127                         if (state != NULL) {
4128                                 if (nfs4_schedule_stateid_recovery(server, state) < 0)
4129                                         goto stateid_invalid;
4130                         }
4131                 case -NFS4ERR_STALE_STATEID:
4132                 case -NFS4ERR_STALE_CLIENTID:
4133                         nfs4_schedule_lease_recovery(clp);
4134                         goto wait_on_recovery;
4135 #if defined(CONFIG_NFS_V4_1)
4136                 case -NFS4ERR_BADSESSION:
4137                 case -NFS4ERR_BADSLOT:
4138                 case -NFS4ERR_BAD_HIGH_SLOT:
4139                 case -NFS4ERR_DEADSESSION:
4140                 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
4141                 case -NFS4ERR_SEQ_FALSE_RETRY:
4142                 case -NFS4ERR_SEQ_MISORDERED:
4143                         dprintk("%s ERROR %d, Reset session\n", __func__,
4144                                 task->tk_status);
4145                         nfs4_schedule_session_recovery(clp->cl_session, task->tk_status);
4146                         task->tk_status = 0;
4147                         return -EAGAIN;
4148 #endif /* CONFIG_NFS_V4_1 */
4149                 case -NFS4ERR_DELAY:
4150                         nfs_inc_server_stats(server, NFSIOS_DELAY);
4151                 case -NFS4ERR_GRACE:
4152                         rpc_delay(task, NFS4_POLL_RETRY_MAX);
4153                         task->tk_status = 0;
4154                         return -EAGAIN;
4155                 case -NFS4ERR_RETRY_UNCACHED_REP:
4156                 case -NFS4ERR_OLD_STATEID:
4157                         task->tk_status = 0;
4158                         return -EAGAIN;
4159         }
4160         task->tk_status = nfs4_map_errors(task->tk_status);
4161         return 0;
4162 stateid_invalid:
4163         task->tk_status = -EIO;
4164         return 0;
4165 wait_on_recovery:
4166         rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL);
4167         if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0)
4168                 rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task);
4169         task->tk_status = 0;
4170         return -EAGAIN;
4171 }
4172
4173 static void nfs4_init_boot_verifier(const struct nfs_client *clp,
4174                                     nfs4_verifier *bootverf)
4175 {
4176         __be32 verf[2];
4177
4178         if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
4179                 /* An impossible timestamp guarantees this value
4180                  * will never match a generated boot time. */
4181                 verf[0] = 0;
4182                 verf[1] = (__be32)(NSEC_PER_SEC + 1);
4183         } else {
4184                 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
4185                 verf[0] = (__be32)nn->boot_time.tv_sec;
4186                 verf[1] = (__be32)nn->boot_time.tv_nsec;
4187         }
4188         memcpy(bootverf->data, verf, sizeof(bootverf->data));
4189 }
4190
4191 static unsigned int
4192 nfs4_init_nonuniform_client_string(const struct nfs_client *clp,
4193                                    char *buf, size_t len)
4194 {
4195         unsigned int result;
4196
4197         rcu_read_lock();
4198         result = scnprintf(buf, len, "Linux NFSv4.0 %s/%s %s",
4199                                 clp->cl_ipaddr,
4200                                 rpc_peeraddr2str(clp->cl_rpcclient,
4201                                                         RPC_DISPLAY_ADDR),
4202                                 rpc_peeraddr2str(clp->cl_rpcclient,
4203                                                         RPC_DISPLAY_PROTO));
4204         rcu_read_unlock();
4205         return result;
4206 }
4207
4208 static unsigned int
4209 nfs4_init_uniform_client_string(const struct nfs_client *clp,
4210                                 char *buf, size_t len)
4211 {
4212         char *nodename = clp->cl_rpcclient->cl_nodename;
4213
4214         if (nfs4_client_id_uniquifier[0] != '\0')
4215                 nodename = nfs4_client_id_uniquifier;
4216         return scnprintf(buf, len, "Linux NFSv%u.%u %s",
4217                                 clp->rpc_ops->version, clp->cl_minorversion,
4218                                 nodename);
4219 }
4220
4221 /**
4222  * nfs4_proc_setclientid - Negotiate client ID
4223  * @clp: state data structure
4224  * @program: RPC program for NFSv4 callback service
4225  * @port: IP port number for NFS4 callback service
4226  * @cred: RPC credential to use for this call
4227  * @res: where to place the result
4228  *
4229  * Returns zero, a negative errno, or a negative NFS4ERR status code.
4230  */
4231 int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,
4232                 unsigned short port, struct rpc_cred *cred,
4233                 struct nfs4_setclientid_res *res)
4234 {
4235         nfs4_verifier sc_verifier;
4236         struct nfs4_setclientid setclientid = {
4237                 .sc_verifier = &sc_verifier,
4238                 .sc_prog = program,
4239                 .sc_cb_ident = clp->cl_cb_ident,
4240         };
4241         struct rpc_message msg = {
4242                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID],
4243                 .rpc_argp = &setclientid,
4244                 .rpc_resp = res,
4245                 .rpc_cred = cred,
4246         };
4247         int status;
4248
4249         /* nfs_client_id4 */
4250         nfs4_init_boot_verifier(clp, &sc_verifier);
4251         if (test_bit(NFS_CS_MIGRATION, &clp->cl_flags))
4252                 setclientid.sc_name_len =
4253                                 nfs4_init_uniform_client_string(clp,
4254                                                 setclientid.sc_name,
4255                                                 sizeof(setclientid.sc_name));
4256         else
4257                 setclientid.sc_name_len =
4258                                 nfs4_init_nonuniform_client_string(clp,
4259                                                 setclientid.sc_name,
4260                                                 sizeof(setclientid.sc_name));
4261         /* cb_client4 */
4262         rcu_read_lock();
4263         setclientid.sc_netid_len = scnprintf(setclientid.sc_netid,
4264                                 sizeof(setclientid.sc_netid),
4265                                 rpc_peeraddr2str(clp->cl_rpcclient,
4266                                                         RPC_DISPLAY_NETID));
4267         rcu_read_unlock();
4268         setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr,
4269                                 sizeof(setclientid.sc_uaddr), "%s.%u.%u",
4270                                 clp->cl_ipaddr, port >> 8, port & 255);
4271
4272         dprintk("NFS call  setclientid auth=%s, '%.*s'\n",
4273                 clp->cl_rpcclient->cl_auth->au_ops->au_name,
4274                 setclientid.sc_name_len, setclientid.sc_name);
4275         status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
4276         dprintk("NFS reply setclientid: %d\n", status);
4277         return status;
4278 }
4279
4280 /**
4281  * nfs4_proc_setclientid_confirm - Confirm client ID
4282  * @clp: state data structure
4283  * @res: result of a previous SETCLIENTID
4284  * @cred: RPC credential to use for this call
4285  *
4286  * Returns zero, a negative errno, or a negative NFS4ERR status code.
4287  */
4288 int nfs4_proc_setclientid_confirm(struct nfs_client *clp,
4289                 struct nfs4_setclientid_res *arg,
4290                 struct rpc_cred *cred)
4291 {
4292         struct nfs_fsinfo fsinfo;
4293         struct rpc_message msg = {
4294                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM],
4295                 .rpc_argp = arg,
4296                 .rpc_resp = &fsinfo,
4297                 .rpc_cred = cred,
4298         };
4299         unsigned long now;
4300         int status;
4301
4302         dprintk("NFS call  setclientid_confirm auth=%s, (client ID %llx)\n",
4303                 clp->cl_rpcclient->cl_auth->au_ops->au_name,
4304                 clp->cl_clientid);
4305         now = jiffies;
4306         status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
4307         if (status == 0) {
4308                 spin_lock(&clp->cl_lock);
4309                 clp->cl_lease_time = fsinfo.lease_time * HZ;
4310                 clp->cl_last_renewal = now;
4311                 spin_unlock(&clp->cl_lock);
4312         }
4313         dprintk("NFS reply setclientid_confirm: %d\n", status);
4314         return status;
4315 }
4316
4317 struct nfs4_delegreturndata {
4318         struct nfs4_delegreturnargs args;
4319         struct nfs4_delegreturnres res;
4320         struct nfs_fh fh;
4321         nfs4_stateid stateid;
4322         unsigned long timestamp;
4323         struct nfs_fattr fattr;
4324         int rpc_status;
4325 };
4326
4327 static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata)
4328 {
4329         struct nfs4_delegreturndata *data = calldata;
4330
4331         if (!nfs4_sequence_done(task, &data->res.seq_res))
4332                 return;
4333
4334         switch (task->tk_status) {
4335         case -NFS4ERR_STALE_STATEID:
4336         case -NFS4ERR_EXPIRED:
4337         case 0:
4338                 renew_lease(data->res.server, data->timestamp);
4339                 break;
4340         default:
4341                 if (nfs4_async_handle_error(task, data->res.server, NULL) ==
4342                                 -EAGAIN) {
4343                         rpc_restart_call_prepare(task);
4344                         return;
4345                 }
4346         }
4347         data->rpc_status = task->tk_status;
4348 }
4349
4350 static void nfs4_delegreturn_release(void *calldata)
4351 {
4352         kfree(calldata);
4353 }
4354
4355 #if defined(CONFIG_NFS_V4_1)
4356 static void nfs4_delegreturn_prepare(struct rpc_task *task, void *data)
4357 {
4358         struct nfs4_delegreturndata *d_data;
4359
4360         d_data = (struct nfs4_delegreturndata *)data;
4361
4362         nfs4_setup_sequence(d_data->res.server,
4363                         &d_data->args.seq_args,
4364                         &d_data->res.seq_res,
4365                         task);
4366 }
4367 #endif /* CONFIG_NFS_V4_1 */
4368
4369 static const struct rpc_call_ops nfs4_delegreturn_ops = {
4370 #if defined(CONFIG_NFS_V4_1)
4371         .rpc_call_prepare = nfs4_delegreturn_prepare,
4372 #endif /* CONFIG_NFS_V4_1 */
4373         .rpc_call_done = nfs4_delegreturn_done,
4374         .rpc_release = nfs4_delegreturn_release,
4375 };
4376
4377 static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
4378 {
4379         struct nfs4_delegreturndata *data;
4380         struct nfs_server *server = NFS_SERVER(inode);
4381         struct rpc_task *task;
4382         struct rpc_message msg = {
4383                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN],
4384                 .rpc_cred = cred,
4385         };
4386         struct rpc_task_setup task_setup_data = {
4387                 .rpc_client = server->client,
4388                 .rpc_message = &msg,
4389                 .callback_ops = &nfs4_delegreturn_ops,
4390                 .flags = RPC_TASK_ASYNC,
4391         };
4392         int status = 0;
4393
4394         data = kzalloc(sizeof(*data), GFP_NOFS);
4395         if (data == NULL)
4396                 return -ENOMEM;
4397         nfs41_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
4398         data->args.fhandle = &data->fh;
4399         data->args.stateid = &data->stateid;
4400         data->args.bitmask = server->cache_consistency_bitmask;
4401         nfs_copy_fh(&data->fh, NFS_FH(inode));
4402         nfs4_stateid_copy(&data->stateid, stateid);
4403         data->res.fattr = &data->fattr;
4404         data->res.server = server;
4405         nfs_fattr_init(data->res.fattr);
4406         data->timestamp = jiffies;
4407         data->rpc_status = 0;
4408
4409         task_setup_data.callback_data = data;
4410         msg.rpc_argp = &data->args;
4411         msg.rpc_resp = &data->res;
4412         task = rpc_run_task(&task_setup_data);
4413         if (IS_ERR(task))
4414                 return PTR_ERR(task);
4415         if (!issync)
4416                 goto out;
4417         status = nfs4_wait_for_completion_rpc_task(task);
4418         if (status != 0)
4419                 goto out;
4420         status = data->rpc_status;
4421         if (status == 0)
4422                 nfs_post_op_update_inode_force_wcc(inode, &data->fattr);
4423         else
4424                 nfs_refresh_inode(inode, &data->fattr);
4425 out:
4426         rpc_put_task(task);
4427         return status;
4428 }
4429
4430 int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
4431 {
4432         struct nfs_server *server = NFS_SERVER(inode);
4433         struct nfs4_exception exception = { };
4434         int err;
4435         do {
4436                 err = _nfs4_proc_delegreturn(inode, cred, stateid, issync);
4437                 switch (err) {
4438                         case -NFS4ERR_STALE_STATEID:
4439                         case -NFS4ERR_EXPIRED:
4440                         case 0:
4441                                 return 0;
4442                 }
4443                 err = nfs4_handle_exception(server, err, &exception);
4444         } while (exception.retry);
4445         return err;
4446 }
4447
4448 #define NFS4_LOCK_MINTIMEOUT (1 * HZ)
4449 #define NFS4_LOCK_MAXTIMEOUT (30 * HZ)
4450
4451 /*
4452  * sleep, with exponential backoff, and retry the LOCK operation.
4453  */
4454 static unsigned long
4455 nfs4_set_lock_task_retry(unsigned long timeout)
4456 {
4457         freezable_schedule_timeout_killable(timeout);
4458         timeout <<= 1;
4459         if (timeout > NFS4_LOCK_MAXTIMEOUT)
4460                 return NFS4_LOCK_MAXTIMEOUT;
4461         return timeout;
4462 }
4463
4464 static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
4465 {
4466         struct inode *inode = state->inode;
4467         struct nfs_server *server = NFS_SERVER(inode);
4468         struct nfs_client *clp = server->nfs_client;
4469         struct nfs_lockt_args arg = {
4470                 .fh = NFS_FH(inode),
4471                 .fl = request,
4472         };
4473         struct nfs_lockt_res res = {
4474                 .denied = request,
4475         };
4476         struct rpc_message msg = {
4477                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_LOCKT],
4478                 .rpc_argp       = &arg,
4479                 .rpc_resp       = &res,
4480                 .rpc_cred       = state->owner->so_cred,
4481         };
4482         struct nfs4_lock_state *lsp;
4483         int status;
4484
4485         arg.lock_owner.clientid = clp->cl_clientid;
4486         status = nfs4_set_lock_state(state, request);
4487         if (status != 0)
4488                 goto out;
4489         lsp = request->fl_u.nfs4_fl.owner;
4490         arg.lock_owner.id = lsp->ls_seqid.owner_id;
4491         arg.lock_owner.s_dev = server->s_dev;
4492         status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
4493         switch (status) {
4494                 case 0:
4495                         request->fl_type = F_UNLCK;
4496                         break;
4497                 case -NFS4ERR_DENIED:
4498                         status = 0;
4499         }
4500         request->fl_ops->fl_release_private(request);
4501 out:
4502         return status;
4503 }
4504
4505 static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
4506 {
4507         struct nfs4_exception exception = { };
4508         int err;
4509
4510         do {
4511                 err = nfs4_handle_exception(NFS_SERVER(state->inode),
4512                                 _nfs4_proc_getlk(state, cmd, request),
4513                                 &exception);
4514         } while (exception.retry);
4515         return err;
4516 }
4517
4518 static int do_vfs_lock(struct file *file, struct file_lock *fl)
4519 {
4520         int res = 0;
4521         switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
4522                 case FL_POSIX:
4523                         res = posix_lock_file_wait(file, fl);
4524                         break;
4525                 case FL_FLOCK:
4526                         res = flock_lock_file_wait(file, fl);
4527                         break;
4528                 default:
4529                         BUG();
4530         }
4531         return res;
4532 }
4533
4534 struct nfs4_unlockdata {
4535         struct nfs_locku_args arg;
4536         struct nfs_locku_res res;
4537         struct nfs4_lock_state *lsp;
4538         struct nfs_open_context *ctx;
4539         struct file_lock fl;
4540         const struct nfs_server *server;
4541         unsigned long timestamp;
4542 };
4543
4544 static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,
4545                 struct nfs_open_context *ctx,
4546                 struct nfs4_lock_state *lsp,
4547                 struct nfs_seqid *seqid)
4548 {
4549         struct nfs4_unlockdata *p;
4550         struct inode *inode = lsp->ls_state->inode;
4551
4552         p = kzalloc(sizeof(*p), GFP_NOFS);
4553         if (p == NULL)
4554                 return NULL;
4555         p->arg.fh = NFS_FH(inode);
4556         p->arg.fl = &p->fl;
4557         p->arg.seqid = seqid;
4558         p->res.seqid = seqid;
4559         p->arg.stateid = &lsp->ls_stateid;
4560         p->lsp = lsp;
4561         atomic_inc(&lsp->ls_count);
4562         /* Ensure we don't close file until we're done freeing locks! */
4563         p->ctx = get_nfs_open_context(ctx);
4564         memcpy(&p->fl, fl, sizeof(p->fl));
4565         p->server = NFS_SERVER(inode);
4566         return p;
4567 }
4568
4569 static void nfs4_locku_release_calldata(void *data)
4570 {
4571         struct nfs4_unlockdata *calldata = data;
4572         nfs_free_seqid(calldata->arg.seqid);
4573         nfs4_put_lock_state(calldata->lsp);
4574         put_nfs_open_context(calldata->ctx);
4575         kfree(calldata);
4576 }
4577
4578 static void nfs4_locku_done(struct rpc_task *task, void *data)
4579 {
4580         struct nfs4_unlockdata *calldata = data;
4581
4582         if (!nfs4_sequence_done(task, &calldata->res.seq_res))
4583                 return;
4584         switch (task->tk_status) {
4585                 case 0:
4586                         nfs4_stateid_copy(&calldata->lsp->ls_stateid,
4587                                         &calldata->res.stateid);
4588                         renew_lease(calldata->server, calldata->timestamp);
4589                         break;
4590                 case -NFS4ERR_BAD_STATEID:
4591                 case -NFS4ERR_OLD_STATEID:
4592                 case -NFS4ERR_STALE_STATEID:
4593                 case -NFS4ERR_EXPIRED:
4594                         break;
4595                 default:
4596                         if (nfs4_async_handle_error(task, calldata->server, NULL) == -EAGAIN)
4597                                 rpc_restart_call_prepare(task);
4598         }
4599         nfs_release_seqid(calldata->arg.seqid);
4600 }
4601
4602 static void nfs4_locku_prepare(struct rpc_task *task, void *data)
4603 {
4604         struct nfs4_unlockdata *calldata = data;
4605
4606         if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
4607                 goto out_wait;
4608         if (test_bit(NFS_LOCK_INITIALIZED, &calldata->lsp->ls_flags) == 0) {
4609                 /* Note: exit _without_ running nfs4_locku_done */
4610                 goto out_no_action;
4611         }
4612         calldata->timestamp = jiffies;
4613         if (nfs4_setup_sequence(calldata->server,
4614                                 &calldata->arg.seq_args,
4615                                 &calldata->res.seq_res,
4616                                 task) != 0)
4617                 nfs_release_seqid(calldata->arg.seqid);
4618         return;
4619 out_no_action:
4620         task->tk_action = NULL;
4621 out_wait:
4622         nfs4_sequence_done(task, &calldata->res.seq_res);
4623 }
4624
4625 static const struct rpc_call_ops nfs4_locku_ops = {
4626         .rpc_call_prepare = nfs4_locku_prepare,
4627         .rpc_call_done = nfs4_locku_done,
4628         .rpc_release = nfs4_locku_release_calldata,
4629 };
4630
4631 static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,
4632                 struct nfs_open_context *ctx,
4633                 struct nfs4_lock_state *lsp,
4634                 struct nfs_seqid *seqid)
4635 {
4636         struct nfs4_unlockdata *data;
4637         struct rpc_message msg = {
4638                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU],
4639                 .rpc_cred = ctx->cred,
4640         };
4641         struct rpc_task_setup task_setup_data = {
4642                 .rpc_client = NFS_CLIENT(lsp->ls_state->inode),
4643                 .rpc_message = &msg,
4644                 .callback_ops = &nfs4_locku_ops,
4645                 .workqueue = nfsiod_workqueue,
4646                 .flags = RPC_TASK_ASYNC,
4647         };
4648
4649         /* Ensure this is an unlock - when canceling a lock, the
4650          * canceled lock is passed in, and it won't be an unlock.
4651          */
4652         fl->fl_type = F_UNLCK;
4653
4654         data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid);
4655         if (data == NULL) {
4656                 nfs_free_seqid(seqid);
4657                 return ERR_PTR(-ENOMEM);
4658         }
4659
4660         nfs41_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1);
4661         msg.rpc_argp = &data->arg;
4662         msg.rpc_resp = &data->res;
4663         task_setup_data.callback_data = data;
4664         return rpc_run_task(&task_setup_data);
4665 }
4666
4667 static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request)
4668 {
4669         struct inode *inode = state->inode;
4670         struct nfs4_state_owner *sp = state->owner;
4671         struct nfs_inode *nfsi = NFS_I(inode);
4672         struct nfs_seqid *seqid;
4673         struct nfs4_lock_state *lsp;
4674         struct rpc_task *task;
4675         int status = 0;
4676         unsigned char fl_flags = request->fl_flags;
4677
4678         status = nfs4_set_lock_state(state, request);
4679         /* Unlock _before_ we do the RPC call */
4680         request->fl_flags |= FL_EXISTS;
4681         /* Exclude nfs_delegation_claim_locks() */
4682         mutex_lock(&sp->so_delegreturn_mutex);
4683         /* Exclude nfs4_reclaim_open_stateid() - note nesting! */
4684         down_read(&nfsi->rwsem);
4685         if (do_vfs_lock(request->fl_file, request) == -ENOENT) {
4686                 up_read(&nfsi->rwsem);
4687                 mutex_unlock(&sp->so_delegreturn_mutex);
4688                 goto out;
4689         }
4690         up_read(&nfsi->rwsem);
4691         mutex_unlock(&sp->so_delegreturn_mutex);
4692         if (status != 0)
4693                 goto out;
4694         /* Is this a delegated lock? */
4695         if (test_bit(NFS_DELEGATED_STATE, &state->flags))
4696                 goto out;
4697         lsp = request->fl_u.nfs4_fl.owner;
4698         seqid = nfs_alloc_seqid(&lsp->ls_seqid, GFP_KERNEL);
4699         status = -ENOMEM;
4700         if (seqid == NULL)
4701                 goto out;
4702         task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid);
4703         status = PTR_ERR(task);
4704         if (IS_ERR(task))
4705                 goto out;
4706         status = nfs4_wait_for_completion_rpc_task(task);
4707         rpc_put_task(task);
4708 out:
4709         request->fl_flags = fl_flags;
4710         return status;
4711 }
4712
4713 struct nfs4_lockdata {
4714         struct nfs_lock_args arg;
4715         struct nfs_lock_res res;
4716         struct nfs4_lock_state *lsp;
4717         struct nfs_open_context *ctx;
4718         struct file_lock fl;
4719         unsigned long timestamp;
4720         int rpc_status;
4721         int cancelled;
4722         struct nfs_server *server;
4723 };
4724
4725 static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl,
4726                 struct nfs_open_context *ctx, struct nfs4_lock_state *lsp,
4727                 gfp_t gfp_mask)
4728 {
4729         struct nfs4_lockdata *p;
4730         struct inode *inode = lsp->ls_state->inode;
4731         struct nfs_server *server = NFS_SERVER(inode);
4732
4733         p = kzalloc(sizeof(*p), gfp_mask);
4734         if (p == NULL)
4735                 return NULL;
4736
4737         p->arg.fh = NFS_FH(inode);
4738         p->arg.fl = &p->fl;
4739         p->arg.open_seqid = nfs_alloc_seqid(&lsp->ls_state->owner->so_seqid, gfp_mask);
4740         if (p->arg.open_seqid == NULL)
4741                 goto out_free;
4742         p->arg.lock_seqid = nfs_alloc_seqid(&lsp->ls_seqid, gfp_mask);
4743         if (p->arg.lock_seqid == NULL)
4744                 goto out_free_seqid;
4745         p->arg.lock_stateid = &lsp->ls_stateid;
4746         p->arg.lock_owner.clientid = server->nfs_client->cl_clientid;
4747         p->arg.lock_owner.id = lsp->ls_seqid.owner_id;
4748         p->arg.lock_owner.s_dev = server->s_dev;
4749         p->res.lock_seqid = p->arg.lock_seqid;
4750         p->lsp = lsp;
4751         p->server = server;
4752         atomic_inc(&lsp->ls_count);
4753         p->ctx = get_nfs_open_context(ctx);
4754         memcpy(&p->fl, fl, sizeof(p->fl));
4755         return p;
4756 out_free_seqid:
4757         nfs_free_seqid(p->arg.open_seqid);
4758 out_free:
4759         kfree(p);
4760         return NULL;
4761 }
4762
4763 static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)
4764 {
4765         struct nfs4_lockdata *data = calldata;
4766         struct nfs4_state *state = data->lsp->ls_state;
4767
4768         dprintk("%s: begin!\n", __func__);
4769         if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0)
4770                 goto out_wait;
4771         /* Do we need to do an open_to_lock_owner? */
4772         if (!(data->arg.lock_seqid->sequence->flags & NFS_SEQID_CONFIRMED)) {
4773                 if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0) {
4774                         goto out_release_lock_seqid;
4775                 }
4776                 data->arg.open_stateid = &state->stateid;
4777                 data->arg.new_lock_owner = 1;
4778                 data->res.open_seqid = data->arg.open_seqid;
4779         } else
4780                 data->arg.new_lock_owner = 0;
4781         if (!nfs4_valid_open_stateid(state)) {
4782                 data->rpc_status = -EBADF;
4783                 task->tk_action = NULL;
4784                 goto out_release_open_seqid;
4785         }
4786         data->timestamp = jiffies;
4787         if (nfs4_setup_sequence(data->server,
4788                                 &data->arg.seq_args,
4789                                 &data->res.seq_res,
4790                                 task) == 0)
4791                 return;
4792 out_release_open_seqid:
4793         nfs_release_seqid(data->arg.open_seqid);
4794 out_release_lock_seqid:
4795         nfs_release_seqid(data->arg.lock_seqid);
4796 out_wait:
4797         nfs4_sequence_done(task, &data->res.seq_res);
4798         dprintk("%s: done!, ret = %d\n", __func__, data->rpc_status);
4799 }
4800
4801 static void nfs4_lock_done(struct rpc_task *task, void *calldata)
4802 {
4803         struct nfs4_lockdata *data = calldata;
4804
4805         dprintk("%s: begin!\n", __func__);
4806
4807         if (!nfs4_sequence_done(task, &data->res.seq_res))
4808                 return;
4809
4810         data->rpc_status = task->tk_status;
4811         if (data->arg.new_lock_owner != 0) {
4812                 if (data->rpc_status == 0)
4813                         nfs_confirm_seqid(&data->lsp->ls_seqid, 0);
4814                 else
4815                         goto out;
4816         }
4817         if (data->rpc_status == 0) {
4818                 nfs4_stateid_copy(&data->lsp->ls_stateid, &data->res.stateid);
4819                 set_bit(NFS_LOCK_INITIALIZED, &data->lsp->ls_flags);
4820                 renew_lease(NFS_SERVER(data->ctx->dentry->d_inode), data->timestamp);
4821         }
4822 out:
4823         dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status);
4824 }
4825
4826 static void nfs4_lock_release(void *calldata)
4827 {
4828         struct nfs4_lockdata *data = calldata;
4829
4830         dprintk("%s: begin!\n", __func__);
4831         nfs_free_seqid(data->arg.open_seqid);
4832         if (data->cancelled != 0) {
4833                 struct rpc_task *task;
4834                 task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp,
4835                                 data->arg.lock_seqid);
4836                 if (!IS_ERR(task))
4837                         rpc_put_task_async(task);
4838                 dprintk("%s: cancelling lock!\n", __func__);
4839         } else
4840                 nfs_free_seqid(data->arg.lock_seqid);
4841         nfs4_put_lock_state(data->lsp);
4842         put_nfs_open_context(data->ctx);
4843         kfree(data);
4844         dprintk("%s: done!\n", __func__);
4845 }
4846
4847 static const struct rpc_call_ops nfs4_lock_ops = {
4848         .rpc_call_prepare = nfs4_lock_prepare,
4849         .rpc_call_done = nfs4_lock_done,
4850         .rpc_release = nfs4_lock_release,
4851 };
4852
4853 static void nfs4_handle_setlk_error(struct nfs_server *server, struct nfs4_lock_state *lsp, int new_lock_owner, int error)
4854 {
4855         switch (error) {
4856         case -NFS4ERR_ADMIN_REVOKED:
4857         case -NFS4ERR_BAD_STATEID:
4858                 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;
4859                 if (new_lock_owner != 0 ||
4860                    test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0)
4861                         nfs4_schedule_stateid_recovery(server, lsp->ls_state);
4862                 break;
4863         case -NFS4ERR_STALE_STATEID:
4864                 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;
4865         case -NFS4ERR_EXPIRED:
4866                 nfs4_schedule_lease_recovery(server->nfs_client);
4867         };
4868 }
4869
4870 static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int recovery_type)
4871 {
4872         struct nfs4_lockdata *data;
4873         struct rpc_task *task;
4874         struct rpc_message msg = {
4875                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK],
4876                 .rpc_cred = state->owner->so_cred,
4877         };
4878         struct rpc_task_setup task_setup_data = {
4879                 .rpc_client = NFS_CLIENT(state->inode),
4880                 .rpc_message = &msg,
4881                 .callback_ops = &nfs4_lock_ops,
4882                 .workqueue = nfsiod_workqueue,
4883                 .flags = RPC_TASK_ASYNC,
4884         };
4885         int ret;
4886
4887         dprintk("%s: begin!\n", __func__);
4888         data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file),
4889                         fl->fl_u.nfs4_fl.owner,
4890                         recovery_type == NFS_LOCK_NEW ? GFP_KERNEL : GFP_NOFS);
4891         if (data == NULL)
4892                 return -ENOMEM;
4893         if (IS_SETLKW(cmd))
4894                 data->arg.block = 1;
4895         nfs41_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1);
4896         msg.rpc_argp = &data->arg;
4897         msg.rpc_resp = &data->res;
4898         task_setup_data.callback_data = data;
4899         if (recovery_type > NFS_LOCK_NEW) {
4900                 if (recovery_type == NFS_LOCK_RECLAIM)
4901                         data->arg.reclaim = NFS_LOCK_RECLAIM;
4902                 nfs4_set_sequence_privileged(&data->arg.seq_args);
4903         }
4904         task = rpc_run_task(&task_setup_data);
4905         if (IS_ERR(task))
4906                 return PTR_ERR(task);
4907         ret = nfs4_wait_for_completion_rpc_task(task);
4908         if (ret == 0) {
4909                 ret = data->rpc_status;
4910                 if (ret)
4911                         nfs4_handle_setlk_error(data->server, data->lsp,
4912                                         data->arg.new_lock_owner, ret);
4913         } else
4914                 data->cancelled = 1;
4915         rpc_put_task(task);
4916         dprintk("%s: done, ret = %d!\n", __func__, ret);
4917         return ret;
4918 }
4919
4920 static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request)
4921 {
4922         struct nfs_server *server = NFS_SERVER(state->inode);
4923         struct nfs4_exception exception = {
4924                 .inode = state->inode,
4925         };
4926         int err;
4927
4928         do {
4929                 /* Cache the lock if possible... */
4930                 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
4931                         return 0;
4932                 err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_RECLAIM);
4933                 if (err != -NFS4ERR_DELAY)
4934                         break;
4935                 nfs4_handle_exception(server, err, &exception);
4936         } while (exception.retry);
4937         return err;
4938 }
4939
4940 static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request)
4941 {
4942         struct nfs_server *server = NFS_SERVER(state->inode);
4943         struct nfs4_exception exception = {
4944                 .inode = state->inode,
4945         };
4946         int err;
4947
4948         err = nfs4_set_lock_state(state, request);
4949         if (err != 0)
4950                 return err;
4951         do {
4952                 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
4953                         return 0;
4954                 err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_EXPIRED);
4955                 switch (err) {
4956                 default:
4957                         goto out;
4958                 case -NFS4ERR_GRACE:
4959                 case -NFS4ERR_DELAY:
4960                         nfs4_handle_exception(server, err, &exception);
4961                         err = 0;
4962                 }
4963         } while (exception.retry);
4964 out:
4965         return err;
4966 }
4967
4968 #if defined(CONFIG_NFS_V4_1)
4969 /**
4970  * nfs41_check_expired_locks - possibly free a lock stateid
4971  *
4972  * @state: NFSv4 state for an inode
4973  *
4974  * Returns NFS_OK if recovery for this stateid is now finished.
4975  * Otherwise a negative NFS4ERR value is returned.
4976  */
4977 static int nfs41_check_expired_locks(struct nfs4_state *state)
4978 {
4979         int status, ret = -NFS4ERR_BAD_STATEID;
4980         struct nfs4_lock_state *lsp;
4981         struct nfs_server *server = NFS_SERVER(state->inode);
4982
4983         list_for_each_entry(lsp, &state->lock_states, ls_locks) {
4984                 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
4985                         status = nfs41_test_stateid(server, &lsp->ls_stateid);
4986                         if (status != NFS_OK) {
4987                                 /* Free the stateid unless the server
4988                                  * informs us the stateid is unrecognized. */
4989                                 if (status != -NFS4ERR_BAD_STATEID)
4990                                         nfs41_free_stateid(server,
4991                                                         &lsp->ls_stateid);
4992                                 clear_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags);
4993                                 ret = status;
4994                         }
4995                 }
4996         };
4997
4998         return ret;
4999 }
5000
5001 static int nfs41_lock_expired(struct nfs4_state *state, struct file_lock *request)
5002 {
5003         int status = NFS_OK;
5004
5005         if (test_bit(LK_STATE_IN_USE, &state->flags))
5006                 status = nfs41_check_expired_locks(state);
5007         if (status != NFS_OK)
5008                 status = nfs4_lock_expired(state, request);
5009         return status;
5010 }
5011 #endif
5012
5013 static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
5014 {
5015         struct nfs4_state_owner *sp = state->owner;
5016         struct nfs_inode *nfsi = NFS_I(state->inode);
5017         unsigned char fl_flags = request->fl_flags;
5018         unsigned int seq;
5019         int status = -ENOLCK;
5020
5021         if ((fl_flags & FL_POSIX) &&
5022                         !test_bit(NFS_STATE_POSIX_LOCKS, &state->flags))
5023                 goto out;
5024         /* Is this a delegated open? */
5025         status = nfs4_set_lock_state(state, request);
5026         if (status != 0)
5027                 goto out;
5028         request->fl_flags |= FL_ACCESS;
5029         status = do_vfs_lock(request->fl_file, request);
5030         if (status < 0)
5031                 goto out;
5032         down_read(&nfsi->rwsem);
5033         if (test_bit(NFS_DELEGATED_STATE, &state->flags)) {
5034                 /* Yes: cache locks! */
5035                 /* ...but avoid races with delegation recall... */
5036                 request->fl_flags = fl_flags & ~FL_SLEEP;
5037                 status = do_vfs_lock(request->fl_file, request);
5038                 goto out_unlock;
5039         }
5040         seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
5041         up_read(&nfsi->rwsem);
5042         status = _nfs4_do_setlk(state, cmd, request, NFS_LOCK_NEW);
5043         if (status != 0)
5044                 goto out;
5045         down_read(&nfsi->rwsem);
5046         if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq)) {
5047                 status = -NFS4ERR_DELAY;
5048                 goto out_unlock;
5049         }
5050         /* Note: we always want to sleep here! */
5051         request->fl_flags = fl_flags | FL_SLEEP;
5052         if (do_vfs_lock(request->fl_file, request) < 0)
5053                 printk(KERN_WARNING "NFS: %s: VFS is out of sync with lock "
5054                         "manager!\n", __func__);
5055 out_unlock:
5056         up_read(&nfsi->rwsem);
5057 out:
5058         request->fl_flags = fl_flags;
5059         return status;
5060 }
5061
5062 static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
5063 {
5064         struct nfs4_exception exception = {
5065                 .state = state,
5066                 .inode = state->inode,
5067         };
5068         int err;
5069
5070         do {
5071                 err = _nfs4_proc_setlk(state, cmd, request);
5072                 if (err == -NFS4ERR_DENIED)
5073                         err = -EAGAIN;
5074                 err = nfs4_handle_exception(NFS_SERVER(state->inode),
5075                                 err, &exception);
5076         } while (exception.retry);
5077         return err;
5078 }
5079
5080 static int
5081 nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request)
5082 {
5083         struct nfs_open_context *ctx;
5084         struct nfs4_state *state;
5085         unsigned long timeout = NFS4_LOCK_MINTIMEOUT;
5086         int status;
5087
5088         /* verify open state */
5089         ctx = nfs_file_open_context(filp);
5090         state = ctx->state;
5091
5092         if (request->fl_start < 0 || request->fl_end < 0)
5093                 return -EINVAL;
5094
5095         if (IS_GETLK(cmd)) {
5096                 if (state != NULL)
5097                         return nfs4_proc_getlk(state, F_GETLK, request);
5098                 return 0;
5099         }
5100
5101         if (!(IS_SETLK(cmd) || IS_SETLKW(cmd)))
5102                 return -EINVAL;
5103
5104         if (request->fl_type == F_UNLCK) {
5105                 if (state != NULL)
5106                         return nfs4_proc_unlck(state, cmd, request);
5107                 return 0;
5108         }
5109
5110         if (state == NULL)
5111                 return -ENOLCK;
5112         /*
5113          * Don't rely on the VFS having checked the file open mode,
5114          * since it won't do this for flock() locks.
5115          */
5116         switch (request->fl_type) {
5117         case F_RDLCK:
5118                 if (!(filp->f_mode & FMODE_READ))
5119                         return -EBADF;
5120                 break;
5121         case F_WRLCK:
5122                 if (!(filp->f_mode & FMODE_WRITE))
5123                         return -EBADF;
5124         }
5125
5126         do {
5127                 status = nfs4_proc_setlk(state, cmd, request);
5128                 if ((status != -EAGAIN) || IS_SETLK(cmd))
5129                         break;
5130                 timeout = nfs4_set_lock_task_retry(timeout);
5131                 status = -ERESTARTSYS;
5132                 if (signalled())
5133                         break;
5134         } while(status < 0);
5135         return status;
5136 }
5137
5138 int nfs4_lock_delegation_recall(struct nfs4_state *state, struct file_lock *fl)
5139 {
5140         struct nfs_server *server = NFS_SERVER(state->inode);
5141         struct nfs4_exception exception = { };
5142         int err;
5143
5144         err = nfs4_set_lock_state(state, fl);
5145         if (err != 0)
5146                 goto out;
5147         do {
5148                 err = _nfs4_do_setlk(state, F_SETLK, fl, NFS_LOCK_NEW);
5149                 switch (err) {
5150                         default:
5151                                 printk(KERN_ERR "NFS: %s: unhandled error "
5152                                         "%d.\n", __func__, err);
5153                         case 0:
5154                         case -ESTALE:
5155                                 goto out;
5156                         case -NFS4ERR_STALE_CLIENTID:
5157                         case -NFS4ERR_STALE_STATEID:
5158                                 set_bit(NFS_DELEGATED_STATE, &state->flags);
5159                         case -NFS4ERR_EXPIRED:
5160                                 nfs4_schedule_lease_recovery(server->nfs_client);
5161                                 err = -EAGAIN;
5162                                 goto out;
5163                         case -NFS4ERR_BADSESSION:
5164                         case -NFS4ERR_BADSLOT:
5165                         case -NFS4ERR_BAD_HIGH_SLOT:
5166                         case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
5167                         case -NFS4ERR_DEADSESSION:
5168                                 set_bit(NFS_DELEGATED_STATE, &state->flags);
5169                                 nfs4_schedule_session_recovery(server->nfs_client->cl_session, err);
5170                                 err = -EAGAIN;
5171                                 goto out;
5172                         case -NFS4ERR_DELEG_REVOKED:
5173                         case -NFS4ERR_ADMIN_REVOKED:
5174                         case -NFS4ERR_BAD_STATEID:
5175                         case -NFS4ERR_OPENMODE:
5176                                 nfs4_schedule_stateid_recovery(server, state);
5177                                 err = 0;
5178                                 goto out;
5179                         case -ENOMEM:
5180                         case -NFS4ERR_DENIED:
5181                                 /* kill_proc(fl->fl_pid, SIGLOST, 1); */
5182                                 err = 0;
5183                                 goto out;
5184                 }
5185                 set_bit(NFS_DELEGATED_STATE, &state->flags);
5186                 err = nfs4_handle_exception(server, err, &exception);
5187         } while (exception.retry);
5188 out:
5189         return err;
5190 }
5191
5192 struct nfs_release_lockowner_data {
5193         struct nfs4_lock_state *lsp;
5194         struct nfs_server *server;
5195         struct nfs_release_lockowner_args args;
5196 };
5197
5198 static void nfs4_release_lockowner_release(void *calldata)
5199 {
5200         struct nfs_release_lockowner_data *data = calldata;
5201         nfs4_free_lock_state(data->server, data->lsp);
5202         kfree(calldata);
5203 }
5204
5205 static const struct rpc_call_ops nfs4_release_lockowner_ops = {
5206         .rpc_release = nfs4_release_lockowner_release,
5207 };
5208
5209 int nfs4_release_lockowner(struct nfs4_lock_state *lsp)
5210 {
5211         struct nfs_server *server = lsp->ls_state->owner->so_server;
5212         struct nfs_release_lockowner_data *data;
5213         struct rpc_message msg = {
5214                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RELEASE_LOCKOWNER],
5215         };
5216
5217         if (server->nfs_client->cl_mvops->minor_version != 0)
5218                 return -EINVAL;
5219         data = kmalloc(sizeof(*data), GFP_NOFS);
5220         if (!data)
5221                 return -ENOMEM;
5222         data->lsp = lsp;
5223         data->server = server;
5224         data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
5225         data->args.lock_owner.id = lsp->ls_seqid.owner_id;
5226         data->args.lock_owner.s_dev = server->s_dev;
5227         msg.rpc_argp = &data->args;
5228         rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, data);
5229         return 0;
5230 }
5231
5232 #define XATTR_NAME_NFSV4_ACL "system.nfs4_acl"
5233
5234 static int nfs4_xattr_set_nfs4_acl(struct dentry *dentry, const char *key,
5235                                    const void *buf, size_t buflen,
5236                                    int flags, int type)
5237 {
5238         if (strcmp(key, "") != 0)
5239                 return -EINVAL;
5240
5241         return nfs4_proc_set_acl(dentry->d_inode, buf, buflen);
5242 }
5243
5244 static int nfs4_xattr_get_nfs4_acl(struct dentry *dentry, const char *key,
5245                                    void *buf, size_t buflen, int type)
5246 {
5247         if (strcmp(key, "") != 0)
5248                 return -EINVAL;
5249
5250         return nfs4_proc_get_acl(dentry->d_inode, buf, buflen);
5251 }
5252
5253 static size_t nfs4_xattr_list_nfs4_acl(struct dentry *dentry, char *list,
5254                                        size_t list_len, const char *name,
5255                                        size_t name_len, int type)
5256 {
5257         size_t len = sizeof(XATTR_NAME_NFSV4_ACL);
5258
5259         if (!nfs4_server_supports_acls(NFS_SERVER(dentry->d_inode)))
5260                 return 0;
5261
5262         if (list && len <= list_len)
5263                 memcpy(list, XATTR_NAME_NFSV4_ACL, len);
5264         return len;
5265 }
5266
5267 /*
5268  * nfs_fhget will use either the mounted_on_fileid or the fileid
5269  */
5270 static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr)
5271 {
5272         if (!(((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) ||
5273                (fattr->valid & NFS_ATTR_FATTR_FILEID)) &&
5274               (fattr->valid & NFS_ATTR_FATTR_FSID) &&
5275               (fattr->valid & NFS_ATTR_FATTR_V4_LOCATIONS)))
5276                 return;
5277
5278         fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |
5279                 NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_V4_REFERRAL;
5280         fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;
5281         fattr->nlink = 2;
5282 }
5283
5284 static int _nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
5285                                    const struct qstr *name,
5286                                    struct nfs4_fs_locations *fs_locations,
5287                                    struct page *page)
5288 {
5289         struct nfs_server *server = NFS_SERVER(dir);
5290         u32 bitmask[2] = {
5291                 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
5292         };
5293         struct nfs4_fs_locations_arg args = {
5294                 .dir_fh = NFS_FH(dir),
5295                 .name = name,
5296                 .page = page,
5297                 .bitmask = bitmask,
5298         };
5299         struct nfs4_fs_locations_res res = {
5300                 .fs_locations = fs_locations,
5301         };
5302         struct rpc_message msg = {
5303                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
5304                 .rpc_argp = &args,
5305                 .rpc_resp = &res,
5306         };
5307         int status;
5308
5309         dprintk("%s: start\n", __func__);
5310
5311         /* Ask for the fileid of the absent filesystem if mounted_on_fileid
5312          * is not supported */
5313         if (NFS_SERVER(dir)->attr_bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)
5314                 bitmask[1] |= FATTR4_WORD1_MOUNTED_ON_FILEID;
5315         else
5316                 bitmask[0] |= FATTR4_WORD0_FILEID;
5317
5318         nfs_fattr_init(&fs_locations->fattr);
5319         fs_locations->server = server;
5320         fs_locations->nlocations = 0;
5321         status = nfs4_call_sync(client, server, &msg, &args.seq_args, &res.seq_res, 0);
5322         dprintk("%s: returned status = %d\n", __func__, status);
5323         return status;
5324 }
5325
5326 int nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
5327                            const struct qstr *name,
5328                            struct nfs4_fs_locations *fs_locations,
5329                            struct page *page)
5330 {
5331         struct nfs4_exception exception = { };
5332         int err;
5333         do {
5334                 err = nfs4_handle_exception(NFS_SERVER(dir),
5335                                 _nfs4_proc_fs_locations(client, dir, name, fs_locations, page),
5336                                 &exception);
5337         } while (exception.retry);
5338         return err;
5339 }
5340
5341 static int _nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct nfs4_secinfo_flavors *flavors)
5342 {
5343         int status;
5344         struct nfs4_secinfo_arg args = {
5345                 .dir_fh = NFS_FH(dir),
5346                 .name   = name,
5347         };
5348         struct nfs4_secinfo_res res = {
5349                 .flavors     = flavors,
5350         };
5351         struct rpc_message msg = {
5352                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO],
5353                 .rpc_argp = &args,
5354                 .rpc_resp = &res,
5355         };
5356
5357         dprintk("NFS call  secinfo %s\n", name->name);
5358         status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &msg, &args.seq_args, &res.seq_res, 0);
5359         dprintk("NFS reply  secinfo: %d\n", status);
5360         return status;
5361 }
5362
5363 int nfs4_proc_secinfo(struct inode *dir, const struct qstr *name,
5364                       struct nfs4_secinfo_flavors *flavors)
5365 {
5366         struct nfs4_exception exception = { };
5367         int err;
5368         do {
5369                 err = nfs4_handle_exception(NFS_SERVER(dir),
5370                                 _nfs4_proc_secinfo(dir, name, flavors),
5371                                 &exception);
5372         } while (exception.retry);
5373         return err;
5374 }
5375
5376 #ifdef CONFIG_NFS_V4_1
5377 /*
5378  * Check the exchange flags returned by the server for invalid flags, having
5379  * both PNFS and NON_PNFS flags set, and not having one of NON_PNFS, PNFS, or
5380  * DS flags set.
5381  */
5382 static int nfs4_check_cl_exchange_flags(u32 flags)
5383 {
5384         if (flags & ~EXCHGID4_FLAG_MASK_R)
5385                 goto out_inval;
5386         if ((flags & EXCHGID4_FLAG_USE_PNFS_MDS) &&
5387             (flags & EXCHGID4_FLAG_USE_NON_PNFS))
5388                 goto out_inval;
5389         if (!(flags & (EXCHGID4_FLAG_MASK_PNFS)))
5390                 goto out_inval;
5391         return NFS_OK;
5392 out_inval:
5393         return -NFS4ERR_INVAL;
5394 }
5395
5396 static bool
5397 nfs41_same_server_scope(struct nfs41_server_scope *a,
5398                         struct nfs41_server_scope *b)
5399 {
5400         if (a->server_scope_sz == b->server_scope_sz &&
5401             memcmp(a->server_scope, b->server_scope, a->server_scope_sz) == 0)
5402                 return true;
5403
5404         return false;
5405 }
5406
5407 /*
5408  * nfs4_proc_bind_conn_to_session()
5409  *
5410  * The 4.1 client currently uses the same TCP connection for the
5411  * fore and backchannel.
5412  */
5413 int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, struct rpc_cred *cred)
5414 {
5415         int status;
5416         struct nfs41_bind_conn_to_session_res res;
5417         struct rpc_message msg = {
5418                 .rpc_proc =
5419                         &nfs4_procedures[NFSPROC4_CLNT_BIND_CONN_TO_SESSION],
5420                 .rpc_argp = clp,
5421                 .rpc_resp = &res,
5422                 .rpc_cred = cred,
5423         };
5424
5425         dprintk("--> %s\n", __func__);
5426
5427         res.session = kzalloc(sizeof(struct nfs4_session), GFP_NOFS);
5428         if (unlikely(res.session == NULL)) {
5429                 status = -ENOMEM;
5430                 goto out;
5431         }
5432
5433         status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
5434         if (status == 0) {
5435                 if (memcmp(res.session->sess_id.data,
5436                     clp->cl_session->sess_id.data, NFS4_MAX_SESSIONID_LEN)) {
5437                         dprintk("NFS: %s: Session ID mismatch\n", __func__);
5438                         status = -EIO;
5439                         goto out_session;
5440                 }
5441                 if (res.dir != NFS4_CDFS4_BOTH) {
5442                         dprintk("NFS: %s: Unexpected direction from server\n",
5443                                 __func__);
5444                         status = -EIO;
5445                         goto out_session;
5446                 }
5447                 if (res.use_conn_in_rdma_mode) {
5448                         dprintk("NFS: %s: Server returned RDMA mode = true\n",
5449                                 __func__);
5450                         status = -EIO;
5451                         goto out_session;
5452                 }
5453         }
5454 out_session:
5455         kfree(res.session);
5456 out:
5457         dprintk("<-- %s status= %d\n", __func__, status);
5458         return status;
5459 }
5460
5461 /*
5462  * nfs4_proc_exchange_id()
5463  *
5464  * Returns zero, a negative errno, or a negative NFS4ERR status code.
5465  *
5466  * Since the clientid has expired, all compounds using sessions
5467  * associated with the stale clientid will be returning
5468  * NFS4ERR_BADSESSION in the sequence operation, and will therefore
5469  * be in some phase of session reset.
5470  */
5471 int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)
5472 {
5473         nfs4_verifier verifier;
5474         struct nfs41_exchange_id_args args = {
5475                 .verifier = &verifier,
5476                 .client = clp,
5477                 .flags = EXCHGID4_FLAG_SUPP_MOVED_REFER,
5478         };
5479         struct nfs41_exchange_id_res res = {
5480                 0
5481         };
5482         int status;
5483         struct rpc_message msg = {
5484                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_EXCHANGE_ID],
5485                 .rpc_argp = &args,
5486                 .rpc_resp = &res,
5487                 .rpc_cred = cred,
5488         };
5489
5490         nfs4_init_boot_verifier(clp, &verifier);
5491         args.id_len = nfs4_init_uniform_client_string(clp, args.id,
5492                                                         sizeof(args.id));
5493         dprintk("NFS call  exchange_id auth=%s, '%.*s'\n",
5494                 clp->cl_rpcclient->cl_auth->au_ops->au_name,
5495                 args.id_len, args.id);
5496
5497         res.server_owner = kzalloc(sizeof(struct nfs41_server_owner),
5498                                         GFP_NOFS);
5499         if (unlikely(res.server_owner == NULL)) {
5500                 status = -ENOMEM;
5501                 goto out;
5502         }
5503
5504         res.server_scope = kzalloc(sizeof(struct nfs41_server_scope),
5505                                         GFP_NOFS);
5506         if (unlikely(res.server_scope == NULL)) {
5507                 status = -ENOMEM;
5508                 goto out_server_owner;
5509         }
5510
5511         res.impl_id = kzalloc(sizeof(struct nfs41_impl_id), GFP_NOFS);
5512         if (unlikely(res.impl_id == NULL)) {
5513                 status = -ENOMEM;
5514                 goto out_server_scope;
5515         }
5516
5517         status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
5518         if (status == 0)
5519                 status = nfs4_check_cl_exchange_flags(res.flags);
5520
5521         if (status == 0) {
5522                 clp->cl_clientid = res.clientid;
5523                 clp->cl_exchange_flags = (res.flags & ~EXCHGID4_FLAG_CONFIRMED_R);
5524                 if (!(res.flags & EXCHGID4_FLAG_CONFIRMED_R))
5525                         clp->cl_seqid = res.seqid;
5526
5527                 kfree(clp->cl_serverowner);
5528                 clp->cl_serverowner = res.server_owner;
5529                 res.server_owner = NULL;
5530
5531                 /* use the most recent implementation id */
5532                 kfree(clp->cl_implid);
5533                 clp->cl_implid = res.impl_id;
5534
5535                 if (clp->cl_serverscope != NULL &&
5536                     !nfs41_same_server_scope(clp->cl_serverscope,
5537                                              res.server_scope)) {
5538                         dprintk("%s: server_scope mismatch detected\n",
5539                                 __func__);
5540                         set_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state);
5541                         kfree(clp->cl_serverscope);
5542                         clp->cl_serverscope = NULL;
5543                 }
5544
5545                 if (clp->cl_serverscope == NULL) {
5546                         clp->cl_serverscope = res.server_scope;
5547                         goto out;
5548                 }
5549         } else
5550                 kfree(res.impl_id);
5551
5552 out_server_owner:
5553         kfree(res.server_owner);
5554 out_server_scope:
5555         kfree(res.server_scope);
5556 out:
5557         if (clp->cl_implid != NULL)
5558                 dprintk("NFS reply exchange_id: Server Implementation ID: "
5559                         "domain: %s, name: %s, date: %llu,%u\n",
5560                         clp->cl_implid->domain, clp->cl_implid->name,
5561                         clp->cl_implid->date.seconds,
5562                         clp->cl_implid->date.nseconds);
5563         dprintk("NFS reply exchange_id: %d\n", status);
5564         return status;
5565 }
5566
5567 static int _nfs4_proc_destroy_clientid(struct nfs_client *clp,
5568                 struct rpc_cred *cred)
5569 {
5570         struct rpc_message msg = {
5571                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_CLIENTID],
5572                 .rpc_argp = clp,
5573                 .rpc_cred = cred,
5574         };
5575         int status;
5576
5577         status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
5578         if (status)
5579                 dprintk("NFS: Got error %d from the server %s on "
5580                         "DESTROY_CLIENTID.", status, clp->cl_hostname);
5581         return status;
5582 }
5583
5584 static int nfs4_proc_destroy_clientid(struct nfs_client *clp,
5585                 struct rpc_cred *cred)
5586 {
5587         unsigned int loop;
5588         int ret;
5589
5590         for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) {
5591                 ret = _nfs4_proc_destroy_clientid(clp, cred);
5592                 switch (ret) {
5593                 case -NFS4ERR_DELAY:
5594                 case -NFS4ERR_CLIENTID_BUSY:
5595                         ssleep(1);
5596                         break;
5597                 default:
5598                         return ret;
5599                 }
5600         }
5601         return 0;
5602 }
5603
5604 int nfs4_destroy_clientid(struct nfs_client *clp)
5605 {
5606         struct rpc_cred *cred;
5607         int ret = 0;
5608
5609         if (clp->cl_mvops->minor_version < 1)
5610                 goto out;
5611         if (clp->cl_exchange_flags == 0)
5612                 goto out;
5613         if (clp->cl_preserve_clid)
5614                 goto out;
5615         cred = nfs4_get_exchange_id_cred(clp);
5616         ret = nfs4_proc_destroy_clientid(clp, cred);
5617         if (cred)
5618                 put_rpccred(cred);
5619         switch (ret) {
5620         case 0:
5621         case -NFS4ERR_STALE_CLIENTID:
5622                 clp->cl_exchange_flags = 0;
5623         }
5624 out:
5625         return ret;
5626 }
5627
5628 struct nfs4_get_lease_time_data {
5629         struct nfs4_get_lease_time_args *args;
5630         struct nfs4_get_lease_time_res *res;
5631         struct nfs_client *clp;
5632 };
5633
5634 static void nfs4_get_lease_time_prepare(struct rpc_task *task,
5635                                         void *calldata)
5636 {
5637         struct nfs4_get_lease_time_data *data =
5638                         (struct nfs4_get_lease_time_data *)calldata;
5639
5640         dprintk("--> %s\n", __func__);
5641         /* just setup sequence, do not trigger session recovery
5642            since we're invoked within one */
5643         nfs41_setup_sequence(data->clp->cl_session,
5644                         &data->args->la_seq_args,
5645                         &data->res->lr_seq_res,
5646                         task);
5647         dprintk("<-- %s\n", __func__);
5648 }
5649
5650 /*
5651  * Called from nfs4_state_manager thread for session setup, so don't recover
5652  * from sequence operation or clientid errors.
5653  */
5654 static void nfs4_get_lease_time_done(struct rpc_task *task, void *calldata)
5655 {
5656         struct nfs4_get_lease_time_data *data =
5657                         (struct nfs4_get_lease_time_data *)calldata;
5658
5659         dprintk("--> %s\n", __func__);
5660         if (!nfs41_sequence_done(task, &data->res->lr_seq_res))
5661                 return;
5662         switch (task->tk_status) {
5663         case -NFS4ERR_DELAY:
5664         case -NFS4ERR_GRACE:
5665                 dprintk("%s Retry: tk_status %d\n", __func__, task->tk_status);
5666                 rpc_delay(task, NFS4_POLL_RETRY_MIN);
5667                 task->tk_status = 0;
5668                 /* fall through */
5669         case -NFS4ERR_RETRY_UNCACHED_REP:
5670                 rpc_restart_call_prepare(task);
5671                 return;
5672         }
5673         dprintk("<-- %s\n", __func__);
5674 }
5675
5676 static const struct rpc_call_ops nfs4_get_lease_time_ops = {
5677         .rpc_call_prepare = nfs4_get_lease_time_prepare,
5678         .rpc_call_done = nfs4_get_lease_time_done,
5679 };
5680
5681 int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo)
5682 {
5683         struct rpc_task *task;
5684         struct nfs4_get_lease_time_args args;
5685         struct nfs4_get_lease_time_res res = {
5686                 .lr_fsinfo = fsinfo,
5687         };
5688         struct nfs4_get_lease_time_data data = {
5689                 .args = &args,
5690                 .res = &res,
5691                 .clp = clp,
5692         };
5693         struct rpc_message msg = {
5694                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GET_LEASE_TIME],
5695                 .rpc_argp = &args,
5696                 .rpc_resp = &res,
5697         };
5698         struct rpc_task_setup task_setup = {
5699                 .rpc_client = clp->cl_rpcclient,
5700                 .rpc_message = &msg,
5701                 .callback_ops = &nfs4_get_lease_time_ops,
5702                 .callback_data = &data,
5703                 .flags = RPC_TASK_TIMEOUT,
5704         };
5705         int status;
5706
5707         nfs41_init_sequence(&args.la_seq_args, &res.lr_seq_res, 0);
5708         nfs4_set_sequence_privileged(&args.la_seq_args);
5709         dprintk("--> %s\n", __func__);
5710         task = rpc_run_task(&task_setup);
5711
5712         if (IS_ERR(task))
5713                 status = PTR_ERR(task);
5714         else {
5715                 status = task->tk_status;
5716                 rpc_put_task(task);
5717         }
5718         dprintk("<-- %s return %d\n", __func__, status);
5719
5720         return status;
5721 }
5722
5723 /*
5724  * Initialize the values to be used by the client in CREATE_SESSION
5725  * If nfs4_init_session set the fore channel request and response sizes,
5726  * use them.
5727  *
5728  * Set the back channel max_resp_sz_cached to zero to force the client to
5729  * always set csa_cachethis to FALSE because the current implementation
5730  * of the back channel DRC only supports caching the CB_SEQUENCE operation.
5731  */
5732 static void nfs4_init_channel_attrs(struct nfs41_create_session_args *args)
5733 {
5734         struct nfs4_session *session = args->client->cl_session;
5735         unsigned int mxrqst_sz = session->fc_target_max_rqst_sz,
5736                      mxresp_sz = session->fc_target_max_resp_sz;
5737
5738         if (mxrqst_sz == 0)
5739                 mxrqst_sz = NFS_MAX_FILE_IO_SIZE;
5740         if (mxresp_sz == 0)
5741                 mxresp_sz = NFS_MAX_FILE_IO_SIZE;
5742         /* Fore channel attributes */
5743         args->fc_attrs.max_rqst_sz = mxrqst_sz;
5744         args->fc_attrs.max_resp_sz = mxresp_sz;
5745         args->fc_attrs.max_ops = NFS4_MAX_OPS;
5746         args->fc_attrs.max_reqs = max_session_slots;
5747
5748         dprintk("%s: Fore Channel : max_rqst_sz=%u max_resp_sz=%u "
5749                 "max_ops=%u max_reqs=%u\n",
5750                 __func__,
5751                 args->fc_attrs.max_rqst_sz, args->fc_attrs.max_resp_sz,
5752                 args->fc_attrs.max_ops, args->fc_attrs.max_reqs);
5753
5754         /* Back channel attributes */
5755         args->bc_attrs.max_rqst_sz = PAGE_SIZE;
5756         args->bc_attrs.max_resp_sz = PAGE_SIZE;
5757         args->bc_attrs.max_resp_sz_cached = 0;
5758         args->bc_attrs.max_ops = NFS4_MAX_BACK_CHANNEL_OPS;
5759         args->bc_attrs.max_reqs = 1;
5760
5761         dprintk("%s: Back Channel : max_rqst_sz=%u max_resp_sz=%u "
5762                 "max_resp_sz_cached=%u max_ops=%u max_reqs=%u\n",
5763                 __func__,
5764                 args->bc_attrs.max_rqst_sz, args->bc_attrs.max_resp_sz,
5765                 args->bc_attrs.max_resp_sz_cached, args->bc_attrs.max_ops,
5766                 args->bc_attrs.max_reqs);
5767 }
5768
5769 static int nfs4_verify_fore_channel_attrs(struct nfs41_create_session_args *args, struct nfs4_session *session)
5770 {
5771         struct nfs4_channel_attrs *sent = &args->fc_attrs;
5772         struct nfs4_channel_attrs *rcvd = &session->fc_attrs;
5773
5774         if (rcvd->max_resp_sz > sent->max_resp_sz)
5775                 return -EINVAL;
5776         /*
5777          * Our requested max_ops is the minimum we need; we're not
5778          * prepared to break up compounds into smaller pieces than that.
5779          * So, no point even trying to continue if the server won't
5780          * cooperate:
5781          */
5782         if (rcvd->max_ops < sent->max_ops)
5783                 return -EINVAL;
5784         if (rcvd->max_reqs == 0)
5785                 return -EINVAL;
5786         if (rcvd->max_reqs > NFS4_MAX_SLOT_TABLE)
5787                 rcvd->max_reqs = NFS4_MAX_SLOT_TABLE;
5788         return 0;
5789 }
5790
5791 static int nfs4_verify_back_channel_attrs(struct nfs41_create_session_args *args, struct nfs4_session *session)
5792 {
5793         struct nfs4_channel_attrs *sent = &args->bc_attrs;
5794         struct nfs4_channel_attrs *rcvd = &session->bc_attrs;
5795
5796         if (rcvd->max_rqst_sz > sent->max_rqst_sz)
5797                 return -EINVAL;
5798         if (rcvd->max_resp_sz < sent->max_resp_sz)
5799                 return -EINVAL;
5800         if (rcvd->max_resp_sz_cached > sent->max_resp_sz_cached)
5801                 return -EINVAL;
5802         /* These would render the backchannel useless: */
5803         if (rcvd->max_ops != sent->max_ops)
5804                 return -EINVAL;
5805         if (rcvd->max_reqs != sent->max_reqs)
5806                 return -EINVAL;
5807         return 0;
5808 }
5809
5810 static int nfs4_verify_channel_attrs(struct nfs41_create_session_args *args,
5811                                      struct nfs4_session *session)
5812 {
5813         int ret;
5814
5815         ret = nfs4_verify_fore_channel_attrs(args, session);
5816         if (ret)
5817                 return ret;
5818         return nfs4_verify_back_channel_attrs(args, session);
5819 }
5820
5821 static int _nfs4_proc_create_session(struct nfs_client *clp,
5822                 struct rpc_cred *cred)
5823 {
5824         struct nfs4_session *session = clp->cl_session;
5825         struct nfs41_create_session_args args = {
5826                 .client = clp,
5827                 .cb_program = NFS4_CALLBACK,
5828         };
5829         struct nfs41_create_session_res res = {
5830                 .client = clp,
5831         };
5832         struct rpc_message msg = {
5833                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE_SESSION],
5834                 .rpc_argp = &args,
5835                 .rpc_resp = &res,
5836                 .rpc_cred = cred,
5837         };
5838         int status;
5839
5840         nfs4_init_channel_attrs(&args);
5841         args.flags = (SESSION4_PERSIST | SESSION4_BACK_CHAN);
5842
5843         status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
5844
5845         if (!status) {
5846                 /* Verify the session's negotiated channel_attrs values */
5847                 status = nfs4_verify_channel_attrs(&args, session);
5848                 /* Increment the clientid slot sequence id */
5849                 clp->cl_seqid++;
5850         }
5851
5852         return status;
5853 }
5854
5855 /*
5856  * Issues a CREATE_SESSION operation to the server.
5857  * It is the responsibility of the caller to verify the session is
5858  * expired before calling this routine.
5859  */
5860 int nfs4_proc_create_session(struct nfs_client *clp, struct rpc_cred *cred)
5861 {
5862         int status;
5863         unsigned *ptr;
5864         struct nfs4_session *session = clp->cl_session;
5865
5866         dprintk("--> %s clp=%p session=%p\n", __func__, clp, session);
5867
5868         status = _nfs4_proc_create_session(clp, cred);
5869         if (status)
5870                 goto out;
5871
5872         /* Init or reset the session slot tables */
5873         status = nfs4_setup_session_slot_tables(session);
5874         dprintk("slot table setup returned %d\n", status);
5875         if (status)
5876                 goto out;
5877
5878         ptr = (unsigned *)&session->sess_id.data[0];
5879         dprintk("%s client>seqid %d sessionid %u:%u:%u:%u\n", __func__,
5880                 clp->cl_seqid, ptr[0], ptr[1], ptr[2], ptr[3]);
5881 out:
5882         dprintk("<-- %s\n", __func__);
5883         return status;
5884 }
5885
5886 /*
5887  * Issue the over-the-wire RPC DESTROY_SESSION.
5888  * The caller must serialize access to this routine.
5889  */
5890 int nfs4_proc_destroy_session(struct nfs4_session *session,
5891                 struct rpc_cred *cred)
5892 {
5893         struct rpc_message msg = {
5894                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_SESSION],
5895                 .rpc_argp = session,
5896                 .rpc_cred = cred,
5897         };
5898         int status = 0;
5899
5900         dprintk("--> nfs4_proc_destroy_session\n");
5901
5902         /* session is still being setup */
5903         if (session->clp->cl_cons_state != NFS_CS_READY)
5904                 return status;
5905
5906         status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
5907
5908         if (status)
5909                 dprintk("NFS: Got error %d from the server on DESTROY_SESSION. "
5910                         "Session has been destroyed regardless...\n", status);
5911
5912         dprintk("<-- nfs4_proc_destroy_session\n");
5913         return status;
5914 }
5915
5916 /*
5917  * Renew the cl_session lease.
5918  */
5919 struct nfs4_sequence_data {
5920         struct nfs_client *clp;
5921         struct nfs4_sequence_args args;
5922         struct nfs4_sequence_res res;
5923 };
5924
5925 static void nfs41_sequence_release(void *data)
5926 {
5927         struct nfs4_sequence_data *calldata = data;
5928         struct nfs_client *clp = calldata->clp;
5929
5930         if (atomic_read(&clp->cl_count) > 1)
5931                 nfs4_schedule_state_renewal(clp);
5932         nfs_put_client(clp);
5933         kfree(calldata);
5934 }
5935
5936 static int nfs41_sequence_handle_errors(struct rpc_task *task, struct nfs_client *clp)
5937 {
5938         switch(task->tk_status) {
5939         case -NFS4ERR_DELAY:
5940                 rpc_delay(task, NFS4_POLL_RETRY_MAX);
5941                 return -EAGAIN;
5942         default:
5943                 nfs4_schedule_lease_recovery(clp);
5944         }
5945         return 0;
5946 }
5947
5948 static void nfs41_sequence_call_done(struct rpc_task *task, void *data)
5949 {
5950         struct nfs4_sequence_data *calldata = data;
5951         struct nfs_client *clp = calldata->clp;
5952
5953         if (!nfs41_sequence_done(task, task->tk_msg.rpc_resp))
5954                 return;
5955
5956         if (task->tk_status < 0) {
5957                 dprintk("%s ERROR %d\n", __func__, task->tk_status);
5958                 if (atomic_read(&clp->cl_count) == 1)
5959                         goto out;
5960
5961                 if (nfs41_sequence_handle_errors(task, clp) == -EAGAIN) {
5962                         rpc_restart_call_prepare(task);
5963                         return;
5964                 }
5965         }
5966         dprintk("%s rpc_cred %p\n", __func__, task->tk_msg.rpc_cred);
5967 out:
5968         dprintk("<-- %s\n", __func__);
5969 }
5970
5971 static void nfs41_sequence_prepare(struct rpc_task *task, void *data)
5972 {
5973         struct nfs4_sequence_data *calldata = data;
5974         struct nfs_client *clp = calldata->clp;
5975         struct nfs4_sequence_args *args;
5976         struct nfs4_sequence_res *res;
5977
5978         args = task->tk_msg.rpc_argp;
5979         res = task->tk_msg.rpc_resp;
5980
5981         nfs41_setup_sequence(clp->cl_session, args, res, task);
5982 }
5983
5984 static const struct rpc_call_ops nfs41_sequence_ops = {
5985         .rpc_call_done = nfs41_sequence_call_done,
5986         .rpc_call_prepare = nfs41_sequence_prepare,
5987         .rpc_release = nfs41_sequence_release,
5988 };
5989
5990 static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp,
5991                 struct rpc_cred *cred,
5992                 bool is_privileged)
5993 {
5994         struct nfs4_sequence_data *calldata;
5995         struct rpc_message msg = {
5996                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE],
5997                 .rpc_cred = cred,
5998         };
5999         struct rpc_task_setup task_setup_data = {
6000                 .rpc_client = clp->cl_rpcclient,
6001                 .rpc_message = &msg,
6002                 .callback_ops = &nfs41_sequence_ops,
6003                 .flags = RPC_TASK_ASYNC | RPC_TASK_SOFT,
6004         };
6005
6006         if (!atomic_inc_not_zero(&clp->cl_count))
6007                 return ERR_PTR(-EIO);
6008         calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
6009         if (calldata == NULL) {
6010                 nfs_put_client(clp);
6011                 return ERR_PTR(-ENOMEM);
6012         }
6013         nfs41_init_sequence(&calldata->args, &calldata->res, 0);
6014         if (is_privileged)
6015                 nfs4_set_sequence_privileged(&calldata->args);
6016         msg.rpc_argp = &calldata->args;
6017         msg.rpc_resp = &calldata->res;
6018         calldata->clp = clp;
6019         task_setup_data.callback_data = calldata;
6020
6021         return rpc_run_task(&task_setup_data);
6022 }
6023
6024 static int nfs41_proc_async_sequence(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags)
6025 {
6026         struct rpc_task *task;
6027         int ret = 0;
6028
6029         if ((renew_flags & NFS4_RENEW_TIMEOUT) == 0)
6030                 return 0;
6031         task = _nfs41_proc_sequence(clp, cred, false);
6032         if (IS_ERR(task))
6033                 ret = PTR_ERR(task);
6034         else
6035                 rpc_put_task_async(task);
6036         dprintk("<-- %s status=%d\n", __func__, ret);
6037         return ret;
6038 }
6039
6040 static int nfs4_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred)
6041 {
6042         struct rpc_task *task;
6043         int ret;
6044
6045         task = _nfs41_proc_sequence(clp, cred, true);
6046         if (IS_ERR(task)) {
6047                 ret = PTR_ERR(task);
6048                 goto out;
6049         }
6050         ret = rpc_wait_for_completion_task(task);
6051         if (!ret) {
6052                 struct nfs4_sequence_res *res = task->tk_msg.rpc_resp;
6053
6054                 if (task->tk_status == 0)
6055                         nfs41_handle_sequence_flag_errors(clp, res->sr_status_flags);
6056                 ret = task->tk_status;
6057         }
6058         rpc_put_task(task);
6059 out:
6060         dprintk("<-- %s status=%d\n", __func__, ret);
6061         return ret;
6062 }
6063
6064 struct nfs4_reclaim_complete_data {
6065         struct nfs_client *clp;
6066         struct nfs41_reclaim_complete_args arg;
6067         struct nfs41_reclaim_complete_res res;
6068 };
6069
6070 static void nfs4_reclaim_complete_prepare(struct rpc_task *task, void *data)
6071 {
6072         struct nfs4_reclaim_complete_data *calldata = data;
6073
6074         nfs41_setup_sequence(calldata->clp->cl_session,
6075                         &calldata->arg.seq_args,
6076                         &calldata->res.seq_res,
6077                         task);
6078 }
6079
6080 static int nfs41_reclaim_complete_handle_errors(struct rpc_task *task, struct nfs_client *clp)
6081 {
6082         switch(task->tk_status) {
6083         case 0:
6084         case -NFS4ERR_COMPLETE_ALREADY:
6085         case -NFS4ERR_WRONG_CRED: /* What to do here? */
6086                 break;
6087         case -NFS4ERR_DELAY:
6088                 rpc_delay(task, NFS4_POLL_RETRY_MAX);
6089                 /* fall through */
6090         case -NFS4ERR_RETRY_UNCACHED_REP:
6091                 return -EAGAIN;
6092         default:
6093                 nfs4_schedule_lease_recovery(clp);
6094         }
6095         return 0;
6096 }
6097
6098 static void nfs4_reclaim_complete_done(struct rpc_task *task, void *data)
6099 {
6100         struct nfs4_reclaim_complete_data *calldata = data;
6101         struct nfs_client *clp = calldata->clp;
6102         struct nfs4_sequence_res *res = &calldata->res.seq_res;
6103
6104         dprintk("--> %s\n", __func__);
6105         if (!nfs41_sequence_done(task, res))
6106                 return;
6107
6108         if (nfs41_reclaim_complete_handle_errors(task, clp) == -EAGAIN) {
6109                 rpc_restart_call_prepare(task);
6110                 return;
6111         }
6112         dprintk("<-- %s\n", __func__);
6113 }
6114
6115 static void nfs4_free_reclaim_complete_data(void *data)
6116 {
6117         struct nfs4_reclaim_complete_data *calldata = data;
6118
6119         kfree(calldata);
6120 }
6121
6122 static const struct rpc_call_ops nfs4_reclaim_complete_call_ops = {
6123         .rpc_call_prepare = nfs4_reclaim_complete_prepare,
6124         .rpc_call_done = nfs4_reclaim_complete_done,
6125         .rpc_release = nfs4_free_reclaim_complete_data,
6126 };
6127
6128 /*
6129  * Issue a global reclaim complete.
6130  */
6131 static int nfs41_proc_reclaim_complete(struct nfs_client *clp)
6132 {
6133         struct nfs4_reclaim_complete_data *calldata;
6134         struct rpc_task *task;
6135         struct rpc_message msg = {
6136                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RECLAIM_COMPLETE],
6137         };
6138         struct rpc_task_setup task_setup_data = {
6139                 .rpc_client = clp->cl_rpcclient,
6140                 .rpc_message = &msg,
6141                 .callback_ops = &nfs4_reclaim_complete_call_ops,
6142                 .flags = RPC_TASK_ASYNC,
6143         };
6144         int status = -ENOMEM;
6145
6146         dprintk("--> %s\n", __func__);
6147         calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
6148         if (calldata == NULL)
6149                 goto out;
6150         calldata->clp = clp;
6151         calldata->arg.one_fs = 0;
6152
6153         nfs41_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 0);
6154         nfs4_set_sequence_privileged(&calldata->arg.seq_args);
6155         msg.rpc_argp = &calldata->arg;
6156         msg.rpc_resp = &calldata->res;
6157         task_setup_data.callback_data = calldata;
6158         task = rpc_run_task(&task_setup_data);
6159         if (IS_ERR(task)) {
6160                 status = PTR_ERR(task);
6161                 goto out;
6162         }
6163         status = nfs4_wait_for_completion_rpc_task(task);
6164         if (status == 0)
6165                 status = task->tk_status;
6166         rpc_put_task(task);
6167         return 0;
6168 out:
6169         dprintk("<-- %s status=%d\n", __func__, status);
6170         return status;
6171 }
6172
6173 static void
6174 nfs4_layoutget_prepare(struct rpc_task *task, void *calldata)
6175 {
6176         struct nfs4_layoutget *lgp = calldata;
6177         struct nfs_server *server = NFS_SERVER(lgp->args.inode);
6178         struct nfs4_session *session = nfs4_get_session(server);
6179
6180         dprintk("--> %s\n", __func__);
6181         /* Note the is a race here, where a CB_LAYOUTRECALL can come in
6182          * right now covering the LAYOUTGET we are about to send.
6183          * However, that is not so catastrophic, and there seems
6184          * to be no way to prevent it completely.
6185          */
6186         if (nfs41_setup_sequence(session, &lgp->args.seq_args,
6187                                 &lgp->res.seq_res, task))
6188                 return;
6189         if (pnfs_choose_layoutget_stateid(&lgp->args.stateid,
6190                                           NFS_I(lgp->args.inode)->layout,
6191                                           lgp->args.ctx->state)) {
6192                 rpc_exit(task, NFS4_OK);
6193         }
6194 }
6195
6196 static void nfs4_layoutget_done(struct rpc_task *task, void *calldata)
6197 {
6198         struct nfs4_layoutget *lgp = calldata;
6199         struct inode *inode = lgp->args.inode;
6200         struct nfs_server *server = NFS_SERVER(inode);
6201         struct pnfs_layout_hdr *lo;
6202         struct nfs4_state *state = NULL;
6203         unsigned long timeo, giveup;
6204
6205         dprintk("--> %s\n", __func__);
6206
6207         if (!nfs41_sequence_done(task, &lgp->res.seq_res))
6208                 goto out;
6209
6210         switch (task->tk_status) {
6211         case 0:
6212                 goto out;
6213         case -NFS4ERR_LAYOUTTRYLATER:
6214         case -NFS4ERR_RECALLCONFLICT:
6215                 timeo = rpc_get_timeout(task->tk_client);
6216                 giveup = lgp->args.timestamp + timeo;
6217                 if (time_after(giveup, jiffies))
6218                         task->tk_status = -NFS4ERR_DELAY;
6219                 break;
6220         case -NFS4ERR_EXPIRED:
6221         case -NFS4ERR_BAD_STATEID:
6222                 spin_lock(&inode->i_lock);
6223                 lo = NFS_I(inode)->layout;
6224                 if (!lo || list_empty(&lo->plh_segs)) {
6225                         spin_unlock(&inode->i_lock);
6226                         /* If the open stateid was bad, then recover it. */
6227                         state = lgp->args.ctx->state;
6228                 } else {
6229                         LIST_HEAD(head);
6230
6231                         pnfs_mark_matching_lsegs_invalid(lo, &head, NULL);
6232                         spin_unlock(&inode->i_lock);
6233                         /* Mark the bad layout state as invalid, then
6234                          * retry using the open stateid. */
6235                         pnfs_free_lseg_list(&head);
6236                 }
6237         }
6238         if (nfs4_async_handle_error(task, server, state) == -EAGAIN)
6239                 rpc_restart_call_prepare(task);
6240 out:
6241         dprintk("<-- %s\n", __func__);
6242 }
6243
6244 static size_t max_response_pages(struct nfs_server *server)
6245 {
6246         u32 max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;
6247         return nfs_page_array_len(0, max_resp_sz);
6248 }
6249
6250 static void nfs4_free_pages(struct page **pages, size_t size)
6251 {
6252         int i;
6253
6254         if (!pages)
6255                 return;
6256
6257         for (i = 0; i < size; i++) {
6258                 if (!pages[i])
6259                         break;
6260                 __free_page(pages[i]);
6261         }
6262         kfree(pages);
6263 }
6264
6265 static struct page **nfs4_alloc_pages(size_t size, gfp_t gfp_flags)
6266 {
6267         struct page **pages;
6268         int i;
6269
6270         pages = kcalloc(size, sizeof(struct page *), gfp_flags);
6271         if (!pages) {
6272                 dprintk("%s: can't alloc array of %zu pages\n", __func__, size);
6273                 return NULL;
6274         }
6275
6276         for (i = 0; i < size; i++) {
6277                 pages[i] = alloc_page(gfp_flags);
6278                 if (!pages[i]) {
6279                         dprintk("%s: failed to allocate page\n", __func__);
6280                         nfs4_free_pages(pages, size);
6281                         return NULL;
6282                 }
6283         }
6284
6285         return pages;
6286 }
6287
6288 static void nfs4_layoutget_release(void *calldata)
6289 {
6290         struct nfs4_layoutget *lgp = calldata;
6291         struct inode *inode = lgp->args.inode;
6292         struct nfs_server *server = NFS_SERVER(inode);
6293         size_t max_pages = max_response_pages(server);
6294
6295         dprintk("--> %s\n", __func__);
6296         nfs4_free_pages(lgp->args.layout.pages, max_pages);
6297         pnfs_put_layout_hdr(NFS_I(inode)->layout);
6298         put_nfs_open_context(lgp->args.ctx);
6299         kfree(calldata);
6300         dprintk("<-- %s\n", __func__);
6301 }
6302
6303 static const struct rpc_call_ops nfs4_layoutget_call_ops = {
6304         .rpc_call_prepare = nfs4_layoutget_prepare,
6305         .rpc_call_done = nfs4_layoutget_done,
6306         .rpc_release = nfs4_layoutget_release,
6307 };
6308
6309 struct pnfs_layout_segment *
6310 nfs4_proc_layoutget(struct nfs4_layoutget *lgp, gfp_t gfp_flags)
6311 {
6312         struct inode *inode = lgp->args.inode;
6313         struct nfs_server *server = NFS_SERVER(inode);
6314         size_t max_pages = max_response_pages(server);
6315         struct rpc_task *task;
6316         struct rpc_message msg = {
6317                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTGET],
6318                 .rpc_argp = &lgp->args,
6319                 .rpc_resp = &lgp->res,
6320         };
6321         struct rpc_task_setup task_setup_data = {
6322                 .rpc_client = server->client,
6323                 .rpc_message = &msg,
6324                 .callback_ops = &nfs4_layoutget_call_ops,
6325                 .callback_data = lgp,
6326                 .flags = RPC_TASK_ASYNC,
6327         };
6328         struct pnfs_layout_segment *lseg = NULL;
6329         int status = 0;
6330
6331         dprintk("--> %s\n", __func__);
6332
6333         lgp->args.layout.pages = nfs4_alloc_pages(max_pages, gfp_flags);
6334         if (!lgp->args.layout.pages) {
6335                 nfs4_layoutget_release(lgp);
6336                 return ERR_PTR(-ENOMEM);
6337         }
6338         lgp->args.layout.pglen = max_pages * PAGE_SIZE;
6339         lgp->args.timestamp = jiffies;
6340
6341         lgp->res.layoutp = &lgp->args.layout;
6342         lgp->res.seq_res.sr_slot = NULL;
6343         nfs41_init_sequence(&lgp->args.seq_args, &lgp->res.seq_res, 0);
6344
6345         /* nfs4_layoutget_release calls pnfs_put_layout_hdr */
6346         pnfs_get_layout_hdr(NFS_I(inode)->layout);
6347
6348         task = rpc_run_task(&task_setup_data);
6349         if (IS_ERR(task))
6350                 return ERR_CAST(task);
6351         status = nfs4_wait_for_completion_rpc_task(task);
6352         if (status == 0)
6353                 status = task->tk_status;
6354         /* if layoutp->len is 0, nfs4_layoutget_prepare called rpc_exit */
6355         if (status == 0 && lgp->res.layoutp->len)
6356                 lseg = pnfs_layout_process(lgp);
6357         rpc_put_task(task);
6358         dprintk("<-- %s status=%d\n", __func__, status);
6359         if (status)
6360                 return ERR_PTR(status);
6361         return lseg;
6362 }
6363
6364 static void
6365 nfs4_layoutreturn_prepare(struct rpc_task *task, void *calldata)
6366 {
6367         struct nfs4_layoutreturn *lrp = calldata;
6368
6369         dprintk("--> %s\n", __func__);
6370         nfs41_setup_sequence(lrp->clp->cl_session,
6371                         &lrp->args.seq_args,
6372                         &lrp->res.seq_res,
6373                         task);
6374 }
6375
6376 static void nfs4_layoutreturn_done(struct rpc_task *task, void *calldata)
6377 {
6378         struct nfs4_layoutreturn *lrp = calldata;
6379         struct nfs_server *server;
6380
6381         dprintk("--> %s\n", __func__);
6382
6383         if (!nfs41_sequence_done(task, &lrp->res.seq_res))
6384                 return;
6385
6386         server = NFS_SERVER(lrp->args.inode);
6387         if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) {
6388                 rpc_restart_call_prepare(task);
6389                 return;
6390         }
6391         dprintk("<-- %s\n", __func__);
6392 }
6393
6394 static void nfs4_layoutreturn_release(void *calldata)
6395 {
6396         struct nfs4_layoutreturn *lrp = calldata;
6397         struct pnfs_layout_hdr *lo = lrp->args.layout;
6398
6399         dprintk("--> %s\n", __func__);
6400         spin_lock(&lo->plh_inode->i_lock);
6401         if (lrp->res.lrs_present)
6402                 pnfs_set_layout_stateid(lo, &lrp->res.stateid, true);
6403         lo->plh_block_lgets--;
6404         spin_unlock(&lo->plh_inode->i_lock);
6405         pnfs_put_layout_hdr(lrp->args.layout);
6406         kfree(calldata);
6407         dprintk("<-- %s\n", __func__);
6408 }
6409
6410 static const struct rpc_call_ops nfs4_layoutreturn_call_ops = {
6411         .rpc_call_prepare = nfs4_layoutreturn_prepare,
6412         .rpc_call_done = nfs4_layoutreturn_done,
6413         .rpc_release = nfs4_layoutreturn_release,
6414 };
6415
6416 int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp)
6417 {
6418         struct rpc_task *task;
6419         struct rpc_message msg = {
6420                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTRETURN],
6421                 .rpc_argp = &lrp->args,
6422                 .rpc_resp = &lrp->res,
6423         };
6424         struct rpc_task_setup task_setup_data = {
6425                 .rpc_client = lrp->clp->cl_rpcclient,
6426                 .rpc_message = &msg,
6427                 .callback_ops = &nfs4_layoutreturn_call_ops,
6428                 .callback_data = lrp,
6429         };
6430         int status;
6431
6432         dprintk("--> %s\n", __func__);
6433         nfs41_init_sequence(&lrp->args.seq_args, &lrp->res.seq_res, 1);
6434         task = rpc_run_task(&task_setup_data);
6435         if (IS_ERR(task))
6436                 return PTR_ERR(task);
6437         status = task->tk_status;
6438         dprintk("<-- %s status=%d\n", __func__, status);
6439         rpc_put_task(task);
6440         return status;
6441 }
6442
6443 /*
6444  * Retrieve the list of Data Server devices from the MDS.
6445  */
6446 static int _nfs4_getdevicelist(struct nfs_server *server,
6447                                     const struct nfs_fh *fh,
6448                                     struct pnfs_devicelist *devlist)
6449 {
6450         struct nfs4_getdevicelist_args args = {
6451                 .fh = fh,
6452                 .layoutclass = server->pnfs_curr_ld->id,
6453         };
6454         struct nfs4_getdevicelist_res res = {
6455                 .devlist = devlist,
6456         };
6457         struct rpc_message msg = {
6458                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICELIST],
6459                 .rpc_argp = &args,
6460                 .rpc_resp = &res,
6461         };
6462         int status;
6463
6464         dprintk("--> %s\n", __func__);
6465         status = nfs4_call_sync(server->client, server, &msg, &args.seq_args,
6466                                 &res.seq_res, 0);
6467         dprintk("<-- %s status=%d\n", __func__, status);
6468         return status;
6469 }
6470
6471 int nfs4_proc_getdevicelist(struct nfs_server *server,
6472                             const struct nfs_fh *fh,
6473                             struct pnfs_devicelist *devlist)
6474 {
6475         struct nfs4_exception exception = { };
6476         int err;
6477
6478         do {
6479                 err = nfs4_handle_exception(server,
6480                                 _nfs4_getdevicelist(server, fh, devlist),
6481                                 &exception);
6482         } while (exception.retry);
6483
6484         dprintk("%s: err=%d, num_devs=%u\n", __func__,
6485                 err, devlist->num_devs);
6486
6487         return err;
6488 }
6489 EXPORT_SYMBOL_GPL(nfs4_proc_getdevicelist);
6490
6491 static int
6492 _nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)
6493 {
6494         struct nfs4_getdeviceinfo_args args = {
6495                 .pdev = pdev,
6496         };
6497         struct nfs4_getdeviceinfo_res res = {
6498                 .pdev = pdev,
6499         };
6500         struct rpc_message msg = {
6501                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICEINFO],
6502                 .rpc_argp = &args,
6503                 .rpc_resp = &res,
6504         };
6505         int status;
6506
6507         dprintk("--> %s\n", __func__);
6508         status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
6509         dprintk("<-- %s status=%d\n", __func__, status);
6510
6511         return status;
6512 }
6513
6514 int nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)
6515 {
6516         struct nfs4_exception exception = { };
6517         int err;
6518
6519         do {
6520                 err = nfs4_handle_exception(server,
6521                                         _nfs4_proc_getdeviceinfo(server, pdev),
6522                                         &exception);
6523         } while (exception.retry);
6524         return err;
6525 }
6526 EXPORT_SYMBOL_GPL(nfs4_proc_getdeviceinfo);
6527
6528 static void nfs4_layoutcommit_prepare(struct rpc_task *task, void *calldata)
6529 {
6530         struct nfs4_layoutcommit_data *data = calldata;
6531         struct nfs_server *server = NFS_SERVER(data->args.inode);
6532         struct nfs4_session *session = nfs4_get_session(server);
6533
6534         nfs41_setup_sequence(session,
6535                         &data->args.seq_args,
6536                         &data->res.seq_res,
6537                         task);
6538 }
6539
6540 static void
6541 nfs4_layoutcommit_done(struct rpc_task *task, void *calldata)
6542 {
6543         struct nfs4_layoutcommit_data *data = calldata;
6544         struct nfs_server *server = NFS_SERVER(data->args.inode);
6545
6546         if (!nfs41_sequence_done(task, &data->res.seq_res))
6547                 return;
6548
6549         switch (task->tk_status) { /* Just ignore these failures */
6550         case -NFS4ERR_DELEG_REVOKED: /* layout was recalled */
6551         case -NFS4ERR_BADIOMODE:     /* no IOMODE_RW layout for range */
6552         case -NFS4ERR_BADLAYOUT:     /* no layout */
6553         case -NFS4ERR_GRACE:        /* loca_recalim always false */
6554                 task->tk_status = 0;
6555                 break;
6556         case 0:
6557                 nfs_post_op_update_inode_force_wcc(data->args.inode,
6558                                                    data->res.fattr);
6559                 break;
6560         default:
6561                 if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) {
6562                         rpc_restart_call_prepare(task);
6563                         return;
6564                 }
6565         }
6566 }
6567
6568 static void nfs4_layoutcommit_release(void *calldata)
6569 {
6570         struct nfs4_layoutcommit_data *data = calldata;
6571
6572         pnfs_cleanup_layoutcommit(data);
6573         put_rpccred(data->cred);
6574         kfree(data);
6575 }
6576
6577 static const struct rpc_call_ops nfs4_layoutcommit_ops = {
6578         .rpc_call_prepare = nfs4_layoutcommit_prepare,
6579         .rpc_call_done = nfs4_layoutcommit_done,
6580         .rpc_release = nfs4_layoutcommit_release,
6581 };
6582
6583 int
6584 nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, bool sync)
6585 {
6586         struct rpc_message msg = {
6587                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTCOMMIT],
6588                 .rpc_argp = &data->args,
6589                 .rpc_resp = &data->res,
6590                 .rpc_cred = data->cred,
6591         };
6592         struct rpc_task_setup task_setup_data = {
6593                 .task = &data->task,
6594                 .rpc_client = NFS_CLIENT(data->args.inode),
6595                 .rpc_message = &msg,
6596                 .callback_ops = &nfs4_layoutcommit_ops,
6597                 .callback_data = data,
6598                 .flags = RPC_TASK_ASYNC,
6599         };
6600         struct rpc_task *task;
6601         int status = 0;
6602
6603         dprintk("NFS: %4d initiating layoutcommit call. sync %d "
6604                 "lbw: %llu inode %lu\n",
6605                 data->task.tk_pid, sync,
6606                 data->args.lastbytewritten,
6607                 data->args.inode->i_ino);
6608
6609         nfs41_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
6610         task = rpc_run_task(&task_setup_data);
6611         if (IS_ERR(task))
6612                 return PTR_ERR(task);
6613         if (sync == false)
6614                 goto out;
6615         status = nfs4_wait_for_completion_rpc_task(task);
6616         if (status != 0)
6617                 goto out;
6618         status = task->tk_status;
6619 out:
6620         dprintk("%s: status %d\n", __func__, status);
6621         rpc_put_task(task);
6622         return status;
6623 }
6624
6625 static int
6626 _nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
6627                     struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors)
6628 {
6629         struct nfs41_secinfo_no_name_args args = {
6630                 .style = SECINFO_STYLE_CURRENT_FH,
6631         };
6632         struct nfs4_secinfo_res res = {
6633                 .flavors = flavors,
6634         };
6635         struct rpc_message msg = {
6636                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO_NO_NAME],
6637                 .rpc_argp = &args,
6638                 .rpc_resp = &res,
6639         };
6640         return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
6641 }
6642
6643 static int
6644 nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
6645                            struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors)
6646 {
6647         struct nfs4_exception exception = { };
6648         int err;
6649         do {
6650                 err = _nfs41_proc_secinfo_no_name(server, fhandle, info, flavors);
6651                 switch (err) {
6652                 case 0:
6653                 case -NFS4ERR_WRONGSEC:
6654                 case -NFS4ERR_NOTSUPP:
6655                         goto out;
6656                 default:
6657                         err = nfs4_handle_exception(server, err, &exception);
6658                 }
6659         } while (exception.retry);
6660 out:
6661         return err;
6662 }
6663
6664 static int
6665 nfs41_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
6666                     struct nfs_fsinfo *info)
6667 {
6668         int err;
6669         struct page *page;
6670         rpc_authflavor_t flavor;
6671         struct nfs4_secinfo_flavors *flavors;
6672
6673         page = alloc_page(GFP_KERNEL);
6674         if (!page) {
6675                 err = -ENOMEM;
6676                 goto out;
6677         }
6678
6679         flavors = page_address(page);
6680         err = nfs41_proc_secinfo_no_name(server, fhandle, info, flavors);
6681
6682         /*
6683          * Fall back on "guess and check" method if
6684          * the server doesn't support SECINFO_NO_NAME
6685          */
6686         if (err == -NFS4ERR_WRONGSEC || err == -NFS4ERR_NOTSUPP) {
6687                 err = nfs4_find_root_sec(server, fhandle, info);
6688                 goto out_freepage;
6689         }
6690         if (err)
6691                 goto out_freepage;
6692
6693         flavor = nfs_find_best_sec(flavors);
6694         if (err == 0)
6695                 err = nfs4_lookup_root_sec(server, fhandle, info, flavor);
6696
6697 out_freepage:
6698         put_page(page);
6699         if (err == -EACCES)
6700                 return -EPERM;
6701 out:
6702         return err;
6703 }
6704
6705 static int _nfs41_test_stateid(struct nfs_server *server, nfs4_stateid *stateid)
6706 {
6707         int status;
6708         struct nfs41_test_stateid_args args = {
6709                 .stateid = stateid,
6710         };
6711         struct nfs41_test_stateid_res res;
6712         struct rpc_message msg = {
6713                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_TEST_STATEID],
6714                 .rpc_argp = &args,
6715                 .rpc_resp = &res,
6716         };
6717
6718         dprintk("NFS call  test_stateid %p\n", stateid);
6719         nfs41_init_sequence(&args.seq_args, &res.seq_res, 0);
6720         nfs4_set_sequence_privileged(&args.seq_args);
6721         status = nfs4_call_sync_sequence(server->client, server, &msg,
6722                         &args.seq_args, &res.seq_res);
6723         if (status != NFS_OK) {
6724                 dprintk("NFS reply test_stateid: failed, %d\n", status);
6725                 return status;
6726         }
6727         dprintk("NFS reply test_stateid: succeeded, %d\n", -res.status);
6728         return -res.status;
6729 }
6730
6731 /**
6732  * nfs41_test_stateid - perform a TEST_STATEID operation
6733  *
6734  * @server: server / transport on which to perform the operation
6735  * @stateid: state ID to test
6736  *
6737  * Returns NFS_OK if the server recognizes that "stateid" is valid.
6738  * Otherwise a negative NFS4ERR value is returned if the operation
6739  * failed or the state ID is not currently valid.
6740  */
6741 static int nfs41_test_stateid(struct nfs_server *server, nfs4_stateid *stateid)
6742 {
6743         struct nfs4_exception exception = { };
6744         int err;
6745         do {
6746                 err = _nfs41_test_stateid(server, stateid);
6747                 if (err != -NFS4ERR_DELAY)
6748                         break;
6749                 nfs4_handle_exception(server, err, &exception);
6750         } while (exception.retry);
6751         return err;
6752 }
6753
6754 static int _nfs4_free_stateid(struct nfs_server *server, nfs4_stateid *stateid)
6755 {
6756         struct nfs41_free_stateid_args args = {
6757                 .stateid = stateid,
6758         };
6759         struct nfs41_free_stateid_res res;
6760         struct rpc_message msg = {
6761                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FREE_STATEID],
6762                 .rpc_argp = &args,
6763                 .rpc_resp = &res,
6764         };
6765         int status;
6766
6767         dprintk("NFS call  free_stateid %p\n", stateid);
6768         nfs41_init_sequence(&args.seq_args, &res.seq_res, 0);
6769         nfs4_set_sequence_privileged(&args.seq_args);
6770         status = nfs4_call_sync_sequence(server->client, server, &msg,
6771                         &args.seq_args, &res.seq_res);
6772         dprintk("NFS reply free_stateid: %d\n", status);
6773         return status;
6774 }
6775
6776 /**
6777  * nfs41_free_stateid - perform a FREE_STATEID operation
6778  *
6779  * @server: server / transport on which to perform the operation
6780  * @stateid: state ID to release
6781  *
6782  * Returns NFS_OK if the server freed "stateid".  Otherwise a
6783  * negative NFS4ERR value is returned.
6784  */
6785 static int nfs41_free_stateid(struct nfs_server *server, nfs4_stateid *stateid)
6786 {
6787         struct nfs4_exception exception = { };
6788         int err;
6789         do {
6790                 err = _nfs4_free_stateid(server, stateid);
6791                 if (err != -NFS4ERR_DELAY)
6792                         break;
6793                 nfs4_handle_exception(server, err, &exception);
6794         } while (exception.retry);
6795         return err;
6796 }
6797
6798 static bool nfs41_match_stateid(const nfs4_stateid *s1,
6799                 const nfs4_stateid *s2)
6800 {
6801         if (memcmp(s1->other, s2->other, sizeof(s1->other)) != 0)
6802                 return false;
6803
6804         if (s1->seqid == s2->seqid)
6805                 return true;
6806         if (s1->seqid == 0 || s2->seqid == 0)
6807                 return true;
6808
6809         return false;
6810 }
6811
6812 #endif /* CONFIG_NFS_V4_1 */
6813
6814 static bool nfs4_match_stateid(const nfs4_stateid *s1,
6815                 const nfs4_stateid *s2)
6816 {
6817         return nfs4_stateid_match(s1, s2);
6818 }
6819
6820
6821 static const struct nfs4_state_recovery_ops nfs40_reboot_recovery_ops = {
6822         .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,
6823         .state_flag_bit = NFS_STATE_RECLAIM_REBOOT,
6824         .recover_open   = nfs4_open_reclaim,
6825         .recover_lock   = nfs4_lock_reclaim,
6826         .establish_clid = nfs4_init_clientid,
6827         .get_clid_cred  = nfs4_get_setclientid_cred,
6828         .detect_trunking = nfs40_discover_server_trunking,
6829 };
6830
6831 #if defined(CONFIG_NFS_V4_1)
6832 static const struct nfs4_state_recovery_ops nfs41_reboot_recovery_ops = {
6833         .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,
6834         .state_flag_bit = NFS_STATE_RECLAIM_REBOOT,
6835         .recover_open   = nfs4_open_reclaim,
6836         .recover_lock   = nfs4_lock_reclaim,
6837         .establish_clid = nfs41_init_clientid,
6838         .get_clid_cred  = nfs4_get_exchange_id_cred,
6839         .reclaim_complete = nfs41_proc_reclaim_complete,
6840         .detect_trunking = nfs41_discover_server_trunking,
6841 };
6842 #endif /* CONFIG_NFS_V4_1 */
6843
6844 static const struct nfs4_state_recovery_ops nfs40_nograce_recovery_ops = {
6845         .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,
6846         .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE,
6847         .recover_open   = nfs4_open_expired,
6848         .recover_lock   = nfs4_lock_expired,
6849         .establish_clid = nfs4_init_clientid,
6850         .get_clid_cred  = nfs4_get_setclientid_cred,
6851 };
6852
6853 #if defined(CONFIG_NFS_V4_1)
6854 static const struct nfs4_state_recovery_ops nfs41_nograce_recovery_ops = {
6855         .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,
6856         .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE,
6857         .recover_open   = nfs41_open_expired,
6858         .recover_lock   = nfs41_lock_expired,
6859         .establish_clid = nfs41_init_clientid,
6860         .get_clid_cred  = nfs4_get_exchange_id_cred,
6861 };
6862 #endif /* CONFIG_NFS_V4_1 */
6863
6864 static const struct nfs4_state_maintenance_ops nfs40_state_renewal_ops = {
6865         .sched_state_renewal = nfs4_proc_async_renew,
6866         .get_state_renewal_cred_locked = nfs4_get_renew_cred_locked,
6867         .renew_lease = nfs4_proc_renew,
6868 };
6869
6870 #if defined(CONFIG_NFS_V4_1)
6871 static const struct nfs4_state_maintenance_ops nfs41_state_renewal_ops = {
6872         .sched_state_renewal = nfs41_proc_async_sequence,
6873         .get_state_renewal_cred_locked = nfs4_get_machine_cred_locked,
6874         .renew_lease = nfs4_proc_sequence,
6875 };
6876 #endif
6877
6878 static const struct nfs4_minor_version_ops nfs_v4_0_minor_ops = {
6879         .minor_version = 0,
6880         .init_caps = NFS_CAP_READDIRPLUS
6881                 | NFS_CAP_ATOMIC_OPEN
6882                 | NFS_CAP_CHANGE_ATTR
6883                 | NFS_CAP_POSIX_LOCK,
6884         .call_sync = _nfs4_call_sync,
6885         .match_stateid = nfs4_match_stateid,
6886         .find_root_sec = nfs4_find_root_sec,
6887         .reboot_recovery_ops = &nfs40_reboot_recovery_ops,
6888         .nograce_recovery_ops = &nfs40_nograce_recovery_ops,
6889         .state_renewal_ops = &nfs40_state_renewal_ops,
6890 };
6891
6892 #if defined(CONFIG_NFS_V4_1)
6893 static const struct nfs4_minor_version_ops nfs_v4_1_minor_ops = {
6894         .minor_version = 1,
6895         .init_caps = NFS_CAP_READDIRPLUS
6896                 | NFS_CAP_ATOMIC_OPEN
6897                 | NFS_CAP_CHANGE_ATTR
6898                 | NFS_CAP_POSIX_LOCK
6899                 | NFS_CAP_STATEID_NFSV41
6900                 | NFS_CAP_ATOMIC_OPEN_V1,
6901         .call_sync = nfs4_call_sync_sequence,
6902         .match_stateid = nfs41_match_stateid,
6903         .find_root_sec = nfs41_find_root_sec,
6904         .reboot_recovery_ops = &nfs41_reboot_recovery_ops,
6905         .nograce_recovery_ops = &nfs41_nograce_recovery_ops,
6906         .state_renewal_ops = &nfs41_state_renewal_ops,
6907 };
6908 #endif
6909
6910 const struct nfs4_minor_version_ops *nfs_v4_minor_ops[] = {
6911         [0] = &nfs_v4_0_minor_ops,
6912 #if defined(CONFIG_NFS_V4_1)
6913         [1] = &nfs_v4_1_minor_ops,
6914 #endif
6915 };
6916
6917 const struct inode_operations nfs4_dir_inode_operations = {
6918         .create         = nfs_create,
6919         .lookup         = nfs_lookup,
6920         .atomic_open    = nfs_atomic_open,
6921         .link           = nfs_link,
6922         .unlink         = nfs_unlink,
6923         .symlink        = nfs_symlink,
6924         .mkdir          = nfs_mkdir,
6925         .rmdir          = nfs_rmdir,
6926         .mknod          = nfs_mknod,
6927         .rename         = nfs_rename,
6928         .permission     = nfs_permission,
6929         .getattr        = nfs_getattr,
6930         .setattr        = nfs_setattr,
6931         .getxattr       = generic_getxattr,
6932         .setxattr       = generic_setxattr,
6933         .listxattr      = generic_listxattr,
6934         .removexattr    = generic_removexattr,
6935 };
6936
6937 static const struct inode_operations nfs4_file_inode_operations = {
6938         .permission     = nfs_permission,
6939         .getattr        = nfs_getattr,
6940         .setattr        = nfs_setattr,
6941         .getxattr       = generic_getxattr,
6942         .setxattr       = generic_setxattr,
6943         .listxattr      = generic_listxattr,
6944         .removexattr    = generic_removexattr,
6945 };
6946
6947 const struct nfs_rpc_ops nfs_v4_clientops = {
6948         .version        = 4,                    /* protocol version */
6949         .dentry_ops     = &nfs4_dentry_operations,
6950         .dir_inode_ops  = &nfs4_dir_inode_operations,
6951         .file_inode_ops = &nfs4_file_inode_operations,
6952         .file_ops       = &nfs4_file_operations,
6953         .getroot        = nfs4_proc_get_root,
6954         .submount       = nfs4_submount,
6955         .try_mount      = nfs4_try_mount,
6956         .getattr        = nfs4_proc_getattr,
6957         .setattr        = nfs4_proc_setattr,
6958         .lookup         = nfs4_proc_lookup,
6959         .access         = nfs4_proc_access,
6960         .readlink       = nfs4_proc_readlink,
6961         .create         = nfs4_proc_create,
6962         .remove         = nfs4_proc_remove,
6963         .unlink_setup   = nfs4_proc_unlink_setup,
6964         .unlink_rpc_prepare = nfs4_proc_unlink_rpc_prepare,
6965         .unlink_done    = nfs4_proc_unlink_done,
6966         .rename         = nfs4_proc_rename,
6967         .rename_setup   = nfs4_proc_rename_setup,
6968         .rename_rpc_prepare = nfs4_proc_rename_rpc_prepare,
6969         .rename_done    = nfs4_proc_rename_done,
6970         .link           = nfs4_proc_link,
6971         .symlink        = nfs4_proc_symlink,
6972         .mkdir          = nfs4_proc_mkdir,
6973         .rmdir          = nfs4_proc_remove,
6974         .readdir        = nfs4_proc_readdir,
6975         .mknod          = nfs4_proc_mknod,
6976         .statfs         = nfs4_proc_statfs,
6977         .fsinfo         = nfs4_proc_fsinfo,
6978         .pathconf       = nfs4_proc_pathconf,
6979         .set_capabilities = nfs4_server_capabilities,
6980         .decode_dirent  = nfs4_decode_dirent,
6981         .read_setup     = nfs4_proc_read_setup,
6982         .read_pageio_init = pnfs_pageio_init_read,
6983         .read_rpc_prepare = nfs4_proc_read_rpc_prepare,
6984         .read_done      = nfs4_read_done,
6985         .write_setup    = nfs4_proc_write_setup,
6986         .write_pageio_init = pnfs_pageio_init_write,
6987         .write_rpc_prepare = nfs4_proc_write_rpc_prepare,
6988         .write_done     = nfs4_write_done,
6989         .commit_setup   = nfs4_proc_commit_setup,
6990         .commit_rpc_prepare = nfs4_proc_commit_rpc_prepare,
6991         .commit_done    = nfs4_commit_done,
6992         .lock           = nfs4_proc_lock,
6993         .clear_acl_cache = nfs4_zap_acl_attr,
6994         .close_context  = nfs4_close_context,
6995         .open_context   = nfs4_atomic_open,
6996         .have_delegation = nfs4_have_delegation,
6997         .return_delegation = nfs4_inode_return_delegation,
6998         .alloc_client   = nfs4_alloc_client,
6999         .init_client    = nfs4_init_client,
7000         .free_client    = nfs4_free_client,
7001         .create_server  = nfs4_create_server,
7002         .clone_server   = nfs_clone_server,
7003 };
7004
7005 static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = {
7006         .prefix = XATTR_NAME_NFSV4_ACL,
7007         .list   = nfs4_xattr_list_nfs4_acl,
7008         .get    = nfs4_xattr_get_nfs4_acl,
7009         .set    = nfs4_xattr_set_nfs4_acl,
7010 };
7011
7012 const struct xattr_handler *nfs4_xattr_handlers[] = {
7013         &nfs4_xattr_nfs4_acl_handler,
7014         NULL
7015 };
7016
7017 /*
7018  * Local variables:
7019  *  c-basic-offset: 8
7020  * End:
7021  */