fs/nfsd/nfs4state.c

   1 /*
   2 *  Copyright (c) 2001 The Regents of the University of Michigan.
   3 *  All rights reserved.
   4 *
   5 *  Kendrick Smith <kmsmith@umich.edu>
   6 *  Andy Adamson <kandros@umich.edu>
   7 *
   8 *  Redistribution and use in source and binary forms, with or without
   9 *  modification, are permitted provided that the following conditions
  10 *  are met:
  11 *
  12 *  1. Redistributions of source code must retain the above copyright
  13 *     notice, this list of conditions and the following disclaimer.
  14 *  2. Redistributions in binary form must reproduce the above copyright
  15 *     notice, this list of conditions and the following disclaimer in the
  16 *     documentation and/or other materials provided with the distribution.
  17 *  3. Neither the name of the University nor the names of its
  18 *     contributors may be used to endorse or promote products derived
  19 *     from this software without specific prior written permission.
  20 *
  21 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  22 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  23 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  24 *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  26 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  27 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  28 *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  29 *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  30 *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  31 *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32 *
  33 */
  34
  35 #include <linux/file.h>
  36 #include <linux/fs.h>
  37 #include <linux/slab.h>
  38 #include <linux/namei.h>
  39 #include <linux/swap.h>
  40 #include <linux/pagemap.h>
  41 #include <linux/ratelimit.h>
  42 #include <linux/sunrpc/svcauth_gss.h>
  43 #include <linux/sunrpc/addr.h>
  44 #include <linux/hash.h>
  45 #include "xdr4.h"
  46 #include "xdr4cb.h"
  47 #include "vfs.h"
  48 #include "current_stateid.h"
  49
  50 #include "netns.h"
  51
  52 #define NFSDDBG_FACILITY                NFSDDBG_PROC
  53
  54 #define all_ones {{~0,~0},~0}
  55 static const stateid_t one_stateid = {
  56         .si_generation = ~0,
  57         .si_opaque = all_ones,
  58 };
  59 static const stateid_t zero_stateid = {
  60         /* all fields zero */
  61 };
  62 static const stateid_t currentstateid = {
  63         .si_generation = 1,
  64 };
  65
  66 static u64 current_sessionid = 1;
  67
  68 #define ZERO_STATEID(stateid) (!memcmp((stateid), &zero_stateid, sizeof(stateid_t)))
  69 #define ONE_STATEID(stateid)  (!memcmp((stateid), &one_stateid, sizeof(stateid_t)))
  70 #define CURRENT_STATEID(stateid) (!memcmp((stateid), &currentstateid, sizeof(stateid_t)))
  71
  72 /* forward declarations */
  73 static int check_for_locks(struct nfs4_file *filp, struct nfs4_lockowner *lowner);
  74
  75 /* Locking: */
  76
  77 /* Currently used for almost all code touching nfsv4 state: */
  78 static DEFINE_MUTEX(client_mutex);
  79
  80 /*
  81  * Currently used for the del_recall_lru and file hash table.  In an
  82  * effort to decrease the scope of the client_mutex, this spinlock may
  83  * eventually cover more:
  84  */
  85 static DEFINE_SPINLOCK(state_lock);
  86
  87 static struct kmem_cache *openowner_slab;
  88 static struct kmem_cache *lockowner_slab;
  89 static struct kmem_cache *file_slab;
  90 static struct kmem_cache *stateid_slab;
  91 static struct kmem_cache *deleg_slab;
  92
  93 void
  94 nfs4_lock_state(void)
  95 {
  96         mutex_lock(&client_mutex);
  97 }
  98
  99 static void free_session(struct nfsd4_session *);
 100
 101 static bool is_session_dead(struct nfsd4_session *ses)
 102 {
 103         return ses->se_flags & NFS4_SESSION_DEAD;
 104 }
 105
 106 static __be32 mark_session_dead_locked(struct nfsd4_session *ses, int ref_held_by_me)
 107 {
 108         if (atomic_read(&ses->se_ref) > ref_held_by_me)
 109                 return nfserr_jukebox;
 110         ses->se_flags |= NFS4_SESSION_DEAD;
 111         return nfs_ok;
 112 }
 113
 114 void
 115 nfs4_unlock_state(void)
 116 {
 117         mutex_unlock(&client_mutex);
 118 }
 119
 120 static bool is_client_expired(struct nfs4_client *clp)
 121 {
 122         return clp->cl_time == 0;
 123 }
 124
 125 static __be32 mark_client_expired_locked(struct nfs4_client *clp)
 126 {
 127         if (atomic_read(&clp->cl_refcount))
 128                 return nfserr_jukebox;
 129         clp->cl_time = 0;
 130         return nfs_ok;
 131 }
 132
 133 static __be32 mark_client_expired(struct nfs4_client *clp)
 134 {
 135         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
 136         __be32 ret;
 137
 138         spin_lock(&nn->client_lock);
 139         ret = mark_client_expired_locked(clp);
 140         spin_unlock(&nn->client_lock);
 141         return ret;
 142 }
 143
 144 static __be32 get_client_locked(struct nfs4_client *clp)
 145 {
 146         if (is_client_expired(clp))
 147                 return nfserr_expired;
 148         atomic_inc(&clp->cl_refcount);
 149         return nfs_ok;
 150 }
 151
 152 /* must be called under the client_lock */
 153 static inline void
 154 renew_client_locked(struct nfs4_client *clp)
 155 {
 156         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
 157
 158         if (is_client_expired(clp)) {
 159                 WARN_ON(1);
 160                 printk("%s: client (clientid %08x/%08x) already expired\n",
 161                         __func__,
 162                         clp->cl_clientid.cl_boot,
 163                         clp->cl_clientid.cl_id);
 164                 return;
 165         }
 166
 167         dprintk("renewing client (clientid %08x/%08x)\n",
 168                         clp->cl_clientid.cl_boot,
 169                         clp->cl_clientid.cl_id);
 170         list_move_tail(&clp->cl_lru, &nn->client_lru);
 171         clp->cl_time = get_seconds();
 172 }
 173
 174 static inline void
 175 renew_client(struct nfs4_client *clp)
 176 {
 177         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
 178
 179         spin_lock(&nn->client_lock);
 180         renew_client_locked(clp);
 181         spin_unlock(&nn->client_lock);
 182 }
 183
 184 static void put_client_renew_locked(struct nfs4_client *clp)
 185 {
 186         if (!atomic_dec_and_test(&clp->cl_refcount))
 187                 return;
 188         if (!is_client_expired(clp))
 189                 renew_client_locked(clp);
 190 }
 191
 192 static void put_client_renew(struct nfs4_client *clp)
 193 {
 194         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
 195
 196         if (!atomic_dec_and_lock(&clp->cl_refcount, &nn->client_lock))
 197                 return;
 198         if (!is_client_expired(clp))
 199                 renew_client_locked(clp);
 200         spin_unlock(&nn->client_lock);
 201 }
 202
 203 static __be32 nfsd4_get_session_locked(struct nfsd4_session *ses)
 204 {
 205         __be32 status;
 206
 207         if (is_session_dead(ses))
 208                 return nfserr_badsession;
 209         status = get_client_locked(ses->se_client);
 210         if (status)
 211                 return status;
 212         atomic_inc(&ses->se_ref);
 213         return nfs_ok;
 214 }
 215
 216 static void nfsd4_put_session_locked(struct nfsd4_session *ses)
 217 {
 218         struct nfs4_client *clp = ses->se_client;
 219
 220         if (atomic_dec_and_test(&ses->se_ref) && is_session_dead(ses))
 221                 free_session(ses);
 222         put_client_renew_locked(clp);
 223 }
 224
 225 static void nfsd4_put_session(struct nfsd4_session *ses)
 226 {
 227         struct nfs4_client *clp = ses->se_client;
 228         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
 229
 230         spin_lock(&nn->client_lock);
 231         nfsd4_put_session_locked(ses);
 232         spin_unlock(&nn->client_lock);
 233 }
 234
 235
 236 static inline u32
 237 opaque_hashval(const void *ptr, int nbytes)
 238 {
 239         unsigned char *cptr = (unsigned char *) ptr;
 240
 241         u32 x = 0;
 242         while (nbytes--) {
 243                 x *= 37;
 244                 x += *cptr++;
 245         }
 246         return x;
 247 }
 248
 249 static void nfsd4_free_file(struct nfs4_file *f)
 250 {
 251         kmem_cache_free(file_slab, f);
 252 }
 253
 254 static inline void
 255 put_nfs4_file(struct nfs4_file *fi)
 256 {
 257         if (atomic_dec_and_lock(&fi->fi_ref, &state_lock)) {
 258                 hlist_del(&fi->fi_hash);
 259                 spin_unlock(&state_lock);
 260                 iput(fi->fi_inode);
 261                 nfsd4_free_file(fi);
 262         }
 263 }
 264
 265 static inline void
 266 get_nfs4_file(struct nfs4_file *fi)
 267 {
 268         atomic_inc(&fi->fi_ref);
 269 }
 270
 271 static struct file *
 272 __nfs4_get_fd(struct nfs4_file *f, int oflag)
 273 {
 274         if (f->fi_fds[oflag])
 275                 return get_file(f->fi_fds[oflag]);
 276         return NULL;
 277 }
 278
 279 static struct file *
 280 find_writeable_file_locked(struct nfs4_file *f)
 281 {
 282         struct file *ret;
 283
 284         lockdep_assert_held(&f->fi_lock);
 285
 286         ret = __nfs4_get_fd(f, O_WRONLY);
 287         if (!ret)
 288                 ret = __nfs4_get_fd(f, O_RDWR);
 289         return ret;
 290 }
 291
 292 static struct file *
 293 find_writeable_file(struct nfs4_file *f)
 294 {
 295         struct file *ret;
 296
 297         spin_lock(&f->fi_lock);
 298         ret = find_writeable_file_locked(f);
 299         spin_unlock(&f->fi_lock);
 300
 301         return ret;
 302 }
 303
 304 static struct file *find_readable_file_locked(struct nfs4_file *f)
 305 {
 306         struct file *ret;
 307
 308         lockdep_assert_held(&f->fi_lock);
 309
 310         ret = __nfs4_get_fd(f, O_RDONLY);
 311         if (!ret)
 312                 ret = __nfs4_get_fd(f, O_RDWR);
 313         return ret;
 314 }
 315
 316 static struct file *
 317 find_readable_file(struct nfs4_file *f)
 318 {
 319         struct file *ret;
 320
 321         spin_lock(&f->fi_lock);
 322         ret = find_readable_file_locked(f);
 323         spin_unlock(&f->fi_lock);
 324
 325         return ret;
 326 }
 327
 328 static struct file *
 329 find_any_file(struct nfs4_file *f)
 330 {
 331         struct file *ret;
 332
 333         spin_lock(&f->fi_lock);
 334         ret = __nfs4_get_fd(f, O_RDWR);
 335         if (!ret) {
 336                 ret = __nfs4_get_fd(f, O_WRONLY);
 337                 if (!ret)
 338                         ret = __nfs4_get_fd(f, O_RDONLY);
 339         }
 340         spin_unlock(&f->fi_lock);
 341         return ret;
 342 }
 343
 344 static int num_delegations;
 345 unsigned long max_delegations;
 346
 347 /*
 348  * Open owner state (share locks)
 349  */
 350
 351 /* hash tables for lock and open owners */
 352 #define OWNER_HASH_BITS              8
 353 #define OWNER_HASH_SIZE             (1 << OWNER_HASH_BITS)
 354 #define OWNER_HASH_MASK             (OWNER_HASH_SIZE - 1)
 355
 356 static unsigned int ownerstr_hashval(u32 clientid, struct xdr_netobj *ownername)
 357 {
 358         unsigned int ret;
 359
 360         ret = opaque_hashval(ownername->data, ownername->len);
 361         ret += clientid;
 362         return ret & OWNER_HASH_MASK;
 363 }
 364
 365 /* hash table for nfs4_file */
 366 #define FILE_HASH_BITS                   8
 367 #define FILE_HASH_SIZE                  (1 << FILE_HASH_BITS)
 368
 369 static unsigned int file_hashval(struct inode *ino)
 370 {
 371         /* XXX: why are we hashing on inode pointer, anyway? */
 372         return hash_ptr(ino, FILE_HASH_BITS);
 373 }
 374
 375 static struct hlist_head file_hashtbl[FILE_HASH_SIZE];
 376
 377 static void
 378 __nfs4_file_get_access(struct nfs4_file *fp, u32 access)
 379 {
 380         if (access & NFS4_SHARE_ACCESS_WRITE)
 381                 atomic_inc(&fp->fi_access[O_WRONLY]);
 382         if (access & NFS4_SHARE_ACCESS_READ)
 383                 atomic_inc(&fp->fi_access[O_RDONLY]);
 384 }
 385
 386 static __be32
 387 nfs4_file_get_access(struct nfs4_file *fp, u32 access)
 388 {
 389         /* Does this access mode make sense? */
 390         if (access & ~NFS4_SHARE_ACCESS_BOTH)
 391                 return nfserr_inval;
 392
 393         __nfs4_file_get_access(fp, access);
 394         return nfs_ok;
 395 }
 396
 397 static struct file *nfs4_file_put_fd(struct nfs4_file *fp, int oflag)
 398 {
 399         struct file *filp;
 400
 401         filp = fp->fi_fds[oflag];
 402         fp->fi_fds[oflag] = NULL;
 403         return filp;
 404 }
 405
 406 static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
 407 {
 408         might_lock(&fp->fi_lock);
 409
 410         if (atomic_dec_and_lock(&fp->fi_access[oflag], &fp->fi_lock)) {
 411                 struct file *f1 = NULL;
 412                 struct file *f2 = NULL;
 413
 414                 f1 = nfs4_file_put_fd(fp, oflag);
 415                 if (atomic_read(&fp->fi_access[1 - oflag]) == 0)
 416                         f2 = nfs4_file_put_fd(fp, O_RDWR);
 417                 spin_unlock(&fp->fi_lock);
 418                 if (f1)
 419                         fput(f1);
 420                 if (f2)
 421                         fput(f2);
 422         }
 423 }
 424
 425 static void nfs4_file_put_access(struct nfs4_file *fp, u32 access)
 426 {
 427         WARN_ON_ONCE(access & ~NFS4_SHARE_ACCESS_BOTH);
 428
 429         if (access & NFS4_SHARE_ACCESS_WRITE)
 430                 __nfs4_file_put_access(fp, O_WRONLY);
 431         if (access & NFS4_SHARE_ACCESS_READ)
 432                 __nfs4_file_put_access(fp, O_RDONLY);
 433 }
 434
 435 static struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct
 436 kmem_cache *slab)
 437 {
 438         struct idr *stateids = &cl->cl_stateids;
 439         struct nfs4_stid *stid;
 440         int new_id;
 441
 442         stid = kmem_cache_alloc(slab, GFP_KERNEL);
 443         if (!stid)
 444                 return NULL;
 445
 446         new_id = idr_alloc_cyclic(stateids, stid, 0, 0, GFP_KERNEL);
 447         if (new_id < 0)
 448                 goto out_free;
 449         stid->sc_client = cl;
 450         stid->sc_type = 0;
 451         stid->sc_stateid.si_opaque.so_id = new_id;
 452         stid->sc_stateid.si_opaque.so_clid = cl->cl_clientid;
 453         /* Will be incremented before return to client: */
 454         stid->sc_stateid.si_generation = 0;
 455
 456         /*
 457          * It shouldn't be a problem to reuse an opaque stateid value.
 458          * I don't think it is for 4.1.  But with 4.0 I worry that, for
 459          * example, a stray write retransmission could be accepted by
 460          * the server when it should have been rejected.  Therefore,
 461          * adopt a trick from the sctp code to attempt to maximize the
 462          * amount of time until an id is reused, by ensuring they always
 463          * "increase" (mod INT_MAX):
 464          */
 465         return stid;
 466 out_free:
 467         kmem_cache_free(slab, stid);
 468         return NULL;
 469 }
 470
 471 static struct nfs4_ol_stateid * nfs4_alloc_stateid(struct nfs4_client *clp)
 472 {
 473         return openlockstateid(nfs4_alloc_stid(clp, stateid_slab));
 474 }
 475
 476 /*
 477  * When we recall a delegation, we should be careful not to hand it
 478  * out again straight away.
 479  * To ensure this we keep a pair of bloom filters ('new' and 'old')
 480  * in which the filehandles of recalled delegations are "stored".
 481  * If a filehandle appear in either filter, a delegation is blocked.
 482  * When a delegation is recalled, the filehandle is stored in the "new"
 483  * filter.
 484  * Every 30 seconds we swap the filters and clear the "new" one,
 485  * unless both are empty of course.
 486  *
 487  * Each filter is 256 bits.  We hash the filehandle to 32bit and use the
 488  * low 3 bytes as hash-table indices.
 489  *
 490  * 'state_lock', which is always held when block_delegations() is called,
 491  * is used to manage concurrent access.  Testing does not need the lock
 492  * except when swapping the two filters.
 493  */
 494 static struct bloom_pair {
 495         int     entries, old_entries;
 496         time_t  swap_time;
 497         int     new; /* index into 'set' */
 498         DECLARE_BITMAP(set[2], 256);
 499 } blocked_delegations;
 500
 501 static int delegation_blocked(struct knfsd_fh *fh)
 502 {
 503         u32 hash;
 504         struct bloom_pair *bd = &blocked_delegations;
 505
 506         if (bd->entries == 0)
 507                 return 0;
 508         if (seconds_since_boot() - bd->swap_time > 30) {
 509                 spin_lock(&state_lock);
 510                 if (seconds_since_boot() - bd->swap_time > 30) {
 511                         bd->entries -= bd->old_entries;
 512                         bd->old_entries = bd->entries;
 513                         memset(bd->set[bd->new], 0,
 514                                sizeof(bd->set[0]));
 515                         bd->new = 1-bd->new;
 516                         bd->swap_time = seconds_since_boot();
 517                 }
 518                 spin_unlock(&state_lock);
 519         }
 520         hash = arch_fast_hash(&fh->fh_base, fh->fh_size, 0);
 521         if (test_bit(hash&255, bd->set[0]) &&
 522             test_bit((hash>>8)&255, bd->set[0]) &&
 523             test_bit((hash>>16)&255, bd->set[0]))
 524                 return 1;
 525
 526         if (test_bit(hash&255, bd->set[1]) &&
 527             test_bit((hash>>8)&255, bd->set[1]) &&
 528             test_bit((hash>>16)&255, bd->set[1]))
 529                 return 1;
 530
 531         return 0;
 532 }
 533
 534 static void block_delegations(struct knfsd_fh *fh)
 535 {
 536         u32 hash;
 537         struct bloom_pair *bd = &blocked_delegations;
 538
 539         hash = arch_fast_hash(&fh->fh_base, fh->fh_size, 0);
 540
 541         __set_bit(hash&255, bd->set[bd->new]);
 542         __set_bit((hash>>8)&255, bd->set[bd->new]);
 543         __set_bit((hash>>16)&255, bd->set[bd->new]);
 544         if (bd->entries == 0)
 545                 bd->swap_time = seconds_since_boot();
 546         bd->entries += 1;
 547 }
 548
 549 static struct nfs4_delegation *
 550 alloc_init_deleg(struct nfs4_client *clp, struct nfs4_ol_stateid *stp, struct svc_fh *current_fh)
 551 {
 552         struct nfs4_delegation *dp;
 553
 554         dprintk("NFSD alloc_init_deleg\n");
 555         if (num_delegations > max_delegations)
 556                 return NULL;
 557         if (delegation_blocked(&current_fh->fh_handle))
 558                 return NULL;
 559         dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab));
 560         if (dp == NULL)
 561                 return dp;
 562         /*
 563          * delegation seqid's are never incremented.  The 4.1 special
 564          * meaning of seqid 0 isn't meaningful, really, but let's avoid
 565          * 0 anyway just for consistency and use 1:
 566          */
 567         dp->dl_stid.sc_stateid.si_generation = 1;
 568         num_delegations++;
 569         INIT_LIST_HEAD(&dp->dl_perfile);
 570         INIT_LIST_HEAD(&dp->dl_perclnt);
 571         INIT_LIST_HEAD(&dp->dl_recall_lru);
 572         dp->dl_file = NULL;
 573         dp->dl_type = NFS4_OPEN_DELEGATE_READ;
 574         fh_copy_shallow(&dp->dl_fh, &current_fh->fh_handle);
 575         dp->dl_time = 0;
 576         atomic_set(&dp->dl_count, 1);
 577         nfsd4_init_callback(&dp->dl_recall);
 578         return dp;
 579 }
 580
 581 static void remove_stid(struct nfs4_stid *s)
 582 {
 583         struct idr *stateids = &s->sc_client->cl_stateids;
 584
 585         idr_remove(stateids, s->sc_stateid.si_opaque.so_id);
 586 }
 587
 588 static void nfs4_free_stid(struct kmem_cache *slab, struct nfs4_stid *s)
 589 {
 590         kmem_cache_free(slab, s);
 591 }
 592
 593 void
 594 nfs4_put_delegation(struct nfs4_delegation *dp)
 595 {
 596         if (atomic_dec_and_test(&dp->dl_count)) {
 597                 nfs4_free_stid(deleg_slab, &dp->dl_stid);
 598                 num_delegations--;
 599         }
 600 }
 601
 602 static void nfs4_put_deleg_lease(struct nfs4_file *fp)
 603 {
 604         if (!fp->fi_lease)
 605                 return;
 606         if (atomic_dec_and_test(&fp->fi_delegees)) {
 607                 vfs_setlease(fp->fi_deleg_file, F_UNLCK, &fp->fi_lease);
 608                 fp->fi_lease = NULL;
 609                 fput(fp->fi_deleg_file);
 610                 fp->fi_deleg_file = NULL;
 611         }
 612 }
 613
 614 static void unhash_stid(struct nfs4_stid *s)
 615 {
 616         s->sc_type = 0;
 617 }
 618
 619 static void
 620 hash_delegation_locked(struct nfs4_delegation *dp, struct nfs4_file *fp)
 621 {
 622         lockdep_assert_held(&state_lock);
 623
 624         dp->dl_stid.sc_type = NFS4_DELEG_STID;
 625         list_add(&dp->dl_perfile, &fp->fi_delegations);
 626         list_add(&dp->dl_perclnt, &dp->dl_stid.sc_client->cl_delegations);
 627 }
 628
 629 /* Called under the state lock. */
 630 static void
 631 unhash_delegation(struct nfs4_delegation *dp)
 632 {
 633         spin_lock(&state_lock);
 634         list_del_init(&dp->dl_perclnt);
 635         list_del_init(&dp->dl_perfile);
 636         list_del_init(&dp->dl_recall_lru);
 637         spin_unlock(&state_lock);
 638         if (dp->dl_file) {
 639                 nfs4_put_deleg_lease(dp->dl_file);
 640                 put_nfs4_file(dp->dl_file);
 641                 dp->dl_file = NULL;
 642         }
 643 }
 644
 645
 646
 647 static void destroy_revoked_delegation(struct nfs4_delegation *dp)
 648 {
 649         list_del_init(&dp->dl_recall_lru);
 650         remove_stid(&dp->dl_stid);
 651         nfs4_put_delegation(dp);
 652 }
 653
 654 static void destroy_delegation(struct nfs4_delegation *dp)
 655 {
 656         unhash_delegation(dp);
 657         remove_stid(&dp->dl_stid);
 658         nfs4_put_delegation(dp);
 659 }
 660
 661 static void revoke_delegation(struct nfs4_delegation *dp)
 662 {
 663         struct nfs4_client *clp = dp->dl_stid.sc_client;
 664
 665         if (clp->cl_minorversion == 0)
 666                 destroy_delegation(dp);
 667         else {
 668                 unhash_delegation(dp);
 669                 dp->dl_stid.sc_type = NFS4_REVOKED_DELEG_STID;
 670                 list_add(&dp->dl_recall_lru, &clp->cl_revoked);
 671         }
 672 }
 673
 674 /*
 675  * SETCLIENTID state
 676  */
 677
 678 static unsigned int clientid_hashval(u32 id)
 679 {
 680         return id & CLIENT_HASH_MASK;
 681 }
 682
 683 static unsigned int clientstr_hashval(const char *name)
 684 {
 685         return opaque_hashval(name, 8) & CLIENT_HASH_MASK;
 686 }
 687
 688 /*
 689  * We store the NONE, READ, WRITE, and BOTH bits separately in the
 690  * st_{access,deny}_bmap field of the stateid, in order to track not
 691  * only what share bits are currently in force, but also what
 692  * combinations of share bits previous opens have used.  This allows us
 693  * to enforce the recommendation of rfc 3530 14.2.19 that the server
 694  * return an error if the client attempt to downgrade to a combination
 695  * of share bits not explicable by closing some of its previous opens.
 696  *
 697  * XXX: This enforcement is actually incomplete, since we don't keep
 698  * track of access/deny bit combinations; so, e.g., we allow:
 699  *
 700  *      OPEN allow read, deny write
 701  *      OPEN allow both, deny none
 702  *      DOWNGRADE allow read, deny none
 703  *
 704  * which we should reject.
 705  */
 706 static unsigned int
 707 bmap_to_share_mode(unsigned long bmap) {
 708         int i;
 709         unsigned int access = 0;
 710
 711         for (i = 1; i < 4; i++) {
 712                 if (test_bit(i, &bmap))
 713                         access |= i;
 714         }
 715         return access;
 716 }
 717
 718 static bool
 719 test_share(struct nfs4_ol_stateid *stp, struct nfsd4_open *open) {
 720         unsigned int access, deny;
 721
 722         access = bmap_to_share_mode(stp->st_access_bmap);
 723         deny = bmap_to_share_mode(stp->st_deny_bmap);
 724         if ((access & open->op_share_deny) || (deny & open->op_share_access))
 725                 return false;
 726         return true;
 727 }
 728
 729 /* set share access for a given stateid */
 730 static inline void
 731 set_access(u32 access, struct nfs4_ol_stateid *stp)
 732 {
 733         __set_bit(access, &stp->st_access_bmap);
 734 }
 735
 736 /* clear share access for a given stateid */
 737 static inline void
 738 clear_access(u32 access, struct nfs4_ol_stateid *stp)
 739 {
 740         __clear_bit(access, &stp->st_access_bmap);
 741 }
 742
 743 /* test whether a given stateid has access */
 744 static inline bool
 745 test_access(u32 access, struct nfs4_ol_stateid *stp)
 746 {
 747         return test_bit(access, &stp->st_access_bmap);
 748 }
 749
 750 /* set share deny for a given stateid */
 751 static inline void
 752 set_deny(u32 access, struct nfs4_ol_stateid *stp)
 753 {
 754         __set_bit(access, &stp->st_deny_bmap);
 755 }
 756
 757 /* clear share deny for a given stateid */
 758 static inline void
 759 clear_deny(u32 access, struct nfs4_ol_stateid *stp)
 760 {
 761         __clear_bit(access, &stp->st_deny_bmap);
 762 }
 763
 764 /* test whether a given stateid is denying specific access */
 765 static inline bool
 766 test_deny(u32 access, struct nfs4_ol_stateid *stp)
 767 {
 768         return test_bit(access, &stp->st_deny_bmap);
 769 }
 770
 771 static int nfs4_access_to_omode(u32 access)
 772 {
 773         switch (access & NFS4_SHARE_ACCESS_BOTH) {
 774         case NFS4_SHARE_ACCESS_READ:
 775                 return O_RDONLY;
 776         case NFS4_SHARE_ACCESS_WRITE:
 777                 return O_WRONLY;
 778         case NFS4_SHARE_ACCESS_BOTH:
 779                 return O_RDWR;
 780         }
 781         WARN_ON_ONCE(1);
 782         return O_RDONLY;
 783 }
 784
 785 /* release all access and file references for a given stateid */
 786 static void
 787 release_all_access(struct nfs4_ol_stateid *stp)
 788 {
 789         int i;
 790
 791         for (i = 1; i < 4; i++) {
 792                 if (test_access(i, stp))
 793                         nfs4_file_put_access(stp->st_file, i);
 794                 clear_access(i, stp);
 795         }
 796 }
 797
 798 static void unhash_generic_stateid(struct nfs4_ol_stateid *stp)
 799 {
 800         struct nfs4_file *fp = stp->st_file;
 801
 802         spin_lock(&fp->fi_lock);
 803         list_del(&stp->st_perfile);
 804         spin_unlock(&fp->fi_lock);
 805         list_del(&stp->st_perstateowner);
 806 }
 807
 808 static void close_generic_stateid(struct nfs4_ol_stateid *stp)
 809 {
 810         release_all_access(stp);
 811         put_nfs4_file(stp->st_file);
 812         stp->st_file = NULL;
 813 }
 814
 815 static void free_generic_stateid(struct nfs4_ol_stateid *stp)
 816 {
 817         remove_stid(&stp->st_stid);
 818         nfs4_free_stid(stateid_slab, &stp->st_stid);
 819 }
 820
 821 static void __release_lock_stateid(struct nfs4_ol_stateid *stp)
 822 {
 823         struct file *file;
 824
 825         list_del(&stp->st_locks);
 826         unhash_generic_stateid(stp);
 827         unhash_stid(&stp->st_stid);
 828         file = find_any_file(stp->st_file);
 829         if (file)
 830                 filp_close(file, (fl_owner_t)lockowner(stp->st_stateowner));
 831         close_generic_stateid(stp);
 832         free_generic_stateid(stp);
 833 }
 834
 835 static void unhash_lockowner(struct nfs4_lockowner *lo)
 836 {
 837         struct nfs4_ol_stateid *stp;
 838
 839         list_del(&lo->lo_owner.so_strhash);
 840         while (!list_empty(&lo->lo_owner.so_stateids)) {
 841                 stp = list_first_entry(&lo->lo_owner.so_stateids,
 842                                 struct nfs4_ol_stateid, st_perstateowner);
 843                 __release_lock_stateid(stp);
 844         }
 845 }
 846
 847 static void nfs4_free_lockowner(struct nfs4_lockowner *lo)
 848 {
 849         kfree(lo->lo_owner.so_owner.data);
 850         kmem_cache_free(lockowner_slab, lo);
 851 }
 852
 853 static void release_lockowner(struct nfs4_lockowner *lo)
 854 {
 855         unhash_lockowner(lo);
 856         nfs4_free_lockowner(lo);
 857 }
 858
 859 static void release_lockowner_if_empty(struct nfs4_lockowner *lo)
 860 {
 861         if (list_empty(&lo->lo_owner.so_stateids))
 862                 release_lockowner(lo);
 863 }
 864
 865 static void release_lock_stateid(struct nfs4_ol_stateid *stp)
 866 {
 867         struct nfs4_lockowner *lo;
 868
 869         lo = lockowner(stp->st_stateowner);
 870         __release_lock_stateid(stp);
 871         release_lockowner_if_empty(lo);
 872 }
 873
 874 static void release_open_stateid_locks(struct nfs4_ol_stateid *open_stp)
 875 {
 876         struct nfs4_ol_stateid *stp;
 877
 878         while (!list_empty(&open_stp->st_locks)) {
 879                 stp = list_entry(open_stp->st_locks.next,
 880                                 struct nfs4_ol_stateid, st_locks);
 881                 release_lock_stateid(stp);
 882         }
 883 }
 884
 885 static void unhash_open_stateid(struct nfs4_ol_stateid *stp)
 886 {
 887         unhash_generic_stateid(stp);
 888         release_open_stateid_locks(stp);
 889         close_generic_stateid(stp);
 890 }
 891
 892 static void release_open_stateid(struct nfs4_ol_stateid *stp)
 893 {
 894         unhash_open_stateid(stp);
 895         free_generic_stateid(stp);
 896 }
 897
 898 static void unhash_openowner(struct nfs4_openowner *oo)
 899 {
 900         struct nfs4_ol_stateid *stp;
 901
 902         list_del(&oo->oo_owner.so_strhash);
 903         list_del(&oo->oo_perclient);
 904         while (!list_empty(&oo->oo_owner.so_stateids)) {
 905                 stp = list_first_entry(&oo->oo_owner.so_stateids,
 906                                 struct nfs4_ol_stateid, st_perstateowner);
 907                 release_open_stateid(stp);
 908         }
 909 }
 910
 911 static void release_last_closed_stateid(struct nfs4_openowner *oo)
 912 {
 913         struct nfs4_ol_stateid *s = oo->oo_last_closed_stid;
 914
 915         if (s) {
 916                 free_generic_stateid(s);
 917                 oo->oo_last_closed_stid = NULL;
 918         }
 919 }
 920
 921 static void nfs4_free_openowner(struct nfs4_openowner *oo)
 922 {
 923         kfree(oo->oo_owner.so_owner.data);
 924         kmem_cache_free(openowner_slab, oo);
 925 }
 926
 927 static void release_openowner(struct nfs4_openowner *oo)
 928 {
 929         unhash_openowner(oo);
 930         list_del(&oo->oo_close_lru);
 931         release_last_closed_stateid(oo);
 932         nfs4_free_openowner(oo);
 933 }
 934
 935 static inline int
 936 hash_sessionid(struct nfs4_sessionid *sessionid)
 937 {
 938         struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
 939
 940         return sid->sequence % SESSION_HASH_SIZE;
 941 }
 942
 943 #ifdef NFSD_DEBUG
 944 static inline void
 945 dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
 946 {
 947         u32 *ptr = (u32 *)(&sessionid->data[0]);
 948         dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
 949 }
 950 #else
 951 static inline void
 952 dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
 953 {
 954 }
 955 #endif
 956
 957 /*
 958  * Bump the seqid on cstate->replay_owner, and clear replay_owner if it
 959  * won't be used for replay.
 960  */
 961 void nfsd4_bump_seqid(struct nfsd4_compound_state *cstate, __be32 nfserr)
 962 {
 963         struct nfs4_stateowner *so = cstate->replay_owner;
 964
 965         if (nfserr == nfserr_replay_me)
 966                 return;
 967
 968         if (!seqid_mutating_err(ntohl(nfserr))) {
 969                 cstate->replay_owner = NULL;
 970                 return;
 971         }
 972         if (!so)
 973                 return;
 974         if (so->so_is_open_owner)
 975                 release_last_closed_stateid(openowner(so));
 976         so->so_seqid++;
 977         return;
 978 }
 979
 980 static void
 981 gen_sessionid(struct nfsd4_session *ses)
 982 {
 983         struct nfs4_client *clp = ses->se_client;
 984         struct nfsd4_sessionid *sid;
 985
 986         sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
 987         sid->clientid = clp->cl_clientid;
 988         sid->sequence = current_sessionid++;
 989         sid->reserved = 0;
 990 }
 991
 992 /*
 993  * The protocol defines ca_maxresponssize_cached to include the size of
 994  * the rpc header, but all we need to cache is the data starting after
 995  * the end of the initial SEQUENCE operation--the rest we regenerate
 996  * each time.  Therefore we can advertise a ca_maxresponssize_cached
 997  * value that is the number of bytes in our cache plus a few additional
 998  * bytes.  In order to stay on the safe side, and not promise more than
 999  * we can cache, those additional bytes must be the minimum possible: 24
1000  * bytes of rpc header (xid through accept state, with AUTH_NULL
1001  * verifier), 12 for the compound header (with zero-length tag), and 44
1002  * for the SEQUENCE op response:
1003  */
1004 #define NFSD_MIN_HDR_SEQ_SZ  (24 + 12 + 44)
1005
1006 static void
1007 free_session_slots(struct nfsd4_session *ses)
1008 {
1009         int i;
1010
1011         for (i = 0; i < ses->se_fchannel.maxreqs; i++)
1012                 kfree(ses->se_slots[i]);
1013 }
1014
1015 /*
1016  * We don't actually need to cache the rpc and session headers, so we
1017  * can allocate a little less for each slot:
1018  */
1019 static inline u32 slot_bytes(struct nfsd4_channel_attrs *ca)
1020 {
1021         u32 size;
1022
1023         if (ca->maxresp_cached < NFSD_MIN_HDR_SEQ_SZ)
1024                 size = 0;
1025         else
1026                 size = ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
1027         return size + sizeof(struct nfsd4_slot);
1028 }
1029
1030 /*
1031  * XXX: If we run out of reserved DRC memory we could (up to a point)
1032  * re-negotiate active sessions and reduce their slot usage to make
1033  * room for new connections. For now we just fail the create session.
1034  */
1035 static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca)
1036 {
1037         u32 slotsize = slot_bytes(ca);
1038         u32 num = ca->maxreqs;
1039         int avail;
1040
1041         spin_lock(&nfsd_drc_lock);
1042         avail = min((unsigned long)NFSD_MAX_MEM_PER_SESSION,
1043                     nfsd_drc_max_mem - nfsd_drc_mem_used);
1044         num = min_t(int, num, avail / slotsize);
1045         nfsd_drc_mem_used += num * slotsize;
1046         spin_unlock(&nfsd_drc_lock);
1047
1048         return num;
1049 }
1050
1051 static void nfsd4_put_drc_mem(struct nfsd4_channel_attrs *ca)
1052 {
1053         int slotsize = slot_bytes(ca);
1054
1055         spin_lock(&nfsd_drc_lock);
1056         nfsd_drc_mem_used -= slotsize * ca->maxreqs;
1057         spin_unlock(&nfsd_drc_lock);
1058 }
1059
1060 static struct nfsd4_session *alloc_session(struct nfsd4_channel_attrs *fattrs,
1061                                            struct nfsd4_channel_attrs *battrs)
1062 {
1063         int numslots = fattrs->maxreqs;
1064         int slotsize = slot_bytes(fattrs);
1065         struct nfsd4_session *new;
1066         int mem, i;
1067
1068         BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
1069                         + sizeof(struct nfsd4_session) > PAGE_SIZE);
1070         mem = numslots * sizeof(struct nfsd4_slot *);
1071
1072         new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
1073         if (!new)
1074                 return NULL;
1075         /* allocate each struct nfsd4_slot and data cache in one piece */
1076         for (i = 0; i < numslots; i++) {
1077                 new->se_slots[i] = kzalloc(slotsize, GFP_KERNEL);
1078                 if (!new->se_slots[i])
1079                         goto out_free;
1080         }
1081
1082         memcpy(&new->se_fchannel, fattrs, sizeof(struct nfsd4_channel_attrs));
1083         memcpy(&new->se_bchannel, battrs, sizeof(struct nfsd4_channel_attrs));
1084
1085         return new;
1086 out_free:
1087         while (i--)
1088                 kfree(new->se_slots[i]);
1089         kfree(new);
1090         return NULL;
1091 }
1092
1093 static void free_conn(struct nfsd4_conn *c)
1094 {
1095         svc_xprt_put(c->cn_xprt);
1096         kfree(c);
1097 }
1098
1099 static void nfsd4_conn_lost(struct svc_xpt_user *u)
1100 {
1101         struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
1102         struct nfs4_client *clp = c->cn_session->se_client;
1103
1104         spin_lock(&clp->cl_lock);
1105         if (!list_empty(&c->cn_persession)) {
1106                 list_del(&c->cn_persession);
1107                 free_conn(c);
1108         }
1109         nfsd4_probe_callback(clp);
1110         spin_unlock(&clp->cl_lock);
1111 }
1112
1113 static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
1114 {
1115         struct nfsd4_conn *conn;
1116
1117         conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
1118         if (!conn)
1119                 return NULL;
1120         svc_xprt_get(rqstp->rq_xprt);
1121         conn->cn_xprt = rqstp->rq_xprt;
1122         conn->cn_flags = flags;
1123         INIT_LIST_HEAD(&conn->cn_xpt_user.list);
1124         return conn;
1125 }
1126
1127 static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
1128 {
1129         conn->cn_session = ses;
1130         list_add(&conn->cn_persession, &ses->se_conns);
1131 }
1132
1133 static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
1134 {
1135         struct nfs4_client *clp = ses->se_client;
1136
1137         spin_lock(&clp->cl_lock);
1138         __nfsd4_hash_conn(conn, ses);
1139         spin_unlock(&clp->cl_lock);
1140 }
1141
1142 static int nfsd4_register_conn(struct nfsd4_conn *conn)
1143 {
1144         conn->cn_xpt_user.callback = nfsd4_conn_lost;
1145         return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
1146 }
1147
1148 static void nfsd4_init_conn(struct svc_rqst *rqstp, struct nfsd4_conn *conn, struct nfsd4_session *ses)
1149 {
1150         int ret;
1151
1152         nfsd4_hash_conn(conn, ses);
1153         ret = nfsd4_register_conn(conn);
1154         if (ret)
1155                 /* oops; xprt is already down: */
1156                 nfsd4_conn_lost(&conn->cn_xpt_user);
1157         if (conn->cn_flags & NFS4_CDFC4_BACK) {
1158                 /* callback channel may be back up */
1159                 nfsd4_probe_callback(ses->se_client);
1160         }
1161 }
1162
1163 static struct nfsd4_conn *alloc_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_create_session *cses)
1164 {
1165         u32 dir = NFS4_CDFC4_FORE;
1166
1167         if (cses->flags & SESSION4_BACK_CHAN)
1168                 dir |= NFS4_CDFC4_BACK;
1169         return alloc_conn(rqstp, dir);
1170 }
1171
1172 /* must be called under client_lock */
1173 static void nfsd4_del_conns(struct nfsd4_session *s)
1174 {
1175         struct nfs4_client *clp = s->se_client;
1176         struct nfsd4_conn *c;
1177
1178         spin_lock(&clp->cl_lock);
1179         while (!list_empty(&s->se_conns)) {
1180                 c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
1181                 list_del_init(&c->cn_persession);
1182                 spin_unlock(&clp->cl_lock);
1183
1184                 unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
1185                 free_conn(c);
1186
1187                 spin_lock(&clp->cl_lock);
1188         }
1189         spin_unlock(&clp->cl_lock);
1190 }
1191
1192 static void __free_session(struct nfsd4_session *ses)
1193 {
1194         free_session_slots(ses);
1195         kfree(ses);
1196 }
1197
1198 static void free_session(struct nfsd4_session *ses)
1199 {
1200         struct nfsd_net *nn = net_generic(ses->se_client->net, nfsd_net_id);
1201
1202         lockdep_assert_held(&nn->client_lock);
1203         nfsd4_del_conns(ses);
1204         nfsd4_put_drc_mem(&ses->se_fchannel);
1205         __free_session(ses);
1206 }
1207
1208 static void init_session(struct svc_rqst *rqstp, struct nfsd4_session *new, struct nfs4_client *clp, struct nfsd4_create_session *cses)
1209 {
1210         int idx;
1211         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
1212
1213         new->se_client = clp;
1214         gen_sessionid(new);
1215
1216         INIT_LIST_HEAD(&new->se_conns);
1217
1218         new->se_cb_seq_nr = 1;
1219         new->se_flags = cses->flags;
1220         new->se_cb_prog = cses->callback_prog;
1221         new->se_cb_sec = cses->cb_sec;
1222         atomic_set(&new->se_ref, 0);
1223         idx = hash_sessionid(&new->se_sessionid);
1224         spin_lock(&nn->client_lock);
1225         list_add(&new->se_hash, &nn->sessionid_hashtbl[idx]);
1226         spin_lock(&clp->cl_lock);
1227         list_add(&new->se_perclnt, &clp->cl_sessions);
1228         spin_unlock(&clp->cl_lock);
1229         spin_unlock(&nn->client_lock);
1230
1231         if (cses->flags & SESSION4_BACK_CHAN) {
1232                 struct sockaddr *sa = svc_addr(rqstp);
1233                 /*
1234                  * This is a little silly; with sessions there's no real
1235                  * use for the callback address.  Use the peer address
1236                  * as a reasonable default for now, but consider fixing
1237                  * the rpc client not to require an address in the
1238                  * future:
1239                  */
1240                 rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
1241                 clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
1242         }
1243 }
1244
1245 /* caller must hold client_lock */
1246 static struct nfsd4_session *
1247 __find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net)
1248 {
1249         struct nfsd4_session *elem;
1250         int idx;
1251         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1252
1253         dump_sessionid(__func__, sessionid);
1254         idx = hash_sessionid(sessionid);
1255         /* Search in the appropriate list */
1256         list_for_each_entry(elem, &nn->sessionid_hashtbl[idx], se_hash) {
1257                 if (!memcmp(elem->se_sessionid.data, sessionid->data,
1258                             NFS4_MAX_SESSIONID_LEN)) {
1259                         return elem;
1260                 }
1261         }
1262
1263         dprintk("%s: session not found\n", __func__);
1264         return NULL;
1265 }
1266
1267 static struct nfsd4_session *
1268 find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net,
1269                 __be32 *ret)
1270 {
1271         struct nfsd4_session *session;
1272         __be32 status = nfserr_badsession;
1273
1274         session = __find_in_sessionid_hashtbl(sessionid, net);
1275         if (!session)
1276                 goto out;
1277         status = nfsd4_get_session_locked(session);
1278         if (status)
1279                 session = NULL;
1280 out:
1281         *ret = status;
1282         return session;
1283 }
1284
1285 /* caller must hold client_lock */
1286 static void
1287 unhash_session(struct nfsd4_session *ses)
1288 {
1289         list_del(&ses->se_hash);
1290         spin_lock(&ses->se_client->cl_lock);
1291         list_del(&ses->se_perclnt);
1292         spin_unlock(&ses->se_client->cl_lock);
1293 }
1294
1295 /* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
1296 static int
1297 STALE_CLIENTID(clientid_t *clid, struct nfsd_net *nn)
1298 {
1299         if (clid->cl_boot == nn->boot_time)
1300                 return 0;
1301         dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
1302                 clid->cl_boot, clid->cl_id, nn->boot_time);
1303         return 1;
1304 }
1305
1306 /*
1307  * XXX Should we use a slab cache ?
1308  * This type of memory management is somewhat inefficient, but we use it
1309  * anyway since SETCLIENTID is not a common operation.
1310  */
1311 static struct nfs4_client *alloc_client(struct xdr_netobj name)
1312 {
1313         struct nfs4_client *clp;
1314
1315         clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
1316         if (clp == NULL)
1317                 return NULL;
1318         clp->cl_name.data = kmemdup(name.data, name.len, GFP_KERNEL);
1319         if (clp->cl_name.data == NULL) {
1320                 kfree(clp);
1321                 return NULL;
1322         }
1323         clp->cl_name.len = name.len;
1324         INIT_LIST_HEAD(&clp->cl_sessions);
1325         idr_init(&clp->cl_stateids);
1326         atomic_set(&clp->cl_refcount, 0);
1327         clp->cl_cb_state = NFSD4_CB_UNKNOWN;
1328         INIT_LIST_HEAD(&clp->cl_idhash);
1329         INIT_LIST_HEAD(&clp->cl_openowners);
1330         INIT_LIST_HEAD(&clp->cl_delegations);
1331         INIT_LIST_HEAD(&clp->cl_lru);
1332         INIT_LIST_HEAD(&clp->cl_callbacks);
1333         INIT_LIST_HEAD(&clp->cl_revoked);
1334         spin_lock_init(&clp->cl_lock);
1335         rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
1336         return clp;
1337 }
1338
1339 static void
1340 free_client(struct nfs4_client *clp)
1341 {
1342         struct nfsd_net __maybe_unused *nn = net_generic(clp->net, nfsd_net_id);
1343
1344         lockdep_assert_held(&nn->client_lock);
1345         while (!list_empty(&clp->cl_sessions)) {
1346                 struct nfsd4_session *ses;
1347                 ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
1348                                 se_perclnt);
1349                 list_del(&ses->se_perclnt);
1350                 WARN_ON_ONCE(atomic_read(&ses->se_ref));
1351                 free_session(ses);
1352         }
1353         rpc_destroy_wait_queue(&clp->cl_cb_waitq);
1354         free_svc_cred(&clp->cl_cred);
1355         kfree(clp->cl_name.data);
1356         idr_destroy(&clp->cl_stateids);
1357         kfree(clp);
1358 }
1359
1360 /* must be called under the client_lock */
1361 static inline void
1362 unhash_client_locked(struct nfs4_client *clp)
1363 {
1364         struct nfsd4_session *ses;
1365
1366         list_del(&clp->cl_lru);
1367         spin_lock(&clp->cl_lock);
1368         list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
1369                 list_del_init(&ses->se_hash);
1370         spin_unlock(&clp->cl_lock);
1371 }
1372
1373 static void
1374 destroy_client(struct nfs4_client *clp)
1375 {
1376         struct nfs4_openowner *oo;
1377         struct nfs4_delegation *dp;
1378         struct list_head reaplist;
1379         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1380
1381         INIT_LIST_HEAD(&reaplist);
1382         spin_lock(&state_lock);
1383         while (!list_empty(&clp->cl_delegations)) {
1384                 dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
1385                 list_del_init(&dp->dl_perclnt);
1386                 /* Ensure that deleg break won't try to requeue it */
1387                 ++dp->dl_time;
1388                 list_move(&dp->dl_recall_lru, &reaplist);
1389         }
1390         spin_unlock(&state_lock);
1391         while (!list_empty(&reaplist)) {
1392                 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
1393                 destroy_delegation(dp);
1394         }
1395         list_splice_init(&clp->cl_revoked, &reaplist);
1396         while (!list_empty(&reaplist)) {
1397                 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
1398                 destroy_revoked_delegation(dp);
1399         }
1400         while (!list_empty(&clp->cl_openowners)) {
1401                 oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient);
1402                 release_openowner(oo);
1403         }
1404         nfsd4_shutdown_callback(clp);
1405         if (clp->cl_cb_conn.cb_xprt)
1406                 svc_xprt_put(clp->cl_cb_conn.cb_xprt);
1407         list_del(&clp->cl_idhash);
1408         if (test_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags))
1409                 rb_erase(&clp->cl_namenode, &nn->conf_name_tree);
1410         else
1411                 rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
1412         spin_lock(&nn->client_lock);
1413         unhash_client_locked(clp);
1414         WARN_ON_ONCE(atomic_read(&clp->cl_refcount));
1415         free_client(clp);
1416         spin_unlock(&nn->client_lock);
1417 }
1418
1419 static void expire_client(struct nfs4_client *clp)
1420 {
1421         nfsd4_client_record_remove(clp);
1422         destroy_client(clp);
1423 }
1424
1425 static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
1426 {
1427         memcpy(target->cl_verifier.data, source->data,
1428                         sizeof(target->cl_verifier.data));
1429 }
1430
1431 static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
1432 {
1433         target->cl_clientid.cl_boot = source->cl_clientid.cl_boot;
1434         target->cl_clientid.cl_id = source->cl_clientid.cl_id;
1435 }
1436
1437 static int copy_cred(struct svc_cred *target, struct svc_cred *source)
1438 {
1439         if (source->cr_principal) {
1440                 target->cr_principal =
1441                                 kstrdup(source->cr_principal, GFP_KERNEL);
1442                 if (target->cr_principal == NULL)
1443                         return -ENOMEM;
1444         } else
1445                 target->cr_principal = NULL;
1446         target->cr_flavor = source->cr_flavor;
1447         target->cr_uid = source->cr_uid;
1448         target->cr_gid = source->cr_gid;
1449         target->cr_group_info = source->cr_group_info;
1450         get_group_info(target->cr_group_info);
1451         target->cr_gss_mech = source->cr_gss_mech;
1452         if (source->cr_gss_mech)
1453                 gss_mech_get(source->cr_gss_mech);
1454         return 0;
1455 }
1456
1457 static long long
1458 compare_blob(const struct xdr_netobj *o1, const struct xdr_netobj *o2)
1459 {
1460         long long res;
1461
1462         res = o1->len - o2->len;
1463         if (res)
1464                 return res;
1465         return (long long)memcmp(o1->data, o2->data, o1->len);
1466 }
1467
1468 static int same_name(const char *n1, const char *n2)
1469 {
1470         return 0 == memcmp(n1, n2, HEXDIR_LEN);
1471 }
1472
1473 static int
1474 same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
1475 {
1476         return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
1477 }
1478
1479 static int
1480 same_clid(clientid_t *cl1, clientid_t *cl2)
1481 {
1482         return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
1483 }
1484
1485 static bool groups_equal(struct group_info *g1, struct group_info *g2)
1486 {
1487         int i;
1488
1489         if (g1->ngroups != g2->ngroups)
1490                 return false;
1491         for (i=0; i<g1->ngroups; i++)
1492                 if (!gid_eq(GROUP_AT(g1, i), GROUP_AT(g2, i)))
1493                         return false;
1494         return true;
1495 }
1496
1497 /*
1498  * RFC 3530 language requires clid_inuse be returned when the
1499  * "principal" associated with a requests differs from that previously
1500  * used.  We use uid, gid's, and gss principal string as our best
1501  * approximation.  We also don't want to allow non-gss use of a client
1502  * established using gss: in theory cr_principal should catch that
1503  * change, but in practice cr_principal can be null even in the gss case
1504  * since gssd doesn't always pass down a principal string.
1505  */
1506 static bool is_gss_cred(struct svc_cred *cr)
1507 {
1508         /* Is cr_flavor one of the gss "pseudoflavors"?: */
1509         return (cr->cr_flavor > RPC_AUTH_MAXFLAVOR);
1510 }
1511
1512
1513 static bool
1514 same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
1515 {
1516         if ((is_gss_cred(cr1) != is_gss_cred(cr2))
1517                 || (!uid_eq(cr1->cr_uid, cr2->cr_uid))
1518                 || (!gid_eq(cr1->cr_gid, cr2->cr_gid))
1519                 || !groups_equal(cr1->cr_group_info, cr2->cr_group_info))
1520                 return false;
1521         if (cr1->cr_principal == cr2->cr_principal)
1522                 return true;
1523         if (!cr1->cr_principal || !cr2->cr_principal)
1524                 return false;
1525         return 0 == strcmp(cr1->cr_principal, cr2->cr_principal);
1526 }
1527
1528 static bool svc_rqst_integrity_protected(struct svc_rqst *rqstp)
1529 {
1530         struct svc_cred *cr = &rqstp->rq_cred;
1531         u32 service;
1532
1533         if (!cr->cr_gss_mech)
1534                 return false;
1535         service = gss_pseudoflavor_to_service(cr->cr_gss_mech, cr->cr_flavor);
1536         return service == RPC_GSS_SVC_INTEGRITY ||
1537                service == RPC_GSS_SVC_PRIVACY;
1538 }
1539
1540 static bool mach_creds_match(struct nfs4_client *cl, struct svc_rqst *rqstp)
1541 {
1542         struct svc_cred *cr = &rqstp->rq_cred;
1543
1544         if (!cl->cl_mach_cred)
1545                 return true;
1546         if (cl->cl_cred.cr_gss_mech != cr->cr_gss_mech)
1547                 return false;
1548         if (!svc_rqst_integrity_protected(rqstp))
1549                 return false;
1550         if (!cr->cr_principal)
1551                 return false;
1552         return 0 == strcmp(cl->cl_cred.cr_principal, cr->cr_principal);
1553 }
1554
1555 static void gen_clid(struct nfs4_client *clp, struct nfsd_net *nn)
1556 {
1557         static u32 current_clientid = 1;
1558
1559         clp->cl_clientid.cl_boot = nn->boot_time;
1560         clp->cl_clientid.cl_id = current_clientid++;
1561 }
1562
1563 static void gen_confirm(struct nfs4_client *clp)
1564 {
1565         __be32 verf[2];
1566         static u32 i;
1567
1568         /*
1569          * This is opaque to client, so no need to byte-swap. Use
1570          * __force to keep sparse happy
1571          */
1572         verf[0] = (__force __be32)get_seconds();
1573         verf[1] = (__force __be32)i++;
1574         memcpy(clp->cl_confirm.data, verf, sizeof(clp->cl_confirm.data));
1575 }
1576
1577 static struct nfs4_stid *find_stateid(struct nfs4_client *cl, stateid_t *t)
1578 {
1579         struct nfs4_stid *ret;
1580
1581         ret = idr_find(&cl->cl_stateids, t->si_opaque.so_id);
1582         if (!ret || !ret->sc_type)
1583                 return NULL;
1584         return ret;
1585 }
1586
1587 static struct nfs4_stid *find_stateid_by_type(struct nfs4_client *cl, stateid_t *t, char typemask)
1588 {
1589         struct nfs4_stid *s;
1590
1591         s = find_stateid(cl, t);
1592         if (!s)
1593                 return NULL;
1594         if (typemask & s->sc_type)
1595                 return s;
1596         return NULL;
1597 }
1598
1599 static struct nfs4_client *create_client(struct xdr_netobj name,
1600                 struct svc_rqst *rqstp, nfs4_verifier *verf)
1601 {
1602         struct nfs4_client *clp;
1603         struct sockaddr *sa = svc_addr(rqstp);
1604         int ret;
1605         struct net *net = SVC_NET(rqstp);
1606         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1607
1608         clp = alloc_client(name);
1609         if (clp == NULL)
1610                 return NULL;
1611
1612         ret = copy_cred(&clp->cl_cred, &rqstp->rq_cred);
1613         if (ret) {
1614                 spin_lock(&nn->client_lock);
1615                 free_client(clp);
1616                 spin_unlock(&nn->client_lock);
1617                 return NULL;
1618         }
1619         nfsd4_init_callback(&clp->cl_cb_null);
1620         clp->cl_time = get_seconds();
1621         clear_bit(0, &clp->cl_cb_slot_busy);
1622         copy_verf(clp, verf);
1623         rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
1624         gen_confirm(clp);
1625         clp->cl_cb_session = NULL;
1626         clp->net = net;
1627         return clp;
1628 }
1629
1630 static void
1631 add_clp_to_name_tree(struct nfs4_client *new_clp, struct rb_root *root)
1632 {
1633         struct rb_node **new = &(root->rb_node), *parent = NULL;
1634         struct nfs4_client *clp;
1635
1636         while (*new) {
1637                 clp = rb_entry(*new, struct nfs4_client, cl_namenode);
1638                 parent = *new;
1639
1640                 if (compare_blob(&clp->cl_name, &new_clp->cl_name) > 0)
1641                         new = &((*new)->rb_left);
1642                 else
1643                         new = &((*new)->rb_right);
1644         }
1645
1646         rb_link_node(&new_clp->cl_namenode, parent, new);
1647         rb_insert_color(&new_clp->cl_namenode, root);
1648 }
1649
1650 static struct nfs4_client *
1651 find_clp_in_name_tree(struct xdr_netobj *name, struct rb_root *root)
1652 {
1653         long long cmp;
1654         struct rb_node *node = root->rb_node;
1655         struct nfs4_client *clp;
1656
1657         while (node) {
1658                 clp = rb_entry(node, struct nfs4_client, cl_namenode);
1659                 cmp = compare_blob(&clp->cl_name, name);
1660                 if (cmp > 0)
1661                         node = node->rb_left;
1662                 else if (cmp < 0)
1663                         node = node->rb_right;
1664                 else
1665                         return clp;
1666         }
1667         return NULL;
1668 }
1669
1670 static void
1671 add_to_unconfirmed(struct nfs4_client *clp)
1672 {
1673         unsigned int idhashval;
1674         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1675
1676         clear_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
1677         add_clp_to_name_tree(clp, &nn->unconf_name_tree);
1678         idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1679         list_add(&clp->cl_idhash, &nn->unconf_id_hashtbl[idhashval]);
1680         renew_client(clp);
1681 }
1682
1683 static void
1684 move_to_confirmed(struct nfs4_client *clp)
1685 {
1686         unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1687         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1688
1689         dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
1690         list_move(&clp->cl_idhash, &nn->conf_id_hashtbl[idhashval]);
1691         rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
1692         add_clp_to_name_tree(clp, &nn->conf_name_tree);
1693         set_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
1694         renew_client(clp);
1695 }
1696
1697 static struct nfs4_client *
1698 find_client_in_id_table(struct list_head *tbl, clientid_t *clid, bool sessions)
1699 {
1700         struct nfs4_client *clp;
1701         unsigned int idhashval = clientid_hashval(clid->cl_id);
1702
1703         list_for_each_entry(clp, &tbl[idhashval], cl_idhash) {
1704                 if (same_clid(&clp->cl_clientid, clid)) {
1705                         if ((bool)clp->cl_minorversion != sessions)
1706                                 return NULL;
1707                         renew_client(clp);
1708                         return clp;
1709                 }
1710         }
1711         return NULL;
1712 }
1713
1714 static struct nfs4_client *
1715 find_confirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
1716 {
1717         struct list_head *tbl = nn->conf_id_hashtbl;
1718
1719         return find_client_in_id_table(tbl, clid, sessions);
1720 }
1721
1722 static struct nfs4_client *
1723 find_unconfirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
1724 {
1725         struct list_head *tbl = nn->unconf_id_hashtbl;
1726
1727         return find_client_in_id_table(tbl, clid, sessions);
1728 }
1729
1730 static bool clp_used_exchangeid(struct nfs4_client *clp)
1731 {
1732         return clp->cl_exchange_flags != 0;
1733 }
1734
1735 static struct nfs4_client *
1736 find_confirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
1737 {
1738         return find_clp_in_name_tree(name, &nn->conf_name_tree);
1739 }
1740
1741 static struct nfs4_client *
1742 find_unconfirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
1743 {
1744         return find_clp_in_name_tree(name, &nn->unconf_name_tree);
1745 }
1746
1747 static void
1748 gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
1749 {
1750         struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
1751         struct sockaddr *sa = svc_addr(rqstp);
1752         u32 scopeid = rpc_get_scope_id(sa);
1753         unsigned short expected_family;
1754
1755         /* Currently, we only support tcp and tcp6 for the callback channel */
1756         if (se->se_callback_netid_len == 3 &&
1757             !memcmp(se->se_callback_netid_val, "tcp", 3))
1758                 expected_family = AF_INET;
1759         else if (se->se_callback_netid_len == 4 &&
1760                  !memcmp(se->se_callback_netid_val, "tcp6", 4))
1761                 expected_family = AF_INET6;
1762         else
1763                 goto out_err;
1764
1765         conn->cb_addrlen = rpc_uaddr2sockaddr(clp->net, se->se_callback_addr_val,
1766                                             se->se_callback_addr_len,
1767                                             (struct sockaddr *)&conn->cb_addr,
1768                                             sizeof(conn->cb_addr));
1769
1770         if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
1771                 goto out_err;
1772
1773         if (conn->cb_addr.ss_family == AF_INET6)
1774                 ((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
1775
1776         conn->cb_prog = se->se_callback_prog;
1777         conn->cb_ident = se->se_callback_ident;
1778         memcpy(&conn->cb_saddr, &rqstp->rq_daddr, rqstp->rq_daddrlen);
1779         return;
1780 out_err:
1781         conn->cb_addr.ss_family = AF_UNSPEC;
1782         conn->cb_addrlen = 0;
1783         dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
1784                 "will not receive delegations\n",
1785                 clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
1786
1787         return;
1788 }
1789
1790 /*
1791  * Cache a reply. nfsd4_check_resp_size() has bounded the cache size.
1792  */
1793 static void
1794 nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
1795 {
1796         struct xdr_buf *buf = resp->xdr.buf;
1797         struct nfsd4_slot *slot = resp->cstate.slot;
1798         unsigned int base;
1799
1800         dprintk("--> %s slot %p\n", __func__, slot);
1801
1802         slot->sl_opcnt = resp->opcnt;
1803         slot->sl_status = resp->cstate.status;
1804
1805         slot->sl_flags |= NFSD4_SLOT_INITIALIZED;
1806         if (nfsd4_not_cached(resp)) {
1807                 slot->sl_datalen = 0;
1808                 return;
1809         }
1810         base = resp->cstate.data_offset;
1811         slot->sl_datalen = buf->len - base;
1812         if (read_bytes_from_xdr_buf(buf, base, slot->sl_data, slot->sl_datalen))
1813                 WARN("%s: sessions DRC could not cache compound\n", __func__);
1814         return;
1815 }
1816
1817 /*
1818  * Encode the replay sequence operation from the slot values.
1819  * If cachethis is FALSE encode the uncached rep error on the next
1820  * operation which sets resp->p and increments resp->opcnt for
1821  * nfs4svc_encode_compoundres.
1822  *
1823  */
1824 static __be32
1825 nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
1826                           struct nfsd4_compoundres *resp)
1827 {
1828         struct nfsd4_op *op;
1829         struct nfsd4_slot *slot = resp->cstate.slot;
1830
1831         /* Encode the replayed sequence operation */
1832         op = &args->ops[resp->opcnt - 1];
1833         nfsd4_encode_operation(resp, op);
1834
1835         /* Return nfserr_retry_uncached_rep in next operation. */
1836         if (args->opcnt > 1 && !(slot->sl_flags & NFSD4_SLOT_CACHETHIS)) {
1837                 op = &args->ops[resp->opcnt++];
1838                 op->status = nfserr_retry_uncached_rep;
1839                 nfsd4_encode_operation(resp, op);
1840         }
1841         return op->status;
1842 }
1843
1844 /*
1845  * The sequence operation is not cached because we can use the slot and
1846  * session values.
1847  */
1848 static __be32
1849 nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
1850                          struct nfsd4_sequence *seq)
1851 {
1852         struct nfsd4_slot *slot = resp->cstate.slot;
1853         struct xdr_stream *xdr = &resp->xdr;
1854         __be32 *p;
1855         __be32 status;
1856
1857         dprintk("--> %s slot %p\n", __func__, slot);
1858
1859         status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
1860         if (status)
1861                 return status;
1862
1863         p = xdr_reserve_space(xdr, slot->sl_datalen);
1864         if (!p) {
1865                 WARN_ON_ONCE(1);
1866                 return nfserr_serverfault;
1867         }
1868         xdr_encode_opaque_fixed(p, slot->sl_data, slot->sl_datalen);
1869         xdr_commit_encode(xdr);
1870
1871         resp->opcnt = slot->sl_opcnt;
1872         return slot->sl_status;
1873 }
1874
1875 /*
1876  * Set the exchange_id flags returned by the server.
1877  */
1878 static void
1879 nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
1880 {
1881         /* pNFS is not supported */
1882         new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
1883
1884         /* Referrals are supported, Migration is not. */
1885         new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
1886
1887         /* set the wire flags to return to client. */
1888         clid->flags = new->cl_exchange_flags;
1889 }
1890
1891 static bool client_has_state(struct nfs4_client *clp)
1892 {
1893         /*
1894          * Note clp->cl_openowners check isn't quite right: there's no
1895          * need to count owners without stateid's.
1896          *
1897          * Also note we should probably be using this in 4.0 case too.
1898          */
1899         return !list_empty(&clp->cl_openowners)
1900                 || !list_empty(&clp->cl_delegations)
1901                 || !list_empty(&clp->cl_sessions);
1902 }
1903
1904 __be32
1905 nfsd4_exchange_id(struct svc_rqst *rqstp,
1906                   struct nfsd4_compound_state *cstate,
1907                   struct nfsd4_exchange_id *exid)
1908 {
1909         struct nfs4_client *unconf, *conf, *new;
1910         __be32 status;
1911         char                    addr_str[INET6_ADDRSTRLEN];
1912         nfs4_verifier           verf = exid->verifier;
1913         struct sockaddr         *sa = svc_addr(rqstp);
1914         bool    update = exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A;
1915         struct nfsd_net         *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
1916
1917         rpc_ntop(sa, addr_str, sizeof(addr_str));
1918         dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
1919                 "ip_addr=%s flags %x, spa_how %d\n",
1920                 __func__, rqstp, exid, exid->clname.len, exid->clname.data,
1921                 addr_str, exid->flags, exid->spa_how);
1922
1923         if (exid->flags & ~EXCHGID4_FLAG_MASK_A)
1924                 return nfserr_inval;
1925
1926         switch (exid->spa_how) {
1927         case SP4_MACH_CRED:
1928                 if (!svc_rqst_integrity_protected(rqstp))
1929                         return nfserr_inval;
1930         case SP4_NONE:
1931                 break;
1932         default:                                /* checked by xdr code */
1933                 WARN_ON_ONCE(1);
1934         case SP4_SSV:
1935                 return nfserr_encr_alg_unsupp;
1936         }
1937
1938         /* Cases below refer to rfc 5661 section 18.35.4: */
1939         nfs4_lock_state();
1940         conf = find_confirmed_client_by_name(&exid->clname, nn);
1941         if (conf) {
1942                 bool creds_match = same_creds(&conf->cl_cred, &rqstp->rq_cred);
1943                 bool verfs_match = same_verf(&verf, &conf->cl_verifier);
1944
1945                 if (update) {
1946                         if (!clp_used_exchangeid(conf)) { /* buggy client */
1947                                 status = nfserr_inval;
1948                                 goto out;
1949                         }
1950                         if (!mach_creds_match(conf, rqstp)) {
1951                                 status = nfserr_wrong_cred;
1952                                 goto out;
1953                         }
1954                         if (!creds_match) { /* case 9 */
1955                                 status = nfserr_perm;
1956                                 goto out;
1957                         }
1958                         if (!verfs_match) { /* case 8 */
1959                                 status = nfserr_not_same;
1960                                 goto out;
1961                         }
1962                         /* case 6 */
1963                         exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
1964                         new = conf;
1965                         goto out_copy;
1966                 }
1967                 if (!creds_match) { /* case 3 */
1968                         if (client_has_state(conf)) {
1969                                 status = nfserr_clid_inuse;
1970                                 goto out;
1971                         }
1972                         expire_client(conf);
1973                         goto out_new;
1974                 }
1975                 if (verfs_match) { /* case 2 */
1976                         conf->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R;
1977                         new = conf;
1978                         goto out_copy;
1979                 }
1980                 /* case 5, client reboot */
1981                 goto out_new;
1982         }
1983
1984         if (update) { /* case 7 */
1985                 status = nfserr_noent;
1986                 goto out;
1987         }
1988
1989         unconf  = find_unconfirmed_client_by_name(&exid->clname, nn);
1990         if (unconf) /* case 4, possible retry or client restart */
1991                 expire_client(unconf);
1992
1993         /* case 1 (normal case) */
1994 out_new:
1995         new = create_client(exid->clname, rqstp, &verf);
1996         if (new == NULL) {
1997                 status = nfserr_jukebox;
1998                 goto out;
1999         }
2000         new->cl_minorversion = cstate->minorversion;
2001         new->cl_mach_cred = (exid->spa_how == SP4_MACH_CRED);
2002
2003         gen_clid(new, nn);
2004         add_to_unconfirmed(new);
2005 out_copy:
2006         exid->clientid.cl_boot = new->cl_clientid.cl_boot;
2007         exid->clientid.cl_id = new->cl_clientid.cl_id;
2008
2009         exid->seqid = new->cl_cs_slot.sl_seqid + 1;
2010         nfsd4_set_ex_flags(new, exid);
2011
2012         dprintk("nfsd4_exchange_id seqid %d flags %x\n",
2013                 new->cl_cs_slot.sl_seqid, new->cl_exchange_flags);
2014         status = nfs_ok;
2015
2016 out:
2017         nfs4_unlock_state();
2018         return status;
2019 }
2020
2021 static __be32
2022 check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
2023 {
2024         dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
2025                 slot_seqid);
2026
2027         /* The slot is in use, and no response has been sent. */
2028         if (slot_inuse) {
2029                 if (seqid == slot_seqid)
2030                         return nfserr_jukebox;
2031                 else
2032                         return nfserr_seq_misordered;
2033         }
2034         /* Note unsigned 32-bit arithmetic handles wraparound: */
2035         if (likely(seqid == slot_seqid + 1))
2036                 return nfs_ok;
2037         if (seqid == slot_seqid)
2038                 return nfserr_replay_cache;
2039         return nfserr_seq_misordered;
2040 }
2041
2042 /*
2043  * Cache the create session result into the create session single DRC
2044  * slot cache by saving the xdr structure. sl_seqid has been set.
2045  * Do this for solo or embedded create session operations.
2046  */
2047 static void
2048 nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
2049                            struct nfsd4_clid_slot *slot, __be32 nfserr)
2050 {
2051         slot->sl_status = nfserr;
2052         memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
2053 }
2054
2055 static __be32
2056 nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
2057                             struct nfsd4_clid_slot *slot)
2058 {
2059         memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
2060         return slot->sl_status;
2061 }
2062
2063 #define NFSD_MIN_REQ_HDR_SEQ_SZ ((\
2064                         2 * 2 + /* credential,verifier: AUTH_NULL, length 0 */ \
2065                         1 +     /* MIN tag is length with zero, only length */ \
2066                         3 +     /* version, opcount, opcode */ \
2067                         XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
2068                                 /* seqid, slotID, slotID, cache */ \
2069                         4 ) * sizeof(__be32))
2070
2071 #define NFSD_MIN_RESP_HDR_SEQ_SZ ((\
2072                         2 +     /* verifier: AUTH_NULL, length 0 */\
2073                         1 +     /* status */ \
2074                         1 +     /* MIN tag is length with zero, only length */ \
2075                         3 +     /* opcount, opcode, opstatus*/ \
2076                         XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
2077                                 /* seqid, slotID, slotID, slotID, status */ \
2078                         5 ) * sizeof(__be32))
2079
2080 static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn)
2081 {
2082         u32 maxrpc = nn->nfsd_serv->sv_max_mesg;
2083
2084         if (ca->maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ)
2085                 return nfserr_toosmall;
2086         if (ca->maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ)
2087                 return nfserr_toosmall;
2088         ca->headerpadsz = 0;
2089         ca->maxreq_sz = min_t(u32, ca->maxreq_sz, maxrpc);
2090         ca->maxresp_sz = min_t(u32, ca->maxresp_sz, maxrpc);
2091         ca->maxops = min_t(u32, ca->maxops, NFSD_MAX_OPS_PER_COMPOUND);
2092         ca->maxresp_cached = min_t(u32, ca->maxresp_cached,
2093                         NFSD_SLOT_CACHE_SIZE + NFSD_MIN_HDR_SEQ_SZ);
2094         ca->maxreqs = min_t(u32, ca->maxreqs, NFSD_MAX_SLOTS_PER_SESSION);
2095         /*
2096          * Note decreasing slot size below client's request may make it
2097          * difficult for client to function correctly, whereas
2098          * decreasing the number of slots will (just?) affect
2099          * performance.  When short on memory we therefore prefer to
2100          * decrease number of slots instead of their size.  Clients that
2101          * request larger slots than they need will get poor results:
2102          */
2103         ca->maxreqs = nfsd4_get_drc_mem(ca);
2104         if (!ca->maxreqs)
2105                 return nfserr_jukebox;
2106
2107         return nfs_ok;
2108 }
2109
2110 #define NFSD_CB_MAX_REQ_SZ      ((NFS4_enc_cb_recall_sz + \
2111                                  RPC_MAX_HEADER_WITH_AUTH) * sizeof(__be32))
2112 #define NFSD_CB_MAX_RESP_SZ     ((NFS4_dec_cb_recall_sz + \
2113                                  RPC_MAX_REPHEADER_WITH_AUTH) * sizeof(__be32))
2114
2115 static __be32 check_backchannel_attrs(struct nfsd4_channel_attrs *ca)
2116 {
2117         ca->headerpadsz = 0;
2118
2119         /*
2120          * These RPC_MAX_HEADER macros are overkill, especially since we
2121          * don't even do gss on the backchannel yet.  But this is still
2122          * less than 1k.  Tighten up this estimate in the unlikely event
2123          * it turns out to be a problem for some client:
2124          */
2125         if (ca->maxreq_sz < NFSD_CB_MAX_REQ_SZ)
2126                 return nfserr_toosmall;
2127         if (ca->maxresp_sz < NFSD_CB_MAX_RESP_SZ)
2128                 return nfserr_toosmall;
2129         ca->maxresp_cached = 0;
2130         if (ca->maxops < 2)
2131                 return nfserr_toosmall;
2132
2133         return nfs_ok;
2134 }
2135
2136 static __be32 nfsd4_check_cb_sec(struct nfsd4_cb_sec *cbs)
2137 {
2138         switch (cbs->flavor) {
2139         case RPC_AUTH_NULL:
2140         case RPC_AUTH_UNIX:
2141                 return nfs_ok;
2142         default:
2143                 /*
2144                  * GSS case: the spec doesn't allow us to return this
2145                  * error.  But it also doesn't allow us not to support
2146                  * GSS.
2147                  * I'd rather this fail hard than return some error the
2148                  * client might think it can already handle:
2149                  */
2150                 return nfserr_encr_alg_unsupp;
2151         }
2152 }
2153
2154 __be32
2155 nfsd4_create_session(struct svc_rqst *rqstp,
2156                      struct nfsd4_compound_state *cstate,
2157                      struct nfsd4_create_session *cr_ses)
2158 {
2159         struct sockaddr *sa = svc_addr(rqstp);
2160         struct nfs4_client *conf, *unconf;
2161         struct nfsd4_session *new;
2162         struct nfsd4_conn *conn;
2163         struct nfsd4_clid_slot *cs_slot = NULL;
2164         __be32 status = 0;
2165         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2166
2167         if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
2168                 return nfserr_inval;
2169         status = nfsd4_check_cb_sec(&cr_ses->cb_sec);
2170         if (status)
2171                 return status;
2172         status = check_forechannel_attrs(&cr_ses->fore_channel, nn);
2173         if (status)
2174                 return status;
2175         status = check_backchannel_attrs(&cr_ses->back_channel);
2176         if (status)
2177                 goto out_release_drc_mem;
2178         status = nfserr_jukebox;
2179         new = alloc_session(&cr_ses->fore_channel, &cr_ses->back_channel);
2180         if (!new)
2181                 goto out_release_drc_mem;
2182         conn = alloc_conn_from_crses(rqstp, cr_ses);
2183         if (!conn)
2184                 goto out_free_session;
2185
2186         nfs4_lock_state();
2187         unconf = find_unconfirmed_client(&cr_ses->clientid, true, nn);
2188         conf = find_confirmed_client(&cr_ses->clientid, true, nn);
2189         WARN_ON_ONCE(conf && unconf);
2190
2191         if (conf) {
2192                 status = nfserr_wrong_cred;
2193                 if (!mach_creds_match(conf, rqstp))
2194                         goto out_free_conn;
2195                 cs_slot = &conf->cl_cs_slot;
2196                 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
2197                 if (status == nfserr_replay_cache) {
2198                         status = nfsd4_replay_create_session(cr_ses, cs_slot);
2199                         goto out_free_conn;
2200                 } else if (cr_ses->seqid != cs_slot->sl_seqid + 1) {
2201                         status = nfserr_seq_misordered;
2202                         goto out_free_conn;
2203                 }
2204         } else if (unconf) {
2205                 struct nfs4_client *old;
2206                 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
2207                     !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
2208                         status = nfserr_clid_inuse;
2209                         goto out_free_conn;
2210                 }
2211                 status = nfserr_wrong_cred;
2212                 if (!mach_creds_match(unconf, rqstp))
2213                         goto out_free_conn;
2214                 cs_slot = &unconf->cl_cs_slot;
2215                 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
2216                 if (status) {
2217                         /* an unconfirmed replay returns misordered */
2218                         status = nfserr_seq_misordered;
2219                         goto out_free_conn;
2220                 }
2221                 old = find_confirmed_client_by_name(&unconf->cl_name, nn);
2222                 if (old) {
2223                         status = mark_client_expired(old);
2224                         if (status)
2225                                 goto out_free_conn;
2226                         expire_client(old);
2227                 }
2228                 move_to_confirmed(unconf);
2229                 conf = unconf;
2230         } else {
2231                 status = nfserr_stale_clientid;
2232                 goto out_free_conn;
2233         }
2234         status = nfs_ok;
2235         /*
2236          * We do not support RDMA or persistent sessions
2237          */
2238         cr_ses->flags &= ~SESSION4_PERSIST;
2239         cr_ses->flags &= ~SESSION4_RDMA;
2240
2241         init_session(rqstp, new, conf, cr_ses);
2242         nfsd4_init_conn(rqstp, conn, new);
2243
2244         memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
2245                NFS4_MAX_SESSIONID_LEN);
2246         cs_slot->sl_seqid++;
2247         cr_ses->seqid = cs_slot->sl_seqid;
2248
2249         /* cache solo and embedded create sessions under the state lock */
2250         nfsd4_cache_create_session(cr_ses, cs_slot, status);
2251         nfs4_unlock_state();
2252         return status;
2253 out_free_conn:
2254         nfs4_unlock_state();
2255         free_conn(conn);
2256 out_free_session:
2257         __free_session(new);
2258 out_release_drc_mem:
2259         nfsd4_put_drc_mem(&cr_ses->fore_channel);
2260         return status;
2261 }
2262
2263 static __be32 nfsd4_map_bcts_dir(u32 *dir)
2264 {
2265         switch (*dir) {
2266         case NFS4_CDFC4_FORE:
2267         case NFS4_CDFC4_BACK:
2268                 return nfs_ok;
2269         case NFS4_CDFC4_FORE_OR_BOTH:
2270         case NFS4_CDFC4_BACK_OR_BOTH:
2271                 *dir = NFS4_CDFC4_BOTH;
2272                 return nfs_ok;
2273         };
2274         return nfserr_inval;
2275 }
2276
2277 __be32 nfsd4_backchannel_ctl(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_backchannel_ctl *bc)
2278 {
2279         struct nfsd4_session *session = cstate->session;
2280         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2281         __be32 status;
2282
2283         status = nfsd4_check_cb_sec(&bc->bc_cb_sec);
2284         if (status)
2285                 return status;
2286         spin_lock(&nn->client_lock);
2287         session->se_cb_prog = bc->bc_cb_program;
2288         session->se_cb_sec = bc->bc_cb_sec;
2289         spin_unlock(&nn->client_lock);
2290
2291         nfsd4_probe_callback(session->se_client);
2292
2293         return nfs_ok;
2294 }
2295
2296 __be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
2297                      struct nfsd4_compound_state *cstate,
2298                      struct nfsd4_bind_conn_to_session *bcts)
2299 {
2300         __be32 status;
2301         struct nfsd4_conn *conn;
2302         struct nfsd4_session *session;
2303         struct net *net = SVC_NET(rqstp);
2304         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2305
2306         if (!nfsd4_last_compound_op(rqstp))
2307                 return nfserr_not_only_op;
2308         nfs4_lock_state();
2309         spin_lock(&nn->client_lock);
2310         session = find_in_sessionid_hashtbl(&bcts->sessionid, net, &status);
2311         spin_unlock(&nn->client_lock);
2312         if (!session)
2313                 goto out_no_session;
2314         status = nfserr_wrong_cred;
2315         if (!mach_creds_match(session->se_client, rqstp))
2316                 goto out;
2317         status = nfsd4_map_bcts_dir(&bcts->dir);
2318         if (status)
2319                 goto out;
2320         conn = alloc_conn(rqstp, bcts->dir);
2321         status = nfserr_jukebox;
2322         if (!conn)
2323                 goto out;
2324         nfsd4_init_conn(rqstp, conn, session);
2325         status = nfs_ok;
2326 out:
2327         nfsd4_put_session(session);
2328 out_no_session:
2329         nfs4_unlock_state();
2330         return status;
2331 }
2332
2333 static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
2334 {
2335         if (!session)
2336                 return 0;
2337         return !memcmp(sid, &session->se_sessionid, sizeof(*sid));
2338 }
2339
2340 __be32
2341 nfsd4_destroy_session(struct svc_rqst *r,
2342                       struct nfsd4_compound_state *cstate,
2343                       struct nfsd4_destroy_session *sessionid)
2344 {
2345         struct nfsd4_session *ses;
2346         __be32 status;
2347         int ref_held_by_me = 0;
2348         struct net *net = SVC_NET(r);
2349         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2350
2351         nfs4_lock_state();
2352         status = nfserr_not_only_op;
2353         if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) {
2354                 if (!nfsd4_last_compound_op(r))
2355                         goto out;
2356                 ref_held_by_me++;
2357         }
2358         dump_sessionid(__func__, &sessionid->sessionid);
2359         spin_lock(&nn->client_lock);
2360         ses = find_in_sessionid_hashtbl(&sessionid->sessionid, net, &status);
2361         if (!ses)
2362                 goto out_client_lock;
2363         status = nfserr_wrong_cred;
2364         if (!mach_creds_match(ses->se_client, r))
2365                 goto out_put_session;
2366         status = mark_session_dead_locked(ses, 1 + ref_held_by_me);
2367         if (status)
2368                 goto out_put_session;
2369         unhash_session(ses);
2370         spin_unlock(&nn->client_lock);
2371
2372         nfsd4_probe_callback_sync(ses->se_client);
2373
2374         spin_lock(&nn->client_lock);
2375         status = nfs_ok;
2376 out_put_session:
2377         nfsd4_put_session_locked(ses);
2378 out_client_lock:
2379         spin_unlock(&nn->client_lock);
2380 out:
2381         nfs4_unlock_state();
2382         return status;
2383 }
2384
2385 static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
2386 {
2387         struct nfsd4_conn *c;
2388
2389         list_for_each_entry(c, &s->se_conns, cn_persession) {
2390                 if (c->cn_xprt == xpt) {
2391                         return c;
2392                 }
2393         }
2394         return NULL;
2395 }
2396
2397 static __be32 nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
2398 {
2399         struct nfs4_client *clp = ses->se_client;
2400         struct nfsd4_conn *c;
2401         __be32 status = nfs_ok;
2402         int ret;
2403
2404         spin_lock(&clp->cl_lock);
2405         c = __nfsd4_find_conn(new->cn_xprt, ses);
2406         if (c)
2407                 goto out_free;
2408         status = nfserr_conn_not_bound_to_session;
2409         if (clp->cl_mach_cred)
2410                 goto out_free;
2411         __nfsd4_hash_conn(new, ses);
2412         spin_unlock(&clp->cl_lock);
2413         ret = nfsd4_register_conn(new);
2414         if (ret)
2415                 /* oops; xprt is already down: */
2416                 nfsd4_conn_lost(&new->cn_xpt_user);
2417         return nfs_ok;
2418 out_free:
2419         spin_unlock(&clp->cl_lock);
2420         free_conn(new);
2421         return status;
2422 }
2423
2424 static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session)
2425 {
2426         struct nfsd4_compoundargs *args = rqstp->rq_argp;
2427
2428         return args->opcnt > session->se_fchannel.maxops;
2429 }
2430
2431 static bool nfsd4_request_too_big(struct svc_rqst *rqstp,
2432                                   struct nfsd4_session *session)
2433 {
2434         struct xdr_buf *xb = &rqstp->rq_arg;
2435
2436         return xb->len > session->se_fchannel.maxreq_sz;
2437 }
2438
2439 __be32
2440 nfsd4_sequence(struct svc_rqst *rqstp,
2441                struct nfsd4_compound_state *cstate,
2442                struct nfsd4_sequence *seq)
2443 {
2444         struct nfsd4_compoundres *resp = rqstp->rq_resp;
2445         struct xdr_stream *xdr = &resp->xdr;
2446         struct nfsd4_session *session;
2447         struct nfs4_client *clp;
2448         struct nfsd4_slot *slot;
2449         struct nfsd4_conn *conn;
2450         __be32 status;
2451         int buflen;
2452         struct net *net = SVC_NET(rqstp);
2453         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2454
2455         if (resp->opcnt != 1)
2456                 return nfserr_sequence_pos;
2457
2458         /*
2459          * Will be either used or freed by nfsd4_sequence_check_conn
2460          * below.
2461          */
2462         conn = alloc_conn(rqstp, NFS4_CDFC4_FORE);
2463         if (!conn)
2464                 return nfserr_jukebox;
2465
2466         spin_lock(&nn->client_lock);
2467         session = find_in_sessionid_hashtbl(&seq->sessionid, net, &status);
2468         if (!session)
2469                 goto out_no_session;
2470         clp = session->se_client;
2471
2472         status = nfserr_too_many_ops;
2473         if (nfsd4_session_too_many_ops(rqstp, session))
2474                 goto out_put_session;
2475
2476         status = nfserr_req_too_big;
2477         if (nfsd4_request_too_big(rqstp, session))
2478                 goto out_put_session;
2479
2480         status = nfserr_badslot;
2481         if (seq->slotid >= session->se_fchannel.maxreqs)
2482                 goto out_put_session;
2483
2484         slot = session->se_slots[seq->slotid];
2485         dprintk("%s: slotid %d\n", __func__, seq->slotid);
2486
2487         /* We do not negotiate the number of slots yet, so set the
2488          * maxslots to the session maxreqs which is used to encode
2489          * sr_highest_slotid and the sr_target_slot id to maxslots */
2490         seq->maxslots = session->se_fchannel.maxreqs;
2491
2492         status = check_slot_seqid(seq->seqid, slot->sl_seqid,
2493                                         slot->sl_flags & NFSD4_SLOT_INUSE);
2494         if (status == nfserr_replay_cache) {
2495                 status = nfserr_seq_misordered;
2496                 if (!(slot->sl_flags & NFSD4_SLOT_INITIALIZED))
2497                         goto out_put_session;
2498                 cstate->slot = slot;
2499                 cstate->session = session;
2500                 cstate->clp = clp;
2501                 /* Return the cached reply status and set cstate->status
2502                  * for nfsd4_proc_compound processing */
2503                 status = nfsd4_replay_cache_entry(resp, seq);
2504                 cstate->status = nfserr_replay_cache;
2505                 goto out;
2506         }
2507         if (status)
2508                 goto out_put_session;
2509
2510         status = nfsd4_sequence_check_conn(conn, session);
2511         conn = NULL;
2512         if (status)
2513                 goto out_put_session;
2514
2515         buflen = (seq->cachethis) ?
2516                         session->se_fchannel.maxresp_cached :
2517                         session->se_fchannel.maxresp_sz;
2518         status = (seq->cachethis) ? nfserr_rep_too_big_to_cache :
2519                                     nfserr_rep_too_big;
2520         if (xdr_restrict_buflen(xdr, buflen - rqstp->rq_auth_slack))
2521                 goto out_put_session;
2522         svc_reserve(rqstp, buflen);
2523
2524         status = nfs_ok;
2525         /* Success! bump slot seqid */
2526         slot->sl_seqid = seq->seqid;
2527         slot->sl_flags |= NFSD4_SLOT_INUSE;
2528         if (seq->cachethis)
2529                 slot->sl_flags |= NFSD4_SLOT_CACHETHIS;
2530         else
2531                 slot->sl_flags &= ~NFSD4_SLOT_CACHETHIS;
2532
2533         cstate->slot = slot;
2534         cstate->session = session;
2535         cstate->clp = clp;
2536
2537 out:
2538         switch (clp->cl_cb_state) {
2539         case NFSD4_CB_DOWN:
2540                 seq->status_flags = SEQ4_STATUS_CB_PATH_DOWN;
2541                 break;
2542         case NFSD4_CB_FAULT:
2543                 seq->status_flags = SEQ4_STATUS_BACKCHANNEL_FAULT;
2544                 break;
2545         default:
2546                 seq->status_flags = 0;
2547         }
2548         if (!list_empty(&clp->cl_revoked))
2549                 seq->status_flags |= SEQ4_STATUS_RECALLABLE_STATE_REVOKED;
2550 out_no_session:
2551         if (conn)
2552                 free_conn(conn);
2553         spin_unlock(&nn->client_lock);
2554         return status;
2555 out_put_session:
2556         nfsd4_put_session_locked(session);
2557         goto out_no_session;
2558 }
2559
2560 void
2561 nfsd4_sequence_done(struct nfsd4_compoundres *resp)
2562 {
2563         struct nfsd4_compound_state *cs = &resp->cstate;
2564
2565         if (nfsd4_has_session(cs)) {
2566                 if (cs->status != nfserr_replay_cache) {
2567                         nfsd4_store_cache_entry(resp);
2568                         cs->slot->sl_flags &= ~NFSD4_SLOT_INUSE;
2569                 }
2570                 /* Drop session reference that was taken in nfsd4_sequence() */
2571                 nfsd4_put_session(cs->session);
2572         } else if (cs->clp)
2573                 put_client_renew(cs->clp);
2574 }
2575
2576 __be32
2577 nfsd4_destroy_clientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_destroy_clientid *dc)
2578 {
2579         struct nfs4_client *conf, *unconf, *clp;
2580         __be32 status = 0;
2581         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2582
2583         nfs4_lock_state();
2584         unconf = find_unconfirmed_client(&dc->clientid, true, nn);
2585         conf = find_confirmed_client(&dc->clientid, true, nn);
2586         WARN_ON_ONCE(conf && unconf);
2587
2588         if (conf) {
2589                 clp = conf;
2590
2591                 if (client_has_state(conf)) {
2592                         status = nfserr_clientid_busy;
2593                         goto out;
2594                 }
2595         } else if (unconf)
2596                 clp = unconf;
2597         else {
2598                 status = nfserr_stale_clientid;
2599                 goto out;
2600         }
2601         if (!mach_creds_match(clp, rqstp)) {
2602                 status = nfserr_wrong_cred;
2603                 goto out;
2604         }
2605         expire_client(clp);
2606 out:
2607         nfs4_unlock_state();
2608         return status;
2609 }
2610
2611 __be32
2612 nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
2613 {
2614         __be32 status = 0;
2615
2616         if (rc->rca_one_fs) {
2617                 if (!cstate->current_fh.fh_dentry)
2618                         return nfserr_nofilehandle;
2619                 /*
2620                  * We don't take advantage of the rca_one_fs case.
2621                  * That's OK, it's optional, we can safely ignore it.
2622                  */
2623                  return nfs_ok;
2624         }
2625
2626         nfs4_lock_state();
2627         status = nfserr_complete_already;
2628         if (test_and_set_bit(NFSD4_CLIENT_RECLAIM_COMPLETE,
2629                              &cstate->session->se_client->cl_flags))
2630                 goto out;
2631
2632         status = nfserr_stale_clientid;
2633         if (is_client_expired(cstate->session->se_client))
2634                 /*
2635                  * The following error isn't really legal.
2636                  * But we only get here if the client just explicitly
2637                  * destroyed the client.  Surely it no longer cares what
2638                  * error it gets back on an operation for the dead
2639                  * client.
2640                  */
2641                 goto out;
2642
2643         status = nfs_ok;
2644         nfsd4_client_record_create(cstate->session->se_client);
2645 out:
2646         nfs4_unlock_state();
2647         return status;
2648 }
2649
2650 __be32
2651 nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
2652                   struct nfsd4_setclientid *setclid)
2653 {
2654         struct xdr_netobj       clname = setclid->se_name;
2655         nfs4_verifier           clverifier = setclid->se_verf;
2656         struct nfs4_client      *conf, *unconf, *new;
2657         __be32                  status;
2658         struct nfsd_net         *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2659
2660         /* Cases below refer to rfc 3530 section 14.2.33: */
2661         nfs4_lock_state();
2662         conf = find_confirmed_client_by_name(&clname, nn);
2663         if (conf) {
2664                 /* case 0: */
2665                 status = nfserr_clid_inuse;
2666                 if (clp_used_exchangeid(conf))
2667                         goto out;
2668                 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
2669                         char addr_str[INET6_ADDRSTRLEN];
2670                         rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
2671                                  sizeof(addr_str));
2672                         dprintk("NFSD: setclientid: string in use by client "
2673                                 "at %s\n", addr_str);
2674                         goto out;
2675                 }
2676         }
2677         unconf = find_unconfirmed_client_by_name(&clname, nn);
2678         if (unconf)
2679                 expire_client(unconf);
2680         status = nfserr_jukebox;
2681         new = create_client(clname, rqstp, &clverifier);
2682         if (new == NULL)
2683                 goto out;
2684         if (conf && same_verf(&conf->cl_verifier, &clverifier))
2685                 /* case 1: probable callback update */
2686                 copy_clid(new, conf);
2687         else /* case 4 (new client) or cases 2, 3 (client reboot): */
2688                 gen_clid(new, nn);
2689         new->cl_minorversion = 0;
2690         gen_callback(new, setclid, rqstp);
2691         add_to_unconfirmed(new);
2692         setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
2693         setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
2694         memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
2695         status = nfs_ok;
2696 out:
2697         nfs4_unlock_state();
2698         return status;
2699 }
2700
2701
2702 __be32
2703 nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
2704                          struct nfsd4_compound_state *cstate,
2705                          struct nfsd4_setclientid_confirm *setclientid_confirm)
2706 {
2707         struct nfs4_client *conf, *unconf;
2708         nfs4_verifier confirm = setclientid_confirm->sc_confirm;
2709         clientid_t * clid = &setclientid_confirm->sc_clientid;
2710         __be32 status;
2711         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2712
2713         if (STALE_CLIENTID(clid, nn))
2714                 return nfserr_stale_clientid;
2715         nfs4_lock_state();
2716
2717         conf = find_confirmed_client(clid, false, nn);
2718         unconf = find_unconfirmed_client(clid, false, nn);
2719         /*
2720          * We try hard to give out unique clientid's, so if we get an
2721          * attempt to confirm the same clientid with a different cred,
2722          * there's a bug somewhere.  Let's charitably assume it's our
2723          * bug.
2724          */
2725         status = nfserr_serverfault;
2726         if (unconf && !same_creds(&unconf->cl_cred, &rqstp->rq_cred))
2727                 goto out;
2728         if (conf && !same_creds(&conf->cl_cred, &rqstp->rq_cred))
2729                 goto out;
2730         /* cases below refer to rfc 3530 section 14.2.34: */
2731         if (!unconf || !same_verf(&confirm, &unconf->cl_confirm)) {
2732                 if (conf && !unconf) /* case 2: probable retransmit */
2733                         status = nfs_ok;
2734                 else /* case 4: client hasn't noticed we rebooted yet? */
2735                         status = nfserr_stale_clientid;
2736                 goto out;
2737         }
2738         status = nfs_ok;
2739         if (conf) { /* case 1: callback update */
2740                 nfsd4_change_callback(conf, &unconf->cl_cb_conn);
2741                 nfsd4_probe_callback(conf);
2742                 expire_client(unconf);
2743         } else { /* case 3: normal case; new or rebooted client */
2744                 conf = find_confirmed_client_by_name(&unconf->cl_name, nn);
2745                 if (conf) {
2746                         status = mark_client_expired(conf);
2747                         if (status)
2748                                 goto out;
2749                         expire_client(conf);
2750                 }
2751                 move_to_confirmed(unconf);
2752                 nfsd4_probe_callback(unconf);
2753         }
2754 out:
2755         nfs4_unlock_state();
2756         return status;
2757 }
2758
2759 static struct nfs4_file *nfsd4_alloc_file(void)
2760 {
2761         return kmem_cache_alloc(file_slab, GFP_KERNEL);
2762 }
2763
2764 /* OPEN Share state helper functions */
2765 static void nfsd4_init_file(struct nfs4_file *fp, struct inode *ino)
2766 {
2767         unsigned int hashval = file_hashval(ino);
2768
2769         lockdep_assert_held(&state_lock);
2770
2771         atomic_set(&fp->fi_ref, 1);
2772         spin_lock_init(&fp->fi_lock);
2773         INIT_LIST_HEAD(&fp->fi_stateids);
2774         INIT_LIST_HEAD(&fp->fi_delegations);
2775         ihold(ino);
2776         fp->fi_inode = ino;
2777         fp->fi_had_conflict = false;
2778         fp->fi_lease = NULL;
2779         memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
2780         memset(fp->fi_access, 0, sizeof(fp->fi_access));
2781         hlist_add_head(&fp->fi_hash, &file_hashtbl[hashval]);
2782 }
2783
2784 void
2785 nfsd4_free_slabs(void)
2786 {
2787         kmem_cache_destroy(openowner_slab);
2788         kmem_cache_destroy(lockowner_slab);
2789         kmem_cache_destroy(file_slab);
2790         kmem_cache_destroy(stateid_slab);
2791         kmem_cache_destroy(deleg_slab);
2792 }
2793
2794 int
2795 nfsd4_init_slabs(void)
2796 {
2797         openowner_slab = kmem_cache_create("nfsd4_openowners",
2798                         sizeof(struct nfs4_openowner), 0, 0, NULL);
2799         if (openowner_slab == NULL)
2800                 goto out;
2801         lockowner_slab = kmem_cache_create("nfsd4_lockowners",
2802                         sizeof(struct nfs4_lockowner), 0, 0, NULL);
2803         if (lockowner_slab == NULL)
2804                 goto out_free_openowner_slab;
2805         file_slab = kmem_cache_create("nfsd4_files",
2806                         sizeof(struct nfs4_file), 0, 0, NULL);
2807         if (file_slab == NULL)
2808                 goto out_free_lockowner_slab;
2809         stateid_slab = kmem_cache_create("nfsd4_stateids",
2810                         sizeof(struct nfs4_ol_stateid), 0, 0, NULL);
2811         if (stateid_slab == NULL)
2812                 goto out_free_file_slab;
2813         deleg_slab = kmem_cache_create("nfsd4_delegations",
2814                         sizeof(struct nfs4_delegation), 0, 0, NULL);
2815         if (deleg_slab == NULL)
2816                 goto out_free_stateid_slab;
2817         return 0;
2818
2819 out_free_stateid_slab:
2820         kmem_cache_destroy(stateid_slab);
2821 out_free_file_slab:
2822         kmem_cache_destroy(file_slab);
2823 out_free_lockowner_slab:
2824         kmem_cache_destroy(lockowner_slab);
2825 out_free_openowner_slab:
2826         kmem_cache_destroy(openowner_slab);
2827 out:
2828         dprintk("nfsd4: out of memory while initializing nfsv4\n");
2829         return -ENOMEM;
2830 }
2831
2832 static void init_nfs4_replay(struct nfs4_replay *rp)
2833 {
2834         rp->rp_status = nfserr_serverfault;
2835         rp->rp_buflen = 0;
2836         rp->rp_buf = rp->rp_ibuf;
2837 }
2838
2839 static inline void *alloc_stateowner(struct kmem_cache *slab, struct xdr_netobj *owner, struct nfs4_client *clp)
2840 {
2841         struct nfs4_stateowner *sop;
2842
2843         sop = kmem_cache_alloc(slab, GFP_KERNEL);
2844         if (!sop)
2845                 return NULL;
2846
2847         sop->so_owner.data = kmemdup(owner->data, owner->len, GFP_KERNEL);
2848         if (!sop->so_owner.data) {
2849                 kmem_cache_free(slab, sop);
2850                 return NULL;
2851         }
2852         sop->so_owner.len = owner->len;
2853
2854         INIT_LIST_HEAD(&sop->so_stateids);
2855         sop->so_client = clp;
2856         init_nfs4_replay(&sop->so_replay);
2857         return sop;
2858 }
2859
2860 static void hash_openowner(struct nfs4_openowner *oo, struct nfs4_client *clp, unsigned int strhashval)
2861 {
2862         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2863
2864         list_add(&oo->oo_owner.so_strhash, &nn->ownerstr_hashtbl[strhashval]);
2865         list_add(&oo->oo_perclient, &clp->cl_openowners);
2866 }
2867
2868 static struct nfs4_openowner *
2869 alloc_init_open_stateowner(unsigned int strhashval, struct nfsd4_open *open,
2870                            struct nfsd4_compound_state *cstate)
2871 {
2872         struct nfs4_client *clp = cstate->clp;
2873         struct nfs4_openowner *oo;
2874
2875         oo = alloc_stateowner(openowner_slab, &open->op_owner, clp);
2876         if (!oo)
2877                 return NULL;
2878         oo->oo_owner.so_is_open_owner = 1;
2879         oo->oo_owner.so_seqid = open->op_seqid;
2880         oo->oo_flags = NFS4_OO_NEW;
2881         if (nfsd4_has_session(cstate))
2882                 oo->oo_flags |= NFS4_OO_CONFIRMED;
2883         oo->oo_time = 0;
2884         oo->oo_last_closed_stid = NULL;
2885         INIT_LIST_HEAD(&oo->oo_close_lru);
2886         hash_openowner(oo, clp, strhashval);
2887         return oo;
2888 }
2889
2890 static void init_open_stateid(struct nfs4_ol_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *open) {
2891         struct nfs4_openowner *oo = open->op_openowner;
2892
2893         stp->st_stid.sc_type = NFS4_OPEN_STID;
2894         INIT_LIST_HEAD(&stp->st_locks);
2895         list_add(&stp->st_perstateowner, &oo->oo_owner.so_stateids);
2896         stp->st_stateowner = &oo->oo_owner;
2897         get_nfs4_file(fp);
2898         stp->st_file = fp;
2899         stp->st_access_bmap = 0;
2900         stp->st_deny_bmap = 0;
2901         set_access(open->op_share_access, stp);
2902         set_deny(open->op_share_deny, stp);
2903         stp->st_openstp = NULL;
2904         spin_lock(&fp->fi_lock);
2905         list_add(&stp->st_perfile, &fp->fi_stateids);
2906         spin_unlock(&fp->fi_lock);
2907 }
2908
2909 static void
2910 move_to_close_lru(struct nfs4_openowner *oo, struct net *net)
2911 {
2912         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2913
2914         dprintk("NFSD: move_to_close_lru nfs4_openowner %p\n", oo);
2915
2916         list_move_tail(&oo->oo_close_lru, &nn->close_lru);
2917         oo->oo_time = get_seconds();
2918 }
2919
2920 static int
2921 same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner,
2922                                                         clientid_t *clid)
2923 {
2924         return (sop->so_owner.len == owner->len) &&
2925                 0 == memcmp(sop->so_owner.data, owner->data, owner->len) &&
2926                 (sop->so_client->cl_clientid.cl_id == clid->cl_id);
2927 }
2928
2929 static struct nfs4_openowner *
2930 find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open,
2931                         bool sessions, struct nfsd_net *nn)
2932 {
2933         struct nfs4_stateowner *so;
2934         struct nfs4_openowner *oo;
2935         struct nfs4_client *clp;
2936
2937         list_for_each_entry(so, &nn->ownerstr_hashtbl[hashval], so_strhash) {
2938                 if (!so->so_is_open_owner)
2939                         continue;
2940                 if (same_owner_str(so, &open->op_owner, &open->op_clientid)) {
2941                         oo = openowner(so);
2942                         clp = oo->oo_owner.so_client;
2943                         if ((bool)clp->cl_minorversion != sessions)
2944                                 return NULL;
2945                         renew_client(oo->oo_owner.so_client);
2946                         return oo;
2947                 }
2948         }
2949         return NULL;
2950 }
2951
2952 /* search file_hashtbl[] for file */
2953 static struct nfs4_file *
2954 find_file_locked(struct inode *ino)
2955 {
2956         unsigned int hashval = file_hashval(ino);
2957         struct nfs4_file *fp;
2958
2959         lockdep_assert_held(&state_lock);
2960
2961         hlist_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) {
2962                 if (fp->fi_inode == ino) {
2963                         get_nfs4_file(fp);
2964                         return fp;
2965                 }
2966         }
2967         return NULL;
2968 }
2969
2970 static struct nfs4_file *
2971 find_file(struct inode *ino)
2972 {
2973         struct nfs4_file *fp;
2974
2975         spin_lock(&state_lock);
2976         fp = find_file_locked(ino);
2977         spin_unlock(&state_lock);
2978         return fp;
2979 }
2980
2981 static struct nfs4_file *
2982 find_or_add_file(struct inode *ino, struct nfs4_file *new)
2983 {
2984         struct nfs4_file *fp;
2985
2986         spin_lock(&state_lock);
2987         fp = find_file_locked(ino);
2988         if (fp == NULL) {
2989                 nfsd4_init_file(new, ino);
2990                 fp = new;
2991         }
2992         spin_unlock(&state_lock);
2993
2994         return fp;
2995 }
2996
2997 /*
2998  * Called to check deny when READ with all zero stateid or
2999  * WRITE with all zero or all one stateid
3000  */
3001 static __be32
3002 nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
3003 {
3004         struct inode *ino = current_fh->fh_dentry->d_inode;
3005         struct nfs4_file *fp;
3006         struct nfs4_ol_stateid *stp;
3007         __be32 ret;
3008
3009         fp = find_file(ino);
3010         if (!fp)
3011                 return nfs_ok;
3012         ret = nfserr_locked;
3013         /* Search for conflicting share reservations */
3014         spin_lock(&fp->fi_lock);
3015         list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
3016                 if (test_deny(deny_type, stp) ||
3017                     test_deny(NFS4_SHARE_DENY_BOTH, stp))
3018                         goto out;
3019         }
3020         ret = nfs_ok;
3021 out:
3022         spin_unlock(&fp->fi_lock);
3023         put_nfs4_file(fp);
3024         return ret;
3025 }
3026
3027 static void nfsd_break_one_deleg(struct nfs4_delegation *dp)
3028 {
3029         struct nfs4_client *clp = dp->dl_stid.sc_client;
3030         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
3031
3032         lockdep_assert_held(&state_lock);
3033         /* We're assuming the state code never drops its reference
3034          * without first removing the lease.  Since we're in this lease
3035          * callback (and since the lease code is serialized by the kernel
3036          * lock) we know the server hasn't removed the lease yet, we know
3037          * it's safe to take a reference: */
3038         atomic_inc(&dp->dl_count);
3039
3040         /*
3041          * If the dl_time != 0, then we know that it has already been
3042          * queued for a lease break. Don't queue it again.
3043          */
3044         if (dp->dl_time == 0) {
3045                 list_add_tail(&dp->dl_recall_lru, &nn->del_recall_lru);
3046                 dp->dl_time = get_seconds();
3047         }
3048
3049         block_delegations(&dp->dl_fh);
3050
3051         nfsd4_cb_recall(dp);
3052 }
3053
3054 /* Called from break_lease() with i_lock held. */
3055 static void nfsd_break_deleg_cb(struct file_lock *fl)
3056 {
3057         struct nfs4_file *fp = (struct nfs4_file *)fl->fl_owner;
3058         struct nfs4_delegation *dp;
3059
3060         if (!fp) {
3061                 WARN(1, "(%p)->fl_owner NULL\n", fl);
3062                 return;
3063         }
3064         if (fp->fi_had_conflict) {
3065                 WARN(1, "duplicate break on %p\n", fp);
3066                 return;
3067         }
3068         /*
3069          * We don't want the locks code to timeout the lease for us;
3070          * we'll remove it ourself if a delegation isn't returned
3071          * in time:
3072          */
3073         fl->fl_break_time = 0;
3074
3075         spin_lock(&state_lock);
3076         fp->fi_had_conflict = true;
3077         list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
3078                 nfsd_break_one_deleg(dp);
3079         spin_unlock(&state_lock);
3080 }
3081
3082 static
3083 int nfsd_change_deleg_cb(struct file_lock **onlist, int arg)
3084 {
3085         if (arg & F_UNLCK)
3086                 return lease_modify(onlist, arg);
3087         else
3088                 return -EAGAIN;
3089 }
3090
3091 static const struct lock_manager_operations nfsd_lease_mng_ops = {
3092         .lm_break = nfsd_break_deleg_cb,
3093         .lm_change = nfsd_change_deleg_cb,
3094 };
3095
3096 static __be32 nfsd4_check_seqid(struct nfsd4_compound_state *cstate, struct nfs4_stateowner *so, u32 seqid)
3097 {
3098         if (nfsd4_has_session(cstate))
3099                 return nfs_ok;
3100         if (seqid == so->so_seqid - 1)
3101                 return nfserr_replay_me;
3102         if (seqid == so->so_seqid)
3103                 return nfs_ok;
3104         return nfserr_bad_seqid;
3105 }
3106
3107 static __be32 lookup_clientid(clientid_t *clid,
3108                 struct nfsd4_compound_state *cstate,
3109                 struct nfsd_net *nn)
3110 {
3111         struct nfs4_client *found;
3112
3113         if (cstate->clp) {
3114                 found = cstate->clp;
3115                 if (!same_clid(&found->cl_clientid, clid))
3116                         return nfserr_stale_clientid;
3117                 return nfs_ok;
3118         }
3119
3120         if (STALE_CLIENTID(clid, nn))
3121                 return nfserr_stale_clientid;
3122
3123         /*
3124          * For v4.1+ we get the client in the SEQUENCE op. If we don't have one
3125          * cached already then we know this is for is for v4.0 and "sessions"
3126          * will be false.
3127          */
3128         WARN_ON_ONCE(cstate->session);
3129         found = find_confirmed_client(clid, false, nn);
3130         if (!found)
3131                 return nfserr_expired;
3132
3133         /* Cache the nfs4_client in cstate! */
3134         cstate->clp = found;
3135         atomic_inc(&found->cl_refcount);
3136         return nfs_ok;
3137 }
3138
3139 __be32
3140 nfsd4_process_open1(struct nfsd4_compound_state *cstate,
3141                     struct nfsd4_open *open, struct nfsd_net *nn)
3142 {
3143         clientid_t *clientid = &open->op_clientid;
3144         struct nfs4_client *clp = NULL;
3145         unsigned int strhashval;
3146         struct nfs4_openowner *oo = NULL;
3147         __be32 status;
3148
3149         if (STALE_CLIENTID(&open->op_clientid, nn))
3150                 return nfserr_stale_clientid;
3151         /*
3152          * In case we need it later, after we've already created the
3153          * file and don't want to risk a further failure:
3154          */
3155         open->op_file = nfsd4_alloc_file();
3156         if (open->op_file == NULL)
3157                 return nfserr_jukebox;
3158
3159         status = lookup_clientid(clientid, cstate, nn);
3160         if (status)
3161                 return status;
3162         clp = cstate->clp;
3163
3164         strhashval = ownerstr_hashval(clientid->cl_id, &open->op_owner);
3165         oo = find_openstateowner_str(strhashval, open, cstate->minorversion, nn);
3166         open->op_openowner = oo;
3167         if (!oo) {
3168                 goto new_owner;
3169         }
3170         if (!(oo->oo_flags & NFS4_OO_CONFIRMED)) {
3171                 /* Replace unconfirmed owners without checking for replay. */
3172                 release_openowner(oo);
3173                 open->op_openowner = NULL;
3174                 goto new_owner;
3175         }
3176         status = nfsd4_check_seqid(cstate, &oo->oo_owner, open->op_seqid);
3177         if (status)
3178                 return status;
3179         goto alloc_stateid;
3180 new_owner:
3181         oo = alloc_init_open_stateowner(strhashval, open, cstate);
3182         if (oo == NULL)
3183                 return nfserr_jukebox;
3184         open->op_openowner = oo;
3185 alloc_stateid:
3186         open->op_stp = nfs4_alloc_stateid(clp);
3187         if (!open->op_stp)
3188                 return nfserr_jukebox;
3189         return nfs_ok;
3190 }
3191
3192 static inline __be32
3193 nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
3194 {
3195         if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
3196                 return nfserr_openmode;
3197         else
3198                 return nfs_ok;
3199 }
3200
3201 static int share_access_to_flags(u32 share_access)
3202 {
3203         return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
3204 }
3205
3206 static struct nfs4_delegation *find_deleg_stateid(struct nfs4_client *cl, stateid_t *s)
3207 {
3208         struct nfs4_stid *ret;
3209
3210         ret = find_stateid_by_type(cl, s, NFS4_DELEG_STID);
3211         if (!ret)
3212                 return NULL;
3213         return delegstateid(ret);
3214 }
3215
3216 static bool nfsd4_is_deleg_cur(struct nfsd4_open *open)
3217 {
3218         return open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR ||
3219                open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH;
3220 }
3221
3222 static __be32
3223 nfs4_check_deleg(struct nfs4_client *cl, struct nfsd4_open *open,
3224                 struct nfs4_delegation **dp)
3225 {
3226         int flags;
3227         __be32 status = nfserr_bad_stateid;
3228
3229         *dp = find_deleg_stateid(cl, &open->op_delegate_stateid);
3230         if (*dp == NULL)
3231                 goto out;
3232         flags = share_access_to_flags(open->op_share_access);
3233         status = nfs4_check_delegmode(*dp, flags);
3234         if (status)
3235                 *dp = NULL;
3236 out:
3237         if (!nfsd4_is_deleg_cur(open))
3238                 return nfs_ok;
3239         if (status)
3240                 return status;
3241         open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
3242         return nfs_ok;
3243 }
3244
3245 static __be32
3246 nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_ol_stateid **stpp)
3247 {
3248         struct nfs4_ol_stateid *local;
3249         struct nfs4_openowner *oo = open->op_openowner;
3250
3251         spin_lock(&fp->fi_lock);
3252         list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
3253                 /* ignore lock owners */
3254                 if (local->st_stateowner->so_is_open_owner == 0)
3255                         continue;
3256                 /* remember if we have seen this open owner */
3257                 if (local->st_stateowner == &oo->oo_owner)
3258                         *stpp = local;
3259                 /* check for conflicting share reservations */
3260                 if (!test_share(local, open)) {
3261                         spin_unlock(&fp->fi_lock);
3262                         return nfserr_share_denied;
3263                 }
3264         }
3265         spin_unlock(&fp->fi_lock);
3266         return nfs_ok;
3267 }
3268
3269 static inline int nfs4_access_to_access(u32 nfs4_access)
3270 {
3271         int flags = 0;
3272
3273         if (nfs4_access & NFS4_SHARE_ACCESS_READ)
3274                 flags |= NFSD_MAY_READ;
3275         if (nfs4_access & NFS4_SHARE_ACCESS_WRITE)
3276                 flags |= NFSD_MAY_WRITE;
3277         return flags;
3278 }
3279
3280 static inline __be32
3281 nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
3282                 struct nfsd4_open *open)
3283 {
3284         struct iattr iattr = {
3285                 .ia_valid = ATTR_SIZE,
3286                 .ia_size = 0,
3287         };
3288         if (!open->op_truncate)
3289                 return 0;
3290         if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
3291                 return nfserr_inval;
3292         return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
3293 }
3294
3295 static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file *fp,
3296                 struct svc_fh *cur_fh, struct nfsd4_open *open)
3297 {
3298         struct file *filp = NULL;
3299         __be32 status;
3300         int oflag = nfs4_access_to_omode(open->op_share_access);
3301         int access = nfs4_access_to_access(open->op_share_access);
3302
3303         spin_lock(&fp->fi_lock);
3304         if (!fp->fi_fds[oflag]) {
3305                 spin_unlock(&fp->fi_lock);
3306                 status = nfsd_open(rqstp, cur_fh, S_IFREG, access, &filp);
3307                 if (status)
3308                         goto out;
3309                 spin_lock(&fp->fi_lock);
3310                 if (!fp->fi_fds[oflag]) {
3311                         fp->fi_fds[oflag] = filp;
3312                         filp = NULL;
3313                 }
3314         }
3315         status = nfs4_file_get_access(fp, open->op_share_access);
3316         spin_unlock(&fp->fi_lock);
3317         if (filp)
3318                 fput(filp);
3319         if (status)
3320                 goto out_put_access;
3321
3322         status = nfsd4_truncate(rqstp, cur_fh, open);
3323         if (status)
3324                 goto out_put_access;
3325
3326         return nfs_ok;
3327
3328 out_put_access:
3329         nfs4_file_put_access(fp, open->op_share_access);
3330 out:
3331         return status;
3332 }
3333
3334 static __be32
3335 nfs4_upgrade_open(struct svc_rqst *rqstp, struct nfs4_file *fp, struct svc_fh *cur_fh, struct nfs4_ol_stateid *stp, struct nfsd4_open *open)
3336 {
3337         u32 op_share_access = open->op_share_access;
3338         __be32 status;
3339
3340         if (!test_access(op_share_access, stp))
3341                 status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open);
3342         else
3343                 status = nfsd4_truncate(rqstp, cur_fh, open);
3344
3345         if (status)
3346                 return status;
3347
3348         /* remember the open */
3349         set_access(op_share_access, stp);
3350         set_deny(open->op_share_deny, stp);
3351         return nfs_ok;
3352 }
3353
3354
3355 static void
3356 nfs4_set_claim_prev(struct nfsd4_open *open, bool has_session)
3357 {
3358         open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
3359 }
3360
3361 /* Should we give out recallable state?: */
3362 static bool nfsd4_cb_channel_good(struct nfs4_client *clp)
3363 {
3364         if (clp->cl_cb_state == NFSD4_CB_UP)
3365                 return true;
3366         /*
3367          * In the sessions case, since we don't have to establish a
3368          * separate connection for callbacks, we assume it's OK
3369          * until we hear otherwise:
3370          */
3371         return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN;
3372 }
3373
3374 static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, int flag)
3375 {
3376         struct file_lock *fl;
3377
3378         fl = locks_alloc_lock();
3379         if (!fl)
3380                 return NULL;
3381         locks_init_lock(fl);
3382         fl->fl_lmops = &nfsd_lease_mng_ops;
3383         fl->fl_flags = FL_DELEG;
3384         fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
3385         fl->fl_end = OFFSET_MAX;
3386         fl->fl_owner = (fl_owner_t)(dp->dl_file);
3387         fl->fl_pid = current->tgid;
3388         return fl;
3389 }
3390
3391 static int nfs4_setlease(struct nfs4_delegation *dp)
3392 {
3393         struct nfs4_file *fp = dp->dl_file;
3394         struct file_lock *fl;
3395         int status;
3396
3397         fl = nfs4_alloc_init_lease(dp, NFS4_OPEN_DELEGATE_READ);
3398         if (!fl)
3399                 return -ENOMEM;
3400         fl->fl_file = find_readable_file(fp);
3401         status = vfs_setlease(fl->fl_file, fl->fl_type, &fl);
3402         if (status)
3403                 goto out_free;
3404         fp->fi_lease = fl;
3405         fp->fi_deleg_file = fl->fl_file;
3406         atomic_set(&fp->fi_delegees, 1);
3407         spin_lock(&state_lock);
3408         hash_delegation_locked(dp, fp);
3409         spin_unlock(&state_lock);
3410         return 0;
3411 out_free:
3412         if (fl->fl_file)
3413                 fput(fl->fl_file);
3414         locks_free_lock(fl);
3415         return status;
3416 }
3417
3418 static int nfs4_set_delegation(struct nfs4_delegation *dp, struct nfs4_file *fp)
3419 {
3420         if (fp->fi_had_conflict)
3421                 return -EAGAIN;
3422         get_nfs4_file(fp);
3423         dp->dl_file = fp;
3424         if (!fp->fi_lease)
3425                 return nfs4_setlease(dp);
3426         spin_lock(&state_lock);
3427         atomic_inc(&fp->fi_delegees);
3428         if (fp->fi_had_conflict) {
3429                 spin_unlock(&state_lock);
3430                 return -EAGAIN;
3431         }
3432         hash_delegation_locked(dp, fp);
3433         spin_unlock(&state_lock);
3434         return 0;
3435 }
3436
3437 static void nfsd4_open_deleg_none_ext(struct nfsd4_open *open, int status)
3438 {
3439         open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3440         if (status == -EAGAIN)
3441                 open->op_why_no_deleg = WND4_CONTENTION;
3442         else {
3443                 open->op_why_no_deleg = WND4_RESOURCE;
3444                 switch (open->op_deleg_want) {
3445                 case NFS4_SHARE_WANT_READ_DELEG:
3446                 case NFS4_SHARE_WANT_WRITE_DELEG:
3447                 case NFS4_SHARE_WANT_ANY_DELEG:
3448                         break;
3449                 case NFS4_SHARE_WANT_CANCEL:
3450                         open->op_why_no_deleg = WND4_CANCELLED;
3451                         break;
3452                 case NFS4_SHARE_WANT_NO_DELEG:
3453                         WARN_ON_ONCE(1);
3454                 }
3455         }
3456 }
3457
3458 /*
3459  * Attempt to hand out a delegation.
3460  *
3461  * Note we don't support write delegations, and won't until the vfs has
3462  * proper support for them.
3463  */
3464 static void
3465 nfs4_open_delegation(struct net *net, struct svc_fh *fh,
3466                      struct nfsd4_open *open, struct nfs4_ol_stateid *stp)
3467 {
3468         struct nfs4_delegation *dp;
3469         struct nfs4_openowner *oo = container_of(stp->st_stateowner, struct nfs4_openowner, oo_owner);
3470         int cb_up;
3471         int status = 0;
3472
3473         cb_up = nfsd4_cb_channel_good(oo->oo_owner.so_client);
3474         open->op_recall = 0;
3475         switch (open->op_claim_type) {
3476                 case NFS4_OPEN_CLAIM_PREVIOUS:
3477                         if (!cb_up)
3478                                 open->op_recall = 1;
3479                         if (open->op_delegate_type != NFS4_OPEN_DELEGATE_READ)
3480                                 goto out_no_deleg;
3481                         break;
3482                 case NFS4_OPEN_CLAIM_NULL:
3483                 case NFS4_OPEN_CLAIM_FH:
3484                         /*
3485                          * Let's not give out any delegations till everyone's
3486                          * had the chance to reclaim theirs....
3487                          */
3488                         if (locks_in_grace(net))
3489                                 goto out_no_deleg;
3490                         if (!cb_up || !(oo->oo_flags & NFS4_OO_CONFIRMED))
3491                                 goto out_no_deleg;
3492                         /*
3493                          * Also, if the file was opened for write or
3494                          * create, there's a good chance the client's
3495                          * about to write to it, resulting in an
3496                          * immediate recall (since we don't support
3497                          * write delegations):
3498                          */
3499                         if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
3500                                 goto out_no_deleg;
3501                         if (open->op_create == NFS4_OPEN_CREATE)
3502                                 goto out_no_deleg;
3503                         break;
3504                 default:
3505                         goto out_no_deleg;
3506         }
3507         dp = alloc_init_deleg(oo->oo_owner.so_client, stp, fh);
3508         if (dp == NULL)
3509                 goto out_no_deleg;
3510         status = nfs4_set_delegation(dp, stp->st_file);
3511         if (status)
3512                 goto out_free;
3513
3514         memcpy(&open->op_delegate_stateid, &dp->dl_stid.sc_stateid, sizeof(dp->dl_stid.sc_stateid));
3515
3516         dprintk("NFSD: delegation stateid=" STATEID_FMT "\n",
3517                 STATEID_VAL(&dp->dl_stid.sc_stateid));
3518         open->op_delegate_type = NFS4_OPEN_DELEGATE_READ;
3519         return;
3520 out_free:
3521         destroy_delegation(dp);
3522 out_no_deleg:
3523         open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE;
3524         if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS &&
3525             open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE) {
3526                 dprintk("NFSD: WARNING: refusing delegation reclaim\n");
3527                 open->op_recall = 1;
3528         }
3529
3530         /* 4.1 client asking for a delegation? */
3531         if (open->op_deleg_want)
3532                 nfsd4_open_deleg_none_ext(open, status);
3533         return;
3534 }
3535
3536 static void nfsd4_deleg_xgrade_none_ext(struct nfsd4_open *open,
3537                                         struct nfs4_delegation *dp)
3538 {
3539         if (open->op_deleg_want == NFS4_SHARE_WANT_READ_DELEG &&
3540             dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
3541                 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3542                 open->op_why_no_deleg = WND4_NOT_SUPP_DOWNGRADE;
3543         } else if (open->op_deleg_want == NFS4_SHARE_WANT_WRITE_DELEG &&
3544                    dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
3545                 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3546                 open->op_why_no_deleg = WND4_NOT_SUPP_UPGRADE;
3547         }
3548         /* Otherwise the client must be confused wanting a delegation
3549          * it already has, therefore we don't return
3550          * NFS4_OPEN_DELEGATE_NONE_EXT and reason.
3551          */
3552 }
3553
3554 /*
3555  * called with nfs4_lock_state() held.
3556  */
3557 __be32
3558 nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
3559 {
3560         struct nfsd4_compoundres *resp = rqstp->rq_resp;
3561         struct nfs4_client *cl = open->op_openowner->oo_owner.so_client;
3562         struct nfs4_file *fp = NULL;
3563         struct inode *ino = current_fh->fh_dentry->d_inode;
3564         struct nfs4_ol_stateid *stp = NULL;
3565         struct nfs4_delegation *dp = NULL;
3566         __be32 status;
3567
3568         /*
3569          * Lookup file; if found, lookup stateid and check open request,
3570          * and check for delegations in the process of being recalled.
3571          * If not found, create the nfs4_file struct
3572          */
3573         fp = find_or_add_file(ino, open->op_file);
3574         if (fp != open->op_file) {
3575                 if ((status = nfs4_check_open(fp, open, &stp)))
3576                         goto out;
3577                 status = nfs4_check_deleg(cl, open, &dp);
3578                 if (status)
3579                         goto out;
3580         } else {
3581                 open->op_file = NULL;
3582                 status = nfserr_bad_stateid;
3583                 if (nfsd4_is_deleg_cur(open))
3584                         goto out;
3585                 status = nfserr_jukebox;
3586         }
3587
3588         /*
3589          * OPEN the file, or upgrade an existing OPEN.
3590          * If truncate fails, the OPEN fails.
3591          */
3592         if (stp) {
3593                 /* Stateid was found, this is an OPEN upgrade */
3594                 status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open);
3595                 if (status)
3596                         goto out;
3597         } else {
3598                 status = nfs4_get_vfs_file(rqstp, fp, current_fh, open);
3599                 if (status)
3600                         goto out;
3601                 stp = open->op_stp;
3602                 open->op_stp = NULL;
3603                 init_open_stateid(stp, fp, open);
3604         }
3605         update_stateid(&stp->st_stid.sc_stateid);
3606         memcpy(&open->op_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
3607
3608         if (nfsd4_has_session(&resp->cstate)) {
3609                 if (open->op_deleg_want & NFS4_SHARE_WANT_NO_DELEG) {
3610                         open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3611                         open->op_why_no_deleg = WND4_NOT_WANTED;
3612                         goto nodeleg;
3613                 }
3614         }
3615
3616         /*
3617         * Attempt to hand out a delegation. No error return, because the
3618         * OPEN succeeds even if we fail.
3619         */
3620         nfs4_open_delegation(SVC_NET(rqstp), current_fh, open, stp);
3621 nodeleg:
3622         status = nfs_ok;
3623
3624         dprintk("%s: stateid=" STATEID_FMT "\n", __func__,
3625                 STATEID_VAL(&stp->st_stid.sc_stateid));
3626 out:
3627         /* 4.1 client trying to upgrade/downgrade delegation? */
3628         if (open->op_delegate_type == NFS4_OPEN_DELEGATE_NONE && dp &&
3629             open->op_deleg_want)
3630                 nfsd4_deleg_xgrade_none_ext(open, dp);
3631
3632         if (fp)
3633                 put_nfs4_file(fp);
3634         if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
3635                 nfs4_set_claim_prev(open, nfsd4_has_session(&resp->cstate));
3636         /*
3637         * To finish the open response, we just need to set the rflags.
3638         */
3639         open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
3640         if (!(open->op_openowner->oo_flags & NFS4_OO_CONFIRMED) &&
3641             !nfsd4_has_session(&resp->cstate))
3642                 open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
3643
3644         return status;
3645 }
3646
3647 void nfsd4_cleanup_open_state(struct nfsd4_open *open, __be32 status)
3648 {
3649         if (open->op_openowner) {
3650                 struct nfs4_openowner *oo = open->op_openowner;
3651
3652                 if (!list_empty(&oo->oo_owner.so_stateids))
3653                         list_del_init(&oo->oo_close_lru);
3654                 if (oo->oo_flags & NFS4_OO_NEW) {
3655                         if (status) {
3656                                 release_openowner(oo);
3657                                 open->op_openowner = NULL;
3658                         } else
3659                                 oo->oo_flags &= ~NFS4_OO_NEW;
3660                 }
3661         }
3662         if (open->op_file)
3663                 nfsd4_free_file(open->op_file);
3664         if (open->op_stp)
3665                 free_generic_stateid(open->op_stp);
3666 }
3667
3668 __be32
3669 nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3670             clientid_t *clid)
3671 {
3672         struct nfs4_client *clp;
3673         __be32 status;
3674         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
3675
3676         nfs4_lock_state();
3677         dprintk("process_renew(%08x/%08x): starting\n",
3678                         clid->cl_boot, clid->cl_id);
3679         status = lookup_clientid(clid, cstate, nn);
3680         if (status)
3681                 goto out;
3682         clp = cstate->clp;
3683         status = nfserr_cb_path_down;
3684         if (!list_empty(&clp->cl_delegations)
3685                         && clp->cl_cb_state != NFSD4_CB_UP)
3686                 goto out;
3687         status = nfs_ok;
3688 out:
3689         nfs4_unlock_state();
3690         return status;
3691 }
3692
3693 static void
3694 nfsd4_end_grace(struct nfsd_net *nn)
3695 {
3696         /* do nothing if grace period already ended */
3697         if (nn->grace_ended)
3698                 return;
3699
3700         dprintk("NFSD: end of grace period\n");
3701         nn->grace_ended = true;
3702         nfsd4_record_grace_done(nn, nn->boot_time);
3703         locks_end_grace(&nn->nfsd4_manager);
3704         /*
3705          * Now that every NFSv4 client has had the chance to recover and
3706          * to see the (possibly new, possibly shorter) lease time, we
3707          * can safely set the next grace time to the current lease time:
3708          */
3709         nn->nfsd4_grace = nn->nfsd4_lease;
3710 }
3711
3712 static time_t
3713 nfs4_laundromat(struct nfsd_net *nn)
3714 {
3715         struct nfs4_client *clp;
3716         struct nfs4_openowner *oo;
3717         struct nfs4_delegation *dp;
3718         struct list_head *pos, *next, reaplist;
3719         time_t cutoff = get_seconds() - nn->nfsd4_lease;
3720         time_t t, new_timeo = nn->nfsd4_lease;
3721
3722         nfs4_lock_state();
3723
3724         dprintk("NFSD: laundromat service - starting\n");
3725         nfsd4_end_grace(nn);
3726         INIT_LIST_HEAD(&reaplist);
3727         spin_lock(&nn->client_lock);
3728         list_for_each_safe(pos, next, &nn->client_lru) {
3729                 clp = list_entry(pos, struct nfs4_client, cl_lru);
3730                 if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
3731                         t = clp->cl_time - cutoff;
3732                         new_timeo = min(new_timeo, t);
3733                         break;
3734                 }
3735                 if (mark_client_expired_locked(clp)) {
3736                         dprintk("NFSD: client in use (clientid %08x)\n",
3737                                 clp->cl_clientid.cl_id);
3738                         continue;
3739                 }
3740                 list_move(&clp->cl_lru, &reaplist);
3741         }
3742         spin_unlock(&nn->client_lock);
3743         list_for_each_safe(pos, next, &reaplist) {
3744                 clp = list_entry(pos, struct nfs4_client, cl_lru);
3745                 dprintk("NFSD: purging unused client (clientid %08x)\n",
3746                         clp->cl_clientid.cl_id);
3747                 expire_client(clp);
3748         }
3749         spin_lock(&state_lock);
3750         list_for_each_safe(pos, next, &nn->del_recall_lru) {
3751                 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
3752                 if (net_generic(dp->dl_stid.sc_client->net, nfsd_net_id) != nn)
3753                         continue;
3754                 if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
3755                         t = dp->dl_time - cutoff;
3756                         new_timeo = min(new_timeo, t);
3757                         break;
3758                 }
3759                 list_move(&dp->dl_recall_lru, &reaplist);
3760         }
3761         spin_unlock(&state_lock);
3762         list_for_each_safe(pos, next, &reaplist) {
3763                 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
3764                 revoke_delegation(dp);
3765         }
3766         list_for_each_safe(pos, next, &nn->close_lru) {
3767                 oo = container_of(pos, struct nfs4_openowner, oo_close_lru);
3768                 if (time_after((unsigned long)oo->oo_time, (unsigned long)cutoff)) {
3769                         t = oo->oo_time - cutoff;
3770                         new_timeo = min(new_timeo, t);
3771                         break;
3772                 }
3773                 release_openowner(oo);
3774         }
3775         new_timeo = max_t(time_t, new_timeo, NFSD_LAUNDROMAT_MINTIMEOUT);
3776         nfs4_unlock_state();
3777         return new_timeo;
3778 }
3779
3780 static struct workqueue_struct *laundry_wq;
3781 static void laundromat_main(struct work_struct *);
3782
3783 static void
3784 laundromat_main(struct work_struct *laundry)
3785 {
3786         time_t t;
3787         struct delayed_work *dwork = container_of(laundry, struct delayed_work,
3788                                                   work);
3789         struct nfsd_net *nn = container_of(dwork, struct nfsd_net,
3790                                            laundromat_work);
3791
3792         t = nfs4_laundromat(nn);
3793         dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
3794         queue_delayed_work(laundry_wq, &nn->laundromat_work, t*HZ);
3795 }
3796
3797 static inline __be32 nfs4_check_fh(struct svc_fh *fhp, struct nfs4_ol_stateid *stp)
3798 {
3799         if (fhp->fh_dentry->d_inode != stp->st_file->fi_inode)
3800                 return nfserr_bad_stateid;
3801         return nfs_ok;
3802 }
3803
3804 static inline int
3805 access_permit_read(struct nfs4_ol_stateid *stp)
3806 {
3807         return test_access(NFS4_SHARE_ACCESS_READ, stp) ||
3808                 test_access(NFS4_SHARE_ACCESS_BOTH, stp) ||
3809                 test_access(NFS4_SHARE_ACCESS_WRITE, stp);
3810 }
3811
3812 static inline int
3813 access_permit_write(struct nfs4_ol_stateid *stp)
3814 {
3815         return test_access(NFS4_SHARE_ACCESS_WRITE, stp) ||
3816                 test_access(NFS4_SHARE_ACCESS_BOTH, stp);
3817 }
3818
3819 static
3820 __be32 nfs4_check_openmode(struct nfs4_ol_stateid *stp, int flags)
3821 {
3822         __be32 status = nfserr_openmode;
3823
3824         /* For lock stateid's, we test the parent open, not the lock: */
3825         if (stp->st_openstp)
3826                 stp = stp->st_openstp;
3827         if ((flags & WR_STATE) && !access_permit_write(stp))
3828                 goto out;
3829         if ((flags & RD_STATE) && !access_permit_read(stp))
3830                 goto out;
3831         status = nfs_ok;
3832 out:
3833         return status;
3834 }
3835
3836 static inline __be32
3837 check_special_stateids(struct net *net, svc_fh *current_fh, stateid_t *stateid, int flags)
3838 {
3839         if (ONE_STATEID(stateid) && (flags & RD_STATE))
3840                 return nfs_ok;
3841         else if (locks_in_grace(net)) {
3842                 /* Answer in remaining cases depends on existence of
3843                  * conflicting state; so we must wait out the grace period. */
3844                 return nfserr_grace;
3845         } else if (flags & WR_STATE)
3846                 return nfs4_share_conflict(current_fh,
3847                                 NFS4_SHARE_DENY_WRITE);
3848         else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
3849                 return nfs4_share_conflict(current_fh,
3850                                 NFS4_SHARE_DENY_READ);
3851 }
3852
3853 /*
3854  * Allow READ/WRITE during grace period on recovered state only for files
3855  * that are not able to provide mandatory locking.
3856  */
3857 static inline int
3858 grace_disallows_io(struct net *net, struct inode *inode)
3859 {
3860         return locks_in_grace(net) && mandatory_lock(inode);
3861 }
3862
3863 /* Returns true iff a is later than b: */
3864 static bool stateid_generation_after(stateid_t *a, stateid_t *b)
3865 {
3866         return (s32)(a->si_generation - b->si_generation) > 0;
3867 }
3868
3869 static __be32 check_stateid_generation(stateid_t *in, stateid_t *ref, bool has_session)
3870 {
3871         /*
3872          * When sessions are used the stateid generation number is ignored
3873          * when it is zero.
3874          */
3875         if (has_session && in->si_generation == 0)
3876                 return nfs_ok;
3877
3878         if (in->si_generation == ref->si_generation)
3879                 return nfs_ok;
3880
3881         /* If the client sends us a stateid from the future, it's buggy: */
3882         if (stateid_generation_after(in, ref))
3883                 return nfserr_bad_stateid;
3884         /*
3885          * However, we could see a stateid from the past, even from a
3886          * non-buggy client.  For example, if the client sends a lock
3887          * while some IO is outstanding, the lock may bump si_generation
3888          * while the IO is still in flight.  The client could avoid that
3889          * situation by waiting for responses on all the IO requests,
3890          * but better performance may result in retrying IO that
3891          * receives an old_stateid error if requests are rarely
3892          * reordered in flight:
3893          */
3894         return nfserr_old_stateid;
3895 }
3896
3897 static __be32 nfsd4_validate_stateid(struct nfs4_client *cl, stateid_t *stateid)
3898 {
3899         struct nfs4_stid *s;
3900         struct nfs4_ol_stateid *ols;
3901         __be32 status;
3902
3903         if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3904                 return nfserr_bad_stateid;
3905         /* Client debugging aid. */
3906         if (!same_clid(&stateid->si_opaque.so_clid, &cl->cl_clientid)) {
3907                 char addr_str[INET6_ADDRSTRLEN];
3908                 rpc_ntop((struct sockaddr *)&cl->cl_addr, addr_str,
3909                                  sizeof(addr_str));
3910                 pr_warn_ratelimited("NFSD: client %s testing state ID "
3911                                         "with incorrect client ID\n", addr_str);
3912                 return nfserr_bad_stateid;
3913         }
3914         s = find_stateid(cl, stateid);
3915         if (!s)
3916                 return nfserr_bad_stateid;
3917         status = check_stateid_generation(stateid, &s->sc_stateid, 1);
3918         if (status)
3919                 return status;
3920         switch (s->sc_type) {
3921         case NFS4_DELEG_STID:
3922                 return nfs_ok;
3923         case NFS4_REVOKED_DELEG_STID:
3924                 return nfserr_deleg_revoked;
3925         case NFS4_OPEN_STID:
3926         case NFS4_LOCK_STID:
3927                 ols = openlockstateid(s);
3928                 if (ols->st_stateowner->so_is_open_owner
3929                                 && !(openowner(ols->st_stateowner)->oo_flags
3930                                                 & NFS4_OO_CONFIRMED))
3931                         return nfserr_bad_stateid;
3932                 return nfs_ok;
3933         default:
3934                 printk("unknown stateid type %x\n", s->sc_type);
3935         case NFS4_CLOSED_STID:
3936                 return nfserr_bad_stateid;
3937         }
3938 }
3939
3940 static __be32
3941 nfsd4_lookup_stateid(struct nfsd4_compound_state *cstate,
3942                      stateid_t *stateid, unsigned char typemask,
3943                      struct nfs4_stid **s, struct nfsd_net *nn)
3944 {
3945         __be32 status;
3946
3947         if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3948                 return nfserr_bad_stateid;
3949         status = lookup_clientid(&stateid->si_opaque.so_clid, cstate, nn);
3950         if (status == nfserr_stale_clientid) {
3951                 if (cstate->session)
3952                         return nfserr_bad_stateid;
3953                 return nfserr_stale_stateid;
3954         }
3955         if (status)
3956                 return status;
3957         *s = find_stateid_by_type(cstate->clp, stateid, typemask);
3958         if (!*s)
3959                 return nfserr_bad_stateid;
3960         return nfs_ok;
3961 }
3962
3963 /*
3964 * Checks for stateid operations
3965 */
3966 __be32
3967 nfs4_preprocess_stateid_op(struct net *net, struct nfsd4_compound_state *cstate,
3968                            stateid_t *stateid, int flags, struct file **filpp)
3969 {
3970         struct nfs4_stid *s;
3971         struct nfs4_ol_stateid *stp = NULL;
3972         struct nfs4_delegation *dp = NULL;
3973         struct svc_fh *current_fh = &cstate->current_fh;
3974         struct inode *ino = current_fh->fh_dentry->d_inode;
3975         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
3976         struct file *file = NULL;
3977         __be32 status;
3978
3979         if (filpp)
3980                 *filpp = NULL;
3981
3982         if (grace_disallows_io(net, ino))
3983                 return nfserr_grace;
3984
3985         if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3986                 return check_special_stateids(net, current_fh, stateid, flags);
3987
3988         nfs4_lock_state();
3989
3990         status = nfsd4_lookup_stateid(cstate, stateid,
3991                                 NFS4_DELEG_STID|NFS4_OPEN_STID|NFS4_LOCK_STID,
3992                                 &s, nn);
3993         if (status)
3994                 goto out;
3995         status = check_stateid_generation(stateid, &s->sc_stateid, nfsd4_has_session(cstate));
3996         if (status)
3997                 goto out;
3998         switch (s->sc_type) {
3999         case NFS4_DELEG_STID:
4000                 dp = delegstateid(s);
4001                 status = nfs4_check_delegmode(dp, flags);
4002                 if (status)
4003                         goto out;
4004                 if (filpp) {
4005                         file = dp->dl_file->fi_deleg_file;
4006                         if (!file) {
4007                                 WARN_ON_ONCE(1);
4008                                 status = nfserr_serverfault;
4009                                 goto out;
4010                         }
4011                         get_file(file);
4012                 }
4013                 break;
4014         case NFS4_OPEN_STID:
4015         case NFS4_LOCK_STID:
4016                 stp = openlockstateid(s);
4017                 status = nfs4_check_fh(current_fh, stp);
4018                 if (status)
4019                         goto out;
4020                 if (stp->st_stateowner->so_is_open_owner
4021                     && !(openowner(stp->st_stateowner)->oo_flags & NFS4_OO_CONFIRMED))
4022                         goto out;
4023                 status = nfs4_check_openmode(stp, flags);
4024                 if (status)
4025                         goto out;
4026                 if (filpp) {
4027                         if (flags & RD_STATE)
4028                                 file = find_readable_file(stp->st_file);
4029                         else
4030                                 file = find_writeable_file(stp->st_file);
4031                 }
4032                 break;
4033         default:
4034                 status = nfserr_bad_stateid;
4035                 goto out;
4036         }
4037         status = nfs_ok;
4038         if (file)
4039                 *filpp = file;
4040 out:
4041         nfs4_unlock_state();
4042         return status;
4043 }
4044
4045 static __be32
4046 nfsd4_free_lock_stateid(struct nfs4_ol_stateid *stp)
4047 {
4048         struct nfs4_lockowner *lo = lockowner(stp->st_stateowner);
4049
4050         if (check_for_locks(stp->st_file, lo))
4051                 return nfserr_locks_held;
4052         release_lockowner_if_empty(lo);
4053         return nfs_ok;
4054 }
4055
4056 /*
4057  * Test if the stateid is valid
4058  */
4059 __be32
4060 nfsd4_test_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4061                    struct nfsd4_test_stateid *test_stateid)
4062 {
4063         struct nfsd4_test_stateid_id *stateid;
4064         struct nfs4_client *cl = cstate->session->se_client;
4065
4066         nfs4_lock_state();
4067         list_for_each_entry(stateid, &test_stateid->ts_stateid_list, ts_id_list)
4068                 stateid->ts_id_status =
4069                         nfsd4_validate_stateid(cl, &stateid->ts_id_stateid);
4070         nfs4_unlock_state();
4071
4072         return nfs_ok;
4073 }
4074
4075 __be32
4076 nfsd4_free_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4077                    struct nfsd4_free_stateid *free_stateid)
4078 {
4079         stateid_t *stateid = &free_stateid->fr_stateid;
4080         struct nfs4_stid *s;
4081         struct nfs4_delegation *dp;
4082         struct nfs4_client *cl = cstate->session->se_client;
4083         __be32 ret = nfserr_bad_stateid;
4084
4085         nfs4_lock_state();
4086         s = find_stateid(cl, stateid);
4087         if (!s)
4088                 goto out;
4089         switch (s->sc_type) {
4090         case NFS4_DELEG_STID:
4091                 ret = nfserr_locks_held;
4092                 goto out;
4093         case NFS4_OPEN_STID:
4094         case NFS4_LOCK_STID:
4095                 ret = check_stateid_generation(stateid, &s->sc_stateid, 1);
4096                 if (ret)
4097                         goto out;
4098                 if (s->sc_type == NFS4_LOCK_STID)
4099                         ret = nfsd4_free_lock_stateid(openlockstateid(s));
4100                 else
4101                         ret = nfserr_locks_held;
4102                 break;
4103         case NFS4_REVOKED_DELEG_STID:
4104                 dp = delegstateid(s);
4105                 destroy_revoked_delegation(dp);
4106                 ret = nfs_ok;
4107                 break;
4108         default:
4109                 ret = nfserr_bad_stateid;
4110         }
4111 out:
4112         nfs4_unlock_state();
4113         return ret;
4114 }
4115
4116 static inline int
4117 setlkflg (int type)
4118 {
4119         return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
4120                 RD_STATE : WR_STATE;
4121 }
4122
4123 static __be32 nfs4_seqid_op_checks(struct nfsd4_compound_state *cstate, stateid_t *stateid, u32 seqid, struct nfs4_ol_stateid *stp)
4124 {
4125         struct svc_fh *current_fh = &cstate->current_fh;
4126         struct nfs4_stateowner *sop = stp->st_stateowner;
4127         __be32 status;
4128
4129         status = nfsd4_check_seqid(cstate, sop, seqid);
4130         if (status)
4131                 return status;
4132         if (stp->st_stid.sc_type == NFS4_CLOSED_STID
4133                 || stp->st_stid.sc_type == NFS4_REVOKED_DELEG_STID)
4134                 /*
4135                  * "Closed" stateid's exist *only* to return
4136                  * nfserr_replay_me from the previous step, and
4137                  * revoked delegations are kept only for free_stateid.
4138                  */
4139                 return nfserr_bad_stateid;
4140         status = check_stateid_generation(stateid, &stp->st_stid.sc_stateid, nfsd4_has_session(cstate));
4141         if (status)
4142                 return status;
4143         return nfs4_check_fh(current_fh, stp);
4144 }
4145
4146 /*
4147  * Checks for sequence id mutating operations.
4148  */
4149 static __be32
4150 nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
4151                          stateid_t *stateid, char typemask,
4152                          struct nfs4_ol_stateid **stpp,
4153                          struct nfsd_net *nn)
4154 {
4155         __be32 status;
4156         struct nfs4_stid *s;
4157         struct nfs4_ol_stateid *stp = NULL;
4158
4159         dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__,
4160                 seqid, STATEID_VAL(stateid));
4161
4162         *stpp = NULL;
4163         status = nfsd4_lookup_stateid(cstate, stateid, typemask, &s, nn);
4164         if (status)
4165                 return status;
4166         stp = openlockstateid(s);
4167         if (!nfsd4_has_session(cstate))
4168                 cstate->replay_owner = stp->st_stateowner;
4169
4170         status = nfs4_seqid_op_checks(cstate, stateid, seqid, stp);
4171         if (!status)
4172                 *stpp = stp;
4173         return status;
4174 }
4175
4176 static __be32 nfs4_preprocess_confirmed_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
4177                                                  stateid_t *stateid, struct nfs4_ol_stateid **stpp, struct nfsd_net *nn)
4178 {
4179         __be32 status;
4180         struct nfs4_openowner *oo;
4181
4182         status = nfs4_preprocess_seqid_op(cstate, seqid, stateid,
4183                                                 NFS4_OPEN_STID, stpp, nn);
4184         if (status)
4185                 return status;
4186         oo = openowner((*stpp)->st_stateowner);
4187         if (!(oo->oo_flags & NFS4_OO_CONFIRMED))
4188                 return nfserr_bad_stateid;
4189         return nfs_ok;
4190 }
4191
4192 __be32
4193 nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4194                    struct nfsd4_open_confirm *oc)
4195 {
4196         __be32 status;
4197         struct nfs4_openowner *oo;
4198         struct nfs4_ol_stateid *stp;
4199         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
4200
4201         dprintk("NFSD: nfsd4_open_confirm on file %pd\n",
4202                         cstate->current_fh.fh_dentry);
4203
4204         status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
4205         if (status)
4206                 return status;
4207
4208         nfs4_lock_state();
4209
4210         status = nfs4_preprocess_seqid_op(cstate,
4211                                         oc->oc_seqid, &oc->oc_req_stateid,
4212                                         NFS4_OPEN_STID, &stp, nn);
4213         if (status)
4214                 goto out;
4215         oo = openowner(stp->st_stateowner);
4216         status = nfserr_bad_stateid;
4217         if (oo->oo_flags & NFS4_OO_CONFIRMED)
4218                 goto out;
4219         oo->oo_flags |= NFS4_OO_CONFIRMED;
4220         update_stateid(&stp->st_stid.sc_stateid);
4221         memcpy(&oc->oc_resp_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
4222         dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n",
4223                 __func__, oc->oc_seqid, STATEID_VAL(&stp->st_stid.sc_stateid));
4224
4225         nfsd4_client_record_create(oo->oo_owner.so_client);
4226         status = nfs_ok;
4227 out:
4228         nfsd4_bump_seqid(cstate, status);
4229         if (!cstate->replay_owner)
4230                 nfs4_unlock_state();
4231         return status;
4232 }
4233
4234 static inline void nfs4_stateid_downgrade_bit(struct nfs4_ol_stateid *stp, u32 access)
4235 {
4236         if (!test_access(access, stp))
4237                 return;
4238         nfs4_file_put_access(stp->st_file, access);
4239         clear_access(access, stp);
4240 }
4241
4242 static inline void nfs4_stateid_downgrade(struct nfs4_ol_stateid *stp, u32 to_access)
4243 {
4244         switch (to_access) {
4245         case NFS4_SHARE_ACCESS_READ:
4246                 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_WRITE);
4247                 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
4248                 break;
4249         case NFS4_SHARE_ACCESS_WRITE:
4250                 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_READ);
4251                 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
4252                 break;
4253         case NFS4_SHARE_ACCESS_BOTH:
4254                 break;
4255         default:
4256                 WARN_ON_ONCE(1);
4257         }
4258 }
4259
4260 static void
4261 reset_union_bmap_deny(unsigned long deny, struct nfs4_ol_stateid *stp)
4262 {
4263         int i;
4264         for (i = 0; i < 4; i++) {
4265                 if ((i & deny) != i)
4266                         clear_deny(i, stp);
4267         }
4268 }
4269
4270 __be32
4271 nfsd4_open_downgrade(struct svc_rqst *rqstp,
4272                      struct nfsd4_compound_state *cstate,
4273                      struct nfsd4_open_downgrade *od)
4274 {
4275         __be32 status;
4276         struct nfs4_ol_stateid *stp;
4277         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
4278
4279         dprintk("NFSD: nfsd4_open_downgrade on file %pd\n",
4280                         cstate->current_fh.fh_dentry);
4281
4282         /* We don't yet support WANT bits: */
4283         if (od->od_deleg_want)
4284                 dprintk("NFSD: %s: od_deleg_want=0x%x ignored\n", __func__,
4285                         od->od_deleg_want);
4286
4287         nfs4_lock_state();
4288         status = nfs4_preprocess_confirmed_seqid_op(cstate, od->od_seqid,
4289                                         &od->od_stateid, &stp, nn);
4290         if (status)
4291                 goto out;
4292         status = nfserr_inval;
4293         if (!test_access(od->od_share_access, stp)) {
4294                 dprintk("NFSD: access not a subset current bitmap: 0x%lx, input access=%08x\n",
4295                         stp->st_access_bmap, od->od_share_access);
4296                 goto out;
4297         }
4298         if (!test_deny(od->od_share_deny, stp)) {
4299                 dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
4300                         stp->st_deny_bmap, od->od_share_deny);
4301                 goto out;
4302         }
4303         nfs4_stateid_downgrade(stp, od->od_share_access);
4304
4305         reset_union_bmap_deny(od->od_share_deny, stp);
4306
4307         update_stateid(&stp->st_stid.sc_stateid);
4308         memcpy(&od->od_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
4309         status = nfs_ok;
4310 out:
4311         nfsd4_bump_seqid(cstate, status);
4312         if (!cstate->replay_owner)
4313                 nfs4_unlock_state();
4314         return status;
4315 }
4316
4317 static void nfsd4_close_open_stateid(struct nfs4_ol_stateid *s)
4318 {
4319         struct nfs4_client *clp = s->st_stid.sc_client;
4320         struct nfs4_openowner *oo = openowner(s->st_stateowner);
4321
4322         s->st_stid.sc_type = NFS4_CLOSED_STID;
4323         unhash_open_stateid(s);
4324
4325         if (clp->cl_minorversion) {
4326                 free_generic_stateid(s);
4327                 if (list_empty(&oo->oo_owner.so_stateids))
4328                         release_openowner(oo);
4329         } else {
4330                 oo->oo_last_closed_stid = s;
4331                 /*
4332                  * In the 4.0 case we need to keep the owners around a
4333                  * little while to handle CLOSE replay.
4334                  */
4335                 if (list_empty(&oo->oo_owner.so_stateids))
4336                         move_to_close_lru(oo, clp->net);
4337         }
4338 }
4339
4340 /*
4341  * nfs4_unlock_state() called after encode
4342  */
4343 __be32
4344 nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4345             struct nfsd4_close *close)
4346 {
4347         __be32 status;
4348         struct nfs4_ol_stateid *stp;
4349         struct net *net = SVC_NET(rqstp);
4350         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
4351
4352         dprintk("NFSD: nfsd4_close on file %pd\n",
4353                         cstate->current_fh.fh_dentry);
4354
4355         nfs4_lock_state();
4356         status = nfs4_preprocess_seqid_op(cstate, close->cl_seqid,
4357                                         &close->cl_stateid,
4358                                         NFS4_OPEN_STID|NFS4_CLOSED_STID,
4359                                         &stp, nn);
4360         nfsd4_bump_seqid(cstate, status);
4361         if (status)
4362                 goto out;
4363         update_stateid(&stp->st_stid.sc_stateid);
4364         memcpy(&close->cl_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
4365
4366         nfsd4_close_open_stateid(stp);
4367 out:
4368         if (!cstate->replay_owner)
4369                 nfs4_unlock_state();
4370         return status;
4371 }
4372
4373 __be32
4374 nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4375                   struct nfsd4_delegreturn *dr)
4376 {
4377         struct nfs4_delegation *dp;
4378         stateid_t *stateid = &dr->dr_stateid;
4379         struct nfs4_stid *s;
4380         __be32 status;
4381         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
4382
4383         if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
4384                 return status;
4385
4386         nfs4_lock_state();
4387         status = nfsd4_lookup_stateid(cstate, stateid, NFS4_DELEG_STID, &s, nn);
4388         if (status)
4389                 goto out;
4390         dp = delegstateid(s);
4391         status = check_stateid_generation(stateid, &dp->dl_stid.sc_stateid, nfsd4_has_session(cstate));
4392         if (status)
4393                 goto out;
4394
4395         destroy_delegation(dp);
4396 out:
4397         nfs4_unlock_state();
4398
4399         return status;
4400 }
4401
4402
4403 #define LOFF_OVERFLOW(start, len)      ((u64)(len) > ~(u64)(start))
4404
4405 static inline u64
4406 end_offset(u64 start, u64 len)
4407 {
4408         u64 end;
4409
4410         end = start + len;
4411         return end >= start ? end: NFS4_MAX_UINT64;
4412 }
4413
4414 /* last octet in a range */
4415 static inline u64
4416 last_byte_offset(u64 start, u64 len)
4417 {
4418         u64 end;
4419
4420         WARN_ON_ONCE(!len);
4421         end = start + len;
4422         return end > start ? end - 1: NFS4_MAX_UINT64;
4423 }
4424
4425 /*
4426  * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
4427  * we can't properly handle lock requests that go beyond the (2^63 - 1)-th
4428  * byte, because of sign extension problems.  Since NFSv4 calls for 64-bit
4429  * locking, this prevents us from being completely protocol-compliant.  The
4430  * real solution to this problem is to start using unsigned file offsets in
4431  * the VFS, but this is a very deep change!
4432  */
4433 static inline void
4434 nfs4_transform_lock_offset(struct file_lock *lock)
4435 {
4436         if (lock->fl_start < 0)
4437                 lock->fl_start = OFFSET_MAX;
4438         if (lock->fl_end < 0)
4439                 lock->fl_end = OFFSET_MAX;
4440 }
4441
4442 /* Hack!: For now, we're defining this just so we can use a pointer to it
4443  * as a unique cookie to identify our (NFSv4's) posix locks. */
4444 static const struct lock_manager_operations nfsd_posix_mng_ops  = {
4445 };
4446
4447 static inline void
4448 nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
4449 {
4450         struct nfs4_lockowner *lo;
4451
4452         if (fl->fl_lmops == &nfsd_posix_mng_ops) {
4453                 lo = (struct nfs4_lockowner *) fl->fl_owner;
4454                 deny->ld_owner.data = kmemdup(lo->lo_owner.so_owner.data,
4455                                         lo->lo_owner.so_owner.len, GFP_KERNEL);
4456                 if (!deny->ld_owner.data)
4457                         /* We just don't care that much */
4458                         goto nevermind;
4459                 deny->ld_owner.len = lo->lo_owner.so_owner.len;
4460                 deny->ld_clientid = lo->lo_owner.so_client->cl_clientid;
4461         } else {
4462 nevermind:
4463                 deny->ld_owner.len = 0;
4464                 deny->ld_owner.data = NULL;
4465                 deny->ld_clientid.cl_boot = 0;
4466                 deny->ld_clientid.cl_id = 0;
4467         }
4468         deny->ld_start = fl->fl_start;
4469         deny->ld_length = NFS4_MAX_UINT64;
4470         if (fl->fl_end != NFS4_MAX_UINT64)
4471                 deny->ld_length = fl->fl_end - fl->fl_start + 1;
4472         deny->ld_type = NFS4_READ_LT;
4473         if (fl->fl_type != F_RDLCK)
4474                 deny->ld_type = NFS4_WRITE_LT;
4475 }
4476
4477 static struct nfs4_lockowner *
4478 find_lockowner_str(clientid_t *clid, struct xdr_netobj *owner,
4479                 struct nfsd_net *nn)
4480 {
4481         unsigned int strhashval = ownerstr_hashval(clid->cl_id, owner);
4482         struct nfs4_stateowner *so;
4483
4484         list_for_each_entry(so, &nn->ownerstr_hashtbl[strhashval], so_strhash) {
4485                 if (so->so_is_open_owner)
4486                         continue;
4487                 if (!same_owner_str(so, owner, clid))
4488                         continue;
4489                 return lockowner(so);
4490         }
4491         return NULL;
4492 }
4493
4494 /*
4495  * Alloc a lock owner structure.
4496  * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has
4497  * occurred.
4498  *
4499  * strhashval = ownerstr_hashval
4500  */
4501 static struct nfs4_lockowner *
4502 alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfs4_ol_stateid *open_stp, struct nfsd4_lock *lock) {
4503         struct nfs4_lockowner *lo;
4504         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
4505
4506         lo = alloc_stateowner(lockowner_slab, &lock->lk_new_owner, clp);
4507         if (!lo)
4508                 return NULL;
4509         INIT_LIST_HEAD(&lo->lo_owner.so_stateids);
4510         lo->lo_owner.so_is_open_owner = 0;
4511         /* It is the openowner seqid that will be incremented in encode in the
4512          * case of new lockowners; so increment the lock seqid manually: */
4513         lo->lo_owner.so_seqid = lock->lk_new_lock_seqid + 1;
4514         list_add(&lo->lo_owner.so_strhash, &nn->ownerstr_hashtbl[strhashval]);
4515         return lo;
4516 }
4517
4518 static struct nfs4_ol_stateid *
4519 alloc_init_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fp, struct nfs4_ol_stateid *open_stp)
4520 {
4521         struct nfs4_ol_stateid *stp;
4522         struct nfs4_client *clp = lo->lo_owner.so_client;
4523
4524         stp = nfs4_alloc_stateid(clp);
4525         if (stp == NULL)
4526                 return NULL;
4527         stp->st_stid.sc_type = NFS4_LOCK_STID;
4528         list_add(&stp->st_perstateowner, &lo->lo_owner.so_stateids);
4529         stp->st_stateowner = &lo->lo_owner;
4530         get_nfs4_file(fp);
4531         stp->st_file = fp;
4532         stp->st_access_bmap = 0;
4533         stp->st_deny_bmap = open_stp->st_deny_bmap;
4534         stp->st_openstp = open_stp;
4535         list_add(&stp->st_locks, &open_stp->st_locks);
4536         spin_lock(&fp->fi_lock);
4537         list_add(&stp->st_perfile, &fp->fi_stateids);
4538         spin_unlock(&fp->fi_lock);
4539         return stp;
4540 }
4541
4542 static struct nfs4_ol_stateid *
4543 find_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fp)
4544 {
4545         struct nfs4_ol_stateid *lst;
4546
4547         list_for_each_entry(lst, &lo->lo_owner.so_stateids, st_perstateowner) {
4548                 if (lst->st_file == fp)
4549                         return lst;
4550         }
4551         return NULL;
4552 }
4553
4554
4555 static int
4556 check_lock_length(u64 offset, u64 length)
4557 {
4558         return ((length == 0)  || ((length != NFS4_MAX_UINT64) &&
4559              LOFF_OVERFLOW(offset, length)));
4560 }
4561
4562 static void get_lock_access(struct nfs4_ol_stateid *lock_stp, u32 access)
4563 {
4564         struct nfs4_file *fp = lock_stp->st_file;
4565
4566         if (test_access(access, lock_stp))
4567                 return;
4568         __nfs4_file_get_access(fp, access);
4569         set_access(access, lock_stp);
4570 }
4571
4572 static __be32 lookup_or_create_lock_state(struct nfsd4_compound_state *cstate, struct nfs4_ol_stateid *ost, struct nfsd4_lock *lock, struct nfs4_ol_stateid **lst, bool *new)
4573 {
4574         struct nfs4_file *fi = ost->st_file;
4575         struct nfs4_openowner *oo = openowner(ost->st_stateowner);
4576         struct nfs4_client *cl = oo->oo_owner.so_client;
4577         struct nfs4_lockowner *lo;
4578         unsigned int strhashval;
4579         struct nfsd_net *nn = net_generic(cl->net, nfsd_net_id);
4580
4581         lo = find_lockowner_str(&cl->cl_clientid, &lock->v.new.owner, nn);
4582         if (!lo) {
4583                 strhashval = ownerstr_hashval(cl->cl_clientid.cl_id,
4584                                 &lock->v.new.owner);
4585                 lo = alloc_init_lock_stateowner(strhashval, cl, ost, lock);
4586                 if (lo == NULL)
4587                         return nfserr_jukebox;
4588         } else {
4589                 /* with an existing lockowner, seqids must be the same */
4590                 if (!cstate->minorversion &&
4591                     lock->lk_new_lock_seqid != lo->lo_owner.so_seqid)
4592                         return nfserr_bad_seqid;
4593         }
4594
4595         *lst = find_lock_stateid(lo, fi);
4596         if (*lst == NULL) {
4597                 *lst = alloc_init_lock_stateid(lo, fi, ost);
4598                 if (*lst == NULL) {
4599                         release_lockowner_if_empty(lo);
4600                         return nfserr_jukebox;
4601                 }
4602                 *new = true;
4603         }
4604         return nfs_ok;
4605 }
4606
4607 /*
4608  *  LOCK operation
4609  */
4610 __be32
4611 nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4612            struct nfsd4_lock *lock)
4613 {
4614         struct nfs4_openowner *open_sop = NULL;
4615         struct nfs4_lockowner *lock_sop = NULL;
4616         struct nfs4_ol_stateid *lock_stp;
4617         struct file *filp = NULL;
4618         struct file_lock *file_lock = NULL;
4619         struct file_lock *conflock = NULL;
4620         __be32 status = 0;
4621         bool new_state = false;
4622         int lkflg;
4623         int err;
4624         struct net *net = SVC_NET(rqstp);
4625         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
4626
4627         dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
4628                 (long long) lock->lk_offset,
4629                 (long long) lock->lk_length);
4630
4631         if (check_lock_length(lock->lk_offset, lock->lk_length))
4632                  return nfserr_inval;
4633
4634         if ((status = fh_verify(rqstp, &cstate->current_fh,
4635                                 S_IFREG, NFSD_MAY_LOCK))) {
4636                 dprintk("NFSD: nfsd4_lock: permission denied!\n");
4637                 return status;
4638         }
4639
4640         nfs4_lock_state();
4641
4642         if (lock->lk_is_new) {
4643                 struct nfs4_ol_stateid *open_stp = NULL;
4644
4645                 if (nfsd4_has_session(cstate))
4646                         /* See rfc 5661 18.10.3: given clientid is ignored: */
4647                         memcpy(&lock->v.new.clientid,
4648                                 &cstate->session->se_client->cl_clientid,
4649                                 sizeof(clientid_t));
4650
4651                 status = nfserr_stale_clientid;
4652                 if (STALE_CLIENTID(&lock->lk_new_clientid, nn))
4653                         goto out;
4654
4655                 /* validate and update open stateid and open seqid */
4656                 status = nfs4_preprocess_confirmed_seqid_op(cstate,
4657                                         lock->lk_new_open_seqid,
4658                                         &lock->lk_new_open_stateid,
4659                                         &open_stp, nn);
4660                 if (status)
4661                         goto out;
4662                 open_sop = openowner(open_stp->st_stateowner);
4663                 status = nfserr_bad_stateid;
4664                 if (!same_clid(&open_sop->oo_owner.so_client->cl_clientid,
4665                                                 &lock->v.new.clientid))
4666                         goto out;
4667                 status = lookup_or_create_lock_state(cstate, open_stp, lock,
4668                                                         &lock_stp, &new_state);
4669         } else
4670                 status = nfs4_preprocess_seqid_op(cstate,
4671                                        lock->lk_old_lock_seqid,
4672                                        &lock->lk_old_lock_stateid,
4673                                        NFS4_LOCK_STID, &lock_stp, nn);
4674         if (status)
4675                 goto out;
4676         lock_sop = lockowner(lock_stp->st_stateowner);
4677
4678         lkflg = setlkflg(lock->lk_type);
4679         status = nfs4_check_openmode(lock_stp, lkflg);
4680         if (status)
4681                 goto out;
4682
4683         status = nfserr_grace;
4684         if (locks_in_grace(net) && !lock->lk_reclaim)
4685                 goto out;
4686         status = nfserr_no_grace;
4687         if (!locks_in_grace(net) && lock->lk_reclaim)
4688                 goto out;
4689
4690         file_lock = locks_alloc_lock();
4691         if (!file_lock) {
4692                 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4693                 status = nfserr_jukebox;
4694                 goto out;
4695         }
4696
4697         locks_init_lock(file_lock);
4698         switch (lock->lk_type) {
4699                 case NFS4_READ_LT:
4700                 case NFS4_READW_LT:
4701                         filp = find_readable_file(lock_stp->st_file);
4702                         if (filp)
4703                                 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ);
4704                         file_lock->fl_type = F_RDLCK;
4705                         break;
4706                 case NFS4_WRITE_LT:
4707                 case NFS4_WRITEW_LT:
4708                         filp = find_writeable_file(lock_stp->st_file);
4709                         if (filp)
4710                                 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE);
4711                         file_lock->fl_type = F_WRLCK;
4712                         break;
4713                 default:
4714                         status = nfserr_inval;
4715                 goto out;
4716         }
4717         if (!filp) {
4718                 status = nfserr_openmode;
4719                 goto out;
4720         }
4721         file_lock->fl_owner = (fl_owner_t)lock_sop;
4722         file_lock->fl_pid = current->tgid;
4723         file_lock->fl_file = filp;
4724         file_lock->fl_flags = FL_POSIX;
4725         file_lock->fl_lmops = &nfsd_posix_mng_ops;
4726         file_lock->fl_start = lock->lk_offset;
4727         file_lock->fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
4728         nfs4_transform_lock_offset(file_lock);
4729
4730         conflock = locks_alloc_lock();
4731         if (!conflock) {
4732                 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4733                 status = nfserr_jukebox;
4734                 goto out;
4735         }
4736
4737         err = vfs_lock_file(filp, F_SETLK, file_lock, conflock);
4738         switch (-err) {
4739         case 0: /* success! */
4740                 update_stateid(&lock_stp->st_stid.sc_stateid);
4741                 memcpy(&lock->lk_resp_stateid, &lock_stp->st_stid.sc_stateid,
4742                                 sizeof(stateid_t));
4743                 status = 0;
4744                 break;
4745         case (EAGAIN):          /* conflock holds conflicting lock */
4746                 status = nfserr_denied;
4747                 dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
4748                 nfs4_set_lock_denied(conflock, &lock->lk_denied);
4749                 break;
4750         case (EDEADLK):
4751                 status = nfserr_deadlock;
4752                 break;
4753         default:
4754                 dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
4755                 status = nfserrno(err);
4756                 break;
4757         }
4758 out:
4759         if (filp)
4760                 fput(filp);
4761         if (status && new_state)
4762                 release_lock_stateid(lock_stp);
4763         nfsd4_bump_seqid(cstate, status);
4764         if (!cstate->replay_owner)
4765                 nfs4_unlock_state();
4766         if (file_lock)
4767                 locks_free_lock(file_lock);
4768         if (conflock)
4769                 locks_free_lock(conflock);
4770         return status;
4771 }
4772
4773 /*
4774  * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
4775  * so we do a temporary open here just to get an open file to pass to
4776  * vfs_test_lock.  (Arguably perhaps test_lock should be done with an
4777  * inode operation.)
4778  */
4779 static __be32 nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
4780 {
4781         struct file *file;
4782         __be32 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
4783         if (!err) {
4784                 err = nfserrno(vfs_test_lock(file, lock));
4785                 nfsd_close(file);
4786         }
4787         return err;
4788 }
4789
4790 /*
4791  * LOCKT operation
4792  */
4793 __be32
4794 nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4795             struct nfsd4_lockt *lockt)
4796 {
4797         struct file_lock *file_lock = NULL;
4798         struct nfs4_lockowner *lo;
4799         __be32 status;
4800         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
4801
4802         if (locks_in_grace(SVC_NET(rqstp)))
4803                 return nfserr_grace;
4804
4805         if (check_lock_length(lockt->lt_offset, lockt->lt_length))
4806                  return nfserr_inval;
4807
4808         nfs4_lock_state();
4809
4810         if (!nfsd4_has_session(cstate)) {
4811                 status = lookup_clientid(&lockt->lt_clientid, cstate, nn);
4812                 if (status)
4813                         goto out;
4814         }
4815
4816         if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
4817                 goto out;
4818
4819         file_lock = locks_alloc_lock();
4820         if (!file_lock) {
4821                 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4822                 status = nfserr_jukebox;
4823                 goto out;
4824         }
4825         locks_init_lock(file_lock);
4826         switch (lockt->lt_type) {
4827                 case NFS4_READ_LT:
4828                 case NFS4_READW_LT:
4829                         file_lock->fl_type = F_RDLCK;
4830                 break;
4831                 case NFS4_WRITE_LT:
4832                 case NFS4_WRITEW_LT:
4833                         file_lock->fl_type = F_WRLCK;
4834                 break;
4835                 default:
4836                         dprintk("NFSD: nfs4_lockt: bad lock type!\n");
4837                         status = nfserr_inval;
4838                 goto out;
4839         }
4840
4841         lo = find_lockowner_str(&lockt->lt_clientid, &lockt->lt_owner, nn);
4842         if (lo)
4843                 file_lock->fl_owner = (fl_owner_t)lo;
4844         file_lock->fl_pid = current->tgid;
4845         file_lock->fl_flags = FL_POSIX;
4846
4847         file_lock->fl_start = lockt->lt_offset;
4848         file_lock->fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
4849
4850         nfs4_transform_lock_offset(file_lock);
4851
4852         status = nfsd_test_lock(rqstp, &cstate->current_fh, file_lock);
4853         if (status)
4854                 goto out;
4855
4856         if (file_lock->fl_type != F_UNLCK) {
4857                 status = nfserr_denied;
4858                 nfs4_set_lock_denied(file_lock, &lockt->lt_denied);
4859         }
4860 out:
4861         nfs4_unlock_state();
4862         if (file_lock)
4863                 locks_free_lock(file_lock);
4864         return status;
4865 }
4866
4867 __be32
4868 nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4869             struct nfsd4_locku *locku)
4870 {
4871         struct nfs4_ol_stateid *stp;
4872         struct file *filp = NULL;
4873         struct file_lock *file_lock = NULL;
4874         __be32 status;
4875         int err;
4876         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
4877
4878         dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
4879                 (long long) locku->lu_offset,
4880                 (long long) locku->lu_length);
4881
4882         if (check_lock_length(locku->lu_offset, locku->lu_length))
4883                  return nfserr_inval;
4884
4885         nfs4_lock_state();
4886
4887         status = nfs4_preprocess_seqid_op(cstate, locku->lu_seqid,
4888                                         &locku->lu_stateid, NFS4_LOCK_STID,
4889                                         &stp, nn);
4890         if (status)
4891                 goto out;
4892         filp = find_any_file(stp->st_file);
4893         if (!filp) {
4894                 status = nfserr_lock_range;
4895                 goto out;
4896         }
4897         file_lock = locks_alloc_lock();
4898         if (!file_lock) {
4899                 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4900                 status = nfserr_jukebox;
4901                 goto fput;
4902         }
4903         locks_init_lock(file_lock);
4904         file_lock->fl_type = F_UNLCK;
4905         file_lock->fl_owner = (fl_owner_t)lockowner(stp->st_stateowner);
4906         file_lock->fl_pid = current->tgid;
4907         file_lock->fl_file = filp;
4908         file_lock->fl_flags = FL_POSIX;
4909         file_lock->fl_lmops = &nfsd_posix_mng_ops;
4910         file_lock->fl_start = locku->lu_offset;
4911
4912         file_lock->fl_end = last_byte_offset(locku->lu_offset,
4913                                                 locku->lu_length);
4914         nfs4_transform_lock_offset(file_lock);
4915
4916         err = vfs_lock_file(filp, F_SETLK, file_lock, NULL);
4917         if (err) {
4918                 dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
4919                 goto out_nfserr;
4920         }
4921         update_stateid(&stp->st_stid.sc_stateid);
4922         memcpy(&locku->lu_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
4923 fput:
4924         fput(filp);
4925 out:
4926         nfsd4_bump_seqid(cstate, status);
4927         if (!cstate->replay_owner)
4928                 nfs4_unlock_state();
4929         if (file_lock)
4930                 locks_free_lock(file_lock);
4931         return status;
4932
4933 out_nfserr:
4934         status = nfserrno(err);
4935         goto fput;
4936 }
4937
4938 /*
4939  * returns
4940  *      1: locks held by lockowner
4941  *      0: no locks held by lockowner
4942  */
4943 static int
4944 check_for_locks(struct nfs4_file *filp, struct nfs4_lockowner *lowner)
4945 {
4946         struct file_lock **flpp;
4947         struct inode *inode = filp->fi_inode;
4948         int status = 0;
4949
4950         spin_lock(&inode->i_lock);
4951         for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) {
4952                 if ((*flpp)->fl_owner == (fl_owner_t)lowner) {
4953                         status = 1;
4954                         goto out;
4955                 }
4956         }
4957 out:
4958         spin_unlock(&inode->i_lock);
4959         return status;
4960 }
4961
4962 __be32
4963 nfsd4_release_lockowner(struct svc_rqst *rqstp,
4964                         struct nfsd4_compound_state *cstate,
4965                         struct nfsd4_release_lockowner *rlockowner)
4966 {
4967         clientid_t *clid = &rlockowner->rl_clientid;
4968         struct nfs4_stateowner *sop = NULL, *tmp;
4969         struct nfs4_lockowner *lo;
4970         struct nfs4_ol_stateid *stp;
4971         struct xdr_netobj *owner = &rlockowner->rl_owner;
4972         unsigned int hashval = ownerstr_hashval(clid->cl_id, owner);
4973         __be32 status;
4974         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
4975
4976         dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
4977                 clid->cl_boot, clid->cl_id);
4978
4979         nfs4_lock_state();
4980
4981         status = lookup_clientid(clid, cstate, nn);
4982         if (status)
4983                 goto out;
4984
4985         status = nfserr_locks_held;
4986
4987         /* Find the matching lock stateowner */
4988         list_for_each_entry(tmp, &nn->ownerstr_hashtbl[hashval], so_strhash) {
4989                 if (tmp->so_is_open_owner)
4990                         continue;
4991                 if (same_owner_str(tmp, owner, clid)) {
4992                         sop = tmp;
4993                         break;
4994                 }
4995         }
4996
4997         /* No matching owner found, maybe a replay? Just declare victory... */
4998         if (!sop) {
4999                 status = nfs_ok;
5000                 goto out;
5001         }
5002
5003         lo = lockowner(sop);
5004         /* see if there are still any locks associated with it */
5005         list_for_each_entry(stp, &sop->so_stateids, st_perstateowner) {
5006                 if (check_for_locks(stp->st_file, lo))
5007                         goto out;
5008         }
5009
5010         status = nfs_ok;
5011         release_lockowner(lo);
5012 out:
5013         nfs4_unlock_state();
5014         return status;
5015 }
5016
5017 static inline struct nfs4_client_reclaim *
5018 alloc_reclaim(void)
5019 {
5020         return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
5021 }
5022
5023 bool
5024 nfs4_has_reclaimed_state(const char *name, struct nfsd_net *nn)
5025 {
5026         struct nfs4_client_reclaim *crp;
5027
5028         crp = nfsd4_find_reclaim_client(name, nn);
5029         return (crp && crp->cr_clp);
5030 }
5031
5032 /*
5033  * failure => all reset bets are off, nfserr_no_grace...
5034  */
5035 struct nfs4_client_reclaim *
5036 nfs4_client_to_reclaim(const char *name, struct nfsd_net *nn)
5037 {
5038         unsigned int strhashval;
5039         struct nfs4_client_reclaim *crp;
5040
5041         dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
5042         crp = alloc_reclaim();
5043         if (crp) {
5044                 strhashval = clientstr_hashval(name);
5045                 INIT_LIST_HEAD(&crp->cr_strhash);
5046                 list_add(&crp->cr_strhash, &nn->reclaim_str_hashtbl[strhashval]);
5047                 memcpy(crp->cr_recdir, name, HEXDIR_LEN);
5048                 crp->cr_clp = NULL;
5049                 nn->reclaim_str_hashtbl_size++;
5050         }
5051         return crp;
5052 }
5053
5054 void
5055 nfs4_remove_reclaim_record(struct nfs4_client_reclaim *crp, struct nfsd_net *nn)
5056 {
5057         list_del(&crp->cr_strhash);
5058         kfree(crp);
5059         nn->reclaim_str_hashtbl_size--;
5060 }
5061
5062 void
5063 nfs4_release_reclaim(struct nfsd_net *nn)
5064 {
5065         struct nfs4_client_reclaim *crp = NULL;
5066         int i;
5067
5068         for (i = 0; i < CLIENT_HASH_SIZE; i++) {
5069                 while (!list_empty(&nn->reclaim_str_hashtbl[i])) {
5070                         crp = list_entry(nn->reclaim_str_hashtbl[i].next,
5071                                         struct nfs4_client_reclaim, cr_strhash);
5072                         nfs4_remove_reclaim_record(crp, nn);
5073                 }
5074         }
5075         WARN_ON_ONCE(nn->reclaim_str_hashtbl_size);
5076 }
5077
5078 /*
5079  * called from OPEN, CLAIM_PREVIOUS with a new clientid. */
5080 struct nfs4_client_reclaim *
5081 nfsd4_find_reclaim_client(const char *recdir, struct nfsd_net *nn)
5082 {
5083         unsigned int strhashval;
5084         struct nfs4_client_reclaim *crp = NULL;
5085
5086         dprintk("NFSD: nfs4_find_reclaim_client for recdir %s\n", recdir);
5087
5088         strhashval = clientstr_hashval(recdir);
5089         list_for_each_entry(crp, &nn->reclaim_str_hashtbl[strhashval], cr_strhash) {
5090                 if (same_name(crp->cr_recdir, recdir)) {
5091                         return crp;
5092                 }
5093         }
5094         return NULL;
5095 }
5096
5097 /*
5098 * Called from OPEN. Look for clientid in reclaim list.
5099 */
5100 __be32
5101 nfs4_check_open_reclaim(clientid_t *clid,
5102                 struct nfsd4_compound_state *cstate,
5103                 struct nfsd_net *nn)
5104 {
5105         __be32 status;
5106
5107         /* find clientid in conf_id_hashtbl */
5108         status = lookup_clientid(clid, cstate, nn);
5109         if (status)
5110                 return nfserr_reclaim_bad;
5111
5112         if (nfsd4_client_record_check(cstate->clp))
5113                 return nfserr_reclaim_bad;
5114
5115         return nfs_ok;
5116 }
5117
5118 #ifdef CONFIG_NFSD_FAULT_INJECTION
5119
5120 u64 nfsd_forget_client(struct nfs4_client *clp, u64 max)
5121 {
5122         if (mark_client_expired(clp))
5123                 return 0;
5124         expire_client(clp);
5125         return 1;
5126 }
5127
5128 u64 nfsd_print_client(struct nfs4_client *clp, u64 num)
5129 {
5130         char buf[INET6_ADDRSTRLEN];
5131         rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf));
5132         printk(KERN_INFO "NFS Client: %s\n", buf);
5133         return 1;
5134 }
5135
5136 static void nfsd_print_count(struct nfs4_client *clp, unsigned int count,
5137                              const char *type)
5138 {
5139         char buf[INET6_ADDRSTRLEN];
5140         rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf));
5141         printk(KERN_INFO "NFS Client: %s has %u %s\n", buf, count, type);
5142 }
5143
5144 static u64 nfsd_foreach_client_lock(struct nfs4_client *clp, u64 max,
5145                                     void (*func)(struct nfs4_ol_stateid *))
5146 {
5147         struct nfs4_openowner *oop;
5148         struct nfs4_ol_stateid *stp, *st_next;
5149         struct nfs4_ol_stateid *lst, *lst_next;
5150         u64 count = 0;
5151
5152         list_for_each_entry(oop, &clp->cl_openowners, oo_perclient) {
5153                 list_for_each_entry_safe(stp, st_next,
5154                                 &oop->oo_owner.so_stateids, st_perstateowner) {
5155                         list_for_each_entry_safe(lst, lst_next,
5156                                         &stp->st_locks, st_locks) {
5157                                 if (func)
5158                                         func(lst);
5159                                 if (++count == max)
5160                                         return count;
5161                         }
5162                 }
5163         }
5164
5165         return count;
5166 }
5167
5168 u64 nfsd_forget_client_locks(struct nfs4_client *clp, u64 max)
5169 {
5170         return nfsd_foreach_client_lock(clp, max, release_lock_stateid);
5171 }
5172
5173 u64 nfsd_print_client_locks(struct nfs4_client *clp, u64 max)
5174 {
5175         u64 count = nfsd_foreach_client_lock(clp, max, NULL);
5176         nfsd_print_count(clp, count, "locked files");
5177         return count;
5178 }
5179
5180 static u64 nfsd_foreach_client_open(struct nfs4_client *clp, u64 max, void (*func)(struct nfs4_openowner *))
5181 {
5182         struct nfs4_openowner *oop, *next;
5183         u64 count = 0;
5184
5185         list_for_each_entry_safe(oop, next, &clp->cl_openowners, oo_perclient) {
5186                 if (func)
5187                         func(oop);
5188                 if (++count == max)
5189                         break;
5190         }
5191
5192         return count;
5193 }
5194
5195 u64 nfsd_forget_client_openowners(struct nfs4_client *clp, u64 max)
5196 {
5197         return nfsd_foreach_client_open(clp, max, release_openowner);
5198 }
5199
5200 u64 nfsd_print_client_openowners(struct nfs4_client *clp, u64 max)
5201 {
5202         u64 count = nfsd_foreach_client_open(clp, max, NULL);
5203         nfsd_print_count(clp, count, "open files");
5204         return count;
5205 }
5206
5207 static u64 nfsd_find_all_delegations(struct nfs4_client *clp, u64 max,
5208                                      struct list_head *victims)
5209 {
5210         struct nfs4_delegation *dp, *next;
5211         u64 count = 0;
5212
5213         lockdep_assert_held(&state_lock);
5214         list_for_each_entry_safe(dp, next, &clp->cl_delegations, dl_perclnt) {
5215                 if (victims) {
5216                         /*
5217                          * It's not safe to mess with delegations that have a
5218                          * non-zero dl_time. They might have already been broken
5219                          * and could be processed by the laundromat outside of
5220                          * the state_lock. Just leave them be.
5221                          */
5222                         if (dp->dl_time != 0)
5223                                 continue;
5224
5225                         /*
5226                          * Increment dl_time to ensure that delegation breaks
5227                          * don't monkey with it now that we are.
5228                          */
5229                         ++dp->dl_time;
5230                         list_move(&dp->dl_recall_lru, victims);
5231                 }
5232                 if (++count == max)
5233                         break;
5234         }
5235         return count;
5236 }
5237
5238 u64 nfsd_forget_client_delegations(struct nfs4_client *clp, u64 max)
5239 {
5240         struct nfs4_delegation *dp, *next;
5241         LIST_HEAD(victims);
5242         u64 count;
5243
5244         spin_lock(&state_lock);
5245         count = nfsd_find_all_delegations(clp, max, &victims);
5246         spin_unlock(&state_lock);
5247
5248         list_for_each_entry_safe(dp, next, &victims, dl_recall_lru)
5249                 revoke_delegation(dp);
5250
5251         return count;
5252 }
5253
5254 u64 nfsd_recall_client_delegations(struct nfs4_client *clp, u64 max)
5255 {
5256         struct nfs4_delegation *dp;
5257         LIST_HEAD(victims);
5258         u64 count;
5259
5260         spin_lock(&state_lock);
5261         count = nfsd_find_all_delegations(clp, max, &victims);
5262         while (!list_empty(&victims)) {
5263                 dp = list_first_entry(&victims, struct nfs4_delegation,
5264                                         dl_recall_lru);
5265                 list_del_init(&dp->dl_recall_lru);
5266                 dp->dl_time = 0;
5267                 nfsd_break_one_deleg(dp);
5268         }
5269         spin_unlock(&state_lock);
5270
5271         return count;
5272 }
5273
5274 u64 nfsd_print_client_delegations(struct nfs4_client *clp, u64 max)
5275 {
5276         u64 count = 0;
5277
5278         spin_lock(&state_lock);
5279         count = nfsd_find_all_delegations(clp, max, NULL);
5280         spin_unlock(&state_lock);
5281
5282         nfsd_print_count(clp, count, "delegations");
5283         return count;
5284 }
5285
5286 u64 nfsd_for_n_state(u64 max, u64 (*func)(struct nfs4_client *, u64))
5287 {
5288         struct nfs4_client *clp, *next;
5289         u64 count = 0;
5290         struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_net_id);
5291
5292         if (!nfsd_netns_ready(nn))
5293                 return 0;
5294
5295         list_for_each_entry_safe(clp, next, &nn->client_lru, cl_lru) {
5296                 count += func(clp, max - count);
5297                 if ((max != 0) && (count >= max))
5298                         break;
5299         }
5300
5301         return count;
5302 }
5303
5304 struct nfs4_client *nfsd_find_client(struct sockaddr_storage *addr, size_t addr_size)
5305 {
5306         struct nfs4_client *clp;
5307         struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_net_id);
5308
5309         if (!nfsd_netns_ready(nn))
5310                 return NULL;
5311
5312         list_for_each_entry(clp, &nn->client_lru, cl_lru) {
5313                 if (memcmp(&clp->cl_addr, addr, addr_size) == 0)
5314                         return clp;
5315         }
5316         return NULL;
5317 }
5318
5319 #endif /* CONFIG_NFSD_FAULT_INJECTION */
5320
5321 /*
5322  * Since the lifetime of a delegation isn't limited to that of an open, a
5323  * client may quite reasonably hang on to a delegation as long as it has
5324  * the inode cached.  This becomes an obvious problem the first time a
5325  * client's inode cache approaches the size of the server's total memory.
5326  *
5327  * For now we avoid this problem by imposing a hard limit on the number
5328  * of delegations, which varies according to the server's memory size.
5329  */
5330 static void
5331 set_max_delegations(void)
5332 {
5333         /*
5334          * Allow at most 4 delegations per megabyte of RAM.  Quick
5335          * estimates suggest that in the worst case (where every delegation
5336          * is for a different inode), a delegation could take about 1.5K,
5337          * giving a worst case usage of about 6% of memory.
5338          */
5339         max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
5340 }
5341
5342 static int nfs4_state_create_net(struct net *net)
5343 {
5344         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
5345         int i;
5346
5347         nn->conf_id_hashtbl = kmalloc(sizeof(struct list_head) *
5348                         CLIENT_HASH_SIZE, GFP_KERNEL);
5349         if (!nn->conf_id_hashtbl)
5350                 goto err;
5351         nn->unconf_id_hashtbl = kmalloc(sizeof(struct list_head) *
5352                         CLIENT_HASH_SIZE, GFP_KERNEL);
5353         if (!nn->unconf_id_hashtbl)
5354                 goto err_unconf_id;
5355         nn->ownerstr_hashtbl = kmalloc(sizeof(struct list_head) *
5356                         OWNER_HASH_SIZE, GFP_KERNEL);
5357         if (!nn->ownerstr_hashtbl)
5358                 goto err_ownerstr;
5359         nn->sessionid_hashtbl = kmalloc(sizeof(struct list_head) *
5360                         SESSION_HASH_SIZE, GFP_KERNEL);
5361         if (!nn->sessionid_hashtbl)
5362                 goto err_sessionid;
5363
5364         for (i = 0; i < CLIENT_HASH_SIZE; i++) {
5365                 INIT_LIST_HEAD(&nn->conf_id_hashtbl[i]);
5366                 INIT_LIST_HEAD(&nn->unconf_id_hashtbl[i]);
5367         }
5368         for (i = 0; i < OWNER_HASH_SIZE; i++)
5369                 INIT_LIST_HEAD(&nn->ownerstr_hashtbl[i]);
5370         for (i = 0; i < SESSION_HASH_SIZE; i++)
5371                 INIT_LIST_HEAD(&nn->sessionid_hashtbl[i]);
5372         nn->conf_name_tree = RB_ROOT;
5373         nn->unconf_name_tree = RB_ROOT;
5374         INIT_LIST_HEAD(&nn->client_lru);
5375         INIT_LIST_HEAD(&nn->close_lru);
5376         INIT_LIST_HEAD(&nn->del_recall_lru);
5377         spin_lock_init(&nn->client_lock);
5378
5379         INIT_DELAYED_WORK(&nn->laundromat_work, laundromat_main);
5380         get_net(net);
5381
5382         return 0;
5383
5384 err_sessionid:
5385         kfree(nn->ownerstr_hashtbl);
5386 err_ownerstr:
5387         kfree(nn->unconf_id_hashtbl);
5388 err_unconf_id:
5389         kfree(nn->conf_id_hashtbl);
5390 err:
5391         return -ENOMEM;
5392 }
5393
5394 static void
5395 nfs4_state_destroy_net(struct net *net)
5396 {
5397         int i;
5398         struct nfs4_client *clp = NULL;
5399         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
5400
5401         for (i = 0; i < CLIENT_HASH_SIZE; i++) {
5402                 while (!list_empty(&nn->conf_id_hashtbl[i])) {
5403                         clp = list_entry(nn->conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
5404                         destroy_client(clp);
5405                 }
5406         }
5407
5408         for (i = 0; i < CLIENT_HASH_SIZE; i++) {
5409                 while (!list_empty(&nn->unconf_id_hashtbl[i])) {
5410                         clp = list_entry(nn->unconf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
5411                         destroy_client(clp);
5412                 }
5413         }
5414
5415         kfree(nn->sessionid_hashtbl);
5416         kfree(nn->ownerstr_hashtbl);
5417         kfree(nn->unconf_id_hashtbl);
5418         kfree(nn->conf_id_hashtbl);
5419         put_net(net);
5420 }
5421
5422 int
5423 nfs4_state_start_net(struct net *net)
5424 {
5425         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
5426         int ret;
5427
5428         ret = nfs4_state_create_net(net);
5429         if (ret)
5430                 return ret;
5431         nfsd4_client_tracking_init(net);
5432         nn->boot_time = get_seconds();
5433         locks_start_grace(net, &nn->nfsd4_manager);
5434         nn->grace_ended = false;
5435         printk(KERN_INFO "NFSD: starting %ld-second grace period (net %p)\n",
5436                nn->nfsd4_grace, net);
5437         queue_delayed_work(laundry_wq, &nn->laundromat_work, nn->nfsd4_grace * HZ);
5438         return 0;
5439 }
5440
5441 /* initialization to perform when the nfsd service is started: */
5442
5443 int
5444 nfs4_state_start(void)
5445 {
5446         int ret;
5447
5448         ret = set_callback_cred();
5449         if (ret)
5450                 return -ENOMEM;
5451         laundry_wq = create_singlethread_workqueue("nfsd4");
5452         if (laundry_wq == NULL) {
5453                 ret = -ENOMEM;
5454                 goto out_recovery;
5455         }
5456         ret = nfsd4_create_callback_queue();
5457         if (ret)
5458                 goto out_free_laundry;
5459
5460         set_max_delegations();
5461
5462         return 0;
5463
5464 out_free_laundry:
5465         destroy_workqueue(laundry_wq);
5466 out_recovery:
5467         return ret;
5468 }
5469
5470 void
5471 nfs4_state_shutdown_net(struct net *net)
5472 {
5473         struct nfs4_delegation *dp = NULL;
5474         struct list_head *pos, *next, reaplist;
5475         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
5476
5477         cancel_delayed_work_sync(&nn->laundromat_work);
5478         locks_end_grace(&nn->nfsd4_manager);
5479
5480         nfs4_lock_state();
5481         INIT_LIST_HEAD(&reaplist);
5482         spin_lock(&state_lock);
5483         list_for_each_safe(pos, next, &nn->del_recall_lru) {
5484                 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
5485                 list_move(&dp->dl_recall_lru, &reaplist);
5486         }
5487         spin_unlock(&state_lock);
5488         list_for_each_safe(pos, next, &reaplist) {
5489                 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
5490                 destroy_delegation(dp);
5491         }
5492
5493         nfsd4_client_tracking_exit(net);
5494         nfs4_state_destroy_net(net);
5495         nfs4_unlock_state();
5496 }
5497
5498 void
5499 nfs4_state_shutdown(void)
5500 {
5501         destroy_workqueue(laundry_wq);
5502         nfsd4_destroy_callback_queue();
5503 }
5504
5505 static void
5506 get_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
5507 {
5508         if (HAS_STATE_ID(cstate, CURRENT_STATE_ID_FLAG) && CURRENT_STATEID(stateid))
5509                 memcpy(stateid, &cstate->current_stateid, sizeof(stateid_t));
5510 }
5511
5512 static void
5513 put_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
5514 {
5515         if (cstate->minorversion) {
5516                 memcpy(&cstate->current_stateid, stateid, sizeof(stateid_t));
5517                 SET_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
5518         }
5519 }
5520
5521 void
5522 clear_current_stateid(struct nfsd4_compound_state *cstate)
5523 {
5524         CLEAR_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
5525 }
5526
5527 /*
5528  * functions to set current state id
5529  */
5530 void
5531 nfsd4_set_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp)
5532 {
5533         put_stateid(cstate, &odp->od_stateid);
5534 }
5535
5536 void
5537 nfsd4_set_openstateid(struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
5538 {
5539         put_stateid(cstate, &open->op_stateid);
5540 }
5541
5542 void
5543 nfsd4_set_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close)
5544 {
5545         put_stateid(cstate, &close->cl_stateid);
5546 }
5547
5548 void
5549 nfsd4_set_lockstateid(struct nfsd4_compound_state *cstate, struct nfsd4_lock *lock)
5550 {
5551         put_stateid(cstate, &lock->lk_resp_stateid);
5552 }
5553
5554 /*
5555  * functions to consume current state id
5556  */
5557
5558 void
5559 nfsd4_get_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp)
5560 {
5561         get_stateid(cstate, &odp->od_stateid);
5562 }
5563
5564 void
5565 nfsd4_get_delegreturnstateid(struct nfsd4_compound_state *cstate, struct nfsd4_delegreturn *drp)
5566 {
5567         get_stateid(cstate, &drp->dr_stateid);
5568 }
5569
5570 void
5571 nfsd4_get_freestateid(struct nfsd4_compound_state *cstate, struct nfsd4_free_stateid *fsp)
5572 {
5573         get_stateid(cstate, &fsp->fr_stateid);
5574 }
5575
5576 void
5577 nfsd4_get_setattrstateid(struct nfsd4_compound_state *cstate, struct nfsd4_setattr *setattr)
5578 {
5579         get_stateid(cstate, &setattr->sa_stateid);
5580 }
5581
5582 void
5583 nfsd4_get_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close)
5584 {
5585         get_stateid(cstate, &close->cl_stateid);
5586 }
5587
5588 void
5589 nfsd4_get_lockustateid(struct nfsd4_compound_state *cstate, struct nfsd4_locku *locku)
5590 {
5591         get_stateid(cstate, &locku->lu_stateid);
5592 }
5593
5594 void
5595 nfsd4_get_readstateid(struct nfsd4_compound_state *cstate, struct nfsd4_read *read)
5596 {
5597         get_stateid(cstate, &read->rd_stateid);
5598 }
5599
5600 void
5601 nfsd4_get_writestateid(struct nfsd4_compound_state *cstate, struct nfsd4_write *write)
5602 {
5603         get_stateid(cstate, &write->wr_stateid);
5604 }