[linux-block.git] / include / linux / sunrpc / cache.h

/*
 * include/linux/sunrpc/cache.h
 *
 * Generic code for various authentication-related caches
 * used by sunrpc clients and servers.
 *
 * Copyright (C) 2002 Neil Brown <neilb@cse.unsw.edu.au>
 *
 * Released under terms in GPL version 2.  See COPYING.
 *
 */

#ifndef _LINUX_SUNRPC_CACHE_H_
#define _LINUX_SUNRPC_CACHE_H_

#include <linux/slab.h>
#include <asm/atomic.h>
#include <linux/proc_fs.h>

/*
 * Each cache requires:
 *  - A 'struct cache_detail' which contains information specific to the cache
 *    for common code to use.
 *  - An item structure that must contain a "struct cache_head"
 *  - A lookup function defined using DefineCacheLookup
 *  - A 'put' function that can release a cache item. It will only
 *    be called after cache_put has succeed, so there are guarantee
 *    to be no references.
 *  - A function to calculate a hash of an item's key.
 *
 * as well as assorted code fragments (e.g. compare keys) and numbers
 * (e.g. hash size, goal_age, etc).
 *
 * Each cache must be registered so that it can be cleaned regularly.
 * When the cache is unregistered, it is flushed completely.
 *
 * Entries have a ref count and a 'hashed' flag which counts the existance
 * in the hash table.
 * We only expire entries when refcount is zero.
 * Existance in the cache is counted  the refcount.
 */

/* Every cache item has a common header that is used
 * for expiring and refreshing entries.
 * 
 */
struct cache_head {
	struct cache_head * next;
	time_t		expiry_time;	/* After time time, don't use the data */
	time_t		last_refresh;   /* If CACHE_PENDING, this is when upcall 
					 * was sent, else this is when update was received
					 */
	struct kref	ref;
	unsigned long	flags;
};
#define	CACHE_VALID	0	/* Entry contains valid data */
#define	CACHE_NEGATIVE	1	/* Negative entry - there is no match for the key */
#define	CACHE_PENDING	2	/* An upcall has been sent but no reply received yet*/

#define	CACHE_NEW_EXPIRY 120	/* keep new things pending confirmation for 120 seconds */

struct cache_detail {
	struct module *		owner;
	int			hash_size;
	struct cache_head **	hash_table;
	rwlock_t		hash_lock;

	atomic_t		inuse; /* active user-space update or lookup */

	char			*name;
	void			(*cache_put)(struct kref *);

	void			(*cache_request)(struct cache_detail *cd,
						 struct cache_head *h,
						 char **bpp, int *blen);
	int			(*cache_parse)(struct cache_detail *,
					       char *buf, int len);

	int			(*cache_show)(struct seq_file *m,
					      struct cache_detail *cd,
					      struct cache_head *h);

	struct cache_head *	(*alloc)(void);
	int			(*match)(struct cache_head *orig, struct cache_head *new);
	void			(*init)(struct cache_head *orig, struct cache_head *new);
	void			(*update)(struct cache_head *orig, struct cache_head *new);

	/* fields below this comment are for internal use
	 * and should not be touched by cache owners
	 */
	time_t			flush_time;		/* flush all cache items with last_refresh
							 * earlier than this */
	struct list_head	others;
	time_t			nextcheck;
	int			entries;

	/* fields for communication over channel */
	struct list_head	queue;
	struct proc_dir_entry	*proc_ent;
	struct proc_dir_entry   *flush_ent, *channel_ent, *content_ent;

	atomic_t		readers;		/* how many time is /chennel open */
	time_t			last_close;		/* if no readers, when did last close */
	time_t			last_warn;		/* when we last warned about no readers */
	void			(*warn_no_listener)(struct cache_detail *cd);
};


/* this must be embedded in any request structure that
 * identifies an object that will want a callback on
 * a cache fill
 */
