Changeset 22f7769 in mainline for src/proc


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/proc
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • 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}
Note: See TracChangeset for help on using the changeset viewer.