1 // SPDX-License-Identifier: GPL-2.0
3 * Implementation of the SID table type.
5 * Original author: Stephen Smalley, <stephen.smalley.work@gmail.com>
6 * Author: Ondrej Mosnacek, <omosnacek@gmail.com>
8 * Copyright (C) 2018 Red Hat, Inc.
11 #include <linux/errno.h>
12 #include <linux/kernel.h>
13 #include <linux/list.h>
14 #include <linux/rcupdate.h>
15 #include <linux/slab.h>
16 #include <linux/sched.h>
17 #include <linux/spinlock.h>
18 #include <asm/barrier.h>
24 struct sidtab_str_cache {
25 struct rcu_head rcu_member;
26 struct list_head lru_member;
27 struct sidtab_entry *parent;
29 char str[] __counted_by(len);
32 #define index_to_sid(index) ((index) + SECINITSID_NUM + 1)
33 #define sid_to_index(sid) ((sid) - (SECINITSID_NUM + 1))
35 int sidtab_init(struct sidtab *s)
39 memset(s->roots, 0, sizeof(s->roots));
41 for (i = 0; i < SECINITSID_NUM; i++)
47 hash_init(s->context_to_sid);
49 spin_lock_init(&s->lock);
51 #if CONFIG_SECURITY_SELINUX_SID2STR_CACHE_SIZE > 0
52 s->cache_free_slots = CONFIG_SECURITY_SELINUX_SID2STR_CACHE_SIZE;
53 INIT_LIST_HEAD(&s->cache_lru_list);
54 spin_lock_init(&s->cache_lock);
60 static u32 context_to_sid(struct sidtab *s, struct context *context, u32 hash)
62 struct sidtab_entry *entry;
66 hash_for_each_possible_rcu(s->context_to_sid, entry, list, hash) {
67 if (entry->hash != hash)
69 if (context_cmp(&entry->context, context)) {
78 int sidtab_set_initial(struct sidtab *s, u32 sid, struct context *context)
80 struct sidtab_isid_entry *isid;
84 if (sid == 0 || sid > SECINITSID_NUM)
87 isid = &s->isids[sid - 1];
89 rc = context_cpy(&isid->entry.context, context);
93 #if CONFIG_SECURITY_SELINUX_SID2STR_CACHE_SIZE > 0
94 isid->entry.cache = NULL;
98 hash = context_compute_hash(context);
101 * Multiple initial sids may map to the same context. Check that this
102 * context is not already represented in the context_to_sid hashtable
103 * to avoid duplicate entries and long linked lists upon hash
106 if (!context_to_sid(s, context, hash)) {
107 isid->entry.sid = sid;
108 isid->entry.hash = hash;
109 hash_add(s->context_to_sid, &isid->entry.list, hash);
115 int sidtab_hash_stats(struct sidtab *sidtab, char *page)
121 int max_chain_len = 0;
123 struct sidtab_entry *entry;
126 hash_for_each_rcu(sidtab->context_to_sid, i, entry, list) {
128 if (i == cur_bucket) {
134 if (chain_len > max_chain_len)
135 max_chain_len = chain_len;
141 if (chain_len > max_chain_len)
142 max_chain_len = chain_len;
144 return scnprintf(page, PAGE_SIZE,
145 "entries: %d\nbuckets used: %d/%d\n"
146 "longest chain: %d\n",
147 entries, slots_used, SIDTAB_HASH_BUCKETS,
151 static u32 sidtab_level_from_count(u32 count)
153 u32 capacity = SIDTAB_LEAF_ENTRIES;
156 while (count > capacity) {
157 capacity <<= SIDTAB_INNER_SHIFT;
163 static int sidtab_alloc_roots(struct sidtab *s, u32 level)
167 if (!s->roots[0].ptr_leaf) {
168 s->roots[0].ptr_leaf =
169 kzalloc(SIDTAB_NODE_ALLOC_SIZE, GFP_ATOMIC);
170 if (!s->roots[0].ptr_leaf)
173 for (l = 1; l <= level; ++l)
174 if (!s->roots[l].ptr_inner) {
175 s->roots[l].ptr_inner =
176 kzalloc(SIDTAB_NODE_ALLOC_SIZE, GFP_ATOMIC);
177 if (!s->roots[l].ptr_inner)
179 s->roots[l].ptr_inner->entries[0] = s->roots[l - 1];
184 static struct sidtab_entry *sidtab_do_lookup(struct sidtab *s, u32 index,
187 union sidtab_entry_inner *entry;
188 u32 level, capacity_shift, leaf_index = index / SIDTAB_LEAF_ENTRIES;
190 /* find the level of the subtree we need */
191 level = sidtab_level_from_count(index + 1);
192 capacity_shift = level * SIDTAB_INNER_SHIFT;
194 /* allocate roots if needed */
195 if (alloc && sidtab_alloc_roots(s, level) != 0)
198 /* lookup inside the subtree */
199 entry = &s->roots[level];
201 capacity_shift -= SIDTAB_INNER_SHIFT;
204 entry = &entry->ptr_inner->entries[leaf_index >> capacity_shift];
205 leaf_index &= ((u32)1 << capacity_shift) - 1;
207 if (!entry->ptr_inner) {
209 entry->ptr_inner = kzalloc(
210 SIDTAB_NODE_ALLOC_SIZE, GFP_ATOMIC);
211 if (!entry->ptr_inner)
215 if (!entry->ptr_leaf) {
218 kzalloc(SIDTAB_NODE_ALLOC_SIZE, GFP_ATOMIC);
219 if (!entry->ptr_leaf)
222 return &entry->ptr_leaf->entries[index % SIDTAB_LEAF_ENTRIES];
225 static struct sidtab_entry *sidtab_lookup(struct sidtab *s, u32 index)
227 /* read entries only after reading count */
228 u32 count = smp_load_acquire(&s->count);
233 return sidtab_do_lookup(s, index, 0);
236 static struct sidtab_entry *sidtab_lookup_initial(struct sidtab *s, u32 sid)
238 return s->isids[sid - 1].set ? &s->isids[sid - 1].entry : NULL;
241 static struct sidtab_entry *sidtab_search_core(struct sidtab *s, u32 sid,
245 struct sidtab_entry *entry;
247 if (sid > SECINITSID_NUM)
248 entry = sidtab_lookup(s, sid_to_index(sid));
250 entry = sidtab_lookup_initial(s, sid);
251 if (entry && (!entry->context.len || force))
255 return sidtab_lookup_initial(s, SECINITSID_UNLABELED);
258 struct sidtab_entry *sidtab_search_entry(struct sidtab *s, u32 sid)
260 return sidtab_search_core(s, sid, 0);
263 struct sidtab_entry *sidtab_search_entry_force(struct sidtab *s, u32 sid)
265 return sidtab_search_core(s, sid, 1);
268 int sidtab_context_to_sid(struct sidtab *s, struct context *context, u32 *sid)
271 u32 count, hash = context_compute_hash(context);
272 struct sidtab_convert_params *convert;
273 struct sidtab_entry *dst, *dst_convert;
276 *sid = context_to_sid(s, context, hash);
280 /* lock-free search failed: lock, re-search, and insert if not found */
281 spin_lock_irqsave(&s->lock, flags);
284 *sid = context_to_sid(s, context, hash);
288 if (unlikely(s->frozen)) {
290 * This sidtab is now frozen - tell the caller to abort and
299 /* bail out if we already reached max entries */
301 if (count >= SIDTAB_MAX)
304 /* insert context into new entry */
306 dst = sidtab_do_lookup(s, count, 1);
310 dst->sid = index_to_sid(count);
313 rc = context_cpy(&dst->context, context);
318 * if we are building a new sidtab, we need to convert the context
319 * and insert it there as well
321 convert = s->convert;
323 struct sidtab *target = convert->target;
326 dst_convert = sidtab_do_lookup(target, count, 1);
328 context_destroy(&dst->context);
332 rc = services_convert_context(convert->args, context,
333 &dst_convert->context,
336 context_destroy(&dst->context);
339 dst_convert->sid = index_to_sid(count);
340 dst_convert->hash = context_compute_hash(&dst_convert->context);
341 target->count = count + 1;
343 hash_add_rcu(target->context_to_sid, &dst_convert->list,
348 pr_info("SELinux: Context %s is not valid (left unmapped).\n",
351 *sid = index_to_sid(count);
353 /* write entries before updating count */
354 smp_store_release(&s->count, count + 1);
355 hash_add_rcu(s->context_to_sid, &dst->list, dst->hash);
359 spin_unlock_irqrestore(&s->lock, flags);
363 static void sidtab_convert_hashtable(struct sidtab *s, u32 count)
365 struct sidtab_entry *entry;
368 for (i = 0; i < count; i++) {
369 entry = sidtab_do_lookup(s, i, 0);
370 entry->sid = index_to_sid(i);
371 entry->hash = context_compute_hash(&entry->context);
373 hash_add_rcu(s->context_to_sid, &entry->list, entry->hash);
377 static int sidtab_convert_tree(union sidtab_entry_inner *edst,
378 union sidtab_entry_inner *esrc, u32 *pos,
379 u32 count, u32 level,
380 struct sidtab_convert_params *convert)
386 if (!edst->ptr_inner) {
388 kzalloc(SIDTAB_NODE_ALLOC_SIZE, GFP_KERNEL);
389 if (!edst->ptr_inner)
393 while (i < SIDTAB_INNER_ENTRIES && *pos < count) {
394 rc = sidtab_convert_tree(&edst->ptr_inner->entries[i],
395 &esrc->ptr_inner->entries[i],
396 pos, count, level - 1,
403 if (!edst->ptr_leaf) {
405 kzalloc(SIDTAB_NODE_ALLOC_SIZE, GFP_KERNEL);
410 while (i < SIDTAB_LEAF_ENTRIES && *pos < count) {
411 rc = services_convert_context(
413 &esrc->ptr_leaf->entries[i].context,
414 &edst->ptr_leaf->entries[i].context,
426 int sidtab_convert(struct sidtab *s, struct sidtab_convert_params *params)
429 u32 count, level, pos;
432 spin_lock_irqsave(&s->lock, flags);
434 /* concurrent policy loads are not allowed */
436 spin_unlock_irqrestore(&s->lock, flags);
441 level = sidtab_level_from_count(count);
443 /* allocate last leaf in the new sidtab (to avoid race with
446 rc = sidtab_do_lookup(params->target, count - 1, 1) ? 0 : -ENOMEM;
448 spin_unlock_irqrestore(&s->lock, flags);
452 /* set count in case no new entries are added during conversion */
453 params->target->count = count;
455 /* enable live convert of new entries */
458 /* we can safely convert the tree outside the lock */
459 spin_unlock_irqrestore(&s->lock, flags);
461 pr_info("SELinux: Converting %u SID table entries...\n", count);
463 /* convert all entries not covered by live convert */
465 rc = sidtab_convert_tree(¶ms->target->roots[level],
466 &s->roots[level], &pos, count, level, params);
468 /* we need to keep the old table - disable live convert */
469 spin_lock_irqsave(&s->lock, flags);
471 spin_unlock_irqrestore(&s->lock, flags);
475 * The hashtable can also be modified in sidtab_context_to_sid()
476 * so we must re-acquire the lock here.
478 spin_lock_irqsave(&s->lock, flags);
479 sidtab_convert_hashtable(params->target, count);
480 spin_unlock_irqrestore(&s->lock, flags);
485 void sidtab_cancel_convert(struct sidtab *s)
489 /* cancelling policy load - disable live convert of sidtab */
490 spin_lock_irqsave(&s->lock, flags);
492 spin_unlock_irqrestore(&s->lock, flags);
495 void sidtab_freeze_begin(struct sidtab *s, unsigned long *flags)
498 spin_lock_irqsave(&s->lock, *flags);
502 void sidtab_freeze_end(struct sidtab *s, unsigned long *flags)
505 spin_unlock_irqrestore(&s->lock, *flags);
508 static void sidtab_destroy_entry(struct sidtab_entry *entry)
510 context_destroy(&entry->context);
511 #if CONFIG_SECURITY_SELINUX_SID2STR_CACHE_SIZE > 0
512 kfree(rcu_dereference_raw(entry->cache));
516 static void sidtab_destroy_tree(union sidtab_entry_inner entry, u32 level)
521 struct sidtab_node_inner *node = entry.ptr_inner;
526 for (i = 0; i < SIDTAB_INNER_ENTRIES; i++)
527 sidtab_destroy_tree(node->entries[i], level - 1);
530 struct sidtab_node_leaf *node = entry.ptr_leaf;
535 for (i = 0; i < SIDTAB_LEAF_ENTRIES; i++)
536 sidtab_destroy_entry(&node->entries[i]);
541 void sidtab_destroy(struct sidtab *s)
545 for (i = 0; i < SECINITSID_NUM; i++)
547 sidtab_destroy_entry(&s->isids[i].entry);
549 level = SIDTAB_MAX_LEVEL;
550 while (level && !s->roots[level].ptr_inner)
553 sidtab_destroy_tree(s->roots[level], level);
555 * The context_to_sid hashtable's objects are all shared
556 * with the isids array and context tree, and so don't need
557 * to be cleaned up here.
561 #if CONFIG_SECURITY_SELINUX_SID2STR_CACHE_SIZE > 0
563 void sidtab_sid2str_put(struct sidtab *s, struct sidtab_entry *entry,
564 const char *str, u32 str_len)
566 struct sidtab_str_cache *cache, *victim = NULL;
569 /* do not cache invalid contexts */
570 if (entry->context.len)
573 spin_lock_irqsave(&s->cache_lock, flags);
575 cache = rcu_dereference_protected(entry->cache,
576 lockdep_is_held(&s->cache_lock));
578 /* entry in cache - just bump to the head of LRU list */
579 list_move(&cache->lru_member, &s->cache_lru_list);
583 cache = kmalloc(struct_size(cache, str, str_len), GFP_ATOMIC);
587 if (s->cache_free_slots == 0) {
588 /* pop a cache entry from the tail and free it */
589 victim = container_of(s->cache_lru_list.prev,
590 struct sidtab_str_cache, lru_member);
591 list_del(&victim->lru_member);
592 rcu_assign_pointer(victim->parent->cache, NULL);
594 s->cache_free_slots--;
596 cache->parent = entry;
597 cache->len = str_len;
598 memcpy(cache->str, str, str_len);
599 list_add(&cache->lru_member, &s->cache_lru_list);
601 rcu_assign_pointer(entry->cache, cache);
604 spin_unlock_irqrestore(&s->cache_lock, flags);
605 kfree_rcu(victim, rcu_member);
608 int sidtab_sid2str_get(struct sidtab *s, struct sidtab_entry *entry, char **out,
611 struct sidtab_str_cache *cache;
614 if (entry->context.len)
615 return -ENOENT; /* do not cache invalid contexts */
619 cache = rcu_dereference(entry->cache);
623 *out_len = cache->len;
625 *out = kmemdup(cache->str, cache->len, GFP_ATOMIC);
634 sidtab_sid2str_put(s, entry, *out, *out_len);
638 #endif /* CONFIG_SECURITY_SELINUX_SID2STR_CACHE_SIZE > 0 */