selinux: Unify for- and while-loop style
[linux-2.6.git] / security / selinux / ss / ebitmap.c
1 /*
2  * Implementation of the extensible bitmap type.
3  *
4  * Author : Stephen Smalley, <sds@epoch.ncsc.mil>
5  */
6 /*
7  * Updated: Hewlett-Packard <paul.moore@hp.com>
8  *
9  *      Added support to import/export the NetLabel category bitmap
10  *
11  * (c) Copyright Hewlett-Packard Development Company, L.P., 2006
12  */
13 /*
14  * Updated: KaiGai Kohei <kaigai@ak.jp.nec.com>
15  *      Applied standard bit operations to improve bitmap scanning.
16  */
17
18 #include <linux/kernel.h>
19 #include <linux/slab.h>
20 #include <linux/errno.h>
21 #include <net/netlabel.h>
22 #include "ebitmap.h"
23 #include "policydb.h"
24
25 int ebitmap_cmp(struct ebitmap *e1, struct ebitmap *e2)
26 {
27         struct ebitmap_node *n1, *n2;
28
29         if (e1->highbit != e2->highbit)
30                 return 0;
31
32         n1 = e1->node;
33         n2 = e2->node;
34         while (n1 && n2 &&
35                (n1->startbit == n2->startbit) &&
36                !memcmp(n1->maps, n2->maps, EBITMAP_SIZE / 8)) {
37                 n1 = n1->next;
38                 n2 = n2->next;
39         }
40
41         if (n1 || n2)
42                 return 0;
43
44         return 1;
45 }
46
47 int ebitmap_cpy(struct ebitmap *dst, struct ebitmap *src)
48 {
49         struct ebitmap_node *n, *new, *prev;
50
51         ebitmap_init(dst);
52         n = src->node;
53         prev = NULL;
54         while (n) {
55                 new = kzalloc(sizeof(*new), GFP_ATOMIC);
56                 if (!new) {
57                         ebitmap_destroy(dst);
58                         return -ENOMEM;
59                 }
60                 new->startbit = n->startbit;
61                 memcpy(new->maps, n->maps, EBITMAP_SIZE / 8);
62                 new->next = NULL;
63                 if (prev)
64                         prev->next = new;
65                 else
66                         dst->node = new;
67                 prev = new;
68                 n = n->next;
69         }
70
71         dst->highbit = src->highbit;
72         return 0;
73 }
74
75 #ifdef CONFIG_NETLABEL
76 /**
77  * ebitmap_netlbl_export - Export an ebitmap into a NetLabel category bitmap
78  * @ebmap: the ebitmap to export
79  * @catmap: the NetLabel category bitmap
80  *
81  * Description:
82  * Export a SELinux extensibile bitmap into a NetLabel category bitmap.
83  * Returns zero on success, negative values on error.
84  *
85  */
86 int ebitmap_netlbl_export(struct ebitmap *ebmap,
87                           struct netlbl_lsm_secattr_catmap **catmap)
88 {
89         struct ebitmap_node *e_iter = ebmap->node;
90         struct netlbl_lsm_secattr_catmap *c_iter;
91         u32 cmap_idx, cmap_sft;
92         int i;
93
94         /* NetLabel's NETLBL_CATMAP_MAPTYPE is defined as an array of u64,
95          * however, it is not always compatible with an array of unsigned long
96          * in ebitmap_node.
97          * In addition, you should pay attention the following implementation
98          * assumes unsigned long has a width equal with or less than 64-bit.
99          */
100
101         if (e_iter == NULL) {
102                 *catmap = NULL;
103                 return 0;
104         }
105
106         c_iter = netlbl_secattr_catmap_alloc(GFP_ATOMIC);
107         if (c_iter == NULL)
108                 return -ENOMEM;
109         *catmap = c_iter;
110         c_iter->startbit = e_iter->startbit & ~(NETLBL_CATMAP_SIZE - 1);
111
112         while (e_iter) {
113                 for (i = 0; i < EBITMAP_UNIT_NUMS; i++) {
114                         unsigned int delta, e_startbit, c_endbit;
115
116                         e_startbit = e_iter->startbit + i * EBITMAP_UNIT_SIZE;
117                         c_endbit = c_iter->startbit + NETLBL_CATMAP_SIZE;
118                         if (e_startbit >= c_endbit) {
119                                 c_iter->next
120                                   = netlbl_secattr_catmap_alloc(GFP_ATOMIC);
121                                 if (c_iter->next == NULL)
122                                         goto netlbl_export_failure;
123                                 c_iter = c_iter->next;
124                                 c_iter->startbit
125                                   = e_startbit & ~(NETLBL_CATMAP_SIZE - 1);
126                         }
127                         delta = e_startbit - c_iter->startbit;
128                         cmap_idx = delta / NETLBL_CATMAP_MAPSIZE;
129                         cmap_sft = delta % NETLBL_CATMAP_MAPSIZE;
130                         c_iter->bitmap[cmap_idx]
131                                 |= e_iter->maps[cmap_idx] << cmap_sft;
132                 }
133                 e_iter = e_iter->next;
134         }
135
136         return 0;
137
138 netlbl_export_failure:
139         netlbl_secattr_catmap_free(*catmap);
140         return -ENOMEM;
141 }
142
143 /**
144  * ebitmap_netlbl_import - Import a NetLabel category bitmap into an ebitmap
145  * @ebmap: the ebitmap to import
146  * @catmap: the NetLabel category bitmap
147  *
148  * Description:
149  * Import a NetLabel category bitmap into a SELinux extensibile bitmap.
150  * Returns zero on success, negative values on error.
151  *
152  */
153 int ebitmap_netlbl_import(struct ebitmap *ebmap,
154                           struct netlbl_lsm_secattr_catmap *catmap)
155 {
156         struct ebitmap_node *e_iter = NULL;
157         struct ebitmap_node *emap_prev = NULL;
158         struct netlbl_lsm_secattr_catmap *c_iter = catmap;
159         u32 c_idx, c_pos, e_idx, e_sft;
160
161         /* NetLabel's NETLBL_CATMAP_MAPTYPE is defined as an array of u64,
162          * however, it is not always compatible with an array of unsigned long
163          * in ebitmap_node.
164          * In addition, you should pay attention the following implementation
165          * assumes unsigned long has a width equal with or less than 64-bit.
166          */
167
168         do {
169                 for (c_idx = 0; c_idx < NETLBL_CATMAP_MAPCNT; c_idx++) {
170                         unsigned int delta;
171                         u64 map = c_iter->bitmap[c_idx];
172
173                         if (!map)
174                                 continue;
175
176                         c_pos = c_iter->startbit
177                                 + c_idx * NETLBL_CATMAP_MAPSIZE;
178                         if (!e_iter
179                             || c_pos >= e_iter->startbit + EBITMAP_SIZE) {
180                                 e_iter = kzalloc(sizeof(*e_iter), GFP_ATOMIC);
181                                 if (!e_iter)
182                                         goto netlbl_import_failure;
183                                 e_iter->startbit
184                                         = c_pos - (c_pos % EBITMAP_SIZE);
185                                 if (emap_prev == NULL)
186                                         ebmap->node = e_iter;
187                                 else
188                                         emap_prev->next = e_iter;
189                                 emap_prev = e_iter;
190                         }
191                         delta = c_pos - e_iter->startbit;
192                         e_idx = delta / EBITMAP_UNIT_SIZE;
193                         e_sft = delta % EBITMAP_UNIT_SIZE;
194                         while (map) {
195                                 e_iter->maps[e_idx++] |= map & (-1UL);
196                                 map = EBITMAP_SHIFT_UNIT_SIZE(map);
197                         }
198                 }
199                 c_iter = c_iter->next;
200         } while (c_iter);
201         if (e_iter != NULL)
202                 ebmap->highbit = e_iter->startbit + EBITMAP_SIZE;
203         else
204                 ebitmap_destroy(ebmap);
205
206         return 0;
207
208 netlbl_import_failure:
209         ebitmap_destroy(ebmap);
210         return -ENOMEM;
211 }
212 #endif /* CONFIG_NETLABEL */
213
214 int ebitmap_contains(struct ebitmap *e1, struct ebitmap *e2)
215 {
216         struct ebitmap_node *n1, *n2;
217         int i;
218
219         if (e1->highbit < e2->highbit)
220                 return 0;
221
222         n1 = e1->node;
223         n2 = e2->node;
224         while (n1 && n2 && (n1->startbit <= n2->startbit)) {
225                 if (n1->startbit < n2->startbit) {
226                         n1 = n1->next;
227                         continue;
228                 }
229                 for (i = 0; i < EBITMAP_UNIT_NUMS; i++) {
230                         if ((n1->maps[i] & n2->maps[i]) != n2->maps[i])
231                                 return 0;
232                 }
233
234                 n1 = n1->next;
235                 n2 = n2->next;
236         }
237
238         if (n2)
239                 return 0;
240
241         return 1;
242 }
243
244 int ebitmap_get_bit(struct ebitmap *e, unsigned long bit)
245 {
246         struct ebitmap_node *n;
247
248         if (e->highbit < bit)
249                 return 0;
250
251         n = e->node;
252         while (n && (n->startbit <= bit)) {
253                 if ((n->startbit + EBITMAP_SIZE) > bit)
254                         return ebitmap_node_get_bit(n, bit);
255                 n = n->next;
256         }
257
258         return 0;
259 }
260
261 int ebitmap_set_bit(struct ebitmap *e, unsigned long bit, int value)
262 {
263         struct ebitmap_node *n, *prev, *new;
264
265         prev = NULL;
266         n = e->node;
267         while (n && n->startbit <= bit) {
268                 if ((n->startbit + EBITMAP_SIZE) > bit) {
269                         if (value) {
270                                 ebitmap_node_set_bit(n, bit);
271                         } else {
272                                 unsigned int s;
273
274                                 ebitmap_node_clr_bit(n, bit);
275
276                                 s = find_first_bit(n->maps, EBITMAP_SIZE);
277                                 if (s < EBITMAP_SIZE)
278                                         return 0;
279
280                                 /* drop this node from the bitmap */
281                                 if (!n->next) {
282                                         /*
283                                          * this was the highest map
284                                          * within the bitmap
285                                          */
286                                         if (prev)
287                                                 e->highbit = prev->startbit
288                                                              + EBITMAP_SIZE;
289                                         else
290                                                 e->highbit = 0;
291                                 }
292                                 if (prev)
293                                         prev->next = n->next;
294                                 else
295                                         e->node = n->next;
296                                 kfree(n);
297                         }
298                         return 0;
299                 }
300                 prev = n;
301                 n = n->next;
302         }
303
304         if (!value)
305                 return 0;
306
307         new = kzalloc(sizeof(*new), GFP_ATOMIC);
308         if (!new)
309                 return -ENOMEM;
310
311         new->startbit = bit - (bit % EBITMAP_SIZE);
312         ebitmap_node_set_bit(new, bit);
313
314         if (!n)
315                 /* this node will be the highest map within the bitmap */
316                 e->highbit = new->startbit + EBITMAP_SIZE;
317
318         if (prev) {
319                 new->next = prev->next;
320                 prev->next = new;
321         } else {
322                 new->next = e->node;
323                 e->node = new;
324         }
325
326         return 0;
327 }
328
329 void ebitmap_destroy(struct ebitmap *e)
330 {
331         struct ebitmap_node *n, *temp;
332
333         if (!e)
334                 return;
335
336         n = e->node;
337         while (n) {
338                 temp = n;
339                 n = n->next;
340                 kfree(temp);
341         }
342
343         e->highbit = 0;
344         e->node = NULL;
345         return;
346 }
347
348 int ebitmap_read(struct ebitmap *e, void *fp)
349 {
350         struct ebitmap_node *n = NULL;
351         u32 mapunit, count, startbit, index;
352         u64 map;
353         __le32 buf[3];
354         int rc, i;
355
356         ebitmap_init(e);
357
358         rc = next_entry(buf, fp, sizeof buf);
359         if (rc < 0)
360                 goto out;
361
362         mapunit = le32_to_cpu(buf[0]);
363         e->highbit = le32_to_cpu(buf[1]);
364         count = le32_to_cpu(buf[2]);
365
366         if (mapunit != sizeof(u64) * 8) {
367                 printk(KERN_ERR "SELinux: ebitmap: map size %u does not "
368                        "match my size %Zd (high bit was %d)\n",
369                        mapunit, sizeof(u64) * 8, e->highbit);
370                 goto bad;
371         }
372
373         /* round up e->highbit */
374         e->highbit += EBITMAP_SIZE - 1;
375         e->highbit -= (e->highbit % EBITMAP_SIZE);
376
377         if (!e->highbit) {
378                 e->node = NULL;
379                 goto ok;
380         }
381
382         for (i = 0; i < count; i++) {
383                 rc = next_entry(&startbit, fp, sizeof(u32));
384                 if (rc < 0) {
385                         printk(KERN_ERR "SELinux: ebitmap: truncated map\n");
386                         goto bad;
387                 }
388                 startbit = le32_to_cpu(startbit);
389
390                 if (startbit & (mapunit - 1)) {
391                         printk(KERN_ERR "SELinux: ebitmap start bit (%d) is "
392                                "not a multiple of the map unit size (%u)\n",
393                                startbit, mapunit);
394                         goto bad;
395                 }
396                 if (startbit > e->highbit - mapunit) {
397                         printk(KERN_ERR "SELinux: ebitmap start bit (%d) is "
398                                "beyond the end of the bitmap (%u)\n",
399                                startbit, (e->highbit - mapunit));
400                         goto bad;
401                 }
402
403                 if (!n || startbit >= n->startbit + EBITMAP_SIZE) {
404                         struct ebitmap_node *tmp;
405                         tmp = kzalloc(sizeof(*tmp), GFP_KERNEL);
406                         if (!tmp) {
407                                 printk(KERN_ERR
408                                        "SELinux: ebitmap: out of memory\n");
409                                 rc = -ENOMEM;
410                                 goto bad;
411                         }
412                         /* round down */
413                         tmp->startbit = startbit - (startbit % EBITMAP_SIZE);
414                         if (n)
415                                 n->next = tmp;
416                         else
417                                 e->node = tmp;
418                         n = tmp;
419                 } else if (startbit <= n->startbit) {
420                         printk(KERN_ERR "SELinux: ebitmap: start bit %d"
421                                " comes after start bit %d\n",
422                                startbit, n->startbit);
423                         goto bad;
424                 }
425
426                 rc = next_entry(&map, fp, sizeof(u64));
427                 if (rc < 0) {
428                         printk(KERN_ERR "SELinux: ebitmap: truncated map\n");
429                         goto bad;
430                 }
431                 map = le64_to_cpu(map);
432
433                 index = (startbit - n->startbit) / EBITMAP_UNIT_SIZE;
434                 while (map) {
435                         n->maps[index++] = map & (-1UL);
436                         map = EBITMAP_SHIFT_UNIT_SIZE(map);
437                 }
438         }
439 ok:
440         rc = 0;
441 out:
442         return rc;
443 bad:
444         if (!rc)
445                 rc = -EINVAL;
446         ebitmap_destroy(e);
447         goto out;
448 }