struct cache_req {
	struct cache_deferred_req *(*defer)(struct cache_req *req);
};
/* this must be embedded in a deferred_request that is being
 * delayed awaiting cache-fill
 */
struct cache_deferred_req {
	struct list_head	hash;	/* on hash chain */
	struct list_head	recent; /* on fifo */
	struct cache_head	*item;  /* cache item we wait on */
	time_t			recv_time;
	void			*owner; /* we might need to discard all defered requests
					 * owned by someone */
	void			(*revisit)(struct cache_deferred_req *req,
					   int too_many);
};


extern struct cache_head *
sunrpc_cache_lookup(struct cache_detail *detail,
		    struct cache_head *key, int hash);
extern struct cache_head *
sunrpc_cache_update(struct cache_detail *detail,
		    struct cache_head *new, struct cache_head *old, int hash);


#define cache_for_each(pos, detail, index, member) 						\
	for (({read_lock(&(detail)->hash_lock); index = (detail)->hash_size;}) ;		\
	     ({if (index==0)read_unlock(&(detail)->hash_lock); index--;});			\
		)										\
		for (pos = container_of((detail)->hash_table[index], typeof(*pos), member);	\
		     &pos->member;								\
		     pos = container_of(pos->member.next, typeof(*pos), member))

	     
extern void cache_clean_deferred(void *owner);

static inline struct cache_head  *cache_get(struct cache_head *h)
{
	kref_get(&h->ref);
	return h;
}


static inline void cache_put(struct cache_head *h, struct cache_detail *cd)
{
	if (atomic_read(&h->ref.refcount) <= 2 &&
	    h->expiry_time < cd->nextcheck)
		cd->nextcheck = h->expiry_time;
	kref_put(&h->ref, cd->cache_put);
}

static inline int cache_valid(struct cache_head *h)
{
	/* If an item has been unhashed pending removal when
	 * the refcount drops to 0, the expiry_time will be
	 * set to 0.  We don't want to consider such items
	 * valid in this context even though CACHE_VALID is
	 * set.
	 */
	return (h->expiry_time != 0 && test_bit(CACHE_VALID, &h->flags));
}

extern int cache_check(struct cache_detail *detail,
		       struct cache_head *h, struct cache_req *rqstp);
extern void cache_flush(void);
extern void cache_purge(struct cache_detail *detail);
#define NEVER (0x7FFFFFFF)
extern void cache_register(struct cache_detail *cd);
extern int cache_unregister(struct cache_detail *cd);

extern void qword_add(char **bpp, int *lp, char *str);
extern void qword_addhex(char **bpp, int *lp, char *buf, int blen);
extern int qword_get(char **bpp, char *dest, int bufsize);

static inline int get_int(char **bpp, int *anint)
{
	char buf[50];
	char *ep;
	int rv;
	int len = qword_get(bpp, buf, 50);
	if (len < 0) return -EINVAL;
	if (len ==0) return -ENOENT;
	rv = simple_strtol(buf, &ep, 0);
	if (*ep) return -EINVAL;
	*anint = rv;
	return 0;
}

static inline time_t get_expiry(char **bpp)
{
	int rv;
	if (get_int(bpp, &rv))
		return 0;
	if (rv < 0)
		return 0;
	return rv;
}

