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