Changeset 76cec1e in mainline for src


Ignore:
Timestamp:
2005-07-15T21:57:30Z (20 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
b4a4c5e3
Parents:
e41c47e
Message:

Huge indentation fix.

Location:
src
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • src/cpu/cpu.c

    re41c47e r76cec1e  
    6767                memsetb((__address) cpu_private_data, sizeof(cpu_private_data_t) * config.cpu_count, 0);
    6868                memsetb((__address) cpus, sizeof(cpu_t) * config.cpu_count, 0);
    69    
     69
    7070                for (i=0; i < config.cpu_count; i++) {
    7171                        cpus[i].stack = (__u8 *) malloc(CPU_STACK_SIZE);

  • src/main/kinit.c

    re41c47e r76cec1e  
    9595#ifdef __SMP__
    9696        if (config.cpu_count > 1) {
    97                 /*
     97                /*
    9898                 * For each CPU, create its load balancing thread.
    9999                 */

  • src/mm/frame.c

    re41c47e r76cec1e  
    5555void frame_init(void)
    5656{
    57         if (config.cpu_active == 1) {
     57        if (config.cpu_active == 1) {
    5858
    59                 /*
    60                 * The bootstrap processor will allocate all necessary memory for frame allocation.
    61                 */
     59                /*
     60                * The bootstrap processor will allocate all necessary memory for frame allocation.
     61                */
    6262
    63                 frames = config.memory_size / FRAME_SIZE;
    64                 frame_bitmap_octets = frames / 8 + (frames % 8 > 0);
    65                 frame_bitmap = (__u8 *) malloc(frame_bitmap_octets);
    66                 if (!frame_bitmap)
    67                         panic("malloc/frame_bitmap\n");
     63                frames = config.memory_size / FRAME_SIZE;
     64                frame_bitmap_octets = frames / 8 + (frames % 8 > 0);
     65                frame_bitmap = (__u8 *) malloc(frame_bitmap_octets);
     66                if (!frame_bitmap)
     67                        panic("malloc/frame_bitmap\n");
    6868
    69                 /*
    70                 * Mark all frames free.
    71                 */
    72                 memsetb((__address) frame_bitmap, frame_bitmap_octets, 0);
    73                 frames_free = frames;
     69                /*
     70                * Mark all frames free.
     71                */
     72                memsetb((__address) frame_bitmap, frame_bitmap_octets, 0);
     73                frames_free = frames;
    7474        }
    7575
    … …  
    8181
    8282        if (config.cpu_active == 1) {
    83                 /*
    84                 * Create the memory address space map. Marked frames and frame
    85                 * regions cannot be used for allocation.
    86                 */
     83                /*
     84                * Create the memory address space map. Marked frames and frame
     85                * regions cannot be used for allocation.
     86                */
    8787                frame_region_not_free(config.base, config.base + config.kernel_size);
    8888        }

  • src/mm/page.c

    re41c47e r76cec1e  
    5454
    5555        /* TODO: implement portable way of computing page address from address */
    56         length = size + (s - (s & 0xfffff000));
    57         cnt = length/PAGE_SIZE + (length%PAGE_SIZE>0);
     56        length = size + (s - (s & 0xfffff000));
     57        cnt = length/PAGE_SIZE + (length%PAGE_SIZE>0);
    5858
    59         for (i = 0; i < cnt; i++)
    60                 map_page_to_frame(s + i*PAGE_SIZE, s + i*PAGE_SIZE, PAGE_NOT_CACHEABLE, 0);
     59        for (i = 0; i < cnt; i++)
     60                map_page_to_frame(s + i*PAGE_SIZE, s + i*PAGE_SIZE, PAGE_NOT_CACHEABLE, 0);
    6161
    6262}
    … …  
    7474void map_page_to_frame(__address page, __address frame, int flags, __address root)
    7575{
    76         pte_t *ptl0, *ptl1, *ptl2, *ptl3;
    77         __address newpt;
     76        pte_t *ptl0, *ptl1, *ptl2, *ptl3;
     77        __address newpt;
    7878
    79         ptl0 = (pte_t *) PA2KA(root ? root : (__address) GET_PTL0_ADDRESS());
     79        ptl0 = (pte_t *) PA2KA(root ? root : (__address) GET_PTL0_ADDRESS());
    8080
    81         if (GET_PTL1_FLAGS(ptl0, PTL0_INDEX(page)) & PAGE_NOT_PRESENT) {
    82                 newpt = frame_alloc(FRAME_KA);
    83                 memsetb(newpt, PAGE_SIZE, 0);
    84                 SET_PTL1_ADDRESS(ptl0, PTL0_INDEX(page), KA2PA(newpt));
    85                 SET_PTL1_FLAGS(ptl0, PTL0_INDEX(page), PAGE_PRESENT | PAGE_USER);
    86         }
     81        if (GET_PTL1_FLAGS(ptl0, PTL0_INDEX(page)) & PAGE_NOT_PRESENT) {
     82                newpt = frame_alloc(FRAME_KA);
     83                memsetb(newpt, PAGE_SIZE, 0);
     84                SET_PTL1_ADDRESS(ptl0, PTL0_INDEX(page), KA2PA(newpt));
     85                SET_PTL1_FLAGS(ptl0, PTL0_INDEX(page), PAGE_PRESENT | PAGE_USER);
     86        }
    8787
    88         ptl1 = (pte_t *) PA2KA(GET_PTL1_ADDRESS(ptl0, PTL0_INDEX(page)));
     88        ptl1 = (pte_t *) PA2KA(GET_PTL1_ADDRESS(ptl0, PTL0_INDEX(page)));
    8989
    90         if (GET_PTL2_FLAGS(ptl1, PTL1_INDEX(page)) & PAGE_NOT_PRESENT) {
    91                 newpt = frame_alloc(FRAME_KA);
    92                 memsetb(newpt, PAGE_SIZE, 0);
    93                 SET_PTL2_ADDRESS(ptl1, PTL1_INDEX(page), KA2PA(newpt));
    94                 SET_PTL2_FLAGS(ptl1, PTL1_INDEX(page), PAGE_PRESENT | PAGE_USER);
    95         }
     90        if (GET_PTL2_FLAGS(ptl1, PTL1_INDEX(page)) & PAGE_NOT_PRESENT) {
     91                newpt = frame_alloc(FRAME_KA);
     92                memsetb(newpt, PAGE_SIZE, 0);
     93                SET_PTL2_ADDRESS(ptl1, PTL1_INDEX(page), KA2PA(newpt));
     94                SET_PTL2_FLAGS(ptl1, PTL1_INDEX(page), PAGE_PRESENT | PAGE_USER);
     95        }
    9696
    97         ptl2 = (pte_t *) PA2KA(GET_PTL2_ADDRESS(ptl1, PTL1_INDEX(page)));
     97        ptl2 = (pte_t *) PA2KA(GET_PTL2_ADDRESS(ptl1, PTL1_INDEX(page)));
    9898
    99         if (GET_PTL3_FLAGS(ptl2, PTL2_INDEX(page)) & PAGE_NOT_PRESENT) {
    100                 newpt = frame_alloc(FRAME_KA);
    101                 memsetb(newpt, PAGE_SIZE, 0);
    102                 SET_PTL3_ADDRESS(ptl2, PTL2_INDEX(page), KA2PA(newpt));
    103                 SET_PTL3_FLAGS(ptl2, PTL2_INDEX(page), PAGE_PRESENT | PAGE_USER);
    104         }
     99        if (GET_PTL3_FLAGS(ptl2, PTL2_INDEX(page)) & PAGE_NOT_PRESENT) {
     100                newpt = frame_alloc(FRAME_KA);
     101                memsetb(newpt, PAGE_SIZE, 0);
     102                SET_PTL3_ADDRESS(ptl2, PTL2_INDEX(page), KA2PA(newpt));
     103                SET_PTL3_FLAGS(ptl2, PTL2_INDEX(page), PAGE_PRESENT | PAGE_USER);
     104        }
    105105
    106         ptl3 = (pte_t *) PA2KA(GET_PTL3_ADDRESS(ptl2, PTL2_INDEX(page)));
     106        ptl3 = (pte_t *) PA2KA(GET_PTL3_ADDRESS(ptl2, PTL2_INDEX(page)));
    107107
    108         SET_FRAME_ADDRESS(ptl3, PTL3_INDEX(page), frame);
    109         SET_FRAME_FLAGS(ptl3, PTL3_INDEX(page), flags);
     108        SET_FRAME_ADDRESS(ptl3, PTL3_INDEX(page), frame);
     109        SET_FRAME_FLAGS(ptl3, PTL3_INDEX(page), flags);
    110110}

  • src/proc/scheduler.c

    re41c47e r76cec1e  
    103103                 */
    104104                if (test_and_set(&CPU->kcpulbstarted) == 0) {
    105                         waitq_wakeup(&CPU->kcpulb_wq, 0);
     105                        waitq_wakeup(&CPU->kcpulb_wq, 0);
    106106                        goto loop;
    107107                }
    … …  
    239239                         */
    240240                        before_thread_runs();
    241                         spinlock_unlock(&THREAD->lock);
     241                        spinlock_unlock(&THREAD->lock);
    242242                        cpu_priority_restore(THREAD->saved_context.pri);
    243243                        return;
    … …  
    279279                switch (THREAD->state) {
    280280                    case Running:
    281                             THREAD->state = Ready;
    282                             spinlock_unlock(&THREAD->lock);
    283                             thread_ready(THREAD);
    284                             break;
     281                        THREAD->state = Ready;
     282                        spinlock_unlock(&THREAD->lock);
     283                        thread_ready(THREAD);
     284                        break;
    285285
    286286                    case Exiting:
    287                             frame_free((__address) THREAD->kstack);
    288                             if (THREAD->ustack) {
    289                                     frame_free((__address) THREAD->ustack);
    290                             }
    291                            
    292                             /*
    293                              * Detach from the containing task.
    294                              */
    295                             spinlock_lock(&TASK->lock);
    296                             list_remove(&THREAD->th_link);
    297                             spinlock_unlock(&TASK->lock);
    298 
    299                             spinlock_unlock(&THREAD->lock);
    300                            
    301                             spinlock_lock(&threads_lock);
    302                             list_remove(&THREAD->threads_link);
    303                             spinlock_unlock(&threads_lock);
    304 
    305                             spinlock_lock(&CPU->lock);
    306                             if(CPU->fpu_owner==THREAD) CPU->fpu_owner=NULL;
    307                             spinlock_unlock(&CPU->lock);
    308 
    309                            
    310                             free(THREAD);
    311                            
    312                             break;
    313                            
     287                        frame_free((__address) THREAD->kstack);
     288                        if (THREAD->ustack) {
     289                                frame_free((__address) THREAD->ustack);
     290                        }
     291
     292                        /*
     293                         * Detach from the containing task.
     294                         */
     295                        spinlock_lock(&TASK->lock);
     296                        list_remove(&THREAD->th_link);
     297                        spinlock_unlock(&TASK->lock);
     298
     299                        spinlock_unlock(&THREAD->lock);
     300   
     301                        spinlock_lock(&threads_lock);
     302                        list_remove(&THREAD->threads_link);
     303                        spinlock_unlock(&threads_lock);
     304
     305                        spinlock_lock(&CPU->lock);
     306                        if(CPU->fpu_owner==THREAD) CPU->fpu_owner=NULL;
     307                        spinlock_unlock(&CPU->lock);
     308
     309                        free(THREAD);
     310
     311                        break;
     312   
    314313                    case Sleeping:
    315                             /*
    316                              * Prefer the thread after it's woken up.
    317                              */
    318                             THREAD->pri = -1;
    319 
    320                             /*
    321                              * We need to release wq->lock which we locked in waitq_sleep().
    322                              * Address of wq->lock is kept in THREAD->sleep_queue.
    323                              */
    324                             spinlock_unlock(&THREAD->sleep_queue->lock);
    325 
    326                             /*
    327                              * Check for possible requests for out-of-context invocation.
    328                              */
    329                             if (THREAD->call_me) {
    330                                     THREAD->call_me(THREAD->call_me_with);
    331                                     THREAD->call_me = NULL;
    332                                     THREAD->call_me_with = NULL;
    333                             }
    334 
    335                             spinlock_unlock(&THREAD->lock);
    336                            
    337                             break;
     314                        /*
     315                         * Prefer the thread after it's woken up.
     316                         */
     317                        THREAD->pri = -1;
     318
     319                        /*
     320                         * We need to release wq->lock which we locked in waitq_sleep().
     321                         * Address of wq->lock is kept in THREAD->sleep_queue.
     322                         */
     323                        spinlock_unlock(&THREAD->sleep_queue->lock);
     324
     325                        /*
     326                         * Check for possible requests for out-of-context invocation.
     327                         */
     328                        if (THREAD->call_me) {
     329                                THREAD->call_me(THREAD->call_me_with);
     330                                THREAD->call_me = NULL;
     331                                THREAD->call_me_with = NULL;
     332                        }
     333
     334                        spinlock_unlock(&THREAD->lock);
     335
     336                        break;
    338337
    339338                    default:
    340                             /*
    341                              * Entering state is unexpected.
    342                              */
    343                             panic("tid%d: unexpected state %s\n", THREAD->tid, thread_states[THREAD->state]);
    344                             break;
     339                        /*
     340                         * Entering state is unexpected.
     341                         */
     342                        panic("tid%d: unexpected state %s\n", THREAD->tid, thread_states[THREAD->state]);
     343                        break;
    345344                }
    346345                THREAD = NULL;
    347346        }
    348    
     347
    349348        THREAD = find_best_thread();
    350349       
    … …  
    470469                                t = list_get_instance(l, thread_t, rq_link);
    471470                                /*
    472                                  * We don't want to steal CPU-wired threads neither threads already stolen.
     471                                 * We don't want to steal CPU-wired threads neither threads already stolen.
    473472                                 * The latter prevents threads from migrating between CPU's without ever being run.
    474                                  * We don't want to steal threads whose FPU context is still in CPU.
     473                                 * We don't want to steal threads whose FPU context is still in CPU.
    475474                                 */
    476475                                spinlock_lock(&t->lock);
    … …  
    498497                                        atomic_dec(&nrdy);
    499498
    500                                         r->n--;
     499                                        r->n--;
    501500                                        list_remove(&t->rq_link);
    502501
    … …  
    528527                                       
    529528                                /*
    530                                  * We are not satisfied yet, focus on another CPU next time.
     529                                 * We are not satisfied yet, focus on another CPU next time.
    531530                                 */
    532531                                k++;
    … …  
    553552               
    554553        goto not_satisfied;
    555    
     554
    556555satisfied:
    557556        /*

  • src/proc/thread.c

    re41c47e r76cec1e  
    147147        }       
    148148        spinlock_unlock(&cpu->lock);
    149    
     149
    150150        cpu_priority_restore(pri);
    151151}
    … …  
    278278void thread_sleep(__u32 sec)
    279279{
    280         thread_usleep(sec*1000000);
     280        thread_usleep(sec*1000000);
    281281}
    282282

  • src/time/clock.c

    re41c47e r76cec1e  
    9090       
    9191                spinlock_lock(&THREAD->lock);
    92                 if (!THREAD->ticks--) {
     92                if (!THREAD->ticks--) {
    9393                        spinlock_unlock(&THREAD->lock);
    9494                        scheduler();

  • src/time/timeout.c

    re41c47e r76cec1e  
    106106        spinlock_lock(&CPU->timeoutlock);
    107107        spinlock_lock(&t->lock);
    108    
     108
    109109        if (t->cpu)
    110110                panic("t->cpu != 0");
    … …  
    115115        t->handler = f;
    116116        t->arg = arg;
    117    
     117
    118118        /*
    119119         * Insert t into the active timeouts list according to t->ticks.
Note: See TracChangeset for help on using the changeset viewer.