Merge branch 'mini2440-dev-unlikely' into mini2440-dev
[linux-2.6/mini2440.git] / security / selinux / ss / sidtab.c
blobe817989764cd48dd4061bc49c30c6cb8da357474
1 /*
2 * Implementation of the SID table type.
4 * Author : Stephen Smalley, <sds@epoch.ncsc.mil>
5 */
6 #include <linux/kernel.h>
7 #include <linux/slab.h>
8 #include <linux/spinlock.h>
9 #include <linux/errno.h>
10 #include "flask.h"
11 #include "security.h"
12 #include "sidtab.h"
14 #define SIDTAB_HASH(sid) \
15 (sid & SIDTAB_HASH_MASK)
17 int sidtab_init(struct sidtab *s)
19 int i;
21 s->htable = kmalloc(sizeof(*(s->htable)) * SIDTAB_SIZE, GFP_ATOMIC);
22 if (!s->htable)
23 return -ENOMEM;
24 for (i = 0; i < SIDTAB_SIZE; i++)
25 s->htable[i] = NULL;
26 s->nel = 0;
27 s->next_sid = 1;
28 s->shutdown = 0;
29 spin_lock_init(&s->lock);
30 return 0;
33 int sidtab_insert(struct sidtab *s, u32 sid, struct context *context)
35 int hvalue, rc = 0;
36 struct sidtab_node *prev, *cur, *newnode;
38 if (!s) {
39 rc = -ENOMEM;
40 goto out;
43 hvalue = SIDTAB_HASH(sid);
44 prev = NULL;
45 cur = s->htable[hvalue];
46 while (cur && sid > cur->sid) {
47 prev = cur;
48 cur = cur->next;
51 if (cur && sid == cur->sid) {
52 rc = -EEXIST;
53 goto out;
56 newnode = kmalloc(sizeof(*newnode), GFP_ATOMIC);
57 if (newnode == NULL) {
58 rc = -ENOMEM;
59 goto out;
61 newnode->sid = sid;
62 if (context_cpy(&newnode->context, context)) {
63 kfree(newnode);
64 rc = -ENOMEM;
65 goto out;
68 if (prev) {
69 newnode->next = prev->next;
70 wmb();
71 prev->next = newnode;
72 } else {
73 newnode->next = s->htable[hvalue];
74 wmb();
75 s->htable[hvalue] = newnode;
78 s->nel++;
79 if (sid >= s->next_sid)
80 s->next_sid = sid + 1;
81 out:
82 return rc;
85 static struct context *sidtab_search_core(struct sidtab *s, u32 sid, int force)
87 int hvalue;
88 struct sidtab_node *cur;
90 if (!s)
91 return NULL;
93 hvalue = SIDTAB_HASH(sid);
94 cur = s->htable[hvalue];
95 while (cur && sid > cur->sid)
96 cur = cur->next;
98 if (force && cur && sid == cur->sid && cur->context.len)
99 return &cur->context;
101 if (cur == NULL || sid != cur->sid || cur->context.len) {
102 /* Remap invalid SIDs to the unlabeled SID. */
103 sid = SECINITSID_UNLABELED;
104 hvalue = SIDTAB_HASH(sid);
105 cur = s->htable[hvalue];
106 while (cur && sid > cur->sid)
107 cur = cur->next;
108 if (!cur || sid != cur->sid)
109 return NULL;
112 return &cur->context;
115 struct context *sidtab_search(struct sidtab *s, u32 sid)
117 return sidtab_search_core(s, sid, 0);
120 struct context *sidtab_search_force(struct sidtab *s, u32 sid)
122 return sidtab_search_core(s, sid, 1);
125 int sidtab_map(struct sidtab *s,
126 int (*apply) (u32 sid,
127 struct context *context,
128 void *args),
129 void *args)
131 int i, rc = 0;
132 struct sidtab_node *cur;
134 if (!s)
135 goto out;
137 for (i = 0; i < SIDTAB_SIZE; i++) {
138 cur = s->htable[i];
139 while (cur) {
140 rc = apply(cur->sid, &cur->context, args);
141 if (rc)
142 goto out;
143 cur = cur->next;
146 out:
147 return rc;
150 static inline u32 sidtab_search_context(struct sidtab *s,
151 struct context *context)
153 int i;
154 struct sidtab_node *cur;
156 for (i = 0; i < SIDTAB_SIZE; i++) {
157 cur = s->htable[i];
158 while (cur) {
159 if (context_cmp(&cur->context, context))
160 return cur->sid;
161 cur = cur->next;
164 return 0;
167 int sidtab_context_to_sid(struct sidtab *s,
168 struct context *context,
169 u32 *out_sid)
171 u32 sid;
172 int ret = 0;
173 unsigned long flags;
175 *out_sid = SECSID_NULL;
177 sid = sidtab_search_context(s, context);
178 if (!sid) {
179 spin_lock_irqsave(&s->lock, flags);
180 /* Rescan now that we hold the lock. */
181 sid = sidtab_search_context(s, context);
182 if (sid)
183 goto unlock_out;
184 /* No SID exists for the context. Allocate a new one. */
185 if (s->next_sid == UINT_MAX || s->shutdown) {
186 ret = -ENOMEM;
187 goto unlock_out;
189 sid = s->next_sid++;
190 if (context->len)
191 printk(KERN_INFO
192 "SELinux: Context %s is not valid (left unmapped).\n",
193 context->str);
194 ret = sidtab_insert(s, sid, context);
195 if (ret)
196 s->next_sid--;
197 unlock_out:
198 spin_unlock_irqrestore(&s->lock, flags);
201 if (ret)
202 return ret;
204 *out_sid = sid;
205 return 0;
208 void sidtab_hash_eval(struct sidtab *h, char *tag)
210 int i, chain_len, slots_used, max_chain_len;
211 struct sidtab_node *cur;
213 slots_used = 0;
214 max_chain_len = 0;
215 for (i = 0; i < SIDTAB_SIZE; i++) {
216 cur = h->htable[i];
217 if (cur) {
218 slots_used++;
219 chain_len = 0;
220 while (cur) {
221 chain_len++;
222 cur = cur->next;
225 if (chain_len > max_chain_len)
226 max_chain_len = chain_len;
230 printk(KERN_DEBUG "%s: %d entries and %d/%d buckets used, longest "
231 "chain length %d\n", tag, h->nel, slots_used, SIDTAB_SIZE,
232 max_chain_len);
235 void sidtab_destroy(struct sidtab *s)
237 int i;
238 struct sidtab_node *cur, *temp;
240 if (!s)
241 return;
243 for (i = 0; i < SIDTAB_SIZE; i++) {
244 cur = s->htable[i];
245 while (cur) {
246 temp = cur;
247 cur = cur->next;
248 context_destroy(&temp->context);
249 kfree(temp);
251 s->htable[i] = NULL;
253 kfree(s->htable);
254 s->htable = NULL;
255 s->nel = 0;
256 s->next_sid = 1;
259 void sidtab_set(struct sidtab *dst, struct sidtab *src)
261 unsigned long flags;
263 spin_lock_irqsave(&src->lock, flags);
264 dst->htable = src->htable;
265 dst->nel = src->nel;
266 dst->next_sid = src->next_sid;
267 dst->shutdown = 0;
268 spin_unlock_irqrestore(&src->lock, flags);
271 void sidtab_shutdown(struct sidtab *s)
273 unsigned long flags;
275 spin_lock_irqsave(&s->lock, flags);
276 s->shutdown = 1;
277 spin_unlock_irqrestore(&s->lock, flags);