Changes in / [380553c:2616a75b] in mainline


Ignore:
Files:
33 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/ia64/src/drivers/ski.c

    r380553c r2616a75b  
    150150       
    151151        if (instance) {
    152                 instance->thread = thread_create(kskipoll, instance, TASK,
    153                     THREAD_FLAG_UNCOUNTED, "kskipoll");
     152                instance->thread = thread_create(kskipoll, instance, TASK, 0,
     153                    "kskipoll", true);
    154154               
    155155                if (!instance->thread) {

  • kernel/arch/sparc64/src/drivers/niagara.c

    r380553c r2616a75b  
    184184       
    185185        instance = malloc(sizeof(niagara_instance_t), FRAME_ATOMIC);
    186         instance->thread = thread_create(kniagarapoll, NULL, TASK,
    187             THREAD_FLAG_UNCOUNTED, "kniagarapoll");
     186        instance->thread = thread_create(kniagarapoll, NULL, TASK, 0,
     187            "kniagarapoll", true);
    188188       
    189189        if (!instance->thread) {

  • kernel/arch/sparc64/src/proc/sun4u/scheduler.c

    r380553c r2616a75b  
    5151void before_thread_runs_arch(void)
    5252{
    53         if (THREAD->uspace) {
     53        if ((THREAD->flags & THREAD_FLAG_USPACE)) {
    5454                /*
    5555                 * Write kernel stack address to %g6 of the alternate and
    … …  
    7474void after_thread_ran_arch(void)
    7575{
    76         if (THREAD->uspace) {
    77                 /* sample the state of the userspace window buffer */
     76        if ((THREAD->flags & THREAD_FLAG_USPACE)) {
     77                /* sample the state of the userspace window buffer */   
    7878                THREAD->arch.uspace_window_buffer = (uint8_t *) read_from_ag_g7();
    7979        }

  • kernel/arch/sparc64/src/proc/sun4v/scheduler.c

    r380553c r2616a75b  
    5454void before_thread_runs_arch(void)
    5555{
    56         if (THREAD->uspace) {
     56        if ((THREAD->flags & THREAD_FLAG_USPACE)) {
    5757                uint64_t sp = (uintptr_t) THREAD->kstack + STACK_SIZE -
    5858                    (STACK_BIAS + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT));
    … …  
    6666void after_thread_ran_arch(void)
    6767{
    68         if (THREAD->uspace) {
    69                 /* sample the state of the userspace window buffer */
     68        if ((THREAD->flags & THREAD_FLAG_USPACE)) {
     69                /* sample the state of the userspace window buffer */   
    7070                THREAD->arch.uspace_window_buffer =
    7171                    (uint8_t *) asi_u64_read(ASI_SCRATCHPAD, SCRATCHPAD_WBUF);

  • kernel/arch/sparc64/src/proc/thread.c

    r380553c r2616a75b  
    6161void thread_create_arch(thread_t *t)
    6262{
    63         if ((t->uspace) && (!t->arch.uspace_window_buffer))
     63        if ((t->flags & THREAD_FLAG_USPACE) && (!t->arch.uspace_window_buffer))
    6464                {
    6565                /*

  • kernel/genarch/src/kbrd/kbrd.c

    r380553c r2616a75b  
    158158            = malloc(sizeof(kbrd_instance_t), FRAME_ATOMIC);
    159159        if (instance) {
    160                 instance->thread = thread_create(kkbrd, (void *) instance,
    161                     TASK, THREAD_FLAG_NONE, "kkbrd");
     160                instance->thread
     161                        = thread_create(kkbrd, (void *) instance, TASK, 0, "kkbrd", false);
    162162               
    163163                if (!instance->thread) {

  • kernel/genarch/src/mm/as_ht.c

    r380553c r2616a75b  
    7878                hash_table_create(&page_ht, PAGE_HT_ENTRIES, 2, &ht_operations);
    7979                mutex_initialize(&page_ht_lock, MUTEX_PASSIVE);
    80                 pte_cache = slab_cache_create("pte_t", sizeof(pte_t), 0,
    81                     NULL, NULL, SLAB_CACHE_MAGDEFERRED);
     80                pte_cache = slab_cache_create("pte_cache", sizeof(pte_t), 0, NULL, NULL,
     81                    SLAB_CACHE_MAGDEFERRED);
    8282        }
    8383       

  • kernel/genarch/src/srln/srln.c

    r380553c r2616a75b  
    130130            = malloc(sizeof(srln_instance_t), FRAME_ATOMIC);
    131131        if (instance) {
    132                 instance->thread = thread_create(ksrln, (void *) instance,
    133                     TASK, THREAD_FLAG_NONE, "ksrln");
     132                instance->thread
     133                        = thread_create(ksrln, (void *) instance, TASK, 0, "ksrln", false);
    134134               
    135135                if (!instance->thread) {

  • kernel/generic/include/proc/thread.h

    r380553c r2616a75b  
    5454
    5555/* Thread flags */
    56 typedef enum {
    57         THREAD_FLAG_NONE = 0,
    58         /** Thread executes in user space. */
    59         THREAD_FLAG_USPACE = (1 << 0),
    60         /** Thread will be attached by the caller. */
    61         THREAD_FLAG_NOATTACH = (1 << 1),
    62         /** Thread accounting doesn't affect accumulated task accounting. */
    63         THREAD_FLAG_UNCOUNTED = (1 << 2)
    64 } thread_flags_t;
     56
     57/** Thread cannot be migrated to another CPU.
     58 *
     59 * When using this flag, the caller must set cpu in the thread_t
     60 * structure manually before calling thread_ready (even on uniprocessor).
     61 *
     62 */
     63#define THREAD_FLAG_WIRED  (1 << 0)
     64
     65/** Thread was migrated to another CPU and has not run yet. */
     66#define THREAD_FLAG_STOLEN  (1 << 1)
     67
     68/** Thread executes in userspace. */
     69#define THREAD_FLAG_USPACE  (1 << 2)
     70
     71/** Thread will be attached by the caller. */
     72#define THREAD_FLAG_NOATTACH  (1 << 3)
    6573
    6674/** Thread structure. There is one per thread. */
    … …  
    139147       
    140148        fpu_context_t *saved_fpu_context;
    141         bool fpu_context_exists;
     149        int fpu_context_exists;
    142150       
    143151        /*
    … …  
    146154         * thread. This disables migration.
    147155         */
    148         bool fpu_context_engaged;
     156        int fpu_context_engaged;
    149157       
    150158        /* The thread will not be migrated if nomigrate is non-zero. */
    151         unsigned int nomigrate;
    152        
    153         /** Thread state. */
     159        int nomigrate;
     160       
     161        /** Thread's state. */
    154162        state_t state;
    155        
    156         /** Thread CPU. */
     163        /** Thread's flags. */
     164        unsigned int flags;
     165       
     166        /** Thread's CPU. */
    157167        cpu_t *cpu;
    158168        /** Containing task. */
    159169        task_t *task;
    160         /** Thread is wired to CPU. */
    161         bool wired;
    162         /** Thread was migrated to another CPU and has not run yet. */
    163         bool stolen;
    164         /** Thread is executed in user space. */
    165         bool uspace;
    166170       
    167171        /** Ticks before preemption. */
    … …  
    212216extern void thread_init(void);
    213217extern thread_t *thread_create(void (*)(void *), void *, task_t *,
    214     thread_flags_t, const char *);
    215 extern void thread_wire(thread_t *, cpu_t *);
     218    unsigned int, const char *, bool);
    216219extern void thread_attach(thread_t *, task_t *);
    217220extern void thread_ready(thread_t *);

  • kernel/generic/src/adt/btree.c

    r380553c r2616a75b  
    7171void btree_init(void)
    7272{
    73         btree_node_slab = slab_cache_create("btree_node_t",
     73        btree_node_slab = slab_cache_create("btree_node_slab",
    7474            sizeof(btree_node_t), 0, NULL, NULL, SLAB_CACHE_MAGDEFERRED);
    7575}

  • kernel/generic/src/console/cmd.c

    r380553c r2616a75b  
    724724                thread_t *thread;
    725725                if ((thread = thread_create((void (*)(void *)) cmd_call0,
    726                     (void *) argv, TASK, THREAD_FLAG_NONE, "call0"))) {
     726                    (void *) argv, TASK, THREAD_FLAG_WIRED, "call0", false))) {
     727                        irq_spinlock_lock(&thread->lock, true);
     728                        thread->cpu = &cpus[i];
     729                        irq_spinlock_unlock(&thread->lock, true);
     730                       
    727731                        printf("cpu%u: ", i);
    728                         thread_wire(thread, &cpus[i]);
     732                       
    729733                        thread_ready(thread);
    730734                        thread_join(thread);

  • kernel/generic/src/ipc/ipc.c

    r380553c r2616a75b  
    670670void ipc_init(void)
    671671{
    672         ipc_call_slab = slab_cache_create("call_t", sizeof(call_t), 0, NULL,
     672        ipc_call_slab = slab_cache_create("ipc_call", sizeof(call_t), 0, NULL,
    673673            NULL, 0);
    674         ipc_answerbox_slab = slab_cache_create("answerbox_t",
     674        ipc_answerbox_slab = slab_cache_create("ipc_answerbox",
    675675            sizeof(answerbox_t), 0, NULL, NULL, 0);
    676676}

  • kernel/generic/src/ipc/kbox.c

    r380553c r2616a75b  
    244244       
    245245        /* Create a kbox thread */
    246         thread_t *kb_thread = thread_create(kbox_thread_proc, NULL, task,
    247             THREAD_FLAG_NONE, "kbox");
     246        thread_t *kb_thread = thread_create(kbox_thread_proc, NULL, task, 0,
     247            "kbox", false);
    248248        if (!kb_thread) {
    249249                mutex_unlock(&task->kb.cleanup_lock);

  • kernel/generic/src/lib/ra.c

    r380553c r2616a75b  
    424424void ra_init(void)
    425425{
    426         ra_segment_cache = slab_cache_create("ra_segment_t",
     426        ra_segment_cache = slab_cache_create("segment_cache",
    427427            sizeof(ra_segment_t), 0, NULL, NULL, SLAB_CACHE_MAGDEFERRED);
    428428}

  • kernel/generic/src/main/kinit.c

    r380553c r2616a75b  
    116116                 * Just a beautification.
    117117                 */
    118                 thread = thread_create(kmp, NULL, TASK,
    119                     THREAD_FLAG_UNCOUNTED, "kmp");
     118                thread = thread_create(kmp, NULL, TASK, THREAD_FLAG_WIRED, "kmp", true);
    120119                if (thread != NULL) {
    121                         thread_wire(thread, &cpus[0]);
     120                        irq_spinlock_lock(&thread->lock, false);
     121                        thread->cpu = &cpus[0];
     122                        irq_spinlock_unlock(&thread->lock, false);
    122123                        thread_ready(thread);
    123124                } else
    … …  
    133134               
    134135                for (i = 0; i < config.cpu_count; i++) {
    135                         thread = thread_create(kcpulb, NULL, TASK,
    136                             THREAD_FLAG_UNCOUNTED, "kcpulb");
     136                        thread = thread_create(kcpulb, NULL, TASK, THREAD_FLAG_WIRED, "kcpulb", true);
    137137                        if (thread != NULL) {
    138                                 thread_wire(thread, &cpus[i]);
     138                                irq_spinlock_lock(&thread->lock, false);
     139                                thread->cpu = &cpus[i];
     140                                irq_spinlock_unlock(&thread->lock, false);
    139141                                thread_ready(thread);
    140142                        } else
    … …  
    150152       
    151153        /* Start thread computing system load */
    152         thread = thread_create(kload, NULL, TASK, THREAD_FLAG_NONE,
    153             "kload");
     154        thread = thread_create(kload, NULL, TASK, 0, "kload", false);
    154155        if (thread != NULL)
    155156                thread_ready(thread);
    … …  
    162163                 * Create kernel console.
    163164                 */
    164                 thread = thread_create(kconsole_thread, NULL, TASK,
    165                     THREAD_FLAG_NONE, "kconsole");
     165                thread = thread_create(kconsole_thread, NULL, TASK, 0, "kconsole", false);
    166166                if (thread != NULL)
    167167                        thread_ready(thread);

  • kernel/generic/src/main/main.c

    r380553c r2616a75b  
    276276         * Create the first thread.
    277277         */
    278         thread_t *kinit_thread = thread_create(kinit, NULL, kernel,
    279             THREAD_FLAG_UNCOUNTED, "kinit");
     278        thread_t *kinit_thread =
     279            thread_create(kinit, NULL, kernel, 0, "kinit", true);
    280280        if (!kinit_thread)
    281281                panic("Cannot create kinit thread.");

  • kernel/generic/src/mm/as.c

    r380553c r2616a75b  
    130130        as_arch_init();
    131131       
    132         as_slab = slab_cache_create("as_t", sizeof(as_t), 0,
     132        as_slab = slab_cache_create("as_slab", sizeof(as_t), 0,
    133133            as_constructor, as_destructor, SLAB_CACHE_MAGDEFERRED);
    134134       

  • kernel/generic/src/mm/slab.c

    r380553c r2616a75b  
    891891{
    892892        /* Initialize magazine cache */
    893         _slab_cache_create(&mag_cache, "slab_magazine_t",
     893        _slab_cache_create(&mag_cache, "slab_magazine",
    894894            sizeof(slab_magazine_t) + SLAB_MAG_SIZE * sizeof(void*),
    895895            sizeof(uintptr_t), NULL, NULL, SLAB_CACHE_NOMAGAZINE |
    … …  
    897897       
    898898        /* Initialize slab_cache cache */
    899         _slab_cache_create(&slab_cache_cache, "slab_cache_cache",
     899        _slab_cache_create(&slab_cache_cache, "slab_cache",
    900900            sizeof(slab_cache_cache), sizeof(uintptr_t), NULL, NULL,
    901901            SLAB_CACHE_NOMAGAZINE | SLAB_CACHE_SLINSIDE);
    902902       
    903903        /* Initialize external slab cache */
    904         slab_extern_cache = slab_cache_create("slab_t", sizeof(slab_t), 0,
     904        slab_extern_cache = slab_cache_create("slab_extern", sizeof(slab_t), 0,
    905905            NULL, NULL, SLAB_CACHE_SLINSIDE | SLAB_CACHE_MAGDEFERRED);
    906906       

  • kernel/generic/src/proc/program.c

    r380553c r2616a75b  
    102102         */
    103103        prg->main_thread = thread_create(uinit, kernel_uarg, prg->task,
    104             THREAD_FLAG_USPACE, "uinit");
     104            THREAD_FLAG_USPACE, "uinit", false);
    105105        if (!prg->main_thread) {
    106106                free(kernel_uarg);

  • kernel/generic/src/proc/scheduler.c

    r380553c r2616a75b  
    9898        else {
    9999                fpu_init();
    100                 THREAD->fpu_context_exists = true;
     100                THREAD->fpu_context_exists = 1;
    101101        }
    102102#endif
    … …  
    142142               
    143143                /* Don't prevent migration */
    144                 CPU->fpu_owner->fpu_context_engaged = false;
     144                CPU->fpu_owner->fpu_context_engaged = 0;
    145145                irq_spinlock_unlock(&CPU->fpu_owner->lock, false);
    146146                CPU->fpu_owner = NULL;
    … …  
    163163                }
    164164                fpu_init();
    165                 THREAD->fpu_context_exists = true;
     165                THREAD->fpu_context_exists = 1;
    166166        }
    167167       
    168168        CPU->fpu_owner = THREAD;
    169         THREAD->fpu_context_engaged = true;
     169        THREAD->fpu_context_engaged = 1;
    170170        irq_spinlock_unlock(&THREAD->lock, false);
    171171       
    … …  
    248248               
    249249                /*
    250                  * Clear the stolen flag so that it can be migrated
     250                 * Clear the THREAD_FLAG_STOLEN flag so that t can be migrated
    251251                 * when load balancing needs emerge.
    252252                 */
    253                 thread->stolen = false;
     253                thread->flags &= ~THREAD_FLAG_STOLEN;
    254254                irq_spinlock_unlock(&thread->lock, false);
    255255               
    … …  
    630630                                irq_spinlock_lock(&thread->lock, false);
    631631                               
    632                                 if ((!thread->wired) && (!thread->stolen) &&
    633                                     (!thread->nomigrate) &&
    634                                     (!thread->fpu_context_engaged)) {
     632                                if (!(thread->flags & THREAD_FLAG_WIRED) &&
     633                                    !(thread->flags & THREAD_FLAG_STOLEN) &&
     634                                    !thread->nomigrate &&
     635                                    !thread->fpu_context_engaged) {
    635636                                        /*
    636637                                         * Remove thread from ready queue.
    … …  
    669670#endif
    670671                               
    671                                 thread->stolen = true;
     672                                thread->flags |= THREAD_FLAG_STOLEN;
    672673                                thread->state = Entering;
    673674                               

  • kernel/generic/src/proc/task.c

    r380553c r2616a75b  
    9090        TASK = NULL;
    9191        avltree_create(&tasks_tree);
    92         task_slab = slab_cache_create("task_t", sizeof(task_t), 0,
     92        task_slab = slab_cache_create("task_slab", sizeof(task_t), 0,
    9393            tsk_constructor, NULL, 0);
    9494}

  • kernel/generic/src/proc/thread.c

    r380553c r2616a75b  
    191191        kmflags |= FRAME_LOWMEM;
    192192        kmflags &= ~FRAME_HIGHMEM;
    193        
     193
    194194        thread->kstack = (uint8_t *) frame_alloc(STACK_FRAMES, FRAME_KA | kmflags);
    195195        if (!thread->kstack) {
    … …  
    236236       
    237237        atomic_set(&nrdy, 0);
    238         thread_slab = slab_cache_create("thread_t", sizeof(thread_t), 0,
     238        thread_slab = slab_cache_create("thread_slab", sizeof(thread_t), 0,
    239239            thr_constructor, thr_destructor, 0);
    240240       
    241241#ifdef CONFIG_FPU
    242         fpu_context_slab = slab_cache_create("fpu_context_t",
    243             sizeof(fpu_context_t), FPU_CONTEXT_ALIGN, NULL, NULL, 0);
     242        fpu_context_slab = slab_cache_create("fpu_slab", sizeof(fpu_context_t),
     243            FPU_CONTEXT_ALIGN, NULL, NULL, 0);
    244244#endif
    245245       
    … …  
    247247}
    248248
    249 /** Wire thread to the given CPU
    250  *
    251  * @param cpu CPU to wire the thread to.
    252  *
    253  */
    254 void thread_wire(thread_t *thread, cpu_t *cpu)
     249/** Make thread ready
     250 *
     251 * Switch thread to the ready state.
     252 *
     253 * @param thread Thread to make ready.
     254 *
     255 */
     256void thread_ready(thread_t *thread)
    255257{
    256258        irq_spinlock_lock(&thread->lock, true);
    257         thread->cpu = cpu;
    258         thread->wired = true;
    259         irq_spinlock_unlock(&thread->lock, true);
    260 }
    261 
    262 /** Make thread ready
    263  *
    264  * Switch thread to the ready state.
    265  *
    266  * @param thread Thread to make ready.
    267  *
    268  */
    269 void thread_ready(thread_t *thread)
    270 {
    271         irq_spinlock_lock(&thread->lock, true);
    272259       
    273260        ASSERT(thread->state != Ready);
    274261       
    275         int i = (thread->priority < RQ_COUNT - 1) ?
    276             ++thread->priority : thread->priority;
    277        
    278         cpu_t *cpu;
    279         if (thread->wired || thread->nomigrate || thread->fpu_context_engaged) {
     262        int i = (thread->priority < RQ_COUNT - 1)
     263            ? ++thread->priority : thread->priority;
     264       
     265        cpu_t *cpu = CPU;
     266        if (thread->flags & THREAD_FLAG_WIRED) {
    280267                ASSERT(thread->cpu != NULL);
    281268                cpu = thread->cpu;
    282         } else
    283                 cpu = CPU;
    284        
     269        }
    285270        thread->state = Ready;
    286271       
    … …  
    313298 * @param flags     Thread flags.
    314299 * @param name      Symbolic name (a copy is made).
     300 * @param uncounted Thread's accounting doesn't affect accumulated task
     301 *                  accounting.
    315302 *
    316303 * @return New thread's structure on success, NULL on failure.
    … …  
    318305 */
    319306thread_t *thread_create(void (* func)(void *), void *arg, task_t *task,
    320     thread_flags_t flags, const char *name)
     307    unsigned int flags, const char *name, bool uncounted)
    321308{
    322309        thread_t *thread = (thread_t *) slab_alloc(thread_slab, 0);
    … …  
    348335        thread->ucycles = 0;
    349336        thread->kcycles = 0;
    350         thread->uncounted =
    351             ((flags & THREAD_FLAG_UNCOUNTED) == THREAD_FLAG_UNCOUNTED);
     337        thread->uncounted = uncounted;
    352338        thread->priority = -1;          /* Start in rq[0] */
    353339        thread->cpu = NULL;
    354         thread->wired = false;
    355         thread->stolen = false;
    356         thread->uspace =
    357             ((flags & THREAD_FLAG_USPACE) == THREAD_FLAG_USPACE);
    358        
     340        thread->flags = flags;
    359341        thread->nomigrate = 0;
    360342        thread->state = Entering;
    … …  
    374356        thread->task = task;
    375357       
    376         thread->fpu_context_exists = false;
    377         thread->fpu_context_engaged = false;
     358        thread->fpu_context_exists = 0;
     359        thread->fpu_context_engaged = 0;
    378360       
    379361        avltree_node_initialize(&thread->threads_tree_node);
    … …  
    389371        thread_create_arch(thread);
    390372       
    391         if ((flags & THREAD_FLAG_NOATTACH) != THREAD_FLAG_NOATTACH)
     373        if (!(flags & THREAD_FLAG_NOATTACH))
    392374                thread_attach(thread, task);
    393375       
    … …  
    455437       
    456438        /* Must not count kbox thread into lifecount */
    457         if (thread->uspace)
     439        if (thread->flags & THREAD_FLAG_USPACE)
    458440                atomic_inc(&task->lifecount);
    459441       
    … …  
    477459void thread_exit(void)
    478460{
    479         if (THREAD->uspace) {
     461        if (THREAD->flags & THREAD_FLAG_USPACE) {
    480462#ifdef CONFIG_UDEBUG
    481463                /* Generate udebug THREAD_E event */
    482464                udebug_thread_e_event();
    483                
     465
    484466                /*
    485467                 * This thread will not execute any code or system calls from
    … …  
    524506{
    525507        ASSERT(THREAD);
    526        
     508
    527509        THREAD->nomigrate++;
    528510}
    … …  
    533515        ASSERT(THREAD);
    534516        ASSERT(THREAD->nomigrate > 0);
    535        
    536         if (THREAD->nomigrate > 0)
    537                 THREAD->nomigrate--;
     517
     518        THREAD->nomigrate--;
    538519}
    539520
    … …  
    884865       
    885866        thread_t *thread = thread_create(uinit, kernel_uarg, TASK,
    886             THREAD_FLAG_USPACE | THREAD_FLAG_NOATTACH, namebuf);
     867            THREAD_FLAG_USPACE | THREAD_FLAG_NOATTACH, namebuf, false);
    887868        if (thread) {
    888869                if (uspace_thread_id != NULL) {

  • kernel/generic/src/sysinfo/sysinfo.c

    r380553c r2616a75b  
    9797void sysinfo_init(void)
    9898{
    99         sysinfo_item_slab = slab_cache_create("sysinfo_item_t",
     99        sysinfo_item_slab = slab_cache_create("sysinfo_item_slab",
    100100            sizeof(sysinfo_item_t), 0, sysinfo_item_constructor,
    101101            sysinfo_item_destructor, SLAB_CACHE_MAGDEFERRED);

  • kernel/generic/src/udebug/udebug.c

    r380553c r2616a75b  
    410410               
    411411                mutex_lock(&thread->udebug.lock);
     412                unsigned int flags = thread->flags;
    412413               
    413414                /* Only process userspace threads. */
    414                 if (thread->uspace) {
     415                if ((flags & THREAD_FLAG_USPACE) != 0) {
    415416                        /* Prevent any further debug activity in thread. */
    416417                        thread->udebug.active = false;

  • kernel/generic/src/udebug/udebug_ops.c

    r380553c r2616a75b  
    9595       
    9696        /* Verify that 'thread' is a userspace thread. */
    97         if (!thread->uspace) {
     97        if ((thread->flags & THREAD_FLAG_USPACE) == 0) {
    9898                /* It's not, deny its existence */
    9999                irq_spinlock_unlock(&thread->lock, true);
    … …  
    200200               
    201201                mutex_lock(&thread->udebug.lock);
    202                 if (thread->uspace) {
     202                if ((thread->flags & THREAD_FLAG_USPACE) != 0) {
    203203                        thread->udebug.active = true;
    204204                        mutex_unlock(&thread->udebug.lock);
    … …  
    393393               
    394394                irq_spinlock_lock(&thread->lock, false);
    395                 bool uspace = thread->uspace;
     395                int flags = thread->flags;
    396396                irq_spinlock_unlock(&thread->lock, false);
    397397               
    398398                /* Not interested in kernel threads. */
    399                 if (!uspace)
     399                if ((flags & THREAD_FLAG_USPACE) == 0)
    400400                        continue;
    401401               

  • kernel/test/mm/falloc1.c

    r380553c r2616a75b  
    3737#include <align.h>
    3838
    39 #define MAX_FRAMES  1024U
     39#define MAX_FRAMES  1024
    4040#define MAX_ORDER   8
    4141#define TEST_RUNS   2
    4242
    43 const char *test_falloc1(void)
    44 {
     43const char *test_falloc1(void) {
     44        uintptr_t *frames
     45            = (uintptr_t *) malloc(MAX_FRAMES * sizeof(uintptr_t), 0);
     46        int results[MAX_ORDER + 1];
     47       
     48        int i, order, run;
     49        int allocated;
     50       
    4551        if (TEST_RUNS < 2)
    4652                return "Test is compiled with TEST_RUNS < 2";
    4753       
    48         uintptr_t *frames = (uintptr_t *)
    49             malloc(MAX_FRAMES * sizeof(uintptr_t), 0);
    5054        if (frames == NULL)
    5155                return "Unable to allocate frames";
    5256       
    53         unsigned int results[MAX_ORDER + 1];
    54         for (unsigned int run = 0; run < TEST_RUNS; run++) {
    55                 for (unsigned int order = 0; order <= MAX_ORDER; order++) {
    56                         TPRINTF("Allocating %u frames blocks ... ", 1 << order);
     57        for (run = 0; run < TEST_RUNS; run++) {
     58                for (order = 0; order <= MAX_ORDER; order++) {
     59                        TPRINTF("Allocating %d frames blocks ... ", 1 << order);
    5760                       
    58                         unsigned int allocated = 0;
    59                         for (unsigned int i = 0; i < (MAX_FRAMES >> order); i++) {
    60                                 frames[allocated] = (uintptr_t)
    61                                     frame_alloc(order, FRAME_ATOMIC | FRAME_KA);
     61                        allocated = 0;
     62                        for (i = 0; i < MAX_FRAMES >> order; i++) {
     63                                frames[allocated] = (uintptr_t) frame_alloc(order, FRAME_ATOMIC | FRAME_KA);
    6264                               
    63                                 if (ALIGN_UP(frames[allocated], FRAME_SIZE << order) !=
    64                                     frames[allocated]) {
    65                                         TPRINTF("Block at address %p (size %u) is not aligned\n",
     65                                if (ALIGN_UP(frames[allocated], FRAME_SIZE << order) != frames[allocated]) {
     66                                        TPRINTF("Block at address %p (size %dK) is not aligned\n",
    6667                                            (void *) frames[allocated], (FRAME_SIZE << order) >> 10);
    6768                                        return "Test failed";
    … …  
    8687                        TPRINTF("Deallocating ... ");
    8788                       
    88                         for (unsigned int i = 0; i < allocated; i++)
     89                        for (i = 0; i < allocated; i++)
    8990                                frame_free(KA2PA(frames[i]));
    9091                       

  • kernel/test/mm/falloc2.c

    r380553c r2616a75b  
    4040#include <arch.h>
    4141
    42 #define MAX_FRAMES  256U
     42#define MAX_FRAMES  256
    4343#define MAX_ORDER   8
    4444
    … …  
    5151static void falloc(void *arg)
    5252{
     53        int order, run, allocated, i;
    5354        uint8_t val = THREAD->tid % THREADS;
     55        size_t k;
    5456       
    55         void **frames = (void **)
    56             malloc(MAX_FRAMES * sizeof(void *), FRAME_ATOMIC);
     57        void **frames =  (void **) malloc(MAX_FRAMES * sizeof(void *), FRAME_ATOMIC);
    5758        if (frames == NULL) {
    58                 TPRINTF("Thread #%" PRIu64 " (cpu%u): "
    59                     "Unable to allocate frames\n", THREAD->tid, CPU->id);
     59                TPRINTF("Thread #%" PRIu64 " (cpu%u): Unable to allocate frames\n", THREAD->tid, CPU->id);
    6060                atomic_inc(&thread_fail);
    6161                atomic_dec(&thread_count);
    … …  
    6565        thread_detach(THREAD);
    6666       
    67         for (unsigned int run = 0; run < THREAD_RUNS; run++) {
    68                 for (unsigned int order = 0; order <= MAX_ORDER; order++) {
    69                         TPRINTF("Thread #%" PRIu64 " (cpu%u): "
    70                             "Allocating %u frames blocks ... \n", THREAD->tid,
    71                             CPU->id, 1 << order);
     67        for (run = 0; run < THREAD_RUNS; run++) {
     68                for (order = 0; order <= MAX_ORDER; order++) {
     69                        TPRINTF("Thread #%" PRIu64 " (cpu%u): Allocating %d frames blocks ... \n", THREAD->tid, CPU->id, 1 << order);
    7270                       
    73                         unsigned int allocated = 0;
    74                         for (unsigned int i = 0; i < (MAX_FRAMES >> order); i++) {
    75                                 frames[allocated] =
    76                                     frame_alloc(order, FRAME_ATOMIC | FRAME_KA);
     71                        allocated = 0;
     72                        for (i = 0; i < (MAX_FRAMES >> order); i++) {
     73                                frames[allocated] = frame_alloc(order, FRAME_ATOMIC | FRAME_KA);
    7774                                if (frames[allocated]) {
    7875                                        memsetb(frames[allocated], FRAME_SIZE << order, val);
    … …  
    8279                        }
    8380                       
    84                         TPRINTF("Thread #%" PRIu64 " (cpu%u): "
    85                             "%u blocks allocated.\n", THREAD->tid, CPU->id,
    86                             allocated);
    87                         TPRINTF("Thread #%" PRIu64 " (cpu%u): "
    88                             "Deallocating ... \n", THREAD->tid, CPU->id);
     81                        TPRINTF("Thread #%" PRIu64 " (cpu%u): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);
     82                        TPRINTF("Thread #%" PRIu64 " (cpu%u): Deallocating ... \n", THREAD->tid, CPU->id);
    8983                       
    90                         for (unsigned int i = 0; i < allocated; i++) {
    91                                 for (size_t k = 0; k <= (((size_t) FRAME_SIZE << order) - 1);
    92                                     k++) {
     84                        for (i = 0; i < allocated; i++) {
     85                                for (k = 0; k <= (((size_t) FRAME_SIZE << order) - 1); k++) {
    9386                                        if (((uint8_t *) frames[i])[k] != val) {
    94                                                 TPRINTF("Thread #%" PRIu64 " (cpu%u): "
    95                                                     "Unexpected data (%c) in block %p offset %zu\n",
    96                                                     THREAD->tid, CPU->id, ((char *) frames[i])[k],
    97                                                     frames[i], k);
     87                                                TPRINTF("Thread #%" PRIu64 " (cpu%u): Unexpected data (%c) in block %p offset %zu\n",
     88                                                    THREAD->tid, CPU->id, ((char *) frames[i])[k], frames[i], k);
    9889                                                atomic_inc(&thread_fail);
    9990                                                goto cleanup;
    … …  
    10394                        }
    10495                       
    105                         TPRINTF("Thread #%" PRIu64 " (cpu%u): "
    106                             "Finished run.\n", THREAD->tid, CPU->id);
     96                        TPRINTF("Thread #%" PRIu64 " (cpu%u): Finished run.\n", THREAD->tid, CPU->id);
    10797                }
    10898        }
    … …  
    111101        free(frames);
    112102       
    113         TPRINTF("Thread #%" PRIu64 " (cpu%u): Exiting\n",
    114             THREAD->tid, CPU->id);
     103        TPRINTF("Thread #%" PRIu64 " (cpu%u): Exiting\n", THREAD->tid, CPU->id);
    115104        atomic_dec(&thread_count);
    116105}
    … …  
    118107const char *test_falloc2(void)
    119108{
     109        unsigned int i;
     110       
    120111        atomic_set(&thread_count, THREADS);
    121112        atomic_set(&thread_fail, 0);
    122113       
    123         for (unsigned int i = 0; i < THREADS; i++) {
    124                 thread_t *thrd = thread_create(falloc, NULL, TASK,
    125                     THREAD_FLAG_NONE, "falloc2");
     114        for (i = 0; i < THREADS; i++) {
     115                thread_t * thrd = thread_create(falloc, NULL, TASK, 0, "falloc", false);
    126116                if (!thrd) {
    127117                        TPRINTF("Could not create thread %u\n", i);
    … …  
    132122       
    133123        while (atomic_get(&thread_count) > 0) {
    134                 TPRINTF("Threads left: %" PRIua "\n",
    135                     atomic_get(&thread_count));
     124                TPRINTF("Threads left: %" PRIua "\n", atomic_get(&thread_count));
    136125                thread_sleep(1);
    137126        }

  • kernel/test/mm/slab1.c

    r380553c r2616a75b  
    155155       
    156156        semaphore_initialize(&thr_sem, 0);
    157         for (i = 0; i < THREADS; i++) {
    158                 if (!(t = thread_create(slabtest, (void *) (sysarg_t) i, TASK, THREAD_FLAG_NONE, "slabtest"))) {
     157        for (i = 0; i < THREADS; i++) { 
     158                if (!(t = thread_create(slabtest, (void *) (sysarg_t) i, TASK, 0, "slabtest", false))) {
    159159                        TPRINTF("Could not create thread %d\n", i);
    160160                } else

  • kernel/test/mm/slab2.c

    r380553c r2616a75b  
    5252        void *olddata1 = NULL, *olddata2 = NULL;
    5353       
    54         cache1 = slab_cache_create("test_cache1", ITEM_SIZE, 0, NULL, NULL, 0);
    55         cache2 = slab_cache_create("test_cache2", ITEM_SIZE, 0, NULL, NULL, 0);
     54        cache1 = slab_cache_create("cache1_tst", ITEM_SIZE, 0, NULL, NULL, 0);
     55        cache2 = slab_cache_create("cache2_tst", ITEM_SIZE, 0, NULL, NULL, 0);
    5656       
    5757        TPRINTF("Allocating...");
    … …  
    210210        thr_cache = slab_cache_create("thread_cache", size, 0, NULL, NULL, 0);
    211211        semaphore_initialize(&thr_sem,0);
    212         for (i = 0; i < THREADS; i++) {
    213                 if (!(t = thread_create(slabtest, NULL, TASK, THREAD_FLAG_NONE, "slabtest"))) {
     212        for (i = 0; i < THREADS; i++) { 
     213                if (!(t = thread_create(slabtest, NULL, TASK, 0, "slabtest", false))) {
    214214                        TPRINTF("Could not create thread %d\n", i);
    215215                } else

  • kernel/test/synch/semaphore1.c

    r380553c r2616a75b  
    9393                for (j = 0; j < (CONSUMERS + PRODUCERS) / 2; j++) {
    9494                        for (k = 0; k < i; k++) {
    95                                 thrd = thread_create(consumer, NULL, TASK,
    96                                     THREAD_FLAG_NONE, "consumer");
     95                                thrd = thread_create(consumer, NULL, TASK, 0, "consumer", false);
    9796                                if (thrd)
    9897                                        thread_ready(thrd);
    … …  
    101100                        }
    102101                        for (k = 0; k < (4 - i); k++) {
    103                                 thrd = thread_create(producer, NULL, TASK,
    104                                     THREAD_FLAG_NONE, "producer");
     102                                thrd = thread_create(producer, NULL, TASK, 0, "producer", false);
    105103                                if (thrd)
    106104                                        thread_ready(thrd);

  • kernel/test/synch/semaphore2.c

    r380553c r2616a75b  
    9393        TPRINTF("Creating %" PRIu32 " consumers\n", k);
    9494        for (i = 0; i < k; i++) {
    95                 thrd = thread_create(consumer, NULL, TASK,
    96                     THREAD_FLAG_NONE, "consumer");
     95                thrd = thread_create(consumer, NULL, TASK, 0, "consumer", false);
    9796                if (thrd)
    9897                        thread_ready(thrd);

  • kernel/test/thread/thread1.c

    r380553c r2616a75b  
    6363        for (i = 0; i < THREADS; i++) {
    6464                thread_t *t;
    65                 if (!(t = thread_create(threadtest, NULL, TASK,
    66                     THREAD_FLAG_NONE, "threadtest"))) {
     65                if (!(t = thread_create(threadtest, NULL, TASK, 0, "threadtest", false))) {
    6766                        TPRINTF("Could not create thread %d\n", i);
    6867                        break;

  • tools/toolchain.sh

    r380553c r2616a75b  
    5555BINUTILS_VERSION="2.22"
    5656BINUTILS_RELEASE=""
    57 GCC_VERSION="4.7.1"
     57GCC_VERSION="4.7.0"
    5858GDB_VERSION="7.4"
    5959
    … …  
    274274       
    275275        download_fetch "${BINUTILS_SOURCE}" "${BINUTILS}" "ee0f10756c84979622b992a4a61ea3f5"
    276         download_fetch "${GCC_SOURCE}" "${GCC}" "933e6f15f51c031060af64a9e14149ff"
     276        download_fetch "${GCC_SOURCE}" "${GCC}" "2a0f1d99fda235c29d40b561f81d9a77"
    277277        download_fetch "${GDB_SOURCE}" "${GDB}" "95a9a8305fed4d30a30a6dc28ff9d060"
    278278}
Note: See TracChangeset for help on using the changeset viewer.