nfsd4: use idr for stateid's

*

*/

#include <linux/idr.h>

#include <linux/file.h>

#include <linux/fs.h>

#include <linux/slab.h>

time_t nfsd4_lease = 90;     /* default lease time */

time_t nfsd4_grace = 90;

static time_t boot_time;

static u32 current_stateid = 1;

static stateid_t zerostateid;             /* bits all 0 */

static stateid_t onestateid;              /* bits all 1 */

static u64 current_sessionid = 1;

#define FILE_HASH_BITS                   8

#define FILE_HASH_SIZE                  (1 << FILE_HASH_BITS)

/* hash table for (open)nfs4_ol_stateid */

#define STATEID_HASH_BITS              10

#define STATEID_HASH_SIZE              (1 << STATEID_HASH_BITS)

#define STATEID_HASH_MASK              (STATEID_HASH_SIZE - 1)

struct idr stateids;

static unsigned int file_hashval(struct inode *ino)

{

	return hash_ptr(ino, FILE_HASH_BITS);

}

static unsigned int stateid_hashval(stateid_t *s)

{

	return opaque_hashval(&s->si_opaque, sizeof(stateid_opaque_t)) & STATEID_HASH_MASK;

}

static struct list_head file_hashtbl[FILE_HASH_SIZE];

static struct list_head stateid_hashtbl[STATEID_HASH_SIZE];

static void __nfs4_file_get_access(struct nfs4_file *fp, int oflag)

{

		__nfs4_file_put_access(fp, oflag);

}

static inline void hash_stid(struct nfs4_stid *stid)

static inline int get_new_stid(struct nfs4_stid *stid)

{

	stateid_t *s = &stid->sc_stateid;

	unsigned int hashval;

	static int min_stateid = 0;

	int new_stid;

	int error;

	if (!idr_pre_get(&stateids, GFP_KERNEL))

		return -ENOMEM;

	error = idr_get_new_above(&stateids, stid, min_stateid, &new_stid);

	/*

	 * All this code is currently serialized; the preallocation

	 * above should still be ours:

	 */

	BUG_ON(error);

	/*

	 * It shouldn't be a problem to reuse an opaque stateid value.

	 * I don't think it is for 4.1.  But with 4.0 I worry that, for

	 * example, a stray write retransmission could be accepted by

	 * the server when it should have been rejected.  Therefore,

	 * adopt a trick from the sctp code to attempt to maximize the

	 * amount of time until an id is reused, by ensuring they always

	 * "increase" (mod INT_MAX):

	 */

	hashval = stateid_hashval(s);

	list_add(&stid->sc_hash, &stateid_hashtbl[hashval]);

	min_stateid = new_stid+1;

	if (min_stateid == INT_MAX)

		min_stateid = 0;

	return new_stid;

}

static void init_stid(struct nfs4_stid *stid, struct nfs4_client *cl, unsigned char type)

static inline __be32 init_stid(struct nfs4_stid *stid, struct nfs4_client *cl, unsigned char type)

{

	stateid_t *s = &stid->sc_stateid;

	int new_id;

	stid->sc_type = type;

	stid->sc_client = cl;

	s->si_opaque.so_clid = cl->cl_clientid;

	s->si_opaque.so_id = current_stateid++;

	new_id = get_new_stid(stid);

	if (new_id < 0)

		return nfserr_jukebox;

	s->si_opaque.so_id = (u32)new_id;

	/* Will be incremented before return to client: */

	s->si_generation = 0;

	hash_stid(stid);

	return 0;

}

static struct nfs4_delegation *

{

	struct nfs4_delegation *dp;

	struct nfs4_file *fp = stp->st_file;

	__be32 status;

	dprintk("NFSD alloc_init_deleg\n");

	/*

	dp = kmem_cache_alloc(deleg_slab, GFP_KERNEL);

	if (dp == NULL)

		return dp;

	init_stid(&dp->dl_stid, clp, NFS4_DELEG_STID);

	status = init_stid(&dp->dl_stid, clp, NFS4_DELEG_STID);

	if (status) {

		kmem_cache_free(deleg_slab, dp);

		return NULL;

	}

	/*

	 * delegation seqid's are never incremented.  The 4.1 special

	 * meaning of seqid 0 isn't really meaningful, really, but let's

	 * avoid 0 anyway just for consistency and use 1:

	 * meaning of seqid 0 isn't meaningful, really, but let's avoid

	 * 0 anyway just for consistency and use 1:

	 */

	dp->dl_stid.sc_stateid.si_generation = 1;

	num_delegations++;

	}

}

static void unhash_stid(struct nfs4_stid *s)

{

	idr_remove(&stateids, s->sc_stateid.si_opaque.so_id);

}

/* Called under the state lock. */

static void

unhash_delegation(struct nfs4_delegation *dp)

