~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/security/selinux/ss/sidtab.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 }
314 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp