Changeset da1bafb in mainline for kernel/generic/src/security/cap.c


Ignore:
Timestamp:
2010-05-24T18:57:31Z (15 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
0095368
Parents:
666f492
Message:

major code revision

  • replace spinlocks taken with interrupts disabled with irq_spinlocks
  • change spacing (not indendation) to be tab-size independent
  • use unsigned integer types where appropriate (especially bit flags)
  • visual separation
  • remove argument names in function prototypes
  • string changes
  • correct some formating directives
  • replace various cryptic single-character variables (t, a, m, c, b, etc.) with proper identifiers (thread, task, timeout, as, itm, itc, etc.)
  • unify some assembler constructs
  • unused page table levels are now optimized out in compile time
  • replace several ints (with boolean semantics) with bools
  • use specifically sized types instead of generic types where appropriate (size_t, uint32_t, btree_key_t)
  • improve comments
  • split asserts with conjuction into multiple independent asserts
File:
1 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/src/security/cap.c

    r666f492 rda1bafb  
    2727 */
    2828
    29 /** @addtogroup generic 
     29/** @addtogroup generic
    3030 * @{
    3131 */
    3232
    3333/**
    34  * @file        cap.c
    35  * @brief       Capabilities control.
     34 * @file cap.c
     35 * @brief Capabilities control.
    3636 *
    3737 * @see cap.h
    3838 */
    39  
     39
    4040#include <security/cap.h>
    4141#include <proc/task.h>
    … …  
    4848/** Set capabilities.
    4949 *
    50  * @param t Task whose capabilities are to be changed.
     50 * @param task Task whose capabilities are to be changed.
    5151 * @param caps New set of capabilities.
     52 *
    5253 */
    53 void cap_set(task_t *t, cap_t caps)
     54void cap_set(task_t *task, cap_t caps)
    5455{
    55         ipl_t ipl;
    56        
    57         ipl = interrupts_disable();
    58         spinlock_lock(&t->lock);
    59        
    60         t->capabilities = caps;
    61        
    62         spinlock_unlock(&t->lock);
    63         interrupts_restore(ipl);
     56        irq_spinlock_lock(&task->lock, true);
     57        task->capabilities = caps;
     58        irq_spinlock_unlock(&task->lock, true);
    6459}
    6560
    6661/** Get capabilities.
    6762 *
    68  * @param t Task whose capabilities are to be returned.
     63 * @param task Task whose capabilities are to be returned.
     64 *
    6965 * @return Task's capabilities.
     66 *
    7067 */
    71 cap_t cap_get(task_t *t)
     68cap_t cap_get(task_t *task)
    7269{
    73         ipl_t ipl;
    74         cap_t caps;
    75        
    76         ipl = interrupts_disable();
    77         spinlock_lock(&t->lock);
    78        
    79         caps = t->capabilities;
    80        
    81         spinlock_unlock(&t->lock);
    82         interrupts_restore(ipl);
     70        irq_spinlock_lock(&task->lock, true);
     71        cap_t caps = task->capabilities;
     72        irq_spinlock_unlock(&task->lock, true);
    8373       
    8474        return caps;
    … …  
    9383 *
    9484 * @return Zero on success or an error code from @ref errno.h.
     85 *
    9586 */
    9687unative_t sys_cap_grant(sysarg64_t *uspace_taskid_arg, cap_t caps)
    9788{
    98         sysarg64_t taskid_arg;
    99         task_t *t;
    100         ipl_t ipl;
    101         int rc;
    102        
    10389        if (!(cap_get(TASK) & CAP_CAP))
    10490                return (unative_t) EPERM;
    10591       
    106         rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
     92        sysarg64_t taskid_arg;
     93        int rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
    10794        if (rc != 0)
    10895                return (unative_t) rc;
    109                
    110         ipl = interrupts_disable();
    111         spinlock_lock(&tasks_lock);
    112         t = task_find_by_id((task_id_t) taskid_arg.value);
    113         if ((!t) || (!context_check(CONTEXT, t->context))) {
    114                 spinlock_unlock(&tasks_lock);
    115                 interrupts_restore(ipl);
     96       
     97        irq_spinlock_lock(&tasks_lock, true);
     98        task_t *task = task_find_by_id((task_id_t) taskid_arg.value);
     99       
     100        if ((!task) || (!context_check(CONTEXT, task->context))) {
     101                irq_spinlock_unlock(&tasks_lock, true);
    116102                return (unative_t) ENOENT;
    117103        }
    118104       
    119         spinlock_lock(&t->lock);
    120         cap_set(t, cap_get(t) | caps);
    121         spinlock_unlock(&t->lock);
     105        irq_spinlock_lock(&task->lock, false);
     106        task->capabilities |= caps;
     107        irq_spinlock_unlock(&task->lock, false);
    122108       
    123         spinlock_unlock(&tasks_lock);
    124         interrupts_restore(ipl);       
     109        irq_spinlock_unlock(&tasks_lock, true);
    125110        return 0;
    126111}
    … …  
    135120 *
    136121 * @return Zero on success or an error code from @ref errno.h.
     122 *
    137123 */
    138124unative_t sys_cap_revoke(sysarg64_t *uspace_taskid_arg, cap_t caps)
    139125{
    140126        sysarg64_t taskid_arg;
    141         task_t *t;
    142         ipl_t ipl;
    143         int rc;
    144        
    145         rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
     127        int rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
    146128        if (rc != 0)
    147129                return (unative_t) rc;
    148 
    149         ipl = interrupts_disable();
    150         spinlock_lock(&tasks_lock);     
    151         t = task_find_by_id((task_id_t) taskid_arg.value);
    152         if ((!t) || (!context_check(CONTEXT, t->context))) {
    153                 spinlock_unlock(&tasks_lock);
    154                 interrupts_restore(ipl);
     130       
     131        irq_spinlock_lock(&tasks_lock, true);
     132       
     133        task_t *task = task_find_by_id((task_id_t) taskid_arg.value);
     134        if ((!task) || (!context_check(CONTEXT, task->context))) {
     135                irq_spinlock_unlock(&tasks_lock, true);
    155136                return (unative_t) ENOENT;
    156137        }
    157 
     138       
    158139        /*
    159140         * Revoking capabilities is different from granting them in that
    … …  
    161142         * doesn't have CAP_CAP.
    162143         */
    163         if (!(cap_get(TASK) & CAP_CAP) || !(t == TASK)) {
    164                 spinlock_unlock(&tasks_lock);
    165                 interrupts_restore(ipl);
     144        irq_spinlock_unlock(&TASK->lock, false);
     145       
     146        if ((!(TASK->capabilities & CAP_CAP)) || (task != TASK)) {
     147                irq_spinlock_unlock(&TASK->lock, false);
     148                irq_spinlock_unlock(&tasks_lock, true);
    166149                return (unative_t) EPERM;
    167150        }
    168151       
    169         spinlock_lock(&t->lock);
    170         cap_set(t, cap_get(t) & ~caps);
    171         spinlock_unlock(&t->lock);
    172 
    173         spinlock_unlock(&tasks_lock);
    174 
    175         interrupts_restore(ipl);
     152        task->capabilities &= ~caps;
     153        irq_spinlock_unlock(&TASK->lock, false);
     154       
     155        irq_spinlock_unlock(&tasks_lock, true);
    176156        return 0;
    177157}
    … …  
    179159/** @}
    180160 */
    181 
Note: See TracChangeset for help on using the changeset viewer.