Changeset 43114c5 in mainline


Ignore:
Timestamp:
2005-04-09T18:22:53Z (20 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
8262010
Parents:
e6ba9a3f
Message:

Introduce macros CPU, THREAD, TASK and use them to replace the→cpu, the→thread, the→task.
Later on, this will make it possible to reference *current* cpu, thread and/or task without the aid from virtual memory.

Files:
29 edited

Legend:

Unmodified
Added
Removed

  • arch/ia32/src/cpu/cpu.c

    re6ba9a3f r43114c5  
    6262void cpu_arch_init(void)
    6363{
    64         the->cpu->arch.tss = tss_p;
     64        CPU->arch.tss = tss_p;
    6565}
    6666
    … …  
    7171        int i;
    7272
    73         the->cpu->arch.vendor = VendorUnknown;
     73        CPU->arch.vendor = VendorUnknown;
    7474        if (has_cpuid()) {
    7575                cpuid(0, &info);
    … …  
    8282                    info.cpuid_edx==AMD_CPUID_EDX) {
    8383                       
    84                         the->cpu->arch.vendor = VendorAMD;
     84                        CPU->arch.vendor = VendorAMD;
    8585                }
    8686
    … …  
    9292                    info.cpuid_edx==INTEL_CPUID_EDX) {
    9393
    94                         the->cpu->arch.vendor = VendorIntel;
     94                        CPU->arch.vendor = VendorIntel;
    9595
    9696                }
    9797                               
    9898                cpuid(1, &info);
    99                 the->cpu->arch.family = (info.cpuid_eax>>8)&0xf;
    100                 the->cpu->arch.model = (info.cpuid_eax>>4)&0xf;
    101                 the->cpu->arch.stepping = (info.cpuid_eax>>0)&0xf;                                             
     99                CPU->arch.family = (info.cpuid_eax>>8)&0xf;
     100                CPU->arch.model = (info.cpuid_eax>>4)&0xf;
     101                CPU->arch.stepping = (info.cpuid_eax>>0)&0xf;                                           
    102102        }
    103103}

  • arch/ia32/src/drivers/i8042.c

    re6ba9a3f r43114c5  
    5555        trap_virtual_eoi();
    5656        x = inb(0x60);
    57         printf("%d", the->cpu->id);;
     57        printf("%d", CPU->id);;
    5858}

  • arch/ia32/src/drivers/i8254.c

    re6ba9a3f r43114c5  
    111111
    112112
    113         the->cpu->delay_loop_const = ((MAGIC_NUMBER*LOOPS)/1000) / ((t1-t2)-(o1-o2)) +
     113        CPU->delay_loop_const = ((MAGIC_NUMBER*LOOPS)/1000) / ((t1-t2)-(o1-o2)) +
    114114                                    (((MAGIC_NUMBER*LOOPS)/1000) % ((t1-t2)-(o1-o2)) ? 1 : 0);
    115115       
    … …  
    119119        clk2 = rdtsc();
    120120       
    121         the->cpu->frequency_mhz = (clk2-clk1)>>SHIFT;
     121        CPU->frequency_mhz = (clk2-clk1)>>SHIFT;
    122122
    123123        return;

  • arch/ia32/src/drivers/i8259.c

    re6ba9a3f r43114c5  
    117117void pic_spurious(__u8 n, __u32 stack[])
    118118{
    119         printf("cpu%d: PIC spurious interrupt\n", the->cpu->id);
     119        printf("cpu%d: PIC spurious interrupt\n", CPU->id);
    120120}

  • arch/ia32/src/smp/apic.c

    re6ba9a3f r43114c5  
    115115void apic_spurious(__u8 n, __u32 stack[])
    116116{
    117         printf("cpu%d: APIC spurious interrupt\n", the->cpu->id);
     117        printf("cpu%d: APIC spurious interrupt\n", CPU->id);
    118118}
    119119
    … …  
    143143
    144144/*
    145  * Send all CPUs excluding the->cpu IPI vector.
     145 * Send all CPUs excluding CPU IPI vector.
    146146 */
    147147int l_apic_broadcast_custom_ipi(__u8 vector)
    … …  
    233233        l_apic[TPR] &= TPRClear;
    234234
    235         if (the->cpu->arch.family >= 6)
     235        if (CPU->arch.family >= 6)
    236236                enable_l_apic_in_msr();
    237237       
    … …  
    271271        int i, lint;
    272272
    273         printf("LVT on cpu%d, LAPIC ID: %d\n", the->cpu->id, (l_apic[L_APIC_ID] >> 24)&0xf);
     273        printf("LVT on cpu%d, LAPIC ID: %d\n", CPU->id, (l_apic[L_APIC_ID] >> 24)&0xf);
    274274
    275275        printf("LVT_Tm: ");
    … …  
    305305         * This register is supported only on P6 and higher.
    306306         */
    307         if (the->cpu->family > 5) {
     307        if (CPU->family > 5) {
    308308                printf("LVT_PCINT: ");
    309309                if (l_apic[LVT_PCINT] & (1<<16)) printf("masked"); else printf("not masked"); putchar(',');

  • arch/ia32/src/userspace.c

    re6ba9a3f r43114c5  
    4343         * Prepare TSS stack selector and pointers for next syscall.
    4444         */
    45         the->cpu->arch.tss->esp0 = (__address) &the->thread->kstack[THREAD_STACK_SIZE-8];
    46         the->cpu->arch.tss->ss0 = selector(KDATA_DES);
     45        CPU->arch.tss->esp0 = (__address) &THREAD->kstack[THREAD_STACK_SIZE-8];
     46        CPU->arch.tss->ss0 = selector(KDATA_DES);
    4747       
    4848        __asm__ volatile (""

  • arch/mips/src/cpu/cpu.c

    re6ba9a3f r43114c5  
    8484void cpu_identify(void)
    8585{
    86         the->cpu->arch.rev_num = cp0_prid_read() & 0xff;
    87         the->cpu->arch.imp_num = (cp0_prid_read() >> 8) & 0xff;
     86        CPU->arch.rev_num = cp0_prid_read() & 0xff;
     87        CPU->arch.imp_num = (cp0_prid_read() >> 8) & 0xff;
    8888}
    8989

  • arch/mips/src/exception.c

    re6ba9a3f r43114c5  
    4343        cp0_status_write(cp0_status_read() & ~ cp0_status_exl_exception_bit);
    4444
    45         if (the->thread) {
    46                 the->thread->saved_pri = pri;
    47                 the->thread->saved_epc = epc;
     45        if (THREAD) {
     46                THREAD->saved_pri = pri;
     47                THREAD->saved_epc = epc;
    4848        }
    4949        /* decode exception number and process the exception */
    … …  
    5555        }
    5656       
    57         if (the->thread) {
    58                 pri = the->thread->saved_pri;
    59                 epc = the->thread->saved_epc;
     57        if (THREAD) {
     58                pri = THREAD->saved_pri;
     59                epc = THREAD->saved_epc;
    6060        }
    6161

  • arch/mips/src/mm/tlb.c

    re6ba9a3f r43114c5  
    4747void tlb_invalid(void)
    4848{
    49         panic(PANIC "%X: TLB exception at %X", cp0_badvaddr_read(), the->thread ? the->thread->saved_epc : 0);
     49        panic(PANIC "%X: TLB exception at %X", cp0_badvaddr_read(), THREAD ? THREAD->saved_epc : 0);
    5050}
    5151

  • include/arch.h

    re6ba9a3f r43114c5  
    3535#include <cpu.h>
    3636
     37#define CPU             (the->cpu)
     38#define THREAD          (the->thread)
     39#define TASK            (the->task)
     40
    3741extern cpu_private_page_t *the;
    3842

  • src/cpu/cpu.c

    re6ba9a3f r43114c5  
    2828
    2929#include <cpu.h>
     30#include <arch.h>
    3031#include <arch/cpu.h>
    3132#include <mm/heap.h>
    … …  
    8586        #endif /* __SMP__ */
    8687       
    87         the->cpu = &cpus[config.cpu_active-1]; 
     88        CPU = &cpus[config.cpu_active-1];       
    8889        cpu_identify();
    8990        cpu_arch_init();

  • src/lib/func.c

    re6ba9a3f r43114c5  
    3939        haltstate = 1;
    4040        cpu_priority_high();
    41         printf("cpu%d: halted\n", the->cpu->id);
     41        printf("cpu%d: halted\n", CPU->id);
    4242        cpu_halt();
    4343}

  • src/main/kinit.c

    re6ba9a3f r43114c5  
    7171                 * Just a beautification.
    7272                 */
    73                 if (t = thread_create(kmp, NULL, the->task, 0)) {
     73                if (t = thread_create(kmp, NULL, TASK, 0)) {
    7474                        spinlock_lock(&t->lock);
    7575                        t->flags |= X_WIRED;
    … …  
    9696                for (i = 0; i < config.cpu_count; i++) {
    9797
    98                         if (t = thread_create(kcpulb, NULL, the->task, 0)) {
     98                        if (t = thread_create(kcpulb, NULL, TASK, 0)) {
    9999                                spinlock_lock(&t->lock);                       
    100100                                t->flags |= X_WIRED;

  • src/main/main.c

    re6ba9a3f r43114c5  
    185185         * switch to this cpu's private stack prior to waking kmp up.
    186186         */
    187         the->cpu->saved_context.sp = (__address) &the->cpu->stack[CPU_STACK_SIZE-8];
    188         the->cpu->saved_context.pc = (__address) main_ap_separated_stack;
    189         context_restore(&the->cpu->saved_context);
     187        CPU->saved_context.sp = (__address) &CPU->stack[CPU_STACK_SIZE-8];
     188        CPU->saved_context.pc = (__address) main_ap_separated_stack;
     189        context_restore(&CPU->saved_context);
    190190        /* not reached */
    191191}

  • src/proc/scheduler.c

    re6ba9a3f r43114c5  
    7070        cpu_priority_high();
    7171
    72         spinlock_lock(&the->cpu->lock);
    73         n = the->cpu->nrdy;
    74         spinlock_unlock(&the->cpu->lock);
     72        spinlock_lock(&CPU->lock);
     73        n = CPU->nrdy;
     74        spinlock_unlock(&CPU->lock);
    7575
    7676        cpu_priority_low();
    … …  
    8282                 * set CPU-private flag that the kcpulb has been started.
    8383                 */
    84                 if (test_and_set(&the->cpu->kcpulbstarted) == 0) {
    85                         waitq_wakeup(&the->cpu->kcpulb_wq, 0);
     84                if (test_and_set(&CPU->kcpulbstarted) == 0) {
     85                        waitq_wakeup(&CPU->kcpulb_wq, 0);
    8686                        goto loop;
    8787                }
    … …  
    101101
    102102        for (i = 0; i<RQ_COUNT; i++) {
    103                 r = &the->cpu->rq[i];
     103                r = &CPU->rq[i];
    104104                spinlock_lock(&r->lock);
    105105                if (r->n == 0) {
    … …  
    115115                spinlock_unlock(&nrdylock);             
    116116
    117                 spinlock_lock(&the->cpu->lock);
    118                 the->cpu->nrdy--;
    119                 spinlock_unlock(&the->cpu->lock);
     117                spinlock_lock(&CPU->lock);
     118                CPU->nrdy--;
     119                spinlock_unlock(&CPU->lock);
    120120
    121121                r->n--;
    … …  
    130130
    131131                spinlock_lock(&t->lock);
    132                 t->cpu = the->cpu;
     132                t->cpu = CPU;
    133133
    134134                t->ticks = us2ticks((i+1)*10000);
    … …  
    160160
    161161        list_initialize(&head);
    162         spinlock_lock(&the->cpu->lock);
    163         if (the->cpu->needs_relink > NEEDS_RELINK_MAX) {
     162        spinlock_lock(&CPU->lock);
     163        if (CPU->needs_relink > NEEDS_RELINK_MAX) {
    164164                for (i = start; i<RQ_COUNT-1; i++) {
    165165                        /* remember and empty rq[i + 1] */
    166                         r = &the->cpu->rq[i + 1];
     166                        r = &CPU->rq[i + 1];
    167167                        spinlock_lock(&r->lock);
    168168                        list_concat(&head, &r->rq_head);
    … …  
    172172               
    173173                        /* append rq[i + 1] to rq[i] */
    174                         r = &the->cpu->rq[i];
     174                        r = &CPU->rq[i];
    175175                        spinlock_lock(&r->lock);
    176176                        list_concat(&r->rq_head, &head);
    … …  
    178178                        spinlock_unlock(&r->lock);
    179179                }
    180                 the->cpu->needs_relink = 0;
    181         }
    182         spinlock_unlock(&the->cpu->lock);                               
     180                CPU->needs_relink = 0;
     181        }
     182        spinlock_unlock(&CPU->lock);                           
    183183
    184184}
    … …  
    196196                halt();
    197197
    198         if (the->thread) {
    199                 spinlock_lock(&the->thread->lock);
    200                 if (!context_save(&the->thread->saved_context)) {
     198        if (THREAD) {
     199                spinlock_lock(&THREAD->lock);
     200                if (!context_save(&THREAD->saved_context)) {
    201201                        /*
    202202                         * This is the place where threads leave scheduler();
    203203                         */
    204                         spinlock_unlock(&the->thread->lock);
    205                         cpu_priority_restore(the->thread->saved_context.pri);
     204                        spinlock_unlock(&THREAD->lock);
     205                        cpu_priority_restore(THREAD->saved_context.pri);
    206206                        return;
    207207                }
    208                 the->thread->saved_context.pri = pri;
     208                THREAD->saved_context.pri = pri;
    209209        }
    210210
    … …  
    221221         * scheduler_separated_stack().
    222222         */
    223         context_save(&the->cpu->saved_context);
    224         the->cpu->saved_context.sp = (__address) &the->cpu->stack[CPU_STACK_SIZE-8];
    225         the->cpu->saved_context.pc = (__address) scheduler_separated_stack;
    226         context_restore(&the->cpu->saved_context);
     223        context_save(&CPU->saved_context);
     224        CPU->saved_context.sp = (__address) &CPU->stack[CPU_STACK_SIZE-8];
     225        CPU->saved_context.pc = (__address) scheduler_separated_stack;
     226        context_restore(&CPU->saved_context);
    227227        /* not reached */
    228228}
    … …  
    232232        int priority;
    233233
    234         if (the->thread) {
    235                 switch (the->thread->state) {
     234        if (THREAD) {
     235                switch (THREAD->state) {
    236236                    case Running:
    237                             the->thread->state = Ready;
    238                             spinlock_unlock(&the->thread->lock);
    239                             thread_ready(the->thread);
     237                            THREAD->state = Ready;
     238                            spinlock_unlock(&THREAD->lock);
     239                            thread_ready(THREAD);
    240240                            break;
    241241
    242242                    case Exiting:
    243                             frame_free((__address) the->thread->kstack);
    244                             if (the->thread->ustack) {
    245                                     frame_free((__address) the->thread->ustack);
     243                            frame_free((__address) THREAD->kstack);
     244                            if (THREAD->ustack) {
     245                                    frame_free((__address) THREAD->ustack);
    246246                            }
    247247                           
    … …  
    249249                             * Detach from the containing task.
    250250                             */
    251                             spinlock_lock(&the->task->lock);
    252                             list_remove(&the->thread->th_link);
    253                             spinlock_unlock(&the->task->lock);
    254 
    255                             spinlock_unlock(&the->thread->lock);
     251                            spinlock_lock(&TASK->lock);
     252                            list_remove(&THREAD->th_link);
     253                            spinlock_unlock(&TASK->lock);
     254
     255                            spinlock_unlock(&THREAD->lock);
    256256                           
    257257                            spinlock_lock(&threads_lock);
    258                             list_remove(&the->thread->threads_link);
     258                            list_remove(&THREAD->threads_link);
    259259                            spinlock_unlock(&threads_lock);
    260260                           
    261                             free(the->thread);
     261                            free(THREAD);
    262262                           
    263263                            break;
    … …  
    267267                             * Prefer the thread after it's woken up.
    268268                             */
    269                             the->thread->pri = -1;
     269                            THREAD->pri = -1;
    270270
    271271                            /*
    272272                             * We need to release wq->lock which we locked in waitq_sleep().
    273                              * Address of wq->lock is kept in the->thread->sleep_queue.
     273                             * Address of wq->lock is kept in THREAD->sleep_queue.
    274274                             */
    275                             spinlock_unlock(&the->thread->sleep_queue->lock);
     275                            spinlock_unlock(&THREAD->sleep_queue->lock);
    276276
    277277                            /*
    278278                             * Check for possible requests for out-of-context invocation.
    279279                             */
    280                             if (the->thread->call_me) {
    281                                     the->thread->call_me(the->thread->call_me_with);
    282                                     the->thread->call_me = NULL;
    283                                     the->thread->call_me_with = NULL;
     280                            if (THREAD->call_me) {
     281                                    THREAD->call_me(THREAD->call_me_with);
     282                                    THREAD->call_me = NULL;
     283                                    THREAD->call_me_with = NULL;
    284284                            }
    285285
    286                             spinlock_unlock(&the->thread->lock);
     286                            spinlock_unlock(&THREAD->lock);
    287287                           
    288288                            break;
    … …  
    292292                             * Entering state is unexpected.
    293293                             */
    294                             panic("tid%d: unexpected state %s\n", the->thread->tid, thread_states[the->thread->state]);
     294                            panic("tid%d: unexpected state %s\n", THREAD->tid, thread_states[THREAD->state]);
    295295                            break;
    296296                }
    297                 the->thread = NULL;
     297                THREAD = NULL;
    298298        }
    299299   
    300         the->thread = find_best_thread();
     300        THREAD = find_best_thread();
    301301       
    302         spinlock_lock(&the->thread->lock);
    303         priority = the->thread->pri;
    304         spinlock_unlock(&the->thread->lock);   
     302        spinlock_lock(&THREAD->lock);
     303        priority = THREAD->pri;
     304        spinlock_unlock(&THREAD->lock);
    305305       
    306306        relink_rq(priority);           
    307307
    308         spinlock_lock(&the->thread->lock);     
     308        spinlock_lock(&THREAD->lock);   
    309309
    310310        /*
    311311         * If both the old and the new task are the same, lots of work is avoided.
    312312         */
    313         if (the->task != the->thread->task) {
     313        if (TASK != THREAD->task) {
    314314                vm_t *m1 = NULL;
    315315                vm_t *m2;
    316316
    317                 if (the->task) {
    318                         spinlock_lock(&the->task->lock);
    319                         m1 = the->task->vm;
    320                         spinlock_unlock(&the->task->lock);
    321                 }
    322 
    323                 spinlock_lock(&the->thread->task->lock);
    324                 m2 = the->thread->task->vm;
    325                 spinlock_unlock(&the->thread->task->lock);
     317                if (TASK) {
     318                        spinlock_lock(&TASK->lock);
     319                        m1 = TASK->vm;
     320                        spinlock_unlock(&TASK->lock);
     321                }
     322
     323                spinlock_lock(&THREAD->task->lock);
     324                m2 = THREAD->task->vm;
     325                spinlock_unlock(&THREAD->task->lock);
    326326               
    327327                /*
    … …  
    338338                        vm_install(m2);
    339339                }
    340                 the->task = the->thread->task; 
    341         }
    342 
    343         the->thread->state = Running;
     340                TASK = THREAD->task;   
     341        }
     342
     343        THREAD->state = Running;
    344344
    345345        #ifdef SCHEDULER_VERBOSE
    346         printf("cpu%d: tid %d (pri=%d,ticks=%d,nrdy=%d)\n", the->cpu->id, the->thread->tid, the->thread->pri, the->thread->ticks, the->cpu->nrdy);
     346        printf("cpu%d: tid %d (pri=%d,ticks=%d,nrdy=%d)\n", CPU->id, THREAD->tid, THREAD->pri, THREAD->ticks, CPU->nrdy);
    347347        #endif 
    348348
    349         context_restore(&the->thread->saved_context);
     349        context_restore(&THREAD->saved_context);
    350350        /* not reached */
    351351}
    … …  
    366366         * Sleep until there's some work to do.
    367367         */
    368         waitq_sleep(&the->cpu->kcpulb_wq);
     368        waitq_sleep(&CPU->kcpulb_wq);
    369369
    370370not_satisfied:
    … …  
    375375         */
    376376        pri = cpu_priority_high();
    377         spinlock_lock(&the->cpu->lock);
     377        spinlock_lock(&CPU->lock);
    378378        count = nrdy / config.cpu_active;
    379         count -= the->cpu->nrdy;
    380         spinlock_unlock(&the->cpu->lock);
     379        count -= CPU->nrdy;
     380        spinlock_unlock(&CPU->lock);
    381381        cpu_priority_restore(pri);
    382382
    … …  
    400400                         * Doesn't require interrupt disabling for kcpulb is X_WIRED.
    401401                         */
    402                         if (the->cpu == cpu)
     402                        if (CPU == cpu)
    403403                                continue;
    404404
    … …  
    461461                                spinlock_lock(&t->lock);
    462462                                #ifdef KCPULB_VERBOSE
    463                                 printf("kcpulb%d: TID %d -> cpu%d, nrdy=%d, avg=%d\n", the->cpu->id, t->tid, the->cpu->id, the->cpu->nrdy, nrdy / config.cpu_active);
     463                                printf("kcpulb%d: TID %d -> cpu%d, nrdy=%d, avg=%d\n", CPU->id, t->tid, CPU->id, CPU->nrdy, nrdy / config.cpu_active);
    464464                                #endif
    465465                                t->flags |= X_STOLEN;
    … …  
    484484        }
    485485
    486         if (the->cpu->nrdy) {
     486        if (CPU->nrdy) {
    487487                /*
    488488                 * Be a little bit light-weight and let migrated threads run.
    … …  
    504504         * Tell find_best_thread() to wake us up later again.
    505505         */
    506         the->cpu->kcpulbstarted = 0;
     506        CPU->kcpulbstarted = 0;
    507507        goto loop;
    508508}

  • src/proc/task.c

    re6ba9a3f r43114c5  
    4141void task_init(void)
    4242{
    43         the->task = NULL;
     43        TASK = NULL;
    4444        spinlock_initialize(&tasks_lock);
    4545        list_initialize(&tasks_head);

  • src/proc/thread.c

    re6ba9a3f r43114c5  
    6767void cushion(void)
    6868{
    69         void (*f)(void *) = the->thread->thread_code;
    70         void *arg = the->thread->thread_arg;
     69        void (*f)(void *) = THREAD->thread_code;
     70        void *arg = THREAD->thread_arg;
    7171
    7272        /* this is where each thread wakes up after its creation */
    73         spinlock_unlock(&the->thread->lock);
     73        spinlock_unlock(&THREAD->lock);
    7474        cpu_priority_low();
    7575
    … …  
    8181void thread_init(void)
    8282{
    83         the->thread = NULL;
     83        THREAD = NULL;
    8484        nrdy = 0;
    8585        spinlock_initialize(&threads_lock);
    … …  
    215215restart:
    216216        pri = cpu_priority_high();
    217         spinlock_lock(&the->thread->lock);
    218         if (the->thread->timeout_pending) { /* busy waiting for timeouts in progress */
    219                 spinlock_unlock(&the->thread->lock);
     217        spinlock_lock(&THREAD->lock);
     218        if (THREAD->timeout_pending) { /* busy waiting for timeouts in progress */
     219                spinlock_unlock(&THREAD->lock);
    220220                cpu_priority_restore(pri);
    221221                goto restart;
    222222        }
    223         the->thread->state = Exiting;
    224         spinlock_unlock(&the->thread->lock);
     223        THREAD->state = Exiting;
     224        spinlock_unlock(&THREAD->lock);
    225225        scheduler();
    226226}
    … …  
    248248       
    249249        pri = cpu_priority_high();
    250         spinlock_lock(&the->thread->lock);
    251         the->thread->call_me = call_me;
    252         the->thread->call_me_with = call_me_with;
    253         spinlock_unlock(&the->thread->lock);
     250        spinlock_lock(&THREAD->lock);
     251        THREAD->call_me = call_me;
     252        THREAD->call_me_with = call_me_with;
     253        spinlock_unlock(&THREAD->lock);
    254254        cpu_priority_restore(pri);
    255255}

  • src/synch/rwlock.c

    re6ba9a3f r43114c5  
    8181       
    8282        pri = cpu_priority_high();
    83         spinlock_lock(&the->thread->lock);
    84         the->thread->rwlock_holder_type = RWLOCK_WRITER;
    85         spinlock_unlock(&the->thread->lock);   
     83        spinlock_lock(&THREAD->lock);
     84        THREAD->rwlock_holder_type = RWLOCK_WRITER;
     85        spinlock_unlock(&THREAD->lock);
    8686        cpu_priority_restore(pri);
    8787
    … …  
    121121       
    122122        pri = cpu_priority_high();
    123         spinlock_lock(&the->thread->lock);
    124         the->thread->rwlock_holder_type = RWLOCK_READER;
    125         spinlock_unlock(&the->thread->lock);   
     123        spinlock_lock(&THREAD->lock);
     124        THREAD->rwlock_holder_type = RWLOCK_READER;
     125        spinlock_unlock(&THREAD->lock);
    126126
    127127        spinlock_lock(&rwl->lock);

  • src/synch/spinlock.c

    re6ba9a3f r43114c5  
    5050        while (test_and_set(&sl->val)) {
    5151                if (i++ > 300000) {
    52                         printf("cpu%d: looping on spinlock %X, caller=%X\n", the->cpu->id, sl, caller);
     52                        printf("cpu%d: looping on spinlock %X, caller=%X\n", CPU->id, sl, caller);
    5353                        i = 0;
    5454                }

  • src/synch/waitq.c

    re6ba9a3f r43114c5  
    130130         * there are timeouts in progress.
    131131         */
    132         spinlock_lock(&the->thread->lock);
    133         if (the->thread->timeout_pending) {
    134                 spinlock_unlock(&the->thread->lock);
     132        spinlock_lock(&THREAD->lock);
     133        if (THREAD->timeout_pending) {
     134                spinlock_unlock(&THREAD->lock);
    135135                cpu_priority_restore(pri);             
    136136                goto restart;
    137137        }
    138         spinlock_unlock(&the->thread->lock);
     138        spinlock_unlock(&THREAD->lock);
    139139       
    140140        spinlock_lock(&wq->lock);
    … …  
    160160         * Now we are firmly decided to go to sleep.
    161161         */
    162         spinlock_lock(&the->thread->lock);
     162        spinlock_lock(&THREAD->lock);
    163163        if (usec) {
    164164                /* We use the timeout variant. */
    165                 if (!context_save(&the->thread->sleep_timeout_context)) {
     165                if (!context_save(&THREAD->sleep_timeout_context)) {
    166166                        /*
    167167                         * Short emulation of scheduler() return code.
    168168                         */
    169                         spinlock_unlock(&the->thread->lock);
     169                        spinlock_unlock(&THREAD->lock);
    170170                        cpu_priority_restore(pri);
    171171                        return ESYNCH_TIMEOUT;
    172172                }
    173                 the->thread->timeout_pending = 1;
    174                 timeout_register(&the->thread->sleep_timeout, (__u64) usec, waitq_interrupted_sleep, the->thread);
    175         }
    176 
    177         list_append(&the->thread->wq_link, &wq->head);
     173                THREAD->timeout_pending = 1;
     174                timeout_register(&THREAD->sleep_timeout, (__u64) usec, waitq_interrupted_sleep, THREAD);
     175        }
     176
     177        list_append(&THREAD->wq_link, &wq->head);
    178178
    179179        /*
    180180         * Suspend execution.
    181181         */
    182         the->thread->state = Sleeping;
    183         the->thread->sleep_queue = wq;
    184 
    185         spinlock_unlock(&the->thread->lock);
     182        THREAD->state = Sleeping;
     183        THREAD->sleep_queue = wq;
     184
     185        spinlock_unlock(&THREAD->lock);
    186186
    187187        scheduler();    /* wq->lock is released in scheduler_separated_stack() */

  • src/time/clock.c

    re6ba9a3f r43114c5  
    5858         * run all expired timeouts as you visit them.
    5959         */
    60         spinlock_lock(&the->cpu->timeoutlock);
    61         while ((l = the->cpu->timeout_active_head.next) != &the->cpu->timeout_active_head) {
     60        spinlock_lock(&CPU->timeoutlock);
     61        while ((l = CPU->timeout_active_head.next) != &CPU->timeout_active_head) {
    6262                h = list_get_instance(l, timeout_t, link);
    6363                spinlock_lock(&h->lock);
    … …  
    7171                timeout_reinitialize(h);
    7272                spinlock_unlock(&h->lock);     
    73                 spinlock_unlock(&the->cpu->timeoutlock);
     73                spinlock_unlock(&CPU->timeoutlock);
    7474
    7575                f(arg);
    7676
    77                 spinlock_lock(&the->cpu->timeoutlock);
     77                spinlock_lock(&CPU->timeoutlock);
    7878        }
    79         spinlock_unlock(&the->cpu->timeoutlock);
     79        spinlock_unlock(&CPU->timeoutlock);
    8080
    8181        /*
    82          * Do CPU usage accounting and find out whether to preempt the->thread.
     82         * Do CPU usage accounting and find out whether to preempt THREAD.
    8383         */
    8484
    85         if (the->thread) {
    86                 spinlock_lock(&the->cpu->lock);
    87                 the->cpu->needs_relink++;
    88                 spinlock_unlock(&the->cpu->lock);       
     85        if (THREAD) {
     86                spinlock_lock(&CPU->lock);
     87                CPU->needs_relink++;
     88                spinlock_unlock(&CPU->lock);   
    8989       
    90                 spinlock_lock(&the->thread->lock);
    91                 if (!the->thread->ticks--) {
    92                         spinlock_unlock(&the->thread->lock);
     90                spinlock_lock(&THREAD->lock);
     91                if (!THREAD->ticks--) {
     92                        spinlock_unlock(&THREAD->lock);
    9393                        scheduler();
    9494                }
    9595                else {
    96                         spinlock_unlock(&the->thread->lock);
     96                        spinlock_unlock(&THREAD->lock);
    9797                }
    9898        }

  • src/time/delay.c

    re6ba9a3f r43114c5  
    4242
    4343        pri = cpu_priority_high();
    44         asm_delay_loop(microseconds * the->cpu->delay_loop_const);
     44        asm_delay_loop(microseconds * CPU->delay_loop_const);
    4545        cpu_priority_restore(pri);
    4646}

  • src/time/timeout.c

    re6ba9a3f r43114c5  
    4040void timeout_init(void)
    4141{
    42         spinlock_initialize(&the->cpu->timeoutlock);
    43         list_initialize(&the->cpu->timeout_active_head);
     42        spinlock_initialize(&CPU->timeoutlock);
     43        list_initialize(&CPU->timeout_active_head);
    4444}
    4545
    … …  
    7171
    7272        pri = cpu_priority_high();
    73         spinlock_lock(&the->cpu->timeoutlock);
     73        spinlock_lock(&CPU->timeoutlock);
    7474        spinlock_lock(&t->lock);
    7575   
    … …  
    7777                panic("timeout_register: t->cpu != 0");
    7878
    79         t->cpu = the->cpu;
     79        t->cpu = CPU;
    8080        t->ticks = us2ticks(time);
    8181       
    … …  
    8787         */
    8888        sum = 0;
    89         l = the->cpu->timeout_active_head.next;
    90         while (l != &the->cpu->timeout_active_head) {
     89        l = CPU->timeout_active_head.next;
     90        while (l != &CPU->timeout_active_head) {
    9191                hlp = list_get_instance(l, timeout_t, link);
    9292                spinlock_lock(&hlp->lock);
    … …  
    110110         * Decrease ticks of t's immediate succesor by t->ticks.
    111111         */
    112         if (l != &the->cpu->timeout_active_head) {
     112        if (l != &CPU->timeout_active_head) {
    113113                spinlock_lock(&hlp->lock);
    114114                hlp->ticks -= t->ticks;
    … …  
    117117
    118118        spinlock_unlock(&t->lock);
    119         spinlock_unlock(&the->cpu->timeoutlock);
     119        spinlock_unlock(&CPU->timeoutlock);
    120120        cpu_priority_restore(pri);
    121121}

  • test/synch/rwlock2/test.c

    re6ba9a3f r43114c5  
    7575        rwlock_read_lock(&rwlock);     
    7676       
    77         thrd = thread_create(writer, NULL, the->task, 0);
     77        thrd = thread_create(writer, NULL, TASK, 0);
    7878        if (thrd)
    7979                thread_ready(thrd);

  • test/synch/rwlock3/test.c

    re6ba9a3f r43114c5  
    4545void reader(void *arg)
    4646{
    47         printf("cpu%d, tid %d: trying to lock rwlock for reading....\n", the->cpu->id, the->thread->tid);       
     47        printf("cpu%d, tid %d: trying to lock rwlock for reading....\n", CPU->id, THREAD->tid);         
    4848        rwlock_read_lock(&rwlock);
    4949        rwlock_read_unlock(&rwlock);   
    50         printf("cpu%d, tid %d: success\n", the->cpu->id, the->thread->tid);             
     50        printf("cpu%d, tid %d: success\n", CPU->id, THREAD->tid);               
    5151
    52         printf("cpu%d, tid %d: trying to lock rwlock for writing....\n", the->cpu->id, the->thread->tid);       
     52        printf("cpu%d, tid %d: trying to lock rwlock for writing....\n", CPU->id, THREAD->tid);         
    5353
    5454        rwlock_write_lock(&rwlock);
    5555        rwlock_write_unlock(&rwlock);
    56         printf("cpu%d, tid %d: success\n", the->cpu->id, the->thread->tid);                     
     56        printf("cpu%d, tid %d: success\n", CPU->id, THREAD->tid);                       
    5757       
    5858        printf("Test passed.\n");       
    … …  
    7878       
    7979        for (i=0; i<4; i++) {
    80                 thrd = thread_create(reader, NULL, the->task, 0);
     80                thrd = thread_create(reader, NULL, TASK, 0);
    8181                if (thrd)
    8282                        thread_ready(thrd);

  • test/synch/rwlock4/test.c

    re6ba9a3f r43114c5  
    7474
    7575        to = random(40000);
    76         printf("cpu%d, tid %d w+ (%d)\n", the->cpu->id, the->thread->tid, to);
     76        printf("cpu%d, tid %d w+ (%d)\n", CPU->id, THREAD->tid, to);
    7777        rc = rwlock_write_lock_timeout(&rwlock, to);
    7878        if (SYNCH_FAILED(rc)) {
    79                 printf("cpu%d, tid %d w!\n", the->cpu->id, the->thread->tid);
     79                printf("cpu%d, tid %d w!\n", CPU->id, THREAD->tid);
    8080                return;
    8181        };
    82         printf("cpu%d, tid %d w=\n", the->cpu->id, the->thread->tid);
     82        printf("cpu%d, tid %d w=\n", CPU->id, THREAD->tid);
    8383
    8484        if (rwlock.readers_in) panic("Oops.");
    … …  
    8787
    8888        rwlock_write_unlock(&rwlock);
    89         printf("cpu%d, tid %d w-\n", the->cpu->id, the->thread->tid);   
     89        printf("cpu%d, tid %d w-\n", CPU->id, THREAD->tid);     
    9090}
    9191
    … …  
    9696       
    9797        to = random(2000);
    98         printf("cpu%d, tid %d r+ (%d)\n", the->cpu->id, the->thread->tid, to);
     98        printf("cpu%d, tid %d r+ (%d)\n", CPU->id, THREAD->tid, to);
    9999        rc = rwlock_read_lock_timeout(&rwlock, to);
    100100        if (SYNCH_FAILED(rc)) {
    101                 printf("cpu%d, tid %d r!\n", the->cpu->id, the->thread->tid);
     101                printf("cpu%d, tid %d r!\n", CPU->id, THREAD->tid);
    102102                return;
    103103        }
    104         printf("cpu%d, tid %d r=\n", the->cpu->id, the->thread->tid);
     104        printf("cpu%d, tid %d r=\n", CPU->id, THREAD->tid);
    105105        thread_usleep(30000);
    106106        rwlock_read_unlock(&rwlock);
    107         printf("cpu%d, tid %d r-\n", the->cpu->id, the->thread->tid);           
     107        printf("cpu%d, tid %d r-\n", CPU->id, THREAD->tid);             
    108108}
    109109
    … …  
    135135                printf("Creating %d readers\n", k);
    136136                for (i=0; i<k; i++) {
    137                         thrd = thread_create(reader, NULL, the->task, 0);
     137                        thrd = thread_create(reader, NULL, TASK, 0);
    138138                        if (thrd)
    139139                                thread_ready(thrd);
    … …  
    145145                printf("Creating %d writers\n", k);
    146146                for (i=0; i<k; i++) {
    147                         thrd = thread_create(writer, NULL, the->task, 0);
     147                        thrd = thread_create(writer, NULL, TASK, 0);
    148148                        if (thrd)
    149149                                thread_ready(thrd);

  • test/synch/rwlock5/test.c

    re6ba9a3f r43114c5  
    9696                for (j=0; j<(READERS+WRITERS)/2; j++) {
    9797                        for (k=0; k<i; k++) {
    98                                 thrd = thread_create(reader, NULL, the->task, 0);
     98                                thrd = thread_create(reader, NULL, TASK, 0);
    9999                                if (thrd)
    100100                                        thread_ready(thrd);
    … …  
    103103                        }
    104104                        for (k=0; k<(4-i); k++) {
    105                                 thrd = thread_create(writer, NULL, the->task, 0);
     105                                thrd = thread_create(writer, NULL, TASK, 0);
    106106                                if (thrd)
    107107                                        thread_ready(thrd);

  • test/synch/semaphore1/test.c

    re6ba9a3f r43114c5  
    100100                for (j=0; j<(CONSUMERS+PRODUCERS)/2; j++) {
    101101                        for (k=0; k<i; k++) {
    102                                 thrd = thread_create(consumer, NULL, the->task, 0);
     102                                thrd = thread_create(consumer, NULL, TASK, 0);
    103103                                if (thrd)
    104104                                        thread_ready(thrd);
    … …  
    107107                        }
    108108                        for (k=0; k<(4-i); k++) {
    109                                 thrd = thread_create(producer, NULL, the->task, 0);
     109                                thrd = thread_create(producer, NULL, TASK, 0);
    110110                                if (thrd)
    111111                                        thread_ready(thrd);

  • test/synch/semaphore2/test.c

    re6ba9a3f r43114c5  
    7070       
    7171        to = random(20000);
    72         printf("cpu%d, tid %d down+ (%d)\n", the->cpu->id, the->thread->tid, to);
     72        printf("cpu%d, tid %d down+ (%d)\n", CPU->id, THREAD->tid, to);
    7373        rc = semaphore_down_timeout(&sem, to);
    7474        if (SYNCH_FAILED(rc)) {
    75                 printf("cpu%d, tid %d down!\n", the->cpu->id, the->thread->tid);
     75                printf("cpu%d, tid %d down!\n", CPU->id, THREAD->tid);
    7676                return;
    7777        }
    7878       
    79         printf("cpu%d, tid %d down=\n", the->cpu->id, the->thread->tid);       
     79        printf("cpu%d, tid %d down=\n", CPU->id, THREAD->tid); 
    8080        thread_usleep(random(30000));
    8181       
    8282        semaphore_up(&sem);
    83         printf("cpu%d, tid %d up\n", the->cpu->id, the->thread->tid);
     83        printf("cpu%d, tid %d up\n", CPU->id, THREAD->tid);
    8484}
    8585
    … …  
    108108                printf("Creating %d consumers\n", k);
    109109                for (i=0; i<k; i++) {
    110                         thrd = thread_create(consumer, NULL, the->task, 0);
     110                        thrd = thread_create(consumer, NULL, TASK, 0);
    111111                        if (thrd)
    112112                                thread_ready(thrd);
Note: See TracChangeset for help on using the changeset viewer.