[PATCH] fs/nfsd/export.c,net/sunrpc/cache.c: make needlessly global code static
[linux-2.6.git] / include / linux / sunrpc / cache.h
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                                          */
53         struct kref     ref;
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 {
63         struct module *         owner;
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;
71         void                    (*cache_put)(struct kref *);
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
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
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
130
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
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 {
153         kref_get(&h->ref);
154         return h;
155 }
156
157
158 static inline void cache_put(struct cache_head *h, struct cache_detail *cd)
159 {
160         if (atomic_read(&h->ref.refcount) <= 2 &&
161             h->expiry_time < cd->nextcheck)
162                 cd->nextcheck = h->expiry_time;
163         kref_put(&h->ref, cd->cache_put);
164 }
165
166 extern int cache_check(struct cache_detail *detail,
167                        struct cache_head *h, struct cache_req *rqstp);
168 extern void cache_flush(void);
169 extern void cache_purge(struct cache_detail *detail);
170 #define NEVER (0x7FFFFFFF)
171 extern void cache_register(struct cache_detail *cd);
172 extern int cache_unregister(struct cache_detail *cd);
173
174 extern void qword_add(char **bpp, int *lp, char *str);
175 extern void qword_addhex(char **bpp, int *lp, char *buf, int blen);
176 extern int qword_get(char **bpp, char *dest, int bufsize);
177
178 static inline int get_int(char **bpp, int *anint)
179 {
180         char buf[50];
181         char *ep;
182         int rv;
183         int len = qword_get(bpp, buf, 50);
184         if (len < 0) return -EINVAL;
185         if (len ==0) return -ENOENT;
186         rv = simple_strtol(buf, &ep, 0);
187         if (*ep) return -EINVAL;
188         *anint = rv;
189         return 0;
190 }
191
192 static inline time_t get_expiry(char **bpp)
193 {
194         int rv;
195         if (get_int(bpp, &rv))
196                 return 0;
197         if (rv < 0)
198                 return 0;
199         return rv;
200 }
201
202 #endif /*  _LINUX_SUNRPC_CACHE_H_ */