← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to security/selinux/ss/sidtab.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
security/selinux/ss/sidtab.c
 
1
/*
 
2
 * Implementation of the SID table type.
 
3
 *
 
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"
 
13
 
 
14
#define SIDTAB_HASH(sid) \
 
15
(sid & SIDTAB_HASH_MASK)
 
16
 
 
17
int sidtab_init(struct sidtab *s)
 
18
{
 
19
        int i;
 
20
 
 
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;
 
31
}
 
32
 
 
33
int sidtab_insert(struct sidtab *s, u32 sid, struct context *context)
 
34
{
 
35
        int hvalue, rc = 0;
 
36
        struct sidtab_node *prev, *cur, *newnode;
 
37
 
 
38
        if (!s) {
 
39
                rc = -ENOMEM;
 
40
                goto out;
 
41
        }
 
42
 
 
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;
 
49
        }
 
50
 
 
51
        if (cur && sid == cur->sid) {
 
52
                rc = -EEXIST;
 
53
                goto out;
 
54
        }
 
55
 
 
56
        newnode = kmalloc(sizeof(*newnode), GFP_ATOMIC);
 
57
        if (newnode == NULL) {
 
58
                rc = -ENOMEM;
 
59
                goto out;
 
60
        }
 
61
        newnode->sid = sid;
 
62
        if (context_cpy(&newnode->context, context)) {
 
63
                kfree(newnode);
 
64
                rc = -ENOMEM;
 
65
                goto out;
 
66
        }
 
67
 
 
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;
 
76
        }
 
77
 
 
78
        s->nel++;
 
79
        if (sid >= s->next_sid)
 
80
                s->next_sid = sid + 1;
 
81
out:
 
82
        return rc;
 
83
}
 
84
 
 
85
static struct context *sidtab_search_core(struct sidtab *s, u32 sid, int force)
 
86
{
 
87
        int hvalue;
 
88
        struct sidtab_node *cur;
 
89
 
 
90
        if (!s)
 
91
                return NULL;
 
92
 
 
93
        hvalue = SIDTAB_HASH(sid);
 
94
        cur = s->htable[hvalue];
 
95
        while (cur && sid > cur->sid)
 
96
                cur = cur->next;
 
97
 
 
98
        if (force && cur && sid == cur->sid && cur->context.len)
 
99
                return &cur->context;
 
100
 
 
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;
 
110
        }
 
111
 
 
112
        return &cur->context;
 
113
}
 
114
 
 
115
struct context *sidtab_search(struct sidtab *s, u32 sid)
 
116
{
 
117
        return sidtab_search_core(s, sid, 0);
 
118
}
 
119
 
 
120
struct context *sidtab_search_force(struct sidtab *s, u32 sid)
 
121
{
 
122
        return sidtab_search_core(s, sid, 1);
 
123
}
 
124
 
 
125
int sidtab_map(struct sidtab *s,
 
126
               int (*apply) (u32 sid,
 
127
                             struct context *context,
 
128
                             void *args),
 
129
               void *args)
 
130
{
 
131
        int i, rc = 0;
 
132
        struct sidtab_node *cur;
 
133
 
 
134
        if (!s)
 
135
                goto out;
 
136
 
 
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;
 
144
                }
 
145
        }
 
146
out:
 
147
        return rc;
 
148
}
 
149
 
 
150
static void sidtab_update_cache(struct sidtab *s, struct sidtab_node *n, int loc)
 
151
{
 
152
        BUG_ON(loc >= SIDTAB_CACHE_LEN);
 
153
 
 
154
        while (loc > 0) {
 
155
                s->cache[loc] = s->cache[loc - 1];
 
156
                loc--;
 
157
        }
 
158
        s->cache[0] = n;
 
159
}
 
160
 
 
161
static inline u32 sidtab_search_context(struct sidtab *s,
 
162
                                                  struct context *context)
 
163
{
 
164
        int i;
 
165
        struct sidtab_node *cur;
 
166
 
 
167
        for (i = 0; i < SIDTAB_SIZE; i++) {
 
168
                cur = s->htable[i];
 
169
                while (cur) {
 
170
                        if (context_cmp(&cur->context, context)) {
 
171
                                sidtab_update_cache(s, cur, SIDTAB_CACHE_LEN - 1);
 
172
                                return cur->sid;
 
173
                        }
 
174
                        cur = cur->next;
 
175
                }
 
176
        }
 
177
        return 0;
 
178
}
 
179
 
 
180
static inline u32 sidtab_search_cache(struct sidtab *s, struct context *context)
 
181
{
 
182
        int i;
 
183
        struct sidtab_node *node;
 
184
 
 
185
        for (i = 0; i < SIDTAB_CACHE_LEN; i++) {
 
186
                node = s->cache[i];
 
187
                if (unlikely(!node))
 
188
                        return 0;
 
189
                if (context_cmp(&node->context, context)) {
 
190
                        sidtab_update_cache(s, node, i);
 
191
                        return node->sid;
 
192
                }
 
193
        }
 
194
        return 0;
 
195
}
 
196
 
 
197
int sidtab_context_to_sid(struct sidtab *s,
 
198
                          struct context *context,
 
199
                          u32 *out_sid)
 
200
{
 
201
        u32 sid;
 
202
        int ret = 0;
 
203
        unsigned long flags;
 
204
 
 
205
        *out_sid = SECSID_NULL;
 
206
 
 
207
        sid  = sidtab_search_cache(s, context);
 
208
        if (!sid)
 
209
                sid = sidtab_search_context(s, context);
 
210
        if (!sid) {
 
211
                spin_lock_irqsave(&s->lock, flags);
 
212
                /* Rescan now that we hold the lock. */
 
