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