Changeset 32fffef0 in mainline for kernel/generic/src/proc

Timestamp:

2006-08-29T11:06:57Z (19 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

0fa6044

Parents:

c8ea4a8b

Message:

Define architecture-specific thread sub-constructors and sub-destructors on all architectures.
Define the THREAD_FLAG_USPACE which means that the thread runs in user space.
The forementioned changes allow for allocating of user window buffer on sparc64
threads that execute in userspace.

A lot of formatting and indentation fixes.

Location:

kernel/generic/src/proc

Files:

• scheduler.c (modified) (7 diffs)
• thread.c (modified) (7 diffs)

kernel/generic/src/proc/scheduler.c

@@ -142 +142 @@
                         spinlock_unlock(&THREAD->lock);
                         spinlock_unlock(&CPU->lock);
-                        THREAD->saved_fpu_context = slab_alloc(fpu_context_slab,
-                                                               0);
+                        THREAD->saved_fpu_context = slab_alloc(fpu_context_slab, 0);
                         /* We may have switched CPUs during slab_alloc */
                         goto restart; 
@@ -236 +235 @@
 
                 /*
-                 * Clear the X_STOLEN flag so that t can be migrated when load balancing needs emerge.
+                 * Clear the THREAD_FLAG_STOLEN flag so that t can be migrated
+                 * when load balancing needs emerge.
                  */
-                t->flags &= ~X_STOLEN;
+                t->flags &= ~THREAD_FLAG_STOLEN;
                 spinlock_unlock(&t->lock);
 
@@ -350 +350 @@
          */
         context_save(&CPU->saved_context);
-        context_set(&CPU->saved_context, FADDR(scheduler_separated_stack), (uintptr_t) CPU->stack, CPU_STACK_SIZE);
+        context_set(&CPU->saved_context, FADDR(scheduler_separated_stack),
+                (uintptr_t) CPU->stack, CPU_STACK_SIZE);
         context_restore(&CPU->saved_context);
         /* not reached */
@@ -484 +485 @@
 
 #ifdef SCHEDULER_VERBOSE
-        printf("cpu%d: tid %d (priority=%d,ticks=%lld,nrdy=%ld)\n", CPU->id, THREAD->tid, THREAD->priority, THREAD->ticks, atomic_get(&CPU->nrdy));
+        printf("cpu%d: tid %d (priority=%d,ticks=%lld,nrdy=%ld)\n",
+                CPU->id, THREAD->tid, THREAD->priority, THREAD->ticks, atomic_get(&CPU->nrdy));
 #endif  
 
@@ -557 +559 @@
                         /*
                          * Not interested in ourselves.
-                         * Doesn't require interrupt disabling for kcpulb is X_WIRED.
+                         * Doesn't require interrupt disabling for kcpulb has THREAD_FLAG_WIRED.
                          */
                         if (CPU == cpu)
@@ -578 +580 @@
                                 t = list_get_instance(l, thread_t, rq_link);
                                 /*
-                                 * We don't want to steal CPU-wired threads neither threads already stolen.
-                                 * The latter prevents threads from migrating between CPU's without ever being run.
-                                 * We don't want to steal threads whose FPU context is still in CPU.
+                                 * We don't want to steal CPU-wired threads neither threads already
+                                 * stolen. The latter prevents threads from migrating between CPU's
+                                 * without ever being run. We don't want to steal threads whose FPU
+                                 * context is still in CPU.
                                  */
                                 spinlock_lock(&t->lock);
-                                if ( (!(t->flags & (X_WIRED | X_STOLEN))) && (!(t->fpu_context_engaged)) ) {
+                                if ((!(t->flags & (THREAD_FLAG_WIRED | THREAD_FLAG_STOLEN))) &&
+                                        (!(t->fpu_context_engaged)) ) {
                                         /*
                                          * Remove t from r.
@@ -609 +613 @@
                                 spinlock_lock(&t->lock);
 #ifdef KCPULB_VERBOSE
-                                printf("kcpulb%d: TID %d -> cpu%d, nrdy=%ld, avg=%nd\n", CPU->id, t->tid, CPU->id, atomic_get(&CPU->nrdy), atomic_get(&nrdy) / config.cpu_active);
+                                printf("kcpulb%d: TID %d -> cpu%d, nrdy=%ld, avg=%nd\n",
+                                        CPU->id, t->tid, CPU->id, atomic_get(&CPU->nrdy),
+                                        atomic_get(&nrdy) / config.cpu_active);
 #endif
-                                t->flags |= X_STOLEN;
+                                t->flags |= THREAD_FLAG_STOLEN;
                                 t->state = Entering;
                                 spinlock_unlock(&t->lock);

kernel/generic/src/proc/thread.c

@@ -130 +130 @@
         link_initialize(&t->wq_link);
         link_initialize(&t->th_link);
+
+        /* call the architecture-specific part of the constructor */
+        thr_constructor_arch(t);
         
 #ifdef ARCH_HAS_FPU
@@ -157 +160 @@
 {
         thread_t *t = (thread_t *) obj;
+
+        /* call the architecture-specific part of the destructor */
+        thr_destructor_arch(t);
 
         frame_free(KA2PA(t->kstack));
@@ -211 +217 @@
         
         cpu = CPU;
-        if (t->flags & X_WIRED) {
+        if (t->flags & THREAD_FLAG_WIRED) {
                 cpu = t->cpu;
         }
@@ -296 +302 @@
         if (!t)
                 return NULL;
-
-        thread_create_arch(t);
         
         /* Not needed, but good for debugging */
@@ -324 +328 @@
         t->priority = -1;               /* start in rq[0] */
         t->cpu = NULL;
-        t->flags = 0;
+        t->flags = flags;
         t->state = Entering;
         t->call_me = NULL;
@@ -348 +352 @@
         t->fpu_context_exists = 0;
         t->fpu_context_engaged = 0;
+
+        thread_create_arch(t);          /* might depend on previous initialization */
         
         /*
@@ -590 +596 @@
         }
 
-        if ((t = thread_create(uinit, kernel_uarg, TASK, 0, namebuf))) {
+        if ((t = thread_create(uinit, kernel_uarg, TASK, THREAD_FLAG_USPACE, namebuf))) {
                 tid = t->tid;
                 thread_ready(t);