213
                sid = sidtab_search_context(s, context);
 
214
                if (sid)
 
215
                        goto unlock_out;
 
216
                /* No SID exists for the context.  Allocate a new one. */
 
217
                if (s->next_sid == UINT_MAX || s->shutdown) {
 
218
                        ret = -ENOMEM;
 
219
                        goto unlock_out;
 
220
                }
 
221
                sid = s->next_sid++;
 
222
                if (context->len)
 
223
                        printk(KERN_INFO
 
224
                       "SELinux:  Context %s is not valid (left unmapped).\n",
 
225
                               context->str);
 
226
                ret = sidtab_insert(s, sid, context);
 
227
                if (ret)
 
228
                        s->next_sid--;
 
229
unlock_out:
 
230
                spin_unlock_irqrestore(&s->lock, flags);
 
231
        }
 
232
 
 
233
        if (ret)
 
234
                return ret;
 
235
 
 
236
        *out_sid = sid;
 
237
        return 0;
 
238
}
 
239
 
 
240
void sidtab_hash_eval(struct sidtab *h, char *tag)
 
241
{
 
242
        int i, chain_len, slots_used, max_chain_len;
 
243
        struct sidtab_node *cur;
 
244
 
 
245
        slots_used = 0;
 
246
        max_chain_len = 0;
 
247
        for (i = 0; i < SIDTAB_SIZE; i++) {
 
248
                cur = h->htable[i];
 
249
                if (cur) {
 
250
                        slots_used++;
 
251
                        chain_len = 0;
 
252
                        while (cur) {
 
253
                                chain_len++;
 
254
                                cur = cur->next;
 
255
                        }
 
256
 
 
257
                        if (chain_len > max_chain_len)
 
258
                                max_chain_len = chain_len;
 
259
                }
 
260
        }
 
261
 
 
262
        printk(KERN_DEBUG "%s:  %d entries and %d/%d buckets used, longest "
 
263
               "chain length %d\n", tag, h->nel, slots_used, SIDTAB_SIZE,
 
264
               max_chain_len);
 
265
}
 
266
 
 
267
void sidtab_destroy(struct sidtab *s)
 
268
{
 
269
        int i;
 
270
        struct sidtab_node *cur, *temp;
 
271
 
 
272
        if (!s)
 
273
                return;
 
274
 
 
275
        for (i = 0; i < SIDTAB_SIZE; i++) {
 
276
                cur = s->htable[i];
 
277
                while (cur) {
 
278
                        temp = cur;
 
279
                        cur = cur->next;
 
280
                        context_destroy(&temp->context);
 
281
                        kfree(temp);
 
282
                }
 
283
                s->htable[i] = NULL;
 
284
        }
 
285
        kfree(s->htable);
 
286
        s->htable = NULL;
 
287
        s->nel = 0;
 
288
        s->next_sid = 1;
 
289
}
 
290
 
 
291
void sidtab_set(struct sidtab *dst, struct sidtab *src)
 
292
{
 
293
        unsigned long flags;
 
294
        int i;
 
295
 
 
296
        spin_lock_irqsave(&src->lock, flags);
 
297
        dst->htable = src->htable;
 
298
        dst->nel = src->nel;
 
299
        dst->next_sid = src->next_sid;
 
300
        dst->shutdown = 0;
 
301
        for (i = 0; i < SIDTAB_CACHE_LEN; i++)
 
302
                dst->cache[i] = NULL;
 
303
        spin_unlock_irqrestore(&src->lock, flags);
 
304
}
 
305
 
 
306
void sidtab_shutdown(struct sidtab *s)
 
307
{
 
308
        unsigned long flags;
 
309
 
 
310
        spin_lock_irqsave(&s->lock, flags);
 
311
        s->shutdown = 1;
 
312
        spin_unlock_irqrestore(&s->lock, flags);
 
313
}