]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Implementation of the access vector table type. | |
3 | * | |
4 | * Author : Stephen Smalley, <sds@epoch.ncsc.mil> | |
5 | */ | |
6 | ||
7 | /* Updated: Frank Mayer <mayerf@tresys.com> and Karl MacMillan <kmacmillan@tresys.com> | |
8 | * | |
eb5df9a7 | 9 | * Added conditional policy language extensions |
1da177e4 LT |
10 | * |
11 | * Copyright (C) 2003 Tresys Technology, LLC | |
12 | * This program is free software; you can redistribute it and/or modify | |
eb5df9a7 | 13 | * it under the terms of the GNU General Public License as published by |
1da177e4 | 14 | * the Free Software Foundation, version 2. |
3232c110 YN |
15 | * |
16 | * Updated: Yuichi Nakamura <ynakam@hitachisoft.jp> | |
eb5df9a7 | 17 | * Tuned number of hash slots for avtab to reduce memory usage |
1da177e4 LT |
18 | */ |
19 | ||
20 | #include <linux/kernel.h> | |
21 | #include <linux/slab.h> | |
1da177e4 | 22 | #include <linux/errno.h> |
1da177e4 LT |
23 | #include "avtab.h" |
24 | #include "policydb.h" | |
25 | ||
e18b890b | 26 | static struct kmem_cache *avtab_node_cachep; |
1da177e4 | 27 | |
3232c110 YN |
28 | static inline int avtab_hash(struct avtab_key *keyp, u16 mask) |
29 | { | |
30 | return ((keyp->target_class + (keyp->target_type << 2) + | |
31 | (keyp->source_type << 9)) & mask); | |
32 | } | |
33 | ||
1da177e4 LT |
34 | static struct avtab_node* |
35 | avtab_insert_node(struct avtab *h, int hvalue, | |
eb5df9a7 | 36 | struct avtab_node *prev, struct avtab_node *cur, |
1da177e4 LT |
37 | struct avtab_key *key, struct avtab_datum *datum) |
38 | { | |
eb5df9a7 | 39 | struct avtab_node *newnode; |
c3762229 | 40 | newnode = kmem_cache_zalloc(avtab_node_cachep, GFP_KERNEL); |
1da177e4 LT |
41 | if (newnode == NULL) |
42 | return NULL; | |
1da177e4 LT |
43 | newnode->key = *key; |
44 | newnode->datum = *datum; | |
45 | if (prev) { | |
46 | newnode->next = prev->next; | |
47 | prev->next = newnode; | |
48 | } else { | |
49 | newnode->next = h->htable[hvalue]; | |
50 | h->htable[hvalue] = newnode; | |
51 | } | |
52 | ||
53 | h->nel++; | |
54 | return newnode; | |
55 | } | |
56 | ||
57 | static int avtab_insert(struct avtab *h, struct avtab_key *key, struct avtab_datum *datum) | |
58 | { | |
59 | int hvalue; | |
60 | struct avtab_node *prev, *cur, *newnode; | |
782ebb99 | 61 | u16 specified = key->specified & ~(AVTAB_ENABLED|AVTAB_ENABLED_OLD); |
1da177e4 | 62 | |
3232c110 | 63 | if (!h || !h->htable) |
1da177e4 LT |
64 | return -EINVAL; |
65 | ||
3232c110 | 66 | hvalue = avtab_hash(key, h->mask); |
1da177e4 LT |
67 | for (prev = NULL, cur = h->htable[hvalue]; |
68 | cur; | |
69 | prev = cur, cur = cur->next) { | |
70 | if (key->source_type == cur->key.source_type && | |
71 | key->target_type == cur->key.target_type && | |
72 | key->target_class == cur->key.target_class && | |
782ebb99 | 73 | (specified & cur->key.specified)) |
1da177e4 LT |
74 | return -EEXIST; |
75 | if (key->source_type < cur->key.source_type) | |
76 | break; | |
77 | if (key->source_type == cur->key.source_type && | |
78 | key->target_type < cur->key.target_type) | |
79 | break; | |
80 | if (key->source_type == cur->key.source_type && | |
81 | key->target_type == cur->key.target_type && | |
82 | key->target_class < cur->key.target_class) | |
83 | break; | |
84 | } | |
85 | ||
86 | newnode = avtab_insert_node(h, hvalue, prev, cur, key, datum); | |
eb5df9a7 | 87 | if (!newnode) |
1da177e4 LT |
88 | return -ENOMEM; |
89 | ||
90 | return 0; | |
91 | } | |
92 | ||
93 | /* Unlike avtab_insert(), this function allow multiple insertions of the same | |
94 | * key/specified mask into the table, as needed by the conditional avtab. | |
95 | * It also returns a pointer to the node inserted. | |
96 | */ | |
97 | struct avtab_node * | |
eb5df9a7 | 98 | avtab_insert_nonunique(struct avtab *h, struct avtab_key *key, struct avtab_datum *datum) |
1da177e4 LT |
99 | { |
100 | int hvalue; | |
0c0e186f | 101 | struct avtab_node *prev, *cur; |
782ebb99 | 102 | u16 specified = key->specified & ~(AVTAB_ENABLED|AVTAB_ENABLED_OLD); |
1da177e4 | 103 | |
3232c110 | 104 | if (!h || !h->htable) |
1da177e4 | 105 | return NULL; |
3232c110 | 106 | hvalue = avtab_hash(key, h->mask); |
1da177e4 LT |
107 | for (prev = NULL, cur = h->htable[hvalue]; |
108 | cur; | |
109 | prev = cur, cur = cur->next) { | |
110 | if (key->source_type == cur->key.source_type && | |
111 | key->target_type == cur->key.target_type && | |
112 | key->target_class == cur->key.target_class && | |
782ebb99 | 113 | (specified & cur->key.specified)) |
1da177e4 LT |
114 | break; |
115 | if (key->source_type < cur->key.source_type) | |
116 | break; | |
117 | if (key->source_type == cur->key.source_type && | |
118 | key->target_type < cur->key.target_type) | |
119 | break; | |
120 | if (key->source_type == cur->key.source_type && | |
121 | key->target_type == cur->key.target_type && | |
122 | key->target_class < cur->key.target_class) | |
123 | break; | |
124 | } | |
0c0e186f | 125 | return avtab_insert_node(h, hvalue, prev, cur, key, datum); |
1da177e4 LT |
126 | } |
127 | ||
782ebb99 | 128 | struct avtab_datum *avtab_search(struct avtab *h, struct avtab_key *key) |
1da177e4 LT |
129 | { |
130 | int hvalue; | |
131 | struct avtab_node *cur; | |
782ebb99 | 132 | u16 specified = key->specified & ~(AVTAB_ENABLED|AVTAB_ENABLED_OLD); |
1da177e4 | 133 | |
3232c110 | 134 | if (!h || !h->htable) |
1da177e4 LT |
135 | return NULL; |
136 | ||
3232c110 | 137 | hvalue = avtab_hash(key, h->mask); |
1da177e4 LT |
138 | for (cur = h->htable[hvalue]; cur; cur = cur->next) { |
139 | if (key->source_type == cur->key.source_type && | |
140 | key->target_type == cur->key.target_type && | |
141 | key->target_class == cur->key.target_class && | |
782ebb99 | 142 | (specified & cur->key.specified)) |
1da177e4 LT |
143 | return &cur->datum; |
144 | ||
145 | if (key->source_type < cur->key.source_type) | |
146 | break; | |
147 | if (key->source_type == cur->key.source_type && | |
148 | key->target_type < cur->key.target_type) | |
149 | break; | |
150 | if (key->source_type == cur->key.source_type && | |
151 | key->target_type == cur->key.target_type && | |
152 | key->target_class < cur->key.target_class) | |
153 | break; | |
154 | } | |
155 | ||
156 | return NULL; | |
157 | } | |
158 | ||
159 | /* This search function returns a node pointer, and can be used in | |
160 | * conjunction with avtab_search_next_node() | |
161 | */ | |
162 | struct avtab_node* | |
782ebb99 | 163 | avtab_search_node(struct avtab *h, struct avtab_key *key) |
1da177e4 LT |
164 | { |
165 | int hvalue; | |
166 | struct avtab_node *cur; | |
782ebb99 | 167 | u16 specified = key->specified & ~(AVTAB_ENABLED|AVTAB_ENABLED_OLD); |
1da177e4 | 168 | |
3232c110 | 169 | if (!h || !h->htable) |
1da177e4 LT |
170 | return NULL; |
171 | ||
3232c110 | 172 | hvalue = avtab_hash(key, h->mask); |
1da177e4 LT |
173 | for (cur = h->htable[hvalue]; cur; cur = cur->next) { |
174 | if (key->source_type == cur->key.source_type && | |
175 | key->target_type == cur->key.target_type && | |
176 | key->target_class == cur->key.target_class && | |
782ebb99 | 177 | (specified & cur->key.specified)) |
1da177e4 LT |
178 | return cur; |
179 | ||
180 | if (key->source_type < cur->key.source_type) | |
181 | break; | |
182 | if (key->source_type == cur->key.source_type && | |
183 | key->target_type < cur->key.target_type) | |
184 | break; | |
185 | if (key->source_type == cur->key.source_type && | |
186 | key->target_type == cur->key.target_type && | |
187 | key->target_class < cur->key.target_class) | |
188 | break; | |
189 | } | |
190 | return NULL; | |
191 | } | |
192 | ||
193 | struct avtab_node* | |
194 | avtab_search_node_next(struct avtab_node *node, int specified) | |
195 | { | |
196 | struct avtab_node *cur; | |
197 | ||
198 | if (!node) | |
199 | return NULL; | |
200 | ||
782ebb99 | 201 | specified &= ~(AVTAB_ENABLED|AVTAB_ENABLED_OLD); |
1da177e4 LT |
202 | for (cur = node->next; cur; cur = cur->next) { |
203 | if (node->key.source_type == cur->key.source_type && | |
204 | node->key.target_type == cur->key.target_type && | |
205 | node->key.target_class == cur->key.target_class && | |
782ebb99 | 206 | (specified & cur->key.specified)) |
1da177e4 LT |
207 | return cur; |
208 | ||
209 | if (node->key.source_type < cur->key.source_type) | |
210 | break; | |
211 | if (node->key.source_type == cur->key.source_type && | |
212 | node->key.target_type < cur->key.target_type) | |
213 | break; | |
214 | if (node->key.source_type == cur->key.source_type && | |
215 | node->key.target_type == cur->key.target_type && | |
216 | node->key.target_class < cur->key.target_class) | |
217 | break; | |
218 | } | |
219 | return NULL; | |
220 | } | |
221 | ||
222 | void avtab_destroy(struct avtab *h) | |
223 | { | |
224 | int i; | |
225 | struct avtab_node *cur, *temp; | |
226 | ||
227 | if (!h || !h->htable) | |
228 | return; | |
229 | ||
3232c110 | 230 | for (i = 0; i < h->nslot; i++) { |
1da177e4 | 231 | cur = h->htable[i]; |
dbc74c65 | 232 | while (cur) { |
1da177e4 LT |
233 | temp = cur; |
234 | cur = cur->next; | |
235 | kmem_cache_free(avtab_node_cachep, temp); | |
236 | } | |
237 | h->htable[i] = NULL; | |
238 | } | |
3232c110 | 239 | kfree(h->htable); |
1da177e4 | 240 | h->htable = NULL; |
3232c110 YN |
241 | h->nslot = 0; |
242 | h->mask = 0; | |
1da177e4 LT |
243 | } |
244 | ||
1da177e4 LT |
245 | int avtab_init(struct avtab *h) |
246 | { | |
3232c110 YN |
247 | h->htable = NULL; |
248 | h->nel = 0; | |
249 | return 0; | |
250 | } | |
251 | ||
252 | int avtab_alloc(struct avtab *h, u32 nrules) | |
253 | { | |
254 | u16 mask = 0; | |
255 | u32 shift = 0; | |
256 | u32 work = nrules; | |
257 | u32 nslot = 0; | |
258 | ||
259 | if (nrules == 0) | |
260 | goto avtab_alloc_out; | |
1da177e4 | 261 | |
3232c110 YN |
262 | while (work) { |
263 | work = work >> 1; | |
264 | shift++; | |
265 | } | |
266 | if (shift > 2) | |
267 | shift = shift - 2; | |
268 | nslot = 1 << shift; | |
00d85c83 EP |
269 | if (nslot > MAX_AVTAB_HASH_BUCKETS) |
270 | nslot = MAX_AVTAB_HASH_BUCKETS; | |
3232c110 YN |
271 | mask = nslot - 1; |
272 | ||
273 | h->htable = kcalloc(nslot, sizeof(*(h->htable)), GFP_KERNEL); | |
1da177e4 LT |
274 | if (!h->htable) |
275 | return -ENOMEM; | |
3232c110 YN |
276 | |
277 | avtab_alloc_out: | |
1da177e4 | 278 | h->nel = 0; |
3232c110 YN |
279 | h->nslot = nslot; |
280 | h->mask = mask; | |
454d972c JM |
281 | printk(KERN_DEBUG "SELinux: %d avtab hash slots, %d rules.\n", |
282 | h->nslot, nrules); | |
1da177e4 LT |
283 | return 0; |
284 | } | |
285 | ||
286 | void avtab_hash_eval(struct avtab *h, char *tag) | |
287 | { | |
288 | int i, chain_len, slots_used, max_chain_len; | |
3232c110 | 289 | unsigned long long chain2_len_sum; |
1da177e4 LT |
290 | struct avtab_node *cur; |
291 | ||
292 | slots_used = 0; | |
293 | max_chain_len = 0; | |
3232c110 YN |
294 | chain2_len_sum = 0; |
295 | for (i = 0; i < h->nslot; i++) { | |
1da177e4 LT |
296 | cur = h->htable[i]; |
297 | if (cur) { | |
298 | slots_used++; | |
299 | chain_len = 0; | |
300 | while (cur) { | |
301 | chain_len++; | |
302 | cur = cur->next; | |
303 | } | |
304 | ||
305 | if (chain_len > max_chain_len) | |
306 | max_chain_len = chain_len; | |
3232c110 | 307 | chain2_len_sum += chain_len * chain_len; |
1da177e4 LT |
308 | } |
309 | } | |
310 | ||
744ba35e | 311 | printk(KERN_DEBUG "SELinux: %s: %d entries and %d/%d buckets used, " |
f5269710 | 312 | "longest chain length %d sum of chain length^2 %llu\n", |
3232c110 YN |
313 | tag, h->nel, slots_used, h->nslot, max_chain_len, |
314 | chain2_len_sum); | |
1da177e4 LT |
315 | } |
316 | ||
782ebb99 SS |
317 | static uint16_t spec_order[] = { |
318 | AVTAB_ALLOWED, | |
319 | AVTAB_AUDITDENY, | |
320 | AVTAB_AUDITALLOW, | |
321 | AVTAB_TRANSITION, | |
322 | AVTAB_CHANGE, | |
323 | AVTAB_MEMBER | |
324 | }; | |
325 | ||
45e5421e | 326 | int avtab_read_item(struct avtab *a, void *fp, struct policydb *pol, |
eb5df9a7 | 327 | int (*insertf)(struct avtab *a, struct avtab_key *k, |
782ebb99 SS |
328 | struct avtab_datum *d, void *p), |
329 | void *p) | |
1da177e4 | 330 | { |
b5bf6c55 AD |
331 | __le16 buf16[4]; |
332 | u16 enabled; | |
333 | __le32 buf32[7]; | |
45e5421e | 334 | u32 items, items2, val, vers = pol->policyvers; |
782ebb99 SS |
335 | struct avtab_key key; |
336 | struct avtab_datum datum; | |
337 | int i, rc; | |
45e5421e | 338 | unsigned set; |
782ebb99 SS |
339 | |
340 | memset(&key, 0, sizeof(struct avtab_key)); | |
341 | memset(&datum, 0, sizeof(struct avtab_datum)); | |
342 | ||
343 | if (vers < POLICYDB_VERSION_AVTAB) { | |
344 | rc = next_entry(buf32, fp, sizeof(u32)); | |
9e0bd4cb | 345 | if (rc) { |
454d972c | 346 | printk(KERN_ERR "SELinux: avtab: truncated entry\n"); |
9e0bd4cb | 347 | return rc; |
782ebb99 SS |
348 | } |
349 | items2 = le32_to_cpu(buf32[0]); | |
350 | if (items2 > ARRAY_SIZE(buf32)) { | |
454d972c | 351 | printk(KERN_ERR "SELinux: avtab: entry overflow\n"); |
9e0bd4cb | 352 | return -EINVAL; |
1da177e4 | 353 | |
782ebb99 SS |
354 | } |
355 | rc = next_entry(buf32, fp, sizeof(u32)*items2); | |
9e0bd4cb | 356 | if (rc) { |
454d972c | 357 | printk(KERN_ERR "SELinux: avtab: truncated entry\n"); |
9e0bd4cb | 358 | return rc; |
782ebb99 SS |
359 | } |
360 | items = 0; | |
1da177e4 | 361 | |
782ebb99 SS |
362 | val = le32_to_cpu(buf32[items++]); |
363 | key.source_type = (u16)val; | |
364 | if (key.source_type != val) { | |
744ba35e | 365 | printk(KERN_ERR "SELinux: avtab: truncated source type\n"); |
9e0bd4cb | 366 | return -EINVAL; |
782ebb99 SS |
367 | } |
368 | val = le32_to_cpu(buf32[items++]); | |
369 | key.target_type = (u16)val; | |
370 | if (key.target_type != val) { | |
744ba35e | 371 | printk(KERN_ERR "SELinux: avtab: truncated target type\n"); |
9e0bd4cb | 372 | return -EINVAL; |
782ebb99 SS |
373 | } |
374 | val = le32_to_cpu(buf32[items++]); | |
375 | key.target_class = (u16)val; | |
376 | if (key.target_class != val) { | |
744ba35e | 377 | printk(KERN_ERR "SELinux: avtab: truncated target class\n"); |
9e0bd4cb | 378 | return -EINVAL; |
782ebb99 SS |
379 | } |
380 | ||
381 | val = le32_to_cpu(buf32[items++]); | |
382 | enabled = (val & AVTAB_ENABLED_OLD) ? AVTAB_ENABLED : 0; | |
383 | ||
384 | if (!(val & (AVTAB_AV | AVTAB_TYPE))) { | |
744ba35e | 385 | printk(KERN_ERR "SELinux: avtab: null entry\n"); |
9e0bd4cb | 386 | return -EINVAL; |
782ebb99 SS |
387 | } |
388 | if ((val & AVTAB_AV) && | |
389 | (val & AVTAB_TYPE)) { | |
744ba35e | 390 | printk(KERN_ERR "SELinux: avtab: entry has both access vectors and types\n"); |
9e0bd4cb | 391 | return -EINVAL; |
782ebb99 SS |
392 | } |
393 | ||
32725ad8 | 394 | for (i = 0; i < ARRAY_SIZE(spec_order); i++) { |
782ebb99 SS |
395 | if (val & spec_order[i]) { |
396 | key.specified = spec_order[i] | enabled; | |
397 | datum.data = le32_to_cpu(buf32[items++]); | |
398 | rc = insertf(a, &key, &datum, p); | |
eb5df9a7 EP |
399 | if (rc) |
400 | return rc; | |
782ebb99 SS |
401 | } |
402 | } | |
403 | ||
404 | if (items != items2) { | |
744ba35e | 405 | printk(KERN_ERR "SELinux: avtab: entry only had %d items, expected %d\n", items2, items); |
9e0bd4cb | 406 | return -EINVAL; |
782ebb99 SS |
407 | } |
408 | return 0; | |
1da177e4 | 409 | } |
782ebb99 SS |
410 | |
411 | rc = next_entry(buf16, fp, sizeof(u16)*4); | |
9e0bd4cb | 412 | if (rc) { |
744ba35e | 413 | printk(KERN_ERR "SELinux: avtab: truncated entry\n"); |
9e0bd4cb | 414 | return rc; |
1da177e4 | 415 | } |
782ebb99 | 416 | |
1da177e4 | 417 | items = 0; |
782ebb99 SS |
418 | key.source_type = le16_to_cpu(buf16[items++]); |
419 | key.target_type = le16_to_cpu(buf16[items++]); | |
420 | key.target_class = le16_to_cpu(buf16[items++]); | |
421 | key.specified = le16_to_cpu(buf16[items++]); | |
422 | ||
45e5421e SS |
423 | if (!policydb_type_isvalid(pol, key.source_type) || |
424 | !policydb_type_isvalid(pol, key.target_type) || | |
425 | !policydb_class_isvalid(pol, key.target_class)) { | |
744ba35e | 426 | printk(KERN_ERR "SELinux: avtab: invalid type or class\n"); |
9e0bd4cb | 427 | return -EINVAL; |
45e5421e SS |
428 | } |
429 | ||
430 | set = 0; | |
431 | for (i = 0; i < ARRAY_SIZE(spec_order); i++) { | |
432 | if (key.specified & spec_order[i]) | |
433 | set++; | |
434 | } | |
435 | if (!set || set > 1) { | |
744ba35e | 436 | printk(KERN_ERR "SELinux: avtab: more than one specifier\n"); |
9e0bd4cb | 437 | return -EINVAL; |
45e5421e SS |
438 | } |
439 | ||
782ebb99 | 440 | rc = next_entry(buf32, fp, sizeof(u32)); |
9e0bd4cb | 441 | if (rc) { |
744ba35e | 442 | printk(KERN_ERR "SELinux: avtab: truncated entry\n"); |
9e0bd4cb | 443 | return rc; |
1da177e4 | 444 | } |
782ebb99 | 445 | datum.data = le32_to_cpu(*buf32); |
45e5421e SS |
446 | if ((key.specified & AVTAB_TYPE) && |
447 | !policydb_type_isvalid(pol, datum.data)) { | |
744ba35e | 448 | printk(KERN_ERR "SELinux: avtab: invalid type\n"); |
9e0bd4cb | 449 | return -EINVAL; |
45e5421e | 450 | } |
782ebb99 SS |
451 | return insertf(a, &key, &datum, p); |
452 | } | |
1da177e4 | 453 | |
782ebb99 SS |
454 | static int avtab_insertf(struct avtab *a, struct avtab_key *k, |
455 | struct avtab_datum *d, void *p) | |
456 | { | |
457 | return avtab_insert(a, k, d); | |
1da177e4 LT |
458 | } |
459 | ||
45e5421e | 460 | int avtab_read(struct avtab *a, void *fp, struct policydb *pol) |
1da177e4 LT |
461 | { |
462 | int rc; | |
b5bf6c55 | 463 | __le32 buf[1]; |
1da177e4 LT |
464 | u32 nel, i; |
465 | ||
466 | ||
467 | rc = next_entry(buf, fp, sizeof(u32)); | |
468 | if (rc < 0) { | |
454d972c | 469 | printk(KERN_ERR "SELinux: avtab: truncated table\n"); |
1da177e4 LT |
470 | goto bad; |
471 | } | |
472 | nel = le32_to_cpu(buf[0]); | |
473 | if (!nel) { | |
454d972c | 474 | printk(KERN_ERR "SELinux: avtab: table is empty\n"); |
1da177e4 LT |
475 | rc = -EINVAL; |
476 | goto bad; | |
477 | } | |
3232c110 YN |
478 | |
479 | rc = avtab_alloc(a, nel); | |
480 | if (rc) | |
481 | goto bad; | |
482 | ||
1da177e4 | 483 | for (i = 0; i < nel; i++) { |
45e5421e | 484 | rc = avtab_read_item(a, fp, pol, avtab_insertf, NULL); |
1da177e4 LT |
485 | if (rc) { |
486 | if (rc == -ENOMEM) | |
454d972c | 487 | printk(KERN_ERR "SELinux: avtab: out of memory\n"); |
782ebb99 | 488 | else if (rc == -EEXIST) |
454d972c | 489 | printk(KERN_ERR "SELinux: avtab: duplicate entry\n"); |
9e0bd4cb | 490 | |
1da177e4 LT |
491 | goto bad; |
492 | } | |
493 | } | |
494 | ||
495 | rc = 0; | |
496 | out: | |
497 | return rc; | |
498 | ||
499 | bad: | |
500 | avtab_destroy(a); | |
501 | goto out; | |
502 | } | |
503 | ||
cee74f47 EP |
504 | int avtab_write_item(struct policydb *p, struct avtab_node *cur, void *fp) |
505 | { | |
506 | __le16 buf16[4]; | |
507 | __le32 buf32[1]; | |
508 | int rc; | |
509 | ||
510 | buf16[0] = cpu_to_le16(cur->key.source_type); | |
511 | buf16[1] = cpu_to_le16(cur->key.target_type); | |
512 | buf16[2] = cpu_to_le16(cur->key.target_class); | |
513 | buf16[3] = cpu_to_le16(cur->key.specified); | |
514 | rc = put_entry(buf16, sizeof(u16), 4, fp); | |
515 | if (rc) | |
516 | return rc; | |
517 | buf32[0] = cpu_to_le32(cur->datum.data); | |
518 | rc = put_entry(buf32, sizeof(u32), 1, fp); | |
519 | if (rc) | |
520 | return rc; | |
521 | return 0; | |
522 | } | |
523 | ||
524 | int avtab_write(struct policydb *p, struct avtab *a, void *fp) | |
525 | { | |
526 | unsigned int i; | |
527 | int rc = 0; | |
528 | struct avtab_node *cur; | |
529 | __le32 buf[1]; | |
530 | ||
531 | buf[0] = cpu_to_le32(a->nel); | |
532 | rc = put_entry(buf, sizeof(u32), 1, fp); | |
533 | if (rc) | |
534 | return rc; | |
535 | ||
536 | for (i = 0; i < a->nslot; i++) { | |
537 | for (cur = a->htable[i]; cur; cur = cur->next) { | |
538 | rc = avtab_write_item(p, cur, fp); | |
539 | if (rc) | |
540 | return rc; | |
541 | } | |
542 | } | |
543 | ||
544 | return rc; | |
545 | } | |
1da177e4 LT |
546 | void avtab_cache_init(void) |
547 | { | |
548 | avtab_node_cachep = kmem_cache_create("avtab_node", | |
549 | sizeof(struct avtab_node), | |
20c2df83 | 550 | 0, SLAB_PANIC, NULL); |
1da177e4 LT |
551 | } |
552 | ||
553 | void avtab_cache_destroy(void) | |
554 | { | |
eb5df9a7 | 555 | kmem_cache_destroy(avtab_node_cachep); |
1da177e4 | 556 | } |