2 * include/linux/sunrpc/cache.h
4 * Generic code for various authentication-related caches
5 * used by sunrpc clients and servers.
7 * Copyright (C) 2002 Neil Brown <neilb@cse.unsw.edu.au>
9 * Released under terms in GPL version 2. See COPYING.
13 #ifndef _LINUX_SUNRPC_CACHE_H_
14 #define _LINUX_SUNRPC_CACHE_H_
16 #include <linux/slab.h>
17 #include <asm/atomic.h>
18 #include <linux/proc_fs.h>
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.
31 * as well as assorted code fragments (e.g. compare keys) and numbers
32 * (e.g. hash size, goal_age, etc).
34 * Each cache must be registered so that it can be cleaned regularly.
35 * When the cache is unregistered, it is flushed completely.
37 * Entries have a ref count and a 'hashed' flag which counts the existance
39 * We only expire entries when refcount is zero.
40 * Existance in the cache is counted the refcount.
43 /* Every cache item has a common header that is used
44 * for expiring and refreshing entries.
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
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*/
60 #define CACHE_NEW_EXPIRY 120 /* keep new things pending confirmation for 120 seconds */
63 struct module
* owner
;
65 struct cache_head
** hash_table
;
68 atomic_t inuse
; /* active user-space update or lookup */
71 void (*cache_put
)(struct cache_head
*,
72 struct cache_detail
*);
74 void (*cache_request
)(struct cache_detail
*cd
,
76 char **bpp
, int *blen
);
77 int (*cache_parse
)(struct cache_detail
*,
80 int (*cache_show
)(struct seq_file
*m
,
81 struct cache_detail
*cd
,
82 struct cache_head
*h
);
84 struct cache_head
* (*alloc
)(void);
85 int (*match
)(struct cache_head
*orig
, struct cache_head
*new);
86 void (*init
)(struct cache_head
*orig
, struct cache_head
*new);
87 void (*update
)(struct cache_head
*orig
, struct cache_head
*new);
89 /* fields below this comment are for internal use
90 * and should not be touched by cache owners
92 time_t flush_time
; /* flush all cache items with last_refresh
93 * earlier than this */
94 struct list_head others
;
98 /* fields for communication over channel */
99 struct list_head queue
;
100 struct proc_dir_entry
*proc_ent
;
101 struct proc_dir_entry
*flush_ent
, *channel_ent
, *content_ent
;
103 atomic_t readers
; /* how many time is /chennel open */
104 time_t last_close
; /* if no readers, when did last close */
105 time_t last_warn
; /* when we last warned about no readers */
106 void (*warn_no_listener
)(struct cache_detail
*cd
);
110 /* this must be embedded in any request structure that
111 * identifies an object that will want a callback on
115 struct cache_deferred_req
*(*defer
)(struct cache_req
*req
);
117 /* this must be embedded in a deferred_request that is being
118 * delayed awaiting cache-fill
120 struct cache_deferred_req
{
121 struct list_head hash
; /* on hash chain */
122 struct list_head recent
; /* on fifo */
123 struct cache_head
*item
; /* cache item we wait on */
125 void *owner
; /* we might need to discard all defered requests
126 * owned by someone */
127 void (*revisit
)(struct cache_deferred_req
*req
,
132 * just like a template in C++, this macro does cache lookup
134 * The function is passed some sort of HANDLE from which a cache_detail
135 * structure can be determined (via SETUP, DETAIL), a template
136 * cache entry (type RTN*), and a "set" flag. Using the HASHFN and the
137 * TEST, the function will try to find a matching cache entry in the cache.
139 * If an entry is found, it is returned
140 * If no entry is found, a new non-VALID entry is created.
142 * If no entry is found a new one is inserted with data from "template"
143 * If a non-CACHE_VALID entry is found, it is updated from template using UPDATE
144 * If a CACHE_VALID entry is found, a new entry is swapped in with data
147 * If the passed handle has the CACHE_NEGATIVE flag set, then UPDATE is not
148 * run but insteead CACHE_NEGATIVE is set in any new item.
150 * In any case, the new entry is returned with a reference count.
153 * RTN is a struct type for a cache entry
154 * MEMBER is the member of the cache which is cache_head, which must be first
155 * FNAME is the name for the function
156 * ARGS are arguments to function and must contain RTN *item, int set. May
157 * also contain something to be usedby SETUP or DETAIL to find cache_detail.
158 * SETUP locates the cache detail and makes it available as...
159 * DETAIL identifies the cache detail, possibly set up by SETUP
160 * HASHFN returns a hash value of the cache entry "item"
161 * TEST tests if "tmp" matches "item"
162 * INIT copies key information from "item" to "new"
163 * UPDATE copies content information from "item" to "tmp"
165 #define DefineCacheLookup(RTN,MEMBER,FNAME,ARGS,SETUP,DETAIL,HASHFN,TEST,INIT,UPDATE) \
168 RTN *tmp, *new=NULL; \
169 struct cache_head **hp, **head; \
171 head = &(DETAIL)->hash_table[HASHFN]; \
173 if (set||new) write_lock(&(DETAIL)->hash_lock); \
174 else read_lock(&(DETAIL)->hash_lock); \
175 for(hp=head; *hp != NULL; hp = &tmp->MEMBER.next) { \
176 tmp = container_of(*hp, RTN, MEMBER); \
177 if (TEST) { /* found a match */ \
179 if (set && test_bit(CACHE_VALID, &tmp->MEMBER.flags) && !new) \
185 if (test_bit(CACHE_VALID, &tmp->MEMBER.flags))\
186 { /* need to swap in new */ \
189 new->MEMBER.next = tmp->MEMBER.next; \
190 *hp = &new->MEMBER; \
191 tmp->MEMBER.next = NULL; \
192 t2 = tmp; tmp = new; new = t2; \
194 if (test_bit(CACHE_NEGATIVE, &item->MEMBER.flags)) \
195 set_bit(CACHE_NEGATIVE, &tmp->MEMBER.flags); \
198 clear_bit(CACHE_NEGATIVE, &tmp->MEMBER.flags); \
201 cache_get(&tmp->MEMBER); \
202 if (set||new) write_unlock(&(DETAIL)->hash_lock); \
203 else read_unlock(&(DETAIL)->hash_lock); \
205 cache_fresh(DETAIL, &tmp->MEMBER, item->MEMBER.expiry_time); \
206 if (set && new) cache_fresh(DETAIL, &new->MEMBER, 0); \
207 if (new) (DETAIL)->cache_put(&new->MEMBER, DETAIL); \
211 /* Didn't find anything */ \
214 new->MEMBER.next = *head; \
215 *head = &new->MEMBER; \
216 (DETAIL)->entries ++; \
217 cache_get(&new->MEMBER); \
220 if (test_bit(CACHE_NEGATIVE, &item->MEMBER.flags)) \
221 set_bit(CACHE_NEGATIVE, &tmp->MEMBER.flags); \
225 if (set||new) write_unlock(&(DETAIL)->hash_lock); \
226 else read_unlock(&(DETAIL)->hash_lock); \
228 cache_fresh(DETAIL, &new->MEMBER, item->MEMBER.expiry_time); \
231 new = kmalloc(sizeof(*new), GFP_KERNEL); \
233 cache_init(&new->MEMBER); \
239 #define DefineSimpleCacheLookup(STRUCT, FUNC) \
240 DefineCacheLookup(struct STRUCT, h, FUNC##_lookup, \
241 (struct STRUCT *item, int set), /*no setup */, \
242 & FUNC##_cache, FUNC##_hash(item), FUNC##_match(item, tmp), \
243 STRUCT##_init(new, item), STRUCT##_update(tmp, item))
245 extern struct cache_head
*
246 sunrpc_cache_lookup(struct cache_detail
*detail
,
247 struct cache_head
*key
, int hash
);
248 extern struct cache_head
*
249 sunrpc_cache_update(struct cache_detail
*detail
,
250 struct cache_head
*new, struct cache_head
*old
, int hash
);
253 #define cache_for_each(pos, detail, index, member) \
254 for (({read_lock(&(detail)->hash_lock); index = (detail)->hash_size;}) ; \
255 ({if (index==0)read_unlock(&(detail)->hash_lock); index--;}); \
257 for (pos = container_of((detail)->hash_table[index], typeof(*pos), member); \
259 pos = container_of(pos->member.next, typeof(*pos), member))
263 extern void cache_clean_deferred(void *owner
);
265 static inline struct cache_head
*cache_get(struct cache_head
*h
)
267 atomic_inc(&h
->refcnt
);
272 static inline int cache_put(struct cache_head
*h
, struct cache_detail
*cd
)
274 if (atomic_read(&h
->refcnt
) <= 2 &&
275 h
->expiry_time
< cd
->nextcheck
)
276 cd
->nextcheck
= h
->expiry_time
;
277 return atomic_dec_and_test(&h
->refcnt
);
280 extern void cache_init(struct cache_head
*h
);
281 extern void cache_fresh(struct cache_detail
*detail
,
282 struct cache_head
*head
, time_t expiry
);
283 extern int cache_check(struct cache_detail
*detail
,
284 struct cache_head
*h
, struct cache_req
*rqstp
);
285 extern void cache_flush(void);
286 extern void cache_purge(struct cache_detail
*detail
);
287 #define NEVER (0x7FFFFFFF)
288 extern void cache_register(struct cache_detail
*cd
);
289 extern int cache_unregister(struct cache_detail
*cd
);
291 extern void qword_add(char **bpp
, int *lp
, char *str
);
292 extern void qword_addhex(char **bpp
, int *lp
, char *buf
, int blen
);
293 extern int qword_get(char **bpp
, char *dest
, int bufsize
);
295 static inline int get_int(char **bpp
, int *anint
)
300 int len
= qword_get(bpp
, buf
, 50);
301 if (len
< 0) return -EINVAL
;
302 if (len
==0) return -ENOENT
;
303 rv
= simple_strtol(buf
, &ep
, 0);
304 if (*ep
) return -EINVAL
;
309 static inline time_t get_expiry(char **bpp
)
312 if (get_int(bpp
, &rv
))
319 #endif /* _LINUX_SUNRPC_CACHE_H_ */
This page took 0.060102 seconds and 5 git commands to generate.