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 <[email protected]> 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/kref.h> 17 #include <linux/slab.h> 18 #include <linux/atomic.h> 19 #include <linux/proc_fs.h> 20 21 /* 22 * Each cache requires: 23 * - A 'struct cache_detail' which contains information specific to the cache 24 * for common code to use. 25 * - An item structure that must contain a "struct cache_head" 26 * - A lookup function defined using DefineCacheLookup 27 * - A 'put' function that can release a cache item. It will only 28 * be called after cache_put has succeed, so there are guarantee 29 * to be no references. 30 * - A function to calculate a hash of an item's key. 31 * 32 * as well as assorted code fragments (e.g. compare keys) and numbers 33 * (e.g. hash size, goal_age, etc). 34 * 35 * Each cache must be registered so that it can be cleaned regularly. 36 * When the cache is unregistered, it is flushed completely. 37 * 38 * Entries have a ref count and a 'hashed' flag which counts the existence 39 * in the hash table. 40 * We only expire entries when refcount is zero. 41 * Existence in the cache is counted the refcount. 42 */ 43 44 /* Every cache item has a common header that is used 45 * for expiring and refreshing entries. 46 * 47 */ 48 struct cache_head { 49 struct cache_head * next; 50 time_t expiry_time; /* After time time, don't use the data */ 51 time_t last_refresh; /* If CACHE_PENDING, this is when upcall 52 * was sent, else this is when update was received 53 */ 54 struct kref ref; 55 unsigned long flags; 56 }; 57 #define CACHE_VALID 0 /* Entry contains valid data */ 58 #define CACHE_NEGATIVE 1 /* Negative entry - there is no match for the key */ 59 #define CACHE_PENDING 2 /* An upcall has been sent but no reply received yet*/ 60 61 #define CACHE_NEW_EXPIRY 120 /* keep new things pending confirmation for 120 seconds */ 62 63 struct cache_detail_procfs { 64 struct proc_dir_entry *proc_ent; 65 struct proc_dir_entry *flush_ent, *channel_ent, *content_ent; 66 }; 67 68 struct cache_detail_pipefs { 69 struct dentry *dir; 70 }; 71 72 struct cache_detail { 73 struct module * owner; 74 int hash_size; 75 struct cache_head ** hash_table; 76 rwlock_t hash_lock; 77 78 atomic_t inuse; /* active user-space update or lookup */ 79 80 char *name; 81 void (*cache_put)(struct kref *); 82 83 int (*cache_upcall)(struct cache_detail *, 84 struct cache_head *); 85 86 int (*cache_parse)(struct cache_detail *, 87 char *buf, int len); 88 89 int (*cache_show)(struct seq_file *m, 90 struct cache_detail *cd, 91 struct cache_head *h); 92 void (*warn_no_listener)(struct cache_detail *cd, 93 int has_died); 94 95 struct cache_head * (*alloc)(void); 96 int (*match)(struct cache_head *orig, struct cache_head *new); 97 void (*init)(struct cache_head *orig, struct cache_head *new); 98 void (*update)(struct cache_head *orig, struct cache_head *new); 99 100 /* fields below this comment are for internal use 101 * and should not be touched by cache owners 102 */ 103 time_t flush_time; /* flush all cache items with last_refresh 104 * earlier than this */ 105 struct list_head others; 106 time_t nextcheck; 107 int entries; 108 109 /* fields for communication over channel */ 110 struct list_head queue; 111 112 atomic_t readers; /* how many time is /chennel open */ 113 time_t last_close; /* if no readers, when did last close */ 114 time_t last_warn; /* when we last warned about no readers */ 115 116 union { 117 struct cache_detail_procfs procfs; 118 struct cache_detail_pipefs pipefs; 119 } u; 120 struct net *net; 121 }; 122 123 124 /* this must be embedded in any request structure that 125 * identifies an object that will want a callback on 126 * a cache fill 127 */ 128 struct cache_req { 129 struct cache_deferred_req *(*defer)(struct cache_req *req); 130 int thread_wait; /* How long (jiffies) we can block the 131 * current thread to wait for updates. 132 */ 133 }; 134 /* this must be embedded in a deferred_request that is being 135 * delayed awaiting cache-fill 136 */ 137 struct cache_deferred_req { 138 struct hlist_node hash; /* on hash chain */ 139 struct list_head recent; /* on fifo */ 140 struct cache_head *item; /* cache item we wait on */ 141 void *owner; /* we might need to discard all defered requests 142 * owned by someone */ 143 void (*revisit)(struct cache_deferred_req *req, 144 int too_many); 145 }; 146 147 148 extern const struct file_operations cache_file_operations_pipefs; 149 extern const struct file_operations content_file_operations_pipefs; 150 extern const struct file_operations cache_flush_operations_pipefs; 151 152 extern struct cache_head * 153 sunrpc_cache_lookup(struct cache_detail *detail, 154 struct cache_head *key, int hash); 155 extern struct cache_head * 156 sunrpc_cache_update(struct cache_detail *detail, 157 struct cache_head *new, struct cache_head *old, int hash); 158 159 extern int 160 sunrpc_cache_pipe_upcall(struct cache_detail *detail, struct cache_head *h, 161 void (*cache_request)(struct cache_detail *, 162 struct cache_head *, 163 char **, 164 int *)); 165 166 167 extern void cache_clean_deferred(void *owner); 168 169 static inline struct cache_head *cache_get(struct cache_head *h) 170 { 171 kref_get(&h->ref); 172 return h; 173 } 174 175 176 static inline void cache_put(struct cache_head *h, struct cache_detail *cd) 177 { 178 if (atomic_read(&h->ref.refcount) <= 2 && 179 h->expiry_time < cd->nextcheck) 180 cd->nextcheck = h->expiry_time; 181 kref_put(&h->ref, cd->cache_put); 182 } 183 184 static inline int cache_valid(struct cache_head *h) 185 { 186 /* If an item has been unhashed pending removal when 187 * the refcount drops to 0, the expiry_time will be 188 * set to 0. We don't want to consider such items 189 * valid in this context even though CACHE_VALID is 190 * set. 191 */ 192 return (h->expiry_time != 0 && test_bit(CACHE_VALID, &h->flags)); 193 } 194 195 extern int cache_check(struct cache_detail *detail, 196 struct cache_head *h, struct cache_req *rqstp); 197 extern void cache_flush(void); 198 extern void cache_purge(struct cache_detail *detail); 199 #define NEVER (0x7FFFFFFF) 200 extern void __init cache_initialize(void); 201 extern int cache_register_net(struct cache_detail *cd, struct net *net); 202 extern void cache_unregister_net(struct cache_detail *cd, struct net *net); 203 204 extern struct cache_detail *cache_create_net(struct cache_detail *tmpl, struct net *net); 205 extern void cache_destroy_net(struct cache_detail *cd, struct net *net); 206 207 extern void sunrpc_init_cache_detail(struct cache_detail *cd); 208 extern void sunrpc_destroy_cache_detail(struct cache_detail *cd); 209 extern int sunrpc_cache_register_pipefs(struct dentry *parent, const char *, 210 umode_t, struct cache_detail *); 211 extern void sunrpc_cache_unregister_pipefs(struct cache_detail *); 212 213 extern void qword_add(char **bpp, int *lp, char *str); 214 extern void qword_addhex(char **bpp, int *lp, char *buf, int blen); 215 extern int qword_get(char **bpp, char *dest, int bufsize); 216 217 static inline int get_int(char **bpp, int *anint) 218 { 219 char buf[50]; 220 char *ep; 221 int rv; 222 int len = qword_get(bpp, buf, sizeof(buf)); 223 224 if (len < 0) 225 return -EINVAL; 226 if (len == 0) 227 return -ENOENT; 228 229 rv = simple_strtol(buf, &ep, 0); 230 if (*ep) 231 return -EINVAL; 232 233 *anint = rv; 234 return 0; 235 } 236 237 static inline int get_uint(char **bpp, unsigned int *anint) 238 { 239 char buf[50]; 240 int len = qword_get(bpp, buf, sizeof(buf)); 241 242 if (len < 0) 243 return -EINVAL; 244 if (len == 0) 245 return -ENOENT; 246 247 if (kstrtouint(buf, 0, anint)) 248 return -EINVAL; 249 250 return 0; 251 } 252 253 /* 254 * timestamps kept in the cache are expressed in seconds 255 * since boot. This is the best for measuring differences in 256 * real time. 257 */ 258 static inline time_t seconds_since_boot(void) 259 { 260 struct timespec boot; 261 getboottime(&boot); 262 return get_seconds() - boot.tv_sec; 263 } 264 265 static inline time_t convert_to_wallclock(time_t sinceboot) 266 { 267 struct timespec boot; 268 getboottime(&boot); 269 return boot.tv_sec + sinceboot; 270 } 271 272 static inline time_t get_expiry(char **bpp) 273 { 274 int rv; 275 struct timespec boot; 276 277 if (get_int(bpp, &rv)) 278 return 0; 279 if (rv < 0) 280 return 0; 281 getboottime(&boot); 282 return rv - boot.tv_sec; 283 } 284 285 #endif /* _LINUX_SUNRPC_CACHE_H_ */ 286