[PATCH] fix broken lib/genalloc.c
[linux-2.6.git] / lib / genalloc.c
1 /*
2  * Basic general purpose allocator for managing special purpose memory
3  * not managed by the regular kmalloc/kfree interface.
4  * Uses for this includes on-device special memory, uncached memory
5  * etc.
6  *
7  * This code is based on the buddy allocator found in the sym53c8xx_2
8  * driver Copyright (C) 1999-2001  Gerard Roudier <groudier@free.fr>,
9  * and adapted for general purpose use.
10  *
11  * Copyright 2005 (C) Jes Sorensen <jes@trained-monkey.org>
12  *
13  * This source code is licensed under the GNU General Public License,
14  * Version 2.  See the file COPYING for more details.
15  */
16
17 #include <linux/module.h>
18 #include <linux/stddef.h>
19 #include <linux/kernel.h>
20 #include <linux/string.h>
21 #include <linux/slab.h>
22 #include <linux/init.h>
23 #include <linux/mm.h>
24 #include <linux/spinlock.h>
25 #include <linux/genalloc.h>
26
27 #include <asm/page.h>
28
29
30 struct gen_pool *gen_pool_create(int nr_chunks, int max_chunk_shift,
31                                  unsigned long (*fp)(struct gen_pool *),
32                                  unsigned long data)
33 {
34         struct gen_pool *poolp;
35         unsigned long tmp;
36         int i;
37
38         /*
39          * This is really an arbitrary limit, +10 is enough for
40          * IA64_GRANULE_SHIFT, aka 16MB. If anyone needs a large limit
41          * this can be increased without problems.
42          */
43         if ((max_chunk_shift > (PAGE_SHIFT + 10)) ||
44             ((max_chunk_shift < ALLOC_MIN_SHIFT) && max_chunk_shift))
45                 return NULL;
46
47         if (!max_chunk_shift)
48                 max_chunk_shift = PAGE_SHIFT;
49
50         poolp = kmalloc(sizeof(struct gen_pool), GFP_KERNEL);
51         if (!poolp)
52                 return NULL;
53         memset(poolp, 0, sizeof(struct gen_pool));
54         poolp->h = kmalloc(sizeof(struct gen_pool_link) *
55                            (max_chunk_shift - ALLOC_MIN_SHIFT + 1),
56                            GFP_KERNEL);
57         if (!poolp->h) {
58                 printk(KERN_WARNING "gen_pool_alloc() failed to allocate\n");
59                 kfree(poolp);
60                 return NULL;
61         }
62         memset(poolp->h, 0, sizeof(struct gen_pool_link) *
63                (max_chunk_shift - ALLOC_MIN_SHIFT + 1));
64
65         spin_lock_init(&poolp->lock);
66         poolp->get_new_chunk = fp;
67         poolp->max_chunk_shift = max_chunk_shift;
68         poolp->private = data;
69
70         for (i = 0; i < nr_chunks; i++) {
71                 tmp = poolp->get_new_chunk(poolp);
72                 printk(KERN_INFO "allocated %lx\n", tmp);
73                 if (!tmp)
74                         break;
75                 gen_pool_free(poolp, tmp, (1 << poolp->max_chunk_shift));
76         }
77
78         return poolp;
79 }
80 EXPORT_SYMBOL(gen_pool_create);
81
82
83 /*
84  *  Simple power of two buddy-like generic allocator.
85  *  Provides naturally aligned memory chunks.
86  */
87 unsigned long gen_pool_alloc(struct gen_pool *poolp, int size)
88 {
89         int j, i, s, max_chunk_size;
90         unsigned long a, flags;
91         struct gen_pool_link *h = poolp->h;
92
93         max_chunk_size = 1 << poolp->max_chunk_shift;
94
95         if (size > max_chunk_size)
96                 return 0;
97
98         size = max(size, 1 << ALLOC_MIN_SHIFT);
99         i = fls(size - 1);
100         s = 1 << i;
101         j = i -= ALLOC_MIN_SHIFT;
102
103         spin_lock_irqsave(&poolp->lock, flags);
104         while (!h[j].next) {
105                 if (s == max_chunk_size) {
106                         struct gen_pool_link *ptr;
107                         spin_unlock_irqrestore(&poolp->lock, flags);
108                         ptr = (struct gen_pool_link *)poolp->get_new_chunk(poolp);
109                         spin_lock_irqsave(&poolp->lock, flags);
110                         h[j].next = ptr;
111                         if (h[j].next)
112                                 h[j].next->next = NULL;
113                         break;
114                 }
115                 j++;
116                 s <<= 1;
117         }
118         a = (unsigned long) h[j].next;
119         if (a) {
120                 h[j].next = h[j].next->next;
121                 /*
122                  * This should be split into a seperate function doing
123                  * the chunk split in order to support custom
124                  * handling memory not physically accessible by host
125                  */
126                 while (j > i) {
127                         j -= 1;
128                         s >>= 1;
129                         h[j].next = (struct gen_pool_link *) (a + s);
130                         h[j].next->next = NULL;
131                 }
132         }
133         spin_unlock_irqrestore(&poolp->lock, flags);
134         return a;
135 }
136 EXPORT_SYMBOL(gen_pool_alloc);
137
138
139 /*
140  *  Counter-part of the generic allocator.
141  */
142 void gen_pool_free(struct gen_pool *poolp, unsigned long ptr, int size)
143 {
144         struct gen_pool_link *q;
145         struct gen_pool_link *h = poolp->h;
146         unsigned long a, b, flags;
147         int i, s, max_chunk_size;
148
149         max_chunk_size = 1 << poolp->max_chunk_shift;
150
151         if (size > max_chunk_size)
152                 return;
153
154         size = max(size, 1 << ALLOC_MIN_SHIFT);
155         i = fls(size - 1);
156         s = 1 << i;
157         i -= ALLOC_MIN_SHIFT;
158
159         a = ptr;
160
161         spin_lock_irqsave(&poolp->lock, flags);
162         while (1) {
163                 if (s == max_chunk_size) {
164                         ((struct gen_pool_link *)a)->next = h[i].next;
165                         h[i].next = (struct gen_pool_link *)a;
166                         break;
167                 }
168                 b = a ^ s;
169                 q = &h[i];
170
171                 while (q->next && q->next != (struct gen_pool_link *)b)
172                         q = q->next;
173
174                 if (!q->next) {
175                         ((struct gen_pool_link *)a)->next = h[i].next;
176                         h[i].next = (struct gen_pool_link *)a;
177                         break;
178                 }
179                 q->next = q->next->next;
180                 a = a & b;
181                 s <<= 1;
182                 i++;
183         }
184         spin_unlock_irqrestore(&poolp->lock, flags);
185 }
186 EXPORT_SYMBOL(gen_pool_free);