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/file.h>
  42 #include <linux/string.h>
  43 #include <linux/ratelimit.h>
  44 #include <linux/printk.h>
  45 #include <linux/slab.h>
  46 #include <linux/sunrpc/clnt.h>
  47 #include <linux/nfs.h>
  48 #include <linux/nfs4.h>
  49 #include <linux/nfs_fs.h>
  50 #include <linux/nfs_page.h>
  51 #include <linux/nfs_mount.h>
  52 #include <linux/namei.h>
  53 #include <linux/mount.h>
  54 #include <linux/module.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 "nfs4idmap.h"
  67 #include "nfs4session.h"
  68 #include "fscache.h"
  69
  70 #include "nfs4trace.h"
  71
  72 #define NFSDBG_FACILITY         NFSDBG_PROC
  73
  74 #define NFS4_POLL_RETRY_MIN     (HZ/10)
  75 #define NFS4_POLL_RETRY_MAX     (15*HZ)
  76
  77 /* file attributes which can be mapped to nfs attributes */
  78 #define NFS4_VALID_ATTRS (ATTR_MODE \
  79         | ATTR_UID \
  80         | ATTR_GID \
  81         | ATTR_SIZE \
  82         | ATTR_ATIME \
  83         | ATTR_MTIME \
  84         | ATTR_CTIME \
  85         | ATTR_ATIME_SET \
  86         | ATTR_MTIME_SET)
  87
  88 struct nfs4_opendata;
  89 static int _nfs4_proc_open(struct nfs4_opendata *data);
  90 static int _nfs4_recover_proc_open(struct nfs4_opendata *data);
  91 static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *);
  92 static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr);
  93 static int nfs4_proc_getattr(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *, struct nfs4_label *label);
  94 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr, struct nfs4_label *label);
  95 static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
  96                             struct nfs_fattr *fattr, struct iattr *sattr,
  97                             struct nfs_open_context *ctx, struct nfs4_label *ilabel,
  98                             struct nfs4_label *olabel);
  99 #ifdef CONFIG_NFS_V4_1
 100 static int nfs41_test_stateid(struct nfs_server *, nfs4_stateid *,
 101                 struct rpc_cred *);
 102 static int nfs41_free_stateid(struct nfs_server *, const nfs4_stateid *,
 103                 struct rpc_cred *, bool);
 104 #endif
 105
 106 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
 107 static inline struct nfs4_label *
 108 nfs4_label_init_security(struct inode *dir, struct dentry *dentry,
 109         struct iattr *sattr, struct nfs4_label *label)
 110 {
 111         int err;
 112
 113         if (label == NULL)
 114                 return NULL;
 115
 116         if (nfs_server_capable(dir, NFS_CAP_SECURITY_LABEL) == 0)
 117                 return NULL;
 118
 119         err = security_dentry_init_security(dentry, sattr->ia_mode,
 120                                 &dentry->d_name, (void **)&label->label, &label->len);
 121         if (err == 0)
 122                 return label;
 123
 124         return NULL;
 125 }
 126 static inline void
 127 nfs4_label_release_security(struct nfs4_label *label)
 128 {
 129         if (label)
 130                 security_release_secctx(label->label, label->len);
 131 }
 132 static inline u32 *nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label)
 133 {
 134         if (label)
 135                 return server->attr_bitmask;
 136
 137         return server->attr_bitmask_nl;
 138 }
 139 #else
 140 static inline struct nfs4_label *
 141 nfs4_label_init_security(struct inode *dir, struct dentry *dentry,
 142         struct iattr *sattr, struct nfs4_label *l)
 143 { return NULL; }
 144 static inline void
 145 nfs4_label_release_security(struct nfs4_label *label)
 146 { return; }
 147 static inline u32 *
 148 nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label)
 149 { return server->attr_bitmask; }
 150 #endif
 151
 152 /* Prevent leaks of NFSv4 errors into userland */
 153 static int nfs4_map_errors(int err)
 154 {
 155         if (err >= -1000)
 156                 return err;
 157         switch (err) {
 158         case -NFS4ERR_RESOURCE:
 159         case -NFS4ERR_LAYOUTTRYLATER:
 160         case -NFS4ERR_RECALLCONFLICT:
 161                 return -EREMOTEIO;
 162         case -NFS4ERR_WRONGSEC:
 163         case -NFS4ERR_WRONG_CRED:
 164                 return -EPERM;
 165         case -NFS4ERR_BADOWNER:
 166         case -NFS4ERR_BADNAME:
 167                 return -EINVAL;
 168         case -NFS4ERR_SHARE_DENIED:
 169                 return -EACCES;
 170         case -NFS4ERR_MINOR_VERS_MISMATCH:
 171                 return -EPROTONOSUPPORT;
 172         case -NFS4ERR_FILE_OPEN:
 173                 return -EBUSY;
 174         default:
 175                 dprintk("%s could not handle NFSv4 error %d\n",
 176                                 __func__, -err);
 177                 break;
 178         }
 179         return -EIO;
 180 }
 181
 182 /*
 183  * This is our standard bitmap for GETATTR requests.
 184  */
 185 const u32 nfs4_fattr_bitmap[3] = {
 186         FATTR4_WORD0_TYPE
 187         | FATTR4_WORD0_CHANGE
 188         | FATTR4_WORD0_SIZE
 189         | FATTR4_WORD0_FSID
 190         | FATTR4_WORD0_FILEID,
 191         FATTR4_WORD1_MODE
 192         | FATTR4_WORD1_NUMLINKS
 193         | FATTR4_WORD1_OWNER
 194         | FATTR4_WORD1_OWNER_GROUP
 195         | FATTR4_WORD1_RAWDEV
 196         | FATTR4_WORD1_SPACE_USED
 197         | FATTR4_WORD1_TIME_ACCESS
 198         | FATTR4_WORD1_TIME_METADATA
 199         | FATTR4_WORD1_TIME_MODIFY
 200         | FATTR4_WORD1_MOUNTED_ON_FILEID,
 201 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
 202         FATTR4_WORD2_SECURITY_LABEL
 203 #endif
 204 };
 205
 206 static const u32 nfs4_pnfs_open_bitmap[3] = {
 207         FATTR4_WORD0_TYPE
 208         | FATTR4_WORD0_CHANGE
 209         | FATTR4_WORD0_SIZE
 210         | FATTR4_WORD0_FSID
 211         | FATTR4_WORD0_FILEID,
 212         FATTR4_WORD1_MODE
 213         | FATTR4_WORD1_NUMLINKS
 214         | FATTR4_WORD1_OWNER
 215         | FATTR4_WORD1_OWNER_GROUP
 216         | FATTR4_WORD1_RAWDEV
 217         | FATTR4_WORD1_SPACE_USED
 218         | FATTR4_WORD1_TIME_ACCESS
 219         | FATTR4_WORD1_TIME_METADATA
 220         | FATTR4_WORD1_TIME_MODIFY,
 221         FATTR4_WORD2_MDSTHRESHOLD
 222 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
 223         | FATTR4_WORD2_SECURITY_LABEL
 224 #endif
 225 };
 226
 227 static const u32 nfs4_open_noattr_bitmap[3] = {
 228         FATTR4_WORD0_TYPE
 229         | FATTR4_WORD0_FILEID,
 230 };
 231
 232 const u32 nfs4_statfs_bitmap[3] = {
 233         FATTR4_WORD0_FILES_AVAIL
 234         | FATTR4_WORD0_FILES_FREE
 235         | FATTR4_WORD0_FILES_TOTAL,
 236         FATTR4_WORD1_SPACE_AVAIL
 237         | FATTR4_WORD1_SPACE_FREE
 238         | FATTR4_WORD1_SPACE_TOTAL
 239 };
 240
 241 const u32 nfs4_pathconf_bitmap[3] = {
 242         FATTR4_WORD0_MAXLINK
 243         | FATTR4_WORD0_MAXNAME,
 244         0
 245 };
 246
 247 const u32 nfs4_fsinfo_bitmap[3] = { FATTR4_WORD0_MAXFILESIZE
 248                         | FATTR4_WORD0_MAXREAD
 249                         | FATTR4_WORD0_MAXWRITE
 250                         | FATTR4_WORD0_LEASE_TIME,
 251                         FATTR4_WORD1_TIME_DELTA
 252                         | FATTR4_WORD1_FS_LAYOUT_TYPES,
 253                         FATTR4_WORD2_LAYOUT_BLKSIZE
 254                         | FATTR4_WORD2_CLONE_BLKSIZE
 255 };
 256
 257 const u32 nfs4_fs_locations_bitmap[3] = {
 258         FATTR4_WORD0_TYPE
 259         | FATTR4_WORD0_CHANGE
 260         | FATTR4_WORD0_SIZE
 261         | FATTR4_WORD0_FSID
 262         | FATTR4_WORD0_FILEID
 263         | FATTR4_WORD0_FS_LOCATIONS,
 264         FATTR4_WORD1_MODE
 265         | FATTR4_WORD1_NUMLINKS
 266         | FATTR4_WORD1_OWNER
 267         | FATTR4_WORD1_OWNER_GROUP
 268         | FATTR4_WORD1_RAWDEV
 269         | FATTR4_WORD1_SPACE_USED
 270         | FATTR4_WORD1_TIME_ACCESS
 271         | FATTR4_WORD1_TIME_METADATA
 272         | FATTR4_WORD1_TIME_MODIFY
 273         | FATTR4_WORD1_MOUNTED_ON_FILEID,
 274 };
 275
 276 static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dentry,
 277                 struct nfs4_readdir_arg *readdir)
 278 {
 279         __be32 *start, *p;
 280
 281         if (cookie > 2) {
 282                 readdir->cookie = cookie;
 283                 memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier));
 284                 return;
 285         }
 286
 287         readdir->cookie = 0;
 288         memset(&readdir->verifier, 0, sizeof(readdir->verifier));
 289         if (cookie == 2)
 290                 return;
 291
 292         /*
 293          * NFSv4 servers do not return entries for '.' and '..'
 294          * Therefore, we fake these entries here.  We let '.'
 295          * have cookie 0 and '..' have cookie 1.  Note that
 296          * when talking to the server, we always send cookie 0
 297          * instead of 1 or 2.
 298          */
 299         start = p = kmap_atomic(*readdir->pages);
 300
 301         if (cookie == 0) {
 302                 *p++ = xdr_one;                                  /* next */
 303                 *p++ = xdr_zero;                   /* cookie, first word */
 304                 *p++ = xdr_one;                   /* cookie, second word */
 305                 *p++ = xdr_one;                             /* entry len */
 306                 memcpy(p, ".\0\0\0", 4);                        /* entry */
 307                 p++;
 308                 *p++ = xdr_one;                         /* bitmap length */
 309                 *p++ = htonl(FATTR4_WORD0_FILEID);             /* bitmap */
 310                 *p++ = htonl(8);              /* attribute buffer length */
 311                 p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry)));
 312         }
 313
 314         *p++ = xdr_one;                                  /* next */
 315         *p++ = xdr_zero;                   /* cookie, first word */
 316         *p++ = xdr_two;                   /* cookie, second word */
 317         *p++ = xdr_two;                             /* entry len */
 318         memcpy(p, "..\0\0", 4);                         /* entry */
 319         p++;
 320         *p++ = xdr_one;                         /* bitmap length */
 321         *p++ = htonl(FATTR4_WORD0_FILEID);             /* bitmap */
 322         *p++ = htonl(8);              /* attribute buffer length */
 323         p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry->d_parent)));
 324
 325         readdir->pgbase = (char *)p - (char *)start;
 326         readdir->count -= readdir->pgbase;
 327         kunmap_atomic(start);
 328 }
 329
 330 static void nfs4_test_and_free_stateid(struct nfs_server *server,
 331                 nfs4_stateid *stateid,
 332                 struct rpc_cred *cred)
 333 {
 334         const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops;
 335
 336         ops->test_and_free_expired(server, stateid, cred);
 337 }
 338
 339 static void __nfs4_free_revoked_stateid(struct nfs_server *server,
 340                 nfs4_stateid *stateid,
 341                 struct rpc_cred *cred)
 342 {
 343         stateid->type = NFS4_REVOKED_STATEID_TYPE;
 344         nfs4_test_and_free_stateid(server, stateid, cred);
 345 }
 346
 347 static void nfs4_free_revoked_stateid(struct nfs_server *server,
 348                 const nfs4_stateid *stateid,
 349                 struct rpc_cred *cred)
 350 {
 351         nfs4_stateid tmp;
 352
 353         nfs4_stateid_copy(&tmp, stateid);
 354         __nfs4_free_revoked_stateid(server, &tmp, cred);
 355 }
 356
 357 static long nfs4_update_delay(long *timeout)
 358 {
 359         long ret;
 360         if (!timeout)
 361                 return NFS4_POLL_RETRY_MAX;
 362         if (*timeout <= 0)
 363                 *timeout = NFS4_POLL_RETRY_MIN;
 364         if (*timeout > NFS4_POLL_RETRY_MAX)
 365                 *timeout = NFS4_POLL_RETRY_MAX;
 366         ret = *timeout;
 367         *timeout <<= 1;
 368         return ret;
 369 }
 370
 371 static int nfs4_delay(struct rpc_clnt *clnt, long *timeout)
 372 {
 373         int res = 0;
 374
 375         might_sleep();
 376
 377         freezable_schedule_timeout_killable_unsafe(
 378                 nfs4_update_delay(timeout));
 379         if (fatal_signal_pending(current))
 380                 res = -ERESTARTSYS;
 381         return res;
 382 }
 383
 384 /* This is the error handling routine for processes that are allowed
 385  * to sleep.
 386  */
 387 static int nfs4_do_handle_exception(struct nfs_server *server,
 388                 int errorcode, struct nfs4_exception *exception)
 389 {
 390         struct nfs_client *clp = server->nfs_client;
 391         struct nfs4_state *state = exception->state;
 392         const nfs4_stateid *stateid = exception->stateid;
 393         struct inode *inode = exception->inode;
 394         int ret = errorcode;
 395
 396         exception->delay = 0;
 397         exception->recovering = 0;
 398         exception->retry = 0;
 399
 400         if (stateid == NULL && state != NULL)
 401                 stateid = &state->stateid;
 402
 403         switch(errorcode) {
 404                 case 0:
 405                         return 0;
 406                 case -NFS4ERR_DELEG_REVOKED:
 407                 case -NFS4ERR_ADMIN_REVOKED:
 408                 case -NFS4ERR_EXPIRED:
 409                 case -NFS4ERR_BAD_STATEID:
 410                         if (inode != NULL && stateid != NULL) {
 411                                 nfs_inode_find_state_and_recover(inode,
 412                                                 stateid);
 413                                 goto wait_on_recovery;
 414                         }
 415                 case -NFS4ERR_OPENMODE:
 416                         if (inode) {
 417                                 int err;
 418
 419                                 err = nfs_async_inode_return_delegation(inode,
 420                                                 stateid);
 421                                 if (err == 0)
 422                                         goto wait_on_recovery;
 423                                 if (stateid != NULL && stateid->type == NFS4_DELEGATION_STATEID_TYPE) {
 424                                         exception->retry = 1;
 425                                         break;
 426                                 }
 427                         }
 428                         if (state == NULL)
 429                                 break;
 430                         ret = nfs4_schedule_stateid_recovery(server, state);
 431                         if (ret < 0)
 432                                 break;
 433                         goto wait_on_recovery;
 434                 case -NFS4ERR_STALE_STATEID:
 435                 case -NFS4ERR_STALE_CLIENTID:
 436                         nfs4_schedule_lease_recovery(clp);
 437                         goto wait_on_recovery;
 438                 case -NFS4ERR_MOVED:
 439                         ret = nfs4_schedule_migration_recovery(server);
 440                         if (ret < 0)
 441                                 break;
 442                         goto wait_on_recovery;
 443                 case -NFS4ERR_LEASE_MOVED:
 444                         nfs4_schedule_lease_moved_recovery(clp);
 445                         goto wait_on_recovery;
 446 #if defined(CONFIG_NFS_V4_1)
 447                 case -NFS4ERR_BADSESSION:
 448                 case -NFS4ERR_BADSLOT:
 449                 case -NFS4ERR_BAD_HIGH_SLOT:
 450                 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
 451                 case -NFS4ERR_DEADSESSION:
 452                 case -NFS4ERR_SEQ_FALSE_RETRY:
 453                 case -NFS4ERR_SEQ_MISORDERED:
 454                         dprintk("%s ERROR: %d Reset session\n", __func__,
 455                                 errorcode);
 456                         nfs4_schedule_session_recovery(clp->cl_session, errorcode);
 457                         goto wait_on_recovery;
 458 #endif /* defined(CONFIG_NFS_V4_1) */
 459                 case -NFS4ERR_FILE_OPEN:
 460                         if (exception->timeout > HZ) {
 461                                 /* We have retried a decent amount, time to
 462                                  * fail
 463                                  */
 464                                 ret = -EBUSY;
 465                                 break;
 466                         }
 467                 case -NFS4ERR_DELAY:
 468                         nfs_inc_server_stats(server, NFSIOS_DELAY);
 469                 case -NFS4ERR_GRACE:
 470                 case -NFS4ERR_LAYOUTTRYLATER:
 471                 case -NFS4ERR_RECALLCONFLICT:
 472                         exception->delay = 1;
 473                         return 0;
 474
 475                 case -NFS4ERR_RETRY_UNCACHED_REP:
 476                 case -NFS4ERR_OLD_STATEID:
 477                         exception->retry = 1;
 478                         break;
 479                 case -NFS4ERR_BADOWNER:
 480                         /* The following works around a Linux server bug! */
 481                 case -NFS4ERR_BADNAME:
 482                         if (server->caps & NFS_CAP_UIDGID_NOMAP) {
 483                                 server->caps &= ~NFS_CAP_UIDGID_NOMAP;
 484                                 exception->retry = 1;
 485                                 printk(KERN_WARNING "NFS: v4 server %s "
 486                                                 "does not accept raw "
 487                                                 "uid/gids. "
 488                                                 "Reenabling the idmapper.\n",
 489                                                 server->nfs_client->cl_hostname);
 490                         }
 491         }
 492         /* We failed to handle the error */
 493         return nfs4_map_errors(ret);
 494 wait_on_recovery:
 495         exception->recovering = 1;
 496         return 0;
 497 }
 498
 499 /* This is the error handling routine for processes that are allowed
 500  * to sleep.
 501  */
 502 int nfs4_handle_exception(struct nfs_server *server, int errorcode, struct nfs4_exception *exception)
 503 {
 504         struct nfs_client *clp = server->nfs_client;
 505         int ret;
 506
 507         ret = nfs4_do_handle_exception(server, errorcode, exception);
 508         if (exception->delay) {
 509                 ret = nfs4_delay(server->client, &exception->timeout);
 510                 goto out_retry;
 511         }
 512         if (exception->recovering) {
 513                 ret = nfs4_wait_clnt_recover(clp);
 514                 if (test_bit(NFS_MIG_FAILED, &server->mig_status))
 515                         return -EIO;
 516                 goto out_retry;
 517         }
 518         return ret;
 519 out_retry:
 520         if (ret == 0)
 521                 exception->retry = 1;
 522         return ret;
 523 }
 524
 525 static int
 526 nfs4_async_handle_exception(struct rpc_task *task, struct nfs_server *server,
 527                 int errorcode, struct nfs4_exception *exception)
 528 {
 529         struct nfs_client *clp = server->nfs_client;
 530         int ret;
 531
 532         ret = nfs4_do_handle_exception(server, errorcode, exception);
 533         if (exception->delay) {
 534                 rpc_delay(task, nfs4_update_delay(&exception->timeout));
 535                 goto out_retry;
 536         }
 537         if (exception->recovering) {
 538                 rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL);
 539                 if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0)
 540                         rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task);
 541                 goto out_retry;
 542         }
 543         if (test_bit(NFS_MIG_FAILED, &server->mig_status))
 544                 ret = -EIO;
 545         return ret;
 546 out_retry:
 547         if (ret == 0)
 548                 exception->retry = 1;
 549         return ret;
 550 }
 551
 552 static int
 553 nfs4_async_handle_error(struct rpc_task *task, struct nfs_server *server,
 554                         struct nfs4_state *state, long *timeout)
 555 {
 556         struct nfs4_exception exception = {
 557                 .state = state,
 558         };
 559
 560         if (task->tk_status >= 0)
 561                 return 0;
 562         if (timeout)
 563                 exception.timeout = *timeout;
 564         task->tk_status = nfs4_async_handle_exception(task, server,
 565                         task->tk_status,
 566                         &exception);
 567         if (exception.delay && timeout)
 568                 *timeout = exception.timeout;
 569         if (exception.retry)
 570                 return -EAGAIN;
 571         return 0;
 572 }
 573
 574 /*
 575  * Return 'true' if 'clp' is using an rpc_client that is integrity protected
 576  * or 'false' otherwise.
 577  */
 578 static bool _nfs4_is_integrity_protected(struct nfs_client *clp)
 579 {
 580         rpc_authflavor_t flavor = clp->cl_rpcclient->cl_auth->au_flavor;
 581
 582         if (flavor == RPC_AUTH_GSS_KRB5I ||
 583             flavor == RPC_AUTH_GSS_KRB5P)
 584                 return true;
 585
 586         return false;
 587 }
 588
 589 static void do_renew_lease(struct nfs_client *clp, unsigned long timestamp)
 590 {
 591         spin_lock(&clp->cl_lock);
 592         if (time_before(clp->cl_last_renewal,timestamp))
 593                 clp->cl_last_renewal = timestamp;
 594         spin_unlock(&clp->cl_lock);
 595 }
 596
 597 static void renew_lease(const struct nfs_server *server, unsigned long timestamp)
 598 {
 599         struct nfs_client *clp = server->nfs_client;
 600
 601         if (!nfs4_has_session(clp))
 602                 do_renew_lease(clp, timestamp);
 603 }
 604
 605 struct nfs4_call_sync_data {
 606         const struct nfs_server *seq_server;
 607         struct nfs4_sequence_args *seq_args;
 608         struct nfs4_sequence_res *seq_res;
 609 };
 610
 611 void nfs4_init_sequence(struct nfs4_sequence_args *args,
 612                         struct nfs4_sequence_res *res, int cache_reply)
 613 {
 614         args->sa_slot = NULL;
 615         args->sa_cache_this = cache_reply;
 616         args->sa_privileged = 0;
 617
 618         res->sr_slot = NULL;
 619 }
 620
 621 static void nfs4_set_sequence_privileged(struct nfs4_sequence_args *args)
 622 {
 623         args->sa_privileged = 1;
 624 }
 625
 626 int nfs40_setup_sequence(struct nfs4_slot_table *tbl,
 627                          struct nfs4_sequence_args *args,
 628                          struct nfs4_sequence_res *res,
 629                          struct rpc_task *task)
 630 {
 631         struct nfs4_slot *slot;
 632
 633         /* slot already allocated? */
 634         if (res->sr_slot != NULL)
 635                 goto out_start;
 636
 637         spin_lock(&tbl->slot_tbl_lock);
 638         if (nfs4_slot_tbl_draining(tbl) && !args->sa_privileged)
 639                 goto out_sleep;
 640
 641         slot = nfs4_alloc_slot(tbl);
 642         if (IS_ERR(slot)) {
 643                 if (slot == ERR_PTR(-ENOMEM))
 644                         task->tk_timeout = HZ >> 2;
 645                 goto out_sleep;
 646         }
 647         spin_unlock(&tbl->slot_tbl_lock);
 648
 649         slot->privileged = args->sa_privileged ? 1 : 0;
 650         args->sa_slot = slot;
 651         res->sr_slot = slot;
 652
 653 out_start:
 654         rpc_call_start(task);
 655         return 0;
 656
 657 out_sleep:
 658         if (args->sa_privileged)
 659                 rpc_sleep_on_priority(&tbl->slot_tbl_waitq, task,
 660                                 NULL, RPC_PRIORITY_PRIVILEGED);
 661         else
 662                 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);
 663         spin_unlock(&tbl->slot_tbl_lock);
 664         return -EAGAIN;
 665 }
 666 EXPORT_SYMBOL_GPL(nfs40_setup_sequence);
 667
 668 static void nfs40_sequence_free_slot(struct nfs4_sequence_res *res)
 669 {
 670         struct nfs4_slot *slot = res->sr_slot;
 671         struct nfs4_slot_table *tbl;
 672
 673         tbl = slot->table;
 674         spin_lock(&tbl->slot_tbl_lock);
 675         if (!nfs41_wake_and_assign_slot(tbl, slot))
 676                 nfs4_free_slot(tbl, slot);
 677         spin_unlock(&tbl->slot_tbl_lock);
 678
 679         res->sr_slot = NULL;
 680 }
 681
 682 static int nfs40_sequence_done(struct rpc_task *task,
 683                                struct nfs4_sequence_res *res)
 684 {
 685         if (res->sr_slot != NULL)
 686                 nfs40_sequence_free_slot(res);
 687         return 1;
 688 }
 689
 690 #if defined(CONFIG_NFS_V4_1)
 691
 692 static void nfs41_sequence_free_slot(struct nfs4_sequence_res *res)
 693 {
 694         struct nfs4_session *session;
 695         struct nfs4_slot_table *tbl;
 696         struct nfs4_slot *slot = res->sr_slot;
 697         bool send_new_highest_used_slotid = false;
 698
 699         tbl = slot->table;
 700         session = tbl->session;
 701
 702         /* Bump the slot sequence number */
 703         if (slot->seq_done)
 704                 slot->seq_nr++;
 705         slot->seq_done = 0;
 706
 707         spin_lock(&tbl->slot_tbl_lock);
 708         /* Be nice to the server: try to ensure that the last transmitted
 709          * value for highest_user_slotid <= target_highest_slotid
 710          */
 711         if (tbl->highest_used_slotid > tbl->target_highest_slotid)
 712                 send_new_highest_used_slotid = true;
 713
 714         if (nfs41_wake_and_assign_slot(tbl, slot)) {
 715                 send_new_highest_used_slotid = false;
 716                 goto out_unlock;
 717         }
 718         nfs4_free_slot(tbl, slot);
 719
 720         if (tbl->highest_used_slotid != NFS4_NO_SLOT)
 721                 send_new_highest_used_slotid = false;
 722 out_unlock:
 723         spin_unlock(&tbl->slot_tbl_lock);
 724         res->sr_slot = NULL;
 725         if (send_new_highest_used_slotid)
 726                 nfs41_notify_server(session->clp);
 727         if (waitqueue_active(&tbl->slot_waitq))
 728                 wake_up_all(&tbl->slot_waitq);
 729 }
 730
 731 static int nfs41_sequence_process(struct rpc_task *task,
 732                 struct nfs4_sequence_res *res)
 733 {
 734         struct nfs4_session *session;
 735         struct nfs4_slot *slot = res->sr_slot;
 736         struct nfs_client *clp;
 737         bool interrupted = false;
 738         int ret = 1;
 739
 740         if (slot == NULL)
 741                 goto out_noaction;
 742         /* don't increment the sequence number if the task wasn't sent */
 743         if (!RPC_WAS_SENT(task))
 744                 goto out;
 745
 746         session = slot->table->session;
 747
 748         if (slot->interrupted) {
 749                 slot->interrupted = 0;
 750                 interrupted = true;
 751         }
 752
 753         trace_nfs4_sequence_done(session, res);
 754         /* Check the SEQUENCE operation status */
 755         switch (res->sr_status) {
 756         case 0:
 757                 /* If previous op on slot was interrupted and we reused
 758                  * the seq# and got a reply from the cache, then retry
 759                  */
 760                 if (task->tk_status == -EREMOTEIO && interrupted) {
 761                         ++slot->seq_nr;
 762                         goto retry_nowait;
 763                 }
 764                 /* Update the slot's sequence and clientid lease timer */
 765                 slot->seq_done = 1;
 766                 clp = session->clp;
 767                 do_renew_lease(clp, res->sr_timestamp);
 768                 /* Check sequence flags */
 769                 nfs41_handle_sequence_flag_errors(clp, res->sr_status_flags,
 770                                 !!slot->privileged);
 771                 nfs41_update_target_slotid(slot->table, slot, res);
 772                 break;
 773         case 1:
 774                 /*
 775                  * sr_status remains 1 if an RPC level error occurred.
 776                  * The server may or may not have processed the sequence
 777                  * operation..
 778                  * Mark the slot as having hosted an interrupted RPC call.
 779                  */
 780                 slot->interrupted = 1;
 781                 goto out;
 782         case -NFS4ERR_DELAY:
 783                 /* The server detected a resend of the RPC call and
 784                  * returned NFS4ERR_DELAY as per Section 2.10.6.2
 785                  * of RFC5661.
 786                  */
 787                 dprintk("%s: slot=%u seq=%u: Operation in progress\n",
 788                         __func__,
 789                         slot->slot_nr,
 790                         slot->seq_nr);
 791                 goto out_retry;
 792         case -NFS4ERR_BADSLOT:
 793                 /*
 794                  * The slot id we used was probably retired. Try again
 795                  * using a different slot id.
 796                  */
 797                 goto retry_nowait;
 798         case -NFS4ERR_SEQ_MISORDERED:
 799                 /*
 800                  * Was the last operation on this sequence interrupted?
 801                  * If so, retry after bumping the sequence number.
 802                  */
 803                 if (interrupted) {
 804                         ++slot->seq_nr;
 805                         goto retry_nowait;
 806                 }
 807                 /*
 808                  * Could this slot have been previously retired?
 809                  * If so, then the server may be expecting seq_nr = 1!
 810                  */
 811                 if (slot->seq_nr != 1) {
 812                         slot->seq_nr = 1;
 813                         goto retry_nowait;
 814                 }
 815                 break;
 816         case -NFS4ERR_SEQ_FALSE_RETRY:
 817                 ++slot->seq_nr;
 818                 goto retry_nowait;
 819         case -NFS4ERR_DEADSESSION:
 820         case -NFS4ERR_BADSESSION:
 821                 nfs4_schedule_session_recovery(session, res->sr_status);
 822                 goto retry_nowait;
 823         default:
 824                 /* Just update the slot sequence no. */
 825                 slot->seq_done = 1;
 826         }
 827 out:
 828         /* The session may be reset by one of the error handlers. */
 829         dprintk("%s: Error %d free the slot \n", __func__, res->sr_status);
 830 out_noaction:
 831         return ret;
 832 retry_nowait:
 833         if (rpc_restart_call_prepare(task)) {
 834                 nfs41_sequence_free_slot(res);
 835                 task->tk_status = 0;
 836                 ret = 0;
 837         }
 838         goto out;
 839 out_retry:
 840         if (!rpc_restart_call(task))
 841                 goto out;
 842         rpc_delay(task, NFS4_POLL_RETRY_MAX);
 843         return 0;
 844 }
 845
 846 int nfs41_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)
 847 {
 848         if (!nfs41_sequence_process(task, res))
 849                 return 0;
 850         if (res->sr_slot != NULL)
 851                 nfs41_sequence_free_slot(res);
 852         return 1;
 853
 854 }
 855 EXPORT_SYMBOL_GPL(nfs41_sequence_done);
 856
 857 static int nfs4_sequence_process(struct rpc_task *task, struct nfs4_sequence_res *res)
 858 {
 859         if (res->sr_slot == NULL)
 860                 return 1;
 861         if (res->sr_slot->table->session != NULL)
 862                 return nfs41_sequence_process(task, res);
 863         return nfs40_sequence_done(task, res);
 864 }
 865
 866 static void nfs4_sequence_free_slot(struct nfs4_sequence_res *res)
 867 {
 868         if (res->sr_slot != NULL) {
 869                 if (res->sr_slot->table->session != NULL)
 870                         nfs41_sequence_free_slot(res);
 871                 else
 872                         nfs40_sequence_free_slot(res);
 873         }
 874 }
 875
 876 int nfs4_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)
 877 {
 878         if (res->sr_slot == NULL)
 879                 return 1;
 880         if (!res->sr_slot->table->session)
 881                 return nfs40_sequence_done(task, res);
 882         return nfs41_sequence_done(task, res);
 883 }
 884 EXPORT_SYMBOL_GPL(nfs4_sequence_done);
 885
 886 int nfs41_setup_sequence(struct nfs4_session *session,
 887                                 struct nfs4_sequence_args *args,
 888                                 struct nfs4_sequence_res *res,
 889                                 struct rpc_task *task)
 890 {
 891         struct nfs4_slot *slot;
 892         struct nfs4_slot_table *tbl;
 893
 894         dprintk("--> %s\n", __func__);
 895         /* slot already allocated? */
 896         if (res->sr_slot != NULL)
 897                 goto out_success;
 898
 899         tbl = &session->fc_slot_table;
 900
 901         task->tk_timeout = 0;
 902
 903         spin_lock(&tbl->slot_tbl_lock);
 904         if (test_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state) &&
 905             !args->sa_privileged) {
 906                 /* The state manager will wait until the slot table is empty */
 907                 dprintk("%s session is draining\n", __func__);
 908                 goto out_sleep;
 909         }
 910
 911         slot = nfs4_alloc_slot(tbl);
 912         if (IS_ERR(slot)) {
 913                 /* If out of memory, try again in 1/4 second */
 914                 if (slot == ERR_PTR(-ENOMEM))
 915                         task->tk_timeout = HZ >> 2;
 916                 dprintk("<-- %s: no free slots\n", __func__);
 917                 goto out_sleep;
 918         }
 919         spin_unlock(&tbl->slot_tbl_lock);
 920
 921         slot->privileged = args->sa_privileged ? 1 : 0;
 922         args->sa_slot = slot;
 923
 924         dprintk("<-- %s slotid=%u seqid=%u\n", __func__,
 925                         slot->slot_nr, slot->seq_nr);
 926
 927         res->sr_slot = slot;
 928         res->sr_timestamp = jiffies;
 929         res->sr_status_flags = 0;
 930         /*
 931          * sr_status is only set in decode_sequence, and so will remain
 932          * set to 1 if an rpc level failure occurs.
 933          */
 934         res->sr_status = 1;
 935         trace_nfs4_setup_sequence(session, args);
 936 out_success:
 937         rpc_call_start(task);
 938         return 0;
 939 out_sleep:
 940         /* Privileged tasks are queued with top priority */
 941         if (args->sa_privileged)
 942                 rpc_sleep_on_priority(&tbl->slot_tbl_waitq, task,
 943                                 NULL, RPC_PRIORITY_PRIVILEGED);
 944         else
 945                 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);
 946         spin_unlock(&tbl->slot_tbl_lock);
 947         return -EAGAIN;
 948 }
 949 EXPORT_SYMBOL_GPL(nfs41_setup_sequence);
 950
 951 static int nfs4_setup_sequence(const struct nfs_server *server,
 952                                struct nfs4_sequence_args *args,
 953                                struct nfs4_sequence_res *res,
 954                                struct rpc_task *task)
 955 {
 956         struct nfs4_session *session = nfs4_get_session(server);
 957         int ret = 0;
 958
 959         if (!session)
 960                 return nfs40_setup_sequence(server->nfs_client->cl_slot_tbl,
 961                                             args, res, task);
 962
 963         dprintk("--> %s clp %p session %p sr_slot %u\n",
 964                 __func__, session->clp, session, res->sr_slot ?
 965                         res->sr_slot->slot_nr : NFS4_NO_SLOT);
 966
 967         ret = nfs41_setup_sequence(session, args, res, task);
 968
 969         dprintk("<-- %s status=%d\n", __func__, ret);
 970         return ret;
 971 }
 972
 973 static void nfs41_call_sync_prepare(struct rpc_task *task, void *calldata)
 974 {
 975         struct nfs4_call_sync_data *data = calldata;
 976         struct nfs4_session *session = nfs4_get_session(data->seq_server);
 977
 978         dprintk("--> %s data->seq_server %p\n", __func__, data->seq_server);
 979
 980         nfs41_setup_sequence(session, data->seq_args, data->seq_res, task);
 981 }
 982
 983 static void nfs41_call_sync_done(struct rpc_task *task, void *calldata)
 984 {
 985         struct nfs4_call_sync_data *data = calldata;
 986
 987         nfs41_sequence_done(task, data->seq_res);
 988 }
 989
 990 static const struct rpc_call_ops nfs41_call_sync_ops = {
 991         .rpc_call_prepare = nfs41_call_sync_prepare,
 992         .rpc_call_done = nfs41_call_sync_done,
 993 };
 994
 995 #else   /* !CONFIG_NFS_V4_1 */
 996
 997 static int nfs4_setup_sequence(const struct nfs_server *server,
 998                                struct nfs4_sequence_args *args,
 999                                struct nfs4_sequence_res *res,
1000                                struct rpc_task *task)
1001 {
1002         return nfs40_setup_sequence(server->nfs_client->cl_slot_tbl,
1003                                     args, res, task);
1004 }
1005
1006 static int nfs4_sequence_process(struct rpc_task *task, struct nfs4_sequence_res *res)
1007 {
1008         return nfs40_sequence_done(task, res);
1009 }
1010
1011 static void nfs4_sequence_free_slot(struct nfs4_sequence_res *res)
1012 {
1013         if (res->sr_slot != NULL)
1014                 nfs40_sequence_free_slot(res);
1015 }
1016
1017 int nfs4_sequence_done(struct rpc_task *task,
1018                        struct nfs4_sequence_res *res)
1019 {
1020         return nfs40_sequence_done(task, res);
1021 }
1022 EXPORT_SYMBOL_GPL(nfs4_sequence_done);
1023
1024 #endif  /* !CONFIG_NFS_V4_1 */
1025
1026 static void nfs40_call_sync_prepare(struct rpc_task *task, void *calldata)
1027 {
1028         struct nfs4_call_sync_data *data = calldata;
1029         nfs4_setup_sequence(data->seq_server,
1030                                 data->seq_args, data->seq_res, task);
1031 }
1032
1033 static void nfs40_call_sync_done(struct rpc_task *task, void *calldata)
1034 {
1035         struct nfs4_call_sync_data *data = calldata;
1036         nfs4_sequence_done(task, data->seq_res);
1037 }
1038
1039 static const struct rpc_call_ops nfs40_call_sync_ops = {
1040         .rpc_call_prepare = nfs40_call_sync_prepare,
1041         .rpc_call_done = nfs40_call_sync_done,
1042 };
1043
1044 static int nfs4_call_sync_sequence(struct rpc_clnt *clnt,
1045                                    struct nfs_server *server,
1046                                    struct rpc_message *msg,
1047                                    struct nfs4_sequence_args *args,
1048                                    struct nfs4_sequence_res *res)
1049 {
1050         int ret;
1051         struct rpc_task *task;
1052         struct nfs_client *clp = server->nfs_client;
1053         struct nfs4_call_sync_data data = {
1054                 .seq_server = server,
1055                 .seq_args = args,
1056                 .seq_res = res,
1057         };
1058         struct rpc_task_setup task_setup = {
1059                 .rpc_client = clnt,
1060                 .rpc_message = msg,
1061                 .callback_ops = clp->cl_mvops->call_sync_ops,
1062                 .callback_data = &data
1063         };
1064
1065         task = rpc_run_task(&task_setup);
1066         if (IS_ERR(task))
1067                 ret = PTR_ERR(task);
1068         else {
1069                 ret = task->tk_status;
1070                 rpc_put_task(task);
1071         }
1072         return ret;
1073 }
1074
1075 int nfs4_call_sync(struct rpc_clnt *clnt,
1076                    struct nfs_server *server,
1077                    struct rpc_message *msg,
1078                    struct nfs4_sequence_args *args,
1079                    struct nfs4_sequence_res *res,
1080                    int cache_reply)
1081 {
1082         nfs4_init_sequence(args, res, cache_reply);
1083         return nfs4_call_sync_sequence(clnt, server, msg, args, res);
1084 }
1085
1086 static void update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo)
1087 {
1088         struct nfs_inode *nfsi = NFS_I(dir);
1089
1090         spin_lock(&dir->i_lock);
1091         nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
1092         if (cinfo->atomic && cinfo->before == dir->i_version) {
1093                 nfsi->cache_validity &= ~NFS_INO_REVAL_PAGECACHE;
1094                 nfsi->attrtimeo_timestamp = jiffies;
1095         } else {
1096                 nfs_force_lookup_revalidate(dir);
1097                 if (cinfo->before != dir->i_version)
1098                         nfsi->cache_validity |= NFS_INO_INVALID_ACCESS |
1099                                 NFS_INO_INVALID_ACL;
1100         }
1101         dir->i_version = cinfo->after;
1102         nfsi->attr_gencount = nfs_inc_attr_generation_counter();
1103         nfs_fscache_invalidate(dir);
1104         spin_unlock(&dir->i_lock);
1105 }
1106
1107 struct nfs4_opendata {
1108         struct kref kref;
1109         struct nfs_openargs o_arg;
1110         struct nfs_openres o_res;
1111         struct nfs_open_confirmargs c_arg;
1112         struct nfs_open_confirmres c_res;
1113         struct nfs4_string owner_name;
1114         struct nfs4_string group_name;
1115         struct nfs4_label *a_label;
1116         struct nfs_fattr f_attr;
1117         struct nfs4_label *f_label;
1118         struct dentry *dir;
1119         struct dentry *dentry;
1120         struct nfs4_state_owner *owner;
1121         struct nfs4_state *state;
1122         struct iattr attrs;
1123         unsigned long timestamp;
1124         unsigned int rpc_done : 1;
1125         unsigned int file_created : 1;
1126         unsigned int is_recover : 1;
1127         int rpc_status;
1128         int cancelled;
1129 };
1130
1131 static bool nfs4_clear_cap_atomic_open_v1(struct nfs_server *server,
1132                 int err, struct nfs4_exception *exception)
1133 {
1134         if (err != -EINVAL)
1135                 return false;
1136         if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1))
1137                 return false;
1138         server->caps &= ~NFS_CAP_ATOMIC_OPEN_V1;
1139         exception->retry = 1;
1140         return true;
1141 }
1142
1143 static u32
1144 nfs4_map_atomic_open_share(struct nfs_server *server,
1145                 fmode_t fmode, int openflags)
1146 {
1147         u32 res = 0;
1148
1149         switch (fmode & (FMODE_READ | FMODE_WRITE)) {
1150         case FMODE_READ:
1151                 res = NFS4_SHARE_ACCESS_READ;
1152                 break;
1153         case FMODE_WRITE:
1154                 res = NFS4_SHARE_ACCESS_WRITE;
1155                 break;
1156         case FMODE_READ|FMODE_WRITE:
1157                 res = NFS4_SHARE_ACCESS_BOTH;
1158         }
1159         if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1))
1160                 goto out;
1161         /* Want no delegation if we're using O_DIRECT */
1162         if (openflags & O_DIRECT)
1163                 res |= NFS4_SHARE_WANT_NO_DELEG;
1164 out:
1165         return res;
1166 }
1167
1168 static enum open_claim_type4
1169 nfs4_map_atomic_open_claim(struct nfs_server *server,
1170                 enum open_claim_type4 claim)
1171 {
1172         if (server->caps & NFS_CAP_ATOMIC_OPEN_V1)
1173                 return claim;
1174         switch (claim) {
1175         default:
1176                 return claim;
1177         case NFS4_OPEN_CLAIM_FH:
1178                 return NFS4_OPEN_CLAIM_NULL;
1179         case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
1180                 return NFS4_OPEN_CLAIM_DELEGATE_CUR;
1181         case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
1182                 return NFS4_OPEN_CLAIM_DELEGATE_PREV;
1183         }
1184 }
1185
1186 static void nfs4_init_opendata_res(struct nfs4_opendata *p)
1187 {
1188         p->o_res.f_attr = &p->f_attr;
1189         p->o_res.f_label = p->f_label;
1190         p->o_res.seqid = p->o_arg.seqid;
1191         p->c_res.seqid = p->c_arg.seqid;
1192         p->o_res.server = p->o_arg.server;
1193         p->o_res.access_request = p->o_arg.access;
1194         nfs_fattr_init(&p->f_attr);
1195         nfs_fattr_init_names(&p->f_attr, &p->owner_name, &p->group_name);
1196 }
1197
1198 static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
1199                 struct nfs4_state_owner *sp, fmode_t fmode, int flags,
1200                 const struct iattr *attrs,
1201                 struct nfs4_label *label,
1202                 enum open_claim_type4 claim,
1203                 gfp_t gfp_mask)
1204 {
1205         struct dentry *parent = dget_parent(dentry);
1206         struct inode *dir = d_inode(parent);
1207         struct nfs_server *server = NFS_SERVER(dir);
1208         struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
1209         struct nfs4_opendata *p;
1210
1211         p = kzalloc(sizeof(*p), gfp_mask);
1212         if (p == NULL)
1213                 goto err;
1214
1215         p->f_label = nfs4_label_alloc(server, gfp_mask);
1216         if (IS_ERR(p->f_label))
1217                 goto err_free_p;
1218
1219         p->a_label = nfs4_label_alloc(server, gfp_mask);
1220         if (IS_ERR(p->a_label))
1221                 goto err_free_f;
1222
1223         alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
1224         p->o_arg.seqid = alloc_seqid(&sp->so_seqid, gfp_mask);
1225         if (IS_ERR(p->o_arg.seqid))
1226                 goto err_free_label;
1227         nfs_sb_active(dentry->d_sb);
1228         p->dentry = dget(dentry);
1229         p->dir = parent;
1230         p->owner = sp;
1231         atomic_inc(&sp->so_count);
1232         p->o_arg.open_flags = flags;
1233         p->o_arg.fmode = fmode & (FMODE_READ|FMODE_WRITE);
1234         p->o_arg.umask = current_umask();
1235         p->o_arg.claim = nfs4_map_atomic_open_claim(server, claim);
1236         p->o_arg.share_access = nfs4_map_atomic_open_share(server,
1237                         fmode, flags);
1238         /* don't put an ACCESS op in OPEN compound if O_EXCL, because ACCESS
1239          * will return permission denied for all bits until close */
1240         if (!(flags & O_EXCL)) {
1241                 /* ask server to check for all possible rights as results
1242                  * are cached */
1243                 switch (p->o_arg.claim) {
1244                 default:
1245                         break;
1246                 case NFS4_OPEN_CLAIM_NULL:
1247                 case NFS4_OPEN_CLAIM_FH:
1248                         p->o_arg.access = NFS4_ACCESS_READ |
1249                                 NFS4_ACCESS_MODIFY |
1250                                 NFS4_ACCESS_EXTEND |
1251                                 NFS4_ACCESS_EXECUTE;
1252                 }
1253         }
1254         p->o_arg.clientid = server->nfs_client->cl_clientid;
1255         p->o_arg.id.create_time = ktime_to_ns(sp->so_seqid.create_time);
1256         p->o_arg.id.uniquifier = sp->so_seqid.owner_id;
1257         p->o_arg.name = &dentry->d_name;
1258         p->o_arg.server = server;
1259         p->o_arg.bitmask = nfs4_bitmask(server, label);
1260         p->o_arg.open_bitmap = &nfs4_fattr_bitmap[0];
1261         p->o_arg.label = nfs4_label_copy(p->a_label, label);
1262         switch (p->o_arg.claim) {
1263         case NFS4_OPEN_CLAIM_NULL:
1264         case NFS4_OPEN_CLAIM_DELEGATE_CUR:
1265         case NFS4_OPEN_CLAIM_DELEGATE_PREV:
1266                 p->o_arg.fh = NFS_FH(dir);
1267                 break;
1268         case NFS4_OPEN_CLAIM_PREVIOUS:
1269         case NFS4_OPEN_CLAIM_FH:
1270         case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
1271         case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
1272                 p->o_arg.fh = NFS_FH(d_inode(dentry));
1273         }
1274         if (attrs != NULL && attrs->ia_valid != 0) {
1275                 __u32 verf[2];
1276
1277                 p->o_arg.u.attrs = &p->attrs;
1278                 memcpy(&p->attrs, attrs, sizeof(p->attrs));
1279
1280                 verf[0] = jiffies;
1281                 verf[1] = current->pid;
1282                 memcpy(p->o_arg.u.verifier.data, verf,
1283                                 sizeof(p->o_arg.u.verifier.data));
1284         }
1285         p->c_arg.fh = &p->o_res.fh;
1286         p->c_arg.stateid = &p->o_res.stateid;
1287         p->c_arg.seqid = p->o_arg.seqid;
1288         nfs4_init_opendata_res(p);
1289         kref_init(&p->kref);
1290         return p;
1291
1292 err_free_label:
1293         nfs4_label_free(p->a_label);
1294 err_free_f:
1295         nfs4_label_free(p->f_label);
1296 err_free_p:
1297         kfree(p);
1298 err:
1299         dput(parent);
1300         return NULL;
1301 }
1302
1303 static void nfs4_opendata_free(struct kref *kref)
1304 {
1305         struct nfs4_opendata *p = container_of(kref,
1306                         struct nfs4_opendata, kref);
1307         struct super_block *sb = p->dentry->d_sb;
1308
1309         nfs_free_seqid(p->o_arg.seqid);
1310         nfs4_sequence_free_slot(&p->o_res.seq_res);
1311         if (p->state != NULL)
1312                 nfs4_put_open_state(p->state);
1313         nfs4_put_state_owner(p->owner);
1314
1315         nfs4_label_free(p->a_label);
1316         nfs4_label_free(p->f_label);
1317
1318         dput(p->dir);
1319         dput(p->dentry);
1320         nfs_sb_deactive(sb);
1321         nfs_fattr_free_names(&p->f_attr);
1322         kfree(p->f_attr.mdsthreshold);
1323         kfree(p);
1324 }
1325
1326 static void nfs4_opendata_put(struct nfs4_opendata *p)
1327 {
1328         if (p != NULL)
1329                 kref_put(&p->kref, nfs4_opendata_free);
1330 }
1331
1332 static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task)
1333 {
1334         int ret;
1335
1336         ret = rpc_wait_for_completion_task(task);
1337         return ret;
1338 }
1339
1340 static bool nfs4_mode_match_open_stateid(struct nfs4_state *state,
1341                 fmode_t fmode)
1342 {
1343         switch(fmode & (FMODE_READ|FMODE_WRITE)) {
1344         case FMODE_READ|FMODE_WRITE:
1345                 return state->n_rdwr != 0;
1346         case FMODE_WRITE:
1347                 return state->n_wronly != 0;
1348         case FMODE_READ:
1349                 return state->n_rdonly != 0;
1350         }
1351         WARN_ON_ONCE(1);
1352         return false;
1353 }
1354
1355 static int can_open_cached(struct nfs4_state *state, fmode_t mode, int open_mode)
1356 {
1357         int ret = 0;
1358
1359         if (open_mode & (O_EXCL|O_TRUNC))
1360                 goto out;
1361         switch (mode & (FMODE_READ|FMODE_WRITE)) {
1362                 case FMODE_READ:
1363                         ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0
1364                                 && state->n_rdonly != 0;
1365                         break;
1366                 case FMODE_WRITE:
1367                         ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0
1368                                 && state->n_wronly != 0;
1369                         break;
1370                 case FMODE_READ|FMODE_WRITE:
1371                         ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0
1372                                 && state->n_rdwr != 0;
1373         }
1374 out:
1375         return ret;
1376 }
1377
1378 static int can_open_delegated(struct nfs_delegation *delegation, fmode_t fmode,
1379                 enum open_claim_type4 claim)
1380 {
1381         if (delegation == NULL)
1382                 return 0;
1383         if ((delegation->type & fmode) != fmode)
1384                 return 0;
1385         if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
1386                 return 0;
1387         switch (claim) {
1388         case NFS4_OPEN_CLAIM_NULL:
1389         case NFS4_OPEN_CLAIM_FH:
1390                 break;
1391         case NFS4_OPEN_CLAIM_PREVIOUS:
1392                 if (!test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags))
1393                         break;
1394         default:
1395                 return 0;
1396         }
1397         nfs_mark_delegation_referenced(delegation);
1398         return 1;
1399 }
1400
1401 static void update_open_stateflags(struct nfs4_state *state, fmode_t fmode)
1402 {
1403         switch (fmode) {
1404                 case FMODE_WRITE:
1405                         state->n_wronly++;
1406                         break;
1407                 case FMODE_READ:
1408                         state->n_rdonly++;
1409                         break;
1410                 case FMODE_READ|FMODE_WRITE:
1411                         state->n_rdwr++;
1412         }
1413         nfs4_state_set_mode_locked(state, state->state | fmode);
1414 }
1415
1416 #ifdef CONFIG_NFS_V4_1
1417 static bool nfs_open_stateid_recover_openmode(struct nfs4_state *state)
1418 {
1419         if (state->n_rdonly && !test_bit(NFS_O_RDONLY_STATE, &state->flags))
1420                 return true;
1421         if (state->n_wronly && !test_bit(NFS_O_WRONLY_STATE, &state->flags))
1422                 return true;
1423         if (state->n_rdwr && !test_bit(NFS_O_RDWR_STATE, &state->flags))
1424                 return true;
1425         return false;
1426 }
1427 #endif /* CONFIG_NFS_V4_1 */
1428
1429 static void nfs_test_and_clear_all_open_stateid(struct nfs4_state *state)
1430 {
1431         struct nfs_client *clp = state->owner->so_server->nfs_client;
1432         bool need_recover = false;
1433
1434         if (test_and_clear_bit(NFS_O_RDONLY_STATE, &state->flags) && state->n_rdonly)
1435                 need_recover = true;
1436         if (test_and_clear_bit(NFS_O_WRONLY_STATE, &state->flags) && state->n_wronly)
1437                 need_recover = true;
1438         if (test_and_clear_bit(NFS_O_RDWR_STATE, &state->flags) && state->n_rdwr)
1439                 need_recover = true;
1440         if (need_recover)
1441                 nfs4_state_mark_reclaim_nograce(clp, state);
1442 }
1443
1444 static bool nfs_need_update_open_stateid(struct nfs4_state *state,
1445                 const nfs4_stateid *stateid, nfs4_stateid *freeme)
1446 {
1447         if (test_and_set_bit(NFS_OPEN_STATE, &state->flags) == 0)
1448                 return true;
1449         if (!nfs4_stateid_match_other(stateid, &state->open_stateid)) {
1450                 nfs4_stateid_copy(freeme, &state->open_stateid);
1451                 nfs_test_and_clear_all_open_stateid(state);
1452                 return true;
1453         }
1454         if (nfs4_stateid_is_newer(stateid, &state->open_stateid))
1455                 return true;
1456         return false;
1457 }
1458
1459 static void nfs_resync_open_stateid_locked(struct nfs4_state *state)
1460 {
1461         if (!(state->n_wronly || state->n_rdonly || state->n_rdwr))
1462                 return;
1463         if (state->n_wronly)
1464                 set_bit(NFS_O_WRONLY_STATE, &state->flags);
1465         if (state->n_rdonly)
1466                 set_bit(NFS_O_RDONLY_STATE, &state->flags);
1467         if (state->n_rdwr)
1468                 set_bit(NFS_O_RDWR_STATE, &state->flags);
1469         set_bit(NFS_OPEN_STATE, &state->flags);
1470 }
1471
1472 static void nfs_clear_open_stateid_locked(struct nfs4_state *state,
1473                 nfs4_stateid *stateid, fmode_t fmode)
1474 {
1475         clear_bit(NFS_O_RDWR_STATE, &state->flags);
1476         switch (fmode & (FMODE_READ|FMODE_WRITE)) {
1477         case FMODE_WRITE:
1478                 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1479                 break;
1480         case FMODE_READ:
1481                 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1482                 break;
1483         case 0:
1484                 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1485                 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1486                 clear_bit(NFS_OPEN_STATE, &state->flags);
1487         }
1488         if (stateid == NULL)
1489                 return;
1490         /* Handle OPEN+OPEN_DOWNGRADE races */
1491         if (nfs4_stateid_match_other(stateid, &state->open_stateid) &&
1492             !nfs4_stateid_is_newer(stateid, &state->open_stateid)) {
1493                 nfs_resync_open_stateid_locked(state);
1494                 return;
1495         }
1496         if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
1497                 nfs4_stateid_copy(&state->stateid, stateid);
1498         nfs4_stateid_copy(&state->open_stateid, stateid);
1499 }
1500
1501 static void nfs_clear_open_stateid(struct nfs4_state *state,
1502         nfs4_stateid *arg_stateid,
1503         nfs4_stateid *stateid, fmode_t fmode)
1504 {
1505         write_seqlock(&state->seqlock);
1506         /* Ignore, if the CLOSE argment doesn't match the current stateid */
1507         if (nfs4_state_match_open_stateid_other(state, arg_stateid))
1508                 nfs_clear_open_stateid_locked(state, stateid, fmode);
1509         write_sequnlock(&state->seqlock);
1510         if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags))
1511                 nfs4_schedule_state_manager(state->owner->so_server->nfs_client);
1512 }
1513
1514 static void nfs_set_open_stateid_locked(struct nfs4_state *state,
1515                 const nfs4_stateid *stateid, fmode_t fmode,
1516                 nfs4_stateid *freeme)
1517 {
1518         switch (fmode) {
1519                 case FMODE_READ:
1520                         set_bit(NFS_O_RDONLY_STATE, &state->flags);
1521                         break;
1522                 case FMODE_WRITE:
1523                         set_bit(NFS_O_WRONLY_STATE, &state->flags);
1524                         break;
1525                 case FMODE_READ|FMODE_WRITE:
1526                         set_bit(NFS_O_RDWR_STATE, &state->flags);
1527         }
1528         if (!nfs_need_update_open_stateid(state, stateid, freeme))
1529                 return;
1530         if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
1531                 nfs4_stateid_copy(&state->stateid, stateid);
1532         nfs4_stateid_copy(&state->open_stateid, stateid);
1533 }
1534
1535 static void __update_open_stateid(struct nfs4_state *state,
1536                 const nfs4_stateid *open_stateid,
1537                 const nfs4_stateid *deleg_stateid,
1538                 fmode_t fmode,
1539                 nfs4_stateid *freeme)
1540 {
1541         /*
1542          * Protect the call to nfs4_state_set_mode_locked and
1543          * serialise the stateid update
1544          */
1545         spin_lock(&state->owner->so_lock);
1546         write_seqlock(&state->seqlock);
1547         if (deleg_stateid != NULL) {
1548                 nfs4_stateid_copy(&state->stateid, deleg_stateid);
1549                 set_bit(NFS_DELEGATED_STATE, &state->flags);
1550         }
1551         if (open_stateid != NULL)
1552                 nfs_set_open_stateid_locked(state, open_stateid, fmode, freeme);
1553         write_sequnlock(&state->seqlock);
1554         update_open_stateflags(state, fmode);
1555         spin_unlock(&state->owner->so_lock);
1556 }
1557
1558 static int update_open_stateid(struct nfs4_state *state,
1559                 const nfs4_stateid *open_stateid,
1560                 const nfs4_stateid *delegation,
1561                 fmode_t fmode)
1562 {
1563         struct nfs_server *server = NFS_SERVER(state->inode);
1564         struct nfs_client *clp = server->nfs_client;
1565         struct nfs_inode *nfsi = NFS_I(state->inode);
1566         struct nfs_delegation *deleg_cur;
1567         nfs4_stateid freeme = { };
1568         int ret = 0;
1569
1570         fmode &= (FMODE_READ|FMODE_WRITE);
1571
1572         rcu_read_lock();
1573         deleg_cur = rcu_dereference(nfsi->delegation);
1574         if (deleg_cur == NULL)
1575                 goto no_delegation;
1576
1577         spin_lock(&deleg_cur->lock);
1578         if (rcu_dereference(nfsi->delegation) != deleg_cur ||
1579            test_bit(NFS_DELEGATION_RETURNING, &deleg_cur->flags) ||
1580             (deleg_cur->type & fmode) != fmode)
1581                 goto no_delegation_unlock;
1582
1583         if (delegation == NULL)
1584                 delegation = &deleg_cur->stateid;
1585         else if (!nfs4_stateid_match(&deleg_cur->stateid, delegation))
1586                 goto no_delegation_unlock;
1587
1588         nfs_mark_delegation_referenced(deleg_cur);
1589         __update_open_stateid(state, open_stateid, &deleg_cur->stateid,
1590                         fmode, &freeme);
1591         ret = 1;
1592 no_delegation_unlock:
1593         spin_unlock(&deleg_cur->lock);
1594 no_delegation:
1595         rcu_read_unlock();
1596
1597         if (!ret && open_stateid != NULL) {
1598                 __update_open_stateid(state, open_stateid, NULL, fmode, &freeme);
1599                 ret = 1;
1600         }
1601         if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags))
1602                 nfs4_schedule_state_manager(clp);
1603         if (freeme.type != 0)
1604                 nfs4_test_and_free_stateid(server, &freeme,
1605                                 state->owner->so_cred);
1606
1607         return ret;
1608 }
1609
1610 static bool nfs4_update_lock_stateid(struct nfs4_lock_state *lsp,
1611                 const nfs4_stateid *stateid)
1612 {
1613         struct nfs4_state *state = lsp->ls_state;
1614         bool ret = false;
1615
1616         spin_lock(&state->state_lock);
1617         if (!nfs4_stateid_match_other(stateid, &lsp->ls_stateid))
1618                 goto out_noupdate;
1619         if (!nfs4_stateid_is_newer(stateid, &lsp->ls_stateid))
1620                 goto out_noupdate;
1621         nfs4_stateid_copy(&lsp->ls_stateid, stateid);
1622         ret = true;
1623 out_noupdate:
1624         spin_unlock(&state->state_lock);
1625         return ret;
1626 }
1627
1628 static void nfs4_return_incompatible_delegation(struct inode *inode, fmode_t fmode)
1629 {
1630         struct nfs_delegation *delegation;
1631
1632         rcu_read_lock();
1633         delegation = rcu_dereference(NFS_I(inode)->delegation);
1634         if (delegation == NULL || (delegation->type & fmode) == fmode) {
1635                 rcu_read_unlock();
1636                 return;
1637         }
1638         rcu_read_unlock();
1639         nfs4_inode_return_delegation(inode);
1640 }
1641
1642 static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata)
1643 {
1644         struct nfs4_state *state = opendata->state;
1645         struct nfs_inode *nfsi = NFS_I(state->inode);
1646         struct nfs_delegation *delegation;
1647         int open_mode = opendata->o_arg.open_flags;
1648         fmode_t fmode = opendata->o_arg.fmode;
1649         enum open_claim_type4 claim = opendata->o_arg.claim;
1650         nfs4_stateid stateid;
1651         int ret = -EAGAIN;
1652
1653         for (;;) {
1654                 spin_lock(&state->owner->so_lock);
1655                 if (can_open_cached(state, fmode, open_mode)) {
1656                         update_open_stateflags(state, fmode);
1657                         spin_unlock(&state->owner->so_lock);
1658                         goto out_return_state;
1659                 }
1660                 spin_unlock(&state->owner->so_lock);
1661                 rcu_read_lock();
1662                 delegation = rcu_dereference(nfsi->delegation);
1663                 if (!can_open_delegated(delegation, fmode, claim)) {
1664                         rcu_read_unlock();
1665                         break;
1666                 }
1667                 /* Save the delegation */
1668                 nfs4_stateid_copy(&stateid, &delegation->stateid);
1669                 rcu_read_unlock();
1670                 nfs_release_seqid(opendata->o_arg.seqid);
1671                 if (!opendata->is_recover) {
1672                         ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode);
1673                         if (ret != 0)
1674                                 goto out;
1675                 }
1676                 ret = -EAGAIN;
1677
1678                 /* Try to update the stateid using the delegation */
1679                 if (update_open_stateid(state, NULL, &stateid, fmode))
1680                         goto out_return_state;
1681         }
1682 out:
1683         return ERR_PTR(ret);
1684 out_return_state:
1685         atomic_inc(&state->count);
1686         return state;
1687 }
1688
1689 static void
1690 nfs4_opendata_check_deleg(struct nfs4_opendata *data, struct nfs4_state *state)
1691 {
1692         struct nfs_client *clp = NFS_SERVER(state->inode)->nfs_client;
1693         struct nfs_delegation *delegation;
1694         int delegation_flags = 0;
1695
1696         rcu_read_lock();
1697         delegation = rcu_dereference(NFS_I(state->inode)->delegation);
1698         if (delegation)
1699                 delegation_flags = delegation->flags;
1700         rcu_read_unlock();
1701         switch (data->o_arg.claim) {
1702         default:
1703                 break;
1704         case NFS4_OPEN_CLAIM_DELEGATE_CUR:
1705         case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
1706                 pr_err_ratelimited("NFS: Broken NFSv4 server %s is "
1707                                    "returning a delegation for "
1708                                    "OPEN(CLAIM_DELEGATE_CUR)\n",
1709                                    clp->cl_hostname);
1710                 return;
1711         }
1712         if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0)
1713                 nfs_inode_set_delegation(state->inode,
1714                                          data->owner->so_cred,
1715                                          &data->o_res);
1716         else
1717                 nfs_inode_reclaim_delegation(state->inode,
1718                                              data->owner->so_cred,
1719                                              &data->o_res);
1720 }
1721
1722 /*
1723  * Check the inode attributes against the CLAIM_PREVIOUS returned attributes
1724  * and update the nfs4_state.
1725  */
1726 static struct nfs4_state *
1727 _nfs4_opendata_reclaim_to_nfs4_state(struct nfs4_opendata *data)
1728 {
1729         struct inode *inode = data->state->inode;
1730         struct nfs4_state *state = data->state;
1731         int ret;
1732
1733         if (!data->rpc_done) {
1734                 if (data->rpc_status) {
1735                         ret = data->rpc_status;
1736                         goto err;
1737                 }
1738                 /* cached opens have already been processed */
1739                 goto update;
1740         }
1741
1742         ret = nfs_refresh_inode(inode, &data->f_attr);
1743         if (ret)
1744                 goto err;
1745
1746         if (data->o_res.delegation_type != 0)
1747                 nfs4_opendata_check_deleg(data, state);
1748 update:
1749         update_open_stateid(state, &data->o_res.stateid, NULL,
1750                             data->o_arg.fmode);
1751         atomic_inc(&state->count);
1752
1753         return state;
1754 err:
1755         return ERR_PTR(ret);
1756
1757 }
1758
1759 static struct nfs4_state *
1760 _nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
1761 {
1762         struct inode *inode;
1763         struct nfs4_state *state = NULL;
1764         int ret;
1765
1766         if (!data->rpc_done) {
1767                 state = nfs4_try_open_cached(data);
1768                 trace_nfs4_cached_open(data->state);
1769                 goto out;
1770         }
1771
1772         ret = -EAGAIN;
1773         if (!(data->f_attr.valid & NFS_ATTR_FATTR))
1774                 goto err;
1775         inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr, data->f_label);
1776         ret = PTR_ERR(inode);
1777         if (IS_ERR(inode))
1778                 goto err;
1779         ret = -ENOMEM;
1780         state = nfs4_get_open_state(inode, data->owner);
1781         if (state == NULL)
1782                 goto err_put_inode;
1783         if (data->o_res.delegation_type != 0)
1784                 nfs4_opendata_check_deleg(data, state);
1785         update_open_stateid(state, &data->o_res.stateid, NULL,
1786                         data->o_arg.fmode);
1787         iput(inode);
1788 out:
1789         nfs_release_seqid(data->o_arg.seqid);
1790         return state;
1791 err_put_inode:
1792         iput(inode);
1793 err:
1794         return ERR_PTR(ret);
1795 }
1796
1797 static struct nfs4_state *
1798 nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
1799 {
1800         struct nfs4_state *ret;
1801
1802         if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS)
1803                 ret =_nfs4_opendata_reclaim_to_nfs4_state(data);
1804         else
1805                 ret = _nfs4_opendata_to_nfs4_state(data);
1806         nfs4_sequence_free_slot(&data->o_res.seq_res);
1807         return ret;
1808 }
1809
1810 static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *state)
1811 {
1812         struct nfs_inode *nfsi = NFS_I(state->inode);
1813         struct nfs_open_context *ctx;
1814
1815         spin_lock(&state->inode->i_lock);
1816         list_for_each_entry(ctx, &nfsi->open_files, list) {
1817                 if (ctx->state != state)
1818                         continue;
1819                 get_nfs_open_context(ctx);
1820                 spin_unlock(&state->inode->i_lock);
1821                 return ctx;
1822         }
1823         spin_unlock(&state->inode->i_lock);
1824         return ERR_PTR(-ENOENT);
1825 }
1826
1827 static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context *ctx,
1828                 struct nfs4_state *state, enum open_claim_type4 claim)
1829 {
1830         struct nfs4_opendata *opendata;
1831
1832         opendata = nfs4_opendata_alloc(ctx->dentry, state->owner, 0, 0,
1833                         NULL, NULL, claim, GFP_NOFS);
1834         if (opendata == NULL)
1835                 return ERR_PTR(-ENOMEM);
1836         opendata->state = state;
1837         atomic_inc(&state->count);
1838         return opendata;
1839 }
1840
1841 static int nfs4_open_recover_helper(struct nfs4_opendata *opendata,
1842                 fmode_t fmode)
1843 {
1844         struct nfs4_state *newstate;
1845         int ret;
1846
1847         if (!nfs4_mode_match_open_stateid(opendata->state, fmode))
1848                 return 0;
1849         opendata->o_arg.open_flags = 0;
1850         opendata->o_arg.fmode = fmode;
1851         opendata->o_arg.share_access = nfs4_map_atomic_open_share(
1852                         NFS_SB(opendata->dentry->d_sb),
1853                         fmode, 0);
1854         memset(&opendata->o_res, 0, sizeof(opendata->o_res));
1855         memset(&opendata->c_res, 0, sizeof(opendata->c_res));
1856         nfs4_init_opendata_res(opendata);
1857         ret = _nfs4_recover_proc_open(opendata);
1858         if (ret != 0)
1859                 return ret;
1860         newstate = nfs4_opendata_to_nfs4_state(opendata);
1861         if (IS_ERR(newstate))
1862                 return PTR_ERR(newstate);
1863         if (newstate != opendata->state)
1864                 ret = -ESTALE;
1865         nfs4_close_state(newstate, fmode);
1866         return ret;
1867 }
1868
1869 static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *state)
1870 {
1871         int ret;
1872
1873         /* Don't trigger recovery in nfs_test_and_clear_all_open_stateid */
1874         clear_bit(NFS_O_RDWR_STATE, &state->flags);
1875         clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1876         clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1877         /* memory barrier prior to reading state->n_* */
1878         clear_bit(NFS_DELEGATED_STATE, &state->flags);
1879         clear_bit(NFS_OPEN_STATE, &state->flags);
1880         smp_rmb();
1881         ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE);
1882         if (ret != 0)
1883                 return ret;
1884         ret = nfs4_open_recover_helper(opendata, FMODE_WRITE);
1885         if (ret != 0)
1886                 return ret;
1887         ret = nfs4_open_recover_helper(opendata, FMODE_READ);
1888         if (ret != 0)
1889                 return ret;
1890         /*
1891          * We may have performed cached opens for all three recoveries.
1892          * Check if we need to update the current stateid.
1893          */
1894         if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 &&
1895             !nfs4_stateid_match(&state->stateid, &state->open_stateid)) {
1896                 write_seqlock(&state->seqlock);
1897                 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
1898                         nfs4_stateid_copy(&state->stateid, &state->open_stateid);
1899                 write_sequnlock(&state->seqlock);
1900         }
1901         return 0;
1902 }
1903
1904 /*
1905  * OPEN_RECLAIM:
1906  *      reclaim state on the server after a reboot.
1907  */
1908 static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
1909 {
1910         struct nfs_delegation *delegation;
1911         struct nfs4_opendata *opendata;
1912         fmode_t delegation_type = 0;
1913         int status;
1914
1915         opendata = nfs4_open_recoverdata_alloc(ctx, state,
1916                         NFS4_OPEN_CLAIM_PREVIOUS);
1917         if (IS_ERR(opendata))
1918                 return PTR_ERR(opendata);
1919         rcu_read_lock();
1920         delegation = rcu_dereference(NFS_I(state->inode)->delegation);
1921         if (delegation != NULL && test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) != 0)
1922                 delegation_type = delegation->type;
1923         rcu_read_unlock();
1924         opendata->o_arg.u.delegation_type = delegation_type;
1925         status = nfs4_open_recover(opendata, state);
1926         nfs4_opendata_put(opendata);
1927         return status;
1928 }
1929
1930 static int nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
1931 {
1932         struct nfs_server *server = NFS_SERVER(state->inode);
1933         struct nfs4_exception exception = { };
1934         int err;
1935         do {
1936                 err = _nfs4_do_open_reclaim(ctx, state);
1937                 trace_nfs4_open_reclaim(ctx, 0, err);
1938                 if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
1939                         continue;
1940                 if (err != -NFS4ERR_DELAY)
1941                         break;
1942                 nfs4_handle_exception(server, err, &exception);
1943         } while (exception.retry);
1944         return err;
1945 }
1946
1947 static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state)
1948 {
1949         struct nfs_open_context *ctx;
1950         int ret;
1951
1952         ctx = nfs4_state_find_open_context(state);
1953         if (IS_ERR(ctx))
1954                 return -EAGAIN;
1955         ret = nfs4_do_open_reclaim(ctx, state);
1956         put_nfs_open_context(ctx);
1957         return ret;
1958 }
1959
1960 static int nfs4_handle_delegation_recall_error(struct nfs_server *server, struct nfs4_state *state, const nfs4_stateid *stateid, int err)
1961 {
1962         switch (err) {
1963                 default:
1964                         printk(KERN_ERR "NFS: %s: unhandled error "
1965                                         "%d.\n", __func__, err);
1966                 case 0:
1967                 case -ENOENT:
1968                 case -EAGAIN:
1969                 case -ESTALE:
1970                         break;
1971                 case -NFS4ERR_BADSESSION:
1972                 case -NFS4ERR_BADSLOT:
1973                 case -NFS4ERR_BAD_HIGH_SLOT:
1974                 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1975                 case -NFS4ERR_DEADSESSION:
1976                         set_bit(NFS_DELEGATED_STATE, &state->flags);
1977                         nfs4_schedule_session_recovery(server->nfs_client->cl_session, err);
1978                         return -EAGAIN;
1979                 case -NFS4ERR_STALE_CLIENTID:
1980                 case -NFS4ERR_STALE_STATEID:
1981                         set_bit(NFS_DELEGATED_STATE, &state->flags);
1982                         /* Don't recall a delegation if it was lost */
1983                         nfs4_schedule_lease_recovery(server->nfs_client);
1984                         return -EAGAIN;
1985                 case -NFS4ERR_MOVED:
1986                         nfs4_schedule_migration_recovery(server);
1987                         return -EAGAIN;
1988                 case -NFS4ERR_LEASE_MOVED:
1989                         nfs4_schedule_lease_moved_recovery(server->nfs_client);
1990                         return -EAGAIN;
1991                 case -NFS4ERR_DELEG_REVOKED:
1992                 case -NFS4ERR_ADMIN_REVOKED:
1993                 case -NFS4ERR_EXPIRED:
1994                 case -NFS4ERR_BAD_STATEID:
1995                 case -NFS4ERR_OPENMODE:
1996                         nfs_inode_find_state_and_recover(state->inode,
1997                                         stateid);
1998                         nfs4_schedule_stateid_recovery(server, state);
1999                         return -EAGAIN;
2000                 case -NFS4ERR_DELAY:
2001                 case -NFS4ERR_GRACE:
2002                         set_bit(NFS_DELEGATED_STATE, &state->flags);
2003                         ssleep(1);
2004                         return -EAGAIN;
2005                 case -ENOMEM:
2006                 case -NFS4ERR_DENIED:
2007                         /* kill_proc(fl->fl_pid, SIGLOST, 1); */
2008                         return 0;
2009         }
2010         return err;
2011 }
2012
2013 int nfs4_open_delegation_recall(struct nfs_open_context *ctx,
2014                 struct nfs4_state *state, const nfs4_stateid *stateid,
2015                 fmode_t type)
2016 {
2017         struct nfs_server *server = NFS_SERVER(state->inode);
2018         struct nfs4_opendata *opendata;
2019         int err = 0;
2020
2021         opendata = nfs4_open_recoverdata_alloc(ctx, state,
2022                         NFS4_OPEN_CLAIM_DELEG_CUR_FH);
2023         if (IS_ERR(opendata))
2024                 return PTR_ERR(opendata);
2025         nfs4_stateid_copy(&opendata->o_arg.u.delegation, stateid);
2026         write_seqlock(&state->seqlock);
2027         nfs4_stateid_copy(&state->stateid, &state->open_stateid);
2028         write_sequnlock(&state->seqlock);
2029         clear_bit(NFS_DELEGATED_STATE, &state->flags);
2030         switch (type & (FMODE_READ|FMODE_WRITE)) {
2031         case FMODE_READ|FMODE_WRITE:
2032         case FMODE_WRITE:
2033                 err = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE);
2034                 if (err)
2035                         break;
2036                 err = nfs4_open_recover_helper(opendata, FMODE_WRITE);
2037                 if (err)
2038                         break;
2039         case FMODE_READ:
2040                 err = nfs4_open_recover_helper(opendata, FMODE_READ);
2041         }
2042         nfs4_opendata_put(opendata);
2043         return nfs4_handle_delegation_recall_error(server, state, stateid, err);
2044 }
2045
2046 static void nfs4_open_confirm_prepare(struct rpc_task *task, void *calldata)
2047 {
2048         struct nfs4_opendata *data = calldata;
2049
2050         nfs40_setup_sequence(data->o_arg.server->nfs_client->cl_slot_tbl,
2051                              &data->c_arg.seq_args, &data->c_res.seq_res, task);
2052 }
2053
2054 static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata)
2055 {
2056         struct nfs4_opendata *data = calldata;
2057
2058         nfs40_sequence_done(task, &data->c_res.seq_res);
2059
2060         data->rpc_status = task->tk_status;
2061         if (data->rpc_status == 0) {
2062                 nfs4_stateid_copy(&data->o_res.stateid, &data->c_res.stateid);
2063                 nfs_confirm_seqid(&data->owner->so_seqid, 0);
2064                 renew_lease(data->o_res.server, data->timestamp);
2065                 data->rpc_done = 1;
2066         }
2067 }
2068
2069 static void nfs4_open_confirm_release(void *calldata)
2070 {
2071         struct nfs4_opendata *data = calldata;
2072         struct nfs4_state *state = NULL;
2073
2074         /* If this request hasn't been cancelled, do nothing */
2075         if (data->cancelled == 0)
2076                 goto out_free;
2077         /* In case of error, no cleanup! */
2078         if (!data->rpc_done)
2079                 goto out_free;
2080         state = nfs4_opendata_to_nfs4_state(data);
2081         if (!IS_ERR(state))
2082                 nfs4_close_state(state, data->o_arg.fmode);
2083 out_free:
2084         nfs4_opendata_put(data);
2085 }
2086
2087 static const struct rpc_call_ops nfs4_open_confirm_ops = {
2088         .rpc_call_prepare = nfs4_open_confirm_prepare,
2089         .rpc_call_done = nfs4_open_confirm_done,
2090         .rpc_release = nfs4_open_confirm_release,
2091 };
2092
2093 /*
2094  * Note: On error, nfs4_proc_open_confirm will free the struct nfs4_opendata
2095  */
2096 static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)
2097 {
2098         struct nfs_server *server = NFS_SERVER(d_inode(data->dir));
2099         struct rpc_task *task;
2100         struct  rpc_message msg = {
2101                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM],
2102                 .rpc_argp = &data->c_arg,
2103                 .rpc_resp = &data->c_res,
2104                 .rpc_cred = data->owner->so_cred,
2105         };
2106         struct rpc_task_setup task_setup_data = {
2107                 .rpc_client = server->client,
2108                 .rpc_message = &msg,
2109                 .callback_ops = &nfs4_open_confirm_ops,
2110                 .callback_data = data,
2111                 .workqueue = nfsiod_workqueue,
2112                 .flags = RPC_TASK_ASYNC,
2113         };
2114         int status;
2115
2116         nfs4_init_sequence(&data->c_arg.seq_args, &data->c_res.seq_res, 1);
2117         kref_get(&data->kref);
2118         data->rpc_done = 0;
2119         data->rpc_status = 0;
2120         data->timestamp = jiffies;
2121         if (data->is_recover)
2122                 nfs4_set_sequence_privileged(&data->c_arg.seq_args);
2123         task = rpc_run_task(&task_setup_data);
2124         if (IS_ERR(task))
2125                 return PTR_ERR(task);
2126         status = nfs4_wait_for_completion_rpc_task(task);
2127         if (status != 0) {
2128                 data->cancelled = 1;
2129                 smp_wmb();
2130         } else
2131                 status = data->rpc_status;
2132         rpc_put_task(task);
2133         return status;
2134 }
2135
2136 static void nfs4_open_prepare(struct rpc_task *task, void *calldata)
2137 {
2138         struct nfs4_opendata *data = calldata;
2139         struct nfs4_state_owner *sp = data->owner;
2140         struct nfs_client *clp = sp->so_server->nfs_client;
2141         enum open_claim_type4 claim = data->o_arg.claim;
2142
2143         if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0)
2144                 goto out_wait;
2145         /*
2146          * Check if we still need to send an OPEN call, or if we can use
2147          * a delegation instead.
2148          */
2149         if (data->state != NULL) {
2150                 struct nfs_delegation *delegation;
2151
2152                 if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags))
2153                         goto out_no_action;
2154                 rcu_read_lock();
2155                 delegation = rcu_dereference(NFS_I(data->state->inode)->delegation);
2156                 if (can_open_delegated(delegation, data->o_arg.fmode, claim))
2157                         goto unlock_no_action;
2158                 rcu_read_unlock();
2159         }
2160         /* Update client id. */
2161         data->o_arg.clientid = clp->cl_clientid;
2162         switch (claim) {
2163         default:
2164                 break;
2165         case NFS4_OPEN_CLAIM_PREVIOUS:
2166         case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
2167         case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
2168                 data->o_arg.open_bitmap = &nfs4_open_noattr_bitmap[0];
2169         case NFS4_OPEN_CLAIM_FH:
2170                 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR];
2171                 nfs_copy_fh(&data->o_res.fh, data->o_arg.fh);
2172         }
2173         data->timestamp = jiffies;
2174         if (nfs4_setup_sequence(data->o_arg.server,
2175                                 &data->o_arg.seq_args,
2176                                 &data->o_res.seq_res,
2177                                 task) != 0)
2178                 nfs_release_seqid(data->o_arg.seqid);
2179
2180         /* Set the create mode (note dependency on the session type) */
2181         data->o_arg.createmode = NFS4_CREATE_UNCHECKED;
2182         if (data->o_arg.open_flags & O_EXCL) {
2183                 data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE;
2184                 if (nfs4_has_persistent_session(clp))
2185                         data->o_arg.createmode = NFS4_CREATE_GUARDED;
2186                 else if (clp->cl_mvops->minor_version > 0)
2187                         data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE4_1;
2188         }
2189         return;
2190 unlock_no_action:
2191         trace_nfs4_cached_open(data->state);
2192         rcu_read_unlock();
2193 out_no_action:
2194         task->tk_action = NULL;
2195 out_wait:
2196         nfs4_sequence_done(task, &data->o_res.seq_res);
2197 }
2198
2199 static void nfs4_open_done(struct rpc_task *task, void *calldata)
2200 {
2201         struct nfs4_opendata *data = calldata;
2202
2203         data->rpc_status = task->tk_status;
2204
2205         if (!nfs4_sequence_process(task, &data->o_res.seq_res))
2206                 return;
2207
2208         if (task->tk_status == 0) {
2209                 if (data->o_res.f_attr->valid & NFS_ATTR_FATTR_TYPE) {
2210                         switch (data->o_res.f_attr->mode & S_IFMT) {
2211                         case S_IFREG:
2212                                 break;
2213                         case S_IFLNK:
2214                                 data->rpc_status = -ELOOP;
2215                                 break;
2216                         case S_IFDIR:
2217                                 data->rpc_status = -EISDIR;
2218                                 break;
2219                         default:
2220                                 data->rpc_status = -ENOTDIR;
2221                         }
2222                 }
2223                 renew_lease(data->o_res.server, data->timestamp);
2224                 if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM))
2225                         nfs_confirm_seqid(&data->owner->so_seqid, 0);
2226         }
2227         data->rpc_done = 1;
2228 }
2229
2230 static void nfs4_open_release(void *calldata)
2231 {
2232         struct nfs4_opendata *data = calldata;
2233         struct nfs4_state *state = NULL;
2234
2235         /* If this request hasn't been cancelled, do nothing */
2236         if (data->cancelled == 0)
2237                 goto out_free;
2238         /* In case of error, no cleanup! */
2239         if (data->rpc_status != 0 || !data->rpc_done)
2240                 goto out_free;
2241         /* In case we need an open_confirm, no cleanup! */
2242         if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)
2243                 goto out_free;
2244         state = nfs4_opendata_to_nfs4_state(data);
2245         if (!IS_ERR(state))
2246                 nfs4_close_state(state, data->o_arg.fmode);
2247 out_free:
2248         nfs4_opendata_put(data);
2249 }
2250
2251 static const struct rpc_call_ops nfs4_open_ops = {
2252         .rpc_call_prepare = nfs4_open_prepare,
2253         .rpc_call_done = nfs4_open_done,
2254         .rpc_release = nfs4_open_release,
2255 };
2256
2257 static int nfs4_run_open_task(struct nfs4_opendata *data, int isrecover)
2258 {
2259         struct inode *dir = d_inode(data->dir);
2260         struct nfs_server *server = NFS_SERVER(dir);
2261         struct nfs_openargs *o_arg = &data->o_arg;
2262         struct nfs_openres *o_res = &data->o_res;
2263         struct rpc_task *task;
2264         struct rpc_message msg = {
2265                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN],
2266                 .rpc_argp = o_arg,
2267                 .rpc_resp = o_res,
2268                 .rpc_cred = data->owner->so_cred,
2269         };
2270         struct rpc_task_setup task_setup_data = {
2271                 .rpc_client = server->client,
2272                 .rpc_message = &msg,
2273                 .callback_ops = &nfs4_open_ops,
2274                 .callback_data = data,
2275                 .workqueue = nfsiod_workqueue,
2276                 .flags = RPC_TASK_ASYNC,
2277         };
2278         int status;
2279
2280         nfs4_init_sequence(&o_arg->seq_args, &o_res->seq_res, 1);
2281         kref_get(&data->kref);
2282         data->rpc_done = 0;
2283         data->rpc_status = 0;
2284         data->cancelled = 0;
2285         data->is_recover = 0;
2286         if (isrecover) {
2287                 nfs4_set_sequence_privileged(&o_arg->seq_args);
2288                 data->is_recover = 1;
2289         }
2290         task = rpc_run_task(&task_setup_data);
2291         if (IS_ERR(task))
2292                 return PTR_ERR(task);
2293         status = nfs4_wait_for_completion_rpc_task(task);
2294         if (status != 0) {
2295                 data->cancelled = 1;
2296                 smp_wmb();
2297         } else
2298                 status = data->rpc_status;
2299         rpc_put_task(task);
2300
2301         return status;
2302 }
2303
2304 static int _nfs4_recover_proc_open(struct nfs4_opendata *data)
2305 {
2306         struct inode *dir = d_inode(data->dir);
2307         struct nfs_openres *o_res = &data->o_res;
2308         int status;
2309
2310         status = nfs4_run_open_task(data, 1);
2311         if (status != 0 || !data->rpc_done)
2312                 return status;
2313
2314         nfs_fattr_map_and_free_names(NFS_SERVER(dir), &data->f_attr);
2315
2316         if (o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
2317                 status = _nfs4_proc_open_confirm(data);
2318                 if (status != 0)
2319                         return status;
2320         }
2321
2322         return status;
2323 }
2324
2325 /*
2326  * Additional permission checks in order to distinguish between an
2327  * open for read, and an open for execute. This works around the
2328  * fact that NFSv4 OPEN treats read and execute permissions as being
2329  * the same.
2330  * Note that in the non-execute case, we want to turn off permission
2331  * checking if we just created a new file (POSIX open() semantics).
2332  */
2333 static int nfs4_opendata_access(struct rpc_cred *cred,
2334                                 struct nfs4_opendata *opendata,
2335                                 struct nfs4_state *state, fmode_t fmode,
2336                                 int openflags)
2337 {
2338         struct nfs_access_entry cache;
2339         u32 mask;
2340
2341         /* access call failed or for some reason the server doesn't
2342          * support any access modes -- defer access call until later */
2343         if (opendata->o_res.access_supported == 0)
2344                 return 0;
2345
2346         mask = 0;
2347         /*
2348          * Use openflags to check for exec, because fmode won't
2349          * always have FMODE_EXEC set when file open for exec.
2350          */
2351         if (openflags & __FMODE_EXEC) {
2352                 /* ONLY check for exec rights */
2353                 mask = MAY_EXEC;
2354         } else if ((fmode & FMODE_READ) && !opendata->file_created)
2355                 mask = MAY_READ;
2356
2357         cache.cred = cred;
2358         cache.jiffies = jiffies;
2359         nfs_access_set_mask(&cache, opendata->o_res.access_result);
2360         nfs_access_add_cache(state->inode, &cache);
2361
2362         if ((mask & ~cache.mask & (MAY_READ | MAY_EXEC)) == 0)
2363                 return 0;
2364
2365         /* even though OPEN succeeded, access is denied. Close the file */
2366         nfs4_close_state(state, fmode);
2367         return -EACCES;
2368 }
2369
2370 /*
2371  * Note: On error, nfs4_proc_open will free the struct nfs4_opendata
2372  */
2373 static int _nfs4_proc_open(struct nfs4_opendata *data)
2374 {
2375         struct inode *dir = d_inode(data->dir);
2376         struct nfs_server *server = NFS_SERVER(dir);
2377         struct nfs_openargs *o_arg = &data->o_arg;
2378         struct nfs_openres *o_res = &data->o_res;
2379         int status;
2380
2381         status = nfs4_run_open_task(data, 0);
2382         if (!data->rpc_done)
2383                 return status;
2384         if (status != 0) {
2385                 if (status == -NFS4ERR_BADNAME &&
2386                                 !(o_arg->open_flags & O_CREAT))
2387                         return -ENOENT;
2388                 return status;
2389         }
2390
2391         nfs_fattr_map_and_free_names(server, &data->f_attr);
2392
2393         if (o_arg->open_flags & O_CREAT) {
2394                 update_changeattr(dir, &o_res->cinfo);
2395                 if (o_arg->open_flags & O_EXCL)
2396                         data->file_created = 1;
2397                 else if (o_res->cinfo.before != o_res->cinfo.after)
2398                         data->file_created = 1;
2399         }
2400         if ((o_res->rflags & NFS4_OPEN_RESULT_LOCKTYPE_POSIX) == 0)
2401                 server->caps &= ~NFS_CAP_POSIX_LOCK;
2402         if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
2403                 status = _nfs4_proc_open_confirm(data);
2404                 if (status != 0)
2405                         return status;
2406         }
2407         if (!(o_res->f_attr->valid & NFS_ATTR_FATTR))
2408                 nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr, o_res->f_label);
2409         return 0;
2410 }
2411
2412 static int nfs4_recover_expired_lease(struct nfs_server *server)
2413 {
2414         return nfs4_client_recover_expired_lease(server->nfs_client);
2415 }
2416
2417 /*
2418  * OPEN_EXPIRED:
2419  *      reclaim state on the server after a network partition.
2420  *      Assumes caller holds the appropriate lock
2421  */
2422 static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
2423 {
2424         struct nfs4_opendata *opendata;
2425         int ret;
2426
2427         opendata = nfs4_open_recoverdata_alloc(ctx, state,
2428                         NFS4_OPEN_CLAIM_FH);
2429         if (IS_ERR(opendata))
2430                 return PTR_ERR(opendata);
2431         ret = nfs4_open_recover(opendata, state);
2432         if (ret == -ESTALE)
2433                 d_drop(ctx->dentry);
2434         nfs4_opendata_put(opendata);
2435         return ret;
2436 }
2437
2438 static int nfs4_do_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
2439 {
2440         struct nfs_server *server = NFS_SERVER(state->inode);
2441         struct nfs4_exception exception = { };
2442         int err;
2443
2444         do {
2445                 err = _nfs4_open_expired(ctx, state);
2446                 trace_nfs4_open_expired(ctx, 0, err);
2447                 if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
2448                         continue;
2449                 switch (err) {
2450                 default:
2451                         goto out;
2452                 case -NFS4ERR_GRACE:
2453                 case -NFS4ERR_DELAY:
2454                         nfs4_handle_exception(server, err, &exception);
2455                         err = 0;
2456                 }
2457         } while (exception.retry);
2458 out:
2459         return err;
2460 }
2461
2462 static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
2463 {
2464         struct nfs_open_context *ctx;
2465         int ret;
2466
2467         ctx = nfs4_state_find_open_context(state);
2468         if (IS_ERR(ctx))
2469                 return -EAGAIN;
2470         ret = nfs4_do_open_expired(ctx, state);
2471         put_nfs_open_context(ctx);
2472         return ret;
2473 }
2474
2475 static void nfs_finish_clear_delegation_stateid(struct nfs4_state *state,
2476                 const nfs4_stateid *stateid)
2477 {
2478         nfs_remove_bad_delegation(state->inode, stateid);
2479         write_seqlock(&state->seqlock);
2480         nfs4_stateid_copy(&state->stateid, &state->open_stateid);
2481         write_sequnlock(&state->seqlock);
2482         clear_bit(NFS_DELEGATED_STATE, &state->flags);
2483 }
2484
2485 static void nfs40_clear_delegation_stateid(struct nfs4_state *state)
2486 {
2487         if (rcu_access_pointer(NFS_I(state->inode)->delegation) != NULL)
2488                 nfs_finish_clear_delegation_stateid(state, NULL);
2489 }
2490
2491 static int nfs40_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
2492 {
2493         /* NFSv4.0 doesn't allow for delegation recovery on open expire */
2494         nfs40_clear_delegation_stateid(state);
2495         return nfs4_open_expired(sp, state);
2496 }
2497
2498 static int nfs40_test_and_free_expired_stateid(struct nfs_server *server,
2499                 nfs4_stateid *stateid,
2500                 struct rpc_cred *cred)
2501 {
2502         return -NFS4ERR_BAD_STATEID;
2503 }
2504
2505 #if defined(CONFIG_NFS_V4_1)
2506 static int nfs41_test_and_free_expired_stateid(struct nfs_server *server,
2507                 nfs4_stateid *stateid,
2508                 struct rpc_cred *cred)
2509 {
2510         int status;
2511
2512         switch (stateid->type) {
2513         default:
2514                 break;
2515         case NFS4_INVALID_STATEID_TYPE:
2516         case NFS4_SPECIAL_STATEID_TYPE:
2517                 return -NFS4ERR_BAD_STATEID;
2518         case NFS4_REVOKED_STATEID_TYPE:
2519                 goto out_free;
2520         }
2521
2522         status = nfs41_test_stateid(server, stateid, cred);
2523         switch (status) {
2524         case -NFS4ERR_EXPIRED:
2525         case -NFS4ERR_ADMIN_REVOKED:
2526         case -NFS4ERR_DELEG_REVOKED:
2527                 break;
2528         default:
2529                 return status;
2530         }
2531 out_free:
2532         /* Ack the revoked state to the server */
2533         nfs41_free_stateid(server, stateid, cred, true);
2534         return -NFS4ERR_EXPIRED;
2535 }
2536
2537 static void nfs41_check_delegation_stateid(struct nfs4_state *state)
2538 {
2539         struct nfs_server *server = NFS_SERVER(state->inode);
2540         nfs4_stateid stateid;
2541         struct nfs_delegation *delegation;
2542         struct rpc_cred *cred;
2543         int status;
2544
2545         /* Get the delegation credential for use by test/free_stateid */
2546         rcu_read_lock();
2547         delegation = rcu_dereference(NFS_I(state->inode)->delegation);
2548         if (delegation == NULL) {
2549                 rcu_read_unlock();
2550                 return;
2551         }
2552
2553         nfs4_stateid_copy(&stateid, &delegation->stateid);
2554         if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
2555                 rcu_read_unlock();
2556                 nfs_finish_clear_delegation_stateid(state, &stateid);
2557                 return;
2558         }
2559
2560         if (!test_and_clear_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags)) {
2561                 rcu_read_unlock();
2562                 return;
2563         }
2564
2565         cred = get_rpccred(delegation->cred);
2566         rcu_read_unlock();
2567         status = nfs41_test_and_free_expired_stateid(server, &stateid, cred);
2568         trace_nfs4_test_delegation_stateid(state, NULL, status);
2569         if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID)
2570                 nfs_finish_clear_delegation_stateid(state, &stateid);
2571
2572         put_rpccred(cred);
2573 }
2574
2575 /**
2576  * nfs41_check_expired_locks - possibly free a lock stateid
2577  *
2578  * @state: NFSv4 state for an inode
2579  *
2580  * Returns NFS_OK if recovery for this stateid is now finished.
2581  * Otherwise a negative NFS4ERR value is returned.
2582  */
2583 static int nfs41_check_expired_locks(struct nfs4_state *state)
2584 {
2585         int status, ret = NFS_OK;
2586         struct nfs4_lock_state *lsp, *prev = NULL;
2587         struct nfs_server *server = NFS_SERVER(state->inode);
2588
2589         if (!test_bit(LK_STATE_IN_USE, &state->flags))
2590                 goto out;
2591
2592         spin_lock(&state->state_lock);
2593         list_for_each_entry(lsp, &state->lock_states, ls_locks) {
2594                 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
2595                         struct rpc_cred *cred = lsp->ls_state->owner->so_cred;
2596
2597                         atomic_inc(&lsp->ls_count);
2598                         spin_unlock(&state->state_lock);
2599
2600                         nfs4_put_lock_state(prev);
2601                         prev = lsp;
2602
2603                         status = nfs41_test_and_free_expired_stateid(server,
2604                                         &lsp->ls_stateid,
2605                                         cred);
2606                         trace_nfs4_test_lock_stateid(state, lsp, status);
2607                         if (status == -NFS4ERR_EXPIRED ||
2608                             status == -NFS4ERR_BAD_STATEID) {
2609                                 clear_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags);
2610                                 lsp->ls_stateid.type = NFS4_INVALID_STATEID_TYPE;
2611                                 if (!recover_lost_locks)
2612                                         set_bit(NFS_LOCK_LOST, &lsp->ls_flags);
2613                         } else if (status != NFS_OK) {
2614                                 ret = status;
2615                                 nfs4_put_lock_state(prev);
2616                                 goto out;
2617                         }
2618                         spin_lock(&state->state_lock);
2619                 }
2620         }
2621         spin_unlock(&state->state_lock);
2622         nfs4_put_lock_state(prev);
2623 out:
2624         return ret;
2625 }
2626
2627 /**
2628  * nfs41_check_open_stateid - possibly free an open stateid
2629  *
2630  * @state: NFSv4 state for an inode
2631  *
2632  * Returns NFS_OK if recovery for this stateid is now finished.
2633  * Otherwise a negative NFS4ERR value is returned.
2634  */
2635 static int nfs41_check_open_stateid(struct nfs4_state *state)
2636 {
2637         struct nfs_server *server = NFS_SERVER(state->inode);
2638         nfs4_stateid *stateid = &state->open_stateid;
2639         struct rpc_cred *cred = state->owner->so_cred;
2640         int status;
2641
2642         if (test_bit(NFS_OPEN_STATE, &state->flags) == 0) {
2643                 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)  {
2644                         if (nfs4_have_delegation(state->inode, state->state))
2645                                 return NFS_OK;
2646                         return -NFS4ERR_OPENMODE;
2647                 }
2648                 return -NFS4ERR_BAD_STATEID;
2649         }
2650         status = nfs41_test_and_free_expired_stateid(server, stateid, cred);
2651         trace_nfs4_test_open_stateid(state, NULL, status);
2652         if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID) {
2653                 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
2654                 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
2655                 clear_bit(NFS_O_RDWR_STATE, &state->flags);
2656                 clear_bit(NFS_OPEN_STATE, &state->flags);
2657                 stateid->type = NFS4_INVALID_STATEID_TYPE;
2658         }
2659         if (status != NFS_OK)
2660                 return status;
2661         if (nfs_open_stateid_recover_openmode(state))
2662                 return -NFS4ERR_OPENMODE;
2663         return NFS_OK;
2664 }
2665
2666 static int nfs41_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
2667 {
2668         int status;
2669
2670         nfs41_check_delegation_stateid(state);
2671         status = nfs41_check_expired_locks(state);
2672         if (status != NFS_OK)
2673                 return status;
2674         status = nfs41_check_open_stateid(state);
2675         if (status != NFS_OK)
2676                 status = nfs4_open_expired(sp, state);
2677         return status;
2678 }
2679 #endif
2680
2681 /*
2682  * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*
2683  * fields corresponding to attributes that were used to store the verifier.
2684  * Make sure we clobber those fields in the later setattr call
2685  */
2686 static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata,
2687                                 struct iattr *sattr, struct nfs4_label **label)
2688 {
2689         const u32 *attrset = opendata->o_res.attrset;
2690
2691         if ((attrset[1] & FATTR4_WORD1_TIME_ACCESS) &&
2692             !(sattr->ia_valid & ATTR_ATIME_SET))
2693                 sattr->ia_valid |= ATTR_ATIME;
2694
2695         if ((attrset[1] & FATTR4_WORD1_TIME_MODIFY) &&
2696             !(sattr->ia_valid & ATTR_MTIME_SET))
2697                 sattr->ia_valid |= ATTR_MTIME;
2698
2699         /* Except MODE, it seems harmless of setting twice. */
2700         if ((attrset[1] & FATTR4_WORD1_MODE))
2701                 sattr->ia_valid &= ~ATTR_MODE;
2702
2703         if (attrset[2] & FATTR4_WORD2_SECURITY_LABEL)
2704                 *label = NULL;
2705 }
2706
2707 static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata,
2708                 fmode_t fmode,
2709                 int flags,
2710                 struct nfs_open_context *ctx)
2711 {
2712         struct nfs4_state_owner *sp = opendata->owner;
2713         struct nfs_server *server = sp->so_server;
2714         struct dentry *dentry;
2715         struct nfs4_state *state;
2716         unsigned int seq;
2717         int ret;
2718
2719         seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
2720
2721         ret = _nfs4_proc_open(opendata);
2722         if (ret != 0)
2723                 goto out;
2724
2725         state = nfs4_opendata_to_nfs4_state(opendata);
2726         ret = PTR_ERR(state);
2727         if (IS_ERR(state))
2728                 goto out;
2729         if (server->caps & NFS_CAP_POSIX_LOCK)
2730                 set_bit(NFS_STATE_POSIX_LOCKS, &state->flags);
2731         if (opendata->o_res.rflags & NFS4_OPEN_RESULT_MAY_NOTIFY_LOCK)
2732                 set_bit(NFS_STATE_MAY_NOTIFY_LOCK, &state->flags);
2733
2734         dentry = opendata->dentry;
2735         if (d_really_is_negative(dentry)) {
2736                 struct dentry *alias;
2737                 d_drop(dentry);
2738                 alias = d_exact_alias(dentry, state->inode);
2739                 if (!alias)
2740                         alias = d_splice_alias(igrab(state->inode), dentry);
2741                 /* d_splice_alias() can't fail here - it's a non-directory */
2742                 if (alias) {
2743                         dput(ctx->dentry);
2744                         ctx->dentry = dentry = alias;
2745                 }
2746                 nfs_set_verifier(dentry,
2747                                 nfs_save_change_attribute(d_inode(opendata->dir)));
2748         }
2749
2750         ret = nfs4_opendata_access(sp->so_cred, opendata, state, fmode, flags);
2751         if (ret != 0)
2752                 goto out;
2753
2754         ctx->state = state;
2755         if (d_inode(dentry) == state->inode) {
2756                 nfs_inode_attach_open_context(ctx);
2757                 if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
2758                         nfs4_schedule_stateid_recovery(server, state);
2759         }
2760 out:
2761         return ret;
2762 }
2763
2764 /*
2765  * Returns a referenced nfs4_state
2766  */
2767 static int _nfs4_do_open(struct inode *dir,
2768                         struct nfs_open_context *ctx,
2769                         int flags,
2770                         struct iattr *sattr,
2771                         struct nfs4_label *label,
2772                         int *opened)
2773 {
2774         struct nfs4_state_owner  *sp;
2775         struct nfs4_state     *state = NULL;
2776         struct nfs_server       *server = NFS_SERVER(dir);
2777         struct nfs4_opendata *opendata;
2778         struct dentry *dentry = ctx->dentry;
2779         struct rpc_cred *cred = ctx->cred;
2780         struct nfs4_threshold **ctx_th = &ctx->mdsthreshold;
2781         fmode_t fmode = ctx->mode & (FMODE_READ|FMODE_WRITE|FMODE_EXEC);
2782         enum open_claim_type4 claim = NFS4_OPEN_CLAIM_NULL;
2783         struct nfs4_label *olabel = NULL;
2784         int status;
2785
2786         /* Protect against reboot recovery conflicts */
2787         status = -ENOMEM;
2788         sp = nfs4_get_state_owner(server, cred, GFP_KERNEL);
2789         if (sp == NULL) {
2790                 dprintk("nfs4_do_open: nfs4_get_state_owner failed!\n");
2791                 goto out_err;
2792         }
2793         status = nfs4_recover_expired_lease(server);
2794         if (status != 0)
2795                 goto err_put_state_owner;
2796         if (d_really_is_positive(dentry))
2797                 nfs4_return_incompatible_delegation(d_inode(dentry), fmode);
2798         status = -ENOMEM;
2799         if (d_really_is_positive(dentry))
2800                 claim = NFS4_OPEN_CLAIM_FH;
2801         opendata = nfs4_opendata_alloc(dentry, sp, fmode, flags, sattr,
2802                         label, claim, GFP_KERNEL);
2803         if (opendata == NULL)
2804                 goto err_put_state_owner;
2805
2806         if (label) {
2807                 olabel = nfs4_label_alloc(server, GFP_KERNEL);
2808                 if (IS_ERR(olabel)) {
2809                         status = PTR_ERR(olabel);
2810                         goto err_opendata_put;
2811                 }
2812         }
2813
2814         if (server->attr_bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD) {
2815                 if (!opendata->f_attr.mdsthreshold) {
2816                         opendata->f_attr.mdsthreshold = pnfs_mdsthreshold_alloc();
2817                         if (!opendata->f_attr.mdsthreshold)
2818                                 goto err_free_label;
2819                 }
2820                 opendata->o_arg.open_bitmap = &nfs4_pnfs_open_bitmap[0];
2821         }
2822         if (d_really_is_positive(dentry))
2823                 opendata->state = nfs4_get_open_state(d_inode(dentry), sp);
2824
2825         status = _nfs4_open_and_get_state(opendata, fmode, flags, ctx);
2826         if (status != 0)
2827                 goto err_free_label;
2828         state = ctx->state;
2829
2830         if ((opendata->o_arg.open_flags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL) &&
2831             (opendata->o_arg.createmode != NFS4_CREATE_GUARDED)) {
2832                 nfs4_exclusive_attrset(opendata, sattr, &label);
2833                 /*
2834                  * send create attributes which was not set by open
2835                  * with an extra setattr.
2836                  */
2837                 if (sattr->ia_valid & NFS4_VALID_ATTRS) {
2838                         nfs_fattr_init(opendata->o_res.f_attr);
2839                         status = nfs4_do_setattr(state->inode, cred,
2840                                         opendata->o_res.f_attr, sattr,
2841                                         ctx, label, olabel);
2842                         if (status == 0) {
2843                                 nfs_setattr_update_inode(state->inode, sattr,
2844                                                 opendata->o_res.f_attr);
2845                                 nfs_setsecurity(state->inode, opendata->o_res.f_attr, olabel);
2846                         }
2847                 }
2848         }
2849         if (opened && opendata->file_created)
2850                 *opened |= FILE_CREATED;
2851
2852         if (pnfs_use_threshold(ctx_th, opendata->f_attr.mdsthreshold, server)) {
2853                 *ctx_th = opendata->f_attr.mdsthreshold;
2854                 opendata->f_attr.mdsthreshold = NULL;
2855         }
2856
2857         nfs4_label_free(olabel);
2858
2859         nfs4_opendata_put(opendata);
2860         nfs4_put_state_owner(sp);
2861         return 0;
2862 err_free_label:
2863         nfs4_label_free(olabel);
2864 err_opendata_put:
2865         nfs4_opendata_put(opendata);
2866 err_put_state_owner:
2867         nfs4_put_state_owner(sp);
2868 out_err:
2869         return status;
2870 }
2871
2872
2873 static struct nfs4_state *nfs4_do_open(struct inode *dir,
2874                                         struct nfs_open_context *ctx,
2875                                         int flags,
2876                                         struct iattr *sattr,
2877                                         struct nfs4_label *label,
2878                                         int *opened)
2879 {
2880         struct nfs_server *server = NFS_SERVER(dir);
2881         struct nfs4_exception exception = { };
2882         struct nfs4_state *res;
2883         int status;
2884
2885         do {
2886                 status = _nfs4_do_open(dir, ctx, flags, sattr, label, opened);
2887                 res = ctx->state;
2888                 trace_nfs4_open_file(ctx, flags, status);
2889                 if (status == 0)
2890                         break;
2891                 /* NOTE: BAD_SEQID means the server and client disagree about the
2892                  * book-keeping w.r.t. state-changing operations
2893                  * (OPEN/CLOSE/LOCK/LOCKU...)
2894                  * It is actually a sign of a bug on the client or on the server.
2895                  *
2896                  * If we receive a BAD_SEQID error in the particular case of
2897                  * doing an OPEN, we assume that nfs_increment_open_seqid() will
2898                  * have unhashed the old state_owner for us, and that we can
2899                  * therefore safely retry using a new one. We should still warn
2900                  * the user though...
2901                  */
2902                 if (status == -NFS4ERR_BAD_SEQID) {
2903                         pr_warn_ratelimited("NFS: v4 server %s "
2904                                         " returned a bad sequence-id error!\n",
2905                                         NFS_SERVER(dir)->nfs_client->cl_hostname);
2906                         exception.retry = 1;
2907                         continue;
2908                 }
2909                 /*
2910                  * BAD_STATEID on OPEN means that the server cancelled our
2911                  * state before it received the OPEN_CONFIRM.
2912                  * Recover by retrying the request as per the discussion
2913                  * on Page 181 of RFC3530.
2914                  */
2915                 if (status == -NFS4ERR_BAD_STATEID) {
2916                         exception.retry = 1;
2917                         continue;
2918                 }
2919                 if (status == -EAGAIN) {
2920                         /* We must have found a delegation */
2921                         exception.retry = 1;
2922                         continue;
2923                 }
2924                 if (nfs4_clear_cap_atomic_open_v1(server, status, &exception))
2925                         continue;
2926                 res = ERR_PTR(nfs4_handle_exception(server,
2927                                         status, &exception));
2928         } while (exception.retry);
2929         return res;
2930 }
2931
2932 static int _nfs4_do_setattr(struct inode *inode,
2933                             struct nfs_setattrargs *arg,
2934                             struct nfs_setattrres *res,
2935                             struct rpc_cred *cred,
2936                             struct nfs_open_context *ctx)
2937 {
2938         struct nfs_server *server = NFS_SERVER(inode);
2939         struct rpc_message msg = {
2940                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
2941                 .rpc_argp       = arg,
2942                 .rpc_resp       = res,
2943                 .rpc_cred       = cred,
2944         };
2945         struct rpc_cred *delegation_cred = NULL;
2946         unsigned long timestamp = jiffies;
2947         fmode_t fmode;
2948         bool truncate;
2949         int status;
2950
2951         nfs_fattr_init(res->fattr);
2952
2953         /* Servers should only apply open mode checks for file size changes */
2954         truncate = (arg->iap->ia_valid & ATTR_SIZE) ? true : false;
2955         fmode = truncate ? FMODE_WRITE : FMODE_READ;
2956
2957         if (nfs4_copy_delegation_stateid(inode, fmode, &arg->stateid, &delegation_cred)) {
2958                 /* Use that stateid */
2959         } else if (truncate && ctx != NULL) {
2960                 struct nfs_lock_context *l_ctx;
2961                 if (!nfs4_valid_open_stateid(ctx->state))
2962                         return -EBADF;
2963                 l_ctx = nfs_get_lock_context(ctx);
2964                 if (IS_ERR(l_ctx))
2965                         return PTR_ERR(l_ctx);
2966                 status = nfs4_select_rw_stateid(ctx->state, FMODE_WRITE, l_ctx,
2967                                                 &arg->stateid, &delegation_cred);
2968                 nfs_put_lock_context(l_ctx);
2969                 if (status == -EIO)
2970                         return -EBADF;
2971         } else
2972                 nfs4_stateid_copy(&arg->stateid, &zero_stateid);
2973         if (delegation_cred)
2974                 msg.rpc_cred = delegation_cred;
2975
2976         status = nfs4_call_sync(server->client, server, &msg, &arg->seq_args, &res->seq_res, 1);
2977
2978         put_rpccred(delegation_cred);
2979         if (status == 0 && ctx != NULL)
2980                 renew_lease(server, timestamp);
2981         trace_nfs4_setattr(inode, &arg->stateid, status);
2982         return status;
2983 }
2984
2985 static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
2986                            struct nfs_fattr *fattr, struct iattr *sattr,
2987                            struct nfs_open_context *ctx, struct nfs4_label *ilabel,
2988                            struct nfs4_label *olabel)
2989 {
2990         struct nfs_server *server = NFS_SERVER(inode);
2991         struct nfs4_state *state = ctx ? ctx->state : NULL;
2992         struct nfs_setattrargs  arg = {
2993                 .fh             = NFS_FH(inode),
2994                 .iap            = sattr,
2995                 .server         = server,
2996                 .bitmask = server->attr_bitmask,
2997                 .label          = ilabel,
2998         };
2999         struct nfs_setattrres  res = {
3000                 .fattr          = fattr,
3001                 .label          = olabel,
3002                 .server         = server,
3003         };
3004         struct nfs4_exception exception = {
3005                 .state = state,
3006                 .inode = inode,
3007                 .stateid = &arg.stateid,
3008         };
3009         int err;
3010
3011         arg.bitmask = nfs4_bitmask(server, ilabel);
3012         if (ilabel)
3013                 arg.bitmask = nfs4_bitmask(server, olabel);
3014
3015         do {
3016                 err = _nfs4_do_setattr(inode, &arg, &res, cred, ctx);
3017                 switch (err) {
3018                 case -NFS4ERR_OPENMODE:
3019                         if (!(sattr->ia_valid & ATTR_SIZE)) {
3020                                 pr_warn_once("NFSv4: server %s is incorrectly "
3021                                                 "applying open mode checks to "
3022                                                 "a SETATTR that is not "
3023                                                 "changing file size.\n",
3024                                                 server->nfs_client->cl_hostname);
3025                         }
3026                         if (state && !(state->state & FMODE_WRITE)) {
3027                                 err = -EBADF;
3028                                 if (sattr->ia_valid & ATTR_OPEN)
3029                                         err = -EACCES;
3030                                 goto out;
3031                         }
3032                 }
3033                 err = nfs4_handle_exception(server, err, &exception);
3034         } while (exception.retry);
3035 out:
3036         return err;
3037 }
3038
3039 static bool
3040 nfs4_wait_on_layoutreturn(struct inode *inode, struct rpc_task *task)
3041 {
3042         if (inode == NULL || !nfs_have_layout(inode))
3043                 return false;
3044
3045         return pnfs_wait_on_layoutreturn(inode, task);
3046 }
3047
3048 struct nfs4_closedata {
3049         struct inode *inode;
3050         struct nfs4_state *state;
3051         struct nfs_closeargs arg;
3052         struct nfs_closeres res;
3053         struct {
3054                 struct nfs4_layoutreturn_args arg;
3055                 struct nfs4_layoutreturn_res res;
3056                 struct nfs4_xdr_opaque_data ld_private;
3057                 u32 roc_barrier;
3058                 bool roc;
3059         } lr;
3060         struct nfs_fattr fattr;
3061         unsigned long timestamp;
3062 };
3063
3064 static void nfs4_free_closedata(void *data)
3065 {
3066         struct nfs4_closedata *calldata = data;
3067         struct nfs4_state_owner *sp = calldata->state->owner;
3068         struct super_block *sb = calldata->state->inode->i_sb;
3069
3070         if (calldata->lr.roc)
3071                 pnfs_roc_release(&calldata->lr.arg, &calldata->lr.res,
3072                                 calldata->res.lr_ret);
3073         nfs4_put_open_state(calldata->state);
3074         nfs_free_seqid(calldata->arg.seqid);
3075         nfs4_put_state_owner(sp);
3076         nfs_sb_deactive(sb);
3077         kfree(calldata);
3078 }
3079
3080 static void nfs4_close_done(struct rpc_task *task, void *data)
3081 {
3082         struct nfs4_closedata *calldata = data;
3083         struct nfs4_state *state = calldata->state;
3084         struct nfs_server *server = NFS_SERVER(calldata->inode);
3085         nfs4_stateid *res_stateid = NULL;
3086
3087         dprintk("%s: begin!\n", __func__);
3088         if (!nfs4_sequence_done(task, &calldata->res.seq_res))
3089                 return;
3090         trace_nfs4_close(state, &calldata->arg, &calldata->res, task->tk_status);
3091
3092         /* Handle Layoutreturn errors */
3093         if (calldata->arg.lr_args && task->tk_status != 0) {
3094                 switch (calldata->res.lr_ret) {
3095                 default:
3096                         calldata->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT;
3097                         break;
3098                 case 0:
3099                         calldata->arg.lr_args = NULL;
3100                         calldata->res.lr_res = NULL;
3101                         break;
3102                 case -NFS4ERR_ADMIN_REVOKED:
3103                 case -NFS4ERR_DELEG_REVOKED:
3104                 case -NFS4ERR_EXPIRED:
3105                 case -NFS4ERR_BAD_STATEID:
3106                 case -NFS4ERR_OLD_STATEID:
3107                 case -NFS4ERR_UNKNOWN_LAYOUTTYPE:
3108                 case -NFS4ERR_WRONG_CRED:
3109                         calldata->arg.lr_args = NULL;
3110                         calldata->res.lr_res = NULL;
3111                         calldata->res.lr_ret = 0;
3112                         rpc_restart_call_prepare(task);
3113                         return;
3114                 }
3115         }
3116
3117         /* hmm. we are done with the inode, and in the process of freeing
3118          * the state_owner. we keep this around to process errors
3119          */
3120         switch (task->tk_status) {
3121                 case 0:
3122                         res_stateid = &calldata->res.stateid;
3123                         renew_lease(server, calldata->timestamp);
3124                         break;
3125                 case -NFS4ERR_ACCESS:
3126                         if (calldata->arg.bitmask != NULL) {
3127                                 calldata->arg.bitmask = NULL;
3128                                 calldata->res.fattr = NULL;
3129                                 task->tk_status = 0;
3130                                 rpc_restart_call_prepare(task);
3131                                 goto out_release;
3132
3133                         }
3134                         break;
3135                 case -NFS4ERR_ADMIN_REVOKED:
3136                 case -NFS4ERR_STALE_STATEID:
3137                 case -NFS4ERR_EXPIRED:
3138                         nfs4_free_revoked_stateid(server,
3139                                         &calldata->arg.stateid,
3140                                         task->tk_msg.rpc_cred);
3141                 case -NFS4ERR_OLD_STATEID:
3142                 case -NFS4ERR_BAD_STATEID:
3143                         if (!nfs4_stateid_match(&calldata->arg.stateid,
3144                                                 &state->open_stateid)) {
3145                                 rpc_restart_call_prepare(task);
3146                                 goto out_release;
3147                         }
3148                         if (calldata->arg.fmode == 0)
3149                                 break;
3150                 default:
3151                         if (nfs4_async_handle_error(task, server, state, NULL) == -EAGAIN) {
3152                                 rpc_restart_call_prepare(task);
3153                                 goto out_release;
3154                         }
3155         }
3156         nfs_clear_open_stateid(state, &calldata->arg.stateid,
3157                         res_stateid, calldata->arg.fmode);
3158 out_release:
3159         nfs_release_seqid(calldata->arg.seqid);
3160         nfs_refresh_inode(calldata->inode, &calldata->fattr);
3161         dprintk("%s: done, ret = %d!\n", __func__, task->tk_status);
3162 }
3163
3164 static void nfs4_close_prepare(struct rpc_task *task, void *data)
3165 {
3166         struct nfs4_closedata *calldata = data;
3167         struct nfs4_state *state = calldata->state;
3168         struct inode *inode = calldata->inode;
3169         bool is_rdonly, is_wronly, is_rdwr;
3170         int call_close = 0;
3171
3172         dprintk("%s: begin!\n", __func__);
3173         if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
3174                 goto out_wait;
3175
3176         task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE];
3177         spin_lock(&state->owner->so_lock);
3178         is_rdwr = test_bit(NFS_O_RDWR_STATE, &state->flags);
3179         is_rdonly = test_bit(NFS_O_RDONLY_STATE, &state->flags);
3180         is_wronly = test_bit(NFS_O_WRONLY_STATE, &state->flags);
3181         nfs4_stateid_copy(&calldata->arg.stateid, &state->open_stateid);
3182         /* Calculate the change in open mode */
3183         calldata->arg.fmode = 0;
3184         if (state->n_rdwr == 0) {
3185                 if (state->n_rdonly == 0)
3186                         call_close |= is_rdonly;
3187                 else if (is_rdonly)
3188                         calldata->arg.fmode |= FMODE_READ;
3189                 if (state->n_wronly == 0)
3190                         call_close |= is_wronly;
3191                 else if (is_wronly)
3192                         calldata->arg.fmode |= FMODE_WRITE;
3193                 if (calldata->arg.fmode != (FMODE_READ|FMODE_WRITE))
3194                         call_close |= is_rdwr;
3195         } else if (is_rdwr)
3196                 calldata->arg.fmode |= FMODE_READ|FMODE_WRITE;
3197
3198         if (!nfs4_valid_open_stateid(state) ||
3199             test_bit(NFS_OPEN_STATE, &state->flags) == 0)
3200                 call_close = 0;
3201         spin_unlock(&state->owner->so_lock);
3202
3203         if (!call_close) {
3204                 /* Note: exit _without_ calling nfs4_close_done */
3205                 goto out_no_action;
3206         }
3207
3208         if (!calldata->lr.roc && nfs4_wait_on_layoutreturn(inode, task)) {
3209                 nfs_release_seqid(calldata->arg.seqid);
3210                 goto out_wait;
3211         }
3212
3213         if (calldata->arg.fmode == 0)
3214                 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE];
3215
3216         if (calldata->arg.fmode == 0 || calldata->arg.fmode == FMODE_READ) {
3217                 /* Close-to-open cache consistency revalidation */
3218                 if (!nfs4_have_delegation(inode, FMODE_READ))
3219                         calldata->arg.bitmask = NFS_SERVER(inode)->cache_consistency_bitmask;
3220                 else
3221                         calldata->arg.bitmask = NULL;
3222         }
3223
3224         calldata->arg.share_access =
3225                 nfs4_map_atomic_open_share(NFS_SERVER(inode),
3226                                 calldata->arg.fmode, 0);
3227
3228         if (calldata->res.fattr == NULL)
3229                 calldata->arg.bitmask = NULL;
3230         else if (calldata->arg.bitmask == NULL)
3231                 calldata->res.fattr = NULL;
3232         calldata->timestamp = jiffies;
3233         if (nfs4_setup_sequence(NFS_SERVER(inode),
3234                                 &calldata->arg.seq_args,
3235                                 &calldata->res.seq_res,
3236                                 task) != 0)
3237                 nfs_release_seqid(calldata->arg.seqid);
3238         dprintk("%s: done!\n", __func__);
3239         return;
3240 out_no_action:
3241         task->tk_action = NULL;
3242 out_wait:
3243         nfs4_sequence_done(task, &calldata->res.seq_res);
3244 }
3245
3246 static const struct rpc_call_ops nfs4_close_ops = {
3247         .rpc_call_prepare = nfs4_close_prepare,
3248         .rpc_call_done = nfs4_close_done,
3249         .rpc_release = nfs4_free_closedata,
3250 };
3251
3252 /*
3253  * It is possible for data to be read/written from a mem-mapped file
3254  * after the sys_close call (which hits the vfs layer as a flush).
3255  * This means that we can't safely call nfsv4 close on a file until
3256  * the inode is cleared. This in turn means that we are not good
3257  * NFSv4 citizens - we do not indicate to the server to update the file's
3258  * share state even when we are done with one of the three share
3259  * stateid's in the inode.
3260  *
3261  * NOTE: Caller must be holding the sp->so_owner semaphore!
3262  */
3263 int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait)
3264 {
3265         struct nfs_server *server = NFS_SERVER(state->inode);
3266         struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
3267         struct nfs4_closedata *calldata;
3268         struct nfs4_state_owner *sp = state->owner;
3269         struct rpc_task *task;
3270         struct rpc_message msg = {
3271                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE],
3272                 .rpc_cred = state->owner->so_cred,
3273         };
3274         struct rpc_task_setup task_setup_data = {
3275                 .rpc_client = server->client,
3276                 .rpc_message = &msg,
3277                 .callback_ops = &nfs4_close_ops,
3278                 .workqueue = nfsiod_workqueue,
3279                 .flags = RPC_TASK_ASYNC,
3280         };
3281         int status = -ENOMEM;
3282
3283         nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_CLEANUP,
3284                 &task_setup_data.rpc_client, &msg);
3285
3286         calldata = kzalloc(sizeof(*calldata), gfp_mask);
3287         if (calldata == NULL)
3288                 goto out;
3289         nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 1);
3290         calldata->inode = state->inode;
3291         calldata->state = state;
3292         calldata->arg.fh = NFS_FH(state->inode);
3293         /* Serialization for the sequence id */
3294         alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
3295         calldata->arg.seqid = alloc_seqid(&state->owner->so_seqid, gfp_mask);
3296         if (IS_ERR(calldata->arg.seqid))
3297                 goto out_free_calldata;
3298         nfs_fattr_init(&calldata->fattr);
3299         calldata->arg.fmode = 0;
3300         calldata->lr.arg.ld_private = &calldata->lr.ld_private;
3301         calldata->res.fattr = &calldata->fattr;
3302         calldata->res.seqid = calldata->arg.seqid;
3303         calldata->res.server = server;
3304         calldata->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT;
3305         calldata->lr.roc = pnfs_roc(state->inode,
3306                         &calldata->lr.arg, &calldata->lr.res, msg.rpc_cred);
3307         if (calldata->lr.roc) {
3308                 calldata->arg.lr_args = &calldata->lr.arg;
3309                 calldata->res.lr_res = &calldata->lr.res;
3310         }
3311         nfs_sb_active(calldata->inode->i_sb);
3312
3313         msg.rpc_argp = &calldata->arg;
3314         msg.rpc_resp = &calldata->res;
3315         task_setup_data.callback_data = calldata;
3316         task = rpc_run_task(&task_setup_data);
3317         if (IS_ERR(task))
3318                 return PTR_ERR(task);
3319         status = 0;
3320         if (wait)
3321                 status = rpc_wait_for_completion_task(task);
3322         rpc_put_task(task);
3323         return status;
3324 out_free_calldata:
3325         kfree(calldata);
3326 out:
3327         nfs4_put_open_state(state);
3328         nfs4_put_state_owner(sp);
3329         return status;
3330 }
3331
3332 static struct inode *
3333 nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx,
3334                 int open_flags, struct iattr *attr, int *opened)
3335 {
3336         struct nfs4_state *state;
3337         struct nfs4_label l = {0, 0, 0, NULL}, *label = NULL;
3338
3339         label = nfs4_label_init_security(dir, ctx->dentry, attr, &l);
3340
3341         /* Protect against concurrent sillydeletes */
3342         state = nfs4_do_open(dir, ctx, open_flags, attr, label, opened);
3343
3344         nfs4_label_release_security(label);
3345
3346         if (IS_ERR(state))
3347                 return ERR_CAST(state);
3348         return state->inode;
3349 }
3350
3351 static void nfs4_close_context(struct nfs_open_context *ctx, int is_sync)
3352 {
3353         if (ctx->state == NULL)
3354                 return;
3355         if (is_sync)
3356                 nfs4_close_sync(ctx->state, ctx->mode);
3357         else
3358                 nfs4_close_state(ctx->state, ctx->mode);
3359 }
3360
3361 #define FATTR4_WORD1_NFS40_MASK (2*FATTR4_WORD1_MOUNTED_ON_FILEID - 1UL)
3362 #define FATTR4_WORD2_NFS41_MASK (2*FATTR4_WORD2_SUPPATTR_EXCLCREAT - 1UL)
3363 #define FATTR4_WORD2_NFS42_MASK (2*FATTR4_WORD2_MODE_UMASK - 1UL)
3364
3365 static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
3366 {
3367         u32 bitmask[3] = {}, minorversion = server->nfs_client->cl_minorversion;
3368         struct nfs4_server_caps_arg args = {
3369                 .fhandle = fhandle,
3370                 .bitmask = bitmask,
3371         };
3372         struct nfs4_server_caps_res res = {};
3373         struct rpc_message msg = {
3374                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS],
3375                 .rpc_argp = &args,
3376                 .rpc_resp = &res,
3377         };
3378         int status;
3379
3380         bitmask[0] = FATTR4_WORD0_SUPPORTED_ATTRS |
3381                      FATTR4_WORD0_FH_EXPIRE_TYPE |
3382                      FATTR4_WORD0_LINK_SUPPORT |
3383                      FATTR4_WORD0_SYMLINK_SUPPORT |
3384                      FATTR4_WORD0_ACLSUPPORT;
3385         if (minorversion)
3386                 bitmask[2] = FATTR4_WORD2_SUPPATTR_EXCLCREAT;
3387
3388         status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3389         if (status == 0) {
3390                 /* Sanity check the server answers */
3391                 switch (minorversion) {
3392                 case 0:
3393                         res.attr_bitmask[1] &= FATTR4_WORD1_NFS40_MASK;
3394                         res.attr_bitmask[2] = 0;
3395                         break;
3396                 case 1:
3397                         res.attr_bitmask[2] &= FATTR4_WORD2_NFS41_MASK;
3398                         break;
3399                 case 2:
3400                         res.attr_bitmask[2] &= FATTR4_WORD2_NFS42_MASK;
3401                 }
3402                 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask));
3403                 server->caps &= ~(NFS_CAP_ACLS|NFS_CAP_HARDLINKS|
3404                                 NFS_CAP_SYMLINKS|NFS_CAP_FILEID|
3405                                 NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|
3406                                 NFS_CAP_OWNER_GROUP|NFS_CAP_ATIME|
3407                                 NFS_CAP_CTIME|NFS_CAP_MTIME|
3408                                 NFS_CAP_SECURITY_LABEL);
3409                 if (res.attr_bitmask[0] & FATTR4_WORD0_ACL &&
3410                                 res.acl_bitmask & ACL4_SUPPORT_ALLOW_ACL)
3411                         server->caps |= NFS_CAP_ACLS;
3412                 if (res.has_links != 0)
3413                         server->caps |= NFS_CAP_HARDLINKS;
3414                 if (res.has_symlinks != 0)
3415                         server->caps |= NFS_CAP_SYMLINKS;
3416                 if (res.attr_bitmask[0] & FATTR4_WORD0_FILEID)
3417                         server->caps |= NFS_CAP_FILEID;
3418                 if (res.attr_bitmask[1] & FATTR4_WORD1_MODE)
3419                         server->caps |= NFS_CAP_MODE;
3420                 if (res.attr_bitmask[1] & FATTR4_WORD1_NUMLINKS)
3421                         server->caps |= NFS_CAP_NLINK;
3422                 if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER)
3423                         server->caps |= NFS_CAP_OWNER;
3424                 if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER_GROUP)
3425                         server->caps |= NFS_CAP_OWNER_GROUP;
3426                 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_ACCESS)
3427                         server->caps |= NFS_CAP_ATIME;
3428                 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_METADATA)
3429                         server->caps |= NFS_CAP_CTIME;
3430                 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY)
3431                         server->caps |= NFS_CAP_MTIME;
3432 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
3433                 if (res.attr_bitmask[2] & FATTR4_WORD2_SECURITY_LABEL)
3434                         server->caps |= NFS_CAP_SECURITY_LABEL;
3435 #endif
3436                 memcpy(server->attr_bitmask_nl, res.attr_bitmask,
3437                                 sizeof(server->attr_bitmask));
3438                 server->attr_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
3439
3440                 memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask));
3441                 server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE;
3442                 server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY;
3443                 server->cache_consistency_bitmask[2] = 0;
3444                 memcpy(server->exclcreat_bitmask, res.exclcreat_bitmask,
3445                         sizeof(server->exclcreat_bitmask));
3446                 server->acl_bitmask = res.acl_bitmask;
3447                 server->fh_expire_type = res.fh_expire_type;
3448         }
3449
3450         return status;
3451 }
3452
3453 int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
3454 {
3455         struct nfs4_exception exception = { };
3456         int err;
3457         do {
3458                 err = nfs4_handle_exception(server,
3459                                 _nfs4_server_capabilities(server, fhandle),
3460                                 &exception);
3461         } while (exception.retry);
3462         return err;
3463 }
3464
3465 static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
3466                 struct nfs_fsinfo *info)
3467 {
3468         u32 bitmask[3];
3469         struct nfs4_lookup_root_arg args = {
3470                 .bitmask = bitmask,
3471         };
3472         struct nfs4_lookup_res res = {
3473                 .server = server,
3474                 .fattr = info->fattr,
3475                 .fh = fhandle,
3476         };
3477         struct rpc_message msg = {
3478                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP_ROOT],
3479                 .rpc_argp = &args,
3480                 .rpc_resp = &res,
3481         };
3482
3483         bitmask[0] = nfs4_fattr_bitmap[0];
3484         bitmask[1] = nfs4_fattr_bitmap[1];
3485         /*
3486          * Process the label in the upcoming getfattr
3487          */
3488         bitmask[2] = nfs4_fattr_bitmap[2] & ~FATTR4_WORD2_SECURITY_LABEL;
3489
3490         nfs_fattr_init(info->fattr);
3491         return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3492 }
3493
3494 static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
3495                 struct nfs_fsinfo *info)
3496 {
3497         struct nfs4_exception exception = { };
3498         int err;
3499         do {
3500                 err = _nfs4_lookup_root(server, fhandle, info);
3501                 trace_nfs4_lookup_root(server, fhandle, info->fattr, err);
3502                 switch (err) {
3503                 case 0:
3504                 case -NFS4ERR_WRONGSEC:
3505                         goto out;
3506                 default:
3507                         err = nfs4_handle_exception(server, err, &exception);
3508                 }
3509         } while (exception.retry);
3510 out:
3511         return err;
3512 }
3513
3514 static int nfs4_lookup_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
3515                                 struct nfs_fsinfo *info, rpc_authflavor_t flavor)
3516 {
3517         struct rpc_auth_create_args auth_args = {
3518                 .pseudoflavor = flavor,
3519         };
3520         struct rpc_auth *auth;
3521         int ret;
3522
3523         auth = rpcauth_create(&auth_args, server->client);
3524         if (IS_ERR(auth)) {
3525                 ret = -EACCES;
3526                 goto out;
3527         }
3528         ret = nfs4_lookup_root(server, fhandle, info);
3529 out:
3530         return ret;
3531 }
3532
3533 /*
3534  * Retry pseudoroot lookup with various security flavors.  We do this when:
3535  *
3536  *   NFSv4.0: the PUTROOTFH operation returns NFS4ERR_WRONGSEC
3537  *   NFSv4.1: the server does not support the SECINFO_NO_NAME operation
3538  *
3539  * Returns zero on success, or a negative NFS4ERR value, or a
3540  * negative errno value.
3541  */
3542 static int nfs4_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
3543                               struct nfs_fsinfo *info)
3544 {
3545         /* Per 3530bis 15.33.5 */
3546         static const rpc_authflavor_t flav_array[] = {
3547                 RPC_AUTH_GSS_KRB5P,
3548                 RPC_AUTH_GSS_KRB5I,
3549                 RPC_AUTH_GSS_KRB5,
3550                 RPC_AUTH_UNIX,                  /* courtesy */
3551                 RPC_AUTH_NULL,
3552         };
3553         int status = -EPERM;
3554         size_t i;
3555
3556         if (server->auth_info.flavor_len > 0) {
3557                 /* try each flavor specified by user */
3558                 for (i = 0; i < server->auth_info.flavor_len; i++) {
3559                         status = nfs4_lookup_root_sec(server, fhandle, info,
3560                                                 server->auth_info.flavors[i]);
3561                         if (status == -NFS4ERR_WRONGSEC || status == -EACCES)
3562                                 continue;
3563                         break;
3564                 }
3565         } else {
3566                 /* no flavors specified by user, try default list */
3567                 for (i = 0; i < ARRAY_SIZE(flav_array); i++) {
3568                         status = nfs4_lookup_root_sec(server, fhandle, info,
3569                                                       flav_array[i]);
3570                         if (status == -NFS4ERR_WRONGSEC || status == -EACCES)
3571                                 continue;
3572                         break;
3573                 }
3574         }
3575
3576         /*
3577          * -EACCESS could mean that the user doesn't have correct permissions
3578          * to access the mount.  It could also mean that we tried to mount
3579          * with a gss auth flavor, but rpc.gssd isn't running.  Either way,
3580          * existing mount programs don't handle -EACCES very well so it should
3581          * be mapped to -EPERM instead.
3582          */
3583         if (status == -EACCES)
3584                 status = -EPERM;
3585         return status;
3586 }
3587
3588 /**
3589  * nfs4_proc_get_rootfh - get file handle for server's pseudoroot
3590  * @server: initialized nfs_server handle
3591  * @fhandle: we fill in the pseudo-fs root file handle
3592  * @info: we fill in an FSINFO struct
3593  * @auth_probe: probe the auth flavours
3594  *
3595  * Returns zero on success, or a negative errno.
3596  */
3597 int nfs4_proc_get_rootfh(struct nfs_server *server, struct nfs_fh *fhandle,
3598                          struct nfs_fsinfo *info,
3599                          bool auth_probe)
3600 {
3601         int status = 0;
3602
3603         if (!auth_probe)
3604                 status = nfs4_lookup_root(server, fhandle, info);
3605
3606         if (auth_probe || status == NFS4ERR_WRONGSEC)
3607                 status = server->nfs_client->cl_mvops->find_root_sec(server,
3608                                 fhandle, info);
3609
3610         if (status == 0)
3611                 status = nfs4_server_capabilities(server, fhandle);
3612         if (status == 0)
3613                 status = nfs4_do_fsinfo(server, fhandle, info);
3614
3615         return nfs4_map_errors(status);
3616 }
3617
3618 static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh,
3619                               struct nfs_fsinfo *info)
3620 {
3621         int error;
3622         struct nfs_fattr *fattr = info->fattr;
3623         struct nfs4_label *label = NULL;
3624
3625         error = nfs4_server_capabilities(server, mntfh);
3626         if (error < 0) {
3627                 dprintk("nfs4_get_root: getcaps error = %d\n", -error);
3628                 return error;
3629         }
3630
3631         label = nfs4_label_alloc(server, GFP_KERNEL);
3632         if (IS_ERR(label))
3633                 return PTR_ERR(label);
3634
3635         error = nfs4_proc_getattr(server, mntfh, fattr, label);
3636         if (error < 0) {
3637                 dprintk("nfs4_get_root: getattr error = %d\n", -error);
3638                 goto err_free_label;
3639         }
3640
3641         if (fattr->valid & NFS_ATTR_FATTR_FSID &&
3642             !nfs_fsid_equal(&server->fsid, &fattr->fsid))
3643                 memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));
3644
3645 err_free_label:
3646         nfs4_label_free(label);
3647
3648         return error;
3649 }
3650
3651 /*
3652  * Get locations and (maybe) other attributes of a referral.
3653  * Note that we'll actually follow the referral later when
3654  * we detect fsid mismatch in inode revalidation
3655  */
3656 static int nfs4_get_referral(struct rpc_clnt *client, struct inode *dir,
3657                              const struct qstr *name, struct nfs_fattr *fattr,
3658                              struct nfs_fh *fhandle)
3659 {
3660         int status = -ENOMEM;
3661         struct page *page = NULL;
3662         struct nfs4_fs_locations *locations = NULL;
3663
3664         page = alloc_page(GFP_KERNEL);
3665         if (page == NULL)
3666                 goto out;
3667         locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
3668         if (locations == NULL)
3669                 goto out;
3670
3671         status = nfs4_proc_fs_locations(client, dir, name, locations, page);
3672         if (status != 0)
3673                 goto out;
3674
3675         /*
3676          * If the fsid didn't change, this is a migration event, not a
3677          * referral.  Cause us to drop into the exception handler, which
3678          * will kick off migration recovery.
3679          */
3680         if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) {
3681                 dprintk("%s: server did not return a different fsid for"
3682                         " a referral at %s\n", __func__, name->name);
3683                 status = -NFS4ERR_MOVED;
3684                 goto out;
3685         }
3686         /* Fixup attributes for the nfs_lookup() call to nfs_fhget() */
3687         nfs_fixup_referral_attributes(&locations->fattr);
3688
3689         /* replace the lookup nfs_fattr with the locations nfs_fattr */
3690         memcpy(fattr, &locations->fattr, sizeof(struct nfs_fattr));
3691         memset(fhandle, 0, sizeof(struct nfs_fh));
3692 out:
3693         if (page)
3694                 __free_page(page);
3695         kfree(locations);
3696         return status;
3697 }
3698
3699 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
3700                                 struct nfs_fattr *fattr, struct nfs4_label *label)
3701 {
3702         struct nfs4_getattr_arg args = {
3703                 .fh = fhandle,
3704                 .bitmask = server->attr_bitmask,
3705         };
3706         struct nfs4_getattr_res res = {
3707                 .fattr = fattr,
3708                 .label = label,
3709                 .server = server,
3710         };
3711         struct rpc_message msg = {
3712                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
3713                 .rpc_argp = &args,
3714                 .rpc_resp = &res,
3715         };
3716
3717         args.bitmask = nfs4_bitmask(server, label);
3718
3719         nfs_fattr_init(fattr);
3720         return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3721 }
3722
3723 static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
3724                                 struct nfs_fattr *fattr, struct nfs4_label *label)
3725 {
3726         struct nfs4_exception exception = { };
3727         int err;
3728         do {
3729                 err = _nfs4_proc_getattr(server, fhandle, fattr, label);
3730                 trace_nfs4_getattr(server, fhandle, fattr, err);
3731                 err = nfs4_handle_exception(server, err,
3732                                 &exception);
3733         } while (exception.retry);
3734         return err;
3735 }
3736
3737 /*
3738  * The file is not closed if it is opened due to the a request to change
3739  * the size of the file. The open call will not be needed once the
3740  * VFS layer lookup-intents are implemented.
3741  *
3742  * Close is called when the inode is destroyed.
3743  * If we haven't opened the file for O_WRONLY, we
3744  * need to in the size_change case to obtain a stateid.
3745  *
3746  * Got race?
3747  * Because OPEN is always done by name in nfsv4, it is
3748  * possible that we opened a different file by the same
3749  * name.  We can recognize this race condition, but we
3750  * can't do anything about it besides returning an error.
3751  *
3752  * This will be fixed with VFS changes (lookup-intent).
3753  */
3754 static int
3755 nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
3756                   struct iattr *sattr)
3757 {
3758         struct inode *inode = d_inode(dentry);
3759         struct rpc_cred *cred = NULL;
3760         struct nfs_open_context *ctx = NULL;
3761         struct nfs4_label *label = NULL;
3762         int status;
3763
3764         if (pnfs_ld_layoutret_on_setattr(inode) &&
3765             sattr->ia_valid & ATTR_SIZE &&
3766             sattr->ia_size < i_size_read(inode))
3767                 pnfs_commit_and_return_layout(inode);
3768
3769         nfs_fattr_init(fattr);
3770
3771         /* Deal with open(O_TRUNC) */
3772         if (sattr->ia_valid & ATTR_OPEN)
3773                 sattr->ia_valid &= ~(ATTR_MTIME|ATTR_CTIME);
3774
3775         /* Optimization: if the end result is no change, don't RPC */
3776         if ((sattr->ia_valid & ~(ATTR_FILE|ATTR_OPEN)) == 0)
3777                 return 0;
3778
3779         /* Search for an existing open(O_WRITE) file */
3780         if (sattr->ia_valid & ATTR_FILE) {
3781
3782                 ctx = nfs_file_open_context(sattr->ia_file);
3783                 if (ctx)
3784                         cred = ctx->cred;
3785         }
3786
3787         label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
3788         if (IS_ERR(label))
3789                 return PTR_ERR(label);
3790
3791         status = nfs4_do_setattr(inode, cred, fattr, sattr, ctx, NULL, label);
3792         if (status == 0) {
3793                 nfs_setattr_update_inode(inode, sattr, fattr);
3794                 nfs_setsecurity(inode, fattr, label);
3795         }
3796         nfs4_label_free(label);
3797         return status;
3798 }
3799
3800 static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,
3801                 const struct qstr *name, struct nfs_fh *fhandle,
3802                 struct nfs_fattr *fattr, struct nfs4_label *label)
3803 {
3804         struct nfs_server *server = NFS_SERVER(dir);
3805         int                    status;
3806         struct nfs4_lookup_arg args = {
3807                 .bitmask = server->attr_bitmask,
3808                 .dir_fh = NFS_FH(dir),
3809                 .name = name,
3810         };
3811         struct nfs4_lookup_res res = {
3812                 .server = server,
3813                 .fattr = fattr,
3814                 .label = label,
3815                 .fh = fhandle,
3816         };
3817         struct rpc_message msg = {
3818                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP],
3819                 .rpc_argp = &args,
3820                 .rpc_resp = &res,
3821         };
3822
3823         args.bitmask = nfs4_bitmask(server, label);
3824
3825         nfs_fattr_init(fattr);
3826
3827         dprintk("NFS call  lookup %s\n", name->name);
3828         status = nfs4_call_sync(clnt, server, &msg, &args.seq_args, &res.seq_res, 0);
3829         dprintk("NFS reply lookup: %d\n", status);
3830         return status;
3831 }
3832
3833 static void nfs_fixup_secinfo_attributes(struct nfs_fattr *fattr)
3834 {
3835         fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |
3836                 NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_MOUNTPOINT;
3837         fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;
3838         fattr->nlink = 2;
3839 }
3840
3841 static int nfs4_proc_lookup_common(struct rpc_clnt **clnt, struct inode *dir,
3842                                    const struct qstr *name, struct nfs_fh *fhandle,
3843                                    struct nfs_fattr *fattr, struct nfs4_label *label)
3844 {
3845         struct nfs4_exception exception = { };
3846         struct rpc_clnt *client = *clnt;
3847         int err;
3848         do {
3849                 err = _nfs4_proc_lookup(client, dir, name, fhandle, fattr, label);
3850                 trace_nfs4_lookup(dir, name, err);
3851                 switch (err) {
3852                 case -NFS4ERR_BADNAME:
3853                         err = -ENOENT;
3854                         goto out;
3855                 case -NFS4ERR_MOVED:
3856                         err = nfs4_get_referral(client, dir, name, fattr, fhandle);
3857                         if (err == -NFS4ERR_MOVED)
3858                                 err = nfs4_handle_exception(NFS_SERVER(dir), err, &exception);
3859                         goto out;
3860                 case -NFS4ERR_WRONGSEC:
3861                         err = -EPERM;
3862                         if (client != *clnt)
3863                                 goto out;
3864                         client = nfs4_negotiate_security(client, dir, name);
3865                         if (IS_ERR(client))
3866                                 return PTR_ERR(client);
3867
3868                         exception.retry = 1;
3869                         break;
3870                 default:
3871                         err = nfs4_handle_exception(NFS_SERVER(dir), err, &exception);
3872                 }
3873         } while (exception.retry);
3874
3875 out:
3876         if (err == 0)
3877                 *clnt = client;
3878         else if (client != *clnt)
3879                 rpc_shutdown_client(client);
3880
3881         return err;
3882 }
3883
3884 static int nfs4_proc_lookup(struct inode *dir, const struct qstr *name,
3885                             struct nfs_fh *fhandle, struct nfs_fattr *fattr,
3886                             struct nfs4_label *label)
3887 {
3888         int status;
3889         struct rpc_clnt *client = NFS_CLIENT(dir);
3890
3891         status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr, label);
3892         if (client != NFS_CLIENT(dir)) {
3893                 rpc_shutdown_client(client);
3894                 nfs_fixup_secinfo_attributes(fattr);
3895         }
3896         return status;
3897 }
3898
3899 struct rpc_clnt *
3900 nfs4_proc_lookup_mountpoint(struct inode *dir, const struct qstr *name,
3901                             struct nfs_fh *fhandle, struct nfs_fattr *fattr)
3902 {
3903         struct rpc_clnt *client = NFS_CLIENT(dir);
3904         int status;
3905
3906         status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr, NULL);
3907         if (status < 0)
3908                 return ERR_PTR(status);
3909         return (client == NFS_CLIENT(dir)) ? rpc_clone_client(client) : client;
3910 }
3911
3912 static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
3913 {
3914         struct nfs_server *server = NFS_SERVER(inode);
3915         struct nfs4_accessargs args = {
3916                 .fh = NFS_FH(inode),
3917                 .bitmask = server->cache_consistency_bitmask,
3918         };
3919         struct nfs4_accessres res = {
3920                 .server = server,
3921         };
3922         struct rpc_message msg = {
3923                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS],
3924                 .rpc_argp = &args,
3925                 .rpc_resp = &res,
3926                 .rpc_cred = entry->cred,
3927         };
3928         int mode = entry->mask;
3929         int status = 0;
3930
3931         /*
3932          * Determine which access bits we want to ask for...
3933          */
3934         if (mode & MAY_READ)
3935                 args.access |= NFS4_ACCESS_READ;
3936         if (S_ISDIR(inode->i_mode)) {
3937                 if (mode & MAY_WRITE)
3938                         args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE;
3939                 if (mode & MAY_EXEC)
3940                         args.access |= NFS4_ACCESS_LOOKUP;
3941         } else {
3942                 if (mode & MAY_WRITE)
3943                         args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND;
3944                 if (mode & MAY_EXEC)
3945                         args.access |= NFS4_ACCESS_EXECUTE;
3946         }
3947
3948         res.fattr = nfs_alloc_fattr();
3949         if (res.fattr == NULL)
3950                 return -ENOMEM;
3951
3952         status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3953         if (!status) {
3954                 nfs_access_set_mask(entry, res.access);
3955                 nfs_refresh_inode(inode, res.fattr);
3956         }
3957         nfs_free_fattr(res.fattr);
3958         return status;
3959 }
3960
3961 static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
3962 {
3963         struct nfs4_exception exception = { };
3964         int err;
3965         do {
3966                 err = _nfs4_proc_access(inode, entry);
3967                 trace_nfs4_access(inode, err);
3968                 err = nfs4_handle_exception(NFS_SERVER(inode), err,
3969                                 &exception);
3970         } while (exception.retry);
3971         return err;
3972 }
3973
3974 /*
3975  * TODO: For the time being, we don't try to get any attributes
3976  * along with any of the zero-copy operations READ, READDIR,
3977  * READLINK, WRITE.
3978  *
3979  * In the case of the first three, we want to put the GETATTR
3980  * after the read-type operation -- this is because it is hard
3981  * to predict the length of a GETATTR response in v4, and thus
3982  * align the READ data correctly.  This means that the GETATTR
3983  * may end up partially falling into the page cache, and we should
3984  * shift it into the 'tail' of the xdr_buf before processing.
3985  * To do this efficiently, we need to know the total length
3986  * of data received, which doesn't seem to be available outside
3987  * of the RPC layer.
3988  *
3989  * In the case of WRITE, we also want to put the GETATTR after
3990  * the operation -- in this case because we want to make sure
3991  * we get the post-operation mtime and size.
3992  *
3993  * Both of these changes to the XDR layer would in fact be quite
3994  * minor, but I decided to leave them for a subsequent patch.
3995  */
3996 static int _nfs4_proc_readlink(struct inode *inode, struct page *page,
3997                 unsigned int pgbase, unsigned int pglen)
3998 {
3999         struct nfs4_readlink args = {
4000                 .fh       = NFS_FH(inode),
4001                 .pgbase   = pgbase,
4002                 .pglen    = pglen,
4003                 .pages    = &page,
4004         };
4005         struct nfs4_readlink_res res;
4006         struct rpc_message msg = {
4007                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK],
4008                 .rpc_argp = &args,
4009                 .rpc_resp = &res,
4010         };
4011
4012         return nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), &msg, &args.seq_args, &res.seq_res, 0);
4013 }
4014
4015 static int nfs4_proc_readlink(struct inode *inode, struct page *page,
4016                 unsigned int pgbase, unsigned int pglen)
4017 {
4018         struct nfs4_exception exception = { };
4019         int err;
4020         do {
4021                 err = _nfs4_proc_readlink(inode, page, pgbase, pglen);
4022                 trace_nfs4_readlink(inode, err);
4023                 err = nfs4_handle_exception(NFS_SERVER(inode), err,
4024                                 &exception);
4025         } while (exception.retry);
4026         return err;
4027 }
4028
4029 /*
4030  * This is just for mknod.  open(O_CREAT) will always do ->open_context().
4031  */
4032 static int
4033 nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
4034                  int flags)
4035 {
4036         struct nfs_server *server = NFS_SERVER(dir);
4037         struct nfs4_label l, *ilabel = NULL;
4038         struct nfs_open_context *ctx;
4039         struct nfs4_state *state;
4040         int status = 0;
4041
4042         ctx = alloc_nfs_open_context(dentry, FMODE_READ, NULL);
4043         if (IS_ERR(ctx))
4044                 return PTR_ERR(ctx);
4045
4046         ilabel = nfs4_label_init_security(dir, dentry, sattr, &l);
4047
4048         if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
4049                 sattr->ia_mode &= ~current_umask();
4050         state = nfs4_do_open(dir, ctx, flags, sattr, ilabel, NULL);
4051         if (IS_ERR(state)) {
4052                 status = PTR_ERR(state);
4053                 goto out;
4054         }
4055 out:
4056         nfs4_label_release_security(ilabel);
4057         put_nfs_open_context(ctx);
4058         return status;
4059 }
4060
4061 static int _nfs4_proc_remove(struct inode *dir, const struct qstr *name)
4062 {
4063         struct nfs_server *server = NFS_SERVER(dir);
4064         struct nfs_removeargs args = {
4065                 .fh = NFS_FH(dir),
4066                 .name = *name,
4067         };
4068         struct nfs_removeres res = {
4069                 .server = server,
4070         };
4071         struct rpc_message msg = {
4072                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE],
4073                 .rpc_argp = &args,
4074                 .rpc_resp = &res,
4075         };
4076         int status;
4077
4078         status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1);
4079         if (status == 0)
4080                 update_changeattr(dir, &res.cinfo);
4081         return status;
4082 }
4083
4084 static int nfs4_proc_remove(struct inode *dir, const struct qstr *name)
4085 {
4086         struct nfs4_exception exception = { };
4087         int err;
4088         do {
4089                 err = _nfs4_proc_remove(dir, name);
4090                 trace_nfs4_remove(dir, name, err);
4091                 err = nfs4_handle_exception(NFS_SERVER(dir), err,
4092                                 &exception);
4093         } while (exception.retry);
4094         return err;
4095 }
4096
4097 static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
4098 {
4099         struct nfs_server *server = NFS_SERVER(dir);
4100         struct nfs_removeargs *args = msg->rpc_argp;
4101         struct nfs_removeres *res = msg->rpc_resp;
4102
4103         res->server = server;
4104         msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE];
4105         nfs4_init_sequence(&args->seq_args, &res->seq_res, 1);
4106
4107         nfs_fattr_init(res->dir_attr);
4108 }
4109
4110 static void nfs4_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
4111 {
4112         nfs4_setup_sequence(NFS_SB(data->dentry->d_sb),
4113                         &data->args.seq_args,
4114                         &data->res.seq_res,
4115                         task);
4116 }
4117
4118 static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir)
4119 {
4120         struct nfs_unlinkdata *data = task->tk_calldata;
4121         struct nfs_removeres *res = &data->res;
4122
4123         if (!nfs4_sequence_done(task, &res->seq_res))
4124                 return 0;
4125         if (nfs4_async_handle_error(task, res->server, NULL,
4126                                     &data->timeout) == -EAGAIN)
4127                 return 0;
4128         update_changeattr(dir, &res->cinfo);
4129         return 1;
4130 }
4131
4132 static void nfs4_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
4133 {
4134         struct nfs_server *server = NFS_SERVER(dir);
4135         struct nfs_renameargs *arg = msg->rpc_argp;
4136         struct nfs_renameres *res = msg->rpc_resp;
4137
4138         msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME];
4139         res->server = server;
4140         nfs4_init_sequence(&arg->seq_args, &res->seq_res, 1);
4141 }
4142
4143 static void nfs4_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
4144 {
4145         nfs4_setup_sequence(NFS_SERVER(data->old_dir),
4146                         &data->args.seq_args,
4147                         &data->res.seq_res,
4148                         task);
4149 }
4150
4151 static int nfs4_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
4152                                  struct inode *new_dir)
4153 {
4154         struct nfs_renamedata *data = task->tk_calldata;
4155         struct nfs_renameres *res = &data->res;
4156
4157         if (!nfs4_sequence_done(task, &res->seq_res))
4158                 return 0;
4159         if (nfs4_async_handle_error(task, res->server, NULL, &data->timeout) == -EAGAIN)
4160                 return 0;
4161
4162         update_changeattr(old_dir, &res->old_cinfo);
4163         update_changeattr(new_dir, &res->new_cinfo);
4164         return 1;
4165 }
4166
4167 static int _nfs4_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name)
4168 {
4169         struct nfs_server *server = NFS_SERVER(inode);
4170         struct nfs4_link_arg arg = {
4171                 .fh     = NFS_FH(inode),
4172                 .dir_fh = NFS_FH(dir),
4173                 .name   = name,
4174                 .bitmask = server->attr_bitmask,
4175         };
4176         struct nfs4_link_res res = {
4177                 .server = server,
4178                 .label = NULL,
4179         };
4180         struct rpc_message msg = {
4181                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK],
4182                 .rpc_argp = &arg,
4183                 .rpc_resp = &res,
4184         };
4185         int status = -ENOMEM;
4186
4187         res.fattr = nfs_alloc_fattr();
4188         if (res.fattr == NULL)
4189                 goto out;
4190
4191         res.label = nfs4_label_alloc(server, GFP_KERNEL);
4192         if (IS_ERR(res.label)) {
4193                 status = PTR_ERR(res.label);
4194                 goto out;
4195         }
4196         arg.bitmask = nfs4_bitmask(server, res.label);
4197
4198         status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
4199         if (!status) {
4200                 update_changeattr(dir, &res.cinfo);
4201                 status = nfs_post_op_update_inode(inode, res.fattr);
4202                 if (!status)
4203                         nfs_setsecurity(inode, res.fattr, res.label);
4204         }
4205
4206
4207         nfs4_label_free(res.label);
4208
4209 out:
4210         nfs_free_fattr(res.fattr);
4211         return status;
4212 }
4213
4214 static int nfs4_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name)
4215 {
4216         struct nfs4_exception exception = { };
4217         int err;
4218         do {
4219                 err = nfs4_handle_exception(NFS_SERVER(inode),
4220                                 _nfs4_proc_link(inode, dir, name),
4221                                 &exception);
4222         } while (exception.retry);
4223         return err;
4224 }
4225
4226 struct nfs4_createdata {
4227         struct rpc_message msg;
4228         struct nfs4_create_arg arg;
4229         struct nfs4_create_res res;
4230         struct nfs_fh fh;
4231         struct nfs_fattr fattr;
4232         struct nfs4_label *label;
4233 };
4234
4235 static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,
4236                 const struct qstr *name, struct iattr *sattr, u32 ftype)
4237 {
4238         struct nfs4_createdata *data;
4239
4240         data = kzalloc(sizeof(*data), GFP_KERNEL);
4241         if (data != NULL) {
4242                 struct nfs_server *server = NFS_SERVER(dir);
4243
4244                 data->label = nfs4_label_alloc(server, GFP_KERNEL);
4245                 if (IS_ERR(data->label))
4246                         goto out_free;
4247
4248                 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE];
4249                 data->msg.rpc_argp = &data->arg;
4250                 data->msg.rpc_resp = &data->res;
4251                 data->arg.dir_fh = NFS_FH(dir);
4252                 data->arg.server = server;
4253                 data->arg.name = name;
4254                 data->arg.attrs = sattr;
4255                 data->arg.ftype = ftype;
4256                 data->arg.bitmask = nfs4_bitmask(server, data->label);
4257                 data->arg.umask = current_umask();
4258                 data->res.server = server;
4259                 data->res.fh = &data->fh;
4260                 data->res.fattr = &data->fattr;
4261                 data->res.label = data->label;
4262                 nfs_fattr_init(data->res.fattr);
4263         }
4264         return data;
4265 out_free:
4266         kfree(data);
4267         return NULL;
4268 }
4269
4270 static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data)
4271 {
4272         int status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &data->msg,
4273                                     &data->arg.seq_args, &data->res.seq_res, 1);
4274         if (status == 0) {
4275                 update_changeattr(dir, &data->res.dir_cinfo);
4276                 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, data->res.label);
4277         }
4278         return status;
4279 }
4280
4281 static void nfs4_free_createdata(struct nfs4_createdata *data)
4282 {
4283         nfs4_label_free(data->label);
4284         kfree(data);
4285 }
4286
4287 static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
4288                 struct page *page, unsigned int len, struct iattr *sattr,
4289                 struct nfs4_label *label)
4290 {
4291         struct nfs4_createdata *data;
4292         int status = -ENAMETOOLONG;
4293
4294         if (len > NFS4_MAXPATHLEN)
4295                 goto out;
4296
4297         status = -ENOMEM;
4298         data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK);
4299         if (data == NULL)
4300                 goto out;
4301
4302         data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK];
4303         data->arg.u.symlink.pages = &page;
4304         data->arg.u.symlink.len = len;
4305         data->arg.label = label;
4306
4307         status = nfs4_do_create(dir, dentry, data);
4308
4309         nfs4_free_createdata(data);
4310 out:
4311         return status;
4312 }
4313
4314 static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
4315                 struct page *page, unsigned int len, struct iattr *sattr)
4316 {
4317         struct nfs4_exception exception = { };
4318         struct nfs4_label l, *label = NULL;
4319         int err;
4320
4321         label = nfs4_label_init_security(dir, dentry, sattr, &l);
4322
4323         do {
4324                 err = _nfs4_proc_symlink(dir, dentry, page, len, sattr, label);
4325                 trace_nfs4_symlink(dir, &dentry->d_name, err);
4326                 err = nfs4_handle_exception(NFS_SERVER(dir), err,
4327                                 &exception);
4328         } while (exception.retry);
4329
4330         nfs4_label_release_security(label);
4331         return err;
4332 }
4333
4334 static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
4335                 struct iattr *sattr, struct nfs4_label *label)
4336 {
4337         struct nfs4_createdata *data;
4338         int status = -ENOMEM;
4339
4340         data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR);
4341         if (data == NULL)
4342                 goto out;
4343
4344         data->arg.label = label;
4345         status = nfs4_do_create(dir, dentry, data);
4346
4347         nfs4_free_createdata(data);
4348 out:
4349         return status;
4350 }
4351
4352 static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
4353                 struct iattr *sattr)
4354 {
4355         struct nfs_server *server = NFS_SERVER(dir);
4356         struct nfs4_exception exception = { };
4357         struct nfs4_label l, *label = NULL;
4358         int err;
4359
4360         label = nfs4_label_init_security(dir, dentry, sattr, &l);
4361
4362         if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
4363                 sattr->ia_mode &= ~current_umask();
4364         do {
4365                 err = _nfs4_proc_mkdir(dir, dentry, sattr, label);
4366                 trace_nfs4_mkdir(dir, &dentry->d_name, err);
4367                 err = nfs4_handle_exception(NFS_SERVER(dir), err,
4368                                 &exception);
4369         } while (exception.retry);
4370         nfs4_label_release_security(label);
4371
4372         return err;
4373 }
4374
4375 static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
4376                 u64 cookie, struct page **pages, unsigned int count, int plus)
4377 {
4378         struct inode            *dir = d_inode(dentry);
4379         struct nfs4_readdir_arg args = {
4380                 .fh = NFS_FH(dir),
4381                 .pages = pages,
4382                 .pgbase = 0,
4383                 .count = count,
4384                 .bitmask = NFS_SERVER(d_inode(dentry))->attr_bitmask,
4385                 .plus = plus,
4386         };
4387         struct nfs4_readdir_res res;
4388         struct rpc_message msg = {
4389                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR],
4390                 .rpc_argp = &args,
4391                 .rpc_resp = &res,
4392                 .rpc_cred = cred,
4393         };
4394         int                     status;
4395
4396         dprintk("%s: dentry = %pd2, cookie = %Lu\n", __func__,
4397                         dentry,
4398                         (unsigned long long)cookie);
4399         nfs4_setup_readdir(cookie, NFS_I(dir)->cookieverf, dentry, &args);
4400         res.pgbase = args.pgbase;
4401         status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &msg, &args.seq_args, &res.seq_res, 0);
4402         if (status >= 0) {
4403                 memcpy(NFS_I(dir)->cookieverf, res.verifier.data, NFS4_VERIFIER_SIZE);
4404                 status += args.pgbase;
4405         }
4406
4407         nfs_invalidate_atime(dir);
4408
4409         dprintk("%s: returns %d\n", __func__, status);
4410         return status;
4411 }
4412
4413 static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
4414                 u64 cookie, struct page **pages, unsigned int count, int plus)
4415 {
4416         struct nfs4_exception exception = { };
4417         int err;
4418         do {
4419                 err = _nfs4_proc_readdir(dentry, cred, cookie,
4420                                 pages, count, plus);
4421                 trace_nfs4_readdir(d_inode(dentry), err);
4422                 err = nfs4_handle_exception(NFS_SERVER(d_inode(dentry)), err,
4423                                 &exception);
4424         } while (exception.retry);
4425         return err;
4426 }
4427
4428 static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
4429                 struct iattr *sattr, struct nfs4_label *label, dev_t rdev)
4430 {
4431         struct nfs4_createdata *data;
4432         int mode = sattr->ia_mode;
4433         int status = -ENOMEM;
4434
4435         data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK);
4436         if (data == NULL)
4437                 goto out;
4438
4439         if (S_ISFIFO(mode))
4440                 data->arg.ftype = NF4FIFO;
4441         else if (S_ISBLK(mode)) {
4442                 data->arg.ftype = NF4BLK;
4443                 data->arg.u.device.specdata1 = MAJOR(rdev);
4444                 data->arg.u.device.specdata2 = MINOR(rdev);
4445         }
4446         else if (S_ISCHR(mode)) {
4447                 data->arg.ftype = NF4CHR;
4448                 data->arg.u.device.specdata1 = MAJOR(rdev);
4449                 data->arg.u.device.specdata2 = MINOR(rdev);
4450         } else if (!S_ISSOCK(mode)) {
4451                 status = -EINVAL;
4452                 goto out_free;
4453         }
4454
4455         data->arg.label = label;
4456         status = nfs4_do_create(dir, dentry, data);
4457 out_free:
4458         nfs4_free_createdata(data);
4459 out:
4460         return status;
4461 }
4462
4463 static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
4464                 struct iattr *sattr, dev_t rdev)
4465 {
4466         struct nfs_server *server = NFS_SERVER(dir);
4467         struct nfs4_exception exception = { };
4468         struct nfs4_label l, *label = NULL;
4469         int err;
4470
4471         label = nfs4_label_init_security(dir, dentry, sattr, &l);
4472
4473         if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
4474                 sattr->ia_mode &= ~current_umask();
4475         do {
4476                 err = _nfs4_proc_mknod(dir, dentry, sattr, label, rdev);
4477                 trace_nfs4_mknod(dir, &dentry->d_name, err);
4478                 err = nfs4_handle_exception(NFS_SERVER(dir), err,
4479                                 &exception);
4480         } while (exception.retry);
4481
4482         nfs4_label_release_security(label);
4483
4484         return err;
4485 }
4486
4487 static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
4488                  struct nfs_fsstat *fsstat)
4489 {
4490         struct nfs4_statfs_arg args = {
4491                 .fh = fhandle,
4492                 .bitmask = server->attr_bitmask,
4493         };
4494         struct nfs4_statfs_res res = {
4495                 .fsstat = fsstat,
4496         };
4497         struct rpc_message msg = {
4498                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS],
4499                 .rpc_argp = &args,
4500                 .rpc_resp = &res,
4501         };
4502
4503         nfs_fattr_init(fsstat->fattr);
4504         return  nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
4505 }
4506
4507 static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat)
4508 {
4509         struct nfs4_exception exception = { };
4510         int err;
4511         do {
4512                 err = nfs4_handle_exception(server,
4513                                 _nfs4_proc_statfs(server, fhandle, fsstat),
4514                                 &exception);
4515         } while (exception.retry);
4516         return err;
4517 }
4518
4519 static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
4520                 struct nfs_fsinfo *fsinfo)
4521 {
4522         struct nfs4_fsinfo_arg args = {
4523                 .fh = fhandle,
4524                 .bitmask = server->attr_bitmask,
4525         };
4526         struct nfs4_fsinfo_res res = {
4527                 .fsinfo = fsinfo,
4528         };
4529         struct rpc_message msg = {
4530                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO],
4531                 .rpc_argp = &args,
4532                 .rpc_resp = &res,
4533         };
4534
4535         return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
4536 }
4537
4538 static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
4539 {
4540         struct nfs4_exception exception = { };
4541         unsigned long now = jiffies;
4542         int err;
4543
4544         do {
4545                 err = _nfs4_do_fsinfo(server, fhandle, fsinfo);
4546                 trace_nfs4_fsinfo(server, fhandle, fsinfo->fattr, err);
4547                 if (err == 0) {
4548                         nfs4_set_lease_period(server->nfs_client,
4549                                         fsinfo->lease_time * HZ,
4550                                         now);
4551                         break;
4552                 }
4553                 err = nfs4_handle_exception(server, err, &exception);
4554         } while (exception.retry);
4555         return err;
4556 }
4557
4558 static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
4559 {
4560         int error;
4561
4562         nfs_fattr_init(fsinfo->fattr);
4563         error = nfs4_do_fsinfo(server, fhandle, fsinfo);
4564         if (error == 0) {
4565                 /* block layout checks this! */
4566                 server->pnfs_blksize = fsinfo->blksize;
4567                 set_pnfs_layoutdriver(server, fhandle, fsinfo);
4568         }
4569
4570         return error;
4571 }
4572
4573 static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
4574                 struct nfs_pathconf *pathconf)
4575 {
4576         struct nfs4_pathconf_arg args = {
4577                 .fh = fhandle,
4578                 .bitmask = server->attr_bitmask,
4579         };
4580         struct nfs4_pathconf_res res = {
4581                 .pathconf = pathconf,
4582         };
4583         struct rpc_message msg = {
4584                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF],
4585                 .rpc_argp = &args,
4586                 .rpc_resp = &res,
4587         };
4588
4589         /* None of the pathconf attributes are mandatory to implement */
4590         if ((args.bitmask[0] & nfs4_pathconf_bitmap[0]) == 0) {
4591                 memset(pathconf, 0, sizeof(*pathconf));
4592                 return 0;
4593         }
4594
4595         nfs_fattr_init(pathconf->fattr);
4596         return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
4597 }
4598
4599 static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
4600                 struct nfs_pathconf *pathconf)
4601 {
4602         struct nfs4_exception exception = { };
4603         int err;
4604
4605         do {
4606                 err = nfs4_handle_exception(server,
4607                                 _nfs4_proc_pathconf(server, fhandle, pathconf),
4608                                 &exception);
4609         } while (exception.retry);
4610         return err;
4611 }
4612
4613 int nfs4_set_rw_stateid(nfs4_stateid *stateid,
4614                 const struct nfs_open_context *ctx,
4615                 const struct nfs_lock_context *l_ctx,
4616                 fmode_t fmode)
4617 {
4618         return nfs4_select_rw_stateid(ctx->state, fmode, l_ctx, stateid, NULL);
4619 }
4620 EXPORT_SYMBOL_GPL(nfs4_set_rw_stateid);
4621
4622 static bool nfs4_stateid_is_current(nfs4_stateid *stateid,
4623                 const struct nfs_open_context *ctx,
4624                 const struct nfs_lock_context *l_ctx,
4625                 fmode_t fmode)
4626 {
4627         nfs4_stateid current_stateid;
4628
4629         /* If the current stateid represents a lost lock, then exit */
4630         if (nfs4_set_rw_stateid(&current_stateid, ctx, l_ctx, fmode) == -EIO)
4631                 return true;
4632         return nfs4_stateid_match(stateid, &current_stateid);
4633 }
4634
4635 static bool nfs4_error_stateid_expired(int err)
4636 {
4637         switch (err) {
4638         case -NFS4ERR_DELEG_REVOKED:
4639         case -NFS4ERR_ADMIN_REVOKED:
4640         case -NFS4ERR_BAD_STATEID:
4641         case -NFS4ERR_STALE_STATEID:
4642         case -NFS4ERR_OLD_STATEID:
4643         case -NFS4ERR_OPENMODE:
4644         case -NFS4ERR_EXPIRED:
4645                 return true;
4646         }
4647         return false;
4648 }
4649
4650 static int nfs4_read_done_cb(struct rpc_task *task, struct nfs_pgio_header *hdr)
4651 {
4652         struct nfs_server *server = NFS_SERVER(hdr->inode);
4653
4654         trace_nfs4_read(hdr, task->tk_status);
4655         if (task->tk_status < 0) {
4656                 struct nfs4_exception exception = {
4657                         .inode = hdr->inode,
4658                         .state = hdr->args.context->state,
4659                         .stateid = &hdr->args.stateid,
4660                 };
4661                 task->tk_status = nfs4_async_handle_exception(task,
4662                                 server, task->tk_status, &exception);
4663                 if (exception.retry) {
4664                         rpc_restart_call_prepare(task);
4665                         return -EAGAIN;
4666                 }
4667         }
4668
4669         if (task->tk_status > 0)
4670                 renew_lease(server, hdr->timestamp);
4671         return 0;
4672 }
4673
4674 static bool nfs4_read_stateid_changed(struct rpc_task *task,
4675                 struct nfs_pgio_args *args)
4676 {
4677
4678         if (!nfs4_error_stateid_expired(task->tk_status) ||
4679                 nfs4_stateid_is_current(&args->stateid,
4680                                 args->context,
4681                                 args->lock_context,
4682                                 FMODE_READ))
4683                 return false;
4684         rpc_restart_call_prepare(task);
4685         return true;
4686 }
4687
4688 static int nfs4_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
4689 {
4690
4691         dprintk("--> %s\n", __func__);
4692
4693         if (!nfs4_sequence_done(task, &hdr->res.seq_res))
4694                 return -EAGAIN;
4695         if (nfs4_read_stateid_changed(task, &hdr->args))
4696                 return -EAGAIN;
4697         if (task->tk_status > 0)
4698                 nfs_invalidate_atime(hdr->inode);
4699         return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) :
4700                                     nfs4_read_done_cb(task, hdr);
4701 }
4702
4703 static void nfs4_proc_read_setup(struct nfs_pgio_header *hdr,
4704                                  struct rpc_message *msg)
4705 {
4706         hdr->timestamp   = jiffies;
4707         if (!hdr->pgio_done_cb)
4708                 hdr->pgio_done_cb = nfs4_read_done_cb;
4709         msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ];
4710         nfs4_init_sequence(&hdr->args.seq_args, &hdr->res.seq_res, 0);
4711 }
4712
4713 static int nfs4_proc_pgio_rpc_prepare(struct rpc_task *task,
4714                                       struct nfs_pgio_header *hdr)
4715 {
4716         if (nfs4_setup_sequence(NFS_SERVER(hdr->inode),
4717                         &hdr->args.seq_args,
4718                         &hdr->res.seq_res,
4719                         task))
4720                 return 0;
4721         if (nfs4_set_rw_stateid(&hdr->args.stateid, hdr->args.context,
4722                                 hdr->args.lock_context,
4723                                 hdr->rw_ops->rw_mode) == -EIO)
4724                 return -EIO;
4725         if (unlikely(test_bit(NFS_CONTEXT_BAD, &hdr->args.context->flags)))
4726                 return -EIO;
4727         return 0;
4728 }
4729
4730 static int nfs4_write_done_cb(struct rpc_task *task,
4731                               struct nfs_pgio_header *hdr)
4732 {
4733         struct inode *inode = hdr->inode;
4734
4735         trace_nfs4_write(hdr, task->tk_status);
4736         if (task->tk_status < 0) {
4737                 struct nfs4_exception exception = {
4738                         .inode = hdr->inode,
4739                         .state = hdr->args.context->state,
4740                         .stateid = &hdr->args.stateid,
4741                 };
4742                 task->tk_status = nfs4_async_handle_exception(task,
4743                                 NFS_SERVER(inode), task->tk_status,
4744                                 &exception);
4745                 if (exception.retry) {
4746                         rpc_restart_call_prepare(task);
4747                         return -EAGAIN;
4748                 }
4749         }
4750         if (task->tk_status >= 0) {
4751                 renew_lease(NFS_SERVER(inode), hdr->timestamp);
4752                 nfs_writeback_update_inode(hdr);
4753         }
4754         return 0;
4755 }
4756
4757 static bool nfs4_write_stateid_changed(struct rpc_task *task,
4758                 struct nfs_pgio_args *args)
4759 {
4760
4761         if (!nfs4_error_stateid_expired(task->tk_status) ||
4762                 nfs4_stateid_is_current(&args->stateid,
4763                                 args->context,
4764                                 args->lock_context,
4765                                 FMODE_WRITE))
4766                 return false;
4767         rpc_restart_call_prepare(task);
4768         return true;
4769 }
4770
4771 static int nfs4_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
4772 {
4773         if (!nfs4_sequence_done(task, &hdr->res.seq_res))
4774                 return -EAGAIN;
4775         if (nfs4_write_stateid_changed(task, &hdr->args))
4776                 return -EAGAIN;
4777         return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) :
4778                 nfs4_write_done_cb(task, hdr);
4779 }
4780
4781 static
4782 bool nfs4_write_need_cache_consistency_data(struct nfs_pgio_header *hdr)
4783 {
4784         /* Don't request attributes for pNFS or O_DIRECT writes */
4785         if (hdr->ds_clp != NULL || hdr->dreq != NULL)
4786                 return false;
4787         /* Otherwise, request attributes if and only if we don't hold
4788          * a delegation
4789          */
4790         return nfs4_have_delegation(hdr->inode, FMODE_READ) == 0;
4791 }
4792
4793 static void nfs4_proc_write_setup(struct nfs_pgio_header *hdr,
4794                                   struct rpc_message *msg)
4795 {
4796         struct nfs_server *server = NFS_SERVER(hdr->inode);
4797
4798         if (!nfs4_write_need_cache_consistency_data(hdr)) {
4799                 hdr->args.bitmask = NULL;
4800                 hdr->res.fattr = NULL;
4801         } else
4802                 hdr->args.bitmask = server->cache_consistency_bitmask;
4803
4804         if (!hdr->pgio_done_cb)
4805                 hdr->pgio_done_cb = nfs4_write_done_cb;
4806         hdr->res.server = server;
4807         hdr->timestamp   = jiffies;
4808
4809         msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE];
4810         nfs4_init_sequence(&hdr->args.seq_args, &hdr->res.seq_res, 1);
4811 }
4812
4813 static void nfs4_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
4814 {
4815         nfs4_setup_sequence(NFS_SERVER(data->inode),
4816                         &data->args.seq_args,
4817                         &data->res.seq_res,
4818                         task);
4819 }
4820
4821 static int nfs4_commit_done_cb(struct rpc_task *task, struct nfs_commit_data *data)
4822 {
4823         struct inode *inode = data->inode;
4824
4825         trace_nfs4_commit(data, task->tk_status);
4826         if (nfs4_async_handle_error(task, NFS_SERVER(inode),
4827                                     NULL, NULL) == -EAGAIN) {
4828                 rpc_restart_call_prepare(task);
4829                 return -EAGAIN;
4830         }
4831         return 0;
4832 }
4833
4834 static int nfs4_commit_done(struct rpc_task *task, struct nfs_commit_data *data)
4835 {
4836         if (!nfs4_sequence_done(task, &data->res.seq_res))
4837                 return -EAGAIN;
4838         return data->commit_done_cb(task, data);
4839 }
4840
4841 static void nfs4_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
4842 {
4843         struct nfs_server *server = NFS_SERVER(data->inode);
4844
4845         if (data->commit_done_cb == NULL)
4846                 data->commit_done_cb = nfs4_commit_done_cb;
4847         data->res.server = server;
4848         msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT];
4849         nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
4850 }
4851
4852 struct nfs4_renewdata {
4853         struct nfs_client       *client;
4854         unsigned long           timestamp;
4855 };
4856
4857 /*
4858  * nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special
4859  * standalone procedure for queueing an asynchronous RENEW.
4860  */
4861 static void nfs4_renew_release(void *calldata)
4862 {
4863         struct nfs4_renewdata *data = calldata;
4864         struct nfs_client *clp = data->client;
4865
4866         if (atomic_read(&clp->cl_count) > 1)
4867                 nfs4_schedule_state_renewal(clp);
4868         nfs_put_client(clp);
4869         kfree(data);
4870 }
4871
4872 static void nfs4_renew_done(struct rpc_task *task, void *calldata)
4873 {
4874         struct nfs4_renewdata *data = calldata;
4875         struct nfs_client *clp = data->client;
4876         unsigned long timestamp = data->timestamp;
4877
4878         trace_nfs4_renew_async(clp, task->tk_status);
4879         switch (task->tk_status) {
4880         case 0:
4881                 break;
4882         case -NFS4ERR_LEASE_MOVED:
4883                 nfs4_schedule_lease_moved_recovery(clp);
4884                 break;
4885         default:
4886                 /* Unless we're shutting down, schedule state recovery! */
4887                 if (test_bit(NFS_CS_RENEWD, &clp->cl_res_state) == 0)
4888                         return;
4889                 if (task->tk_status != NFS4ERR_CB_PATH_DOWN) {
4890                         nfs4_schedule_lease_recovery(clp);
4891                         return;
4892                 }
4893                 nfs4_schedule_path_down_recovery(clp);
4894         }
4895         do_renew_lease(clp, timestamp);
4896 }
4897
4898 static const struct rpc_call_ops nfs4_renew_ops = {
4899         .rpc_call_done = nfs4_renew_done,
4900         .rpc_release = nfs4_renew_release,
4901 };
4902
4903 static int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags)
4904 {
4905         struct rpc_message msg = {
4906                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
4907                 .rpc_argp       = clp,
4908                 .rpc_cred       = cred,
4909         };
4910         struct nfs4_renewdata *data;
4911
4912         if (renew_flags == 0)
4913                 return 0;
4914         if (!atomic_inc_not_zero(&clp->cl_count))
4915                 return -EIO;
4916         data = kmalloc(sizeof(*data), GFP_NOFS);
4917         if (data == NULL)
4918                 return -ENOMEM;
4919         data->client = clp;
4920         data->timestamp = jiffies;
4921         return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT,
4922                         &nfs4_renew_ops, data);
4923 }
4924
4925 static int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred)
4926 {
4927         struct rpc_message msg = {
4928                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
4929                 .rpc_argp       = clp,
4930                 .rpc_cred       = cred,
4931         };
4932         unsigned long now = jiffies;
4933         int status;
4934
4935         status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
4936         if (status < 0)
4937                 return status;
4938         do_renew_lease(clp, now);
4939         return 0;
4940 }
4941
4942 static inline int nfs4_server_supports_acls(struct nfs_server *server)
4943 {
4944         return server->caps & NFS_CAP_ACLS;
4945 }
4946
4947 /* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_SIZE, and that
4948  * it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_SIZE) bytes on
4949  * the stack.
4950  */
4951 #define NFS4ACL_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE)
4952
4953 static int buf_to_pages_noslab(const void *buf, size_t buflen,
4954                 struct page **pages)
4955 {
4956         struct page *newpage, **spages;
4957         int rc = 0;
4958         size_t len;
4959         spages = pages;
4960
4961         do {
4962                 len = min_t(size_t, PAGE_SIZE, buflen);
4963                 newpage = alloc_page(GFP_KERNEL);
4964
4965                 if (newpage == NULL)
4966                         goto unwind;
4967                 memcpy(page_address(newpage), buf, len);
4968                 buf += len;
4969                 buflen -= len;
4970                 *pages++ = newpage;
4971                 rc++;
4972         } while (buflen != 0);
4973
4974         return rc;
4975
4976 unwind:
4977         for(; rc > 0; rc--)
4978                 __free_page(spages[rc-1]);
4979         return -ENOMEM;
4980 }
4981
4982 struct nfs4_cached_acl {
4983         int cached;
4984         size_t len;
4985         char data[0];
4986 };
4987
4988 static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl)
4989 {
4990         struct nfs_inode *nfsi = NFS_I(inode);
4991
4992         spin_lock(&inode->i_lock);
4993         kfree(nfsi->nfs4_acl);
4994         nfsi->nfs4_acl = acl;
4995         spin_unlock(&inode->i_lock);
4996 }
4997
4998 static void nfs4_zap_acl_attr(struct inode *inode)
4999 {
5000         nfs4_set_cached_acl(inode, NULL);
5001 }
5002
5003 static inline ssize_t nfs4_read_cached_acl(struct inode *inode, char *buf, size_t buflen)
5004 {
5005         struct nfs_inode *nfsi = NFS_I(inode);
5006         struct nfs4_cached_acl *acl;
5007         int ret = -ENOENT;
5008
5009         spin_lock(&inode->i_lock);
5010         acl = nfsi->nfs4_acl;
5011         if (acl == NULL)
5012                 goto out;
5013         if (buf == NULL) /* user is just asking for length */
5014                 goto out_len;
5015         if (acl->cached == 0)
5016                 goto out;
5017         ret = -ERANGE; /* see getxattr(2) man page */
5018         if (acl->len > buflen)
5019                 goto out;
5020         memcpy(buf, acl->data, acl->len);
5021 out_len:
5022         ret = acl->len;
5023 out:
5024         spin_unlock(&inode->i_lock);
5025         return ret;
5026 }
5027
5028 static void nfs4_write_cached_acl(struct inode *inode, struct page **pages, size_t pgbase, size_t acl_len)
5029 {
5030         struct nfs4_cached_acl *acl;
5031         size_t buflen = sizeof(*acl) + acl_len;
5032
5033         if (buflen <= PAGE_SIZE) {
5034                 acl = kmalloc(buflen, GFP_KERNEL);
5035                 if (acl == NULL)
5036                         goto out;
5037                 acl->cached = 1;
5038                 _copy_from_pages(acl->data, pages, pgbase, acl_len);
5039         } else {
5040                 acl = kmalloc(sizeof(*acl), GFP_KERNEL);
5041                 if (acl == NULL)
5042                         goto out;
5043                 acl->cached = 0;
5044         }
5045         acl->len = acl_len;
5046 out:
5047         nfs4_set_cached_acl(inode, acl);
5048 }
5049
5050 /*
5051  * The getxattr API returns the required buffer length when called with a
5052  * NULL buf. The NFSv4 acl tool then calls getxattr again after allocating
5053  * the required buf.  On a NULL buf, we send a page of data to the server
5054  * guessing that the ACL request can be serviced by a page. If so, we cache
5055  * up to the page of ACL data, and the 2nd call to getxattr is serviced by
5056  * the cache. If not so, we throw away the page, and cache the required
5057  * length. The next getxattr call will then produce another round trip to
5058  * the server, this time with the input buf of the required size.
5059  */
5060 static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
5061 {
5062         struct page *pages[NFS4ACL_MAXPAGES] = {NULL, };
5063         struct nfs_getaclargs args = {
5064                 .fh = NFS_FH(inode),
5065                 .acl_pages = pages,
5066                 .acl_len = buflen,
5067         };
5068         struct nfs_getaclres res = {
5069                 .acl_len = buflen,
5070         };
5071         struct rpc_message msg = {
5072                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL],
5073                 .rpc_argp = &args,
5074                 .rpc_resp = &res,
5075         };
5076         unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE);
5077         int ret = -ENOMEM, i;
5078
5079         /* As long as we're doing a round trip to the server anyway,
5080          * let's be prepared for a page of acl data. */
5081         if (npages == 0)
5082                 npages = 1;
5083         if (npages > ARRAY_SIZE(pages))
5084                 return -ERANGE;
5085
5086         for (i = 0; i < npages; i++) {
5087                 pages[i] = alloc_page(GFP_KERNEL);
5088                 if (!pages[i])
5089                         goto out_free;
5090         }
5091
5092         /* for decoding across pages */
5093         res.acl_scratch = alloc_page(GFP_KERNEL);
5094         if (!res.acl_scratch)
5095                 goto out_free;
5096
5097         args.acl_len = npages * PAGE_SIZE;
5098
5099         dprintk("%s  buf %p buflen %zu npages %d args.acl_len %zu\n",
5100                 __func__, buf, buflen, npages, args.acl_len);
5101         ret = nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode),
5102                              &msg, &args.seq_args, &res.seq_res, 0);
5103         if (ret)
5104                 goto out_free;
5105
5106         /* Handle the case where the passed-in buffer is too short */
5107         if (res.acl_flags & NFS4_ACL_TRUNC) {
5108                 /* Did the user only issue a request for the acl length? */
5109                 if (buf == NULL)
5110                         goto out_ok;
5111                 ret = -ERANGE;
5112                 goto out_free;
5113         }
5114         nfs4_write_cached_acl(inode, pages, res.acl_data_offset, res.acl_len);
5115         if (buf) {
5116                 if (res.acl_len > buflen) {
5117                         ret = -ERANGE;
5118                         goto out_free;
5119                 }
5120                 _copy_from_pages(buf, pages, res.acl_data_offset, res.acl_len);
5121         }
5122 out_ok:
5123         ret = res.acl_len;
5124 out_free:
5125         for (i = 0; i < npages; i++)
5126                 if (pages[i])
5127                         __free_page(pages[i]);
5128         if (res.acl_scratch)
5129                 __free_page(res.acl_scratch);
5130         return ret;
5131 }
5132
5133 static ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
5134 {
5135         struct nfs4_exception exception = { };
5136         ssize_t ret;
5137         do {
5138                 ret = __nfs4_get_acl_uncached(inode, buf, buflen);
5139                 trace_nfs4_get_acl(inode, ret);
5140                 if (ret >= 0)
5141                         break;
5142                 ret = nfs4_handle_exception(NFS_SERVER(inode), ret, &exception);
5143         } while (exception.retry);
5144         return ret;
5145 }
5146
5147 static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen)
5148 {
5149         struct nfs_server *server = NFS_SERVER(inode);
5150         int ret;
5151
5152         if (!nfs4_server_supports_acls(server))
5153                 return -EOPNOTSUPP;
5154         ret = nfs_revalidate_inode(server, inode);
5155         if (ret < 0)
5156                 return ret;
5157         if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL)
5158                 nfs_zap_acl_cache(inode);
5159         ret = nfs4_read_cached_acl(inode, buf, buflen);
5160         if (ret != -ENOENT)
5161                 /* -ENOENT is returned if there is no ACL or if there is an ACL
5162                  * but no cached acl data, just the acl length */
5163                 return ret;
5164         return nfs4_get_acl_uncached(inode, buf, buflen);
5165 }
5166
5167 static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
5168 {
5169         struct nfs_server *server = NFS_SERVER(inode);
5170         struct page *pages[NFS4ACL_MAXPAGES];
5171         struct nfs_setaclargs arg = {
5172                 .fh             = NFS_FH(inode),
5173                 .acl_pages      = pages,
5174                 .acl_len        = buflen,
5175         };
5176         struct nfs_setaclres res;
5177         struct rpc_message msg = {
5178                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_SETACL],
5179                 .rpc_argp       = &arg,
5180                 .rpc_resp       = &res,
5181         };
5182         unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE);
5183         int ret, i;
5184
5185         if (!nfs4_server_supports_acls(server))
5186                 return -EOPNOTSUPP;
5187         if (npages > ARRAY_SIZE(pages))
5188                 return -ERANGE;
5189         i = buf_to_pages_noslab(buf, buflen, arg.acl_pages);
5190         if (i < 0)
5191                 return i;
5192         nfs4_inode_return_delegation(inode);
5193         ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
5194
5195         /*
5196          * Free each page after tx, so the only ref left is
5197          * held by the network stack
5198          */
5199         for (; i > 0; i--)
5200                 put_page(pages[i-1]);
5201
5202         /*
5203          * Acl update can result in inode attribute update.
5204          * so mark the attribute cache invalid.
5205          */
5206         spin_lock(&inode->i_lock);
5207         NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR;
5208         spin_unlock(&inode->i_lock);
5209         nfs_access_zap_cache(inode);
5210         nfs_zap_acl_cache(inode);
5211         return ret;
5212 }
5213
5214 static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
5215 {
5216         struct nfs4_exception exception = { };
5217         int err;
5218         do {
5219                 err = __nfs4_proc_set_acl(inode, buf, buflen);
5220                 trace_nfs4_set_acl(inode, err);
5221                 err = nfs4_handle_exception(NFS_SERVER(inode), err,
5222                                 &exception);
5223         } while (exception.retry);
5224         return err;
5225 }
5226
5227 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
5228 static int _nfs4_get_security_label(struct inode *inode, void *buf,
5229                                         size_t buflen)
5230 {
5231         struct nfs_server *server = NFS_SERVER(inode);
5232         struct nfs_fattr fattr;
5233         struct nfs4_label label = {0, 0, buflen, buf};
5234
5235         u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL };
5236         struct nfs4_getattr_arg arg = {
5237                 .fh             = NFS_FH(inode),
5238                 .bitmask        = bitmask,
5239         };
5240         struct nfs4_getattr_res res = {
5241                 .fattr          = &fattr,
5242                 .label          = &label,
5243                 .server         = server,
5244         };
5245         struct rpc_message msg = {
5246                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
5247                 .rpc_argp       = &arg,
5248                 .rpc_resp       = &res,
5249         };
5250         int ret;
5251
5252         nfs_fattr_init(&fattr);
5253
5254         ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 0);
5255         if (ret)
5256                 return ret;
5257         if (!(fattr.valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL))
5258                 return -ENOENT;
5259         if (buflen < label.len)
5260                 return -ERANGE;
5261         return 0;
5262 }
5263
5264 static int nfs4_get_security_label(struct inode *inode, void *buf,
5265                                         size_t buflen)
5266 {
5267         struct nfs4_exception exception = { };
5268         int err;
5269
5270         if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
5271                 return -EOPNOTSUPP;
5272
5273         do {
5274                 err = _nfs4_get_security_label(inode, buf, buflen);
5275                 trace_nfs4_get_security_label(inode, err);
5276                 err = nfs4_handle_exception(NFS_SERVER(inode), err,
5277                                 &exception);
5278         } while (exception.retry);
5279         return err;
5280 }
5281
5282 static int _nfs4_do_set_security_label(struct inode *inode,
5283                 struct nfs4_label *ilabel,
5284                 struct nfs_fattr *fattr,
5285                 struct nfs4_label *olabel)
5286 {
5287
5288         struct iattr sattr = {0};
5289         struct nfs_server *server = NFS_SERVER(inode);
5290         const u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL };
5291         struct nfs_setattrargs arg = {
5292                 .fh             = NFS_FH(inode),
5293                 .iap            = &sattr,
5294                 .server         = server,
5295                 .bitmask        = bitmask,
5296                 .label          = ilabel,
5297         };
5298         struct nfs_setattrres res = {
5299                 .fattr          = fattr,
5300                 .label          = olabel,
5301                 .server         = server,
5302         };
5303         struct rpc_message msg = {
5304                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
5305                 .rpc_argp       = &arg,
5306                 .rpc_resp       = &res,
5307         };
5308         int status;
5309
5310         nfs4_stateid_copy(&arg.stateid, &zero_stateid);
5311
5312         status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
5313         if (status)
5314                 dprintk("%s failed: %d\n", __func__, status);
5315
5316         return status;
5317 }
5318
5319 static int nfs4_do_set_security_label(struct inode *inode,
5320                 struct nfs4_label *ilabel,
5321                 struct nfs_fattr *fattr,
5322                 struct nfs4_label *olabel)
5323 {
5324         struct nfs4_exception exception = { };
5325         int err;
5326
5327         do {
5328                 err = _nfs4_do_set_security_label(inode, ilabel,
5329                                 fattr, olabel);
5330                 trace_nfs4_set_security_label(inode, err);
5331                 err = nfs4_handle_exception(NFS_SERVER(inode), err,
5332                                 &exception);
5333         } while (exception.retry);
5334         return err;
5335 }
5336
5337 static int
5338 nfs4_set_security_label(struct inode *inode, const void *buf, size_t buflen)
5339 {
5340         struct nfs4_label ilabel, *olabel = NULL;
5341         struct nfs_fattr fattr;
5342         struct rpc_cred *cred;
5343         int status;
5344
5345         if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
5346                 return -EOPNOTSUPP;
5347
5348         nfs_fattr_init(&fattr);
5349
5350         ilabel.pi = 0;
5351         ilabel.lfs = 0;
5352         ilabel.label = (char *)buf;
5353         ilabel.len = buflen;
5354
5355         cred = rpc_lookup_cred();
5356         if (IS_ERR(cred))
5357                 return PTR_ERR(cred);
5358
5359         olabel = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
5360         if (IS_ERR(olabel)) {
5361                 status = -PTR_ERR(olabel);
5362                 goto out;
5363         }
5364
5365         status = nfs4_do_set_security_label(inode, &ilabel, &fattr, olabel);
5366         if (status == 0)
5367                 nfs_setsecurity(inode, &fattr, olabel);
5368
5369         nfs4_label_free(olabel);
5370 out:
5371         put_rpccred(cred);
5372         return status;
5373 }
5374 #endif  /* CONFIG_NFS_V4_SECURITY_LABEL */
5375
5376
5377 static void nfs4_init_boot_verifier(const struct nfs_client *clp,
5378                                     nfs4_verifier *bootverf)
5379 {
5380         __be32 verf[2];
5381
5382         if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
5383                 /* An impossible timestamp guarantees this value
5384                  * will never match a generated boot time. */
5385                 verf[0] = cpu_to_be32(U32_MAX);
5386                 verf[1] = cpu_to_be32(U32_MAX);
5387         } else {
5388                 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
5389                 u64 ns = ktime_to_ns(nn->boot_time);
5390
5391                 verf[0] = cpu_to_be32(ns >> 32);
5392                 verf[1] = cpu_to_be32(ns);
5393         }
5394         memcpy(bootverf->data, verf, sizeof(bootverf->data));
5395 }
5396
5397 static int
5398 nfs4_init_nonuniform_client_string(struct nfs_client *clp)
5399 {
5400         size_t len;
5401         char *str;
5402
5403         if (clp->cl_owner_id != NULL)
5404                 return 0;
5405
5406         rcu_read_lock();
5407         len = 14 + strlen(clp->cl_ipaddr) + 1 +
5408                 strlen(rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR)) +
5409                 1 +
5410                 strlen(rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_PROTO)) +
5411                 1;
5412         rcu_read_unlock();
5413
5414         if (len > NFS4_OPAQUE_LIMIT + 1)
5415                 return -EINVAL;
5416
5417         /*
5418          * Since this string is allocated at mount time, and held until the
5419          * nfs_client is destroyed, we can use GFP_KERNEL here w/o worrying
5420          * about a memory-reclaim deadlock.
5421          */
5422         str = kmalloc(len, GFP_KERNEL);
5423         if (!str)
5424                 return -ENOMEM;
5425
5426         rcu_read_lock();
5427         scnprintf(str, len, "Linux NFSv4.0 %s/%s %s",
5428                         clp->cl_ipaddr,
5429                         rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR),
5430                         rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_PROTO));
5431         rcu_read_unlock();
5432
5433         clp->cl_owner_id = str;
5434         return 0;
5435 }
5436
5437 static int
5438 nfs4_init_uniquifier_client_string(struct nfs_client *clp)
5439 {
5440         size_t len;
5441         char *str;
5442
5443         len = 10 + 10 + 1 + 10 + 1 +
5444                 strlen(nfs4_client_id_uniquifier) + 1 +
5445                 strlen(clp->cl_rpcclient->cl_nodename) + 1;
5446
5447         if (len > NFS4_OPAQUE_LIMIT + 1)
5448                 return -EINVAL;
5449
5450         /*
5451          * Since this string is allocated at mount time, and held until the
5452          * nfs_client is destroyed, we can use GFP_KERNEL here w/o worrying
5453          * about a memory-reclaim deadlock.
5454          */
5455         str = kmalloc(len, GFP_KERNEL);
5456         if (!str)
5457                 return -ENOMEM;
5458
5459         scnprintf(str, len, "Linux NFSv%u.%u %s/%s",
5460                         clp->rpc_ops->version, clp->cl_minorversion,
5461                         nfs4_client_id_uniquifier,
5462                         clp->cl_rpcclient->cl_nodename);
5463         clp->cl_owner_id = str;
5464         return 0;
5465 }
5466
5467 static int
5468 nfs4_init_uniform_client_string(struct nfs_client *clp)
5469 {
5470         size_t len;
5471         char *str;
5472
5473         if (clp->cl_owner_id != NULL)
5474                 return 0;
5475
5476         if (nfs4_client_id_uniquifier[0] != '\0')
5477                 return nfs4_init_uniquifier_client_string(clp);
5478
5479         len = 10 + 10 + 1 + 10 + 1 +
5480                 strlen(clp->cl_rpcclient->cl_nodename) + 1;
5481
5482         if (len > NFS4_OPAQUE_LIMIT + 1)
5483                 return -EINVAL;
5484
5485         /*
5486          * Since this string is allocated at mount time, and held until the
5487          * nfs_client is destroyed, we can use GFP_KERNEL here w/o worrying
5488          * about a memory-reclaim deadlock.
5489          */
5490         str = kmalloc(len, GFP_KERNEL);
5491         if (!str)
5492                 return -ENOMEM;
5493
5494         scnprintf(str, len, "Linux NFSv%u.%u %s",
5495                         clp->rpc_ops->version, clp->cl_minorversion,
5496                         clp->cl_rpcclient->cl_nodename);
5497         clp->cl_owner_id = str;
5498         return 0;
5499 }
5500
5501 /*
5502  * nfs4_callback_up_net() starts only "tcp" and "tcp6" callback
5503  * services.  Advertise one based on the address family of the
5504  * clientaddr.
5505  */
5506 static unsigned int
5507 nfs4_init_callback_netid(const struct nfs_client *clp, char *buf, size_t len)
5508 {
5509         if (strchr(clp->cl_ipaddr, ':') != NULL)
5510                 return scnprintf(buf, len, "tcp6");
5511         else
5512                 return scnprintf(buf, len, "tcp");
5513 }
5514
5515 static void nfs4_setclientid_done(struct rpc_task *task, void *calldata)
5516 {
5517         struct nfs4_setclientid *sc = calldata;
5518
5519         if (task->tk_status == 0)
5520                 sc->sc_cred = get_rpccred(task->tk_rqstp->rq_cred);
5521 }
5522
5523 static const struct rpc_call_ops nfs4_setclientid_ops = {
5524         .rpc_call_done = nfs4_setclientid_done,
5525 };
5526
5527 /**
5528  * nfs4_proc_setclientid - Negotiate client ID
5529  * @clp: state data structure
5530  * @program: RPC program for NFSv4 callback service
5531  * @port: IP port number for NFS4 callback service
5532  * @cred: RPC credential to use for this call
5533  * @res: where to place the result
5534  *
5535  * Returns zero, a negative errno, or a negative NFS4ERR status code.
5536  */
5537 int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,
5538                 unsigned short port, struct rpc_cred *cred,
5539                 struct nfs4_setclientid_res *res)
5540 {
5541         nfs4_verifier sc_verifier;
5542         struct nfs4_setclientid setclientid = {
5543                 .sc_verifier = &sc_verifier,
5544                 .sc_prog = program,
5545                 .sc_clnt = clp,
5546         };
5547         struct rpc_message msg = {
5548                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID],
5549                 .rpc_argp = &setclientid,
5550                 .rpc_resp = res,
5551                 .rpc_cred = cred,
5552         };
5553         struct rpc_task *task;
5554         struct rpc_task_setup task_setup_data = {
5555                 .rpc_client = clp->cl_rpcclient,
5556                 .rpc_message = &msg,
5557                 .callback_ops = &nfs4_setclientid_ops,
5558                 .callback_data = &setclientid,
5559                 .flags = RPC_TASK_TIMEOUT,
5560         };
5561         int status;
5562
5563         /* nfs_client_id4 */
5564         nfs4_init_boot_verifier(clp, &sc_verifier);
5565
5566         if (test_bit(NFS_CS_MIGRATION, &clp->cl_flags))
5567                 status = nfs4_init_uniform_client_string(clp);
5568         else
5569                 status = nfs4_init_nonuniform_client_string(clp);
5570
5571         if (status)
5572                 goto out;
5573
5574         /* cb_client4 */
5575         setclientid.sc_netid_len =
5576                                 nfs4_init_callback_netid(clp,
5577                                                 setclientid.sc_netid,
5578                                                 sizeof(setclientid.sc_netid));
5579         setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr,
5580                                 sizeof(setclientid.sc_uaddr), "%s.%u.%u",
5581                                 clp->cl_ipaddr, port >> 8, port & 255);
5582
5583         dprintk("NFS call  setclientid auth=%s, '%s'\n",
5584                 clp->cl_rpcclient->cl_auth->au_ops->au_name,
5585                 clp->cl_owner_id);
5586         task = rpc_run_task(&task_setup_data);
5587         if (IS_ERR(task)) {
5588                 status = PTR_ERR(task);
5589                 goto out;
5590         }
5591         status = task->tk_status;
5592         if (setclientid.sc_cred) {
5593                 clp->cl_acceptor = rpcauth_stringify_acceptor(setclientid.sc_cred);
5594                 put_rpccred(setclientid.sc_cred);
5595         }
5596         rpc_put_task(task);
5597 out:
5598         trace_nfs4_setclientid(clp, status);
5599         dprintk("NFS reply setclientid: %d\n", status);
5600         return status;
5601 }
5602
5603 /**
5604  * nfs4_proc_setclientid_confirm - Confirm client ID
5605  * @clp: state data structure
5606  * @res: result of a previous SETCLIENTID
5607  * @cred: RPC credential to use for this call
5608  *
5609  * Returns zero, a negative errno, or a negative NFS4ERR status code.
5610  */
5611 int nfs4_proc_setclientid_confirm(struct nfs_client *clp,
5612                 struct nfs4_setclientid_res *arg,
5613                 struct rpc_cred *cred)
5614 {
5615         struct rpc_message msg = {
5616                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM],
5617                 .rpc_argp = arg,
5618                 .rpc_cred = cred,
5619         };
5620         int status;
5621
5622         dprintk("NFS call  setclientid_confirm auth=%s, (client ID %llx)\n",
5623                 clp->cl_rpcclient->cl_auth->au_ops->au_name,
5624                 clp->cl_clientid);
5625         status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
5626         trace_nfs4_setclientid_confirm(clp, status);
5627         dprintk("NFS reply setclientid_confirm: %d\n", status);
5628         return status;
5629 }
5630
5631 struct nfs4_delegreturndata {
5632         struct nfs4_delegreturnargs args;
5633         struct nfs4_delegreturnres res;
5634         struct nfs_fh fh;
5635         nfs4_stateid stateid;
5636         unsigned long timestamp;
5637         struct {
5638                 struct nfs4_layoutreturn_args arg;
5639                 struct nfs4_layoutreturn_res res;
5640                 struct nfs4_xdr_opaque_data ld_private;
5641                 u32 roc_barrier;
5642                 bool roc;
5643         } lr;
5644         struct nfs_fattr fattr;
5645         int rpc_status;
5646         struct inode *inode;
5647 };
5648
5649 static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata)
5650 {
5651         struct nfs4_delegreturndata *data = calldata;
5652
5653         if (!nfs4_sequence_done(task, &data->res.seq_res))
5654                 return;
5655
5656         trace_nfs4_delegreturn_exit(&data->args, &data->res, task->tk_status);
5657
5658         /* Handle Layoutreturn errors */
5659         if (data->args.lr_args && task->tk_status != 0) {
5660                 switch(data->res.lr_ret) {
5661                 default:
5662                         data->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT;
5663                         break;
5664                 case 0:
5665                         data->args.lr_args = NULL;
5666                         data->res.lr_res = NULL;
5667                         break;
5668                 case -NFS4ERR_ADMIN_REVOKED:
5669                 case -NFS4ERR_DELEG_REVOKED:
5670                 case -NFS4ERR_EXPIRED:
5671                 case -NFS4ERR_BAD_STATEID:
5672                 case -NFS4ERR_OLD_STATEID:
5673                 case -NFS4ERR_UNKNOWN_LAYOUTTYPE:
5674                 case -NFS4ERR_WRONG_CRED:
5675                         data->args.lr_args = NULL;
5676                         data->res.lr_res = NULL;
5677                         data->res.lr_ret = 0;
5678                         rpc_restart_call_prepare(task);
5679                         return;
5680                 }
5681         }
5682
5683         switch (task->tk_status) {
5684         case 0:
5685                 renew_lease(data->res.server, data->timestamp);
5686                 break;
5687         case -NFS4ERR_ADMIN_REVOKED:
5688         case -NFS4ERR_DELEG_REVOKED:
5689         case -NFS4ERR_EXPIRED:
5690                 nfs4_free_revoked_stateid(data->res.server,
5691                                 data->args.stateid,
5692                                 task->tk_msg.rpc_cred);
5693         case -NFS4ERR_BAD_STATEID:
5694         case -NFS4ERR_OLD_STATEID:
5695         case -NFS4ERR_STALE_STATEID:
5696                 task->tk_status = 0;
5697                 break;
5698         case -NFS4ERR_ACCESS:
5699                 if (data->args.bitmask) {
5700                         data->args.bitmask = NULL;
5701                         data->res.fattr = NULL;
5702                         task->tk_status = 0;
5703                         rpc_restart_call_prepare(task);
5704                         return;
5705                 }
5706         default:
5707                 if (nfs4_async_handle_error(task, data->res.server,
5708                                             NULL, NULL) == -EAGAIN) {
5709                         rpc_restart_call_prepare(task);
5710                         return;
5711                 }
5712         }
5713         data->rpc_status = task->tk_status;
5714 }
5715
5716 static void nfs4_delegreturn_release(void *calldata)
5717 {
5718         struct nfs4_delegreturndata *data = calldata;
5719         struct inode *inode = data->inode;
5720
5721         if (inode) {
5722                 if (data->lr.roc)
5723                         pnfs_roc_release(&data->lr.arg, &data->lr.res,
5724                                         data->res.lr_ret);
5725                 nfs_post_op_update_inode_force_wcc(inode, &data->fattr);
5726                 nfs_iput_and_deactive(inode);
5727         }
5728         kfree(calldata);
5729 }
5730
5731 static void nfs4_delegreturn_prepare(struct rpc_task *task, void *data)
5732 {
5733         struct nfs4_delegreturndata *d_data;
5734
5735         d_data = (struct nfs4_delegreturndata *)data;
5736
5737         if (!d_data->lr.roc && nfs4_wait_on_layoutreturn(d_data->inode, task))
5738                 return;
5739
5740         nfs4_setup_sequence(d_data->res.server,
5741                         &d_data->args.seq_args,
5742                         &d_data->res.seq_res,
5743                         task);
5744 }
5745
5746 static const struct rpc_call_ops nfs4_delegreturn_ops = {
5747         .rpc_call_prepare = nfs4_delegreturn_prepare,
5748         .rpc_call_done = nfs4_delegreturn_done,
5749         .rpc_release = nfs4_delegreturn_release,
5750 };
5751
5752 static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
5753 {
5754         struct nfs4_delegreturndata *data;
5755         struct nfs_server *server = NFS_SERVER(inode);
5756         struct rpc_task *task;
5757         struct rpc_message msg = {
5758                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN],
5759                 .rpc_cred = cred,
5760         };
5761         struct rpc_task_setup task_setup_data = {
5762                 .rpc_client = server->client,
5763                 .rpc_message = &msg,
5764                 .callback_ops = &nfs4_delegreturn_ops,
5765                 .flags = RPC_TASK_ASYNC,
5766         };
5767         int status = 0;
5768
5769         data = kzalloc(sizeof(*data), GFP_NOFS);
5770         if (data == NULL)
5771                 return -ENOMEM;
5772         nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
5773
5774         nfs4_state_protect(server->nfs_client,
5775                         NFS_SP4_MACH_CRED_CLEANUP,
5776                         &task_setup_data.rpc_client, &msg);
5777
5778         data->args.fhandle = &data->fh;
5779         data->args.stateid = &data->stateid;
5780         data->args.bitmask = server->cache_consistency_bitmask;
5781         nfs_copy_fh(&data->fh, NFS_FH(inode));
5782         nfs4_stateid_copy(&data->stateid, stateid);
5783         data->res.fattr = &data->fattr;
5784         data->res.server = server;
5785         data->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT;
5786         data->lr.arg.ld_private = &data->lr.ld_private;
5787         nfs_fattr_init(data->res.fattr);
5788         data->timestamp = jiffies;
5789         data->rpc_status = 0;
5790         data->lr.roc = pnfs_roc(inode, &data->lr.arg, &data->lr.res, cred);
5791         data->inode = nfs_igrab_and_active(inode);
5792         if (data->inode) {
5793                 if (data->lr.roc) {
5794                         data->args.lr_args = &data->lr.arg;
5795                         data->res.lr_res = &data->lr.res;
5796                 }
5797         } else if (data->lr.roc) {
5798                 pnfs_roc_release(&data->lr.arg, &data->lr.res, 0);
5799                 data->lr.roc = false;
5800         }
5801
5802         task_setup_data.callback_data = data;
5803         msg.rpc_argp = &data->args;
5804         msg.rpc_resp = &data->res;
5805         task = rpc_run_task(&task_setup_data);
5806         if (IS_ERR(task))
5807                 return PTR_ERR(task);
5808         if (!issync)
5809                 goto out;
5810         status = nfs4_wait_for_completion_rpc_task(task);
5811         if (status != 0)
5812                 goto out;
5813         status = data->rpc_status;
5814 out:
5815         rpc_put_task(task);
5816         return status;
5817 }
5818
5819 int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
5820 {
5821         struct nfs_server *server = NFS_SERVER(inode);
5822         struct nfs4_exception exception = { };
5823         int err;
5824         do {
5825                 err = _nfs4_proc_delegreturn(inode, cred, stateid, issync);
5826                 trace_nfs4_delegreturn(inode, stateid, err);
5827                 switch (err) {
5828                         case -NFS4ERR_STALE_STATEID:
5829                         case -NFS4ERR_EXPIRED:
5830                         case 0:
5831                                 return 0;
5832                 }
5833                 err = nfs4_handle_exception(server, err, &exception);
5834         } while (exception.retry);
5835         return err;
5836 }
5837
5838 static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
5839 {
5840         struct inode *inode = state->inode;
5841         struct nfs_server *server = NFS_SERVER(inode);
5842         struct nfs_client *clp = server->nfs_client;
5843         struct nfs_lockt_args arg = {
5844                 .fh = NFS_FH(inode),
5845                 .fl = request,
5846         };
5847         struct nfs_lockt_res res = {
5848                 .denied = request,
5849         };
5850         struct rpc_message msg = {
5851                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_LOCKT],
5852                 .rpc_argp       = &arg,
5853                 .rpc_resp       = &res,
5854                 .rpc_cred       = state->owner->so_cred,
5855         };
5856         struct nfs4_lock_state *lsp;
5857         int status;
5858
5859         arg.lock_owner.clientid = clp->cl_clientid;
5860         status = nfs4_set_lock_state(state, request);
5861         if (status != 0)
5862                 goto out;
5863         lsp = request->fl_u.nfs4_fl.owner;
5864         arg.lock_owner.id = lsp->ls_seqid.owner_id;
5865         arg.lock_owner.s_dev = server->s_dev;
5866         status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
5867         switch (status) {
5868                 case 0:
5869                         request->fl_type = F_UNLCK;
5870                         break;
5871                 case -NFS4ERR_DENIED:
5872                         status = 0;
5873         }
5874         request->fl_ops->fl_release_private(request);
5875         request->fl_ops = NULL;
5876 out:
5877         return status;
5878 }
5879
5880 static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
5881 {
5882         struct nfs4_exception exception = { };
5883         int err;
5884
5885         do {
5886                 err = _nfs4_proc_getlk(state, cmd, request);
5887                 trace_nfs4_get_lock(request, state, cmd, err);
5888                 err = nfs4_handle_exception(NFS_SERVER(state->inode), err,
5889                                 &exception);
5890         } while (exception.retry);
5891         return err;
5892 }
5893
5894 struct nfs4_unlockdata {
5895         struct nfs_locku_args arg;
5896         struct nfs_locku_res res;
5897         struct nfs4_lock_state *lsp;
5898         struct nfs_open_context *ctx;
5899         struct file_lock fl;
5900         struct nfs_server *server;
5901         unsigned long timestamp;
5902 };
5903
5904 static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,
5905                 struct nfs_open_context *ctx,
5906                 struct nfs4_lock_state *lsp,
5907                 struct nfs_seqid *seqid)
5908 {
5909         struct nfs4_unlockdata *p;
5910         struct inode *inode = lsp->ls_state->inode;
5911
5912         p = kzalloc(sizeof(*p), GFP_NOFS);
5913         if (p == NULL)
5914                 return NULL;
5915         p->arg.fh = NFS_FH(inode);
5916         p->arg.fl = &p->fl;
5917         p->arg.seqid = seqid;
5918         p->res.seqid = seqid;
5919         p->lsp = lsp;
5920         atomic_inc(&lsp->ls_count);
5921         /* Ensure we don't close file until we're done freeing locks! */
5922         p->ctx = get_nfs_open_context(ctx);
5923         memcpy(&p->fl, fl, sizeof(p->fl));
5924         p->server = NFS_SERVER(inode);
5925         return p;
5926 }
5927
5928 static void nfs4_locku_release_calldata(void *data)
5929 {
5930         struct nfs4_unlockdata *calldata = data;
5931         nfs_free_seqid(calldata->arg.seqid);
5932         nfs4_put_lock_state(calldata->lsp);
5933         put_nfs_open_context(calldata->ctx);
5934         kfree(calldata);
5935 }
5936
5937 static void nfs4_locku_done(struct rpc_task *task, void *data)
5938 {
5939         struct nfs4_unlockdata *calldata = data;
5940
5941         if (!nfs4_sequence_done(task, &calldata->res.seq_res))
5942                 return;
5943         switch (task->tk_status) {
5944                 case 0:
5945                         renew_lease(calldata->server, calldata->timestamp);
5946                         locks_lock_inode_wait(calldata->lsp->ls_state->inode, &calldata->fl);
5947                         if (nfs4_update_lock_stateid(calldata->lsp,
5948                                         &calldata->res.stateid))
5949                                 break;
5950                 case -NFS4ERR_ADMIN_REVOKED:
5951                 case -NFS4ERR_EXPIRED:
5952                         nfs4_free_revoked_stateid(calldata->server,
5953                                         &calldata->arg.stateid,
5954                                         task->tk_msg.rpc_cred);
5955                 case -NFS4ERR_BAD_STATEID:
5956                 case -NFS4ERR_OLD_STATEID:
5957                 case -NFS4ERR_STALE_STATEID:
5958                         if (!nfs4_stateid_match(&calldata->arg.stateid,
5959                                                 &calldata->lsp->ls_stateid))
5960                                 rpc_restart_call_prepare(task);
5961                         break;
5962                 default:
5963                         if (nfs4_async_handle_error(task, calldata->server,
5964                                                     NULL, NULL) == -EAGAIN)
5965                                 rpc_restart_call_prepare(task);
5966         }
5967         nfs_release_seqid(calldata->arg.seqid);
5968 }
5969
5970 static void nfs4_locku_prepare(struct rpc_task *task, void *data)
5971 {
5972         struct nfs4_unlockdata *calldata = data;
5973
5974         if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
5975                 goto out_wait;
5976         nfs4_stateid_copy(&calldata->arg.stateid, &calldata->lsp->ls_stateid);
5977         if (test_bit(NFS_LOCK_INITIALIZED, &calldata->lsp->ls_flags) == 0) {
5978                 /* Note: exit _without_ running nfs4_locku_done */
5979                 goto out_no_action;
5980         }
5981         calldata->timestamp = jiffies;
5982         if (nfs4_setup_sequence(calldata->server,
5983                                 &calldata->arg.seq_args,
5984                                 &calldata->res.seq_res,
5985                                 task) != 0)
5986                 nfs_release_seqid(calldata->arg.seqid);
5987         return;
5988 out_no_action:
5989         task->tk_action = NULL;
5990 out_wait:
5991         nfs4_sequence_done(task, &calldata->res.seq_res);
5992 }
5993
5994 static const struct rpc_call_ops nfs4_locku_ops = {
5995         .rpc_call_prepare = nfs4_locku_prepare,
5996         .rpc_call_done = nfs4_locku_done,
5997         .rpc_release = nfs4_locku_release_calldata,
5998 };
5999
6000 static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,
6001                 struct nfs_open_context *ctx,
6002                 struct nfs4_lock_state *lsp,
6003                 struct nfs_seqid *seqid)
6004 {
6005         struct nfs4_unlockdata *data;
6006         struct rpc_message msg = {
6007                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU],
6008                 .rpc_cred = ctx->cred,
6009         };
6010         struct rpc_task_setup task_setup_data = {
6011                 .rpc_client = NFS_CLIENT(lsp->ls_state->inode),
6012                 .rpc_message = &msg,
6013                 .callback_ops = &nfs4_locku_ops,
6014                 .workqueue = nfsiod_workqueue,
6015                 .flags = RPC_TASK_ASYNC,
6016         };
6017
6018         nfs4_state_protect(NFS_SERVER(lsp->ls_state->inode)->nfs_client,
6019                 NFS_SP4_MACH_CRED_CLEANUP, &task_setup_data.rpc_client, &msg);
6020
6021         /* Ensure this is an unlock - when canceling a lock, the
6022          * canceled lock is passed in, and it won't be an unlock.
6023          */
6024         fl->fl_type = F_UNLCK;
6025
6026         data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid);
6027         if (data == NULL) {
6028                 nfs_free_seqid(seqid);
6029                 return ERR_PTR(-ENOMEM);
6030         }
6031
6032         nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1);
6033         msg.rpc_argp = &data->arg;
6034         msg.rpc_resp = &data->res;
6035         task_setup_data.callback_data = data;
6036         return rpc_run_task(&task_setup_data);
6037 }
6038
6039 static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request)
6040 {
6041         struct inode *inode = state->inode;
6042         struct nfs4_state_owner *sp = state->owner;
6043         struct nfs_inode *nfsi = NFS_I(inode);
6044         struct nfs_seqid *seqid;
6045         struct nfs4_lock_state *lsp;
6046         struct rpc_task *task;
6047         struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
6048         int status = 0;
6049         unsigned char fl_flags = request->fl_flags;
6050
6051         status = nfs4_set_lock_state(state, request);
6052         /* Unlock _before_ we do the RPC call */
6053         request->fl_flags |= FL_EXISTS;
6054         /* Exclude nfs_delegation_claim_locks() */
6055         mutex_lock(&sp->so_delegreturn_mutex);
6056         /* Exclude nfs4_reclaim_open_stateid() - note nesting! */
6057         down_read(&nfsi->rwsem);
6058         if (locks_lock_inode_wait(inode, request) == -ENOENT) {
6059                 up_read(&nfsi->rwsem);
6060                 mutex_unlock(&sp->so_delegreturn_mutex);
6061                 goto out;
6062         }
6063         up_read(&nfsi->rwsem);
6064         mutex_unlock(&sp->so_delegreturn_mutex);
6065         if (status != 0)
6066                 goto out;
6067         /* Is this a delegated lock? */
6068         lsp = request->fl_u.nfs4_fl.owner;
6069         if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) == 0)
6070                 goto out;
6071         alloc_seqid = NFS_SERVER(inode)->nfs_client->cl_mvops->alloc_seqid;
6072         seqid = alloc_seqid(&lsp->ls_seqid, GFP_KERNEL);
6073         status = -ENOMEM;
6074         if (IS_ERR(seqid))
6075                 goto out;
6076         task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid);
6077         status = PTR_ERR(task);
6078         if (IS_ERR(task))
6079                 goto out;
6080         status = nfs4_wait_for_completion_rpc_task(task);
6081         rpc_put_task(task);
6082 out:
6083         request->fl_flags = fl_flags;
6084         trace_nfs4_unlock(request, state, F_SETLK, status);
6085         return status;
6086 }
6087
6088 struct nfs4_lockdata {
6089         struct nfs_lock_args arg;
6090         struct nfs_lock_res res;
6091         struct nfs4_lock_state *lsp;
6092         struct nfs_open_context *ctx;
6093         struct file_lock fl;
6094         unsigned long timestamp;
6095         int rpc_status;
6096         int cancelled;
6097         struct nfs_server *server;
6098 };
6099
6100 static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl,
6101                 struct nfs_open_context *ctx, struct nfs4_lock_state *lsp,
6102                 gfp_t gfp_mask)
6103 {
6104         struct nfs4_lockdata *p;
6105         struct inode *inode = lsp->ls_state->inode;
6106         struct nfs_server *server = NFS_SERVER(inode);
6107         struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
6108
6109         p = kzalloc(sizeof(*p), gfp_mask);
6110         if (p == NULL)
6111                 return NULL;
6112
6113         p->arg.fh = NFS_FH(inode);
6114         p->arg.fl = &p->fl;
6115         p->arg.open_seqid = nfs_alloc_seqid(&lsp->ls_state->owner->so_seqid, gfp_mask);
6116         if (IS_ERR(p->arg.open_seqid))
6117                 goto out_free;
6118         alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
6119         p->arg.lock_seqid = alloc_seqid(&lsp->ls_seqid, gfp_mask);
6120         if (IS_ERR(p->arg.lock_seqid))
6121                 goto out_free_seqid;
6122         p->arg.lock_owner.clientid = server->nfs_client->cl_clientid;
6123         p->arg.lock_owner.id = lsp->ls_seqid.owner_id;
6124         p->arg.lock_owner.s_dev = server->s_dev;
6125         p->res.lock_seqid = p->arg.lock_seqid;
6126         p->lsp = lsp;
6127         p->server = server;
6128         atomic_inc(&lsp->ls_count);
6129         p->ctx = get_nfs_open_context(ctx);
6130         get_file(fl->fl_file);
6131         memcpy(&p->fl, fl, sizeof(p->fl));
6132         return p;
6133 out_free_seqid:
6134         nfs_free_seqid(p->arg.open_seqid);
6135 out_free:
6136         kfree(p);
6137         return NULL;
6138 }
6139
6140 static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)
6141 {
6142         struct nfs4_lockdata *data = calldata;
6143         struct nfs4_state *state = data->lsp->ls_state;
6144
6145         dprintk("%s: begin!\n", __func__);
6146         if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0)
6147                 goto out_wait;
6148         /* Do we need to do an open_to_lock_owner? */
6149         if (!test_bit(NFS_LOCK_INITIALIZED, &data->lsp->ls_flags)) {
6150                 if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0) {
6151                         goto out_release_lock_seqid;
6152                 }
6153                 nfs4_stateid_copy(&data->arg.open_stateid,
6154                                 &state->open_stateid);
6155                 data->arg.new_lock_owner = 1;
6156                 data->res.open_seqid = data->arg.open_seqid;
6157         } else {
6158                 data->arg.new_lock_owner = 0;
6159                 nfs4_stateid_copy(&data->arg.lock_stateid,
6160                                 &data->lsp->ls_stateid);
6161         }
6162         if (!nfs4_valid_open_stateid(state)) {
6163                 data->rpc_status = -EBADF;
6164                 task->tk_action = NULL;
6165                 goto out_release_open_seqid;
6166         }
6167         data->timestamp = jiffies;
6168         if (nfs4_setup_sequence(data->server,
6169                                 &data->arg.seq_args,
6170                                 &data->res.seq_res,
6171                                 task) == 0)
6172                 return;
6173 out_release_open_seqid:
6174         nfs_release_seqid(data->arg.open_seqid);
6175 out_release_lock_seqid:
6176         nfs_release_seqid(data->arg.lock_seqid);
6177 out_wait:
6178         nfs4_sequence_done(task, &data->res.seq_res);
6179         dprintk("%s: done!, ret = %d\n", __func__, data->rpc_status);
6180 }
6181
6182 static void nfs4_lock_done(struct rpc_task *task, void *calldata)
6183 {
6184         struct nfs4_lockdata *data = calldata;
6185         struct nfs4_lock_state *lsp = data->lsp;
6186
6187         dprintk("%s: begin!\n", __func__);
6188
6189         if (!nfs4_sequence_done(task, &data->res.seq_res))
6190                 return;
6191
6192         data->rpc_status = task->tk_status;
6193         switch (task->tk_status) {
6194         case 0:
6195                 renew_lease(NFS_SERVER(d_inode(data->ctx->dentry)),
6196                                 data->timestamp);
6197                 if (data->arg.new_lock) {
6198                         data->fl.fl_flags &= ~(FL_SLEEP | FL_ACCESS);
6199                         if (locks_lock_inode_wait(lsp->ls_state->inode, &data->fl) < 0) {
6200                                 rpc_restart_call_prepare(task);
6201                                 break;
6202                         }
6203                 }
6204                 if (data->arg.new_lock_owner != 0) {
6205                         nfs_confirm_seqid(&lsp->ls_seqid, 0);
6206                         nfs4_stateid_copy(&lsp->ls_stateid, &data->res.stateid);
6207                         set_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags);
6208                 } else if (!nfs4_update_lock_stateid(lsp, &data->res.stateid))
6209                         rpc_restart_call_prepare(task);
6210                 break;
6211         case -NFS4ERR_BAD_STATEID:
6212         case -NFS4ERR_OLD_STATEID:
6213         case -NFS4ERR_STALE_STATEID:
6214         case -NFS4ERR_EXPIRED:
6215                 if (data->arg.new_lock_owner != 0) {
6216                         if (!nfs4_stateid_match(&data->arg.open_stateid,
6217                                                 &lsp->ls_state->open_stateid))
6218                                 rpc_restart_call_prepare(task);
6219                 } else if (!nfs4_stateid_match(&data->arg.lock_stateid,
6220                                                 &lsp->ls_stateid))
6221                                 rpc_restart_call_prepare(task);
6222         }
6223         dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status);
6224 }
6225
6226 static void nfs4_lock_release(void *calldata)
6227 {
6228         struct nfs4_lockdata *data = calldata;
6229
6230         dprintk("%s: begin!\n", __func__);
6231         nfs_free_seqid(data->arg.open_seqid);
6232         if (data->cancelled != 0) {
6233                 struct rpc_task *task;
6234                 task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp,
6235                                 data->arg.lock_seqid);
6236                 if (!IS_ERR(task))
6237                         rpc_put_task_async(task);
6238                 dprintk("%s: cancelling lock!\n", __func__);
6239         } else
6240                 nfs_free_seqid(data->arg.lock_seqid);
6241         nfs4_put_lock_state(data->lsp);
6242         put_nfs_open_context(data->ctx);
6243         fput(data->fl.fl_file);
6244         kfree(data);
6245         dprintk("%s: done!\n", __func__);
6246 }
6247
6248 static const struct rpc_call_ops nfs4_lock_ops = {
6249         .rpc_call_prepare = nfs4_lock_prepare,
6250         .rpc_call_done = nfs4_lock_done,
6251         .rpc_release = nfs4_lock_release,
6252 };
6253
6254 static void nfs4_handle_setlk_error(struct nfs_server *server, struct nfs4_lock_state *lsp, int new_lock_owner, int error)
6255 {
6256         switch (error) {
6257         case -NFS4ERR_ADMIN_REVOKED:
6258         case -NFS4ERR_EXPIRED:
6259         case -NFS4ERR_BAD_STATEID:
6260                 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;
6261                 if (new_lock_owner != 0 ||
6262                    test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0)
6263                         nfs4_schedule_stateid_recovery(server, lsp->ls_state);
6264                 break;
6265         case -NFS4ERR_STALE_STATEID:
6266                 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;
6267                 nfs4_schedule_lease_recovery(server->nfs_client);
6268         };
6269 }
6270
6271 static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int recovery_type)
6272 {
6273         struct nfs4_lockdata *data;
6274         struct rpc_task *task;
6275         struct rpc_message msg = {
6276                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK],
6277                 .rpc_cred = state->owner->so_cred,
6278         };
6279         struct rpc_task_setup task_setup_data = {
6280                 .rpc_client = NFS_CLIENT(state->inode),
6281                 .rpc_message = &msg,
6282                 .callback_ops = &nfs4_lock_ops,
6283                 .workqueue = nfsiod_workqueue,
6284                 .flags = RPC_TASK_ASYNC,
6285         };
6286         int ret;
6287
6288         dprintk("%s: begin!\n", __func__);
6289         data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file),
6290                         fl->fl_u.nfs4_fl.owner,
6291                         recovery_type == NFS_LOCK_NEW ? GFP_KERNEL : GFP_NOFS);
6292         if (data == NULL)
6293                 return -ENOMEM;
6294         if (IS_SETLKW(cmd))
6295                 data->arg.block = 1;
6296         nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1);
6297         msg.rpc_argp = &data->arg;
6298         msg.rpc_resp = &data->res;
6299         task_setup_data.callback_data = data;
6300         if (recovery_type > NFS_LOCK_NEW) {
6301                 if (recovery_type == NFS_LOCK_RECLAIM)
6302                         data->arg.reclaim = NFS_LOCK_RECLAIM;
6303                 nfs4_set_sequence_privileged(&data->arg.seq_args);
6304         } else
6305                 data->arg.new_lock = 1;
6306         task = rpc_run_task(&task_setup_data);
6307         if (IS_ERR(task))
6308                 return PTR_ERR(task);
6309         ret = nfs4_wait_for_completion_rpc_task(task);
6310         if (ret == 0) {
6311                 ret = data->rpc_status;
6312                 if (ret)
6313                         nfs4_handle_setlk_error(data->server, data->lsp,
6314                                         data->arg.new_lock_owner, ret);
6315         } else
6316                 data->cancelled = 1;
6317         rpc_put_task(task);
6318         dprintk("%s: done, ret = %d!\n", __func__, ret);
6319         trace_nfs4_set_lock(fl, state, &data->res.stateid, cmd, ret);
6320         return ret;
6321 }
6322
6323 static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request)
6324 {
6325         struct nfs_server *server = NFS_SERVER(state->inode);
6326         struct nfs4_exception exception = {
6327                 .inode = state->inode,
6328         };
6329         int err;
6330
6331         do {
6332                 /* Cache the lock if possible... */
6333                 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
6334                         return 0;
6335                 err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_RECLAIM);
6336                 if (err != -NFS4ERR_DELAY)
6337                         break;
6338                 nfs4_handle_exception(server, err, &exception);
6339         } while (exception.retry);
6340         return err;
6341 }
6342
6343 static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request)
6344 {
6345         struct nfs_server *server = NFS_SERVER(state->inode);
6346         struct nfs4_exception exception = {
6347                 .inode = state->inode,
6348         };
6349         int err;
6350
6351         err = nfs4_set_lock_state(state, request);
6352         if (err != 0)
6353                 return err;
6354         if (!recover_lost_locks) {
6355                 set_bit(NFS_LOCK_LOST, &request->fl_u.nfs4_fl.owner->ls_flags);
6356                 return 0;
6357         }
6358         do {
6359                 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
6360                         return 0;
6361                 err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_EXPIRED);
6362                 switch (err) {
6363                 default:
6364                         goto out;
6365                 case -NFS4ERR_GRACE:
6366                 case -NFS4ERR_DELAY:
6367                         nfs4_handle_exception(server, err, &exception);
6368                         err = 0;
6369                 }
6370         } while (exception.retry);
6371 out:
6372         return err;
6373 }
6374
6375 #if defined(CONFIG_NFS_V4_1)
6376 static int nfs41_lock_expired(struct nfs4_state *state, struct file_lock *request)
6377 {
6378         struct nfs4_lock_state *lsp;
6379         int status;
6380
6381         status = nfs4_set_lock_state(state, request);
6382         if (status != 0)
6383                 return status;
6384         lsp = request->fl_u.nfs4_fl.owner;
6385         if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) ||
6386             test_bit(NFS_LOCK_LOST, &lsp->ls_flags))
6387                 return 0;
6388         status = nfs4_lock_expired(state, request);
6389         return status;
6390 }
6391 #endif
6392
6393 static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
6394 {
6395         struct nfs_inode *nfsi = NFS_I(state->inode);
6396         struct nfs4_state_owner *sp = state->owner;
6397         unsigned char fl_flags = request->fl_flags;
6398         int status;
6399
6400         request->fl_flags |= FL_ACCESS;
6401         status = locks_lock_inode_wait(state->inode, request);
6402         if (status < 0)
6403                 goto out;
6404         mutex_lock(&sp->so_delegreturn_mutex);
6405         down_read(&nfsi->rwsem);
6406         if (test_bit(NFS_DELEGATED_STATE, &state->flags)) {
6407                 /* Yes: cache locks! */
6408                 /* ...but avoid races with delegation recall... */
6409                 request->fl_flags = fl_flags & ~FL_SLEEP;
6410                 status = locks_lock_inode_wait(state->inode, request);
6411                 up_read(&nfsi->rwsem);
6412                 mutex_unlock(&sp->so_delegreturn_mutex);
6413                 goto out;
6414         }
6415         up_read(&nfsi->rwsem);
6416         mutex_unlock(&sp->so_delegreturn_mutex);
6417         status = _nfs4_do_setlk(state, cmd, request, NFS_LOCK_NEW);
6418 out:
6419         request->fl_flags = fl_flags;
6420         return status;
6421 }
6422
6423 static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
6424 {
6425         struct nfs4_exception exception = {
6426                 .state = state,
6427                 .inode = state->inode,
6428         };
6429         int err;
6430
6431         do {
6432                 err = _nfs4_proc_setlk(state, cmd, request);
6433                 if (err == -NFS4ERR_DENIED)
6434                         err = -EAGAIN;
6435                 err = nfs4_handle_exception(NFS_SERVER(state->inode),
6436                                 err, &exception);
6437         } while (exception.retry);
6438         return err;
6439 }
6440
6441 #define NFS4_LOCK_MINTIMEOUT (1 * HZ)
6442 #define NFS4_LOCK_MAXTIMEOUT (30 * HZ)
6443
6444 static int
6445 nfs4_retry_setlk_simple(struct nfs4_state *state, int cmd,
6446                         struct file_lock *request)
6447 {
6448         int             status = -ERESTARTSYS;
6449         unsigned long   timeout = NFS4_LOCK_MINTIMEOUT;
6450
6451         while(!signalled()) {
6452                 status = nfs4_proc_setlk(state, cmd, request);
6453                 if ((status != -EAGAIN) || IS_SETLK(cmd))
6454                         break;
6455                 freezable_schedule_timeout_interruptible(timeout);
6456                 timeout *= 2;
6457                 timeout = min_t(unsigned long, NFS4_LOCK_MAXTIMEOUT, timeout);
6458                 status = -ERESTARTSYS;
6459         }
6460         return status;
6461 }
6462
6463 #ifdef CONFIG_NFS_V4_1
6464 struct nfs4_lock_waiter {
6465         struct task_struct      *task;
6466         struct inode            *inode;
6467         struct nfs_lowner       *owner;
6468         bool                    notified;
6469 };
6470
6471 static int
6472 nfs4_wake_lock_waiter(wait_queue_t *wait, unsigned int mode, int flags, void *key)
6473 {
6474         int ret;
6475         struct cb_notify_lock_args *cbnl = key;
6476         struct nfs4_lock_waiter *waiter = wait->private;
6477         struct nfs_lowner       *lowner = &cbnl->cbnl_owner,
6478                                 *wowner = waiter->owner;
6479
6480         /* Only wake if the callback was for the same owner */
6481         if (lowner->clientid != wowner->clientid ||
6482             lowner->id != wowner->id             ||
6483             lowner->s_dev != wowner->s_dev)
6484                 return 0;
6485
6486         /* Make sure it's for the right inode */
6487         if (nfs_compare_fh(NFS_FH(waiter->inode), &cbnl->cbnl_fh))
6488                 return 0;
6489
6490         waiter->notified = true;
6491
6492         /* override "private" so we can use default_wake_function */
6493         wait->private = waiter->task;
6494         ret = autoremove_wake_function(wait, mode, flags, key);
6495         wait->private = waiter;
6496         return ret;
6497 }
6498
6499 static int
6500 nfs4_retry_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
6501 {
6502         int status = -ERESTARTSYS;
6503         unsigned long flags;
6504         struct nfs4_lock_state *lsp = request->fl_u.nfs4_fl.owner;
6505         struct nfs_server *server = NFS_SERVER(state->inode);
6506         struct nfs_client *clp = server->nfs_client;
6507         wait_queue_head_t *q = &clp->cl_lock_waitq;
6508         struct nfs_lowner owner = { .clientid = clp->cl_clientid,
6509                                     .id = lsp->ls_seqid.owner_id,
6510                                     .s_dev = server->s_dev };
6511         struct nfs4_lock_waiter waiter = { .task  = current,
6512                                            .inode = state->inode,
6513                                            .owner = &owner,
6514                                            .notified = false };
6515         wait_queue_t wait;
6516
6517         /* Don't bother with waitqueue if we don't expect a callback */
6518         if (!test_bit(NFS_STATE_MAY_NOTIFY_LOCK, &state->flags))
6519                 return nfs4_retry_setlk_simple(state, cmd, request);
6520
6521         init_wait(&wait);
6522         wait.private = &waiter;
6523         wait.func = nfs4_wake_lock_waiter;
6524         add_wait_queue(q, &wait);
6525
6526         while(!signalled()) {
6527                 status = nfs4_proc_setlk(state, cmd, request);
6528                 if ((status != -EAGAIN) || IS_SETLK(cmd))
6529                         break;
6530
6531                 status = -ERESTARTSYS;
6532                 spin_lock_irqsave(&q->lock, flags);
6533                 if (waiter.notified) {
6534                         spin_unlock_irqrestore(&q->lock, flags);
6535                         continue;
6536                 }
6537                 set_current_state(TASK_INTERRUPTIBLE);
6538                 spin_unlock_irqrestore(&q->lock, flags);
6539
6540                 freezable_schedule_timeout_interruptible(NFS4_LOCK_MAXTIMEOUT);
6541         }
6542
6543         finish_wait(q, &wait);
6544         return status;
6545 }
6546 #else /* !CONFIG_NFS_V4_1 */
6547 static inline int
6548 nfs4_retry_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
6549 {
6550         return nfs4_retry_setlk_simple(state, cmd, request);
6551 }
6552 #endif
6553
6554 static int
6555 nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request)
6556 {
6557         struct nfs_open_context *ctx;
6558         struct nfs4_state *state;
6559         int status;
6560
6561         /* verify open state */
6562         ctx = nfs_file_open_context(filp);
6563         state = ctx->state;
6564
6565         if (request->fl_start < 0 || request->fl_end < 0)
6566                 return -EINVAL;
6567
6568         if (IS_GETLK(cmd)) {
6569                 if (state != NULL)
6570                         return nfs4_proc_getlk(state, F_GETLK, request);
6571                 return 0;
6572         }
6573
6574         if (!(IS_SETLK(cmd) || IS_SETLKW(cmd)))
6575                 return -EINVAL;
6576
6577         if (request->fl_type == F_UNLCK) {
6578                 if (state != NULL)
6579                         return nfs4_proc_unlck(state, cmd, request);
6580                 return 0;
6581         }
6582
6583         if (state == NULL)
6584                 return -ENOLCK;
6585
6586         if ((request->fl_flags & FL_POSIX) &&
6587             !test_bit(NFS_STATE_POSIX_LOCKS, &state->flags))
6588                 return -ENOLCK;
6589
6590         /*
6591          * Don't rely on the VFS having checked the file open mode,
6592          * since it won't do this for flock() locks.
6593          */
6594         switch (request->fl_type) {
6595         case F_RDLCK:
6596                 if (!(filp->f_mode & FMODE_READ))
6597                         return -EBADF;
6598                 break;
6599         case F_WRLCK:
6600                 if (!(filp->f_mode & FMODE_WRITE))
6601                         return -EBADF;
6602         }
6603
6604         status = nfs4_set_lock_state(state, request);
6605         if (status != 0)
6606                 return status;
6607
6608         return nfs4_retry_setlk(state, cmd, request);
6609 }
6610
6611 int nfs4_lock_delegation_recall(struct file_lock *fl, struct nfs4_state *state, const nfs4_stateid *stateid)
6612 {
6613         struct nfs_server *server = NFS_SERVER(state->inode);
6614         int err;
6615
6616         err = nfs4_set_lock_state(state, fl);
6617         if (err != 0)
6618                 return err;
6619         err = _nfs4_do_setlk(state, F_SETLK, fl, NFS_LOCK_NEW);
6620         return nfs4_handle_delegation_recall_error(server, state, stateid, err);
6621 }
6622
6623 struct nfs_release_lockowner_data {
6624         struct nfs4_lock_state *lsp;
6625         struct nfs_server *server;
6626         struct nfs_release_lockowner_args args;
6627         struct nfs_release_lockowner_res res;
6628         unsigned long timestamp;
6629 };
6630
6631 static void nfs4_release_lockowner_prepare(struct rpc_task *task, void *calldata)
6632 {
6633         struct nfs_release_lockowner_data *data = calldata;
6634         struct nfs_server *server = data->server;
6635         nfs40_setup_sequence(server->nfs_client->cl_slot_tbl,
6636                              &data->args.seq_args, &data->res.seq_res, task);
6637         data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
6638         data->timestamp = jiffies;
6639 }
6640
6641 static void nfs4_release_lockowner_done(struct rpc_task *task, void *calldata)
6642 {
6643         struct nfs_release_lockowner_data *data = calldata;
6644         struct nfs_server *server = data->server;
6645
6646         nfs40_sequence_done(task, &data->res.seq_res);
6647
6648         switch (task->tk_status) {
6649         case 0:
6650                 renew_lease(server, data->timestamp);
6651                 break;
6652         case -NFS4ERR_STALE_CLIENTID:
6653         case -NFS4ERR_EXPIRED:
6654                 nfs4_schedule_lease_recovery(server->nfs_client);
6655                 break;
6656         case -NFS4ERR_LEASE_MOVED:
6657         case -NFS4ERR_DELAY:
6658                 if (nfs4_async_handle_error(task, server,
6659                                             NULL, NULL) == -EAGAIN)
6660                         rpc_restart_call_prepare(task);
6661         }
6662 }
6663
6664 static void nfs4_release_lockowner_release(void *calldata)
6665 {
6666         struct nfs_release_lockowner_data *data = calldata;
6667         nfs4_free_lock_state(data->server, data->lsp);
6668         kfree(calldata);
6669 }
6670
6671 static const struct rpc_call_ops nfs4_release_lockowner_ops = {
6672         .rpc_call_prepare = nfs4_release_lockowner_prepare,
6673         .rpc_call_done = nfs4_release_lockowner_done,
6674         .rpc_release = nfs4_release_lockowner_release,
6675 };
6676
6677 static void
6678 nfs4_release_lockowner(struct nfs_server *server, struct nfs4_lock_state *lsp)
6679 {
6680         struct nfs_release_lockowner_data *data;
6681         struct rpc_message msg = {
6682                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RELEASE_LOCKOWNER],
6683         };
6684
6685         if (server->nfs_client->cl_mvops->minor_version != 0)
6686                 return;
6687
6688         data = kmalloc(sizeof(*data), GFP_NOFS);
6689         if (!data)
6690                 return;
6691         data->lsp = lsp;
6692         data->server = server;
6693         data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
6694         data->args.lock_owner.id = lsp->ls_seqid.owner_id;
6695         data->args.lock_owner.s_dev = server->s_dev;
6696
6697         msg.rpc_argp = &data->args;
6698         msg.rpc_resp = &data->res;
6699         nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0);
6700         rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, data);
6701 }
6702
6703 #define XATTR_NAME_NFSV4_ACL "system.nfs4_acl"
6704
6705 static int nfs4_xattr_set_nfs4_acl(const struct xattr_handler *handler,
6706                                    struct dentry *unused, struct inode *inode,
6707                                    const char *key, const void *buf,
6708                                    size_t buflen, int flags)
6709 {
6710         return nfs4_proc_set_acl(inode, buf, buflen);
6711 }
6712
6713 static int nfs4_xattr_get_nfs4_acl(const struct xattr_handler *handler,
6714                                    struct dentry *unused, struct inode *inode,
6715                                    const char *key, void *buf, size_t buflen)
6716 {
6717         return nfs4_proc_get_acl(inode, buf, buflen);
6718 }
6719
6720 static bool nfs4_xattr_list_nfs4_acl(struct dentry *dentry)
6721 {
6722         return nfs4_server_supports_acls(NFS_SERVER(d_inode(dentry)));
6723 }
6724
6725 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
6726
6727 static int nfs4_xattr_set_nfs4_label(const struct xattr_handler *handler,
6728                                      struct dentry *unused, struct inode *inode,
6729                                      const char *key, const void *buf,
6730                                      size_t buflen, int flags)
6731 {
6732         if (security_ismaclabel(key))
6733                 return nfs4_set_security_label(inode, buf, buflen);
6734
6735         return -EOPNOTSUPP;
6736 }
6737
6738 static int nfs4_xattr_get_nfs4_label(const struct xattr_handler *handler,
6739                                      struct dentry *unused, struct inode *inode,
6740                                      const char *key, void *buf, size_t buflen)
6741 {
6742         if (security_ismaclabel(key))
6743                 return nfs4_get_security_label(inode, buf, buflen);
6744         return -EOPNOTSUPP;
6745 }
6746
6747 static ssize_t
6748 nfs4_listxattr_nfs4_label(struct inode *inode, char *list, size_t list_len)
6749 {
6750         int len = 0;
6751
6752         if (nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL)) {
6753                 len = security_inode_listsecurity(inode, list, list_len);
6754                 if (list_len && len > list_len)
6755                         return -ERANGE;
6756         }
6757         return len;
6758 }
6759
6760 static const struct xattr_handler nfs4_xattr_nfs4_label_handler = {
6761         .prefix = XATTR_SECURITY_PREFIX,
6762         .get    = nfs4_xattr_get_nfs4_label,
6763         .set    = nfs4_xattr_set_nfs4_label,
6764 };
6765
6766 #else
6767
6768 static ssize_t
6769 nfs4_listxattr_nfs4_label(struct inode *inode, char *list, size_t list_len)
6770 {
6771         return 0;
6772 }
6773
6774 #endif
6775
6776 /*
6777  * nfs_fhget will use either the mounted_on_fileid or the fileid
6778  */
6779 static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr)
6780 {
6781         if (!(((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) ||
6782                (fattr->valid & NFS_ATTR_FATTR_FILEID)) &&
6783               (fattr->valid & NFS_ATTR_FATTR_FSID) &&
6784               (fattr->valid & NFS_ATTR_FATTR_V4_LOCATIONS)))
6785                 return;
6786
6787         fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |
6788                 NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_V4_REFERRAL;
6789         fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;
6790         fattr->nlink = 2;
6791 }
6792
6793 static int _nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
6794                                    const struct qstr *name,
6795                                    struct nfs4_fs_locations *fs_locations,
6796                                    struct page *page)
6797 {
6798         struct nfs_server *server = NFS_SERVER(dir);
6799         u32 bitmask[3] = {
6800                 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
6801         };
6802         struct nfs4_fs_locations_arg args = {
6803                 .dir_fh = NFS_FH(dir),
6804                 .name = name,
6805                 .page = page,
6806                 .bitmask = bitmask,
6807         };
6808         struct nfs4_fs_locations_res res = {
6809                 .fs_locations = fs_locations,
6810         };
6811         struct rpc_message msg = {
6812                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
6813                 .rpc_argp = &args,
6814                 .rpc_resp = &res,
6815         };
6816         int status;
6817
6818         dprintk("%s: start\n", __func__);
6819
6820         /* Ask for the fileid of the absent filesystem if mounted_on_fileid
6821          * is not supported */
6822         if (NFS_SERVER(dir)->attr_bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)
6823                 bitmask[1] |= FATTR4_WORD1_MOUNTED_ON_FILEID;
6824         else
6825                 bitmask[0] |= FATTR4_WORD0_FILEID;
6826
6827         nfs_fattr_init(&fs_locations->fattr);
6828         fs_locations->server = server;
6829         fs_locations->nlocations = 0;
6830         status = nfs4_call_sync(client, server, &msg, &args.seq_args, &res.seq_res, 0);
6831         dprintk("%s: returned status = %d\n", __func__, status);
6832         return status;
6833 }
6834
6835 int nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
6836                            const struct qstr *name,
6837                            struct nfs4_fs_locations *fs_locations,
6838                            struct page *page)
6839 {
6840         struct nfs4_exception exception = { };
6841         int err;
6842         do {
6843                 err = _nfs4_proc_fs_locations(client, dir, name,
6844                                 fs_locations, page);
6845                 trace_nfs4_get_fs_locations(dir, name, err);
6846                 err = nfs4_handle_exception(NFS_SERVER(dir), err,
6847                                 &exception);
6848         } while (exception.retry);
6849         return err;
6850 }
6851
6852 /*
6853  * This operation also signals the server that this client is
6854  * performing migration recovery.  The server can stop returning
6855  * NFS4ERR_LEASE_MOVED to this client.  A RENEW operation is
6856  * appended to this compound to identify the client ID which is
6857  * performing recovery.
6858  */
6859 static int _nfs40_proc_get_locations(struct inode *inode,
6860                                      struct nfs4_fs_locations *locations,
6861                                      struct page *page, struct rpc_cred *cred)
6862 {
6863         struct nfs_server *server = NFS_SERVER(inode);
6864         struct rpc_clnt *clnt = server->client;
6865         u32 bitmask[2] = {
6866                 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
6867         };
6868         struct nfs4_fs_locations_arg args = {
6869                 .clientid       = server->nfs_client->cl_clientid,
6870                 .fh             = NFS_FH(inode),
6871                 .page           = page,
6872                 .bitmask        = bitmask,
6873                 .migration      = 1,            /* skip LOOKUP */
6874                 .renew          = 1,            /* append RENEW */
6875         };
6876         struct nfs4_fs_locations_res res = {
6877                 .fs_locations   = locations,
6878                 .migration      = 1,
6879                 .renew          = 1,
6880         };
6881         struct rpc_message msg = {
6882                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
6883                 .rpc_argp       = &args,
6884                 .rpc_resp       = &res,
6885                 .rpc_cred       = cred,
6886         };
6887         unsigned long now = jiffies;
6888         int status;
6889
6890         nfs_fattr_init(&locations->fattr);
6891         locations->server = server;
6892         locations->nlocations = 0;
6893
6894         nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
6895         nfs4_set_sequence_privileged(&args.seq_args);
6896         status = nfs4_call_sync_sequence(clnt, server, &msg,
6897                                         &args.seq_args, &res.seq_res);
6898         if (status)
6899                 return status;
6900
6901         renew_lease(server, now);
6902         return 0;
6903 }
6904
6905 #ifdef CONFIG_NFS_V4_1
6906
6907 /*
6908  * This operation also signals the server that this client is
6909  * performing migration recovery.  The server can stop asserting
6910  * SEQ4_STATUS_LEASE_MOVED for this client.  The client ID
6911  * performing this operation is identified in the SEQUENCE
6912  * operation in this compound.
6913  *
6914  * When the client supports GETATTR(fs_locations_info), it can
6915  * be plumbed in here.
6916  */
6917 static int _nfs41_proc_get_locations(struct inode *inode,
6918                                      struct nfs4_fs_locations *locations,
6919                                      struct page *page, struct rpc_cred *cred)
6920 {
6921         struct nfs_server *server = NFS_SERVER(inode);
6922         struct rpc_clnt *clnt = server->client;
6923         u32 bitmask[2] = {
6924                 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
6925         };
6926         struct nfs4_fs_locations_arg args = {
6927                 .fh             = NFS_FH(inode),
6928                 .page           = page,
6929                 .bitmask        = bitmask,
6930                 .migration      = 1,            /* skip LOOKUP */
6931         };
6932         struct nfs4_fs_locations_res res = {
6933                 .fs_locations   = locations,
6934                 .migration      = 1,
6935         };
6936         struct rpc_message msg = {
6937                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
6938                 .rpc_argp       = &args,
6939                 .rpc_resp       = &res,
6940                 .rpc_cred       = cred,
6941         };
6942         int status;
6943
6944         nfs_fattr_init(&locations->fattr);
6945         locations->server = server;
6946         locations->nlocations = 0;
6947
6948         nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
6949         nfs4_set_sequence_privileged(&args.seq_args);
6950         status = nfs4_call_sync_sequence(clnt, server, &msg,
6951                                         &args.seq_args, &res.seq_res);
6952         if (status == NFS4_OK &&
6953             res.seq_res.sr_status_flags & SEQ4_STATUS_LEASE_MOVED)
6954                 status = -NFS4ERR_LEASE_MOVED;
6955         return status;
6956 }
6957
6958 #endif  /* CONFIG_NFS_V4_1 */
6959
6960 /**
6961  * nfs4_proc_get_locations - discover locations for a migrated FSID
6962  * @inode: inode on FSID that is migrating
6963  * @locations: result of query
6964  * @page: buffer
6965  * @cred: credential to use for this operation
6966  *
6967  * Returns NFS4_OK on success, a negative NFS4ERR status code if the
6968  * operation failed, or a negative errno if a local error occurred.
6969  *
6970  * On success, "locations" is filled in, but if the server has
6971  * no locations information, NFS_ATTR_FATTR_V4_LOCATIONS is not
6972  * asserted.
6973  *
6974  * -NFS4ERR_LEASE_MOVED is returned if the server still has leases
6975  * from this client that require migration recovery.
6976  */
6977 int nfs4_proc_get_locations(struct inode *inode,
6978                             struct nfs4_fs_locations *locations,
6979                             struct page *page, struct rpc_cred *cred)
6980 {
6981         struct nfs_server *server = NFS_SERVER(inode);
6982         struct nfs_client *clp = server->nfs_client;
6983         const struct nfs4_mig_recovery_ops *ops =
6984                                         clp->cl_mvops->mig_recovery_ops;
6985         struct nfs4_exception exception = { };
6986         int status;
6987
6988         dprintk("%s: FSID %llx:%llx on \"%s\"\n", __func__,
6989                 (unsigned long long)server->fsid.major,
6990                 (unsigned long long)server->fsid.minor,
6991                 clp->cl_hostname);
6992         nfs_display_fhandle(NFS_FH(inode), __func__);
6993
6994         do {
6995                 status = ops->get_locations(inode, locations, page, cred);
6996                 if (status != -NFS4ERR_DELAY)
6997                         break;
6998                 nfs4_handle_exception(server, status, &exception);
6999         } while (exception.retry);
7000         return status;
7001 }
7002
7003 /*
7004  * This operation also signals the server that this client is
7005  * performing "lease moved" recovery.  The server can stop
7006  * returning NFS4ERR_LEASE_MOVED to this client.  A RENEW operation
7007  * is appended to this compound to identify the client ID which is
7008  * performing recovery.
7009  */
7010 static int _nfs40_proc_fsid_present(struct inode *inode, struct rpc_cred *cred)
7011 {
7012         struct nfs_server *server = NFS_SERVER(inode);
7013         struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
7014         struct rpc_clnt *clnt = server->client;
7015         struct nfs4_fsid_present_arg args = {
7016                 .fh             = NFS_FH(inode),
7017                 .clientid       = clp->cl_clientid,
7018                 .renew          = 1,            /* append RENEW */
7019         };
7020         struct nfs4_fsid_present_res res = {
7021                 .renew          = 1,
7022         };
7023         struct rpc_message msg = {
7024                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_FSID_PRESENT],
7025                 .rpc_argp       = &args,
7026                 .rpc_resp       = &res,
7027                 .rpc_cred       = cred,
7028         };
7029         unsigned long now = jiffies;
7030         int status;
7031
7032         res.fh = nfs_alloc_fhandle();
7033         if (res.fh == NULL)
7034                 return -ENOMEM;
7035
7036         nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
7037         nfs4_set_sequence_privileged(&args.seq_args);
7038         status = nfs4_call_sync_sequence(clnt, server, &msg,
7039                                                 &args.seq_args, &res.seq_res);
7040         nfs_free_fhandle(res.fh);
7041         if (status)
7042                 return status;
7043
7044         do_renew_lease(clp, now);
7045         return 0;
7046 }
7047
7048 #ifdef CONFIG_NFS_V4_1
7049
7050 /*
7051  * This operation also signals the server that this client is
7052  * performing "lease moved" recovery.  The server can stop asserting
7053  * SEQ4_STATUS_LEASE_MOVED for this client.  The client ID performing
7054  * this operation is identified in the SEQUENCE operation in this
7055  * compound.
7056  */
7057 static int _nfs41_proc_fsid_present(struct inode *inode, struct rpc_cred *cred)
7058 {
7059         struct nfs_server *server = NFS_SERVER(inode);
7060         struct rpc_clnt *clnt = server->client;
7061         struct nfs4_fsid_present_arg args = {
7062                 .fh             = NFS_FH(inode),
7063         };
7064         struct nfs4_fsid_present_res res = {
7065         };
7066         struct rpc_message msg = {
7067                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_FSID_PRESENT],
7068                 .rpc_argp       = &args,
7069                 .rpc_resp       = &res,
7070                 .rpc_cred       = cred,
7071         };
7072         int status;
7073
7074         res.fh = nfs_alloc_fhandle();
7075         if (res.fh == NULL)
7076                 return -ENOMEM;
7077
7078         nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
7079         nfs4_set_sequence_privileged(&args.seq_args);
7080         status = nfs4_call_sync_sequence(clnt, server, &msg,
7081                                                 &args.seq_args, &res.seq_res);
7082         nfs_free_fhandle(res.fh);
7083         if (status == NFS4_OK &&
7084             res.seq_res.sr_status_flags & SEQ4_STATUS_LEASE_MOVED)
7085                 status = -NFS4ERR_LEASE_MOVED;
7086         return status;
7087 }
7088
7089 #endif  /* CONFIG_NFS_V4_1 */
7090
7091 /**
7092  * nfs4_proc_fsid_present - Is this FSID present or absent on server?
7093  * @inode: inode on FSID to check
7094  * @cred: credential to use for this operation
7095  *
7096  * Server indicates whether the FSID is present, moved, or not
7097  * recognized.  This operation is necessary to clear a LEASE_MOVED
7098  * condition for this client ID.
7099  *
7100  * Returns NFS4_OK if the FSID is present on this server,
7101  * -NFS4ERR_MOVED if the FSID is no longer present, a negative
7102  *  NFS4ERR code if some error occurred on the server, or a
7103  *  negative errno if a local failure occurred.
7104  */
7105 int nfs4_proc_fsid_present(struct inode *inode, struct rpc_cred *cred)
7106 {
7107         struct nfs_server *server = NFS_SERVER(inode);
7108         struct nfs_client *clp = server->nfs_client;
7109         const struct nfs4_mig_recovery_ops *ops =
7110                                         clp->cl_mvops->mig_recovery_ops;
7111         struct nfs4_exception exception = { };
7112         int status;
7113
7114         dprintk("%s: FSID %llx:%llx on \"%s\"\n", __func__,
7115                 (unsigned long long)server->fsid.major,
7116                 (unsigned long long)server->fsid.minor,
7117                 clp->cl_hostname);
7118         nfs_display_fhandle(NFS_FH(inode), __func__);
7119
7120         do {
7121                 status = ops->fsid_present(inode, cred);
7122                 if (status != -NFS4ERR_DELAY)
7123                         break;
7124                 nfs4_handle_exception(server, status, &exception);
7125         } while (exception.retry);
7126         return status;
7127 }
7128
7129 /**
7130  * If 'use_integrity' is true and the state managment nfs_client
7131  * cl_rpcclient is using krb5i/p, use the integrity protected cl_rpcclient
7132  * and the machine credential as per RFC3530bis and RFC5661 Security
7133  * Considerations sections. Otherwise, just use the user cred with the
7134  * filesystem's rpc_client.
7135  */
7136 static int _nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct nfs4_secinfo_flavors *flavors, bool use_integrity)
7137 {
7138         int status;
7139         struct nfs4_secinfo_arg args = {
7140                 .dir_fh = NFS_FH(dir),
7141                 .name   = name,
7142         };
7143         struct nfs4_secinfo_res res = {
7144                 .flavors     = flavors,
7145         };
7146         struct rpc_message msg = {
7147                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO],
7148                 .rpc_argp = &args,
7149                 .rpc_resp = &res,
7150         };
7151         struct rpc_clnt *clnt = NFS_SERVER(dir)->client;
7152         struct rpc_cred *cred = NULL;
7153
7154         if (use_integrity) {
7155                 clnt = NFS_SERVER(dir)->nfs_client->cl_rpcclient;
7156                 cred = nfs4_get_clid_cred(NFS_SERVER(dir)->nfs_client);
7157                 msg.rpc_cred = cred;
7158         }
7159
7160         dprintk("NFS call  secinfo %s\n", name->name);
7161
7162         nfs4_state_protect(NFS_SERVER(dir)->nfs_client,
7163                 NFS_SP4_MACH_CRED_SECINFO, &clnt, &msg);
7164
7165         status = nfs4_call_sync(clnt, NFS_SERVER(dir), &msg, &args.seq_args,
7166                                 &res.seq_res, 0);
7167         dprintk("NFS reply  secinfo: %d\n", status);
7168
7169         if (cred)
7170                 put_rpccred(cred);
7171
7172         return status;
7173 }
7174
7175 int nfs4_proc_secinfo(struct inode *dir, const struct qstr *name,
7176                       struct nfs4_secinfo_flavors *flavors)
7177 {
7178         struct nfs4_exception exception = { };
7179         int err;
7180         do {
7181                 err = -NFS4ERR_WRONGSEC;
7182
7183                 /* try to use integrity protection with machine cred */
7184                 if (_nfs4_is_integrity_protected(NFS_SERVER(dir)->nfs_client))
7185                         err = _nfs4_proc_secinfo(dir, name, flavors, true);
7186
7187                 /*
7188                  * if unable to use integrity protection, or SECINFO with
7189                  * integrity protection returns NFS4ERR_WRONGSEC (which is
7190                  * disallowed by spec, but exists in deployed servers) use
7191                  * the current filesystem's rpc_client and the user cred.
7192                  */
7193                 if (err == -NFS4ERR_WRONGSEC)
7194                         err = _nfs4_proc_secinfo(dir, name, flavors, false);
7195
7196                 trace_nfs4_secinfo(dir, name, err);
7197                 err = nfs4_handle_exception(NFS_SERVER(dir), err,
7198                                 &exception);
7199         } while (exception.retry);
7200         return err;
7201 }
7202
7203 #ifdef CONFIG_NFS_V4_1
7204 /*
7205  * Check the exchange flags returned by the server for invalid flags, having
7206  * both PNFS and NON_PNFS flags set, and not having one of NON_PNFS, PNFS, or
7207  * DS flags set.
7208  */
7209 static int nfs4_check_cl_exchange_flags(u32 flags)
7210 {
7211         if (flags & ~EXCHGID4_FLAG_MASK_R)
7212                 goto out_inval;
7213         if ((flags & EXCHGID4_FLAG_USE_PNFS_MDS) &&
7214             (flags & EXCHGID4_FLAG_USE_NON_PNFS))
7215                 goto out_inval;
7216         if (!(flags & (EXCHGID4_FLAG_MASK_PNFS)))
7217                 goto out_inval;
7218         return NFS_OK;
7219 out_inval:
7220         return -NFS4ERR_INVAL;
7221 }
7222
7223 static bool
7224 nfs41_same_server_scope(struct nfs41_server_scope *a,
7225                         struct nfs41_server_scope *b)
7226 {
7227         if (a->server_scope_sz == b->server_scope_sz &&
7228             memcmp(a->server_scope, b->server_scope, a->server_scope_sz) == 0)
7229                 return true;
7230
7231         return false;
7232 }
7233
7234 static void
7235 nfs4_bind_one_conn_to_session_done(struct rpc_task *task, void *calldata)
7236 {
7237 }
7238
7239 static const struct rpc_call_ops nfs4_bind_one_conn_to_session_ops = {
7240         .rpc_call_done =  &nfs4_bind_one_conn_to_session_done,
7241 };
7242
7243 /*
7244  * nfs4_proc_bind_one_conn_to_session()
7245  *
7246  * The 4.1 client currently uses the same TCP connection for the
7247  * fore and backchannel.
7248  */
7249 static
7250 int nfs4_proc_bind_one_conn_to_session(struct rpc_clnt *clnt,
7251                 struct rpc_xprt *xprt,
7252                 struct nfs_client *clp,
7253                 struct rpc_cred *cred)
7254 {
7255         int status;
7256         struct nfs41_bind_conn_to_session_args args = {
7257                 .client = clp,
7258                 .dir = NFS4_CDFC4_FORE_OR_BOTH,
7259         };
7260         struct nfs41_bind_conn_to_session_res res;
7261         struct rpc_message msg = {
7262                 .rpc_proc =
7263                         &nfs4_procedures[NFSPROC4_CLNT_BIND_CONN_TO_SESSION],
7264                 .rpc_argp = &args,
7265                 .rpc_resp = &res,
7266                 .rpc_cred = cred,
7267         };
7268         struct rpc_task_setup task_setup_data = {
7269                 .rpc_client = clnt,
7270                 .rpc_xprt = xprt,
7271                 .callback_ops = &nfs4_bind_one_conn_to_session_ops,
7272                 .rpc_message = &msg,
7273                 .flags = RPC_TASK_TIMEOUT,
7274         };
7275         struct rpc_task *task;
7276
7277         dprintk("--> %s\n", __func__);
7278
7279         nfs4_copy_sessionid(&args.sessionid, &clp->cl_session->sess_id);
7280         if (!(clp->cl_session->flags & SESSION4_BACK_CHAN))
7281                 args.dir = NFS4_CDFC4_FORE;
7282
7283         /* Do not set the backchannel flag unless this is clnt->cl_xprt */
7284         if (xprt != rcu_access_pointer(clnt->cl_xprt))
7285                 args.dir = NFS4_CDFC4_FORE;
7286
7287         task = rpc_run_task(&task_setup_data);
7288         if (!IS_ERR(task)) {
7289                 status = task->tk_status;
7290                 rpc_put_task(task);
7291         } else
7292                 status = PTR_ERR(task);
7293         trace_nfs4_bind_conn_to_session(clp, status);
7294         if (status == 0) {
7295                 if (memcmp(res.sessionid.data,
7296                     clp->cl_session->sess_id.data, NFS4_MAX_SESSIONID_LEN)) {
7297                         dprintk("NFS: %s: Session ID mismatch\n", __func__);
7298                         status = -EIO;
7299                         goto out;
7300                 }
7301                 if ((res.dir & args.dir) != res.dir || res.dir == 0) {
7302                         dprintk("NFS: %s: Unexpected direction from server\n",
7303                                 __func__);
7304                         status = -EIO;
7305                         goto out;
7306                 }
7307                 if (res.use_conn_in_rdma_mode != args.use_conn_in_rdma_mode) {
7308                         dprintk("NFS: %s: Server returned RDMA mode = true\n",
7309                                 __func__);
7310                         status = -EIO;
7311                         goto out;
7312                 }
7313         }
7314 out:
7315         dprintk("<-- %s status= %d\n", __func__, status);
7316         return status;
7317 }
7318
7319 struct rpc_bind_conn_calldata {
7320         struct nfs_client *clp;
7321         struct rpc_cred *cred;
7322 };
7323
7324 static int
7325 nfs4_proc_bind_conn_to_session_callback(struct rpc_clnt *clnt,
7326                 struct rpc_xprt *xprt,
7327                 void *calldata)
7328 {
7329         struct rpc_bind_conn_calldata *p = calldata;
7330
7331         return nfs4_proc_bind_one_conn_to_session(clnt, xprt, p->clp, p->cred);
7332 }
7333
7334 int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, struct rpc_cred *cred)
7335 {
7336         struct rpc_bind_conn_calldata data = {
7337                 .clp = clp,
7338                 .cred = cred,
7339         };
7340         return rpc_clnt_iterate_for_each_xprt(clp->cl_rpcclient,
7341                         nfs4_proc_bind_conn_to_session_callback, &data);
7342 }
7343
7344 /*
7345  * Minimum set of SP4_MACH_CRED operations from RFC 5661 in the enforce map
7346  * and operations we'd like to see to enable certain features in the allow map
7347  */
7348 static const struct nfs41_state_protection nfs4_sp4_mach_cred_request = {
7349         .how = SP4_MACH_CRED,
7350         .enforce.u.words = {
7351                 [1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) |
7352                       1 << (OP_EXCHANGE_ID - 32) |
7353                       1 << (OP_CREATE_SESSION - 32) |
7354                       1 << (OP_DESTROY_SESSION - 32) |
7355                       1 << (OP_DESTROY_CLIENTID - 32)
7356         },
7357         .allow.u.words = {
7358                 [0] = 1 << (OP_CLOSE) |
7359                       1 << (OP_OPEN_DOWNGRADE) |
7360                       1 << (OP_LOCKU) |
7361                       1 << (OP_DELEGRETURN) |
7362                       1 << (OP_COMMIT),
7363                 [1] = 1 << (OP_SECINFO - 32) |
7364                       1 << (OP_SECINFO_NO_NAME - 32) |
7365                       1 << (OP_LAYOUTRETURN - 32) |
7366                       1 << (OP_TEST_STATEID - 32) |
7367                       1 << (OP_FREE_STATEID - 32) |
7368                       1 << (OP_WRITE - 32)
7369         }
7370 };
7371
7372 /*
7373  * Select the state protection mode for client `clp' given the server results
7374  * from exchange_id in `sp'.
7375  *
7376  * Returns 0 on success, negative errno otherwise.
7377  */
7378 static int nfs4_sp4_select_mode(struct nfs_client *clp,
7379                                  struct nfs41_state_protection *sp)
7380 {
7381         static const u32 supported_enforce[NFS4_OP_MAP_NUM_WORDS] = {
7382                 [1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) |
7383                       1 << (OP_EXCHANGE_ID - 32) |
7384                       1 << (OP_CREATE_SESSION - 32) |
7385                       1 << (OP_DESTROY_SESSION - 32) |
7386                       1 << (OP_DESTROY_CLIENTID - 32)
7387         };
7388         unsigned int i;
7389
7390         if (sp->how == SP4_MACH_CRED) {
7391                 /* Print state protect result */
7392                 dfprintk(MOUNT, "Server SP4_MACH_CRED support:\n");
7393                 for (i = 0; i <= LAST_NFS4_OP; i++) {
7394                         if (test_bit(i, sp->enforce.u.longs))
7395                                 dfprintk(MOUNT, "  enforce op %d\n", i);
7396                         if (test_bit(i, sp->allow.u.longs))
7397                                 dfprintk(MOUNT, "  allow op %d\n", i);
7398                 }
7399
7400                 /* make sure nothing is on enforce list that isn't supported */
7401                 for (i = 0; i < NFS4_OP_MAP_NUM_WORDS; i++) {
7402                         if (sp->enforce.u.words[i] & ~supported_enforce[i]) {
7403                                 dfprintk(MOUNT, "sp4_mach_cred: disabled\n");
7404                                 return -EINVAL;
7405                         }
7406                 }
7407
7408                 /*
7409                  * Minimal mode - state operations are allowed to use machine
7410                  * credential.  Note this already happens by default, so the
7411                  * client doesn't have to do anything more than the negotiation.
7412                  *
7413                  * NOTE: we don't care if EXCHANGE_ID is in the list -
7414                  *       we're already using the machine cred for exchange_id
7415                  *       and will never use a different cred.
7416                  */
7417                 if (test_bit(OP_BIND_CONN_TO_SESSION, sp->enforce.u.longs) &&
7418                     test_bit(OP_CREATE_SESSION, sp->enforce.u.longs) &&
7419                     test_bit(OP_DESTROY_SESSION, sp->enforce.u.longs) &&
7420                     test_bit(OP_DESTROY_CLIENTID, sp->enforce.u.longs)) {
7421                         dfprintk(MOUNT, "sp4_mach_cred:\n");
7422                         dfprintk(MOUNT, "  minimal mode enabled\n");
7423                         set_bit(NFS_SP4_MACH_CRED_MINIMAL, &clp->cl_sp4_flags);
7424                 } else {
7425                         dfprintk(MOUNT, "sp4_mach_cred: disabled\n");
7426                         return -EINVAL;
7427                 }
7428
7429                 if (test_bit(OP_CLOSE, sp->allow.u.longs) &&
7430                     test_bit(OP_OPEN_DOWNGRADE, sp->allow.u.longs) &&
7431                     test_bit(OP_DELEGRETURN, sp->allow.u.longs) &&
7432                     test_bit(OP_LOCKU, sp->allow.u.longs)) {
7433                         dfprintk(MOUNT, "  cleanup mode enabled\n");
7434                         set_bit(NFS_SP4_MACH_CRED_CLEANUP, &clp->cl_sp4_flags);
7435                 }
7436
7437                 if (test_bit(OP_LAYOUTRETURN, sp->allow.u.longs)) {
7438                         dfprintk(MOUNT, "  pnfs cleanup mode enabled\n");
7439                         set_bit(NFS_SP4_MACH_CRED_PNFS_CLEANUP,
7440                                 &clp->cl_sp4_flags);
7441                 }
7442
7443                 if (test_bit(OP_SECINFO, sp->allow.u.longs) &&
7444                     test_bit(OP_SECINFO_NO_NAME, sp->allow.u.longs)) {
7445                         dfprintk(MOUNT, "  secinfo mode enabled\n");
7446                         set_bit(NFS_SP4_MACH_CRED_SECINFO, &clp->cl_sp4_flags);
7447                 }
7448
7449                 if (test_bit(OP_TEST_STATEID, sp->allow.u.longs) &&
7450                     test_bit(OP_FREE_STATEID, sp->allow.u.longs)) {
7451                         dfprintk(MOUNT, "  stateid mode enabled\n");
7452                         set_bit(NFS_SP4_MACH_CRED_STATEID, &clp->cl_sp4_flags);
7453                 }
7454
7455                 if (test_bit(OP_WRITE, sp->allow.u.longs)) {
7456                         dfprintk(MOUNT, "  write mode enabled\n");
7457                         set_bit(NFS_SP4_MACH_CRED_WRITE, &clp->cl_sp4_flags);
7458                 }
7459
7460                 if (test_bit(OP_COMMIT, sp->allow.u.longs)) {
7461                         dfprintk(MOUNT, "  commit mode enabled\n");
7462                         set_bit(NFS_SP4_MACH_CRED_COMMIT, &clp->cl_sp4_flags);
7463                 }
7464         }
7465
7466         return 0;
7467 }
7468
7469 struct nfs41_exchange_id_data {
7470         struct nfs41_exchange_id_res res;
7471         struct nfs41_exchange_id_args args;
7472         struct rpc_xprt *xprt;
7473         int rpc_status;
7474 };
7475
7476 static void nfs4_exchange_id_done(struct rpc_task *task, void *data)
7477 {
7478         struct nfs41_exchange_id_data *cdata =
7479                                         (struct nfs41_exchange_id_data *)data;
7480         struct nfs_client *clp = cdata->args.client;
7481         int status = task->tk_status;
7482
7483         trace_nfs4_exchange_id(clp, status);
7484
7485         if (status == 0)
7486                 status = nfs4_check_cl_exchange_flags(cdata->res.flags);
7487
7488         if (cdata->xprt && status == 0) {
7489                 status = nfs4_detect_session_trunking(clp, &cdata->res,
7490                                                       cdata->xprt);
7491                 goto out;
7492         }
7493
7494         if (status  == 0)
7495                 status = nfs4_sp4_select_mode(clp, &cdata->res.state_protect);
7496
7497         if (status == 0) {
7498                 clp->cl_clientid = cdata->res.clientid;
7499                 clp->cl_exchange_flags = cdata->res.flags;
7500                 /* Client ID is not confirmed */
7501                 if (!(cdata->res.flags & EXCHGID4_FLAG_CONFIRMED_R)) {
7502                         clear_bit(NFS4_SESSION_ESTABLISHED,
7503                         &clp->cl_session->session_state);
7504                         clp->cl_seqid = cdata->res.seqid;
7505                 }
7506
7507                 kfree(clp->cl_serverowner);
7508                 clp->cl_serverowner = cdata->res.server_owner;
7509                 cdata->res.server_owner = NULL;
7510
7511                 /* use the most recent implementation id */
7512                 kfree(clp->cl_implid);
7513                 clp->cl_implid = cdata->res.impl_id;
7514                 cdata->res.impl_id = NULL;
7515
7516                 if (clp->cl_serverscope != NULL &&
7517                     !nfs41_same_server_scope(clp->cl_serverscope,
7518                                         cdata->res.server_scope)) {
7519                         dprintk("%s: server_scope mismatch detected\n",
7520                                 __func__);
7521                         set_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state);
7522                         kfree(clp->cl_serverscope);
7523                         clp->cl_serverscope = NULL;
7524                 }
7525
7526                 if (clp->cl_serverscope == NULL) {
7527                         clp->cl_serverscope = cdata->res.server_scope;
7528                         cdata->res.server_scope = NULL;
7529                 }
7530                 /* Save the EXCHANGE_ID verifier session trunk tests */
7531                 memcpy(clp->cl_confirm.data, cdata->args.verifier->data,
7532                        sizeof(clp->cl_confirm.data));
7533         }
7534 out:
7535         cdata->rpc_status = status;
7536         return;
7537 }
7538
7539 static void nfs4_exchange_id_release(void *data)
7540 {
7541         struct nfs41_exchange_id_data *cdata =
7542                                         (struct nfs41_exchange_id_data *)data;
7543
7544         nfs_put_client(cdata->args.client);
7545         if (cdata->xprt) {
7546                 xprt_put(cdata->xprt);
7547                 rpc_clnt_xprt_switch_put(cdata->args.client->cl_rpcclient);
7548         }
7549         kfree(cdata->res.impl_id);
7550         kfree(cdata->res.server_scope);
7551         kfree(cdata->res.server_owner);
7552         kfree(cdata);
7553 }
7554
7555 static const struct rpc_call_ops nfs4_exchange_id_call_ops = {
7556         .rpc_call_done = nfs4_exchange_id_done,
7557         .rpc_release = nfs4_exchange_id_release,
7558 };
7559
7560 /*
7561  * _nfs4_proc_exchange_id()
7562  *
7563  * Wrapper for EXCHANGE_ID operation.
7564  */
7565 static int _nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred,
7566                         u32 sp4_how, struct rpc_xprt *xprt)
7567 {
7568         nfs4_verifier verifier;
7569         struct rpc_message msg = {
7570                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_EXCHANGE_ID],
7571                 .rpc_cred = cred,
7572         };
7573         struct rpc_task_setup task_setup_data = {
7574                 .rpc_client = clp->cl_rpcclient,
7575                 .callback_ops = &nfs4_exchange_id_call_ops,
7576                 .rpc_message = &msg,
7577                 .flags = RPC_TASK_ASYNC | RPC_TASK_TIMEOUT,
7578         };
7579         struct nfs41_exchange_id_data *calldata;
7580         struct rpc_task *task;
7581         int status = -EIO;
7582
7583         if (!atomic_inc_not_zero(&clp->cl_count))
7584                 goto out;
7585
7586         status = -ENOMEM;
7587         calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
7588         if (!calldata)
7589                 goto out;
7590
7591         if (!xprt)
7592                 nfs4_init_boot_verifier(clp, &verifier);
7593
7594         status = nfs4_init_uniform_client_string(clp);
7595         if (status)
7596                 goto out_calldata;
7597
7598         dprintk("NFS call  exchange_id auth=%s, '%s'\n",
7599                 clp->cl_rpcclient->cl_auth->au_ops->au_name,
7600                 clp->cl_owner_id);
7601
7602         calldata->res.server_owner = kzalloc(sizeof(struct nfs41_server_owner),
7603                                                 GFP_NOFS);
7604         status = -ENOMEM;
7605         if (unlikely(calldata->res.server_owner == NULL))
7606                 goto out_calldata;
7607
7608         calldata->res.server_scope = kzalloc(sizeof(struct nfs41_server_scope),
7609                                         GFP_NOFS);
7610         if (unlikely(calldata->res.server_scope == NULL))
7611                 goto out_server_owner;
7612
7613         calldata->res.impl_id = kzalloc(sizeof(struct nfs41_impl_id), GFP_NOFS);
7614         if (unlikely(calldata->res.impl_id == NULL))
7615                 goto out_server_scope;
7616
7617         switch (sp4_how) {
7618         case SP4_NONE:
7619                 calldata->args.state_protect.how = SP4_NONE;
7620                 break;
7621
7622         case SP4_MACH_CRED:
7623                 calldata->args.state_protect = nfs4_sp4_mach_cred_request;
7624                 break;
7625
7626         default:
7627                 /* unsupported! */
7628                 WARN_ON_ONCE(1);
7629                 status = -EINVAL;
7630                 goto out_impl_id;
7631         }
7632         if (xprt) {
7633                 calldata->xprt = xprt;
7634                 task_setup_data.rpc_xprt = xprt;
7635                 task_setup_data.flags =
7636                                 RPC_TASK_SOFT|RPC_TASK_SOFTCONN|RPC_TASK_ASYNC;
7637                 calldata->args.verifier = &clp->cl_confirm;
7638         } else {
7639                 calldata->args.verifier = &verifier;
7640         }
7641         calldata->args.client = clp;
7642 #ifdef CONFIG_NFS_V4_1_MIGRATION
7643         calldata->args.flags = EXCHGID4_FLAG_SUPP_MOVED_REFER |
7644         EXCHGID4_FLAG_BIND_PRINC_STATEID |
7645         EXCHGID4_FLAG_SUPP_MOVED_MIGR,
7646 #else
7647         calldata->args.flags = EXCHGID4_FLAG_SUPP_MOVED_REFER |
7648         EXCHGID4_FLAG_BIND_PRINC_STATEID,
7649 #endif
7650         msg.rpc_argp = &calldata->args;
7651         msg.rpc_resp = &calldata->res;
7652         task_setup_data.callback_data = calldata;
7653
7654         task = rpc_run_task(&task_setup_data);
7655         if (IS_ERR(task)) {
7656         status = PTR_ERR(task);
7657                 goto out_impl_id;
7658         }
7659
7660         if (!xprt) {
7661                 status = rpc_wait_for_completion_task(task);
7662                 if (!status)
7663                         status = calldata->rpc_status;
7664         } else  /* session trunking test */
7665                 status = calldata->rpc_status;
7666
7667         rpc_put_task(task);
7668 out:
7669         if (clp->cl_implid != NULL)
7670                 dprintk("NFS reply exchange_id: Server Implementation ID: "
7671                         "domain: %s, name: %s, date: %llu,%u\n",
7672                         clp->cl_implid->domain, clp->cl_implid->name,
7673                         clp->cl_implid->date.seconds,
7674                         clp->cl_implid->date.nseconds);
7675         dprintk("NFS reply exchange_id: %d\n", status);
7676         return status;
7677
7678 out_impl_id:
7679         kfree(calldata->res.impl_id);
7680 out_server_scope:
7681         kfree(calldata->res.server_scope);
7682 out_server_owner:
7683         kfree(calldata->res.server_owner);
7684 out_calldata:
7685         kfree(calldata);
7686         goto out;
7687 }
7688
7689 /*
7690  * nfs4_proc_exchange_id()
7691  *
7692  * Returns zero, a negative errno, or a negative NFS4ERR status code.
7693  *
7694  * Since the clientid has expired, all compounds using sessions
7695  * associated with the stale clientid will be returning
7696  * NFS4ERR_BADSESSION in the sequence operation, and will therefore
7697  * be in some phase of session reset.
7698  *
7699  * Will attempt to negotiate SP4_MACH_CRED if krb5i / krb5p auth is used.
7700  */
7701 int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)
7702 {
7703         rpc_authflavor_t authflavor = clp->cl_rpcclient->cl_auth->au_flavor;
7704         int status;
7705
7706         /* try SP4_MACH_CRED if krb5i/p */
7707         if (authflavor == RPC_AUTH_GSS_KRB5I ||
7708             authflavor == RPC_AUTH_GSS_KRB5P) {
7709                 status = _nfs4_proc_exchange_id(clp, cred, SP4_MACH_CRED, NULL);
7710                 if (!status)
7711                         return 0;
7712         }
7713
7714         /* try SP4_NONE */
7715         return _nfs4_proc_exchange_id(clp, cred, SP4_NONE, NULL);
7716 }
7717
7718 /**
7719  * nfs4_test_session_trunk
7720  *
7721  * This is an add_xprt_test() test function called from
7722  * rpc_clnt_setup_test_and_add_xprt.
7723  *
7724  * The rpc_xprt_switch is referrenced by rpc_clnt_setup_test_and_add_xprt
7725  * and is dereferrenced in nfs4_exchange_id_release
7726  *
7727  * Upon success, add the new transport to the rpc_clnt
7728  *
7729  * @clnt: struct rpc_clnt to get new transport
7730  * @xprt: the rpc_xprt to test
7731  * @data: call data for _nfs4_proc_exchange_id.
7732  */
7733 int nfs4_test_session_trunk(struct rpc_clnt *clnt, struct rpc_xprt *xprt,
7734                             void *data)
7735 {
7736         struct nfs4_add_xprt_data *adata = (struct nfs4_add_xprt_data *)data;
7737         u32 sp4_how;
7738
7739         dprintk("--> %s try %s\n", __func__,
7740                 xprt->address_strings[RPC_DISPLAY_ADDR]);
7741
7742         sp4_how = (adata->clp->cl_sp4_flags == 0 ? SP4_NONE : SP4_MACH_CRED);
7743
7744         /* Test connection for session trunking. Async exchange_id call */
7745         return  _nfs4_proc_exchange_id(adata->clp, adata->cred, sp4_how, xprt);
7746 }
7747 EXPORT_SYMBOL_GPL(nfs4_test_session_trunk);
7748
7749 static int _nfs4_proc_destroy_clientid(struct nfs_client *clp,
7750                 struct rpc_cred *cred)
7751 {
7752         struct rpc_message msg = {
7753                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_CLIENTID],
7754                 .rpc_argp = clp,
7755                 .rpc_cred = cred,
7756         };
7757         int status;
7758
7759         status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
7760         trace_nfs4_destroy_clientid(clp, status);
7761         if (status)
7762                 dprintk("NFS: Got error %d from the server %s on "
7763                         "DESTROY_CLIENTID.", status, clp->cl_hostname);
7764         return status;
7765 }
7766
7767 static int nfs4_proc_destroy_clientid(struct nfs_client *clp,
7768                 struct rpc_cred *cred)
7769 {
7770         unsigned int loop;
7771         int ret;
7772
7773         for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) {
7774                 ret = _nfs4_proc_destroy_clientid(clp, cred);
7775                 switch (ret) {
7776                 case -NFS4ERR_DELAY:
7777                 case -NFS4ERR_CLIENTID_BUSY:
7778                         ssleep(1);
7779                         break;
7780                 default:
7781                         return ret;
7782                 }
7783         }
7784         return 0;
7785 }
7786
7787 int nfs4_destroy_clientid(struct nfs_client *clp)
7788 {
7789         struct rpc_cred *cred;
7790         int ret = 0;
7791
7792         if (clp->cl_mvops->minor_version < 1)
7793                 goto out;
7794         if (clp->cl_exchange_flags == 0)
7795                 goto out;
7796         if (clp->cl_preserve_clid)
7797                 goto out;
7798         cred = nfs4_get_clid_cred(clp);
7799         ret = nfs4_proc_destroy_clientid(clp, cred);
7800         if (cred)
7801                 put_rpccred(cred);
7802         switch (ret) {
7803         case 0:
7804         case -NFS4ERR_STALE_CLIENTID:
7805                 clp->cl_exchange_flags = 0;
7806         }
7807 out:
7808         return ret;
7809 }
7810
7811 struct nfs4_get_lease_time_data {
7812         struct nfs4_get_lease_time_args *args;
7813         struct nfs4_get_lease_time_res *res;
7814         struct nfs_client *clp;
7815 };
7816
7817 static void nfs4_get_lease_time_prepare(struct rpc_task *task,
7818                                         void *calldata)
7819 {
7820         struct nfs4_get_lease_time_data *data =
7821                         (struct nfs4_get_lease_time_data *)calldata;
7822
7823         dprintk("--> %s\n", __func__);
7824         /* just setup sequence, do not trigger session recovery
7825            since we're invoked within one */
7826         nfs41_setup_sequence(data->clp->cl_session,
7827                         &data->args->la_seq_args,
7828                         &data->res->lr_seq_res,
7829                         task);
7830         dprintk("<-- %s\n", __func__);
7831 }
7832
7833 /*
7834  * Called from nfs4_state_manager thread for session setup, so don't recover
7835  * from sequence operation or clientid errors.
7836  */
7837 static void nfs4_get_lease_time_done(struct rpc_task *task, void *calldata)
7838 {
7839         struct nfs4_get_lease_time_data *data =
7840                         (struct nfs4_get_lease_time_data *)calldata;
7841
7842         dprintk("--> %s\n", __func__);
7843         if (!nfs41_sequence_done(task, &data->res->lr_seq_res))
7844                 return;
7845         switch (task->tk_status) {
7846         case -NFS4ERR_DELAY:
7847         case -NFS4ERR_GRACE:
7848                 dprintk("%s Retry: tk_status %d\n", __func__, task->tk_status);
7849                 rpc_delay(task, NFS4_POLL_RETRY_MIN);
7850                 task->tk_status = 0;
7851                 /* fall through */
7852         case -NFS4ERR_RETRY_UNCACHED_REP:
7853                 rpc_restart_call_prepare(task);
7854                 return;
7855         }
7856         dprintk("<-- %s\n", __func__);
7857 }
7858
7859 static const struct rpc_call_ops nfs4_get_lease_time_ops = {
7860         .rpc_call_prepare = nfs4_get_lease_time_prepare,
7861         .rpc_call_done = nfs4_get_lease_time_done,
7862 };
7863
7864 int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo)
7865 {
7866         struct rpc_task *task;
7867         struct nfs4_get_lease_time_args args;
7868         struct nfs4_get_lease_time_res res = {
7869                 .lr_fsinfo = fsinfo,
7870         };
7871         struct nfs4_get_lease_time_data data = {
7872                 .args = &args,
7873                 .res = &res,
7874                 .clp = clp,
7875         };
7876         struct rpc_message msg = {
7877                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GET_LEASE_TIME],
7878                 .rpc_argp = &args,
7879                 .rpc_resp = &res,
7880         };
7881         struct rpc_task_setup task_setup = {
7882                 .rpc_client = clp->cl_rpcclient,
7883                 .rpc_message = &msg,
7884                 .callback_ops = &nfs4_get_lease_time_ops,
7885                 .callback_data = &data,
7886                 .flags = RPC_TASK_TIMEOUT,
7887         };
7888         int status;
7889
7890         nfs4_init_sequence(&args.la_seq_args, &res.lr_seq_res, 0);
7891         nfs4_set_sequence_privileged(&args.la_seq_args);
7892         dprintk("--> %s\n", __func__);
7893         task = rpc_run_task(&task_setup);
7894
7895         if (IS_ERR(task))
7896                 status = PTR_ERR(task);
7897         else {
7898                 status = task->tk_status;
7899                 rpc_put_task(task);
7900         }
7901         dprintk("<-- %s return %d\n", __func__, status);
7902
7903         return status;
7904 }
7905
7906 /*
7907  * Initialize the values to be used by the client in CREATE_SESSION
7908  * If nfs4_init_session set the fore channel request and response sizes,
7909  * use them.
7910  *
7911  * Set the back channel max_resp_sz_cached to zero to force the client to
7912  * always set csa_cachethis to FALSE because the current implementation
7913  * of the back channel DRC only supports caching the CB_SEQUENCE operation.
7914  */
7915 static void nfs4_init_channel_attrs(struct nfs41_create_session_args *args,
7916                                     struct rpc_clnt *clnt)
7917 {
7918         unsigned int max_rqst_sz, max_resp_sz;
7919         unsigned int max_bc_payload = rpc_max_bc_payload(clnt);
7920
7921         max_rqst_sz = NFS_MAX_FILE_IO_SIZE + nfs41_maxwrite_overhead;
7922         max_resp_sz = NFS_MAX_FILE_IO_SIZE + nfs41_maxread_overhead;
7923
7924         /* Fore channel attributes */
7925         args->fc_attrs.max_rqst_sz = max_rqst_sz;
7926         args->fc_attrs.max_resp_sz = max_resp_sz;
7927         args->fc_attrs.max_ops = NFS4_MAX_OPS;
7928         args->fc_attrs.max_reqs = max_session_slots;
7929
7930         dprintk("%s: Fore Channel : max_rqst_sz=%u max_resp_sz=%u "
7931                 "max_ops=%u max_reqs=%u\n",
7932                 __func__,
7933                 args->fc_attrs.max_rqst_sz, args->fc_attrs.max_resp_sz,
7934                 args->fc_attrs.max_ops, args->fc_attrs.max_reqs);
7935
7936         /* Back channel attributes */
7937         args->bc_attrs.max_rqst_sz = max_bc_payload;
7938         args->bc_attrs.max_resp_sz = max_bc_payload;
7939         args->bc_attrs.max_resp_sz_cached = 0;
7940         args->bc_attrs.max_ops = NFS4_MAX_BACK_CHANNEL_OPS;
7941         args->bc_attrs.max_reqs = min_t(unsigned short, max_session_cb_slots, 1);
7942
7943         dprintk("%s: Back Channel : max_rqst_sz=%u max_resp_sz=%u "
7944                 "max_resp_sz_cached=%u max_ops=%u max_reqs=%u\n",
7945                 __func__,
7946                 args->bc_attrs.max_rqst_sz, args->bc_attrs.max_resp_sz,
7947                 args->bc_attrs.max_resp_sz_cached, args->bc_attrs.max_ops,
7948                 args->bc_attrs.max_reqs);
7949 }
7950
7951 static int nfs4_verify_fore_channel_attrs(struct nfs41_create_session_args *args,
7952                 struct nfs41_create_session_res *res)
7953 {
7954         struct nfs4_channel_attrs *sent = &args->fc_attrs;
7955         struct nfs4_channel_attrs *rcvd = &res->fc_attrs;
7956
7957         if (rcvd->max_resp_sz > sent->max_resp_sz)
7958                 return -EINVAL;
7959         /*
7960          * Our requested max_ops is the minimum we need; we're not
7961          * prepared to break up compounds into smaller pieces than that.
7962          * So, no point even trying to continue if the server won't
7963          * cooperate:
7964          */
7965         if (rcvd->max_ops < sent->max_ops)
7966                 return -EINVAL;
7967         if (rcvd->max_reqs == 0)
7968                 return -EINVAL;
7969         if (rcvd->max_reqs > NFS4_MAX_SLOT_TABLE)
7970                 rcvd->max_reqs = NFS4_MAX_SLOT_TABLE;
7971         return 0;
7972 }
7973
7974 static int nfs4_verify_back_channel_attrs(struct nfs41_create_session_args *args,
7975                 struct nfs41_create_session_res *res)
7976 {
7977         struct nfs4_channel_attrs *sent = &args->bc_attrs;
7978         struct nfs4_channel_attrs *rcvd = &res->bc_attrs;
7979
7980         if (!(res->flags & SESSION4_BACK_CHAN))
7981                 goto out;
7982         if (rcvd->max_rqst_sz > sent->max_rqst_sz)
7983                 return -EINVAL;
7984         if (rcvd->max_resp_sz < sent->max_resp_sz)
7985                 return -EINVAL;
7986         if (rcvd->max_resp_sz_cached > sent->max_resp_sz_cached)
7987                 return -EINVAL;
7988         if (rcvd->max_ops > sent->max_ops)
7989                 return -EINVAL;
7990         if (rcvd->max_reqs > sent->max_reqs)
7991                 return -EINVAL;
7992 out:
7993         return 0;
7994 }
7995
7996 static int nfs4_verify_channel_attrs(struct nfs41_create_session_args *args,
7997                                      struct nfs41_create_session_res *res)
7998 {
7999         int ret;
8000
8001         ret = nfs4_verify_fore_channel_attrs(args, res);
8002         if (ret)
8003                 return ret;
8004         return nfs4_verify_back_channel_attrs(args, res);
8005 }
8006
8007 static void nfs4_update_session(struct nfs4_session *session,
8008                 struct nfs41_create_session_res *res)
8009 {
8010         nfs4_copy_sessionid(&session->sess_id, &res->sessionid);
8011         /* Mark client id and session as being confirmed */
8012         session->clp->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R;
8013         set_bit(NFS4_SESSION_ESTABLISHED, &session->session_state);
8014         session->flags = res->flags;
8015         memcpy(&session->fc_attrs, &res->fc_attrs, sizeof(session->fc_attrs));
8016         if (res->flags & SESSION4_BACK_CHAN)
8017                 memcpy(&session->bc_attrs, &res->bc_attrs,
8018                                 sizeof(session->bc_attrs));
8019 }
8020
8021 static int _nfs4_proc_create_session(struct nfs_client *clp,
8022                 struct rpc_cred *cred)
8023 {
8024         struct nfs4_session *session = clp->cl_session;
8025         struct nfs41_create_session_args args = {
8026                 .client = clp,
8027                 .clientid = clp->cl_clientid,
8028                 .seqid = clp->cl_seqid,
8029                 .cb_program = NFS4_CALLBACK,
8030         };
8031         struct nfs41_create_session_res res;
8032
8033         struct rpc_message msg = {
8034                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE_SESSION],
8035                 .rpc_argp = &args,
8036                 .rpc_resp = &res,
8037                 .rpc_cred = cred,
8038         };
8039         int status;
8040
8041         nfs4_init_channel_attrs(&args, clp->cl_rpcclient);
8042         args.flags = (SESSION4_PERSIST | SESSION4_BACK_CHAN);
8043
8044         status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
8045         trace_nfs4_create_session(clp, status);
8046
8047         switch (status) {
8048         case -NFS4ERR_STALE_CLIENTID:
8049         case -NFS4ERR_DELAY:
8050         case -ETIMEDOUT:
8051         case -EACCES:
8052         case -EAGAIN:
8053                 goto out;
8054         };
8055
8056         clp->cl_seqid++;
8057         if (!status) {
8058                 /* Verify the session's negotiated channel_attrs values */
8059                 status = nfs4_verify_channel_attrs(&args, &res);
8060                 /* Increment the clientid slot sequence id */
8061                 if (status)
8062                         goto out;
8063                 nfs4_update_session(session, &res);
8064         }
8065 out:
8066         return status;
8067 }
8068
8069 /*
8070  * Issues a CREATE_SESSION operation to the server.
8071  * It is the responsibility of the caller to verify the session is
8072  * expired before calling this routine.
8073  */
8074 int nfs4_proc_create_session(struct nfs_client *clp, struct rpc_cred *cred)
8075 {
8076         int status;
8077         unsigned *ptr;
8078         struct nfs4_session *session = clp->cl_session;
8079
8080         dprintk("--> %s clp=%p session=%p\n", __func__, clp, session);
8081
8082         status = _nfs4_proc_create_session(clp, cred);
8083         if (status)
8084                 goto out;
8085
8086         /* Init or reset the session slot tables */
8087         status = nfs4_setup_session_slot_tables(session);
8088         dprintk("slot table setup returned %d\n", status);
8089         if (status)
8090                 goto out;
8091
8092         ptr = (unsigned *)&session->sess_id.data[0];
8093         dprintk("%s client>seqid %d sessionid %u:%u:%u:%u\n", __func__,
8094                 clp->cl_seqid, ptr[0], ptr[1], ptr[2], ptr[3]);
8095 out:
8096         dprintk("<-- %s\n", __func__);
8097         return status;
8098 }
8099
8100 /*
8101  * Issue the over-the-wire RPC DESTROY_SESSION.
8102  * The caller must serialize access to this routine.
8103  */
8104 int nfs4_proc_destroy_session(struct nfs4_session *session,
8105                 struct rpc_cred *cred)
8106 {
8107         struct rpc_message msg = {
8108                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_SESSION],
8109                 .rpc_argp = session,
8110                 .rpc_cred = cred,
8111         };
8112         int status = 0;
8113
8114         dprintk("--> nfs4_proc_destroy_session\n");
8115
8116         /* session is still being setup */
8117         if (!test_and_clear_bit(NFS4_SESSION_ESTABLISHED, &session->session_state))
8118                 return 0;
8119
8120         status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
8121         trace_nfs4_destroy_session(session->clp, status);
8122
8123         if (status)
8124                 dprintk("NFS: Got error %d from the server on DESTROY_SESSION. "
8125                         "Session has been destroyed regardless...\n", status);
8126
8127         dprintk("<-- nfs4_proc_destroy_session\n");
8128         return status;
8129 }
8130
8131 /*
8132  * Renew the cl_session lease.
8133  */
8134 struct nfs4_sequence_data {
8135         struct nfs_client *clp;
8136         struct nfs4_sequence_args args;
8137         struct nfs4_sequence_res res;
8138 };
8139
8140 static void nfs41_sequence_release(void *data)
8141 {
8142         struct nfs4_sequence_data *calldata = data;
8143         struct nfs_client *clp = calldata->clp;
8144
8145         if (atomic_read(&clp->cl_count) > 1)
8146                 nfs4_schedule_state_renewal(clp);
8147         nfs_put_client(clp);
8148         kfree(calldata);
8149 }
8150
8151 static int nfs41_sequence_handle_errors(struct rpc_task *task, struct nfs_client *clp)
8152 {
8153         switch(task->tk_status) {
8154         case -NFS4ERR_DELAY:
8155                 rpc_delay(task, NFS4_POLL_RETRY_MAX);
8156                 return -EAGAIN;
8157         default:
8158                 nfs4_schedule_lease_recovery(clp);
8159         }
8160         return 0;
8161 }
8162
8163 static void nfs41_sequence_call_done(struct rpc_task *task, void *data)
8164 {
8165         struct nfs4_sequence_data *calldata = data;
8166         struct nfs_client *clp = calldata->clp;
8167
8168         if (!nfs41_sequence_done(task, task->tk_msg.rpc_resp))
8169                 return;
8170
8171         trace_nfs4_sequence(clp, task->tk_status);
8172         if (task->tk_status < 0) {
8173                 dprintk("%s ERROR %d\n", __func__, task->tk_status);
8174                 if (atomic_read(&clp->cl_count) == 1)
8175                         goto out;
8176
8177                 if (nfs41_sequence_handle_errors(task, clp) == -EAGAIN) {
8178                         rpc_restart_call_prepare(task);
8179                         return;
8180                 }
8181         }
8182         dprintk("%s rpc_cred %p\n", __func__, task->tk_msg.rpc_cred);
8183 out:
8184         dprintk("<-- %s\n", __func__);
8185 }
8186
8187 static void nfs41_sequence_prepare(struct rpc_task *task, void *data)
8188 {
8189         struct nfs4_sequence_data *calldata = data;
8190         struct nfs_client *clp = calldata->clp;
8191         struct nfs4_sequence_args *args;
8192         struct nfs4_sequence_res *res;
8193
8194         args = task->tk_msg.rpc_argp;
8195         res = task->tk_msg.rpc_resp;
8196
8197         nfs41_setup_sequence(clp->cl_session, args, res, task);
8198 }
8199
8200 static const struct rpc_call_ops nfs41_sequence_ops = {
8201         .rpc_call_done = nfs41_sequence_call_done,
8202         .rpc_call_prepare = nfs41_sequence_prepare,
8203         .rpc_release = nfs41_sequence_release,
8204 };
8205
8206 static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp,
8207                 struct rpc_cred *cred,
8208                 bool is_privileged)
8209 {
8210         struct nfs4_sequence_data *calldata;
8211         struct rpc_message msg = {
8212                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE],
8213                 .rpc_cred = cred,
8214         };
8215         struct rpc_task_setup task_setup_data = {
8216                 .rpc_client = clp->cl_rpcclient,
8217                 .rpc_message = &msg,
8218                 .callback_ops = &nfs41_sequence_ops,
8219                 .flags = RPC_TASK_ASYNC | RPC_TASK_TIMEOUT,
8220         };
8221
8222         if (!atomic_inc_not_zero(&clp->cl_count))
8223                 return ERR_PTR(-EIO);
8224         calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
8225         if (calldata == NULL) {
8226                 nfs_put_client(clp);
8227                 return ERR_PTR(-ENOMEM);
8228         }
8229         nfs4_init_sequence(&calldata->args, &calldata->res, 0);
8230         if (is_privileged)
8231                 nfs4_set_sequence_privileged(&calldata->args);
8232         msg.rpc_argp = &calldata->args;
8233         msg.rpc_resp = &calldata->res;
8234         calldata->clp = clp;
8235         task_setup_data.callback_data = calldata;
8236
8237         return rpc_run_task(&task_setup_data);
8238 }
8239
8240 static int nfs41_proc_async_sequence(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags)
8241 {
8242         struct rpc_task *task;
8243         int ret = 0;
8244
8245         if ((renew_flags & NFS4_RENEW_TIMEOUT) == 0)
8246                 return -EAGAIN;
8247         task = _nfs41_proc_sequence(clp, cred, false);
8248         if (IS_ERR(task))
8249                 ret = PTR_ERR(task);
8250         else
8251                 rpc_put_task_async(task);
8252         dprintk("<-- %s status=%d\n", __func__, ret);
8253         return ret;
8254 }
8255
8256 static int nfs4_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred)
8257 {
8258         struct rpc_task *task;
8259         int ret;
8260
8261         task = _nfs41_proc_sequence(clp, cred, true);
8262         if (IS_ERR(task)) {
8263                 ret = PTR_ERR(task);
8264                 goto out;
8265         }
8266         ret = rpc_wait_for_completion_task(task);
8267         if (!ret)
8268                 ret = task->tk_status;
8269         rpc_put_task(task);
8270 out:
8271         dprintk("<-- %s status=%d\n", __func__, ret);
8272         return ret;
8273 }
8274
8275 struct nfs4_reclaim_complete_data {
8276         struct nfs_client *clp;
8277         struct nfs41_reclaim_complete_args arg;
8278         struct nfs41_reclaim_complete_res res;
8279 };
8280
8281 static void nfs4_reclaim_complete_prepare(struct rpc_task *task, void *data)
8282 {
8283         struct nfs4_reclaim_complete_data *calldata = data;
8284
8285         nfs41_setup_sequence(calldata->clp->cl_session,
8286                         &calldata->arg.seq_args,
8287                         &calldata->res.seq_res,
8288                         task);
8289 }
8290
8291 static int nfs41_reclaim_complete_handle_errors(struct rpc_task *task, struct nfs_client *clp)
8292 {
8293         switch(task->tk_status) {
8294         case 0:
8295         case -NFS4ERR_COMPLETE_ALREADY:
8296         case -NFS4ERR_WRONG_CRED: /* What to do here? */
8297                 break;
8298         case -NFS4ERR_DELAY:
8299                 rpc_delay(task, NFS4_POLL_RETRY_MAX);
8300                 /* fall through */
8301         case -NFS4ERR_RETRY_UNCACHED_REP:
8302                 return -EAGAIN;
8303         default:
8304                 nfs4_schedule_lease_recovery(clp);
8305         }
8306         return 0;
8307 }
8308
8309 static void nfs4_reclaim_complete_done(struct rpc_task *task, void *data)
8310 {
8311         struct nfs4_reclaim_complete_data *calldata = data;
8312         struct nfs_client *clp = calldata->clp;
8313         struct nfs4_sequence_res *res = &calldata->res.seq_res;
8314
8315         dprintk("--> %s\n", __func__);
8316         if (!nfs41_sequence_done(task, res))
8317                 return;
8318
8319         trace_nfs4_reclaim_complete(clp, task->tk_status);
8320         if (nfs41_reclaim_complete_handle_errors(task, clp) == -EAGAIN) {
8321                 rpc_restart_call_prepare(task);
8322                 return;
8323         }
8324         dprintk("<-- %s\n", __func__);
8325 }
8326
8327 static void nfs4_free_reclaim_complete_data(void *data)
8328 {
8329         struct nfs4_reclaim_complete_data *calldata = data;
8330
8331         kfree(calldata);
8332 }
8333
8334 static const struct rpc_call_ops nfs4_reclaim_complete_call_ops = {
8335         .rpc_call_prepare = nfs4_reclaim_complete_prepare,
8336         .rpc_call_done = nfs4_reclaim_complete_done,
8337         .rpc_release = nfs4_free_reclaim_complete_data,
8338 };
8339
8340 /*
8341  * Issue a global reclaim complete.
8342  */
8343 static int nfs41_proc_reclaim_complete(struct nfs_client *clp,
8344                 struct rpc_cred *cred)
8345 {
8346         struct nfs4_reclaim_complete_data *calldata;
8347         struct rpc_task *task;
8348         struct rpc_message msg = {
8349                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RECLAIM_COMPLETE],
8350                 .rpc_cred = cred,
8351         };
8352         struct rpc_task_setup task_setup_data = {
8353                 .rpc_client = clp->cl_rpcclient,
8354                 .rpc_message = &msg,
8355                 .callback_ops = &nfs4_reclaim_complete_call_ops,
8356                 .flags = RPC_TASK_ASYNC,
8357         };
8358         int status = -ENOMEM;
8359
8360         dprintk("--> %s\n", __func__);
8361         calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
8362         if (calldata == NULL)
8363                 goto out;
8364         calldata->clp = clp;
8365         calldata->arg.one_fs = 0;
8366
8367         nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 0);
8368         nfs4_set_sequence_privileged(&calldata->arg.seq_args);
8369         msg.rpc_argp = &calldata->arg;
8370         msg.rpc_resp = &calldata->res;
8371         task_setup_data.callback_data = calldata;
8372         task = rpc_run_task(&task_setup_data);
8373         if (IS_ERR(task)) {
8374                 status = PTR_ERR(task);
8375                 goto out;
8376         }
8377         status = nfs4_wait_for_completion_rpc_task(task);
8378         if (status == 0)
8379                 status = task->tk_status;
8380         rpc_put_task(task);
8381         return 0;
8382 out:
8383         dprintk("<-- %s status=%d\n", __func__, status);
8384         return status;
8385 }
8386
8387 static void
8388 nfs4_layoutget_prepare(struct rpc_task *task, void *calldata)
8389 {
8390         struct nfs4_layoutget *lgp = calldata;
8391         struct nfs_server *server = NFS_SERVER(lgp->args.inode);
8392         struct nfs4_session *session = nfs4_get_session(server);
8393
8394         dprintk("--> %s\n", __func__);
8395         nfs41_setup_sequence(session, &lgp->args.seq_args,
8396                                 &lgp->res.seq_res, task);
8397         dprintk("<-- %s\n", __func__);
8398 }
8399
8400 static void nfs4_layoutget_done(struct rpc_task *task, void *calldata)
8401 {
8402         struct nfs4_layoutget *lgp = calldata;
8403
8404         dprintk("--> %s\n", __func__);
8405         nfs41_sequence_process(task, &lgp->res.seq_res);
8406         dprintk("<-- %s\n", __func__);
8407 }
8408
8409 static int
8410 nfs4_layoutget_handle_exception(struct rpc_task *task,
8411                 struct nfs4_layoutget *lgp, struct nfs4_exception *exception)
8412 {
8413         struct inode *inode = lgp->args.inode;
8414         struct nfs_server *server = NFS_SERVER(inode);
8415         struct pnfs_layout_hdr *lo;
8416         int nfs4err = task->tk_status;
8417         int err, status = 0;
8418         LIST_HEAD(head);
8419
8420         dprintk("--> %s tk_status => %d\n", __func__, -task->tk_status);
8421
8422         switch (nfs4err) {
8423         case 0:
8424                 goto out;
8425
8426         /*
8427          * NFS4ERR_LAYOUTUNAVAILABLE means we are not supposed to use pnfs
8428          * on the file. set tk_status to -ENODATA to tell upper layer to
8429          * retry go inband.
8430          */
8431         case -NFS4ERR_LAYOUTUNAVAILABLE:
8432                 status = -ENODATA;
8433                 goto out;
8434         /*
8435          * NFS4ERR_BADLAYOUT means the MDS cannot return a layout of
8436          * length lgp->args.minlength != 0 (see RFC5661 section 18.43.3).
8437          */
8438         case -NFS4ERR_BADLAYOUT:
8439                 status = -EOVERFLOW;
8440                 goto out;
8441         /*
8442          * NFS4ERR_LAYOUTTRYLATER is a conflict with another client
8443          * (or clients) writing to the same RAID stripe except when
8444          * the minlength argument is 0 (see RFC5661 section 18.43.3).
8445          *
8446          * Treat it like we would RECALLCONFLICT -- we retry for a little
8447          * while, and then eventually give up.
8448          */
8449         case -NFS4ERR_LAYOUTTRYLATER:
8450                 if (lgp->args.minlength == 0) {
8451                         status = -EOVERFLOW;
8452                         goto out;
8453                 }
8454                 status = -EBUSY;
8455                 break;
8456         case -NFS4ERR_RECALLCONFLICT:
8457                 status = -ERECALLCONFLICT;
8458                 break;
8459         case -NFS4ERR_DELEG_REVOKED:
8460         case -NFS4ERR_ADMIN_REVOKED:
8461         case -NFS4ERR_EXPIRED:
8462         case -NFS4ERR_BAD_STATEID:
8463                 exception->timeout = 0;
8464                 spin_lock(&inode->i_lock);
8465                 lo = NFS_I(inode)->layout;
8466                 /* If the open stateid was bad, then recover it. */
8467                 if (!lo || test_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags) ||
8468                     nfs4_stateid_match_other(&lgp->args.stateid,
8469                                         &lgp->args.ctx->state->stateid)) {
8470                         spin_unlock(&inode->i_lock);
8471                         exception->state = lgp->args.ctx->state;
8472                         exception->stateid = &lgp->args.stateid;
8473                         break;
8474                 }
8475
8476                 /*
8477                  * Mark the bad layout state as invalid, then retry
8478                  */
8479                 pnfs_mark_layout_stateid_invalid(lo, &head);
8480                 spin_unlock(&inode->i_lock);
8481                 pnfs_free_lseg_list(&head);
8482                 status = -EAGAIN;
8483                 goto out;
8484         }
8485
8486         err = nfs4_handle_exception(server, nfs4err, exception);
8487         if (!status) {
8488                 if (exception->retry)
8489                         status = -EAGAIN;
8490                 else
8491                         status = err;
8492         }
8493 out:
8494         dprintk("<-- %s\n", __func__);
8495         return status;
8496 }
8497
8498 static size_t max_response_pages(struct nfs_server *server)
8499 {
8500         u32 max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;
8501         return nfs_page_array_len(0, max_resp_sz);
8502 }
8503
8504 static void nfs4_free_pages(struct page **pages, size_t size)
8505 {
8506         int i;
8507
8508         if (!pages)
8509                 return;
8510
8511         for (i = 0; i < size; i++) {
8512                 if (!pages[i])
8513                         break;
8514                 __free_page(pages[i]);
8515         }
8516         kfree(pages);
8517 }
8518
8519 static struct page **nfs4_alloc_pages(size_t size, gfp_t gfp_flags)
8520 {
8521         struct page **pages;
8522         int i;
8523
8524         pages = kcalloc(size, sizeof(struct page *), gfp_flags);
8525         if (!pages) {
8526                 dprintk("%s: can't alloc array of %zu pages\n", __func__, size);
8527                 return NULL;
8528         }
8529
8530         for (i = 0; i < size; i++) {
8531                 pages[i] = alloc_page(gfp_flags);
8532                 if (!pages[i]) {
8533                         dprintk("%s: failed to allocate page\n", __func__);
8534                         nfs4_free_pages(pages, size);
8535                         return NULL;
8536                 }
8537         }
8538
8539         return pages;
8540 }
8541
8542 static void nfs4_layoutget_release(void *calldata)
8543 {
8544         struct nfs4_layoutget *lgp = calldata;
8545         struct inode *inode = lgp->args.inode;
8546         struct nfs_server *server = NFS_SERVER(inode);
8547         size_t max_pages = max_response_pages(server);
8548
8549         dprintk("--> %s\n", __func__);
8550         nfs4_free_pages(lgp->args.layout.pages, max_pages);
8551         pnfs_put_layout_hdr(NFS_I(inode)->layout);
8552         put_nfs_open_context(lgp->args.ctx);
8553         kfree(calldata);
8554         dprintk("<-- %s\n", __func__);
8555 }
8556
8557 static const struct rpc_call_ops nfs4_layoutget_call_ops = {
8558         .rpc_call_prepare = nfs4_layoutget_prepare,
8559         .rpc_call_done = nfs4_layoutget_done,
8560         .rpc_release = nfs4_layoutget_release,
8561 };
8562
8563 struct pnfs_layout_segment *
8564 nfs4_proc_layoutget(struct nfs4_layoutget *lgp, long *timeout, gfp_t gfp_flags)
8565 {
8566         struct inode *inode = lgp->args.inode;
8567         struct nfs_server *server = NFS_SERVER(inode);
8568         size_t max_pages = max_response_pages(server);
8569         struct rpc_task *task;
8570         struct rpc_message msg = {
8571                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTGET],
8572                 .rpc_argp = &lgp->args,
8573                 .rpc_resp = &lgp->res,
8574                 .rpc_cred = lgp->cred,
8575         };
8576         struct rpc_task_setup task_setup_data = {
8577                 .rpc_client = server->client,
8578                 .rpc_message = &msg,
8579                 .callback_ops = &nfs4_layoutget_call_ops,
8580                 .callback_data = lgp,
8581                 .flags = RPC_TASK_ASYNC,
8582         };
8583         struct pnfs_layout_segment *lseg = NULL;
8584         struct nfs4_exception exception = {
8585                 .inode = inode,
8586                 .timeout = *timeout,
8587         };
8588         int status = 0;
8589
8590         dprintk("--> %s\n", __func__);
8591
8592         /* nfs4_layoutget_release calls pnfs_put_layout_hdr */
8593         pnfs_get_layout_hdr(NFS_I(inode)->layout);
8594
8595         lgp->args.layout.pages = nfs4_alloc_pages(max_pages, gfp_flags);
8596         if (!lgp->args.layout.pages) {
8597                 nfs4_layoutget_release(lgp);
8598                 return ERR_PTR(-ENOMEM);
8599         }
8600         lgp->args.layout.pglen = max_pages * PAGE_SIZE;
8601
8602         lgp->res.layoutp = &lgp->args.layout;
8603         lgp->res.seq_res.sr_slot = NULL;
8604         nfs4_init_sequence(&lgp->args.seq_args, &lgp->res.seq_res, 0);
8605
8606         task = rpc_run_task(&task_setup_data);
8607         if (IS_ERR(task))
8608                 return ERR_CAST(task);
8609         status = nfs4_wait_for_completion_rpc_task(task);
8610         if (status == 0) {
8611                 status = nfs4_layoutget_handle_exception(task, lgp, &exception);
8612                 *timeout = exception.timeout;
8613         }
8614
8615         trace_nfs4_layoutget(lgp->args.ctx,
8616                         &lgp->args.range,
8617                         &lgp->res.range,
8618                         &lgp->res.stateid,
8619                         status);
8620
8621         /* if layoutp->len is 0, nfs4_layoutget_prepare called rpc_exit */
8622         if (status == 0 && lgp->res.layoutp->len)
8623                 lseg = pnfs_layout_process(lgp);
8624         nfs4_sequence_free_slot(&lgp->res.seq_res);
8625         rpc_put_task(task);
8626         dprintk("<-- %s status=%d\n", __func__, status);
8627         if (status)
8628                 return ERR_PTR(status);
8629         return lseg;
8630 }
8631
8632 static void
8633 nfs4_layoutreturn_prepare(struct rpc_task *task, void *calldata)
8634 {
8635         struct nfs4_layoutreturn *lrp = calldata;
8636
8637         dprintk("--> %s\n", __func__);
8638         nfs41_setup_sequence(lrp->clp->cl_session,
8639                         &lrp->args.seq_args,
8640                         &lrp->res.seq_res,
8641                         task);
8642 }
8643
8644 static void nfs4_layoutreturn_done(struct rpc_task *task, void *calldata)
8645 {
8646         struct nfs4_layoutreturn *lrp = calldata;
8647         struct nfs_server *server;
8648
8649         dprintk("--> %s\n", __func__);
8650
8651         if (!nfs41_sequence_process(task, &lrp->res.seq_res))
8652                 return;
8653
8654         server = NFS_SERVER(lrp->args.inode);
8655         switch (task->tk_status) {
8656         default:
8657                 task->tk_status = 0;
8658         case 0:
8659                 break;
8660         case -NFS4ERR_DELAY:
8661                 if (nfs4_async_handle_error(task, server, NULL, NULL) != -EAGAIN)
8662                         break;
8663                 nfs4_sequence_free_slot(&lrp->res.seq_res);
8664                 rpc_restart_call_prepare(task);
8665                 return;
8666         }
8667         dprintk("<-- %s\n", __func__);
8668 }
8669
8670 static void nfs4_layoutreturn_release(void *calldata)
8671 {
8672         struct nfs4_layoutreturn *lrp = calldata;
8673         struct pnfs_layout_hdr *lo = lrp->args.layout;
8674
8675         dprintk("--> %s\n", __func__);
8676         pnfs_layoutreturn_free_lsegs(lo, &lrp->args.stateid, &lrp->args.range,
8677                         lrp->res.lrs_present ? &lrp->res.stateid : NULL);
8678         nfs4_sequence_free_slot(&lrp->res.seq_res);
8679         if (lrp->ld_private.ops && lrp->ld_private.ops->free)
8680                 lrp->ld_private.ops->free(&lrp->ld_private);
8681         pnfs_put_layout_hdr(lrp->args.layout);
8682         nfs_iput_and_deactive(lrp->inode);
8683         kfree(calldata);
8684         dprintk("<-- %s\n", __func__);
8685 }
8686
8687 static const struct rpc_call_ops nfs4_layoutreturn_call_ops = {
8688         .rpc_call_prepare = nfs4_layoutreturn_prepare,
8689         .rpc_call_done = nfs4_layoutreturn_done,
8690         .rpc_release = nfs4_layoutreturn_release,
8691 };
8692
8693 int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp, bool sync)
8694 {
8695         struct rpc_task *task;
8696         struct rpc_message msg = {
8697                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTRETURN],
8698                 .rpc_argp = &lrp->args,
8699                 .rpc_resp = &lrp->res,
8700                 .rpc_cred = lrp->cred,
8701         };
8702         struct rpc_task_setup task_setup_data = {
8703                 .rpc_client = NFS_SERVER(lrp->args.inode)->client,
8704                 .rpc_message = &msg,
8705                 .callback_ops = &nfs4_layoutreturn_call_ops,
8706                 .callback_data = lrp,
8707         };
8708         int status = 0;
8709
8710         nfs4_state_protect(NFS_SERVER(lrp->args.inode)->nfs_client,
8711                         NFS_SP4_MACH_CRED_PNFS_CLEANUP,
8712                         &task_setup_data.rpc_client, &msg);
8713
8714         dprintk("--> %s\n", __func__);
8715         if (!sync) {
8716                 lrp->inode = nfs_igrab_and_active(lrp->args.inode);
8717                 if (!lrp->inode) {
8718                         nfs4_layoutreturn_release(lrp);
8719                         return -EAGAIN;
8720                 }
8721                 task_setup_data.flags |= RPC_TASK_ASYNC;
8722         }
8723         nfs4_init_sequence(&lrp->args.seq_args, &lrp->res.seq_res, 1);
8724         task = rpc_run_task(&task_setup_data);
8725         if (IS_ERR(task))
8726                 return PTR_ERR(task);
8727         if (sync)
8728                 status = task->tk_status;
8729         trace_nfs4_layoutreturn(lrp->args.inode, &lrp->args.stateid, status);
8730         dprintk("<-- %s status=%d\n", __func__, status);
8731         rpc_put_task(task);
8732         return status;
8733 }
8734
8735 static int
8736 _nfs4_proc_getdeviceinfo(struct nfs_server *server,
8737                 struct pnfs_device *pdev,
8738                 struct rpc_cred *cred)
8739 {
8740         struct nfs4_getdeviceinfo_args args = {
8741                 .pdev = pdev,
8742                 .notify_types = NOTIFY_DEVICEID4_CHANGE |
8743                         NOTIFY_DEVICEID4_DELETE,
8744         };
8745         struct nfs4_getdeviceinfo_res res = {
8746                 .pdev = pdev,
8747         };
8748         struct rpc_message msg = {
8749                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICEINFO],
8750                 .rpc_argp = &args,
8751                 .rpc_resp = &res,
8752                 .rpc_cred = cred,
8753         };
8754         int status;
8755
8756         dprintk("--> %s\n", __func__);
8757         status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
8758         if (res.notification & ~args.notify_types)
8759                 dprintk("%s: unsupported notification\n", __func__);
8760         if (res.notification != args.notify_types)
8761                 pdev->nocache = 1;
8762
8763         dprintk("<-- %s status=%d\n", __func__, status);
8764
8765         return status;
8766 }
8767
8768 int nfs4_proc_getdeviceinfo(struct nfs_server *server,
8769                 struct pnfs_device *pdev,
8770                 struct rpc_cred *cred)
8771 {
8772         struct nfs4_exception exception = { };
8773         int err;
8774
8775         do {
8776                 err = nfs4_handle_exception(server,
8777                                         _nfs4_proc_getdeviceinfo(server, pdev, cred),
8778                                         &exception);
8779         } while (exception.retry);
8780         return err;
8781 }
8782 EXPORT_SYMBOL_GPL(nfs4_proc_getdeviceinfo);
8783
8784 static void nfs4_layoutcommit_prepare(struct rpc_task *task, void *calldata)
8785 {
8786         struct nfs4_layoutcommit_data *data = calldata;
8787         struct nfs_server *server = NFS_SERVER(data->args.inode);
8788         struct nfs4_session *session = nfs4_get_session(server);
8789
8790         nfs41_setup_sequence(session,
8791                         &data->args.seq_args,
8792                         &data->res.seq_res,
8793                         task);
8794 }
8795
8796 static void
8797 nfs4_layoutcommit_done(struct rpc_task *task, void *calldata)
8798 {
8799         struct nfs4_layoutcommit_data *data = calldata;
8800         struct nfs_server *server = NFS_SERVER(data->args.inode);
8801
8802         if (!nfs41_sequence_done(task, &data->res.seq_res))
8803                 return;
8804
8805         switch (task->tk_status) { /* Just ignore these failures */
8806         case -NFS4ERR_DELEG_REVOKED: /* layout was recalled */
8807         case -NFS4ERR_BADIOMODE:     /* no IOMODE_RW layout for range */
8808         case -NFS4ERR_BADLAYOUT:     /* no layout */
8809         case -NFS4ERR_GRACE:        /* loca_recalim always false */
8810                 task->tk_status = 0;
8811         case 0:
8812                 break;
8813         default:
8814                 if (nfs4_async_handle_error(task, server, NULL, NULL) == -EAGAIN) {
8815                         rpc_restart_call_prepare(task);
8816                         return;
8817                 }
8818         }
8819 }
8820
8821 static void nfs4_layoutcommit_release(void *calldata)
8822 {
8823         struct nfs4_layoutcommit_data *data = calldata;
8824
8825         pnfs_cleanup_layoutcommit(data);
8826         nfs_post_op_update_inode_force_wcc(data->args.inode,
8827                                            data->res.fattr);
8828         put_rpccred(data->cred);
8829         nfs_iput_and_deactive(data->inode);
8830         kfree(data);
8831 }
8832
8833 static const struct rpc_call_ops nfs4_layoutcommit_ops = {
8834         .rpc_call_prepare = nfs4_layoutcommit_prepare,
8835         .rpc_call_done = nfs4_layoutcommit_done,
8836         .rpc_release = nfs4_layoutcommit_release,
8837 };
8838
8839 int
8840 nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, bool sync)
8841 {
8842         struct rpc_message msg = {
8843                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTCOMMIT],
8844                 .rpc_argp = &data->args,
8845                 .rpc_resp = &data->res,
8846                 .rpc_cred = data->cred,
8847         };
8848         struct rpc_task_setup task_setup_data = {
8849                 .task = &data->task,
8850                 .rpc_client = NFS_CLIENT(data->args.inode),
8851                 .rpc_message = &msg,
8852                 .callback_ops = &nfs4_layoutcommit_ops,
8853                 .callback_data = data,
8854         };
8855         struct rpc_task *task;
8856         int status = 0;
8857
8858         dprintk("NFS: initiating layoutcommit call. sync %d "
8859                 "lbw: %llu inode %lu\n", sync,
8860                 data->args.lastbytewritten,
8861                 data->args.inode->i_ino);
8862
8863         if (!sync) {
8864                 data->inode = nfs_igrab_and_active(data->args.inode);
8865                 if (data->inode == NULL) {
8866                         nfs4_layoutcommit_release(data);
8867                         return -EAGAIN;
8868                 }
8869                 task_setup_data.flags = RPC_TASK_ASYNC;
8870         }
8871         nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
8872         task = rpc_run_task(&task_setup_data);
8873         if (IS_ERR(task))
8874                 return PTR_ERR(task);
8875         if (sync)
8876                 status = task->tk_status;
8877         trace_nfs4_layoutcommit(data->args.inode, &data->args.stateid, status);
8878         dprintk("%s: status %d\n", __func__, status);
8879         rpc_put_task(task);
8880         return status;
8881 }
8882
8883 /**
8884  * Use the state managment nfs_client cl_rpcclient, which uses krb5i (if
8885  * possible) as per RFC3530bis and RFC5661 Security Considerations sections
8886  */
8887 static int
8888 _nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
8889                     struct nfs_fsinfo *info,
8890                     struct nfs4_secinfo_flavors *flavors, bool use_integrity)
8891 {
8892         struct nfs41_secinfo_no_name_args args = {
8893                 .style = SECINFO_STYLE_CURRENT_FH,
8894         };
8895         struct nfs4_secinfo_res res = {
8896                 .flavors = flavors,
8897         };
8898         struct rpc_message msg = {
8899                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO_NO_NAME],
8900                 .rpc_argp = &args,
8901                 .rpc_resp = &res,
8902         };
8903         struct rpc_clnt *clnt = server->client;
8904         struct rpc_cred *cred = NULL;
8905         int status;
8906
8907         if (use_integrity) {
8908                 clnt = server->nfs_client->cl_rpcclient;
8909                 cred = nfs4_get_clid_cred(server->nfs_client);
8910                 msg.rpc_cred = cred;
8911         }
8912
8913         dprintk("--> %s\n", __func__);
8914         status = nfs4_call_sync(clnt, server, &msg, &args.seq_args,
8915                                 &res.seq_res, 0);
8916         dprintk("<-- %s status=%d\n", __func__, status);
8917
8918         if (cred)
8919                 put_rpccred(cred);
8920
8921         return status;
8922 }
8923
8924 static int
8925 nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
8926                            struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors)
8927 {
8928         struct nfs4_exception exception = { };
8929         int err;
8930         do {
8931                 /* first try using integrity protection */
8932                 err = -NFS4ERR_WRONGSEC;
8933
8934                 /* try to use integrity protection with machine cred */
8935                 if (_nfs4_is_integrity_protected(server->nfs_client))
8936                         err = _nfs41_proc_secinfo_no_name(server, fhandle, info,
8937                                                           flavors, true);
8938
8939                 /*
8940                  * if unable to use integrity protection, or SECINFO with
8941                  * integrity protection returns NFS4ERR_WRONGSEC (which is
8942                  * disallowed by spec, but exists in deployed servers) use
8943                  * the current filesystem's rpc_client and the user cred.
8944                  */
8945                 if (err == -NFS4ERR_WRONGSEC)
8946                         err = _nfs41_proc_secinfo_no_name(server, fhandle, info,
8947                                                           flavors, false);
8948
8949                 switch (err) {
8950                 case 0:
8951                 case -NFS4ERR_WRONGSEC:
8952                 case -ENOTSUPP:
8953                         goto out;
8954                 default:
8955                         err = nfs4_handle_exception(server, err, &exception);
8956                 }
8957         } while (exception.retry);
8958 out:
8959         return err;
8960 }
8961
8962 static int
8963 nfs41_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
8964                     struct nfs_fsinfo *info)
8965 {
8966         int err;
8967         struct page *page;
8968         rpc_authflavor_t flavor = RPC_AUTH_MAXFLAVOR;
8969         struct nfs4_secinfo_flavors *flavors;
8970         struct nfs4_secinfo4 *secinfo;
8971         int i;
8972
8973         page = alloc_page(GFP_KERNEL);
8974         if (!page) {
8975                 err = -ENOMEM;
8976                 goto out;
8977         }
8978
8979         flavors = page_address(page);
8980         err = nfs41_proc_secinfo_no_name(server, fhandle, info, flavors);
8981
8982         /*
8983          * Fall back on "guess and check" method if
8984          * the server doesn't support SECINFO_NO_NAME
8985          */
8986         if (err == -NFS4ERR_WRONGSEC || err == -ENOTSUPP) {
8987                 err = nfs4_find_root_sec(server, fhandle, info);
8988                 goto out_freepage;
8989         }
8990         if (err)
8991                 goto out_freepage;
8992
8993         for (i = 0; i < flavors->num_flavors; i++) {
8994                 secinfo = &flavors->flavors[i];
8995
8996                 switch (secinfo->flavor) {
8997                 case RPC_AUTH_NULL:
8998                 case RPC_AUTH_UNIX:
8999                 case RPC_AUTH_GSS:
9000                         flavor = rpcauth_get_pseudoflavor(secinfo->flavor,
9001                                         &secinfo->flavor_info);
9002                         break;
9003                 default:
9004                         flavor = RPC_AUTH_MAXFLAVOR;
9005                         break;
9006                 }
9007
9008                 if (!nfs_auth_info_match(&server->auth_info, flavor))
9009                         flavor = RPC_AUTH_MAXFLAVOR;
9010
9011                 if (flavor != RPC_AUTH_MAXFLAVOR) {
9012                         err = nfs4_lookup_root_sec(server, fhandle,
9013                                                    info, flavor);
9014                         if (!err)
9015                                 break;
9016                 }
9017         }
9018
9019         if (flavor == RPC_AUTH_MAXFLAVOR)
9020                 err = -EPERM;
9021
9022 out_freepage:
9023         put_page(page);
9024         if (err == -EACCES)
9025                 return -EPERM;
9026 out:
9027         return err;
9028 }
9029
9030 static int _nfs41_test_stateid(struct nfs_server *server,
9031                 nfs4_stateid *stateid,
9032                 struct rpc_cred *cred)
9033 {
9034         int status;
9035         struct nfs41_test_stateid_args args = {
9036                 .stateid = stateid,
9037         };
9038         struct nfs41_test_stateid_res res;
9039         struct rpc_message msg = {
9040                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_TEST_STATEID],
9041                 .rpc_argp = &args,
9042                 .rpc_resp = &res,
9043                 .rpc_cred = cred,
9044         };
9045         struct rpc_clnt *rpc_client = server->client;
9046
9047         nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID,
9048                 &rpc_client, &msg);
9049
9050         dprintk("NFS call  test_stateid %p\n", stateid);
9051         nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
9052         nfs4_set_sequence_privileged(&args.seq_args);
9053         status = nfs4_call_sync_sequence(rpc_client, server, &msg,
9054                         &args.seq_args, &res.seq_res);
9055         if (status != NFS_OK) {
9056                 dprintk("NFS reply test_stateid: failed, %d\n", status);
9057                 return status;
9058         }
9059         dprintk("NFS reply test_stateid: succeeded, %d\n", -res.status);
9060         return -res.status;
9061 }
9062
9063 static void nfs4_handle_delay_or_session_error(struct nfs_server *server,
9064                 int err, struct nfs4_exception *exception)
9065 {
9066         exception->retry = 0;
9067         switch(err) {
9068         case -NFS4ERR_DELAY:
9069         case -NFS4ERR_RETRY_UNCACHED_REP:
9070                 nfs4_handle_exception(server, err, exception);
9071                 break;
9072         case -NFS4ERR_BADSESSION:
9073         case -NFS4ERR_BADSLOT:
9074         case -NFS4ERR_BAD_HIGH_SLOT:
9075         case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
9076         case -NFS4ERR_DEADSESSION:
9077                 nfs4_do_handle_exception(server, err, exception);
9078         }
9079 }
9080
9081 /**
9082  * nfs41_test_stateid - perform a TEST_STATEID operation
9083  *
9084  * @server: server / transport on which to perform the operation
9085  * @stateid: state ID to test
9086  * @cred: credential
9087  *
9088  * Returns NFS_OK if the server recognizes that "stateid" is valid.
9089  * Otherwise a negative NFS4ERR value is returned if the operation
9090  * failed or the state ID is not currently valid.
9091  */
9092 static int nfs41_test_stateid(struct nfs_server *server,
9093                 nfs4_stateid *stateid,
9094                 struct rpc_cred *cred)
9095 {
9096         struct nfs4_exception exception = { };
9097         int err;
9098         do {
9099                 err = _nfs41_test_stateid(server, stateid, cred);
9100                 nfs4_handle_delay_or_session_error(server, err, &exception);
9101         } while (exception.retry);
9102         return err;
9103 }
9104
9105 struct nfs_free_stateid_data {
9106         struct nfs_server *server;
9107         struct nfs41_free_stateid_args args;
9108         struct nfs41_free_stateid_res res;
9109 };
9110
9111 static void nfs41_free_stateid_prepare(struct rpc_task *task, void *calldata)
9112 {
9113         struct nfs_free_stateid_data *data = calldata;
9114         nfs41_setup_sequence(nfs4_get_session(data->server),
9115                         &data->args.seq_args,
9116                         &data->res.seq_res,
9117                         task);
9118 }
9119
9120 static void nfs41_free_stateid_done(struct rpc_task *task, void *calldata)
9121 {
9122         struct nfs_free_stateid_data *data = calldata;
9123
9124         nfs41_sequence_done(task, &data->res.seq_res);
9125
9126         switch (task->tk_status) {
9127         case -NFS4ERR_DELAY:
9128                 if (nfs4_async_handle_error(task, data->server, NULL, NULL) == -EAGAIN)
9129                         rpc_restart_call_prepare(task);
9130         }
9131 }
9132
9133 static void nfs41_free_stateid_release(void *calldata)
9134 {
9135         kfree(calldata);
9136 }
9137
9138 static const struct rpc_call_ops nfs41_free_stateid_ops = {
9139         .rpc_call_prepare = nfs41_free_stateid_prepare,
9140         .rpc_call_done = nfs41_free_stateid_done,
9141         .rpc_release = nfs41_free_stateid_release,
9142 };
9143
9144 static struct rpc_task *_nfs41_free_stateid(struct nfs_server *server,
9145                 const nfs4_stateid *stateid,
9146                 struct rpc_cred *cred,
9147                 bool privileged)
9148 {
9149         struct rpc_message msg = {
9150                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FREE_STATEID],
9151                 .rpc_cred = cred,
9152         };
9153         struct rpc_task_setup task_setup = {
9154                 .rpc_client = server->client,
9155                 .rpc_message = &msg,
9156                 .callback_ops = &nfs41_free_stateid_ops,
9157                 .flags = RPC_TASK_ASYNC,
9158         };
9159         struct nfs_free_stateid_data *data;
9160
9161         nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID,
9162                 &task_setup.rpc_client, &msg);
9163
9164         dprintk("NFS call  free_stateid %p\n", stateid);
9165         data = kmalloc(sizeof(*data), GFP_NOFS);
9166         if (!data)
9167                 return ERR_PTR(-ENOMEM);
9168         data->server = server;
9169         nfs4_stateid_copy(&data->args.stateid, stateid);
9170
9171         task_setup.callback_data = data;
9172
9173         msg.rpc_argp = &data->args;
9174         msg.rpc_resp = &data->res;
9175         nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
9176         if (privileged)
9177                 nfs4_set_sequence_privileged(&data->args.seq_args);
9178
9179         return rpc_run_task(&task_setup);
9180 }
9181
9182 /**
9183  * nfs41_free_stateid - perform a FREE_STATEID operation
9184  *
9185  * @server: server / transport on which to perform the operation
9186  * @stateid: state ID to release
9187  * @cred: credential
9188  * @is_recovery: set to true if this call needs to be privileged
9189  *
9190  * Note: this function is always asynchronous.
9191  */
9192 static int nfs41_free_stateid(struct nfs_server *server,
9193                 const nfs4_stateid *stateid,
9194                 struct rpc_cred *cred,
9195                 bool is_recovery)
9196 {
9197         struct rpc_task *task;
9198
9199         task = _nfs41_free_stateid(server, stateid, cred, is_recovery);
9200         if (IS_ERR(task))
9201                 return PTR_ERR(task);
9202         rpc_put_task(task);
9203         return 0;
9204 }
9205
9206 static void
9207 nfs41_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
9208 {
9209         struct rpc_cred *cred = lsp->ls_state->owner->so_cred;
9210
9211         nfs41_free_stateid(server, &lsp->ls_stateid, cred, false);
9212         nfs4_free_lock_state(server, lsp);
9213 }
9214
9215 static bool nfs41_match_stateid(const nfs4_stateid *s1,
9216                 const nfs4_stateid *s2)
9217 {
9218         if (s1->type != s2->type)
9219                 return false;
9220
9221         if (memcmp(s1->other, s2->other, sizeof(s1->other)) != 0)
9222                 return false;
9223
9224         if (s1->seqid == s2->seqid)
9225                 return true;
9226         if (s1->seqid == 0 || s2->seqid == 0)
9227                 return true;
9228
9229         return false;
9230 }
9231
9232 #endif /* CONFIG_NFS_V4_1 */
9233
9234 static bool nfs4_match_stateid(const nfs4_stateid *s1,
9235                 const nfs4_stateid *s2)
9236 {
9237         return nfs4_stateid_match(s1, s2);
9238 }
9239
9240
9241 static const struct nfs4_state_recovery_ops nfs40_reboot_recovery_ops = {
9242         .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,
9243         .state_flag_bit = NFS_STATE_RECLAIM_REBOOT,
9244         .recover_open   = nfs4_open_reclaim,
9245         .recover_lock   = nfs4_lock_reclaim,
9246         .establish_clid = nfs4_init_clientid,
9247         .detect_trunking = nfs40_discover_server_trunking,
9248 };
9249
9250 #if defined(CONFIG_NFS_V4_1)
9251 static const struct nfs4_state_recovery_ops nfs41_reboot_recovery_ops = {
9252         .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,
9253         .state_flag_bit = NFS_STATE_RECLAIM_REBOOT,
9254         .recover_open   = nfs4_open_reclaim,
9255         .recover_lock   = nfs4_lock_reclaim,
9256         .establish_clid = nfs41_init_clientid,
9257         .reclaim_complete = nfs41_proc_reclaim_complete,
9258         .detect_trunking = nfs41_discover_server_trunking,
9259 };
9260 #endif /* CONFIG_NFS_V4_1 */
9261
9262 static const struct nfs4_state_recovery_ops nfs40_nograce_recovery_ops = {
9263         .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,
9264         .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE,
9265         .recover_open   = nfs40_open_expired,
9266         .recover_lock   = nfs4_lock_expired,
9267         .establish_clid = nfs4_init_clientid,
9268 };
9269
9270 #if defined(CONFIG_NFS_V4_1)
9271 static const struct nfs4_state_recovery_ops nfs41_nograce_recovery_ops = {
9272         .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,
9273         .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE,
9274         .recover_open   = nfs41_open_expired,
9275         .recover_lock   = nfs41_lock_expired,
9276         .establish_clid = nfs41_init_clientid,
9277 };
9278 #endif /* CONFIG_NFS_V4_1 */
9279
9280 static const struct nfs4_state_maintenance_ops nfs40_state_renewal_ops = {
9281         .sched_state_renewal = nfs4_proc_async_renew,
9282         .get_state_renewal_cred_locked = nfs4_get_renew_cred_locked,
9283         .renew_lease = nfs4_proc_renew,
9284 };
9285
9286 #if defined(CONFIG_NFS_V4_1)
9287 static const struct nfs4_state_maintenance_ops nfs41_state_renewal_ops = {
9288         .sched_state_renewal = nfs41_proc_async_sequence,
9289         .get_state_renewal_cred_locked = nfs4_get_machine_cred_locked,
9290         .renew_lease = nfs4_proc_sequence,
9291 };
9292 #endif
9293
9294 static const struct nfs4_mig_recovery_ops nfs40_mig_recovery_ops = {
9295         .get_locations = _nfs40_proc_get_locations,
9296         .fsid_present = _nfs40_proc_fsid_present,
9297 };
9298
9299 #if defined(CONFIG_NFS_V4_1)
9300 static const struct nfs4_mig_recovery_ops nfs41_mig_recovery_ops = {
9301         .get_locations = _nfs41_proc_get_locations,
9302         .fsid_present = _nfs41_proc_fsid_present,
9303 };
9304 #endif  /* CONFIG_NFS_V4_1 */
9305
9306 static const struct nfs4_minor_version_ops nfs_v4_0_minor_ops = {
9307         .minor_version = 0,
9308         .init_caps = NFS_CAP_READDIRPLUS
9309                 | NFS_CAP_ATOMIC_OPEN
9310                 | NFS_CAP_POSIX_LOCK,
9311         .init_client = nfs40_init_client,
9312         .shutdown_client = nfs40_shutdown_client,
9313         .match_stateid = nfs4_match_stateid,
9314         .find_root_sec = nfs4_find_root_sec,
9315         .free_lock_state = nfs4_release_lockowner,
9316         .test_and_free_expired = nfs40_test_and_free_expired_stateid,
9317         .alloc_seqid = nfs_alloc_seqid,
9318         .call_sync_ops = &nfs40_call_sync_ops,
9319         .reboot_recovery_ops = &nfs40_reboot_recovery_ops,
9320         .nograce_recovery_ops = &nfs40_nograce_recovery_ops,
9321         .state_renewal_ops = &nfs40_state_renewal_ops,
9322         .mig_recovery_ops = &nfs40_mig_recovery_ops,
9323 };
9324
9325 #if defined(CONFIG_NFS_V4_1)
9326 static struct nfs_seqid *
9327 nfs_alloc_no_seqid(struct nfs_seqid_counter *arg1, gfp_t arg2)
9328 {
9329         return NULL;
9330 }
9331
9332 static const struct nfs4_minor_version_ops nfs_v4_1_minor_ops = {
9333         .minor_version = 1,
9334         .init_caps = NFS_CAP_READDIRPLUS
9335                 | NFS_CAP_ATOMIC_OPEN
9336                 | NFS_CAP_POSIX_LOCK
9337                 | NFS_CAP_STATEID_NFSV41
9338                 | NFS_CAP_ATOMIC_OPEN_V1,
9339         .init_client = nfs41_init_client,
9340         .shutdown_client = nfs41_shutdown_client,
9341         .match_stateid = nfs41_match_stateid,
9342         .find_root_sec = nfs41_find_root_sec,
9343         .free_lock_state = nfs41_free_lock_state,
9344         .test_and_free_expired = nfs41_test_and_free_expired_stateid,
9345         .alloc_seqid = nfs_alloc_no_seqid,
9346         .session_trunk = nfs4_test_session_trunk,
9347         .call_sync_ops = &nfs41_call_sync_ops,
9348         .reboot_recovery_ops = &nfs41_reboot_recovery_ops,
9349         .nograce_recovery_ops = &nfs41_nograce_recovery_ops,
9350         .state_renewal_ops = &nfs41_state_renewal_ops,
9351         .mig_recovery_ops = &nfs41_mig_recovery_ops,
9352 };
9353 #endif
9354
9355 #if defined(CONFIG_NFS_V4_2)
9356 static const struct nfs4_minor_version_ops nfs_v4_2_minor_ops = {
9357         .minor_version = 2,
9358         .init_caps = NFS_CAP_READDIRPLUS
9359                 | NFS_CAP_ATOMIC_OPEN
9360                 | NFS_CAP_POSIX_LOCK
9361                 | NFS_CAP_STATEID_NFSV41
9362                 | NFS_CAP_ATOMIC_OPEN_V1
9363                 | NFS_CAP_ALLOCATE
9364                 | NFS_CAP_COPY
9365                 | NFS_CAP_DEALLOCATE
9366                 | NFS_CAP_SEEK
9367                 | NFS_CAP_LAYOUTSTATS
9368                 | NFS_CAP_CLONE,
9369         .init_client = nfs41_init_client,
9370         .shutdown_client = nfs41_shutdown_client,
9371         .match_stateid = nfs41_match_stateid,
9372         .find_root_sec = nfs41_find_root_sec,
9373         .free_lock_state = nfs41_free_lock_state,
9374         .call_sync_ops = &nfs41_call_sync_ops,
9375         .test_and_free_expired = nfs41_test_and_free_expired_stateid,
9376         .alloc_seqid = nfs_alloc_no_seqid,
9377         .session_trunk = nfs4_test_session_trunk,
9378         .reboot_recovery_ops = &nfs41_reboot_recovery_ops,
9379         .nograce_recovery_ops = &nfs41_nograce_recovery_ops,
9380         .state_renewal_ops = &nfs41_state_renewal_ops,
9381         .mig_recovery_ops = &nfs41_mig_recovery_ops,
9382 };
9383 #endif
9384
9385 const struct nfs4_minor_version_ops *nfs_v4_minor_ops[] = {
9386         [0] = &nfs_v4_0_minor_ops,
9387 #if defined(CONFIG_NFS_V4_1)
9388         [1] = &nfs_v4_1_minor_ops,
9389 #endif
9390 #if defined(CONFIG_NFS_V4_2)
9391         [2] = &nfs_v4_2_minor_ops,
9392 #endif
9393 };
9394
9395 static ssize_t nfs4_listxattr(struct dentry *dentry, char *list, size_t size)
9396 {
9397         ssize_t error, error2;
9398
9399         error = generic_listxattr(dentry, list, size);
9400         if (error < 0)
9401                 return error;
9402         if (list) {
9403                 list += error;
9404                 size -= error;
9405         }
9406
9407         error2 = nfs4_listxattr_nfs4_label(d_inode(dentry), list, size);
9408         if (error2 < 0)
9409                 return error2;
9410         return error + error2;
9411 }
9412
9413 static const struct inode_operations nfs4_dir_inode_operations = {
9414         .create         = nfs_create,
9415         .lookup         = nfs_lookup,
9416         .atomic_open    = nfs_atomic_open,
9417         .link           = nfs_link,
9418         .unlink         = nfs_unlink,
9419         .symlink        = nfs_symlink,
9420         .mkdir          = nfs_mkdir,
9421         .rmdir          = nfs_rmdir,
9422         .mknod          = nfs_mknod,
9423         .rename         = nfs_rename,
9424         .permission     = nfs_permission,
9425         .getattr        = nfs_getattr,
9426         .setattr        = nfs_setattr,
9427         .listxattr      = nfs4_listxattr,
9428 };
9429
9430 static const struct inode_operations nfs4_file_inode_operations = {
9431         .permission     = nfs_permission,
9432         .getattr        = nfs_getattr,
9433         .setattr        = nfs_setattr,
9434         .listxattr      = nfs4_listxattr,
9435 };
9436
9437 const struct nfs_rpc_ops nfs_v4_clientops = {
9438         .version        = 4,                    /* protocol version */
9439         .dentry_ops     = &nfs4_dentry_operations,
9440         .dir_inode_ops  = &nfs4_dir_inode_operations,
9441         .file_inode_ops = &nfs4_file_inode_operations,
9442         .file_ops       = &nfs4_file_operations,
9443         .getroot        = nfs4_proc_get_root,
9444         .submount       = nfs4_submount,
9445         .try_mount      = nfs4_try_mount,
9446         .getattr        = nfs4_proc_getattr,
9447         .setattr        = nfs4_proc_setattr,
9448         .lookup         = nfs4_proc_lookup,
9449         .access         = nfs4_proc_access,
9450         .readlink       = nfs4_proc_readlink,
9451         .create         = nfs4_proc_create,
9452         .remove         = nfs4_proc_remove,
9453         .unlink_setup   = nfs4_proc_unlink_setup,
9454         .unlink_rpc_prepare = nfs4_proc_unlink_rpc_prepare,
9455         .unlink_done    = nfs4_proc_unlink_done,
9456         .rename_setup   = nfs4_proc_rename_setup,
9457         .rename_rpc_prepare = nfs4_proc_rename_rpc_prepare,
9458         .rename_done    = nfs4_proc_rename_done,
9459         .link           = nfs4_proc_link,
9460         .symlink        = nfs4_proc_symlink,
9461         .mkdir          = nfs4_proc_mkdir,
9462         .rmdir          = nfs4_proc_remove,
9463         .readdir        = nfs4_proc_readdir,
9464         .mknod          = nfs4_proc_mknod,
9465         .statfs         = nfs4_proc_statfs,
9466         .fsinfo         = nfs4_proc_fsinfo,
9467         .pathconf       = nfs4_proc_pathconf,
9468         .set_capabilities = nfs4_server_capabilities,
9469         .decode_dirent  = nfs4_decode_dirent,
9470         .pgio_rpc_prepare = nfs4_proc_pgio_rpc_prepare,
9471         .read_setup     = nfs4_proc_read_setup,
9472         .read_done      = nfs4_read_done,
9473         .write_setup    = nfs4_proc_write_setup,
9474         .write_done     = nfs4_write_done,
9475         .commit_setup   = nfs4_proc_commit_setup,
9476         .commit_rpc_prepare = nfs4_proc_commit_rpc_prepare,
9477         .commit_done    = nfs4_commit_done,
9478         .lock           = nfs4_proc_lock,
9479         .clear_acl_cache = nfs4_zap_acl_attr,
9480         .close_context  = nfs4_close_context,
9481         .open_context   = nfs4_atomic_open,
9482         .have_delegation = nfs4_have_delegation,
9483         .return_delegation = nfs4_inode_return_delegation,
9484         .alloc_client   = nfs4_alloc_client,
9485         .init_client    = nfs4_init_client,
9486         .free_client    = nfs4_free_client,
9487         .create_server  = nfs4_create_server,
9488         .clone_server   = nfs_clone_server,
9489 };
9490
9491 static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = {
9492         .name   = XATTR_NAME_NFSV4_ACL,
9493         .list   = nfs4_xattr_list_nfs4_acl,
9494         .get    = nfs4_xattr_get_nfs4_acl,
9495         .set    = nfs4_xattr_set_nfs4_acl,
9496 };
9497
9498 const struct xattr_handler *nfs4_xattr_handlers[] = {
9499         &nfs4_xattr_nfs4_acl_handler,
9500 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
9501         &nfs4_xattr_nfs4_label_handler,
9502 #endif
9503         NULL
9504 };
9505
9506 /*
9507  * Local variables:
9508  *  c-basic-offset: 8
9509  * End:
9510  */