Changeset 22f7769 in mainline for src/synch


Ignore:
Timestamp:
2005-10-17T23:31:41Z (20 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
4b2c872d
Parents:
75eacab
Message:

Rename cpu_priority_{high|low|restore|read} functions to interrupts_{disable|enable|restore|read}.
Rename pri_t to ipl_t (Interrupt Priority Level).
Rename thread_t::pri to thread_t::priority.

Location:
src/synch
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • src/synch/rwlock.c

    r75eacab r22f7769  
    9797int _rwlock_write_lock_timeout(rwlock_t *rwl, __u32 usec, int trylock)
    9898{
    99         pri_t pri;
     99        ipl_t ipl;
    100100        int rc;
    101101       
    102         pri = cpu_priority_high();
     102        ipl = interrupts_disable();
    103103        spinlock_lock(&THREAD->lock);
    104104        THREAD->rwlock_holder_type = RWLOCK_WRITER;
    105105        spinlock_unlock(&THREAD->lock);
    106         cpu_priority_restore(pri);
     106        interrupts_restore(ipl);
    107107
    108108        /*
    … …  
    119119                 */
    120120                 
    121                 pri = cpu_priority_high();
     121                ipl = interrupts_disable();
    122122                spinlock_lock(&rwl->lock);
    123123                /*
    … …  
    129129                        let_others_in(rwl, ALLOW_READERS_ONLY);
    130130                spinlock_unlock(&rwl->lock);
    131                 cpu_priority_restore(pri);
     131                interrupts_restore(ipl);
    132132        }
    133133       
    … …  
    152152{
    153153        int rc;
    154         pri_t pri;
    155        
    156         pri = cpu_priority_high();
     154        ipl_t ipl;
     155       
     156        ipl = interrupts_disable();
    157157        spinlock_lock(&THREAD->lock);
    158158        THREAD->rwlock_holder_type = RWLOCK_READER;
    … …  
    205205                                /*
    206206                                 * The sleep timeouted.
    207                                  * We just restore the cpu priority.
     207                                 * We just restore interrupt priority level.
    208208                                 */
    209209                        case ESYNCH_OK_BLOCKED:         
    … …  
    216216                                 * rwl->lock is held.)
    217217                                 */
    218                                 cpu_priority_restore(pri);
     218                                interrupts_restore(ipl);
    219219                                break;
    220220                        case ESYNCH_OK_ATOMIC:
    … …  
    237237       
    238238        spinlock_unlock(&rwl->lock);
    239         cpu_priority_restore(pri);
     239        interrupts_restore(ipl);
    240240
    241241        return ESYNCH_OK_ATOMIC;
    … …  
    252252void rwlock_write_unlock(rwlock_t *rwl)
    253253{
    254         pri_t pri;
    255        
    256         pri = cpu_priority_high();
     254        ipl_t ipl;
     255       
     256        ipl = interrupts_disable();
    257257        spinlock_lock(&rwl->lock);
    258258        let_others_in(rwl, ALLOW_ALL);
    259259        spinlock_unlock(&rwl->lock);
    260         cpu_priority_restore(pri);
     260        interrupts_restore(ipl);
    261261       
    262262}
    … …  
    273273void rwlock_read_unlock(rwlock_t *rwl)
    274274{
    275         pri_t pri;
    276 
    277         pri = cpu_priority_high();
     275        ipl_t ipl;
     276
     277        ipl = interrupts_disable();
    278278        spinlock_lock(&rwl->lock);
    279279        if (!--rwl->readers_in)
    280280                let_others_in(rwl, ALLOW_ALL);
    281281        spinlock_unlock(&rwl->lock);
    282         cpu_priority_restore(pri);
     282        interrupts_restore(ipl);
    283283}
    284284
    … …  
    290290 *
    291291 * Must be called with rwl->lock locked.
    292  * Must be called with cpu_priority_high'ed.
     292 * Must be called with interrupts_disable()'d.
    293293 *
    294294 * @param rwl Reader/Writer lock.

  • src/synch/semaphore.c

    r75eacab r22f7769  
    4343void semaphore_initialize(semaphore_t *s, int val)
    4444{
    45         pri_t pri;
     45        ipl_t ipl;
    4646       
    4747        waitq_initialize(&s->wq);
    4848       
    49         pri = cpu_priority_high();
     49        ipl = interrupts_disable();
    5050
    5151        spinlock_lock(&s->wq.lock);
    … …  
    5353        spinlock_unlock(&s->wq.lock);
    5454
    55         cpu_priority_restore(pri);
     55        interrupts_restore(ipl);
    5656}
    5757

  • src/synch/waitq.c

    r75eacab r22f7769  
    138138int waitq_sleep_timeout(waitq_t *wq, __u32 usec, int nonblocking)
    139139{
    140         volatile pri_t pri; /* must be live after context_restore() */
     140        volatile ipl_t ipl; /* must be live after context_restore() */
    141141       
    142142       
    143143restart:
    144         pri = cpu_priority_high();
     144        ipl = interrupts_disable();
    145145       
    146146        /*
    … …  
    154154        if (THREAD->timeout_pending) {
    155155                spinlock_unlock(&THREAD->lock);
    156                 cpu_priority_restore(pri);             
     156                interrupts_restore(ipl);               
    157157                goto restart;
    158158        }
    … …  
    165165                wq->missed_wakeups--;
    166166                spinlock_unlock(&wq->lock);
    167                 cpu_priority_restore(pri);
     167                interrupts_restore(ipl);
    168168                return ESYNCH_OK_ATOMIC;
    169169        }
    … …  
    172172                        /* return immediatelly instead of going to sleep */
    173173                        spinlock_unlock(&wq->lock);
    174                         cpu_priority_restore(pri);
     174                        interrupts_restore(ipl);
    175175                        return ESYNCH_WOULD_BLOCK;
    176176                }
    … …  
    190190                        before_thread_runs();
    191191                        spinlock_unlock(&THREAD->lock);
    192                         cpu_priority_restore(pri);
     192                        interrupts_restore(ipl);
    193193                        return ESYNCH_TIMEOUT;
    194194                }
    … …  
    208208
    209209        scheduler();    /* wq->lock is released in scheduler_separated_stack() */
    210         cpu_priority_restore(pri);
     210        interrupts_restore(ipl);
    211211       
    212212        return ESYNCH_OK_BLOCKED;
    … …  
    229229void waitq_wakeup(waitq_t *wq, int all)
    230230{
    231         pri_t pri;
    232 
    233         pri = cpu_priority_high();
     231        ipl_t ipl;
     232
     233        ipl = interrupts_disable();
    234234        spinlock_lock(&wq->lock);
    235235
    … …  
    237237
    238238        spinlock_unlock(&wq->lock);     
    239         cpu_priority_restore(pri);     
     239        interrupts_restore(ipl);       
    240240}
    241241
Note: See TracChangeset for help on using the changeset viewer.