Changeset 22f7769 in mainline for src


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
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • src/debug/print.c

    r75eacab r22f7769  
    286286        va_start(ap, fmt);
    287287
    288         irqpri = cpu_priority_high();
     288        irqpri = interrupts_disable();
    289289        spinlock_lock(&printflock);
    290290
    … …  
    401401out:
    402402        spinlock_unlock(&printflock);
    403         cpu_priority_restore(irqpri);
     403        interrupts_restore(irqpri);
    404404       
    405405        va_end(ap);

  • src/lib/func.c

    r75eacab r22f7769  
    4444{
    4545        haltstate = 1;
    46         cpu_priority_high();
     46        interrupts_disable();
    4747        if (CPU)
    4848                printf("cpu%d: halted\n", CPU->id);

  • src/main/kinit.c

    r75eacab r22f7769  
    6565        int i;
    6666
    67         cpu_priority_high();
     67        interrupts_disable();
    6868
    6969#ifdef __SMP__                 
    … …  
    116116#endif /* __SMP__ */
    117117
    118         cpu_priority_low();
     118        interrupts_enable();
    119119
    120120#ifdef __USERSPACE__

  • src/main/main.c

    r75eacab r22f7769  
    110110 * Initializes the kernel by bootstrap CPU.
    111111 *
    112  * Assuming cpu_priority_high().
     112 * Assuming interrupts_disable().
    113113 *
    114114 */
    … …  
    209209 * is at ctx.sp which was set during BP boot.
    210210 *
    211  * Assuming  cpu_priority_high().
     211 * Assuming interrupts_disable()'d.
    212212 *
    213213 */

  • src/mm/frame.c

    r75eacab r22f7769  
    6969__address frame_alloc(int flags)
    7070{
    71         pri_t pri;
     71        ipl_t ipl;
    7272        link_t *cur, *tmp;
    7373        zone_t *z;
    … …  
    7777       
    7878loop:
    79         pri = cpu_priority_high();
     79        ipl = interrupts_disable();
    8080        spinlock_lock(&zone_head_lock);
    8181       
    … …  
    105105                 */
    106106                spinlock_unlock(&zone_head_lock);
    107                 cpu_priority_restore(pri);
     107                interrupts_restore(ipl);
    108108
    109109                panic("Sleep not implemented.\n");
    … …  
    127127       
    128128        spinlock_unlock(&zone_head_lock);
    129         cpu_priority_restore(pri);
     129        interrupts_restore(ipl);
    130130       
    131131        return v;
    … …  
    142142void frame_free(__address addr)
    143143{
    144         pri_t pri;
     144        ipl_t ipl;
    145145        link_t *cur;
    146146        zone_t *z;
    … …  
    150150        ASSERT(addr % FRAME_SIZE == 0);
    151151       
    152         pri = cpu_priority_high();
     152        ipl = interrupts_disable();
    153153        spinlock_lock(&zone_head_lock);
    154154       
    … …  
    188188       
    189189        spinlock_unlock(&zone_head_lock);
    190         cpu_priority_restore(pri);
     190        interrupts_restore(ipl);
    191191}
    192192
    … …  
    200200void frame_not_free(__address addr)
    201201{
    202         pri_t pri;
     202        ipl_t ipl;
    203203        link_t *cur;
    204204        zone_t *z;
    … …  
    208208        ASSERT(addr % FRAME_SIZE == 0);
    209209       
    210         pri = cpu_priority_high();
     210        ipl = interrupts_disable();
    211211        spinlock_lock(&zone_head_lock);
    212212       
    … …  
    247247       
    248248        spinlock_unlock(&zone_head_lock);
    249         cpu_priority_restore(pri);
     249        interrupts_restore(ipl);
    250250}
    251251
    … …  
    336336void zone_attach(zone_t *zone)
    337337{
    338         pri_t pri;
    339        
    340         pri = cpu_priority_high();
     338        ipl_t ipl;
     339       
     340        ipl = interrupts_disable();
    341341        spinlock_lock(&zone_head_lock);
    342342       
    … …  
    344344       
    345345        spinlock_unlock(&zone_head_lock);
    346         cpu_priority_restore(pri);
     346        interrupts_restore(ipl);
    347347}
    348348

  • src/mm/heap.c

    r75eacab r22f7769  
    6161void *early_malloc(size_t size)
    6262{
    63         pri_t pri;
     63        ipl_t ipl;
    6464        chunk_t *x, *y, *z;
    6565
    … …  
    6868               
    6969        x = chunk0;
    70         pri = cpu_priority_high();
     70        ipl = interrupts_disable();
    7171        spinlock_lock(&heaplock);               
    7272        while (x) {
    … …  
    8585                if (x->size < size + sizeof(chunk_t) + 1) {
    8686                        spinlock_unlock(&heaplock);
    87                         cpu_priority_restore(pri);
     87                        interrupts_restore(ipl);
    8888                        return &x->data[0];
    8989                }
    … …  
    106106                x->next = y;
    107107                spinlock_unlock(&heaplock);
    108                 cpu_priority_restore(pri);
     108                interrupts_restore(ipl);
    109109
    110110                return &x->data[0];
    111111        }
    112112        spinlock_unlock(&heaplock);
    113         cpu_priority_restore(pri);
     113        interrupts_restore(ipl);
    114114        return NULL;
    115115}
    … …  
    117117void early_free(void *ptr)
    118118{
    119         pri_t pri;
     119        ipl_t ipl;
    120120        chunk_t *x, *y, *z;
    121121
    … …  
    128128                panic("freeing unused/damaged chunk");
    129129
    130         pri = cpu_priority_high();
     130        ipl = interrupts_disable();
    131131        spinlock_lock(&heaplock);
    132132        x = y->prev;
    … …  
    151151        y->used = 0;
    152152        spinlock_unlock(&heaplock);
    153         cpu_priority_restore(pri);
     153        interrupts_restore(ipl);
    154154}

  • src/mm/vm.c

    r75eacab r22f7769  
    9090vm_area_t *vm_area_create(vm_t *m, vm_type_t type, size_t size, __address addr)
    9191{
    92         pri_t pri;
     92        ipl_t ipl;
    9393        vm_area_t *a;
    9494       
    … …  
    9696                panic("addr not aligned to a page boundary");
    9797       
    98         pri = cpu_priority_high();
     98        ipl = interrupts_disable();
    9999        spinlock_lock(&m->lock);
    100100       
    … …  
    111111                        free(a);
    112112                        spinlock_unlock(&m->lock);
    113                         cpu_priority_restore(pri);
     113                        interrupts_restore(ipl);
    114114                        return NULL;
    115115                }
    … …  
    130130
    131131        spinlock_unlock(&m->lock);
    132         cpu_priority_restore(pri);
     132        interrupts_restore(ipl);
    133133       
    134134        return a;
    … …  
    142142{
    143143        int i, flags;
    144         pri_t pri;
    145        
    146         pri = cpu_priority_high();
     144        ipl_t ipl;
     145       
     146        ipl = interrupts_disable();
    147147        spinlock_lock(&m->lock);
    148148        spinlock_lock(&a->lock);
    … …  
    166166        spinlock_unlock(&a->lock);
    167167        spinlock_unlock(&m->lock);
    168         cpu_priority_restore(pri);
     168        interrupts_restore(ipl);
    169169}
    170170
    … …  
    172172{
    173173        int i;
    174         pri_t pri;
    175        
    176         pri = cpu_priority_high();
     174        ipl_t ipl;
     175       
     176        ipl = interrupts_disable();
    177177        spinlock_lock(&m->lock);
    178178        spinlock_lock(&a->lock);
    … …  
    184184        spinlock_unlock(&a->lock);
    185185        spinlock_unlock(&m->lock);
    186         cpu_priority_restore(pri);
     186        interrupts_restore(ipl);
    187187}
    188188
    … …  
    190190{
    191191        link_t *l;
    192         pri_t pri;
    193        
    194         pri = cpu_priority_high();
     192        ipl_t ipl;
     193       
     194        ipl = interrupts_disable();
    195195
    196196        tlb_shootdown_start();
    … …  
    203203        tlb_shootdown_finalize();
    204204
    205         cpu_priority_restore(pri);
     205        interrupts_restore(ipl);
    206206
    207207        vm_install_arch(m);

  • src/proc/scheduler.c

    r75eacab r22f7769  
    126126
    127127loop:
    128         cpu_priority_high();
     128        interrupts_disable();
    129129
    130130        spinlock_lock(&CPU->lock);
    … …  
    132132        spinlock_unlock(&CPU->lock);
    133133
    134         cpu_priority_low();
     134        interrupts_enable();
    135135       
    136136        if (n == 0) {
    … …  
    156156        }
    157157
    158         cpu_priority_high();
     158        interrupts_disable();
    159159       
    160160        i = 0;
    … …  
    197197
    198198                t->ticks = us2ticks((i+1)*10000);
    199                 t->pri = i;     /* eventually correct rq index */
     199                t->priority = i;        /* eventually correct rq index */
    200200
    201201                /*
    … …  
    262262void scheduler(void)
    263263{
    264         volatile pri_t pri;
     264        volatile ipl_t ipl;
    265265
    266266        ASSERT(CPU != NULL);
    267267
    268         pri = cpu_priority_high();
     268        ipl = interrupts_disable();
    269269
    270270        if (haltstate)
    … …  
    282282                        before_thread_runs();
    283283                        spinlock_unlock(&THREAD->lock);
    284                         cpu_priority_restore(THREAD->saved_context.pri);
     284                        interrupts_restore(THREAD->saved_context.ipl);
    285285                        return;
    286286                }
    287287
    288288                /*
    289                  * CPU priority of preempted thread is recorded here
    290                  * to facilitate scheduler() invocations from
    291                  * cpu_priority_high()'ed code (e.g. waitq_sleep_timeout()).
    292                  */
    293                 THREAD->saved_context.pri = pri;
     289                 * Interrupt priority level of preempted thread is recorded here
     290                 * to facilitate scheduler() invocations from interrupts_disable()'d
     291                 * code (e.g. waitq_sleep_timeout()).
     292                 */
     293                THREAD->saved_context.ipl = ipl;
    294294        }
    295295
    … …  
    372372                         * Prefer the thread after it's woken up.
    373373                         */
    374                         THREAD->pri = -1;
     374                        THREAD->priority = -1;
    375375
    376376                        /*
    … …  
    407407       
    408408        spinlock_lock(&THREAD->lock);
    409         priority = THREAD->pri;
     409        priority = THREAD->priority;
    410410        spinlock_unlock(&THREAD->lock);
    411411
    … …  
    447447
    448448        #ifdef SCHEDULER_VERBOSE
    449         printf("cpu%d: tid %d (pri=%d,ticks=%d,nrdy=%d)\n", CPU->id, THREAD->tid, THREAD->pri, THREAD->ticks, CPU->nrdy);
     449        printf("cpu%d: tid %d (priority=%d,ticks=%d,nrdy=%d)\n", CPU->id, THREAD->tid, THREAD->priority, THREAD->ticks, CPU->nrdy);
    450450        #endif 
    451451
    … …  
    473473        thread_t *t;
    474474        int count, i, j, k = 0;
    475         pri_t pri;
     475        ipl_t ipl;
    476476
    477477loop:
    … …  
    487487         * passes. Each time get the most up to date counts.
    488488         */
    489         pri = cpu_priority_high();
     489        ipl = interrupts_disable();
    490490        spinlock_lock(&CPU->lock);
    491491        count = nrdy / config.cpu_active;
    492492        count -= CPU->nrdy;
    493493        spinlock_unlock(&CPU->lock);
    494         cpu_priority_restore(pri);
     494        interrupts_restore(ipl);
    495495
    496496        if (count <= 0)
    … …  
    515515                                continue;                               
    516516
    517 restart:                pri = cpu_priority_high();
     517restart:                ipl = interrupts_disable();
    518518                        r = &cpu->rq[j];
    519519                        spinlock_lock(&r->lock);
    520520                        if (r->n == 0) {
    521521                                spinlock_unlock(&r->lock);
    522                                 cpu_priority_restore(pri);
     522                                interrupts_restore(ipl);
    523523                                continue;
    524524                        }
    … …  
    549549                                                /* Release all locks and try again. */
    550550                                                spinlock_unlock(&r->lock);
    551                                                 cpu_priority_restore(pri);
     551                                                interrupts_restore(ipl);
    552552                                                goto restart;
    553553                                        }
    … …  
    581581                                thread_ready(t);
    582582
    583                                 cpu_priority_restore(pri);
     583                                interrupts_restore(ipl);
    584584       
    585585                                if (--count == 0)
    … …  
    593593                                continue;
    594594                        }
    595                         cpu_priority_restore(pri);
     595                        interrupts_restore(ipl);
    596596                }
    597597        }

  • src/proc/task.c

    r75eacab r22f7769  
    6565task_t *task_create(vm_t *m)
    6666{
    67         pri_t pri;
     67        ipl_t ipl;
    6868        task_t *ta;
    6969       
    … …  
    7575                ta->vm = m;
    7676               
    77                 pri = cpu_priority_high();
     77                ipl = interrupts_disable();
    7878                spinlock_lock(&tasks_lock);
    7979                list_append(&ta->tasks_link, &tasks_head);
    8080                spinlock_unlock(&tasks_lock);
    81                 cpu_priority_restore(pri);
     81                interrupts_restore(ipl);
    8282        }
    8383        return ta;

  • src/proc/thread.c

    r75eacab r22f7769  
    6868 * function returns.
    6969 *
    70  * cpu_priority_high() is assumed.
     70 * interrupts_disable() is assumed.
    7171 *
    7272 */
    … …  
    8080
    8181        spinlock_unlock(&THREAD->lock);
    82         cpu_priority_low();
     82        interrupts_enable();
    8383
    8484        f(arg);
    … …  
    113113        cpu_t *cpu;
    114114        runq_t *r;
    115         pri_t pri;
     115        ipl_t ipl;
    116116        int i, avg, send_ipi = 0;
    117117
    118         pri = cpu_priority_high();
     118        ipl = interrupts_disable();
    119119
    120120        spinlock_lock(&t->lock);
    121121
    122         i = (t->pri < RQ_COUNT -1) ? ++t->pri : t->pri;
     122        i = (t->priority < RQ_COUNT -1) ? ++t->priority : t->priority;
    123123       
    124124        cpu = CPU;
    … …  
    149149        spinlock_unlock(&cpu->lock);
    150150
    151         cpu_priority_restore(pri);
     151        interrupts_restore(ipl);
    152152}
    153153
    … …  
    172172        t = (thread_t *) malloc(sizeof(thread_t));
    173173        if (t) {
    174                 pri_t pri;
     174                ipl_t ipl;
    175175       
    176176                spinlock_initialize(&t->lock);
    … …  
    181181                }
    182182
    183                 pri = cpu_priority_high();
     183                ipl = interrupts_disable();
    184184                spinlock_lock(&tidlock);
    185185                t->tid = ++last_tid;
    186186                spinlock_unlock(&tidlock);
    187                 cpu_priority_restore(pri);
     187                interrupts_restore(ipl);
    188188               
    189189                memsetb(frame_ks, THREAD_STACK_SIZE, 0);
    … …  
    200200                the_initialize((the_t *) t->kstack);
    201201
    202                 pri = cpu_priority_high();
    203                 t->saved_context.pri = cpu_priority_read();
    204                 cpu_priority_restore(pri);
     202                ipl = interrupts_disable();
     203                t->saved_context.ipl = interrupts_read();
     204                interrupts_restore(ipl);
    205205               
    206206                t->thread_code = func;
    207207                t->thread_arg = arg;
    208208                t->ticks = -1;
    209                 t->pri = -1;            /* start in rq[0] */
     209                t->priority = -1;               /* start in rq[0] */
    210210                t->cpu = NULL;
    211211                t->flags = 0;
    … …  
    228228                 * Register this thread in the system-wide list.
    229229                 */
    230                 pri = cpu_priority_high();             
     230                ipl = interrupts_disable();             
    231231                spinlock_lock(&threads_lock);
    232232                list_append(&t->threads_link, &threads_head);
    … …  
    240240                spinlock_unlock(&task->lock);
    241241
    242                 cpu_priority_restore(pri);
     242                interrupts_restore(ipl);
    243243        }
    244244
    … …  
    255255void thread_exit(void)
    256256{
    257         pri_t pri;
     257        ipl_t ipl;
    258258
    259259restart:
    260         pri = cpu_priority_high();
     260        ipl = interrupts_disable();
    261261        spinlock_lock(&THREAD->lock);
    262262        if (THREAD->timeout_pending) { /* busy waiting for timeouts in progress */
    263263                spinlock_unlock(&THREAD->lock);
    264                 cpu_priority_restore(pri);
     264                interrupts_restore(ipl);
    265265                goto restart;
    266266        }
    … …  
    312312void thread_register_call_me(void (* call_me)(void *), void *call_me_with)
    313313{
    314         pri_t pri;
    315        
    316         pri = cpu_priority_high();
     314        ipl_t ipl;
     315       
     316        ipl = interrupts_disable();
    317317        spinlock_lock(&THREAD->lock);
    318318        THREAD->call_me = call_me;
    319319        THREAD->call_me_with = call_me_with;
    320320        spinlock_unlock(&THREAD->lock);
    321         cpu_priority_restore(pri);
    322 }
     321        interrupts_restore(ipl);
     322}

  • 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

  • src/time/clock.c

    r75eacab r22f7769  
    4545 *
    4646 * Clock routine executed from clock interrupt handler
    47  * (assuming cpu_priority_high()). Runs expired timeouts
     47 * (assuming interrupts_disable()'d). Runs expired timeouts
    4848 * and preemptive scheduling.
    4949 *

  • src/time/delay.c

    r75eacab r22f7769  
    4343void delay(__u32 usec)
    4444{
    45         pri_t pri;
     45        ipl_t ipl;
    4646       
    47         /* The delay loop is calibrated for each and every
    48            CPU in the system. Therefore it is necessary to
    49            cpu_priority_high() before calling the asm_delay_loop(). */
    50         pri = cpu_priority_high();
     47        /*
     48         * The delay loop is calibrated for each and every
     49         * CPU in the system. Therefore it is necessary to
     50         * call interrupts_disable() before calling the
     51         * asm_delay_loop().
     52         */
     53        ipl = interrupts_disable();
    5154        asm_delay_loop(usec * CPU->delay_loop_const);
    52         cpu_priority_restore(pri);
     55        interrupts_restore(ipl);
    5356}

  • src/time/timeout.c

    r75eacab r22f7769  
    101101        timeout_t *hlp;
    102102        link_t *l, *m;
    103         pri_t pri;
     103        ipl_t ipl;
    104104        __u64 sum;
    105105
    106         pri = cpu_priority_high();
     106        ipl = interrupts_disable();
    107107        spinlock_lock(&CPU->timeoutlock);
    108108        spinlock_lock(&t->lock);
    … …  
    153153        spinlock_unlock(&t->lock);
    154154        spinlock_unlock(&CPU->timeoutlock);
    155         cpu_priority_restore(pri);
     155        interrupts_restore(ipl);
    156156}
    157157
    … …  
    169169        timeout_t *hlp;
    170170        link_t *l;
    171         pri_t pri;
     171        ipl_t ipl;
    172172
    173173grab_locks:
    174         pri = cpu_priority_high();
     174        ipl = interrupts_disable();
    175175        spinlock_lock(&t->lock);
    176176        if (!t->cpu) {
    177177                spinlock_unlock(&t->lock);
    178                 cpu_priority_restore(pri);
     178                interrupts_restore(ipl);
    179179                return false;
    180180        }
    181181        if (!spinlock_trylock(&t->cpu->timeoutlock)) {
    182182                spinlock_unlock(&t->lock);
    183                 cpu_priority_restore(pri);             
     183                interrupts_restore(ipl);               
    184184                goto grab_locks;
    185185        }
    … …  
    204204        spinlock_unlock(&t->lock);
    205205
    206         cpu_priority_restore(pri);
     206        interrupts_restore(ipl);
    207207        return true;
    208208}
Note: See TracChangeset for help on using the changeset viewer.