Changeset b0f00a9 in mainline for kernel/generic/src/proc


Ignore:
Timestamp:
2011-11-06T22:21:05Z (14 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
898e847
Parents:
2bdf8313 (diff), 7b5f4c9 (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:

Merge mainline changes.

Location:
kernel/generic/src/proc
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    r2bdf8313 rb0f00a9  
    4040#include <proc/thread.h>
    4141#include <proc/task.h>
    42 #include <proc/uarg.h>
    4342#include <mm/as.h>
    4443#include <mm/slab.h>
    … …  
    4847#include <ipc/ipcrsc.h>
    4948#include <security/cap.h>
    50 #include <lib/elf.h>
     49#include <lib/elf_load.h>
    5150#include <errno.h>
    5251#include <print.h>

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

    r2bdf8313 rb0f00a9  
    237237                 * Take the first thread from the queue.
    238238                 */
    239                 thread_t *thread =
    240                     list_get_instance(CPU->rq[i].rq_head.next, thread_t, rq_link);
     239                thread_t *thread = list_get_instance(
     240                    list_first(&CPU->rq[i].rq), thread_t, rq_link);
    241241                list_remove(&thread->rq_link);
    242242               
    … …  
    273273static void relink_rq(int start)
    274274{
    275         link_t head;
    276        
    277         list_initialize(&head);
     275        list_t list;
     276       
     277        list_initialize(&list);
    278278        irq_spinlock_lock(&CPU->lock, false);
    279279       
    … …  
    284284                       
    285285                        irq_spinlock_lock(&CPU->rq[i + 1].lock, false);
    286                         list_concat(&head, &CPU->rq[i + 1].rq_head);
     286                        list_concat(&list, &CPU->rq[i + 1].rq);
    287287                        size_t n = CPU->rq[i + 1].n;
    288288                        CPU->rq[i + 1].n = 0;
    … …  
    292292                       
    293293                        irq_spinlock_lock(&CPU->rq[i].lock, false);
    294                         list_concat(&CPU->rq[i].rq_head, &head);
     294                        list_concat(&CPU->rq[i].rq, &list);
    295295                        CPU->rq[i].n += n;
    296296                        irq_spinlock_unlock(&CPU->rq[i].lock, false);
    … …  
    586586         * Searching least priority queues on all CPU's first and most priority
    587587         * queues on all CPU's last.
    588          *
    589588         */
    590589        size_t acpu;
    … …  
    617616                       
    618617                        /* Search rq from the back */
    619                         link_t *link = cpu->rq[rq].rq_head.prev;
    620                        
    621                         while (link != &(cpu->rq[rq].rq_head)) {
    622                                 thread = (thread_t *) list_get_instance(link, thread_t, rq_link);
     618                        link_t *link = cpu->rq[rq].rq.head.prev;
     619                       
     620                        while (link != &(cpu->rq[rq].rq.head)) {
     621                                thread = (thread_t *) list_get_instance(link,
     622                                    thread_t, rq_link);
    623623                               
    624624                                /*
    625                                  * We don't want to steal CPU-wired threads
    626                                  * neither threads already stolen. The latter
    627                                  * prevents threads from migrating between CPU's
    628                                  * without ever being run. We don't want to
    629                                  * steal threads whose FPU context is still in
    630                                  * CPU.
    631                                  *
     625                                 * Do not steal CPU-wired threads, threads
     626                                 * already stolen, threads for which migration
     627                                 * was temporarily disabled or threads whose
     628                                 * FPU context is still in the CPU.
    632629                                 */
    633630                                irq_spinlock_lock(&thread->lock, false);
    634631                               
    635                                 if ((!(thread->flags & (THREAD_FLAG_WIRED | THREAD_FLAG_STOLEN)))
    636                                     && (!(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) {
    637636                                        /*
    638637                                         * Remove thread from ready queue.
    639638                                         */
    640                                         irq_spinlock_unlock(&thread->lock, false);
     639                                        irq_spinlock_unlock(&thread->lock,
     640                                            false);
    641641                                       
    642642                                        atomic_dec(&cpu->nrdy);
    … …  
    660660                                 */
    661661                               
    662                                 irq_spinlock_pass(&(cpu->rq[rq].lock), &thread->lock);
     662                                irq_spinlock_pass(&(cpu->rq[rq].lock),
     663                                    &thread->lock);
    663664                               
    664665#ifdef KCPULB_VERBOSE
    … …  
    739740                       
    740741                        printf("\trq[%u]: ", i);
    741                         link_t *cur;
    742                         for (cur = cpus[cpu].rq[i].rq_head.next;
    743                             cur != &(cpus[cpu].rq[i].rq_head);
    744                             cur = cur->next) {
    745                                 thread_t *thread = list_get_instance(cur, thread_t, rq_link);
     742                        list_foreach(cpus[cpu].rq[i].rq, cur) {
     743                                thread_t *thread = list_get_instance(cur,
     744                                    thread_t, rq_link);
    746745                                printf("%" PRIu64 "(%s) ", thread->tid,
    747746                                    thread_states[thread->state]);

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

    r2bdf8313 rb0f00a9  
    5050#include <ipc/ipc.h>
    5151#include <ipc/ipcrsc.h>
     52#include <ipc/event.h>
    5253#include <print.h>
    5354#include <errno.h>
    … …  
    5758#include <syscall/copy.h>
    5859#include <macros.h>
    59 #include <ipc/event.h>
    6060
    6161/** Spinlock protecting the tasks_tree AVL tree. */
    … …  
    155155        mutex_initialize(&task->futexes_lock, MUTEX_PASSIVE);
    156156       
    157         list_initialize(&task->th_head);
    158         list_initialize(&task->sync_box_head);
     157        list_initialize(&task->threads);
     158        list_initialize(&task->sync_boxes);
    159159       
    160160        ipc_answerbox_init(&task->answerbox, task);
    … …  
    201201        task->ipc_info.irq_notif_received = 0;
    202202        task->ipc_info.forwarded = 0;
     203
     204        event_task_init(task);
    203205       
    204206#ifdef CONFIG_UDEBUG
    … …  
    435437       
    436438        /* Current values of threads */
    437         link_t *cur;
    438         for (cur = task->th_head.next; cur != &task->th_head; cur = cur->next) {
     439        list_foreach(task->threads, cur) {
    439440                thread_t *thread = list_get_instance(cur, thread_t, th_link);
    440441               
    … …  
    468469         */
    469470       
    470         link_t *cur;
    471         for (cur = task->th_head.next; cur != &task->th_head; cur = cur->next) {
     471        list_foreach(task->threads, cur) {
    472472                thread_t *thread = list_get_instance(cur, thread_t, th_link);
    473473                bool sleeping = false;

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

    r2bdf8313 rb0f00a9  
    3939#include <proc/thread.h>
    4040#include <proc/task.h>
    41 #include <proc/uarg.h>
    4241#include <mm/frame.h>
    4342#include <mm/page.h>
    … …  
    4544#include <arch/cycle.h>
    4645#include <arch.h>
    47 #include <synch/synch.h>
    4846#include <synch/spinlock.h>
    4947#include <synch/waitq.h>
    … …  
    5553#include <time/clock.h>
    5654#include <time/timeout.h>
     55#include <time/delay.h>
    5756#include <config.h>
    5857#include <arch/interrupt.h>
    … …  
    259258         */
    260259       
    261         list_append(&thread->rq_link, &cpu->rq[i].rq_head);
     260        list_append(&thread->rq_link, &cpu->rq[i].rq);
    262261        cpu->rq[i].n++;
    263262        irq_spinlock_unlock(&(cpu->rq[i].lock), true);
    … …  
    321320        thread->cpu = NULL;
    322321        thread->flags = flags;
     322        thread->nomigrate = 0;
    323323        thread->state = Entering;
    324324       
    … …  
    421421                atomic_inc(&task->lifecount);
    422422       
    423         list_append(&thread->th_link, &task->th_head);
     423        list_append(&thread->th_link, &task->threads);
    424424       
    425425        irq_spinlock_pass(&task->lock, &threads_lock);
    … …  
    481481        /* Not reached */
    482482        while (true);
     483}
     484
     485/** Prevent the current thread from being migrated to another processor. */
     486void thread_migration_disable(void)
     487{
     488        ASSERT(THREAD);
     489
     490        THREAD->nomigrate++;
     491}
     492
     493/** Allow the current thread to be migrated to another processor. */
     494void thread_migration_enable(void)
     495{
     496        ASSERT(THREAD);
     497        ASSERT(THREAD->nomigrate > 0);
     498
     499        THREAD->nomigrate--;
    483500}
    484501
    … …  
    912929}
    913930
     931sysarg_t sys_thread_udelay(uint32_t usec)
     932{
     933        delay(usec);
     934        return 0;
     935}
     936
    914937/** @}
    915938 */
Note: See TracChangeset for help on using the changeset viewer.