Changeset 6eef3c4 in mainline


Ignore:
Timestamp:
2012-06-20T16:18:37Z (12 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
8b36bf2, f22dc820
Parents:
abfc9f3
Message:

cleanup thread_create() and thread_t structure

  • remove 'flag' bitfield from thread_t, use individual boolean flags (can be optimized later on by adding : 1)
  • use an enum for call flags, add THREAD_FLAG_NONE
  • remove the 'uncounted' argument in favour of a call flag
  • introduce thread_wire() to setup wired threads
Location:
kernel
Files:
23 edited

Legend:

Unmodified
Added
Removed

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

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

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

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

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

    rabfc9f3 r6eef3c4  
    5151void before_thread_runs_arch(void)
    5252{
    53         if ((THREAD->flags & THREAD_FLAG_USPACE)) {
     53        if (THREAD->uspace) {
    5454                /*
    5555                 * Write kernel stack address to %g6 of the alternate and
    … …  
    7474void after_thread_ran_arch(void)
    7575{
    76         if ((THREAD->flags & THREAD_FLAG_USPACE)) {
    77                 /* sample the state of the userspace window buffer */   
     76        if (THREAD->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

    rabfc9f3 r6eef3c4  
    5454void before_thread_runs_arch(void)
    5555{
    56         if ((THREAD->flags & THREAD_FLAG_USPACE)) {
     56        if (THREAD->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->flags & THREAD_FLAG_USPACE)) {
    69                 /* sample the state of the userspace window buffer */   
     68        if (THREAD->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

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

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

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

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

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

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

    rabfc9f3 r6eef3c4  
    5454
    5555/* Thread flags */
    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)
     56typedef 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;
    7365
    7466/** Thread structure. There is one per thread. */
    … …  
    147139       
    148140        fpu_context_t *saved_fpu_context;
    149         int fpu_context_exists;
     141        bool fpu_context_exists;
    150142       
    151143        /*
    … …  
    154146         * thread. This disables migration.
    155147         */
    156         int fpu_context_engaged;
     148        bool fpu_context_engaged;
    157149       
    158150        /* The thread will not be migrated if nomigrate is non-zero. */
    159         int nomigrate;
    160        
    161         /** Thread's state. */
     151        unsigned int nomigrate;
     152       
     153        /** Thread state. */
    162154        state_t state;
    163         /** Thread's flags. */
    164         unsigned int flags;
    165        
    166         /** Thread's CPU. */
     155       
     156        /** Thread CPU. */
    167157        cpu_t *cpu;
    168158        /** Containing task. */
    169159        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;
    170166       
    171167        /** Ticks before preemption. */
    … …  
    216212extern void thread_init(void);
    217213extern thread_t *thread_create(void (*)(void *), void *, task_t *,
    218     unsigned int, const char *, bool);
     214    thread_flags_t, const char *);
     215extern void thread_wire(thread_t *, cpu_t *);
    219216extern void thread_attach(thread_t *, task_t *);
    220217extern void thread_ready(thread_t *);

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

    rabfc9f3 r6eef3c4  
    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/kbox.c

    rabfc9f3 r6eef3c4  
    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/main/kinit.c

    rabfc9f3 r6eef3c4  
    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

    rabfc9f3 r6eef3c4  
    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/proc/program.c

    rabfc9f3 r6eef3c4  
    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

    rabfc9f3 r6eef3c4  
    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/thread.c

    rabfc9f3 r6eef3c4  
    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) {
    … …  
    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) {
    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/udebug/udebug.c

    rabfc9f3 r6eef3c4  
    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

    rabfc9f3 r6eef3c4  
    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               

  • kernel/test/mm/falloc2.c

    rabfc9f3 r6eef3c4  
    122122       
    123123        for (unsigned int i = 0; i < THREADS; i++) {
    124                 thread_t *thrd =
    125                     thread_create(falloc, NULL, TASK, 0, "falloc2", false);
     124                thread_t *thrd = thread_create(falloc, NULL, TASK,
     125                    THREAD_FLAG_NONE, "falloc2");
    126126                if (!thrd) {
    127127                        TPRINTF("Could not create thread %u\n", i);

  • kernel/test/mm/slab1.c

    rabfc9f3 r6eef3c4  
    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, 0, "slabtest", false))) {
     157        for (i = 0; i < THREADS; i++) {
     158                if (!(t = thread_create(slabtest, (void *) (sysarg_t) i, TASK, THREAD_FLAG_NONE, "slabtest"))) {
    159159                        TPRINTF("Could not create thread %d\n", i);
    160160                } else

  • kernel/test/mm/slab2.c

    rabfc9f3 r6eef3c4  
    211211        semaphore_initialize(&thr_sem,0);
    212212        for (i = 0; i < THREADS; i++) {
    213                 if (!(t = thread_create(slabtest, NULL, TASK, 0, "slabtest", false))) {
     213                if (!(t = thread_create(slabtest, NULL, TASK, THREAD_FLAG_NONE, "slabtest"))) {
    214214                        TPRINTF("Could not create thread %d\n", i);
    215215                } else

  • kernel/test/synch/semaphore1.c

    rabfc9f3 r6eef3c4  
    9393                for (j = 0; j < (CONSUMERS + PRODUCERS) / 2; j++) {
    9494                        for (k = 0; k < i; k++) {
    95                                 thrd = thread_create(consumer, NULL, TASK, 0, "consumer", false);
     95                                thrd = thread_create(consumer, NULL, TASK,
     96                                    THREAD_FLAG_NONE, "consumer");
    9697                                if (thrd)
    9798                                        thread_ready(thrd);
    … …  
    100101                        }
    101102                        for (k = 0; k < (4 - i); k++) {
    102                                 thrd = thread_create(producer, NULL, TASK, 0, "producer", false);
     103                                thrd = thread_create(producer, NULL, TASK,
     104                                    THREAD_FLAG_NONE, "producer");
    103105                                if (thrd)
    104106                                        thread_ready(thrd);

  • kernel/test/synch/semaphore2.c

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

  • kernel/test/thread/thread1.c

    rabfc9f3 r6eef3c4  
    6363        for (i = 0; i < THREADS; i++) {
    6464                thread_t *t;
    65                 if (!(t = thread_create(threadtest, NULL, TASK, 0, "threadtest", false))) {
     65                if (!(t = thread_create(threadtest, NULL, TASK,
     66                    THREAD_FLAG_NONE, "threadtest"))) {
    6667                        TPRINTF("Could not create thread %d\n", i);
    6768                        break;
Note: See TracChangeset for help on using the changeset viewer.