{

	list_del_init(&dp->dl_stid.sc_hash);

	unhash_stid(&dp->dl_stid);

	list_del_init(&dp->dl_perclnt);

	spin_lock(&recall_lock);

	list_del_init(&dp->dl_perfile);

	struct file *file;

	unhash_generic_stateid(stp);

	list_del(&stp->st_stid.sc_hash);

	unhash_stid(&stp->st_stid);

	file = find_any_file(stp->st_file);

	if (file)

		locks_remove_posix(file, (fl_owner_t)lockowner(stp->st_stateowner));

static void release_open_stateid(struct nfs4_ol_stateid *stp)

{

	unhash_open_stateid(stp);

	list_del(&stp->st_stid.sc_hash);

	unhash_stid(&stp->st_stid);

	free_generic_stateid(stp);

}

	struct nfs4_ol_stateid *s = oo->oo_last_closed_stid;

	if (s) {

		list_del_init(&s->st_stid.sc_hash);

		unhash_stid(&s->st_stid);

		free_generic_stateid(s);

		oo->oo_last_closed_stid = NULL;

	}

	*p++ = i++;

}

static int

same_stateid(stateid_t *id_one, stateid_t *id_two)

{

	return 0 == memcmp(&id_one->si_opaque, &id_two->si_opaque,

					sizeof(stateid_opaque_t));

}

static struct nfs4_stid *find_stateid(stateid_t *t)

{

	struct nfs4_stid *s;

	unsigned int hashval;

	hashval = stateid_hashval(t);

	list_for_each_entry(s, &stateid_hashtbl[hashval], sc_hash)

		if (same_stateid(&s->sc_stateid, t))

			return s;

	return NULL;

	return idr_find(&stateids, t->si_opaque.so_id);

}

static struct nfs4_stid *find_stateid_by_type(stateid_t *t, char typemask)

	return oo;

}

static inline void

init_open_stateid(struct nfs4_ol_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *open) {

static inline __be32 init_open_stateid(struct nfs4_ol_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *open) {

	struct nfs4_openowner *oo = open->op_openowner;

	struct nfs4_client *clp = oo->oo_owner.so_client;

	__be32 status;

	init_stid(&stp->st_stid, clp, NFS4_OPEN_STID);

	status = init_stid(&stp->st_stid, clp, NFS4_OPEN_STID);

	if (status)

		return status;

	INIT_LIST_HEAD(&stp->st_lockowners);

	list_add(&stp->st_perstateowner, &oo->oo_owner.so_stateids);

	list_add(&stp->st_perfile, &fp->fi_stateids);

		  &stp->st_access_bmap);

	__set_bit(open->op_share_deny, &stp->st_deny_bmap);

	stp->st_openstp = NULL;

	return nfs_ok;

}

static void

		status = nfs4_new_open(rqstp, &stp, fp, current_fh, open);

		if (status)

			goto out;

		init_open_stateid(stp, fp, open);

		status = init_open_stateid(stp, fp, open);

		if (status) {

			release_open_stateid(stp);

			goto out;

		}

		status = nfsd4_truncate(rqstp, current_fh, open);

		if (status) {

			release_open_stateid(stp);

{

	struct nfs4_ol_stateid *stp;

	struct nfs4_client *clp = lo->lo_owner.so_client;

	__be32 status;

	stp = nfs4_alloc_stateid();

	if (stp == NULL)

		goto out;

	init_stid(&stp->st_stid, clp, NFS4_LOCK_STID);

		return NULL;

	status = init_stid(&stp->st_stid, clp, NFS4_LOCK_STID);

	if (status) {

		free_generic_stateid(stp);

		return NULL;

	}

	list_add(&stp->st_perfile, &fp->fi_stateids);

	list_add(&stp->st_perstateowner, &lo->lo_owner.so_stateids);

	stp->st_stateowner = &lo->lo_owner;

	stp->st_access_bmap = 0;

	stp->st_deny_bmap = open_stp->st_deny_bmap;

	stp->st_openstp = open_stp;

out:

	return stp;

}

	for (i = 0; i < OPEN_OWNER_HASH_SIZE; i++) {

		INIT_LIST_HEAD(&open_ownerstr_hashtbl[i]);

	}

	for (i = 0; i < STATEID_HASH_SIZE; i++)

		INIT_LIST_HEAD(&stateid_hashtbl[i]);

	idr_init(&stateids);

	for (i = 0; i < LOCK_HASH_SIZE; i++) {

		INIT_LIST_HEAD(&lock_ownerstr_hashtbl[i]);

	}

/* For an open stateid kept around *only* to process close replays: */

#define NFS4_CLOSED_STID 8

	unsigned char sc_type;

	struct list_head sc_hash;

	stateid_t sc_stateid;

	struct nfs4_client *sc_client;

};