Linux: use DEFINE_MUTEX for afs_linux_alloc_sem on newer kernels
[openafs.git] / src / afs / LINUX / osi_alloc.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*
11  * osi_alloc.c - Linux memory allocation routines.
12  *
13  */
14 #include <afsconfig.h>
15 #include "afs/param.h"
16
17
18 #include "afs/sysincludes.h"
19 #include "afsincludes.h"
20 #include <linux/mm.h>
21 #include <linux/slab.h>
22
23 #include "afs_atomlist.h"
24 #include "afs_lhash.h"
25
26 #define MAX_KMALLOC_SIZE PAGE_SIZE      /* Max we should alloc with kmalloc */
27 #define MAX_BUCKET_LEN 30       /* max. no. of entries per buckets we expect to see */
28 #define STAT_INTERVAL 8192      /* we collect stats once every STAT_INTERVAL allocs */
29
30 /* types of alloc */
31 #define KM_TYPE 1               /* kmalloc */
32 #define VM_TYPE 2               /* vmalloc */
33
34 struct osi_linux_mem {
35     void *chunk;
36 };
37
38 /* These assume 32-bit pointers */
39 #define MEMTYPE(A) (((unsigned long)A) & 0x3)
40 #define MEMADDR(A) (void *)((unsigned long)(A) & (~0x3))
41
42 /* globals */
43 afs_atomlist *al_mem_pool;      /* pool of osi_linux_mem structures */
44 afs_lhash *lh_mem_htab;         /* mem hash table */
45 unsigned int allocator_init = 0;        /* has the allocator been initialized? */
46 unsigned int afs_linux_cur_allocs = 0;
47 unsigned int afs_linux_total_allocs = 0;
48 unsigned int afs_linux_hash_verify_count = 0;   /* used by hash_verify */
49 struct afs_lhash_stat afs_linux_lsb;    /* hash table statistics */
50 unsigned int afs_linux_hash_bucket_dist[MAX_BUCKET_LEN];        /* bucket population distribution in our hash table */
51
52 #include <linux/vmalloc.h>
53
54 /* Allocator support functions (static) */
55
56 static int
57 hash_equal(const void *a, const void *b)
58 {
59     return (MEMADDR(((struct osi_linux_mem *)a)->chunk) ==
60             MEMADDR(((struct osi_linux_mem *)b)->chunk));
61
62 }
63
64 /* linux_alloc : Allocates memory from the linux kernel. It uses 
65  *               kmalloc if possible. Otherwise, we use vmalloc. 
66  * Input:
67  *  asize - size of memory required in bytes
68  * Return Values:
69  *  returns NULL if we failed to allocate memory.
70  *  or pointer to memory if we succeeded.
71  */
72 static void *
73 linux_alloc(unsigned int asize, int drop_glock)
74 {
75     void *new = NULL;
76     int max_retry = 10;
77     int haveGlock = ISAFS_GLOCK();
78
79     /*  if we can use kmalloc use it to allocate the required memory. */
80     while (!new && max_retry) {
81         if (asize <= MAX_KMALLOC_SIZE) {
82             new = (void *)(unsigned long)kmalloc(asize, GFP_NOFS);
83             if (new)            /* piggy back alloc type */
84                 new = (void *)(KM_TYPE | (unsigned long)new);
85         } else {
86             osi_Assert(drop_glock || !haveGlock);
87             if (drop_glock && haveGlock)
88                 AFS_GUNLOCK();
89             new = (void *)vmalloc(asize);
90             if (drop_glock && haveGlock)
91                 AFS_GLOCK();
92             if (new)            /* piggy back alloc type */
93                 new = (void *)(VM_TYPE | (unsigned long)new);
94         }
95
96         if (!new) {
97 #ifdef set_current_state
98             set_current_state(TASK_INTERRUPTIBLE);
99 #else
100             current->state = TASK_INTERRUPTIBLE;
101 #endif
102             if (drop_glock && haveGlock)
103                 AFS_GUNLOCK();
104             schedule_timeout(HZ);
105             if (drop_glock && haveGlock)
106                 AFS_GLOCK();
107 #ifdef set_current_state
108             set_current_state(TASK_RUNNING);
109 #else
110             current->state = TASK_RUNNING;
111 #endif
112             --max_retry;
113         }
114     }
115     if (new)
116         memset(MEMADDR(new), 0, asize);
117
118     return new;
119 }
120
121 static void
122 linux_free(void *p)
123 {
124
125     /* mask out the type information from the pointer and
126      *  use the appropriate free routine to free the chunk.
127      */
128     switch (MEMTYPE(p)) {
129     case KM_TYPE:
130         kfree(MEMADDR(p));
131         break;
132     case VM_TYPE:
133         vfree(MEMADDR(p));
134         break;
135     default:
136         printf("afs_osi_Free: Asked to free unknown type %d at 0x%lx\n",
137                (int)MEMTYPE(p), (unsigned long)MEMADDR(p));
138         break;
139     }
140
141 }
142
143 /* hash_chunk() receives a pointer to a chunk and hashes it to produce a
144  *            key that the hashtable can use. The key is obtained by 
145  *            right shifting out the 2 LSBs and then multiplying the
146  *            result by a constant no. and dividing it with a large prime.
147  */
148 #define HASH_CONST   32786
149 #define HASH_PRIME   79367
150 static unsigned
151 hash_chunk(void *p)
152 {
153     unsigned int key;
154
155     key = (unsigned int)(long)p >> 2;
156     key = (key * HASH_CONST) % HASH_PRIME;
157
158     return key;
159 }
160
161 /* hash_free() : Invoked by osi_linux_free_afs_memory(), thru 
162  *          afs_lhash_iter(), this function is called by the lhash
163  *          module for every entry in the hash table. hash_free
164  *          frees the memory associated with the entry as well
165  *          as returning the osi_linux_mem struct to its pool.
166  */
167 static void
168 hash_free(size_t index, unsigned key, void *data)
169 {
170     linux_free(((struct osi_linux_mem *)data)->chunk);
171     afs_atomlist_put(al_mem_pool, data);
172 }
173
174 /* hash_verify() is invoked by osi_linux_verify_alloced_memory() thru
175  *   afs_lhash_iter() and is called by the lhash module for every element
176  *   in the hash table. 
177  *  hash_verify() verifies (within limits) that the memory passed to it is
178  *  valid.
179  */
180 static void
181 hash_verify(size_t index, unsigned key, void *data)
182 {
183     struct osi_linux_mem *lmp = (struct osi_linux_mem *)data;
184     int memtype;
185
186     memtype = MEMTYPE(lmp->chunk);
187     if (memtype != KM_TYPE && memtype != VM_TYPE) {
188         printf
189             ("osi_linux_verify_alloced_memory: unknown type %d at 0x%lx, index=%lu\n",
190              (int)memtype, (unsigned long)lmp->chunk, (unsigned long)index);
191     }
192     afs_linux_hash_verify_count++;
193 }
194
195
196 /* local_free() : wrapper for vfree(), to deal with incompatible protoypes */
197 static void
198 local_free(void *p, size_t n)
199 {
200     vfree(p);
201 }
202
203 /* linux_alloc_init(): Initializes the kernel memory allocator. As part
204  *    of this process, it also initializes a pool of osi_linux_mem
205  *    structures as well as the hash table itself.
206  *  Return values:
207  *    0 - failure
208  *    1 - success
209  */
210 static int
211 linux_alloc_init(void)
212 {
213     /* initiate our pool of osi_linux_mem structs */
214     al_mem_pool =
215         afs_atomlist_create(sizeof(struct osi_linux_mem), sizeof(long) * 1024,
216                             (void *)vmalloc, local_free);
217     if (!al_mem_pool) {
218         printf("afs_osi_Alloc: Error in initialization(atomlist_create)\n");
219         return 0;
220     }
221
222     /* initialize the hash table to hold references to alloc'ed chunks */
223     lh_mem_htab = afs_lhash_create(hash_equal, (void *)vmalloc, local_free);
224     if (!lh_mem_htab) {
225         printf("afs_osi_Alloc: Error in initialization(lhash_create)\n");
226         return 0;
227     }
228
229     return 1;
230
231 }
232
233 /* hash_bucket_stat() : Counts the no. of elements in each bucket and
234  *   stores results in our bucket stats vector.
235  */
236 static unsigned int cur_bucket, cur_bucket_len;
237 static void
238 hash_bucket_stat(size_t index, unsigned key, void *data)
239 {
240     if (index == cur_bucket) {
241         /* while still on the same bucket, inc len & return */
242         cur_bucket_len++;
243         return;
244     } else {                    /* if we're on the next bucket, store the distribution */
245         if (cur_bucket_len < MAX_BUCKET_LEN)
246             afs_linux_hash_bucket_dist[cur_bucket_len]++;
247         else
248             printf
249                 ("afs_get_hash_stats: Warning! exceeded max bucket len %d\n",
250                  cur_bucket_len);
251         cur_bucket = index;
252         cur_bucket_len = 1;
253     }
254 }
255
256 /* get_hash_stats() : get hash table statistics */
257 static void
258 get_hash_stats(void)
259 {
260     int i;
261
262     afs_lhash_stat(lh_mem_htab, &afs_linux_lsb);
263
264     /* clear out the bucket stat vector */
265     for (i = 0; i < MAX_BUCKET_LEN; i++, afs_linux_hash_bucket_dist[i] = 0);
266     cur_bucket = cur_bucket_len = 00;
267
268     /* populate the bucket stat vector */
269     afs_lhash_iter(lh_mem_htab, hash_bucket_stat);
270 }
271
272 /************** Linux memory allocator interface functions **********/
273
274 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
275 DEFINE_MUTEX(afs_linux_alloc_sem);
276 #else
277 DECLARE_MUTEX(afs_linux_alloc_sem);
278 #endif
279
280 void *
281 osi_linux_alloc(unsigned int asize, int drop_glock)
282 {
283     void *new = NULL;
284     struct osi_linux_mem *lmem;
285
286     new = linux_alloc(asize, drop_glock);       /* get a chunk of memory of size asize */
287
288     if (!new) {
289         printf("afs_osi_Alloc: Can't vmalloc %d bytes.\n", asize);
290         return new;
291     }
292
293     mutex_lock(&afs_linux_alloc_sem);
294
295     /* allocator hasn't been initialized yet */
296     if (allocator_init == 0) {
297         if (linux_alloc_init() == 0) {
298             goto error;
299         }
300         allocator_init = 1;     /* initialization complete */
301     }
302
303     /* get an atom to store the pointer to the chunk */
304     lmem = (struct osi_linux_mem *)afs_atomlist_get(al_mem_pool);
305     if (!lmem) {
306         printf("afs_osi_Alloc: atomlist_get() failed.");
307         goto free_error;
308     }
309     /* store the chunk reference */
310     lmem->chunk = new;
311
312     /* hash in the chunk */
313     if (afs_lhash_enter(lh_mem_htab, hash_chunk(new), lmem) != 0) {
314         printf("afs_osi_Alloc: lhash_enter failed\n");
315         goto free_error;
316     }
317     afs_linux_cur_allocs++;     /* no. of current allocations */
318     afs_linux_total_allocs++;   /* total no. of allocations done so far */
319     if ((afs_linux_cur_allocs % STAT_INTERVAL) == 0) {
320         get_hash_stats();
321     }
322   error:
323     mutex_unlock(&afs_linux_alloc_sem);
324     return MEMADDR(new);
325
326   free_error:
327     if (new) {
328         linux_free(new);
329     }
330     new = NULL;
331     goto error;
332
333
334 }
335
336 /* osi_linux_free() - free chunk of memory passed to us.
337  */
338 void
339 osi_linux_free(void *addr)
340 {
341     struct osi_linux_mem lmem, *lmp;
342
343     mutex_lock(&afs_linux_alloc_sem);
344
345     lmem.chunk = addr;
346     /* remove this chunk from our hash table */
347     if ((lmp =
348          (struct osi_linux_mem *)afs_lhash_remove(lh_mem_htab,
349                                                   hash_chunk(addr), &lmem))) {
350         linux_free(lmp->chunk); /* this contains the piggybacked type info */
351         afs_atomlist_put(al_mem_pool, lmp);     /* return osi_linux_mem struct to pool */
352         afs_linux_cur_allocs--;
353     } else {
354         printf("osi_linux_free: failed to remove chunk from hashtable\n");
355         BUG();
356     }
357
358     mutex_unlock(&afs_linux_alloc_sem);
359 }
360
361 /* osi_linux_free_afs_memory() - free all chunks of memory allocated.
362  */
363 void
364 osi_linux_free_afs_memory(void)
365 {
366     mutex_lock(&afs_linux_alloc_sem);
367
368     if (allocator_init) {
369         /* iterate through all elements in the hash table and free both 
370          * the chunk and the atom associated with it.
371          */
372         afs_lhash_iter(lh_mem_htab, hash_free);
373
374         /*  free the atomlist. */
375         afs_atomlist_destroy(al_mem_pool);
376
377         /* free the hashlist. */
378         afs_lhash_destroy(lh_mem_htab);
379
380         /* change the state so that the allocator is now uninitialized. */
381         allocator_init = 0;
382     }
383     mutex_unlock(&afs_linux_alloc_sem);
384 }
385
386 /* osi_linux_verify_alloced_memory(): verify all chunks of alloced memory in
387  *          our hash table.
388  */
389 void
390 osi_linux_verify_alloced_memory()
391 {
392     mutex_lock(&afs_linux_alloc_sem);
393
394     /* count of times hash_verify was called. reset it to 0 before iteration */
395     afs_linux_hash_verify_count = 0;
396
397     /* iterate thru elements in the hash table */
398     afs_lhash_iter(lh_mem_htab, hash_verify);
399
400     if (afs_linux_hash_verify_count != afs_linux_cur_allocs) {
401         /* hmm, some pieces of memory are missing. */
402         printf
403             ("osi_linux_verify_alloced_memory: %d chunks of memory are not accounted for during verify!\n",
404              afs_linux_hash_verify_count - afs_linux_cur_allocs);
405     }
406
407     mutex_unlock(&afs_linux_alloc_sem);
408     return;
409 }
410
411 #ifdef AFS_PRIVATE_OSI_ALLOCSPACES
412
413 void
414 osi_FreeLargeSpace(void *p)
415 {
416     kfree(p);
417 }
418
419 void
420 osi_FreeSmallSpace(void *p)
421 {
422     kfree(p);
423 }
424
425 void *
426 osi_AllocLargeSpace(size_t size)
427 {
428     if (size > AFS_LRALLOCSIZ)
429         osi_Panic("osi_AllocLargeSpace: size=%d\n", (int) size);
430     return kmalloc(AFS_LRALLOCSIZ, GFP_NOFS);
431 }
432
433 void *
434 osi_AllocSmallSpace(size_t size)
435 {
436     if (size > AFS_SMALLOCSIZ)
437         osi_Panic("osi_AllocSmallS: size=%d\n", (int)size);
438     return kmalloc(AFS_SMALLOCSIZ, GFP_NOFS);
439 }
440 #endif /* AFS_PRIVATE_OSI_ALLOCSPACES */