Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 9a86e2bad0b9fbf3290ae496da6dab9536dd6bf7

Authored by Ben Hutchings
Committed by Linus Torvalds
1 parent a069c266ae
Exists in master and in 7 other branches imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

lib: fix first line of kernel-doc for a few functions 

The function name must be followed by a space, hypen, space, and a short
description.

Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Showing 2 changed files with 6 additions and 6 deletions Inline Diff

include/linux/list.h
Diff comments   View file @ 9a86e2b
1 #ifndef _LINUX_LIST_H 1 #ifndef _LINUX_LIST_H
2 #define _LINUX_LIST_H 2 #define _LINUX_LIST_H
3 3
4 #include <linux/stddef.h> 4 #include <linux/stddef.h>
5 #include <linux/poison.h> 5 #include <linux/poison.h>
6 #include <linux/prefetch.h> 6 #include <linux/prefetch.h>
7 #include <asm/system.h> 7 #include <asm/system.h>
8 8
9 /* 9 /*
10 * Simple doubly linked list implementation. 10 * Simple doubly linked list implementation.
11 * 11 *
12 * Some of the internal functions ("__xxx") are useful when 12 * Some of the internal functions ("__xxx") are useful when
13 * manipulating whole lists rather than single entries, as 13 * manipulating whole lists rather than single entries, as
14 * sometimes we already know the next/prev entries and we can 14 * sometimes we already know the next/prev entries and we can
15 * generate better code by using them directly rather than 15 * generate better code by using them directly rather than
16 * using the generic single-entry routines. 16 * using the generic single-entry routines.
17 */ 17 */
18 18
19 struct list_head { 19 struct list_head {
20 struct list_head *next, *prev; 20 struct list_head *next, *prev;
21 }; 21 };
22 22
23 #define LIST_HEAD_INIT(name) { &(name), &(name) } 23 #define LIST_HEAD_INIT(name) { &(name), &(name) }
24 24
25 #define LIST_HEAD(name) \ 25 #define LIST_HEAD(name) \
26 struct list_head name = LIST_HEAD_INIT(name) 26 struct list_head name = LIST_HEAD_INIT(name)
27 27
28 static inline void INIT_LIST_HEAD(struct list_head *list) 28 static inline void INIT_LIST_HEAD(struct list_head *list)
29 { 29 {
30 list->next = list; 30 list->next = list;
31 list->prev = list; 31 list->prev = list;
32 } 32 }
33 33
34 /* 34 /*
35 * Insert a new entry between two known consecutive entries. 35 * Insert a new entry between two known consecutive entries.
36 * 36 *
37 * This is only for internal list manipulation where we know 37 * This is only for internal list manipulation where we know
38 * the prev/next entries already! 38 * the prev/next entries already!
39 */ 39 */
40 #ifndef CONFIG_DEBUG_LIST 40 #ifndef CONFIG_DEBUG_LIST
41 static inline void __list_add(struct list_head *new, 41 static inline void __list_add(struct list_head *new,
42 struct list_head *prev, 42 struct list_head *prev,
43 struct list_head *next) 43 struct list_head *next)
44 { 44 {
45 next->prev = new; 45 next->prev = new;
46 new->next = next; 46 new->next = next;
47 new->prev = prev; 47 new->prev = prev;
48 prev->next = new; 48 prev->next = new;
49 } 49 }
50 #else 50 #else
51 extern void __list_add(struct list_head *new, 51 extern void __list_add(struct list_head *new,
52 struct list_head *prev, 52 struct list_head *prev,
53 struct list_head *next); 53 struct list_head *next);
54 #endif 54 #endif
55 55
56 /** 56 /**
57 * list_add - add a new entry 57 * list_add - add a new entry
58 * @new: new entry to be added 58 * @new: new entry to be added
59 * @head: list head to add it after 59 * @head: list head to add it after
60 * 60 *
61 * Insert a new entry after the specified head. 61 * Insert a new entry after the specified head.
62 * This is good for implementing stacks. 62 * This is good for implementing stacks.
63 */ 63 */
64 static inline void list_add(struct list_head *new, struct list_head *head) 64 static inline void list_add(struct list_head *new, struct list_head *head)
65 { 65 {
66 __list_add(new, head, head->next); 66 __list_add(new, head, head->next);
67 } 67 }
68 68
69 69
70 /** 70 /**
71 * list_add_tail - add a new entry 71 * list_add_tail - add a new entry
72 * @new: new entry to be added 72 * @new: new entry to be added
73 * @head: list head to add it before 73 * @head: list head to add it before
74 * 74 *
75 * Insert a new entry before the specified head. 75 * Insert a new entry before the specified head.
76 * This is useful for implementing queues. 76 * This is useful for implementing queues.
77 */ 77 */
78 static inline void list_add_tail(struct list_head *new, struct list_head *head) 78 static inline void list_add_tail(struct list_head *new, struct list_head *head)
79 { 79 {
80 __list_add(new, head->prev, head); 80 __list_add(new, head->prev, head);
81 } 81 }
82 82
83 /* 83 /*
84 * Delete a list entry by making the prev/next entries 84 * Delete a list entry by making the prev/next entries
85 * point to each other. 85 * point to each other.
86 * 86 *
87 * This is only for internal list manipulation where we know 87 * This is only for internal list manipulation where we know
88 * the prev/next entries already! 88 * the prev/next entries already!
89 */ 89 */
90 static inline void __list_del(struct list_head * prev, struct list_head * next) 90 static inline void __list_del(struct list_head * prev, struct list_head * next)
91 { 91 {
92 next->prev = prev; 92 next->prev = prev;
93 prev->next = next; 93 prev->next = next;
94 } 94 }
95 95
96 /** 96 /**
97 * list_del - deletes entry from list. 97 * list_del - deletes entry from list.
98 * @entry: the element to delete from the list. 98 * @entry: the element to delete from the list.
99 * Note: list_empty() on entry does not return true after this, the entry is 99 * Note: list_empty() on entry does not return true after this, the entry is
100 * in an undefined state. 100 * in an undefined state.
101 */ 101 */
102 #ifndef CONFIG_DEBUG_LIST 102 #ifndef CONFIG_DEBUG_LIST
103 static inline void list_del(struct list_head *entry) 103 static inline void list_del(struct list_head *entry)
104 { 104 {
105 __list_del(entry->prev, entry->next); 105 __list_del(entry->prev, entry->next);
106 entry->next = LIST_POISON1; 106 entry->next = LIST_POISON1;
107 entry->prev = LIST_POISON2; 107 entry->prev = LIST_POISON2;
108 } 108 }
109 #else 109 #else
110 extern void list_del(struct list_head *entry); 110 extern void list_del(struct list_head *entry);
111 #endif 111 #endif
112 112
113 /** 113 /**
114 * list_replace - replace old entry by new one 114 * list_replace - replace old entry by new one
115 * @old : the element to be replaced 115 * @old : the element to be replaced
116 * @new : the new element to insert 116 * @new : the new element to insert
117 * 117 *
118 * If @old was empty, it will be overwritten. 118 * If @old was empty, it will be overwritten.
119 */ 119 */
120 static inline void list_replace(struct list_head *old, 120 static inline void list_replace(struct list_head *old,
121 struct list_head *new) 121 struct list_head *new)
122 { 122 {
123 new->next = old->next; 123 new->next = old->next;
124 new->next->prev = new; 124 new->next->prev = new;
125 new->prev = old->prev; 125 new->prev = old->prev;
126 new->prev->next = new; 126 new->prev->next = new;
127 } 127 }
128 128
129 static inline void list_replace_init(struct list_head *old, 129 static inline void list_replace_init(struct list_head *old,
130 struct list_head *new) 130 struct list_head *new)
131 { 131 {
132 list_replace(old, new); 132 list_replace(old, new);
133 INIT_LIST_HEAD(old); 133 INIT_LIST_HEAD(old);
134 } 134 }
135 135
136 /** 136 /**
137 * list_del_init - deletes entry from list and reinitialize it. 137 * list_del_init - deletes entry from list and reinitialize it.
138 * @entry: the element to delete from the list. 138 * @entry: the element to delete from the list.
139 */ 139 */
140 static inline void list_del_init(struct list_head *entry) 140 static inline void list_del_init(struct list_head *entry)
141 { 141 {
142 __list_del(entry->prev, entry->next); 142 __list_del(entry->prev, entry->next);
143 INIT_LIST_HEAD(entry); 143 INIT_LIST_HEAD(entry);
144 } 144 }
145 145
146 /** 146 /**
147 * list_move - delete from one list and add as another's head 147 * list_move - delete from one list and add as another's head
148 * @list: the entry to move 148 * @list: the entry to move
149 * @head: the head that will precede our entry 149 * @head: the head that will precede our entry
150 */ 150 */
151 static inline void list_move(struct list_head *list, struct list_head *head) 151 static inline void list_move(struct list_head *list, struct list_head *head)
152 { 152 {
153 __list_del(list->prev, list->next); 153 __list_del(list->prev, list->next);
154 list_add(list, head); 154 list_add(list, head);
155 } 155 }
156 156
157 /** 157 /**
158 * list_move_tail - delete from one list and add as another's tail 158 * list_move_tail - delete from one list and add as another's tail
159 * @list: the entry to move 159 * @list: the entry to move
160 * @head: the head that will follow our entry 160 * @head: the head that will follow our entry
161 */ 161 */
162 static inline void list_move_tail(struct list_head *list, 162 static inline void list_move_tail(struct list_head *list,
163 struct list_head *head) 163 struct list_head *head)
164 { 164 {
165 __list_del(list->prev, list->next); 165 __list_del(list->prev, list->next);
166 list_add_tail(list, head); 166 list_add_tail(list, head);
167 } 167 }
168 168
169 /** 169 /**
170 * list_is_last - tests whether @list is the last entry in list @head 170 * list_is_last - tests whether @list is the last entry in list @head
171 * @list: the entry to test 171 * @list: the entry to test
172 * @head: the head of the list 172 * @head: the head of the list
173 */ 173 */
174 static inline int list_is_last(const struct list_head *list, 174 static inline int list_is_last(const struct list_head *list,
175 const struct list_head *head) 175 const struct list_head *head)
176 { 176 {
177 return list->next == head; 177 return list->next == head;
178 } 178 }
179 179
180 /** 180 /**
181 * list_empty - tests whether a list is empty 181 * list_empty - tests whether a list is empty
182 * @head: the list to test. 182 * @head: the list to test.
183 */ 183 */
184 static inline int list_empty(const struct list_head *head) 184 static inline int list_empty(const struct list_head *head)
185 { 185 {
186 return head->next == head; 186 return head->next == head;
187 } 187 }
188 188
189 /** 189 /**
190 * list_empty_careful - tests whether a list is empty and not being modified 190 * list_empty_careful - tests whether a list is empty and not being modified
191 * @head: the list to test 191 * @head: the list to test
192 * 192 *
193 * Description: 193 * Description:
194 * tests whether a list is empty _and_ checks that no other CPU might be 194 * tests whether a list is empty _and_ checks that no other CPU might be
195 * in the process of modifying either member (next or prev) 195 * in the process of modifying either member (next or prev)
196 * 196 *
197 * NOTE: using list_empty_careful() without synchronization 197 * NOTE: using list_empty_careful() without synchronization
198 * can only be safe if the only activity that can happen 198 * can only be safe if the only activity that can happen
199 * to the list entry is list_del_init(). Eg. it cannot be used 199 * to the list entry is list_del_init(). Eg. it cannot be used
200 * if another CPU could re-list_add() it. 200 * if another CPU could re-list_add() it.
201 */ 201 */
202 static inline int list_empty_careful(const struct list_head *head) 202 static inline int list_empty_careful(const struct list_head *head)
203 { 203 {
204 struct list_head *next = head->next; 204 struct list_head *next = head->next;
205 return (next == head) && (next == head->prev); 205 return (next == head) && (next == head->prev);
206 } 206 }
207 207
208 /** 208 /**
209 * list_rotate_left - rotate the list to the left 209 * list_rotate_left - rotate the list to the left
210 * @head: the head of the list 210 * @head: the head of the list
211 */ 211 */
212 static inline void list_rotate_left(struct list_head *head) 212 static inline void list_rotate_left(struct list_head *head)
213 { 213 {
214 struct list_head *first; 214 struct list_head *first;
215 215
216 if (!list_empty(head)) { 216 if (!list_empty(head)) {
217 first = head->next; 217 first = head->next;
218 list_move_tail(first, head); 218 list_move_tail(first, head);
219 } 219 }
220 } 220 }
221 221
222 /** 222 /**
223 * list_is_singular - tests whether a list has just one entry. 223 * list_is_singular - tests whether a list has just one entry.
224 * @head: the list to test. 224 * @head: the list to test.
225 */ 225 */
226 static inline int list_is_singular(const struct list_head *head) 226 static inline int list_is_singular(const struct list_head *head)
227 { 227 {
228 return !list_empty(head) && (head->next == head->prev); 228 return !list_empty(head) && (head->next == head->prev);
229 } 229 }
230 230
231 static inline void __list_cut_position(struct list_head *list, 231 static inline void __list_cut_position(struct list_head *list,
232 struct list_head *head, struct list_head *entry) 232 struct list_head *head, struct list_head *entry)
233 { 233 {
234 struct list_head *new_first = entry->next; 234 struct list_head *new_first = entry->next;
235 list->next = head->next; 235 list->next = head->next;
236 list->next->prev = list; 236 list->next->prev = list;
237 list->prev = entry; 237 list->prev = entry;
238 entry->next = list; 238 entry->next = list;
239 head->next = new_first; 239 head->next = new_first;
240 new_first->prev = head; 240 new_first->prev = head;
241 } 241 }
242 242
243 /** 243 /**
244 * list_cut_position - cut a list into two 244 * list_cut_position - cut a list into two
245 * @list: a new list to add all removed entries 245 * @list: a new list to add all removed entries
246 * @head: a list with entries 246 * @head: a list with entries
247 * @entry: an entry within head, could be the head itself 247 * @entry: an entry within head, could be the head itself
248 * and if so we won't cut the list 248 * and if so we won't cut the list
249 * 249 *
250 * This helper moves the initial part of @head, up to and 250 * This helper moves the initial part of @head, up to and
251 * including @entry, from @head to @list. You should 251 * including @entry, from @head to @list. You should
252 * pass on @entry an element you know is on @head. @list 252 * pass on @entry an element you know is on @head. @list
253 * should be an empty list or a list you do not care about 253 * should be an empty list or a list you do not care about
254 * losing its data. 254 * losing its data.
255 * 255 *
256 */ 256 */
257 static inline void list_cut_position(struct list_head *list, 257 static inline void list_cut_position(struct list_head *list,
258 struct list_head *head, struct list_head *entry) 258 struct list_head *head, struct list_head *entry)
259 { 259 {
260 if (list_empty(head)) 260 if (list_empty(head))
261 return; 261 return;
262 if (list_is_singular(head) && 262 if (list_is_singular(head) &&
263 (head->next != entry && head != entry)) 263 (head->next != entry && head != entry))
264 return; 264 return;
265 if (entry == head) 265 if (entry == head)
266 INIT_LIST_HEAD(list); 266 INIT_LIST_HEAD(list);
267 else 267 else
268 __list_cut_position(list, head, entry); 268 __list_cut_position(list, head, entry);
269 } 269 }
270 270
271 static inline void __list_splice(const struct list_head *list, 271 static inline void __list_splice(const struct list_head *list,
272 struct list_head *prev, 272 struct list_head *prev,
273 struct list_head *next) 273 struct list_head *next)
274 { 274 {
275 struct list_head *first = list->next; 275 struct list_head *first = list->next;
276 struct list_head *last = list->prev; 276 struct list_head *last = list->prev;
277 277
278 first->prev = prev; 278 first->prev = prev;
279 prev->next = first; 279 prev->next = first;
280 280
281 last->next = next; 281 last->next = next;
282 next->prev = last; 282 next->prev = last;
283 } 283 }
284 284
285 /** 285 /**
286 * list_splice - join two lists, this is designed for stacks 286 * list_splice - join two lists, this is designed for stacks
287 * @list: the new list to add. 287 * @list: the new list to add.
288 * @head: the place to add it in the first list. 288 * @head: the place to add it in the first list.
289 */ 289 */
290 static inline void list_splice(const struct list_head *list, 290 static inline void list_splice(const struct list_head *list,
291 struct list_head *head) 291 struct list_head *head)
292 { 292 {
293 if (!list_empty(list)) 293 if (!list_empty(list))
294 __list_splice(list, head, head->next); 294 __list_splice(list, head, head->next);
295 } 295 }
296 296
297 /** 297 /**
298 * list_splice_tail - join two lists, each list being a queue 298 * list_splice_tail - join two lists, each list being a queue
299 * @list: the new list to add. 299 * @list: the new list to add.
300 * @head: the place to add it in the first list. 300 * @head: the place to add it in the first list.
301 */ 301 */
302 static inline void list_splice_tail(struct list_head *list, 302 static inline void list_splice_tail(struct list_head *list,
303 struct list_head *head) 303 struct list_head *head)
304 { 304 {
305 if (!list_empty(list)) 305 if (!list_empty(list))
306 __list_splice(list, head->prev, head); 306 __list_splice(list, head->prev, head);
307 } 307 }
308 308
309 /** 309 /**
310 * list_splice_init - join two lists and reinitialise the emptied list. 310 * list_splice_init - join two lists and reinitialise the emptied list.
311 * @list: the new list to add. 311 * @list: the new list to add.
312 * @head: the place to add it in the first list. 312 * @head: the place to add it in the first list.
313 * 313 *
314 * The list at @list is reinitialised 314 * The list at @list is reinitialised
315 */ 315 */
316 static inline void list_splice_init(struct list_head *list, 316 static inline void list_splice_init(struct list_head *list,
317 struct list_head *head) 317 struct list_head *head)
318 { 318 {
319 if (!list_empty(list)) { 319 if (!list_empty(list)) {
320 __list_splice(list, head, head->next); 320 __list_splice(list, head, head->next);
321 INIT_LIST_HEAD(list); 321 INIT_LIST_HEAD(list);
322 } 322 }
323 } 323 }
324 324
325 /** 325 /**
326 * list_splice_tail_init - join two lists and reinitialise the emptied list 326 * list_splice_tail_init - join two lists and reinitialise the emptied list
327 * @list: the new list to add. 327 * @list: the new list to add.
328 * @head: the place to add it in the first list. 328 * @head: the place to add it in the first list.
329 * 329 *
330 * Each of the lists is a queue. 330 * Each of the lists is a queue.
331 * The list at @list is reinitialised 331 * The list at @list is reinitialised
332 */ 332 */
333 static inline void list_splice_tail_init(struct list_head *list, 333 static inline void list_splice_tail_init(struct list_head *list,
334 struct list_head *head) 334 struct list_head *head)
335 { 335 {
336 if (!list_empty(list)) { 336 if (!list_empty(list)) {
337 __list_splice(list, head->prev, head); 337 __list_splice(list, head->prev, head);
338 INIT_LIST_HEAD(list); 338 INIT_LIST_HEAD(list);
339 } 339 }
340 } 340 }
341 341
342 /** 342 /**
343 * list_entry - get the struct for this entry 343 * list_entry - get the struct for this entry
344 * @ptr: the &struct list_head pointer. 344 * @ptr: the &struct list_head pointer.
345 * @type: the type of the struct this is embedded in. 345 * @type: the type of the struct this is embedded in.
346 * @member: the name of the list_struct within the struct. 346 * @member: the name of the list_struct within the struct.
347 */ 347 */
348 #define list_entry(ptr, type, member) \ 348 #define list_entry(ptr, type, member) \
349 container_of(ptr, type, member) 349 container_of(ptr, type, member)
350 350
351 /** 351 /**
352 * list_first_entry - get the first element from a list 352 * list_first_entry - get the first element from a list
353 * @ptr: the list head to take the element from. 353 * @ptr: the list head to take the element from.
354 * @type: the type of the struct this is embedded in. 354 * @type: the type of the struct this is embedded in.
355 * @member: the name of the list_struct within the struct. 355 * @member: the name of the list_struct within the struct.
356 * 356 *
357 * Note, that list is expected to be not empty. 357 * Note, that list is expected to be not empty.
358 */ 358 */
359 #define list_first_entry(ptr, type, member) \ 359 #define list_first_entry(ptr, type, member) \
360 list_entry((ptr)->next, type, member) 360 list_entry((ptr)->next, type, member)
361 361
362 /** 362 /**
363 * list_for_each - iterate over a list 363 * list_for_each - iterate over a list
364 * @pos: the &struct list_head to use as a loop cursor. 364 * @pos: the &struct list_head to use as a loop cursor.
365 * @head: the head for your list. 365 * @head: the head for your list.
366 */ 366 */
367 #define list_for_each(pos, head) \ 367 #define list_for_each(pos, head) \
368 for (pos = (head)->next; prefetch(pos->next), pos != (head); \ 368 for (pos = (head)->next; prefetch(pos->next), pos != (head); \
369 pos = pos->next) 369 pos = pos->next)
370 370
371 /** 371 /**
372 * __list_for_each - iterate over a list 372 * __list_for_each - iterate over a list
373 * @pos: the &struct list_head to use as a loop cursor. 373 * @pos: the &struct list_head to use as a loop cursor.
374 * @head: the head for your list. 374 * @head: the head for your list.
375 * 375 *
376 * This variant differs from list_for_each() in that it's the 376 * This variant differs from list_for_each() in that it's the
377 * simplest possible list iteration code, no prefetching is done. 377 * simplest possible list iteration code, no prefetching is done.
378 * Use this for code that knows the list to be very short (empty 378 * Use this for code that knows the list to be very short (empty
379 * or 1 entry) most of the time. 379 * or 1 entry) most of the time.
380 */ 380 */
381 #define __list_for_each(pos, head) \ 381 #define __list_for_each(pos, head) \
382 for (pos = (head)->next; pos != (head); pos = pos->next) 382 for (pos = (head)->next; pos != (head); pos = pos->next)
383 383
384 /** 384 /**
385 * list_for_each_prev - iterate over a list backwards 385 * list_for_each_prev - iterate over a list backwards
386 * @pos: the &struct list_head to use as a loop cursor. 386 * @pos: the &struct list_head to use as a loop cursor.
387 * @head: the head for your list. 387 * @head: the head for your list.
388 */ 388 */
389 #define list_for_each_prev(pos, head) \ 389 #define list_for_each_prev(pos, head) \
390 for (pos = (head)->prev; prefetch(pos->prev), pos != (head); \ 390 for (pos = (head)->prev; prefetch(pos->prev), pos != (head); \
391 pos = pos->prev) 391 pos = pos->prev)
392 392
393 /** 393 /**
394 * list_for_each_safe - iterate over a list safe against removal of list entry 394 * list_for_each_safe - iterate over a list safe against removal of list entry
395 * @pos: the &struct list_head to use as a loop cursor. 395 * @pos: the &struct list_head to use as a loop cursor.
396 * @n: another &struct list_head to use as temporary storage 396 * @n: another &struct list_head to use as temporary storage
397 * @head: the head for your list. 397 * @head: the head for your list.
398 */ 398 */
399 #define list_for_each_safe(pos, n, head) \ 399 #define list_for_each_safe(pos, n, head) \
400 for (pos = (head)->next, n = pos->next; pos != (head); \ 400 for (pos = (head)->next, n = pos->next; pos != (head); \
401 pos = n, n = pos->next) 401 pos = n, n = pos->next)
402 402
403 /** 403 /**
404 * list_for_each_prev_safe - iterate over a list backwards safe against removal of list entry 404 * list_for_each_prev_safe - iterate over a list backwards safe against removal of list entry
405 * @pos: the &struct list_head to use as a loop cursor. 405 * @pos: the &struct list_head to use as a loop cursor.
406 * @n: another &struct list_head to use as temporary storage 406 * @n: another &struct list_head to use as temporary storage
407 * @head: the head for your list. 407 * @head: the head for your list.
408 */ 408 */
409 #define list_for_each_prev_safe(pos, n, head) \ 409 #define list_for_each_prev_safe(pos, n, head) \
410 for (pos = (head)->prev, n = pos->prev; \ 410 for (pos = (head)->prev, n = pos->prev; \
411 prefetch(pos->prev), pos != (head); \ 411 prefetch(pos->prev), pos != (head); \
412 pos = n, n = pos->prev) 412 pos = n, n = pos->prev)
413 413
414 /** 414 /**
415 * list_for_each_entry - iterate over list of given type 415 * list_for_each_entry - iterate over list of given type
416 * @pos: the type * to use as a loop cursor. 416 * @pos: the type * to use as a loop cursor.
417 * @head: the head for your list. 417 * @head: the head for your list.
418 * @member: the name of the list_struct within the struct. 418 * @member: the name of the list_struct within the struct.
419 */ 419 */
420 #define list_for_each_entry(pos, head, member) \ 420 #define list_for_each_entry(pos, head, member) \
421 for (pos = list_entry((head)->next, typeof(*pos), member); \ 421 for (pos = list_entry((head)->next, typeof(*pos), member); \
422 prefetch(pos->member.next), &pos->member != (head); \ 422 prefetch(pos->member.next), &pos->member != (head); \
423 pos = list_entry(pos->member.next, typeof(*pos), member)) 423 pos = list_entry(pos->member.next, typeof(*pos), member))
424 424
425 /** 425 /**
426 * list_for_each_entry_reverse - iterate backwards over list of given type. 426 * list_for_each_entry_reverse - iterate backwards over list of given type.
427 * @pos: the type * to use as a loop cursor. 427 * @pos: the type * to use as a loop cursor.
428 * @head: the head for your list. 428 * @head: the head for your list.
429 * @member: the name of the list_struct within the struct. 429 * @member: the name of the list_struct within the struct.
430 */ 430 */
431 #define list_for_each_entry_reverse(pos, head, member) \ 431 #define list_for_each_entry_reverse(pos, head, member) \
432 for (pos = list_entry((head)->prev, typeof(*pos), member); \ 432 for (pos = list_entry((head)->prev, typeof(*pos), member); \
433 prefetch(pos->member.prev), &pos->member != (head); \ 433 prefetch(pos->member.prev), &pos->member != (head); \
434 pos = list_entry(pos->member.prev, typeof(*pos), member)) 434 pos = list_entry(pos->member.prev, typeof(*pos), member))
435 435
436 /** 436 /**
437 * list_prepare_entry - prepare a pos entry for use in list_for_each_entry_continue() 437 * list_prepare_entry - prepare a pos entry for use in list_for_each_entry_continue()
438 * @pos: the type * to use as a start point 438 * @pos: the type * to use as a start point
439 * @head: the head of the list 439 * @head: the head of the list
440 * @member: the name of the list_struct within the struct. 440 * @member: the name of the list_struct within the struct.
441 * 441 *
442 * Prepares a pos entry for use as a start point in list_for_each_entry_continue(). 442 * Prepares a pos entry for use as a start point in list_for_each_entry_continue().
443 */ 443 */
444 #define list_prepare_entry(pos, head, member) \ 444 #define list_prepare_entry(pos, head, member) \
445 ((pos) ? : list_entry(head, typeof(*pos), member)) 445 ((pos) ? : list_entry(head, typeof(*pos), member))
446 446
447 /** 447 /**
448 * list_for_each_entry_continue - continue iteration over list of given type 448 * list_for_each_entry_continue - continue iteration over list of given type
449 * @pos: the type * to use as a loop cursor. 449 * @pos: the type * to use as a loop cursor.
450 * @head: the head for your list. 450 * @head: the head for your list.
451 * @member: the name of the list_struct within the struct. 451 * @member: the name of the list_struct within the struct.
452 * 452 *
453 * Continue to iterate over list of given type, continuing after 453 * Continue to iterate over list of given type, continuing after
454 * the current position. 454 * the current position.
455 */ 455 */
456 #define list_for_each_entry_continue(pos, head, member) \ 456 #define list_for_each_entry_continue(pos, head, member) \
457 for (pos = list_entry(pos->member.next, typeof(*pos), member); \ 457 for (pos = list_entry(pos->member.next, typeof(*pos), member); \
458 prefetch(pos->member.next), &pos->member != (head); \ 458 prefetch(pos->member.next), &pos->member != (head); \
459 pos = list_entry(pos->member.next, typeof(*pos), member)) 459 pos = list_entry(pos->member.next, typeof(*pos), member))
460 460
461 /** 461 /**
462 * list_for_each_entry_continue_reverse - iterate backwards from the given point 462 * list_for_each_entry_continue_reverse - iterate backwards from the given point
463 * @pos: the type * to use as a loop cursor. 463 * @pos: the type * to use as a loop cursor.
464 * @head: the head for your list. 464 * @head: the head for your list.
465 * @member: the name of the list_struct within the struct. 465 * @member: the name of the list_struct within the struct.
466 * 466 *
467 * Start to iterate over list of given type backwards, continuing after 467 * Start to iterate over list of given type backwards, continuing after
468 * the current position. 468 * the current position.
469 */ 469 */
470 #define list_for_each_entry_continue_reverse(pos, head, member) \ 470 #define list_for_each_entry_continue_reverse(pos, head, member) \
471 for (pos = list_entry(pos->member.prev, typeof(*pos), member); \ 471 for (pos = list_entry(pos->member.prev, typeof(*pos), member); \
472 prefetch(pos->member.prev), &pos->member != (head); \ 472 prefetch(pos->member.prev), &pos->member != (head); \
473 pos = list_entry(pos->member.prev, typeof(*pos), member)) 473 pos = list_entry(pos->member.prev, typeof(*pos), member))
474 474
475 /** 475 /**
476 * list_for_each_entry_from - iterate over list of given type from the current point 476 * list_for_each_entry_from - iterate over list of given type from the current point
477 * @pos: the type * to use as a loop cursor. 477 * @pos: the type * to use as a loop cursor.
478 * @head: the head for your list. 478 * @head: the head for your list.
479 * @member: the name of the list_struct within the struct. 479 * @member: the name of the list_struct within the struct.
480 * 480 *
481 * Iterate over list of given type, continuing from current position. 481 * Iterate over list of given type, continuing from current position.
482 */ 482 */
483 #define list_for_each_entry_from(pos, head, member) \ 483 #define list_for_each_entry_from(pos, head, member) \
484 for (; prefetch(pos->member.next), &pos->member != (head); \ 484 for (; prefetch(pos->member.next), &pos->member != (head); \
485 pos = list_entry(pos->member.next, typeof(*pos), member)) 485 pos = list_entry(pos->member.next, typeof(*pos), member))
486 486
487 /** 487 /**
488 * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry 488 * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
489 * @pos: the type * to use as a loop cursor. 489 * @pos: the type * to use as a loop cursor.
490 * @n: another type * to use as temporary storage 490 * @n: another type * to use as temporary storage
491 * @head: the head for your list. 491 * @head: the head for your list.
492 * @member: the name of the list_struct within the struct. 492 * @member: the name of the list_struct within the struct.
493 */ 493 */
494 #define list_for_each_entry_safe(pos, n, head, member) \ 494 #define list_for_each_entry_safe(pos, n, head, member) \
495 for (pos = list_entry((head)->next, typeof(*pos), member), \ 495 for (pos = list_entry((head)->next, typeof(*pos), member), \
496 n = list_entry(pos->member.next, typeof(*pos), member); \ 496 n = list_entry(pos->member.next, typeof(*pos), member); \
497 &pos->member != (head); \ 497 &pos->member != (head); \
498 pos = n, n = list_entry(n->member.next, typeof(*n), member)) 498 pos = n, n = list_entry(n->member.next, typeof(*n), member))
499 499
500 /** 500 /**
501 * list_for_each_entry_safe_continue 501 * list_for_each_entry_safe_continue - continue list iteration safe against removal
502 * @pos: the type * to use as a loop cursor. 502 * @pos: the type * to use as a loop cursor.
503 * @n: another type * to use as temporary storage 503 * @n: another type * to use as temporary storage
504 * @head: the head for your list. 504 * @head: the head for your list.
505 * @member: the name of the list_struct within the struct. 505 * @member: the name of the list_struct within the struct.
506 * 506 *
507 * Iterate over list of given type, continuing after current point, 507 * Iterate over list of given type, continuing after current point,
508 * safe against removal of list entry. 508 * safe against removal of list entry.
509 */ 509 */
510 #define list_for_each_entry_safe_continue(pos, n, head, member) \ 510 #define list_for_each_entry_safe_continue(pos, n, head, member) \
511 for (pos = list_entry(pos->member.next, typeof(*pos), member), \ 511 for (pos = list_entry(pos->member.next, typeof(*pos), member), \
512 n = list_entry(pos->member.next, typeof(*pos), member); \ 512 n = list_entry(pos->member.next, typeof(*pos), member); \
513 &pos->member != (head); \ 513 &pos->member != (head); \
514 pos = n, n = list_entry(n->member.next, typeof(*n), member)) 514 pos = n, n = list_entry(n->member.next, typeof(*n), member))
515 515
516 /** 516 /**
517 * list_for_each_entry_safe_from 517 * list_for_each_entry_safe_from - iterate over list from current point safe against removal
518 * @pos: the type * to use as a loop cursor. 518 * @pos: the type * to use as a loop cursor.
519 * @n: another type * to use as temporary storage 519 * @n: another type * to use as temporary storage
520 * @head: the head for your list. 520 * @head: the head for your list.
521 * @member: the name of the list_struct within the struct. 521 * @member: the name of the list_struct within the struct.
522 * 522 *
523 * Iterate over list of given type from current point, safe against 523 * Iterate over list of given type from current point, safe against
524 * removal of list entry. 524 * removal of list entry.
525 */ 525 */
526 #define list_for_each_entry_safe_from(pos, n, head, member) \ 526 #define list_for_each_entry_safe_from(pos, n, head, member) \
527 for (n = list_entry(pos->member.next, typeof(*pos), member); \ 527 for (n = list_entry(pos->member.next, typeof(*pos), member); \
528 &pos->member != (head); \ 528 &pos->member != (head); \
529 pos = n, n = list_entry(n->member.next, typeof(*n), member)) 529 pos = n, n = list_entry(n->member.next, typeof(*n), member))
530 530
531 /** 531 /**
532 * list_for_each_entry_safe_reverse 532 * list_for_each_entry_safe_reverse - iterate backwards over list safe against removal
533 * @pos: the type * to use as a loop cursor. 533 * @pos: the type * to use as a loop cursor.
534 * @n: another type * to use as temporary storage 534 * @n: another type * to use as temporary storage
535 * @head: the head for your list. 535 * @head: the head for your list.
536 * @member: the name of the list_struct within the struct. 536 * @member: the name of the list_struct within the struct.
537 * 537 *
538 * Iterate backwards over list of given type, safe against removal 538 * Iterate backwards over list of given type, safe against removal
539 * of list entry. 539 * of list entry.
540 */ 540 */
541 #define list_for_each_entry_safe_reverse(pos, n, head, member) \ 541 #define list_for_each_entry_safe_reverse(pos, n, head, member) \
542 for (pos = list_entry((head)->prev, typeof(*pos), member), \ 542 for (pos = list_entry((head)->prev, typeof(*pos), member), \
543 n = list_entry(pos->member.prev, typeof(*pos), member); \ 543 n = list_entry(pos->member.prev, typeof(*pos), member); \
544 &pos->member != (head); \ 544 &pos->member != (head); \
545 pos = n, n = list_entry(n->member.prev, typeof(*n), member)) 545 pos = n, n = list_entry(n->member.prev, typeof(*n), member))
546 546
547 /* 547 /*
548 * Double linked lists with a single pointer list head. 548 * Double linked lists with a single pointer list head.
549 * Mostly useful for hash tables where the two pointer list head is 549 * Mostly useful for hash tables where the two pointer list head is
550 * too wasteful. 550 * too wasteful.
551 * You lose the ability to access the tail in O(1). 551 * You lose the ability to access the tail in O(1).
552 */ 552 */
553 553
554 struct hlist_head { 554 struct hlist_head {
555 struct hlist_node *first; 555 struct hlist_node *first;
556 }; 556 };
557 557
558 struct hlist_node { 558 struct hlist_node {
559 struct hlist_node *next, **pprev; 559 struct hlist_node *next, **pprev;
560 }; 560 };
561 561
562 #define HLIST_HEAD_INIT { .first = NULL } 562 #define HLIST_HEAD_INIT { .first = NULL }
563 #define HLIST_HEAD(name) struct hlist_head name = { .first = NULL } 563 #define HLIST_HEAD(name) struct hlist_head name = { .first = NULL }
564 #define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL) 564 #define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)
565 static inline void INIT_HLIST_NODE(struct hlist_node *h) 565 static inline void INIT_HLIST_NODE(struct hlist_node *h)
566 { 566 {
567 h->next = NULL; 567 h->next = NULL;
568 h->pprev = NULL; 568 h->pprev = NULL;
569 } 569 }
570 570
571 static inline int hlist_unhashed(const struct hlist_node *h) 571 static inline int hlist_unhashed(const struct hlist_node *h)
572 { 572 {
573 return !h->pprev; 573 return !h->pprev;
574 } 574 }
575 575
576 static inline int hlist_empty(const struct hlist_head *h) 576 static inline int hlist_empty(const struct hlist_head *h)
577 { 577 {
578 return !h->first; 578 return !h->first;
579 } 579 }
580 580
581 static inline void __hlist_del(struct hlist_node *n) 581 static inline void __hlist_del(struct hlist_node *n)
582 { 582 {
583 struct hlist_node *next = n->next; 583 struct hlist_node *next = n->next;
584 struct hlist_node **pprev = n->pprev; 584 struct hlist_node **pprev = n->pprev;
585 *pprev = next; 585 *pprev = next;
586 if (next) 586 if (next)
587 next->pprev = pprev; 587 next->pprev = pprev;
588 } 588 }
589 589
590 static inline void hlist_del(struct hlist_node *n) 590 static inline void hlist_del(struct hlist_node *n)
591 { 591 {
592 __hlist_del(n); 592 __hlist_del(n);
593 n->next = LIST_POISON1; 593 n->next = LIST_POISON1;
594 n->pprev = LIST_POISON2; 594 n->pprev = LIST_POISON2;
595 } 595 }
596 596
597 static inline void hlist_del_init(struct hlist_node *n) 597 static inline void hlist_del_init(struct hlist_node *n)
598 { 598 {
599 if (!hlist_unhashed(n)) { 599 if (!hlist_unhashed(n)) {
600 __hlist_del(n); 600 __hlist_del(n);
601 INIT_HLIST_NODE(n); 601 INIT_HLIST_NODE(n);
602 } 602 }
603 } 603 }
604 604
605 static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h) 605 static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
606 { 606 {
607 struct hlist_node *first = h->first; 607 struct hlist_node *first = h->first;
608 n->next = first; 608 n->next = first;
609 if (first) 609 if (first)
610 first->pprev = &n->next; 610 first->pprev = &n->next;
611 h->first = n; 611 h->first = n;
612 n->pprev = &h->first; 612 n->pprev = &h->first;
613 } 613 }
614 614
615 /* next must be != NULL */ 615 /* next must be != NULL */
616 static inline void hlist_add_before(struct hlist_node *n, 616 static inline void hlist_add_before(struct hlist_node *n,
617 struct hlist_node *next) 617 struct hlist_node *next)
618 { 618 {
619 n->pprev = next->pprev; 619 n->pprev = next->pprev;
620 n->next = next; 620 n->next = next;
621 next->pprev = &n->next; 621 next->pprev = &n->next;
622 *(n->pprev) = n; 622 *(n->pprev) = n;
623 } 623 }
624 624
625 static inline void hlist_add_after(struct hlist_node *n, 625 static inline void hlist_add_after(struct hlist_node *n,
626 struct hlist_node *next) 626 struct hlist_node *next)
627 { 627 {
628 next->next = n->next; 628 next->next = n->next;
629 n->next = next; 629 n->next = next;
630 next->pprev = &n->next; 630 next->pprev = &n->next;
631 631
632 if(next->next) 632 if(next->next)
633 next->next->pprev = &next->next; 633 next->next->pprev = &next->next;
634 } 634 }
635 635
636 /* 636 /*
637 * Move a list from one list head to another. Fixup the pprev 637 * Move a list from one list head to another. Fixup the pprev
638 * reference of the first entry if it exists. 638 * reference of the first entry if it exists.
639 */ 639 */
640 static inline void hlist_move_list(struct hlist_head *old, 640 static inline void hlist_move_list(struct hlist_head *old,
641 struct hlist_head *new) 641 struct hlist_head *new)
642 { 642 {
643 new->first = old->first; 643 new->first = old->first;
644 if (new->first) 644 if (new->first)
645 new->first->pprev = &new->first; 645 new->first->pprev = &new->first;
646 old->first = NULL; 646 old->first = NULL;
647 } 647 }
648 648
649 #define hlist_entry(ptr, type, member) container_of(ptr,type,member) 649 #define hlist_entry(ptr, type, member) container_of(ptr,type,member)
650 650
651 #define hlist_for_each(pos, head) \ 651 #define hlist_for_each(pos, head) \
652 for (pos = (head)->first; pos && ({ prefetch(pos->next); 1; }); \ 652 for (pos = (head)->first; pos && ({ prefetch(pos->next); 1; }); \
653 pos = pos->next) 653 pos = pos->next)
654 654
655 #define hlist_for_each_safe(pos, n, head) \ 655 #define hlist_for_each_safe(pos, n, head) \
656 for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \ 656 for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \
657 pos = n) 657 pos = n)
658 658
659 /** 659 /**
660 * hlist_for_each_entry - iterate over list of given type 660 * hlist_for_each_entry - iterate over list of given type
661 * @tpos: the type * to use as a loop cursor. 661 * @tpos: the type * to use as a loop cursor.
662 * @pos: the &struct hlist_node to use as a loop cursor. 662 * @pos: the &struct hlist_node to use as a loop cursor.
663 * @head: the head for your list. 663 * @head: the head for your list.
664 * @member: the name of the hlist_node within the struct. 664 * @member: the name of the hlist_node within the struct.
665 */ 665 */
666 #define hlist_for_each_entry(tpos, pos, head, member) \ 666 #define hlist_for_each_entry(tpos, pos, head, member) \
667 for (pos = (head)->first; \ 667 for (pos = (head)->first; \
668 pos && ({ prefetch(pos->next); 1;}) && \ 668 pos && ({ prefetch(pos->next); 1;}) && \
669 ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \ 669 ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
670 pos = pos->next) 670 pos = pos->next)
671 671
672 /** 672 /**
673 * hlist_for_each_entry_continue - iterate over a hlist continuing after current point 673 * hlist_for_each_entry_continue - iterate over a hlist continuing after current point
674 * @tpos: the type * to use as a loop cursor. 674 * @tpos: the type * to use as a loop cursor.
675 * @pos: the &struct hlist_node to use as a loop cursor. 675 * @pos: the &struct hlist_node to use as a loop cursor.
676 * @member: the name of the hlist_node within the struct. 676 * @member: the name of the hlist_node within the struct.
677 */ 677 */
678 #define hlist_for_each_entry_continue(tpos, pos, member) \ 678 #define hlist_for_each_entry_continue(tpos, pos, member) \
679 for (pos = (pos)->next; \ 679 for (pos = (pos)->next; \
680 pos && ({ prefetch(pos->next); 1;}) && \ 680 pos && ({ prefetch(pos->next); 1;}) && \
681 ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \ 681 ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
682 pos = pos->next) 682 pos = pos->next)
683 683
684 /** 684 /**
685 * hlist_for_each_entry_from - iterate over a hlist continuing from current point 685 * hlist_for_each_entry_from - iterate over a hlist continuing from current point
686 * @tpos: the type * to use as a loop cursor. 686 * @tpos: the type * to use as a loop cursor.
687 * @pos: the &struct hlist_node to use as a loop cursor. 687 * @pos: the &struct hlist_node to use as a loop cursor.
688 * @member: the name of the hlist_node within the struct. 688 * @member: the name of the hlist_node within the struct.
689 */ 689 */
690 #define hlist_for_each_entry_from(tpos, pos, member) \ 690 #define hlist_for_each_entry_from(tpos, pos, member) \
691 for (; pos && ({ prefetch(pos->next); 1;}) && \ 691 for (; pos && ({ prefetch(pos->next); 1;}) && \
692 ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \ 692 ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
693 pos = pos->next) 693 pos = pos->next)
694 694
695 /** 695 /**
696 * hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry 696 * hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry
697 * @tpos: the type * to use as a loop cursor. 697 * @tpos: the type * to use as a loop cursor.
698 * @pos: the &struct hlist_node to use as a loop cursor. 698 * @pos: the &struct hlist_node to use as a loop cursor.
699 * @n: another &struct hlist_node to use as temporary storage 699 * @n: another &struct hlist_node to use as temporary storage
700 * @head: the head for your list. 700 * @head: the head for your list.
701 * @member: the name of the hlist_node within the struct. 701 * @member: the name of the hlist_node within the struct.
702 */ 702 */
703 #define hlist_for_each_entry_safe(tpos, pos, n, head, member) \ 703 #define hlist_for_each_entry_safe(tpos, pos, n, head, member) \
704 for (pos = (head)->first; \ 704 for (pos = (head)->first; \
705 pos && ({ n = pos->next; 1; }) && \ 705 pos && ({ n = pos->next; 1; }) && \
706 ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \ 706 ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
707 pos = n) 707 pos = n)
708 708
709 #endif 709 #endif
710 710
1 /* 1 /*
2 * lib/bitmap.c 2 * lib/bitmap.c
3 * Helper functions for bitmap.h. 3 * Helper functions for bitmap.h.
4 * 4 *
5 * This source code is licensed under the GNU General Public License, 5 * This source code is licensed under the GNU General Public License,
6 * Version 2. See the file COPYING for more details. 6 * Version 2. See the file COPYING for more details.
7 */ 7 */
8 #include <linux/module.h> 8 #include <linux/module.h>
9 #include <linux/ctype.h> 9 #include <linux/ctype.h>
10 #include <linux/errno.h> 10 #include <linux/errno.h>
11 #include <linux/bitmap.h> 11 #include <linux/bitmap.h>
12 #include <linux/bitops.h> 12 #include <linux/bitops.h>
13 #include <asm/uaccess.h> 13 #include <asm/uaccess.h>
14 14
15 /* 15 /*
16 * bitmaps provide an array of bits, implemented using an an 16 * bitmaps provide an array of bits, implemented using an an
17 * array of unsigned longs. The number of valid bits in a 17 * array of unsigned longs. The number of valid bits in a
18 * given bitmap does _not_ need to be an exact multiple of 18 * given bitmap does _not_ need to be an exact multiple of
19 * BITS_PER_LONG. 19 * BITS_PER_LONG.
20 * 20 *
21 * The possible unused bits in the last, partially used word 21 * The possible unused bits in the last, partially used word
22 * of a bitmap are 'don't care'. The implementation makes 22 * of a bitmap are 'don't care'. The implementation makes
23 * no particular effort to keep them zero. It ensures that 23 * no particular effort to keep them zero. It ensures that
24 * their value will not affect the results of any operation. 24 * their value will not affect the results of any operation.
25 * The bitmap operations that return Boolean (bitmap_empty, 25 * The bitmap operations that return Boolean (bitmap_empty,
26 * for example) or scalar (bitmap_weight, for example) results 26 * for example) or scalar (bitmap_weight, for example) results
27 * carefully filter out these unused bits from impacting their 27 * carefully filter out these unused bits from impacting their
28 * results. 28 * results.
29 * 29 *
30 * These operations actually hold to a slightly stronger rule: 30 * These operations actually hold to a slightly stronger rule:
31 * if you don't input any bitmaps to these ops that have some 31 * if you don't input any bitmaps to these ops that have some
32 * unused bits set, then they won't output any set unused bits 32 * unused bits set, then they won't output any set unused bits
33 * in output bitmaps. 33 * in output bitmaps.
34 * 34 *
35 * The byte ordering of bitmaps is more natural on little 35 * The byte ordering of bitmaps is more natural on little
36 * endian architectures. See the big-endian headers 36 * endian architectures. See the big-endian headers
37 * include/asm-ppc64/bitops.h and include/asm-s390/bitops.h 37 * include/asm-ppc64/bitops.h and include/asm-s390/bitops.h
38 * for the best explanations of this ordering. 38 * for the best explanations of this ordering.
39 */ 39 */
40 40
41 int __bitmap_empty(const unsigned long *bitmap, int bits) 41 int __bitmap_empty(const unsigned long *bitmap, int bits)
42 { 42 {
43 int k, lim = bits/BITS_PER_LONG; 43 int k, lim = bits/BITS_PER_LONG;
44 for (k = 0; k < lim; ++k) 44 for (k = 0; k < lim; ++k)
45 if (bitmap[k]) 45 if (bitmap[k])
46 return 0; 46 return 0;
47 47
48 if (bits % BITS_PER_LONG) 48 if (bits % BITS_PER_LONG)
49 if (bitmap[k] & BITMAP_LAST_WORD_MASK(bits)) 49 if (bitmap[k] & BITMAP_LAST_WORD_MASK(bits))
50 return 0; 50 return 0;
51 51
52 return 1; 52 return 1;
53 } 53 }
54 EXPORT_SYMBOL(__bitmap_empty); 54 EXPORT_SYMBOL(__bitmap_empty);
55 55
56 int __bitmap_full(const unsigned long *bitmap, int bits) 56 int __bitmap_full(const unsigned long *bitmap, int bits)
57 { 57 {
58 int k, lim = bits/BITS_PER_LONG; 58 int k, lim = bits/BITS_PER_LONG;
59 for (k = 0; k < lim; ++k) 59 for (k = 0; k < lim; ++k)
60 if (~bitmap[k]) 60 if (~bitmap[k])
61 return 0; 61 return 0;
62 62
63 if (bits % BITS_PER_LONG) 63 if (bits % BITS_PER_LONG)
64 if (~bitmap[k] & BITMAP_LAST_WORD_MASK(bits)) 64 if (~bitmap[k] & BITMAP_LAST_WORD_MASK(bits))
65 return 0; 65 return 0;
66 66
67 return 1; 67 return 1;
68 } 68 }
69 EXPORT_SYMBOL(__bitmap_full); 69 EXPORT_SYMBOL(__bitmap_full);
70 70
71 int __bitmap_equal(const unsigned long *bitmap1, 71 int __bitmap_equal(const unsigned long *bitmap1,
72 const unsigned long *bitmap2, int bits) 72 const unsigned long *bitmap2, int bits)
73 { 73 {
74 int k, lim = bits/BITS_PER_LONG; 74 int k, lim = bits/BITS_PER_LONG;
75 for (k = 0; k < lim; ++k) 75 for (k = 0; k < lim; ++k)
76 if (bitmap1[k] != bitmap2[k]) 76 if (bitmap1[k] != bitmap2[k])
77 return 0; 77 return 0;
78 78
79 if (bits % BITS_PER_LONG) 79 if (bits % BITS_PER_LONG)
80 if ((bitmap1[k] ^ bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits)) 80 if ((bitmap1[k] ^ bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits))
81 return 0; 81 return 0;
82 82
83 return 1; 83 return 1;
84 } 84 }
85 EXPORT_SYMBOL(__bitmap_equal); 85 EXPORT_SYMBOL(__bitmap_equal);
86 86
87 void __bitmap_complement(unsigned long *dst, const unsigned long *src, int bits) 87 void __bitmap_complement(unsigned long *dst, const unsigned long *src, int bits)
88 { 88 {
89 int k, lim = bits/BITS_PER_LONG; 89 int k, lim = bits/BITS_PER_LONG;
90 for (k = 0; k < lim; ++k) 90 for (k = 0; k < lim; ++k)
91 dst[k] = ~src[k]; 91 dst[k] = ~src[k];
92 92
93 if (bits % BITS_PER_LONG) 93 if (bits % BITS_PER_LONG)
94 dst[k] = ~src[k] & BITMAP_LAST_WORD_MASK(bits); 94 dst[k] = ~src[k] & BITMAP_LAST_WORD_MASK(bits);
95 } 95 }
96 EXPORT_SYMBOL(__bitmap_complement); 96 EXPORT_SYMBOL(__bitmap_complement);
97 97
98 /** 98 /**
99 * __bitmap_shift_right - logical right shift of the bits in a bitmap 99 * __bitmap_shift_right - logical right shift of the bits in a bitmap
100 * @dst : destination bitmap 100 * @dst : destination bitmap
101 * @src : source bitmap 101 * @src : source bitmap
102 * @shift : shift by this many bits 102 * @shift : shift by this many bits
103 * @bits : bitmap size, in bits 103 * @bits : bitmap size, in bits
104 * 104 *
105 * Shifting right (dividing) means moving bits in the MS -> LS bit 105 * Shifting right (dividing) means moving bits in the MS -> LS bit
106 * direction. Zeros are fed into the vacated MS positions and the 106 * direction. Zeros are fed into the vacated MS positions and the
107 * LS bits shifted off the bottom are lost. 107 * LS bits shifted off the bottom are lost.
108 */ 108 */
109 void __bitmap_shift_right(unsigned long *dst, 109 void __bitmap_shift_right(unsigned long *dst,
110 const unsigned long *src, int shift, int bits) 110 const unsigned long *src, int shift, int bits)
111 { 111 {
112 int k, lim = BITS_TO_LONGS(bits), left = bits % BITS_PER_LONG; 112 int k, lim = BITS_TO_LONGS(bits), left = bits % BITS_PER_LONG;
113 int off = shift/BITS_PER_LONG, rem = shift % BITS_PER_LONG; 113 int off = shift/BITS_PER_LONG, rem = shift % BITS_PER_LONG;
114 unsigned long mask = (1UL << left) - 1; 114 unsigned long mask = (1UL << left) - 1;
115 for (k = 0; off + k < lim; ++k) { 115 for (k = 0; off + k < lim; ++k) {
116 unsigned long upper, lower; 116 unsigned long upper, lower;
117 117
118 /* 118 /*
119 * If shift is not word aligned, take lower rem bits of 119 * If shift is not word aligned, take lower rem bits of
120 * word above and make them the top rem bits of result. 120 * word above and make them the top rem bits of result.
121 */ 121 */
122 if (!rem || off + k + 1 >= lim) 122 if (!rem || off + k + 1 >= lim)
123 upper = 0; 123 upper = 0;
124 else { 124 else {
125 upper = src[off + k + 1]; 125 upper = src[off + k + 1];
126 if (off + k + 1 == lim - 1 && left) 126 if (off + k + 1 == lim - 1 && left)
127 upper &= mask; 127 upper &= mask;
128 } 128 }
129 lower = src[off + k]; 129 lower = src[off + k];
130 if (left && off + k == lim - 1) 130 if (left && off + k == lim - 1)
131 lower &= mask; 131 lower &= mask;
132 dst[k] = upper << (BITS_PER_LONG - rem) | lower >> rem; 132 dst[k] = upper << (BITS_PER_LONG - rem) | lower >> rem;
133 if (left && k == lim - 1) 133 if (left && k == lim - 1)
134 dst[k] &= mask; 134 dst[k] &= mask;
135 } 135 }
136 if (off) 136 if (off)
137 memset(&dst[lim - off], 0, off*sizeof(unsigned long)); 137 memset(&dst[lim - off], 0, off*sizeof(unsigned long));
138 } 138 }
139 EXPORT_SYMBOL(__bitmap_shift_right); 139 EXPORT_SYMBOL(__bitmap_shift_right);
140 140
141 141
142 /** 142 /**
143 * __bitmap_shift_left - logical left shift of the bits in a bitmap 143 * __bitmap_shift_left - logical left shift of the bits in a bitmap
144 * @dst : destination bitmap 144 * @dst : destination bitmap
145 * @src : source bitmap 145 * @src : source bitmap
146 * @shift : shift by this many bits 146 * @shift : shift by this many bits
147 * @bits : bitmap size, in bits 147 * @bits : bitmap size, in bits
148 * 148 *
149 * Shifting left (multiplying) means moving bits in the LS -> MS 149 * Shifting left (multiplying) means moving bits in the LS -> MS
150 * direction. Zeros are fed into the vacated LS bit positions 150 * direction. Zeros are fed into the vacated LS bit positions
151 * and those MS bits shifted off the top are lost. 151 * and those MS bits shifted off the top are lost.
152 */ 152 */
153 153
154 void __bitmap_shift_left(unsigned long *dst, 154 void __bitmap_shift_left(unsigned long *dst,
155 const unsigned long *src, int shift, int bits) 155 const unsigned long *src, int shift, int bits)
156 { 156 {
157 int k, lim = BITS_TO_LONGS(bits), left = bits % BITS_PER_LONG; 157 int k, lim = BITS_TO_LONGS(bits), left = bits % BITS_PER_LONG;
158 int off = shift/BITS_PER_LONG, rem = shift % BITS_PER_LONG; 158 int off = shift/BITS_PER_LONG, rem = shift % BITS_PER_LONG;
159 for (k = lim - off - 1; k >= 0; --k) { 159 for (k = lim - off - 1; k >= 0; --k) {
160 unsigned long upper, lower; 160 unsigned long upper, lower;
161 161
162 /* 162 /*
163 * If shift is not word aligned, take upper rem bits of 163 * If shift is not word aligned, take upper rem bits of
164 * word below and make them the bottom rem bits of result. 164 * word below and make them the bottom rem bits of result.
165 */ 165 */
166 if (rem && k > 0) 166 if (rem && k > 0)
167 lower = src[k - 1]; 167 lower = src[k - 1];
168 else 168 else
169 lower = 0; 169 lower = 0;
170 upper = src[k]; 170 upper = src[k];
171 if (left && k == lim - 1) 171 if (left && k == lim - 1)
172 upper &= (1UL << left) - 1; 172 upper &= (1UL << left) - 1;
173 dst[k + off] = lower >> (BITS_PER_LONG - rem) | upper << rem; 173 dst[k + off] = lower >> (BITS_PER_LONG - rem) | upper << rem;
174 if (left && k + off == lim - 1) 174 if (left && k + off == lim - 1)
175 dst[k + off] &= (1UL << left) - 1; 175 dst[k + off] &= (1UL << left) - 1;
176 } 176 }
177 if (off) 177 if (off)
178 memset(dst, 0, off*sizeof(unsigned long)); 178 memset(dst, 0, off*sizeof(unsigned long));
179 } 179 }
180 EXPORT_SYMBOL(__bitmap_shift_left); 180 EXPORT_SYMBOL(__bitmap_shift_left);
181 181
182 int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1, 182 int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
183 const unsigned long *bitmap2, int bits) 183 const unsigned long *bitmap2, int bits)
184 { 184 {
185 int k; 185 int k;
186 int nr = BITS_TO_LONGS(bits); 186 int nr = BITS_TO_LONGS(bits);
187 unsigned long result = 0; 187 unsigned long result = 0;
188 188
189 for (k = 0; k < nr; k++) 189 for (k = 0; k < nr; k++)
190 result |= (dst[k] = bitmap1[k] & bitmap2[k]); 190 result |= (dst[k] = bitmap1[k] & bitmap2[k]);
191 return result != 0; 191 return result != 0;
192 } 192 }
193 EXPORT_SYMBOL(__bitmap_and); 193 EXPORT_SYMBOL(__bitmap_and);
194 194
195 void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1, 195 void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
196 const unsigned long *bitmap2, int bits) 196 const unsigned long *bitmap2, int bits)
197 { 197 {
198 int k; 198 int k;
199 int nr = BITS_TO_LONGS(bits); 199 int nr = BITS_TO_LONGS(bits);
200 200
201 for (k = 0; k < nr; k++) 201 for (k = 0; k < nr; k++)
202 dst[k] = bitmap1[k] | bitmap2[k]; 202 dst[k] = bitmap1[k] | bitmap2[k];
203 } 203 }
204 EXPORT_SYMBOL(__bitmap_or); 204 EXPORT_SYMBOL(__bitmap_or);
205 205
206 void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1, 206 void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
207 const unsigned long *bitmap2, int bits) 207 const unsigned long *bitmap2, int bits)
208 { 208 {
209 int k; 209 int k;
210 int nr = BITS_TO_LONGS(bits); 210 int nr = BITS_TO_LONGS(bits);
211 211
212 for (k = 0; k < nr; k++) 212 for (k = 0; k < nr; k++)
213 dst[k] = bitmap1[k] ^ bitmap2[k]; 213 dst[k] = bitmap1[k] ^ bitmap2[k];
214 } 214 }
215 EXPORT_SYMBOL(__bitmap_xor); 215 EXPORT_SYMBOL(__bitmap_xor);
216 216
217 int __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1, 217 int __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
218 const unsigned long *bitmap2, int bits) 218 const unsigned long *bitmap2, int bits)
219 { 219 {
220 int k; 220 int k;
221 int nr = BITS_TO_LONGS(bits); 221 int nr = BITS_TO_LONGS(bits);
222 unsigned long result = 0; 222 unsigned long result = 0;
223 223
224 for (k = 0; k < nr; k++) 224 for (k = 0; k < nr; k++)
225 result |= (dst[k] = bitmap1[k] & ~bitmap2[k]); 225 result |= (dst[k] = bitmap1[k] & ~bitmap2[k]);
226 return result != 0; 226 return result != 0;
227 } 227 }
228 EXPORT_SYMBOL(__bitmap_andnot); 228 EXPORT_SYMBOL(__bitmap_andnot);
229 229
230 int __bitmap_intersects(const unsigned long *bitmap1, 230 int __bitmap_intersects(const unsigned long *bitmap1,
231 const unsigned long *bitmap2, int bits) 231 const unsigned long *bitmap2, int bits)
232 { 232 {
233 int k, lim = bits/BITS_PER_LONG; 233 int k, lim = bits/BITS_PER_LONG;
234 for (k = 0; k < lim; ++k) 234 for (k = 0; k < lim; ++k)
235 if (bitmap1[k] & bitmap2[k]) 235 if (bitmap1[k] & bitmap2[k])
236 return 1; 236 return 1;
237 237
238 if (bits % BITS_PER_LONG) 238 if (bits % BITS_PER_LONG)
239 if ((bitmap1[k] & bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits)) 239 if ((bitmap1[k] & bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits))
240 return 1; 240 return 1;
241 return 0; 241 return 0;
242 } 242 }
243 EXPORT_SYMBOL(__bitmap_intersects); 243 EXPORT_SYMBOL(__bitmap_intersects);
244 244
245 int __bitmap_subset(const unsigned long *bitmap1, 245 int __bitmap_subset(const unsigned long *bitmap1,
246 const unsigned long *bitmap2, int bits) 246 const unsigned long *bitmap2, int bits)
247 { 247 {
248 int k, lim = bits/BITS_PER_LONG; 248 int k, lim = bits/BITS_PER_LONG;
249 for (k = 0; k < lim; ++k) 249 for (k = 0; k < lim; ++k)
250 if (bitmap1[k] & ~bitmap2[k]) 250 if (bitmap1[k] & ~bitmap2[k])
251 return 0; 251 return 0;
252 252
253 if (bits % BITS_PER_LONG) 253 if (bits % BITS_PER_LONG)
254 if ((bitmap1[k] & ~bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits)) 254 if ((bitmap1[k] & ~bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits))
255 return 0; 255 return 0;
256 return 1; 256 return 1;
257 } 257 }
258 EXPORT_SYMBOL(__bitmap_subset); 258 EXPORT_SYMBOL(__bitmap_subset);
259 259
260 int __bitmap_weight(const unsigned long *bitmap, int bits) 260 int __bitmap_weight(const unsigned long *bitmap, int bits)
261 { 261 {
262 int k, w = 0, lim = bits/BITS_PER_LONG; 262 int k, w = 0, lim = bits/BITS_PER_LONG;
263 263
264 for (k = 0; k < lim; k++) 264 for (k = 0; k < lim; k++)
265 w += hweight_long(bitmap[k]); 265 w += hweight_long(bitmap[k]);
266 266
267 if (bits % BITS_PER_LONG) 267 if (bits % BITS_PER_LONG)
268 w += hweight_long(bitmap[k] & BITMAP_LAST_WORD_MASK(bits)); 268 w += hweight_long(bitmap[k] & BITMAP_LAST_WORD_MASK(bits));
269 269
270 return w; 270 return w;
271 } 271 }
272 EXPORT_SYMBOL(__bitmap_weight); 272 EXPORT_SYMBOL(__bitmap_weight);
273 273
274 #define BITMAP_FIRST_WORD_MASK(start) (~0UL << ((start) % BITS_PER_LONG)) 274 #define BITMAP_FIRST_WORD_MASK(start) (~0UL << ((start) % BITS_PER_LONG))
275 275
276 void bitmap_set(unsigned long *map, int start, int nr) 276 void bitmap_set(unsigned long *map, int start, int nr)
277 { 277 {
278 unsigned long *p = map + BIT_WORD(start); 278 unsigned long *p = map + BIT_WORD(start);
279 const int size = start + nr; 279 const int size = start + nr;
280 int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG); 280 int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);
281 unsigned long mask_to_set = BITMAP_FIRST_WORD_MASK(start); 281 unsigned long mask_to_set = BITMAP_FIRST_WORD_MASK(start);
282 282
283 while (nr - bits_to_set >= 0) { 283 while (nr - bits_to_set >= 0) {
284 *p |= mask_to_set; 284 *p |= mask_to_set;
285 nr -= bits_to_set; 285 nr -= bits_to_set;
286 bits_to_set = BITS_PER_LONG; 286 bits_to_set = BITS_PER_LONG;
287 mask_to_set = ~0UL; 287 mask_to_set = ~0UL;
288 p++; 288 p++;
289 } 289 }
290 if (nr) { 290 if (nr) {
291 mask_to_set &= BITMAP_LAST_WORD_MASK(size); 291 mask_to_set &= BITMAP_LAST_WORD_MASK(size);
292 *p |= mask_to_set; 292 *p |= mask_to_set;
293 } 293 }
294 } 294 }
295 EXPORT_SYMBOL(bitmap_set); 295 EXPORT_SYMBOL(bitmap_set);
296 296
297 void bitmap_clear(unsigned long *map, int start, int nr) 297 void bitmap_clear(unsigned long *map, int start, int nr)
298 { 298 {
299 unsigned long *p = map + BIT_WORD(start); 299 unsigned long *p = map + BIT_WORD(start);
300 const int size = start + nr; 300 const int size = start + nr;
301 int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG); 301 int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG);
302 unsigned long mask_to_clear = BITMAP_FIRST_WORD_MASK(start); 302 unsigned long mask_to_clear = BITMAP_FIRST_WORD_MASK(start);
303 303
304 while (nr - bits_to_clear >= 0) { 304 while (nr - bits_to_clear >= 0) {
305 *p &= ~mask_to_clear; 305 *p &= ~mask_to_clear;
306 nr -= bits_to_clear; 306 nr -= bits_to_clear;
307 bits_to_clear = BITS_PER_LONG; 307 bits_to_clear = BITS_PER_LONG;
308 mask_to_clear = ~0UL; 308 mask_to_clear = ~0UL;
309 p++; 309 p++;
310 } 310 }
311 if (nr) { 311 if (nr) {
312 mask_to_clear &= BITMAP_LAST_WORD_MASK(size); 312 mask_to_clear &= BITMAP_LAST_WORD_MASK(size);
313 *p &= ~mask_to_clear; 313 *p &= ~mask_to_clear;
314 } 314 }
315 } 315 }
316 EXPORT_SYMBOL(bitmap_clear); 316 EXPORT_SYMBOL(bitmap_clear);
317 317
318 /* 318 /*
319 * bitmap_find_next_zero_area - find a contiguous aligned zero area 319 * bitmap_find_next_zero_area - find a contiguous aligned zero area
320 * @map: The address to base the search on 320 * @map: The address to base the search on
321 * @size: The bitmap size in bits 321 * @size: The bitmap size in bits
322 * @start: The bitnumber to start searching at 322 * @start: The bitnumber to start searching at
323 * @nr: The number of zeroed bits we're looking for 323 * @nr: The number of zeroed bits we're looking for
324 * @align_mask: Alignment mask for zero area 324 * @align_mask: Alignment mask for zero area
325 * 325 *
326 * The @align_mask should be one less than a power of 2; the effect is that 326 * The @align_mask should be one less than a power of 2; the effect is that
327 * the bit offset of all zero areas this function finds is multiples of that 327 * the bit offset of all zero areas this function finds is multiples of that
328 * power of 2. A @align_mask of 0 means no alignment is required. 328 * power of 2. A @align_mask of 0 means no alignment is required.
329 */ 329 */
330 unsigned long bitmap_find_next_zero_area(unsigned long *map, 330 unsigned long bitmap_find_next_zero_area(unsigned long *map,
331 unsigned long size, 331 unsigned long size,
332 unsigned long start, 332 unsigned long start,
333 unsigned int nr, 333 unsigned int nr,
334 unsigned long align_mask) 334 unsigned long align_mask)
335 { 335 {
336 unsigned long index, end, i; 336 unsigned long index, end, i;
337 again: 337 again:
338 index = find_next_zero_bit(map, size, start); 338 index = find_next_zero_bit(map, size, start);
339 339
340 /* Align allocation */ 340 /* Align allocation */
341 index = __ALIGN_MASK(index, align_mask); 341 index = __ALIGN_MASK(index, align_mask);
342 342
343 end = index + nr; 343 end = index + nr;
344 if (end > size) 344 if (end > size)
345 return end; 345 return end;
346 i = find_next_bit(map, end, index); 346 i = find_next_bit(map, end, index);
347 if (i < end) { 347 if (i < end) {
348 start = i + 1; 348 start = i + 1;
349 goto again; 349 goto again;
350 } 350 }
351 return index; 351 return index;
352 } 352 }
353 EXPORT_SYMBOL(bitmap_find_next_zero_area); 353 EXPORT_SYMBOL(bitmap_find_next_zero_area);
354 354
355 /* 355 /*
356 * Bitmap printing & parsing functions: first version by Bill Irwin, 356 * Bitmap printing & parsing functions: first version by Bill Irwin,
357 * second version by Paul Jackson, third by Joe Korty. 357 * second version by Paul Jackson, third by Joe Korty.
358 */ 358 */
359 359
360 #define CHUNKSZ 32 360 #define CHUNKSZ 32
361 #define nbits_to_hold_value(val) fls(val) 361 #define nbits_to_hold_value(val) fls(val)
362 #define unhex(c) (isdigit(c) ? (c - '0') : (toupper(c) - 'A' + 10)) 362 #define unhex(c) (isdigit(c) ? (c - '0') : (toupper(c) - 'A' + 10))
363 #define BASEDEC 10 /* fancier cpuset lists input in decimal */ 363 #define BASEDEC 10 /* fancier cpuset lists input in decimal */
364 364
365 /** 365 /**
366 * bitmap_scnprintf - convert bitmap to an ASCII hex string. 366 * bitmap_scnprintf - convert bitmap to an ASCII hex string.
367 * @buf: byte buffer into which string is placed 367 * @buf: byte buffer into which string is placed
368 * @buflen: reserved size of @buf, in bytes 368 * @buflen: reserved size of @buf, in bytes
369 * @maskp: pointer to bitmap to convert 369 * @maskp: pointer to bitmap to convert
370 * @nmaskbits: size of bitmap, in bits 370 * @nmaskbits: size of bitmap, in bits
371 * 371 *
372 * Exactly @nmaskbits bits are displayed. Hex digits are grouped into 372 * Exactly @nmaskbits bits are displayed. Hex digits are grouped into
373 * comma-separated sets of eight digits per set. 373 * comma-separated sets of eight digits per set.
374 */ 374 */
375 int bitmap_scnprintf(char *buf, unsigned int buflen, 375 int bitmap_scnprintf(char *buf, unsigned int buflen,
376 const unsigned long *maskp, int nmaskbits) 376 const unsigned long *maskp, int nmaskbits)
377 { 377 {
378 int i, word, bit, len = 0; 378 int i, word, bit, len = 0;
379 unsigned long val; 379 unsigned long val;
380 const char *sep = ""; 380 const char *sep = "";
381 int chunksz; 381 int chunksz;
382 u32 chunkmask; 382 u32 chunkmask;
383 383
384 chunksz = nmaskbits & (CHUNKSZ - 1); 384 chunksz = nmaskbits & (CHUNKSZ - 1);
385 if (chunksz == 0) 385 if (chunksz == 0)
386 chunksz = CHUNKSZ; 386 chunksz = CHUNKSZ;
387 387
388 i = ALIGN(nmaskbits, CHUNKSZ) - CHUNKSZ; 388 i = ALIGN(nmaskbits, CHUNKSZ) - CHUNKSZ;
389 for (; i >= 0; i -= CHUNKSZ) { 389 for (; i >= 0; i -= CHUNKSZ) {
390 chunkmask = ((1ULL << chunksz) - 1); 390 chunkmask = ((1ULL << chunksz) - 1);
391 word = i / BITS_PER_LONG; 391 word = i / BITS_PER_LONG;
392 bit = i % BITS_PER_LONG; 392 bit = i % BITS_PER_LONG;
393 val = (maskp[word] >> bit) & chunkmask; 393 val = (maskp[word] >> bit) & chunkmask;
394 len += scnprintf(buf+len, buflen-len, "%s%0*lx", sep, 394 len += scnprintf(buf+len, buflen-len, "%s%0*lx", sep,
395 (chunksz+3)/4, val); 395 (chunksz+3)/4, val);
396 chunksz = CHUNKSZ; 396 chunksz = CHUNKSZ;
397 sep = ","; 397 sep = ",";
398 } 398 }
399 return len; 399 return len;
400 } 400 }
401 EXPORT_SYMBOL(bitmap_scnprintf); 401 EXPORT_SYMBOL(bitmap_scnprintf);
402 402
403 /** 403 /**
404 * __bitmap_parse - convert an ASCII hex string into a bitmap. 404 * __bitmap_parse - convert an ASCII hex string into a bitmap.
405 * @buf: pointer to buffer containing string. 405 * @buf: pointer to buffer containing string.
406 * @buflen: buffer size in bytes. If string is smaller than this 406 * @buflen: buffer size in bytes. If string is smaller than this
407 * then it must be terminated with a \0. 407 * then it must be terminated with a \0.
408 * @is_user: location of buffer, 0 indicates kernel space 408 * @is_user: location of buffer, 0 indicates kernel space
409 * @maskp: pointer to bitmap array that will contain result. 409 * @maskp: pointer to bitmap array that will contain result.
410 * @nmaskbits: size of bitmap, in bits. 410 * @nmaskbits: size of bitmap, in bits.
411 * 411 *
412 * Commas group hex digits into chunks. Each chunk defines exactly 32 412 * Commas group hex digits into chunks. Each chunk defines exactly 32
413 * bits of the resultant bitmask. No chunk may specify a value larger 413 * bits of the resultant bitmask. No chunk may specify a value larger
414 * than 32 bits (%-EOVERFLOW), and if a chunk specifies a smaller value 414 * than 32 bits (%-EOVERFLOW), and if a chunk specifies a smaller value
415 * then leading 0-bits are prepended. %-EINVAL is returned for illegal 415 * then leading 0-bits are prepended. %-EINVAL is returned for illegal
416 * characters and for grouping errors such as "1,,5", ",44", "," and "". 416 * characters and for grouping errors such as "1,,5", ",44", "," and "".
417 * Leading and trailing whitespace accepted, but not embedded whitespace. 417 * Leading and trailing whitespace accepted, but not embedded whitespace.
418 */ 418 */
419 int __bitmap_parse(const char *buf, unsigned int buflen, 419 int __bitmap_parse(const char *buf, unsigned int buflen,
420 int is_user, unsigned long *maskp, 420 int is_user, unsigned long *maskp,
421 int nmaskbits) 421 int nmaskbits)
422 { 422 {
423 int c, old_c, totaldigits, ndigits, nchunks, nbits; 423 int c, old_c, totaldigits, ndigits, nchunks, nbits;
424 u32 chunk; 424 u32 chunk;
425 const char __user *ubuf = buf; 425 const char __user *ubuf = buf;
426 426
427 bitmap_zero(maskp, nmaskbits); 427 bitmap_zero(maskp, nmaskbits);
428 428
429 nchunks = nbits = totaldigits = c = 0; 429 nchunks = nbits = totaldigits = c = 0;
430 do { 430 do {
431 chunk = ndigits = 0; 431 chunk = ndigits = 0;
432 432
433 /* Get the next chunk of the bitmap */ 433 /* Get the next chunk of the bitmap */
434 while (buflen) { 434 while (buflen) {
435 old_c = c; 435 old_c = c;
436 if (is_user) { 436 if (is_user) {
437 if (__get_user(c, ubuf++)) 437 if (__get_user(c, ubuf++))
438 return -EFAULT; 438 return -EFAULT;
439 } 439 }
440 else 440 else
441 c = *buf++; 441 c = *buf++;
442 buflen--; 442 buflen--;
443 if (isspace(c)) 443 if (isspace(c))
444 continue; 444 continue;
445 445
446 /* 446 /*
447 * If the last character was a space and the current 447 * If the last character was a space and the current
448 * character isn't '\0', we've got embedded whitespace. 448 * character isn't '\0', we've got embedded whitespace.
449 * This is a no-no, so throw an error. 449 * This is a no-no, so throw an error.
450 */ 450 */
451 if (totaldigits && c && isspace(old_c)) 451 if (totaldigits && c && isspace(old_c))
452 return -EINVAL; 452 return -EINVAL;
453 453
454 /* A '\0' or a ',' signal the end of the chunk */ 454 /* A '\0' or a ',' signal the end of the chunk */
455 if (c == '\0' || c == ',') 455 if (c == '\0' || c == ',')
456 break; 456 break;
457 457
458 if (!isxdigit(c)) 458 if (!isxdigit(c))
459 return -EINVAL; 459 return -EINVAL;
460 460
461 /* 461 /*
462 * Make sure there are at least 4 free bits in 'chunk'. 462 * Make sure there are at least 4 free bits in 'chunk'.
463 * If not, this hexdigit will overflow 'chunk', so 463 * If not, this hexdigit will overflow 'chunk', so
464 * throw an error. 464 * throw an error.
465 */ 465 */
466 if (chunk & ~((1UL << (CHUNKSZ - 4)) - 1)) 466 if (chunk & ~((1UL << (CHUNKSZ - 4)) - 1))
467 return -EOVERFLOW; 467 return -EOVERFLOW;
468 468
469 chunk = (chunk << 4) | unhex(c); 469 chunk = (chunk << 4) | unhex(c);
470 ndigits++; totaldigits++; 470 ndigits++; totaldigits++;
471 } 471 }
472 if (ndigits == 0) 472 if (ndigits == 0)
473 return -EINVAL; 473 return -EINVAL;
474 if (nchunks == 0 && chunk == 0) 474 if (nchunks == 0 && chunk == 0)
475 continue; 475 continue;
476 476
477 __bitmap_shift_left(maskp, maskp, CHUNKSZ, nmaskbits); 477 __bitmap_shift_left(maskp, maskp, CHUNKSZ, nmaskbits);
478 *maskp |= chunk; 478 *maskp |= chunk;
479 nchunks++; 479 nchunks++;
480 nbits += (nchunks == 1) ? nbits_to_hold_value(chunk) : CHUNKSZ; 480 nbits += (nchunks == 1) ? nbits_to_hold_value(chunk) : CHUNKSZ;
481 if (nbits > nmaskbits) 481 if (nbits > nmaskbits)
482 return -EOVERFLOW; 482 return -EOVERFLOW;
483 } while (buflen && c == ','); 483 } while (buflen && c == ',');
484 484
485 return 0; 485 return 0;
486 } 486 }
487 EXPORT_SYMBOL(__bitmap_parse); 487 EXPORT_SYMBOL(__bitmap_parse);
488 488
489 /** 489 /**
490 * bitmap_parse_user() 490 * bitmap_parse_user - convert an ASCII hex string in a user buffer into a bitmap
491 * 491 *
492 * @ubuf: pointer to user buffer containing string. 492 * @ubuf: pointer to user buffer containing string.
493 * @ulen: buffer size in bytes. If string is smaller than this 493 * @ulen: buffer size in bytes. If string is smaller than this
494 * then it must be terminated with a \0. 494 * then it must be terminated with a \0.
495 * @maskp: pointer to bitmap array that will contain result. 495 * @maskp: pointer to bitmap array that will contain result.
496 * @nmaskbits: size of bitmap, in bits. 496 * @nmaskbits: size of bitmap, in bits.
497 * 497 *
498 * Wrapper for __bitmap_parse(), providing it with user buffer. 498 * Wrapper for __bitmap_parse(), providing it with user buffer.
499 * 499 *
500 * We cannot have this as an inline function in bitmap.h because it needs 500 * We cannot have this as an inline function in bitmap.h because it needs
501 * linux/uaccess.h to get the access_ok() declaration and this causes 501 * linux/uaccess.h to get the access_ok() declaration and this causes
502 * cyclic dependencies. 502 * cyclic dependencies.
503 */ 503 */
504 int bitmap_parse_user(const char __user *ubuf, 504 int bitmap_parse_user(const char __user *ubuf,
505 unsigned int ulen, unsigned long *maskp, 505 unsigned int ulen, unsigned long *maskp,
506 int nmaskbits) 506 int nmaskbits)
507 { 507 {
508 if (!access_ok(VERIFY_READ, ubuf, ulen)) 508 if (!access_ok(VERIFY_READ, ubuf, ulen))
509 return -EFAULT; 509 return -EFAULT;
510 return __bitmap_parse((const char *)ubuf, ulen, 1, maskp, nmaskbits); 510 return __bitmap_parse((const char *)ubuf, ulen, 1, maskp, nmaskbits);
511 } 511 }
512 EXPORT_SYMBOL(bitmap_parse_user); 512 EXPORT_SYMBOL(bitmap_parse_user);
513 513
514 /* 514 /*
515 * bscnl_emit(buf, buflen, rbot, rtop, bp) 515 * bscnl_emit(buf, buflen, rbot, rtop, bp)
516 * 516 *
517 * Helper routine for bitmap_scnlistprintf(). Write decimal number 517 * Helper routine for bitmap_scnlistprintf(). Write decimal number
518 * or range to buf, suppressing output past buf+buflen, with optional 518 * or range to buf, suppressing output past buf+buflen, with optional
519 * comma-prefix. Return len of what would be written to buf, if it 519 * comma-prefix. Return len of what would be written to buf, if it
520 * all fit. 520 * all fit.
521 */ 521 */
522 static inline int bscnl_emit(char *buf, int buflen, int rbot, int rtop, int len) 522 static inline int bscnl_emit(char *buf, int buflen, int rbot, int rtop, int len)
523 { 523 {
524 if (len > 0) 524 if (len > 0)
525 len += scnprintf(buf + len, buflen - len, ","); 525 len += scnprintf(buf + len, buflen - len, ",");
526 if (rbot == rtop) 526 if (rbot == rtop)
527 len += scnprintf(buf + len, buflen - len, "%d", rbot); 527 len += scnprintf(buf + len, buflen - len, "%d", rbot);
528 else 528 else
529 len += scnprintf(buf + len, buflen - len, "%d-%d", rbot, rtop); 529 len += scnprintf(buf + len, buflen - len, "%d-%d", rbot, rtop);
530 return len; 530 return len;
531 } 531 }
532 532
533 /** 533 /**
534 * bitmap_scnlistprintf - convert bitmap to list format ASCII string 534 * bitmap_scnlistprintf - convert bitmap to list format ASCII string
535 * @buf: byte buffer into which string is placed 535 * @buf: byte buffer into which string is placed
536 * @buflen: reserved size of @buf, in bytes 536 * @buflen: reserved size of @buf, in bytes
537 * @maskp: pointer to bitmap to convert 537 * @maskp: pointer to bitmap to convert
538 * @nmaskbits: size of bitmap, in bits 538 * @nmaskbits: size of bitmap, in bits
539 * 539 *
540 * Output format is a comma-separated list of decimal numbers and 540 * Output format is a comma-separated list of decimal numbers and
541 * ranges. Consecutively set bits are shown as two hyphen-separated 541 * ranges. Consecutively set bits are shown as two hyphen-separated
542 * decimal numbers, the smallest and largest bit numbers set in 542 * decimal numbers, the smallest and largest bit numbers set in
543 * the range. Output format is compatible with the format 543 * the range. Output format is compatible with the format
544 * accepted as input by bitmap_parselist(). 544 * accepted as input by bitmap_parselist().
545 * 545 *
546 * The return value is the number of characters which would be 546 * The return value is the number of characters which would be
547 * generated for the given input, excluding the trailing '\0', as 547 * generated for the given input, excluding the trailing '\0', as
548 * per ISO C99. 548 * per ISO C99.
549 */ 549 */
550 int bitmap_scnlistprintf(char *buf, unsigned int buflen, 550 int bitmap_scnlistprintf(char *buf, unsigned int buflen,
551 const unsigned long *maskp, int nmaskbits) 551 const unsigned long *maskp, int nmaskbits)
552 { 552 {
553 int len = 0; 553 int len = 0;
554 /* current bit is 'cur', most recently seen range is [rbot, rtop] */ 554 /* current bit is 'cur', most recently seen range is [rbot, rtop] */
555 int cur, rbot, rtop; 555 int cur, rbot, rtop;
556 556
557 if (buflen == 0) 557 if (buflen == 0)
558 return 0; 558 return 0;
559 buf[0] = 0; 559 buf[0] = 0;
560 560
561 rbot = cur = find_first_bit(maskp, nmaskbits); 561 rbot = cur = find_first_bit(maskp, nmaskbits);
562 while (cur < nmaskbits) { 562 while (cur < nmaskbits) {
563 rtop = cur; 563 rtop = cur;
564 cur = find_next_bit(maskp, nmaskbits, cur+1); 564 cur = find_next_bit(maskp, nmaskbits, cur+1);
565 if (cur >= nmaskbits || cur > rtop + 1) { 565 if (cur >= nmaskbits || cur > rtop + 1) {
566 len = bscnl_emit(buf, buflen, rbot, rtop, len); 566 len = bscnl_emit(buf, buflen, rbot, rtop, len);
567 rbot = cur; 567 rbot = cur;
568 } 568 }
569 } 569 }
570 return len; 570 return len;
571 } 571 }
572 EXPORT_SYMBOL(bitmap_scnlistprintf); 572 EXPORT_SYMBOL(bitmap_scnlistprintf);
573 573
574 /** 574 /**
575 * bitmap_parselist - convert list format ASCII string to bitmap 575 * bitmap_parselist - convert list format ASCII string to bitmap
576 * @bp: read nul-terminated user string from this buffer 576 * @bp: read nul-terminated user string from this buffer
577 * @maskp: write resulting mask here 577 * @maskp: write resulting mask here
578 * @nmaskbits: number of bits in mask to be written 578 * @nmaskbits: number of bits in mask to be written
579 * 579 *
580 * Input format is a comma-separated list of decimal numbers and 580 * Input format is a comma-separated list of decimal numbers and
581 * ranges. Consecutively set bits are shown as two hyphen-separated 581 * ranges. Consecutively set bits are shown as two hyphen-separated
582 * decimal numbers, the smallest and largest bit numbers set in 582 * decimal numbers, the smallest and largest bit numbers set in
583 * the range. 583 * the range.
584 * 584 *
585 * Returns 0 on success, -errno on invalid input strings. 585 * Returns 0 on success, -errno on invalid input strings.
586 * Error values: 586 * Error values:
587 * %-EINVAL: second number in range smaller than first 587 * %-EINVAL: second number in range smaller than first
588 * %-EINVAL: invalid character in string 588 * %-EINVAL: invalid character in string
589 * %-ERANGE: bit number specified too large for mask 589 * %-ERANGE: bit number specified too large for mask
590 */ 590 */
591 int bitmap_parselist(const char *bp, unsigned long *maskp, int nmaskbits) 591 int bitmap_parselist(const char *bp, unsigned long *maskp, int nmaskbits)
592 { 592 {
593 unsigned a, b; 593 unsigned a, b;
594 594
595 bitmap_zero(maskp, nmaskbits); 595 bitmap_zero(maskp, nmaskbits);
596 do { 596 do {
597 if (!isdigit(*bp)) 597 if (!isdigit(*bp))
598 return -EINVAL; 598 return -EINVAL;
599 b = a = simple_strtoul(bp, (char **)&bp, BASEDEC); 599 b = a = simple_strtoul(bp, (char **)&bp, BASEDEC);
600 if (*bp == '-') { 600 if (*bp == '-') {
601 bp++; 601 bp++;
602 if (!isdigit(*bp)) 602 if (!isdigit(*bp))
603 return -EINVAL; 603 return -EINVAL;
604 b = simple_strtoul(bp, (char **)&bp, BASEDEC); 604 b = simple_strtoul(bp, (char **)&bp, BASEDEC);
605 } 605 }
606 if (!(a <= b)) 606 if (!(a <= b))
607 return -EINVAL; 607 return -EINVAL;
608 if (b >= nmaskbits) 608 if (b >= nmaskbits)
609 return -ERANGE; 609 return -ERANGE;
610 while (a <= b) { 610 while (a <= b) {
611 set_bit(a, maskp); 611 set_bit(a, maskp);
612 a++; 612 a++;
613 } 613 }
614 if (*bp == ',') 614 if (*bp == ',')
615 bp++; 615 bp++;
616 } while (*bp != '\0' && *bp != '\n'); 616 } while (*bp != '\0' && *bp != '\n');
617 return 0; 617 return 0;
618 } 618 }
619 EXPORT_SYMBOL(bitmap_parselist); 619 EXPORT_SYMBOL(bitmap_parselist);
620 620
621 /** 621 /**
622 * bitmap_pos_to_ord(buf, pos, bits) 622 * bitmap_pos_to_ord - find ordinal of set bit at given position in bitmap
623 * @buf: pointer to a bitmap 623 * @buf: pointer to a bitmap
624 * @pos: a bit position in @buf (0 <= @pos < @bits) 624 * @pos: a bit position in @buf (0 <= @pos < @bits)
625 * @bits: number of valid bit positions in @buf 625 * @bits: number of valid bit positions in @buf
626 * 626 *
627 * Map the bit at position @pos in @buf (of length @bits) to the 627 * Map the bit at position @pos in @buf (of length @bits) to the
628 * ordinal of which set bit it is. If it is not set or if @pos 628 * ordinal of which set bit it is. If it is not set or if @pos
629 * is not a valid bit position, map to -1. 629 * is not a valid bit position, map to -1.
630 * 630 *
631 * If for example, just bits 4 through 7 are set in @buf, then @pos 631 * If for example, just bits 4 through 7 are set in @buf, then @pos
632 * values 4 through 7 will get mapped to 0 through 3, respectively, 632 * values 4 through 7 will get mapped to 0 through 3, respectively,
633 * and other @pos values will get mapped to 0. When @pos value 7 633 * and other @pos values will get mapped to 0. When @pos value 7
634 * gets mapped to (returns) @ord value 3 in this example, that means 634 * gets mapped to (returns) @ord value 3 in this example, that means
635 * that bit 7 is the 3rd (starting with 0th) set bit in @buf. 635 * that bit 7 is the 3rd (starting with 0th) set bit in @buf.
636 * 636 *
637 * The bit positions 0 through @bits are valid positions in @buf. 637 * The bit positions 0 through @bits are valid positions in @buf.
638 */ 638 */
639 static int bitmap_pos_to_ord(const unsigned long *buf, int pos, int bits) 639 static int bitmap_pos_to_ord(const unsigned long *buf, int pos, int bits)
640 { 640 {
641 int i, ord; 641 int i, ord;
642 642
643 if (pos < 0 || pos >= bits || !test_bit(pos, buf)) 643 if (pos < 0 || pos >= bits || !test_bit(pos, buf))
644 return -1; 644 return -1;
645 645
646 i = find_first_bit(buf, bits); 646 i = find_first_bit(buf, bits);
647 ord = 0; 647 ord = 0;
648 while (i < pos) { 648 while (i < pos) {
649 i = find_next_bit(buf, bits, i + 1); 649 i = find_next_bit(buf, bits, i + 1);
650 ord++; 650 ord++;
651 } 651 }
652 BUG_ON(i != pos); 652 BUG_ON(i != pos);
653 653
654 return ord; 654 return ord;
655 } 655 }
656 656
657 /** 657 /**
658 * bitmap_ord_to_pos(buf, ord, bits) 658 * bitmap_ord_to_pos - find position of n-th set bit in bitmap
659 * @buf: pointer to bitmap 659 * @buf: pointer to bitmap
660 * @ord: ordinal bit position (n-th set bit, n >= 0) 660 * @ord: ordinal bit position (n-th set bit, n >= 0)
661 * @bits: number of valid bit positions in @buf 661 * @bits: number of valid bit positions in @buf
662 * 662 *
663 * Map the ordinal offset of bit @ord in @buf to its position in @buf. 663 * Map the ordinal offset of bit @ord in @buf to its position in @buf.
664 * Value of @ord should be in range 0 <= @ord < weight(buf), else 664 * Value of @ord should be in range 0 <= @ord < weight(buf), else
665 * results are undefined. 665 * results are undefined.
666 * 666 *
667 * If for example, just bits 4 through 7 are set in @buf, then @ord 667 * If for example, just bits 4 through 7 are set in @buf, then @ord
668 * values 0 through 3 will get mapped to 4 through 7, respectively, 668 * values 0 through 3 will get mapped to 4 through 7, respectively,
669 * and all other @ord values return undefined values. When @ord value 3 669 * and all other @ord values return undefined values. When @ord value 3
670 * gets mapped to (returns) @pos value 7 in this example, that means 670 * gets mapped to (returns) @pos value 7 in this example, that means
671 * that the 3rd set bit (starting with 0th) is at position 7 in @buf. 671 * that the 3rd set bit (starting with 0th) is at position 7 in @buf.
672 * 672 *
673 * The bit positions 0 through @bits are valid positions in @buf. 673 * The bit positions 0 through @bits are valid positions in @buf.
674 */ 674 */
675 static int bitmap_ord_to_pos(const unsigned long *buf, int ord, int bits) 675 static int bitmap_ord_to_pos(const unsigned long *buf, int ord, int bits)
676 { 676 {
677 int pos = 0; 677 int pos = 0;
678 678
679 if (ord >= 0 && ord < bits) { 679 if (ord >= 0 && ord < bits) {
680 int i; 680 int i;
681 681
682 for (i = find_first_bit(buf, bits); 682 for (i = find_first_bit(buf, bits);
683 i < bits && ord > 0; 683 i < bits && ord > 0;
684 i = find_next_bit(buf, bits, i + 1)) 684 i = find_next_bit(buf, bits, i + 1))
685 ord--; 685 ord--;
686 if (i < bits && ord == 0) 686 if (i < bits && ord == 0)
687 pos = i; 687 pos = i;
688 } 688 }
689 689
690 return pos; 690 return pos;
691 } 691 }
692 692
693 /** 693 /**
694 * bitmap_remap - Apply map defined by a pair of bitmaps to another bitmap 694 * bitmap_remap - Apply map defined by a pair of bitmaps to another bitmap
695 * @dst: remapped result 695 * @dst: remapped result
696 * @src: subset to be remapped 696 * @src: subset to be remapped
697 * @old: defines domain of map 697 * @old: defines domain of map
698 * @new: defines range of map 698 * @new: defines range of map
699 * @bits: number of bits in each of these bitmaps 699 * @bits: number of bits in each of these bitmaps
700 * 700 *
701 * Let @old and @new define a mapping of bit positions, such that 701 * Let @old and @new define a mapping of bit positions, such that
702 * whatever position is held by the n-th set bit in @old is mapped 702 * whatever position is held by the n-th set bit in @old is mapped
703 * to the n-th set bit in @new. In the more general case, allowing 703 * to the n-th set bit in @new. In the more general case, allowing
704 * for the possibility that the weight 'w' of @new is less than the 704 * for the possibility that the weight 'w' of @new is less than the
705 * weight of @old, map the position of the n-th set bit in @old to 705 * weight of @old, map the position of the n-th set bit in @old to
706 * the position of the m-th set bit in @new, where m == n % w. 706 * the position of the m-th set bit in @new, where m == n % w.
707 * 707 *
708 * If either of the @old and @new bitmaps are empty, or if @src and 708 * If either of the @old and @new bitmaps are empty, or if @src and
709 * @dst point to the same location, then this routine copies @src 709 * @dst point to the same location, then this routine copies @src
710 * to @dst. 710 * to @dst.
711 * 711 *
712 * The positions of unset bits in @old are mapped to themselves 712 * The positions of unset bits in @old are mapped to themselves
713 * (the identify map). 713 * (the identify map).
714 * 714 *
715 * Apply the above specified mapping to @src, placing the result in 715 * Apply the above specified mapping to @src, placing the result in
716 * @dst, clearing any bits previously set in @dst. 716 * @dst, clearing any bits previously set in @dst.
717 * 717 *
718 * For example, lets say that @old has bits 4 through 7 set, and 718 * For example, lets say that @old has bits 4 through 7 set, and
719 * @new has bits 12 through 15 set. This defines the mapping of bit 719 * @new has bits 12 through 15 set. This defines the mapping of bit
720 * position 4 to 12, 5 to 13, 6 to 14 and 7 to 15, and of all other 720 * position 4 to 12, 5 to 13, 6 to 14 and 7 to 15, and of all other
721 * bit positions unchanged. So if say @src comes into this routine 721 * bit positions unchanged. So if say @src comes into this routine
722 * with bits 1, 5 and 7 set, then @dst should leave with bits 1, 722 * with bits 1, 5 and 7 set, then @dst should leave with bits 1,
723 * 13 and 15 set. 723 * 13 and 15 set.
724 */ 724 */
725 void bitmap_remap(unsigned long *dst, const unsigned long *src, 725 void bitmap_remap(unsigned long *dst, const unsigned long *src,
726 const unsigned long *old, const unsigned long *new, 726 const unsigned long *old, const unsigned long *new,
727 int bits) 727 int bits)
728 { 728 {
729 int oldbit, w; 729 int oldbit, w;
730 730
731 if (dst == src) /* following doesn't handle inplace remaps */ 731 if (dst == src) /* following doesn't handle inplace remaps */
732 return; 732 return;
733 bitmap_zero(dst, bits); 733 bitmap_zero(dst, bits);
734 734
735 w = bitmap_weight(new, bits); 735 w = bitmap_weight(new, bits);
736 for (oldbit = find_first_bit(src, bits); 736 for (oldbit = find_first_bit(src, bits);
737 oldbit < bits; 737 oldbit < bits;
738 oldbit = find_next_bit(src, bits, oldbit + 1)) { 738 oldbit = find_next_bit(src, bits, oldbit + 1)) {
739 int n = bitmap_pos_to_ord(old, oldbit, bits); 739 int n = bitmap_pos_to_ord(old, oldbit, bits);
740 if (n < 0 || w == 0) 740 if (n < 0 || w == 0)
741 set_bit(oldbit, dst); /* identity map */ 741 set_bit(oldbit, dst); /* identity map */
742 else 742 else
743 set_bit(bitmap_ord_to_pos(new, n % w, bits), dst); 743 set_bit(bitmap_ord_to_pos(new, n % w, bits), dst);
744 } 744 }
745 } 745 }
746 EXPORT_SYMBOL(bitmap_remap); 746 EXPORT_SYMBOL(bitmap_remap);
747 747
748 /** 748 /**
749 * bitmap_bitremap - Apply map defined by a pair of bitmaps to a single bit 749 * bitmap_bitremap - Apply map defined by a pair of bitmaps to a single bit
750 * @oldbit: bit position to be mapped 750 * @oldbit: bit position to be mapped
751 * @old: defines domain of map 751 * @old: defines domain of map
752 * @new: defines range of map 752 * @new: defines range of map
753 * @bits: number of bits in each of these bitmaps 753 * @bits: number of bits in each of these bitmaps
754 * 754 *
755 * Let @old and @new define a mapping of bit positions, such that 755 * Let @old and @new define a mapping of bit positions, such that
756 * whatever position is held by the n-th set bit in @old is mapped 756 * whatever position is held by the n-th set bit in @old is mapped
757 * to the n-th set bit in @new. In the more general case, allowing 757 * to the n-th set bit in @new. In the more general case, allowing
758 * for the possibility that the weight 'w' of @new is less than the 758 * for the possibility that the weight 'w' of @new is less than the
759 * weight of @old, map the position of the n-th set bit in @old to 759 * weight of @old, map the position of the n-th set bit in @old to
760 * the position of the m-th set bit in @new, where m == n % w. 760 * the position of the m-th set bit in @new, where m == n % w.
761 * 761 *
762 * The positions of unset bits in @old are mapped to themselves 762 * The positions of unset bits in @old are mapped to themselves
763 * (the identify map). 763 * (the identify map).
764 * 764 *
765 * Apply the above specified mapping to bit position @oldbit, returning 765 * Apply the above specified mapping to bit position @oldbit, returning
766 * the new bit position. 766 * the new bit position.
767 * 767 *
768 * For example, lets say that @old has bits 4 through 7 set, and 768 * For example, lets say that @old has bits 4 through 7 set, and
769 * @new has bits 12 through 15 set. This defines the mapping of bit 769 * @new has bits 12 through 15 set. This defines the mapping of bit
770 * position 4 to 12, 5 to 13, 6 to 14 and 7 to 15, and of all other 770 * position 4 to 12, 5 to 13, 6 to 14 and 7 to 15, and of all other
771 * bit positions unchanged. So if say @oldbit is 5, then this routine 771 * bit positions unchanged. So if say @oldbit is 5, then this routine
772 * returns 13. 772 * returns 13.
773 */ 773 */
774 int bitmap_bitremap(int oldbit, const unsigned long *old, 774 int bitmap_bitremap(int oldbit, const unsigned long *old,
775 const unsigned long *new, int bits) 775 const unsigned long *new, int bits)
776 { 776 {
777 int w = bitmap_weight(new, bits); 777 int w = bitmap_weight(new, bits);
778 int n = bitmap_pos_to_ord(old, oldbit, bits); 778 int n = bitmap_pos_to_ord(old, oldbit, bits);
779 if (n < 0 || w == 0) 779 if (n < 0 || w == 0)
780 return oldbit; 780 return oldbit;
781 else 781 else
782 return bitmap_ord_to_pos(new, n % w, bits); 782 return bitmap_ord_to_pos(new, n % w, bits);
783 } 783 }
784 EXPORT_SYMBOL(bitmap_bitremap); 784 EXPORT_SYMBOL(bitmap_bitremap);
785 785
786 /** 786 /**
787 * bitmap_onto - translate one bitmap relative to another 787 * bitmap_onto - translate one bitmap relative to another
788 * @dst: resulting translated bitmap 788 * @dst: resulting translated bitmap
789 * @orig: original untranslated bitmap 789 * @orig: original untranslated bitmap
790 * @relmap: bitmap relative to which translated 790 * @relmap: bitmap relative to which translated
791 * @bits: number of bits in each of these bitmaps 791 * @bits: number of bits in each of these bitmaps
792 * 792 *
793 * Set the n-th bit of @dst iff there exists some m such that the 793 * Set the n-th bit of @dst iff there exists some m such that the
794 * n-th bit of @relmap is set, the m-th bit of @orig is set, and 794 * n-th bit of @relmap is set, the m-th bit of @orig is set, and
795 * the n-th bit of @relmap is also the m-th _set_ bit of @relmap. 795 * the n-th bit of @relmap is also the m-th _set_ bit of @relmap.
796 * (If you understood the previous sentence the first time your 796 * (If you understood the previous sentence the first time your
797 * read it, you're overqualified for your current job.) 797 * read it, you're overqualified for your current job.)
798 * 798 *
799 * In other words, @orig is mapped onto (surjectively) @dst, 799 * In other words, @orig is mapped onto (surjectively) @dst,
800 * using the the map { <n, m> | the n-th bit of @relmap is the 800 * using the the map { <n, m> | the n-th bit of @relmap is the
801 * m-th set bit of @relmap }. 801 * m-th set bit of @relmap }.
802 * 802 *
803 * Any set bits in @orig above bit number W, where W is the 803 * Any set bits in @orig above bit number W, where W is the
804 * weight of (number of set bits in) @relmap are mapped nowhere. 804 * weight of (number of set bits in) @relmap are mapped nowhere.
805 * In particular, if for all bits m set in @orig, m >= W, then 805 * In particular, if for all bits m set in @orig, m >= W, then
806 * @dst will end up empty. In situations where the possibility 806 * @dst will end up empty. In situations where the possibility
807 * of such an empty result is not desired, one way to avoid it is 807 * of such an empty result is not desired, one way to avoid it is
808 * to use the bitmap_fold() operator, below, to first fold the 808 * to use the bitmap_fold() operator, below, to first fold the
809 * @orig bitmap over itself so that all its set bits x are in the 809 * @orig bitmap over itself so that all its set bits x are in the
810 * range 0 <= x < W. The bitmap_fold() operator does this by 810 * range 0 <= x < W. The bitmap_fold() operator does this by
811 * setting the bit (m % W) in @dst, for each bit (m) set in @orig. 811 * setting the bit (m % W) in @dst, for each bit (m) set in @orig.
812 * 812 *
813 * Example [1] for bitmap_onto(): 813 * Example [1] for bitmap_onto():
814 * Let's say @relmap has bits 30-39 set, and @orig has bits 814 * Let's say @relmap has bits 30-39 set, and @orig has bits
815 * 1, 3, 5, 7, 9 and 11 set. Then on return from this routine, 815 * 1, 3, 5, 7, 9 and 11 set. Then on return from this routine,
816 * @dst will have bits 31, 33, 35, 37 and 39 set. 816 * @dst will have bits 31, 33, 35, 37 and 39 set.
817 * 817 *
818 * When bit 0 is set in @orig, it means turn on the bit in 818 * When bit 0 is set in @orig, it means turn on the bit in
819 * @dst corresponding to whatever is the first bit (if any) 819 * @dst corresponding to whatever is the first bit (if any)
820 * that is turned on in @relmap. Since bit 0 was off in the 820 * that is turned on in @relmap. Since bit 0 was off in the
821 * above example, we leave off that bit (bit 30) in @dst. 821 * above example, we leave off that bit (bit 30) in @dst.
822 * 822 *
823 * When bit 1 is set in @orig (as in the above example), it 823 * When bit 1 is set in @orig (as in the above example), it
824 * means turn on the bit in @dst corresponding to whatever 824 * means turn on the bit in @dst corresponding to whatever
825 * is the second bit that is turned on in @relmap. The second 825 * is the second bit that is turned on in @relmap. The second
826 * bit in @relmap that was turned on in the above example was 826 * bit in @relmap that was turned on in the above example was
827 * bit 31, so we turned on bit 31 in @dst. 827 * bit 31, so we turned on bit 31 in @dst.
828 * 828 *
829 * Similarly, we turned on bits 33, 35, 37 and 39 in @dst, 829 * Similarly, we turned on bits 33, 35, 37 and 39 in @dst,
830 * because they were the 4th, 6th, 8th and 10th set bits 830 * because they were the 4th, 6th, 8th and 10th set bits
831 * set in @relmap, and the 4th, 6th, 8th and 10th bits of 831 * set in @relmap, and the 4th, 6th, 8th and 10th bits of
832 * @orig (i.e. bits 3, 5, 7 and 9) were also set. 832 * @orig (i.e. bits 3, 5, 7 and 9) were also set.
833 * 833 *
834 * When bit 11 is set in @orig, it means turn on the bit in 834 * When bit 11 is set in @orig, it means turn on the bit in
835 * @dst corresponding to whatever is the twelth bit that is 835 * @dst corresponding to whatever is the twelth bit that is
836 * turned on in @relmap. In the above example, there were 836 * turned on in @relmap. In the above example, there were
837 * only ten bits turned on in @relmap (30..39), so that bit 837 * only ten bits turned on in @relmap (30..39), so that bit
838 * 11 was set in @orig had no affect on @dst. 838 * 11 was set in @orig had no affect on @dst.
839 * 839 *
840 * Example [2] for bitmap_fold() + bitmap_onto(): 840 * Example [2] for bitmap_fold() + bitmap_onto():
841 * Let's say @relmap has these ten bits set: 841 * Let's say @relmap has these ten bits set:
842 * 40 41 42 43 45 48 53 61 74 95 842 * 40 41 42 43 45 48 53 61 74 95
843 * (for the curious, that's 40 plus the first ten terms of the 843 * (for the curious, that's 40 plus the first ten terms of the
844 * Fibonacci sequence.) 844 * Fibonacci sequence.)
845 * 845 *
846 * Further lets say we use the following code, invoking 846 * Further lets say we use the following code, invoking
847 * bitmap_fold() then bitmap_onto, as suggested above to 847 * bitmap_fold() then bitmap_onto, as suggested above to
848 * avoid the possitility of an empty @dst result: 848 * avoid the possitility of an empty @dst result:
849 * 849 *
850 * unsigned long *tmp; // a temporary bitmap's bits 850 * unsigned long *tmp; // a temporary bitmap's bits
851 * 851 *
852 * bitmap_fold(tmp, orig, bitmap_weight(relmap, bits), bits); 852 * bitmap_fold(tmp, orig, bitmap_weight(relmap, bits), bits);
853 * bitmap_onto(dst, tmp, relmap, bits); 853 * bitmap_onto(dst, tmp, relmap, bits);
854 * 854 *
855 * Then this table shows what various values of @dst would be, for 855 * Then this table shows what various values of @dst would be, for
856 * various @orig's. I list the zero-based positions of each set bit. 856 * various @orig's. I list the zero-based positions of each set bit.
857 * The tmp column shows the intermediate result, as computed by 857 * The tmp column shows the intermediate result, as computed by
858 * using bitmap_fold() to fold the @orig bitmap modulo ten 858 * using bitmap_fold() to fold the @orig bitmap modulo ten
859 * (the weight of @relmap). 859 * (the weight of @relmap).
860 * 860 *
861 * @orig tmp @dst 861 * @orig tmp @dst
862 * 0 0 40 862 * 0 0 40
863 * 1 1 41 863 * 1 1 41
864 * 9 9 95 864 * 9 9 95
865 * 10 0 40 (*) 865 * 10 0 40 (*)
866 * 1 3 5 7 1 3 5 7 41 43 48 61 866 * 1 3 5 7 1 3 5 7 41 43 48 61
867 * 0 1 2 3 4 0 1 2 3 4 40 41 42 43 45 867 * 0 1 2 3 4 0 1 2 3 4 40 41 42 43 45
868 * 0 9 18 27 0 9 8 7 40 61 74 95 868 * 0 9 18 27 0 9 8 7 40 61 74 95
869 * 0 10 20 30 0 40 869 * 0 10 20 30 0 40
870 * 0 11 22 33 0 1 2 3 40 41 42 43 870 * 0 11 22 33 0 1 2 3 40 41 42 43
871 * 0 12 24 36 0 2 4 6 40 42 45 53 871 * 0 12 24 36 0 2 4 6 40 42 45 53
872 * 78 102 211 1 2 8 41 42 74 (*) 872 * 78 102 211 1 2 8 41 42 74 (*)
873 * 873 *
874 * (*) For these marked lines, if we hadn't first done bitmap_fold() 874 * (*) For these marked lines, if we hadn't first done bitmap_fold()
875 * into tmp, then the @dst result would have been empty. 875 * into tmp, then the @dst result would have been empty.
876 * 876 *
877 * If either of @orig or @relmap is empty (no set bits), then @dst 877 * If either of @orig or @relmap is empty (no set bits), then @dst
878 * will be returned empty. 878 * will be returned empty.
879 * 879 *
880 * If (as explained above) the only set bits in @orig are in positions 880 * If (as explained above) the only set bits in @orig are in positions
881 * m where m >= W, (where W is the weight of @relmap) then @dst will 881 * m where m >= W, (where W is the weight of @relmap) then @dst will
882 * once again be returned empty. 882 * once again be returned empty.
883 * 883 *
884 * All bits in @dst not set by the above rule are cleared. 884 * All bits in @dst not set by the above rule are cleared.
885 */ 885 */
886 void bitmap_onto(unsigned long *dst, const unsigned long *orig, 886 void bitmap_onto(unsigned long *dst, const unsigned long *orig,
887 const unsigned long *relmap, int bits) 887 const unsigned long *relmap, int bits)
888 { 888 {
889 int n, m; /* same meaning as in above comment */ 889 int n, m; /* same meaning as in above comment */
890 890
891 if (dst == orig) /* following doesn't handle inplace mappings */ 891 if (dst == orig) /* following doesn't handle inplace mappings */
892 return; 892 return;
893 bitmap_zero(dst, bits); 893 bitmap_zero(dst, bits);
894 894
895 /* 895 /*
896 * The following code is a more efficient, but less 896 * The following code is a more efficient, but less
897 * obvious, equivalent to the loop: 897 * obvious, equivalent to the loop:
898 * for (m = 0; m < bitmap_weight(relmap, bits); m++) { 898 * for (m = 0; m < bitmap_weight(relmap, bits); m++) {
899 * n = bitmap_ord_to_pos(orig, m, bits); 899 * n = bitmap_ord_to_pos(orig, m, bits);
900 * if (test_bit(m, orig)) 900 * if (test_bit(m, orig))
901 * set_bit(n, dst); 901 * set_bit(n, dst);
902 * } 902 * }
903 */ 903 */
904 904
905 m = 0; 905 m = 0;
906 for (n = find_first_bit(relmap, bits); 906 for (n = find_first_bit(relmap, bits);
907 n < bits; 907 n < bits;
908 n = find_next_bit(relmap, bits, n + 1)) { 908 n = find_next_bit(relmap, bits, n + 1)) {
909 /* m == bitmap_pos_to_ord(relmap, n, bits) */ 909 /* m == bitmap_pos_to_ord(relmap, n, bits) */
910 if (test_bit(m, orig)) 910 if (test_bit(m, orig))
911 set_bit(n, dst); 911 set_bit(n, dst);
912 m++; 912 m++;
913 } 913 }
914 } 914 }
915 EXPORT_SYMBOL(bitmap_onto); 915 EXPORT_SYMBOL(bitmap_onto);
916 916
917 /** 917 /**
918 * bitmap_fold - fold larger bitmap into smaller, modulo specified size 918 * bitmap_fold - fold larger bitmap into smaller, modulo specified size
919 * @dst: resulting smaller bitmap 919 * @dst: resulting smaller bitmap
920 * @orig: original larger bitmap 920 * @orig: original larger bitmap
921 * @sz: specified size 921 * @sz: specified size
922 * @bits: number of bits in each of these bitmaps 922 * @bits: number of bits in each of these bitmaps
923 * 923 *
924 * For each bit oldbit in @orig, set bit oldbit mod @sz in @dst. 924 * For each bit oldbit in @orig, set bit oldbit mod @sz in @dst.
925 * Clear all other bits in @dst. See further the comment and 925 * Clear all other bits in @dst. See further the comment and
926 * Example [2] for bitmap_onto() for why and how to use this. 926 * Example [2] for bitmap_onto() for why and how to use this.
927 */ 927 */
928 void bitmap_fold(unsigned long *dst, const unsigned long *orig, 928 void bitmap_fold(unsigned long *dst, const unsigned long *orig,
929 int sz, int bits) 929 int sz, int bits)
930 { 930 {
931 int oldbit; 931 int oldbit;
932 932
933 if (dst == orig) /* following doesn't handle inplace mappings */ 933 if (dst == orig) /* following doesn't handle inplace mappings */
934 return; 934 return;
935 bitmap_zero(dst, bits); 935 bitmap_zero(dst, bits);
936 936
937 for (oldbit = find_first_bit(orig, bits); 937 for (oldbit = find_first_bit(orig, bits);
938 oldbit < bits; 938 oldbit < bits;
939 oldbit = find_next_bit(orig, bits, oldbit + 1)) 939 oldbit = find_next_bit(orig, bits, oldbit + 1))
940 set_bit(oldbit % sz, dst); 940 set_bit(oldbit % sz, dst);
941 } 941 }
942 EXPORT_SYMBOL(bitmap_fold); 942 EXPORT_SYMBOL(bitmap_fold);
943 943
944 /* 944 /*
945 * Common code for bitmap_*_region() routines. 945 * Common code for bitmap_*_region() routines.
946 * bitmap: array of unsigned longs corresponding to the bitmap 946 * bitmap: array of unsigned longs corresponding to the bitmap
947 * pos: the beginning of the region 947 * pos: the beginning of the region
948 * order: region size (log base 2 of number of bits) 948 * order: region size (log base 2 of number of bits)
949 * reg_op: operation(s) to perform on that region of bitmap 949 * reg_op: operation(s) to perform on that region of bitmap
950 * 950 *
951 * Can set, verify and/or release a region of bits in a bitmap, 951 * Can set, verify and/or release a region of bits in a bitmap,
952 * depending on which combination of REG_OP_* flag bits is set. 952 * depending on which combination of REG_OP_* flag bits is set.
953 * 953 *
954 * A region of a bitmap is a sequence of bits in the bitmap, of 954 * A region of a bitmap is a sequence of bits in the bitmap, of
955 * some size '1 << order' (a power of two), aligned to that same 955 * some size '1 << order' (a power of two), aligned to that same
956 * '1 << order' power of two. 956 * '1 << order' power of two.
957 * 957 *
958 * Returns 1 if REG_OP_ISFREE succeeds (region is all zero bits). 958 * Returns 1 if REG_OP_ISFREE succeeds (region is all zero bits).
959 * Returns 0 in all other cases and reg_ops. 959 * Returns 0 in all other cases and reg_ops.
960 */ 960 */
961 961
962 enum { 962 enum {
963 REG_OP_ISFREE, /* true if region is all zero bits */ 963 REG_OP_ISFREE, /* true if region is all zero bits */
964 REG_OP_ALLOC, /* set all bits in region */ 964 REG_OP_ALLOC, /* set all bits in region */
965 REG_OP_RELEASE, /* clear all bits in region */ 965 REG_OP_RELEASE, /* clear all bits in region */
966 }; 966 };
967 967
968 static int __reg_op(unsigned long *bitmap, int pos, int order, int reg_op) 968 static int __reg_op(unsigned long *bitmap, int pos, int order, int reg_op)
969 { 969 {
970 int nbits_reg; /* number of bits in region */ 970 int nbits_reg; /* number of bits in region */
971 int index; /* index first long of region in bitmap */ 971 int index; /* index first long of region in bitmap */
972 int offset; /* bit offset region in bitmap[index] */ 972 int offset; /* bit offset region in bitmap[index] */
973 int nlongs_reg; /* num longs spanned by region in bitmap */ 973 int nlongs_reg; /* num longs spanned by region in bitmap */
974 int nbitsinlong; /* num bits of region in each spanned long */ 974 int nbitsinlong; /* num bits of region in each spanned long */
975 unsigned long mask; /* bitmask for one long of region */ 975 unsigned long mask; /* bitmask for one long of region */
976 int i; /* scans bitmap by longs */ 976 int i; /* scans bitmap by longs */
977 int ret = 0; /* return value */ 977 int ret = 0; /* return value */
978 978
979 /* 979 /*
980 * Either nlongs_reg == 1 (for small orders that fit in one long) 980 * Either nlongs_reg == 1 (for small orders that fit in one long)
981 * or (offset == 0 && mask == ~0UL) (for larger multiword orders.) 981 * or (offset == 0 && mask == ~0UL) (for larger multiword orders.)
982 */ 982 */
983 nbits_reg = 1 << order; 983 nbits_reg = 1 << order;
984 index = pos / BITS_PER_LONG; 984 index = pos / BITS_PER_LONG;
985 offset = pos - (index * BITS_PER_LONG); 985 offset = pos - (index * BITS_PER_LONG);
986 nlongs_reg = BITS_TO_LONGS(nbits_reg); 986 nlongs_reg = BITS_TO_LONGS(nbits_reg);
987 nbitsinlong = min(nbits_reg, BITS_PER_LONG); 987 nbitsinlong = min(nbits_reg, BITS_PER_LONG);
988 988
989 /* 989 /*
990 * Can't do "mask = (1UL << nbitsinlong) - 1", as that 990 * Can't do "mask = (1UL << nbitsinlong) - 1", as that
991 * overflows if nbitsinlong == BITS_PER_LONG. 991 * overflows if nbitsinlong == BITS_PER_LONG.
992 */ 992 */
993 mask = (1UL << (nbitsinlong - 1)); 993 mask = (1UL << (nbitsinlong - 1));
994 mask += mask - 1; 994 mask += mask - 1;
995 mask <<= offset; 995 mask <<= offset;
996 996
997 switch (reg_op) { 997 switch (reg_op) {
998 case REG_OP_ISFREE: 998 case REG_OP_ISFREE:
999 for (i = 0; i < nlongs_reg; i++) { 999 for (i = 0; i < nlongs_reg; i++) {
1000 if (bitmap[index + i] & mask) 1000 if (bitmap[index + i] & mask)
1001 goto done; 1001 goto done;
1002 } 1002 }
1003 ret = 1; /* all bits in region free (zero) */ 1003 ret = 1; /* all bits in region free (zero) */
1004 break; 1004 break;
1005 1005
1006 case REG_OP_ALLOC: 1006 case REG_OP_ALLOC:
1007 for (i = 0; i < nlongs_reg; i++) 1007 for (i = 0; i < nlongs_reg; i++)
1008 bitmap[index + i] |= mask; 1008 bitmap[index + i] |= mask;
1009 break; 1009 break;
1010 1010
1011 case REG_OP_RELEASE: 1011 case REG_OP_RELEASE:
1012 for (i = 0; i < nlongs_reg; i++) 1012 for (i = 0; i < nlongs_reg; i++)
1013 bitmap[index + i] &= ~mask; 1013 bitmap[index + i] &= ~mask;
1014 break; 1014 break;
1015 } 1015 }
1016 done: 1016 done:
1017 return ret; 1017 return ret;
1018 } 1018 }
1019 1019
1020 /** 1020 /**
1021 * bitmap_find_free_region - find a contiguous aligned mem region 1021 * bitmap_find_free_region - find a contiguous aligned mem region
1022 * @bitmap: array of unsigned longs corresponding to the bitmap 1022 * @bitmap: array of unsigned longs corresponding to the bitmap
1023 * @bits: number of bits in the bitmap 1023 * @bits: number of bits in the bitmap
1024 * @order: region size (log base 2 of number of bits) to find 1024 * @order: region size (log base 2 of number of bits) to find
1025 * 1025 *
1026 * Find a region of free (zero) bits in a @bitmap of @bits bits and 1026 * Find a region of free (zero) bits in a @bitmap of @bits bits and
1027 * allocate them (set them to one). Only consider regions of length 1027 * allocate them (set them to one). Only consider regions of length
1028 * a power (@order) of two, aligned to that power of two, which 1028 * a power (@order) of two, aligned to that power of two, which
1029 * makes the search algorithm much faster. 1029 * makes the search algorithm much faster.
1030 * 1030 *
1031 * Return the bit offset in bitmap of the allocated region, 1031 * Return the bit offset in bitmap of the allocated region,
1032 * or -errno on failure. 1032 * or -errno on failure.
1033 */ 1033 */
1034 int bitmap_find_free_region(unsigned long *bitmap, int bits, int order) 1034 int bitmap_find_free_region(unsigned long *bitmap, int bits, int order)
1035 { 1035 {
1036 int pos, end; /* scans bitmap by regions of size order */ 1036 int pos, end; /* scans bitmap by regions of size order */
1037 1037
1038 for (pos = 0 ; (end = pos + (1 << order)) <= bits; pos = end) { 1038 for (pos = 0 ; (end = pos + (1 << order)) <= bits; pos = end) {
1039 if (!__reg_op(bitmap, pos, order, REG_OP_ISFREE)) 1039 if (!__reg_op(bitmap, pos, order, REG_OP_ISFREE))
1040 continue; 1040 continue;
1041 __reg_op(bitmap, pos, order, REG_OP_ALLOC); 1041 __reg_op(bitmap, pos, order, REG_OP_ALLOC);
1042 return pos; 1042 return pos;
1043 } 1043 }
1044 return -ENOMEM; 1044 return -ENOMEM;
1045 } 1045 }
1046 EXPORT_SYMBOL(bitmap_find_free_region); 1046 EXPORT_SYMBOL(bitmap_find_free_region);
1047 1047
1048 /** 1048 /**
1049 * bitmap_release_region - release allocated bitmap region 1049 * bitmap_release_region - release allocated bitmap region
1050 * @bitmap: array of unsigned longs corresponding to the bitmap 1050 * @bitmap: array of unsigned longs corresponding to the bitmap
1051 * @pos: beginning of bit region to release 1051 * @pos: beginning of bit region to release
1052 * @order: region size (log base 2 of number of bits) to release 1052 * @order: region size (log base 2 of number of bits) to release
1053 * 1053 *
1054 * This is the complement to __bitmap_find_free_region() and releases 1054 * This is the complement to __bitmap_find_free_region() and releases
1055 * the found region (by clearing it in the bitmap). 1055 * the found region (by clearing it in the bitmap).
1056 * 1056 *
1057 * No return value. 1057 * No return value.
1058 */ 1058 */
1059 void bitmap_release_region(unsigned long *bitmap, int pos, int order) 1059 void bitmap_release_region(unsigned long *bitmap, int pos, int order)
1060 { 1060 {
1061 __reg_op(bitmap, pos, order, REG_OP_RELEASE); 1061 __reg_op(bitmap, pos, order, REG_OP_RELEASE);
1062 } 1062 }
1063 EXPORT_SYMBOL(bitmap_release_region); 1063 EXPORT_SYMBOL(bitmap_release_region);
1064 1064
1065 /** 1065 /**
1066 * bitmap_allocate_region - allocate bitmap region 1066 * bitmap_allocate_region - allocate bitmap region
1067 * @bitmap: array of unsigned longs corresponding to the bitmap 1067 * @bitmap: array of unsigned longs corresponding to the bitmap
1068 * @pos: beginning of bit region to allocate 1068 * @pos: beginning of bit region to allocate
1069 * @order: region size (log base 2 of number of bits) to allocate 1069 * @order: region size (log base 2 of number of bits) to allocate
1070 * 1070 *
1071 * Allocate (set bits in) a specified region of a bitmap. 1071 * Allocate (set bits in) a specified region of a bitmap.
1072 * 1072 *
1073 * Return 0 on success, or %-EBUSY if specified region wasn't 1073 * Return 0 on success, or %-EBUSY if specified region wasn't
1074 * free (not all bits were zero). 1074 * free (not all bits were zero).
1075 */ 1075 */
1076 int bitmap_allocate_region(unsigned long *bitmap, int pos, int order) 1076 int bitmap_allocate_region(unsigned long *bitmap, int pos, int order)
1077 { 1077 {
1078 if (!__reg_op(bitmap, pos, order, REG_OP_ISFREE)) 1078 if (!__reg_op(bitmap, pos, order, REG_OP_ISFREE))
1079 return -EBUSY; 1079 return -EBUSY;
1080 __reg_op(bitmap, pos, order, REG_OP_ALLOC); 1080 __reg_op(bitmap, pos, order, REG_OP_ALLOC);
1081 return 0; 1081 return 0;
1082 } 1082 }
1083 EXPORT_SYMBOL(bitmap_allocate_region); 1083 EXPORT_SYMBOL(bitmap_allocate_region);
1084 1084
1085 /** 1085 /**
1086 * bitmap_copy_le - copy a bitmap, putting the bits into little-endian order. 1086 * bitmap_copy_le - copy a bitmap, putting the bits into little-endian order.
1087 * @dst: destination buffer 1087 * @dst: destination buffer
1088 * @src: bitmap to copy 1088 * @src: bitmap to copy
1089 * @nbits: number of bits in the bitmap 1089 * @nbits: number of bits in the bitmap
1090 * 1090 *
1091 * Require nbits % BITS_PER_LONG == 0. 1091 * Require nbits % BITS_PER_LONG == 0.
1092 */ 1092 */
1093 void bitmap_copy_le(void *dst, const unsigned long *src, int nbits) 1093 void bitmap_copy_le(void *dst, const unsigned long *src, int nbits)
1094 { 1094 {
1095 unsigned long *d = dst; 1095 unsigned long *d = dst;
1096 int i; 1096 int i;
1097 1097
1098 for (i = 0; i < nbits/BITS_PER_LONG; i++) { 1098 for (i = 0; i < nbits/BITS_PER_LONG; i++) {
1099 if (BITS_PER_LONG == 64) 1099 if (BITS_PER_LONG == 64)
1100 d[i] = cpu_to_le64(src[i]); 1100 d[i] = cpu_to_le64(src[i]);
1101 else 1101 else
1102 d[i] = cpu_to_le32(src[i]); 1102 d[i] = cpu_to_le32(src[i]);
1103 } 1103 }
1104 } 1104 }
1105 EXPORT_SYMBOL(bitmap_copy_le); 1105 EXPORT_SYMBOL(bitmap_copy_le);
1106 1106