Changeset 331 for trunk/kernel/libk


Ignore:
Timestamp:
Aug 7, 2017, 10:06:03 AM (4 years ago)
Author:
max@…
Message:

style

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/kernel/libk/spinlock.c

    r296 r331  
    11/*
    22 * spinlock.c - kernel spinlock synchronization
    3  * 
     3 *
    44 * Authors   Ghassan Almaless  (2008,2009,2010,2011,2012)
    55 *           Alain Greiner     (2016}
     
    3535//////////////////////////////////////////////
    3636inline void spinlock_init( spinlock_t * lock )
    37 { 
    38         lock->taken = 0;
    39         lock->owner = NULL;
     37{
     38    lock->taken = 0;
     39    lock->owner = NULL;
    4040    list_entry_init( &lock->list );
    4141}
    4242
    4343///////////////////////////////////////////
    44 void spinlock_lock_busy( spinlock_t * lock, 
     44void spinlock_lock_busy( spinlock_t * lock,
    4545                         uint32_t   * irq_state )
    4646{
    47         reg_t               mode;
    48         volatile uint32_t   taken;
    49         thread_t          * this     = CURRENT_THREAD;
    50         bool_t              isAtomic = false;
     47    reg_t               mode;
     48    volatile uint32_t   taken;
     49    thread_t          * this     = CURRENT_THREAD;
     50    bool_t              isAtomic = false;
    5151
    5252    // disable interrupts
    53         hal_disable_irq( &mode );
    54  
     53    hal_disable_irq( &mode );
     54
    5555    // loop until success
    56         while( isAtomic == false )
    57         {
    58                 taken = lock->taken;
     56    while( isAtomic == false )
     57    {
     58        taken = lock->taken;
    5959
    6060        // try to take the lock if not already taken
    61                 if( taken == 0 )
     61        if( taken == 0 )
    6262        {
    63                     isAtomic = hal_atomic_cas( &lock->taken , 0 , 1 );
     63            isAtomic = hal_atomic_cas( &lock->taken , 0 , 1 );
    6464        }
    65         }
     65    }
    6666
    67         this->local_locks++;
     67    this->local_locks++;
    6868    lock->owner = this;
    6969    list_add_first( &this->locks_root , &lock->list );
    7070
    71     // irq_state must be restored when lock is released 
     71    // irq_state must be restored when lock is released
    7272    *irq_state = mode;
    7373}
     
    7777                           uint32_t     irq_state )
    7878{
    79         thread_t * this = CURRENT_THREAD;;
    80  
     79    thread_t * this = CURRENT_THREAD;;
     80
    8181    lock->owner = NULL;
    8282    lock->taken = 0;
    8383    this->local_locks--;
    8484    list_unlink( &lock->list );
    85  
    86         hal_restore_irq( irq_state );
     85
     86    hal_restore_irq( irq_state );
    8787}
    88    
     88
    8989///////////////////////////////////////
    9090void spinlock_lock( spinlock_t * lock )
    9191{
    92         reg_t             mode;
    93         thread_t        * this     = CURRENT_THREAD;
    94         bool_t            isAtomic = false;
    95         volatile uint32_t taken;
    96    
     92    reg_t             mode;
     93    thread_t        * this     = CURRENT_THREAD;
     94    bool_t            isAtomic = false;
     95    volatile uint32_t taken;
     96
    9797    // disable interrupts
    98         hal_disable_irq( &mode );
    99  
     98    hal_disable_irq( &mode );
     99
    100100    // loop until success
    101         while( isAtomic == false )
    102         {
     101    while( isAtomic == false )
     102    {
    103103        taken = lock->taken;
    104104
    105105        // deschedule without blocking when lock already taken
    106                 if( taken != 0 )
     106        if( taken != 0 )
    107107        {
    108108            hal_restore_irq( mode );
     
    113113
    114114        // try to atomically take the lock if not already taken
    115             isAtomic = hal_atomic_cas( &lock->taken , 0 , 1 );
     115        isAtomic = hal_atomic_cas( &lock->taken , 0 , 1 );
    116116    }
    117117
    118         this->local_locks++;
     118    this->local_locks++;
    119119    lock->owner = this;
    120120    list_add_first( &this->locks_root , &lock->list );
     
    126126/////////////////////////////////////////////
    127127error_t spinlock_trylock( spinlock_t * lock )
    128 { 
    129         reg_t      mode;
    130         bool_t     isAtomic = false;
    131         thread_t * this     = CURRENT_THREAD;
     128{
     129    reg_t      mode;
     130    bool_t     isAtomic = false;
     131    thread_t * this     = CURRENT_THREAD;
    132132
    133         hal_disable_irq( &mode );
     133    hal_disable_irq( &mode );
    134134
    135         if( lock->taken == 0)
    136                 isAtomic = hal_atomic_cas( &lock->taken , 0 , 1);
    137  
    138         if(isAtomic == false)
    139         {
    140                 hal_restore_irq(mode);
    141                 return 1;
    142         }
     135    if( lock->taken == 0)
     136        isAtomic = hal_atomic_cas( &lock->taken , 0 , 1);
     137
     138    if(isAtomic == false)
     139    {
     140        hal_restore_irq(mode);
     141        return 1;
     142    }
    143143    else
    144144    {
    145             this->local_locks++;
    146             lock->owner = this;
     145        this->local_locks++;
     146        lock->owner = this;
    147147        list_add_first( &this->locks_root , &lock->list );
    148             hal_restore_irq(mode); 
    149             return 0;
     148        hal_restore_irq(mode);
     149        return 0;
    150150    }
    151151}
     
    154154void spinlock_unlock( spinlock_t * lock )
    155155{
    156         thread_t * this = CURRENT_THREAD;
    157  
     156    thread_t * this = CURRENT_THREAD;
     157
    158158    lock->owner = NULL;
    159159    lock->taken = 0;
     
    162162}
    163163
    164 
Note: See TracChangeset for help on using the changeset viewer.