Changeset 1f092d9 in mainline for kernel/generic/src


Ignore:
Timestamp:
2012-06-29T15:32:57Z (13 years ago)
Author:
Adam Hraska <adam.hraska+hos@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
49e6c6b4
Parents:
79d74fe (diff), baf8fbb (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merged changes from mainline.

Location:
kernel/generic/src
Files:
16 edited

Legend:

Unmodified
Added
Removed

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

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

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

    r79d74fe r1f092d9  
    724724                thread_t *thread;
    725725                if ((thread = thread_create((void (*)(void *)) cmd_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                        
     726                    (void *) argv, TASK, THREAD_FLAG_NONE, "call0"))) {
    731727                        printf("cpu%u: ", i);
    732                        
     728                        thread_wire(thread, &cpus[i]);
    733729                        thread_ready(thread);
    734730                        thread_join(thread);

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

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

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

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

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

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

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

    r79d74fe r1f092d9  
    116116                 * Just a beautification.
    117117                 */
    118                 thread = thread_create(kmp, NULL, TASK, THREAD_FLAG_WIRED, "kmp", true);
     118                thread = thread_create(kmp, NULL, TASK,
     119                    THREAD_FLAG_UNCOUNTED, "kmp");
    119120                if (thread != NULL) {
    120                         irq_spinlock_lock(&thread->lock, false);
    121                         thread->cpu = &cpus[0];
    122                         irq_spinlock_unlock(&thread->lock, false);
     121                        thread_wire(thread, &cpus[0]);
    123122                        thread_ready(thread);
    124123                } else
    … …  
    134133               
    135134                for (i = 0; i < config.cpu_count; i++) {
    136                         thread = thread_create(kcpulb, NULL, TASK, THREAD_FLAG_WIRED, "kcpulb", true);
     135                        thread = thread_create(kcpulb, NULL, TASK,
     136                            THREAD_FLAG_UNCOUNTED, "kcpulb");
    137137                        if (thread != NULL) {
    138                                 irq_spinlock_lock(&thread->lock, false);
    139                                 thread->cpu = &cpus[i];
    140                                 irq_spinlock_unlock(&thread->lock, false);
     138                                thread_wire(thread, &cpus[i]);
    141139                                thread_ready(thread);
    142140                        } else
    … …  
    152150       
    153151        /* Start thread computing system load */
    154         thread = thread_create(kload, NULL, TASK, 0, "kload", false);
     152        thread = thread_create(kload, NULL, TASK, THREAD_FLAG_NONE,
     153            "kload");
    155154        if (thread != NULL)
    156155                thread_ready(thread);
    … …  
    163162                 * Create kernel console.
    164163                 */
    165                 thread = thread_create(kconsole_thread, NULL, TASK, 0, "kconsole", false);
     164                thread = thread_create(kconsole_thread, NULL, TASK,
     165                    THREAD_FLAG_NONE, "kconsole");
    166166                if (thread != NULL)
    167167                        thread_ready(thread);

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

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

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

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

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

    r79d74fe r1f092d9  
    891891{
    892892        /* Initialize magazine cache */
    893         _slab_cache_create(&mag_cache, "slab_magazine",
     893        _slab_cache_create(&mag_cache, "slab_magazine_t",
    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",
     899        _slab_cache_create(&slab_cache_cache, "slab_cache_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_extern", sizeof(slab_t), 0,
     904        slab_extern_cache = slab_cache_create("slab_t", sizeof(slab_t), 0,
    905905            NULL, NULL, SLAB_CACHE_SLINSIDE | SLAB_CACHE_MAGDEFERRED);
    906906       

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

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

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

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

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

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

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

    r79d74fe r1f092d9  
    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_slab", sizeof(thread_t), 0,
     238        thread_slab = slab_cache_create("thread_t", sizeof(thread_t), 0,
    239239            thr_constructor, thr_destructor, 0);
    240240       
    241241#ifdef CONFIG_FPU
    242         fpu_context_slab = slab_cache_create("fpu_slab", sizeof(fpu_context_t),
    243             FPU_CONTEXT_ALIGN, NULL, NULL, 0);
     242        fpu_context_slab = slab_cache_create("fpu_context_t",
     243            sizeof(fpu_context_t), 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 */
     254void thread_wire(thread_t *thread, cpu_t *cpu)
     255{
     256        irq_spinlock_lock(&thread->lock, true);
     257        thread->cpu = cpu;
     258        thread->wired = true;
     259        irq_spinlock_unlock(&thread->lock, true);
     260}
     261
    249262/** Make thread ready
    250263 *
    … …  
    260273        ASSERT(thread->state != Ready);
    261274       
    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) {
     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) {
    267280                ASSERT(thread->cpu != NULL);
    268281                cpu = thread->cpu;
    269         }
     282        } else
     283                cpu = CPU;
     284       
    270285        thread->state = Ready;
    271286       
    … …  
    298313 * @param flags     Thread flags.
    299314 * @param name      Symbolic name (a copy is made).
    300  * @param uncounted Thread's accounting doesn't affect accumulated task
    301  *                  accounting.
    302315 *
    303316 * @return New thread's structure on success, NULL on failure.
    … …  
    305318 */
    306319thread_t *thread_create(void (* func)(void *), void *arg, task_t *task,
    307     unsigned int flags, const char *name, bool uncounted)
     320    thread_flags_t flags, const char *name)
    308321{
    309322        thread_t *thread = (thread_t *) slab_alloc(thread_slab, 0);
    … …  
    335348        thread->ucycles = 0;
    336349        thread->kcycles = 0;
    337         thread->uncounted = uncounted;
     350        thread->uncounted =
     351            ((flags & THREAD_FLAG_UNCOUNTED) == THREAD_FLAG_UNCOUNTED);
    338352        thread->priority = -1;          /* Start in rq[0] */
    339353        thread->cpu = NULL;
    340         thread->flags = flags;
     354        thread->wired = false;
     355        thread->stolen = false;
     356        thread->uspace =
     357            ((flags & THREAD_FLAG_USPACE) == THREAD_FLAG_USPACE);
     358       
    341359        thread->nomigrate = 0;
    342360        thread->state = Entering;
    … …  
    356374        thread->task = task;
    357375       
    358         thread->fpu_context_exists = 0;
    359         thread->fpu_context_engaged = 0;
     376        thread->fpu_context_exists = false;
     377        thread->fpu_context_engaged = false;
    360378       
    361379        avltree_node_initialize(&thread->threads_tree_node);
    … …  
    371389        thread_create_arch(thread);
    372390       
    373         if (!(flags & THREAD_FLAG_NOATTACH))
     391        if ((flags & THREAD_FLAG_NOATTACH) != THREAD_FLAG_NOATTACH)
    374392                thread_attach(thread, task);
    375393       
    … …  
    437455       
    438456        /* Must not count kbox thread into lifecount */
    439         if (thread->flags & THREAD_FLAG_USPACE)
     457        if (thread->uspace)
    440458                atomic_inc(&task->lifecount);
    441459       
    … …  
    459477void thread_exit(void)
    460478{
    461         if (THREAD->flags & THREAD_FLAG_USPACE) {
     479        if (THREAD->uspace) {
    462480#ifdef CONFIG_UDEBUG
    463481                /* Generate udebug THREAD_E event */
    464482                udebug_thread_e_event();
    465 
     483               
    466484                /*
    467485                 * This thread will not execute any code or system calls from
    … …  
    506524{
    507525        ASSERT(THREAD);
    508 
     526       
    509527        THREAD->nomigrate++;
    510528}
    … …  
    515533        ASSERT(THREAD);
    516534        ASSERT(THREAD->nomigrate > 0);
    517 
    518         THREAD->nomigrate--;
     535       
     536        if (THREAD->nomigrate > 0)
     537                THREAD->nomigrate--;
    519538}
    520539
    … …  
    865884       
    866885        thread_t *thread = thread_create(uinit, kernel_uarg, TASK,
    867             THREAD_FLAG_USPACE | THREAD_FLAG_NOATTACH, namebuf, false);
     886            THREAD_FLAG_USPACE | THREAD_FLAG_NOATTACH, namebuf);
    868887        if (thread) {
    869888                if (uspace_thread_id != NULL) {

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

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

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

    r79d74fe r1f092d9  
    410410               
    411411                mutex_lock(&thread->udebug.lock);
    412                 unsigned int flags = thread->flags;
    413412               
    414413                /* Only process userspace threads. */
    415                 if ((flags & THREAD_FLAG_USPACE) != 0) {
     414                if (thread->uspace) {
    416415                        /* Prevent any further debug activity in thread. */
    417416                        thread->udebug.active = false;

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

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