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