#endif /*  _LINUX_SUNRPC_CACHE_H_ */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* include/linux/sunrpc/cache.h
	3	*
	4	* Generic code for various authentication-related caches
	5	* used by sunrpc clients and servers.
	6	*
	7	* Copyright (C) 2002 Neil Brown <neilb@cse.unsw.edu.au>
	8	*
	9	* Released under terms in GPL version 2. See COPYING.
	10	*
	11	*/
	12
	13	#ifndef _LINUX_SUNRPC_CACHE_H_
	14	#define _LINUX_SUNRPC_CACHE_H_
	15
	16	#include <linux/slab.h>
	17	#include <asm/atomic.h>
	18	#include <linux/proc_fs.h>
	19
	20	/*
	21	* Each cache requires:
	22	* - A 'struct cache_detail' which contains information specific to the cache
	23	* for common code to use.
	24	* - An item structure that must contain a "struct cache_head"
	25	* - A lookup function defined using DefineCacheLookup
	26	* - A 'put' function that can release a cache item. It will only
	27	* be called after cache_put has succeed, so there are guarantee
	28	* to be no references.
	29	* - A function to calculate a hash of an item's key.
	30	*
	31	* as well as assorted code fragments (e.g. compare keys) and numbers
	32	* (e.g. hash size, goal_age, etc).
	33	*
	34	* Each cache must be registered so that it can be cleaned regularly.
	35	* When the cache is unregistered, it is flushed completely.
	36	*
	37	* Entries have a ref count and a 'hashed' flag which counts the existance
	38	* in the hash table.
	39	* We only expire entries when refcount is zero.
	40	* Existance in the cache is counted the refcount.
	41	*/
	42
	43	/* Every cache item has a common header that is used
	44	* for expiring and refreshing entries.
	45	*
	46	*/
	47	struct cache_head {
	48	struct cache_head * next;
	49	time_t expiry_time; /* After time time, don't use the data */
	50	time_t last_refresh; /* If CACHE_PENDING, this is when upcall
	51	* was sent, else this is when update was received
	52	*/
baab935f	53	struct kref ref;
1da177e4 LT	54	unsigned long flags;
	55	};
	56	#define CACHE_VALID 0 /* Entry contains valid data */
	57	#define CACHE_NEGATIVE 1 /* Negative entry - there is no match for the key */
	58	#define CACHE_PENDING 2 /* An upcall has been sent but no reply received yet*/
	59
	60	#define CACHE_NEW_EXPIRY 120 /* keep new things pending confirmation for 120 seconds */
	61
	62	struct cache_detail {
f35279d3	63	struct module * owner;
1da177e4 LT	64	int hash_size;
	65	struct cache_head ** hash_table;
	66	rwlock_t hash_lock;
	67
	68	atomic_t inuse; /* active user-space update or lookup */
	69
	70	char *name;
baab935f	71	void (cache_put)(struct kref );
1da177e4 LT	72
	73	void (cache_request)(struct cache_detail cd,
	74	struct cache_head *h,
	75	char *bpp, int blen);
	76	int (cache_parse)(struct cache_detail ,
	77	char *buf, int len);
	78
	79	int (cache_show)(struct seq_file m,
	80	struct cache_detail *cd,
	81	struct cache_head *h);
	82
15a5f6bd N	83	struct cache_head * (*alloc)(void);
	84	int (match)(struct cache_head orig, struct cache_head *new);
	85	void (init)(struct cache_head orig, struct cache_head *new);
	86	void (update)(struct cache_head orig, struct cache_head *new);
	87
1da177e4 LT	88	/* fields below this comment are for internal use
	89	* and should not be touched by cache owners
	90	*/
	91	time_t flush_time; /* flush all cache items with last_refresh
	92	* earlier than this */
	93	struct list_head others;
	94	time_t nextcheck;
	95	int entries;
	96
	97	/* fields for communication over channel */
	98	struct list_head queue;
	99	struct proc_dir_entry *proc_ent;
	100	struct proc_dir_entry flush_ent, channel_ent, *content_ent;
	101
	102	atomic_t readers; /* how many time is /chennel open */
	103	time_t last_close; /* if no readers, when did last close */
	104	time_t last_warn; /* when we last warned about no readers */
	105	void (warn_no_listener)(struct cache_detail cd);
	106	};
	107
	108
	109	/* this must be embedded in any request structure that
	110	* identifies an object that will want a callback on
	111	* a cache fill
	112	*/
	113	struct cache_req {
	114	struct cache_deferred_req (defer)(struct cache_req *req);
	115	};
	116	/* this must be embedded in a deferred_request that is being
	117	* delayed awaiting cache-fill
	118	*/
	119	struct cache_deferred_req {
	120	struct list_head hash; /* on hash chain */
	121	struct list_head recent; /* on fifo */
	122	struct cache_head item; / cache item we wait on */
	123	time_t recv_time;
	124	void owner; / we might need to discard all defered requests
	125	* owned by someone */
	126	void (revisit)(struct cache_deferred_req req,
	127	int too_many);
	128	};
	129
