rdma.m4: check if debugfs_create_bool() uses a bool or u32 pointer
[~tnikolova/compat/.git] / compat / compat-2.6.33.c
1 /*
2  * Copyright 2009       Hauke Mehrtens <hauke@hauke-m.de>
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License version 2 as
6  * published by the Free Software Foundation.
7  *
8  * Compatibility file for Linux wireless for kernels 2.6.33.
9  */
10
11 #include <linux/compat.h>
12 #include <linux/autoconf.h>
13 #include <linux/string.h>
14 #include <linux/ctype.h>
15
16 #ifndef BITMAP_FIRST_WORD_MASK
17 #define BITMAP_FIRST_WORD_MASK(start) (~0UL << ((start) % BITS_PER_LONG))
18 #endif /* BITMAP_FIRST_WORD_MASK */
19
20 #ifndef CONFIG_COMPAT_IS_BITMAP
21
22 void bitmap_set(unsigned long *map, int start, int nr)
23 {
24         unsigned long *p = map + BIT_WORD(start);
25         const int size = start + nr;
26         int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);
27         unsigned long mask_to_set = BITMAP_FIRST_WORD_MASK(start);
28
29         while (nr - bits_to_set >= 0) {
30                 *p |= mask_to_set;
31                 nr -= bits_to_set;
32                 bits_to_set = BITS_PER_LONG;
33                 mask_to_set = ~0UL;
34                 p++;
35         }
36         if (nr) {
37                 mask_to_set &= BITMAP_LAST_WORD_MASK(size);
38                 *p |= mask_to_set;
39         }
40 }
41 EXPORT_SYMBOL(bitmap_set);
42
43 void bitmap_clear(unsigned long *map, int start, int nr)
44 {
45         unsigned long *p = map + BIT_WORD(start);
46         const int size = start + nr;
47         int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG);
48         unsigned long mask_to_clear = BITMAP_FIRST_WORD_MASK(start);
49
50         while (nr - bits_to_clear >= 0) {
51                 *p &= ~mask_to_clear;
52                 nr -= bits_to_clear;
53                 bits_to_clear = BITS_PER_LONG;
54                 mask_to_clear = ~0UL;
55                 p++;
56         }
57         if (nr) {
58                 mask_to_clear &= BITMAP_LAST_WORD_MASK(size);
59                 *p &= ~mask_to_clear;
60         }
61 }
62 EXPORT_SYMBOL(bitmap_clear);
63
64 /*
65  * bitmap_find_next_zero_area - find a contiguous aligned zero area
66  * @map: The address to base the search on
67  * @size: The bitmap size in bits
68  * @start: The bitnumber to start searching at
69  * @nr: The number of zeroed bits we're looking for
70  * @align_mask: Alignment mask for zero area
71  *
72  * The @align_mask should be one less than a power of 2; the effect is that
73  * the bit offset of all zero areas this function finds is multiples of that
74  * power of 2. A @align_mask of 0 means no alignment is required.
75  */
76 unsigned long bitmap_find_next_zero_area(unsigned long *map,
77                                          unsigned long size,
78                                          unsigned long start,
79                                          unsigned int nr,
80                                          unsigned long align_mask)
81 {
82         unsigned long index, end, i;
83 again:
84         index = find_next_zero_bit(map, size, start);
85
86         /* Align allocation */
87         index = __ALIGN_MASK(index, align_mask);
88
89         end = index + nr;
90         if (end > size)
91                 return end;
92         i = find_next_bit(map, end, index);
93         if (i < end) {
94                 start = i + 1;
95                 goto again;
96         }
97         return index;
98 }
99 EXPORT_SYMBOL(bitmap_find_next_zero_area);
100 #endif /* CONFIG_COMPAT_IS_BITMAP */
101
102 /**
103  * skip_spaces - Removes leading whitespace from @str.
104  * @str: The string to be stripped.
105  *
106  * Returns a pointer to the first non-whitespace character in @str.
107  */
108 char *skip_spaces(const char *str)
109 {
110         while (isspace(*str))
111                 ++str;
112         return (char *)str;
113 }
114 EXPORT_SYMBOL(skip_spaces);
115
116 /**
117  * strim - Removes leading and trailing whitespace from @s.
118  * @s: The string to be stripped.
119  *
120  * Note that the first trailing whitespace is replaced with a %NUL-terminator
121  * in the given string @s. Returns a pointer to the first non-whitespace
122  * character in @s.
123  */
124 char *strim(char *s)
125 {
126         size_t size;
127         char *end;
128
129         size = strlen(s);
130         if (!size)
131                 return s;
132
133         end = s + size - 1;
134         while (end >= s && isspace(*end))
135                 end--;
136         *(end + 1) = '\0';
137
138         return skip_spaces(s);
139 }
140 EXPORT_SYMBOL(strim);
141