7d317f2c	130
15a5f6bd N	131	extern struct cache_head *
	132	sunrpc_cache_lookup(struct cache_detail *detail,
	133	struct cache_head *key, int hash);
	134	extern struct cache_head *
	135	sunrpc_cache_update(struct cache_detail *detail,
	136	struct cache_head new, struct cache_head old, int hash);
	137
1da177e4 LT	138
	139	#define cache_for_each(pos, detail, index, member) \
	140	for (({read_lock(&(detail)->hash_lock); index = (detail)->hash_size;}) ; \
	141	({if (index==0)read_unlock(&(detail)->hash_lock); index--;}); \
	142	) \
	143	for (pos = container_of((detail)->hash_table[index], typeof(*pos), member); \
	144	&pos->member; \
	145	pos = container_of(pos->member.next, typeof(*pos), member))
	146
	147
	148
	149	extern void cache_clean_deferred(void *owner);
	150
	151	static inline struct cache_head cache_get(struct cache_head h)
	152	{
baab935f	153	kref_get(&h->ref);
1da177e4 LT	154	return h;
	155	}
	156
	157
baab935f	158	static inline void cache_put(struct cache_head h, struct cache_detail cd)
1da177e4	159	{
baab935f	160	if (atomic_read(&h->ref.refcount) <= 2 &&
1da177e4 LT	161	h->expiry_time < cd->nextcheck)
1da177e4 LT	162	cd->nextcheck = h->expiry_time;
baab935f	163	kref_put(&h->ref, cd->cache_put);
1da177e4 LT	164	}
1da177e4 LT	165
7b2b1fee GB	166	static inline int cache_valid(struct cache_head *h)
	167	{
	168	/* If an item has been unhashed pending removal when
	169	* the refcount drops to 0, the expiry_time will be
	170	* set to 0. We don't want to consider such items
	171	* valid in this context even though CACHE_VALID is
	172	* set.
	173	*/
	174	return (h->expiry_time != 0 && test_bit(CACHE_VALID, &h->flags));
	175	}
	176
1da177e4 LT	177	extern int cache_check(struct cache_detail *detail,
	178	struct cache_head h, struct cache_req rqstp);
	179	extern void cache_flush(void);
	180	extern void cache_purge(struct cache_detail *detail);
	181	#define NEVER (0x7FFFFFFF)
	182	extern void cache_register(struct cache_detail *cd);
	183	extern int cache_unregister(struct cache_detail *cd);
	184
	185	extern void qword_add(char *bpp, int lp, char *str);
	186	extern void qword_addhex(char *bpp, int lp, char *buf, int blen);
	187	extern int qword_get(char *bpp, char dest, int bufsize);
	188
	189	static inline int get_int(char *bpp, int anint)
	190	{
	191	char buf[50];
	192	char *ep;
	193	int rv;
	194	int len = qword_get(bpp, buf, 50);
	195	if (len < 0) return -EINVAL;
	196	if (len ==0) return -ENOENT;
	197	rv = simple_strtol(buf, &ep, 0);
	198	if (*ep) return -EINVAL;
	199	*anint = rv;
	200	return 0;
	201	}
	202
	203	static inline time_t get_expiry(char **bpp)
	204	{
	205	int rv;
	206	if (get_int(bpp, &rv))
	207	return 0;
	208	if (rv < 0)
	209	return 0;
	210	return rv;
	211	}
	212
	213	#endif /* _LINUX_SUNRPC_CACHE_H_ */