xnu-344.26.tar.gz

[apple/xnu.git] / osfmk / kern / startup.c

diff --git a/osfmk/kern/startup.c b/osfmk/kern/startup.c
index 7f94aeb7cb9403ced2f18597a1886612db503189..0972af8e1de5c1c4f2f9f405ac2334f3715b1a37 100644 (file)
--- a/osfmk/kern/startup.c
+++ b/osfmk/kern/startup.c
@@ -75,7 +75,7 @@
 #include <kern/machine.h>
 #include <kern/processor.h>
 #include <kern/sched_prim.h>
 #include <kern/machine.h>
 #include <kern/processor.h>
 #include <kern/sched_prim.h>

-#include <kern/sf.h>
+#include <kern/mk_sp.h>

 #include <kern/startup.h>
 #include <kern/task.h>
 #include <kern/thread.h>
 #include <kern/startup.h>
 #include <kern/task.h>
 #include <kern/thread.h>


@@ -122,7 +122,6 @@ setup_main(void)
        ipc_bootstrap();
        vm_mem_init();
        ipc_init();
        ipc_bootstrap();
        vm_mem_init();
        ipc_init();

-       pager_mux_hash_init();

 
        /*
         * As soon as the virtual memory system is up, we record
 
        /*
         * As soon as the virtual memory system is up, we record


@@ -151,11 +150,9 @@ setup_main(void)
         *      Initialize the IPC, task, and thread subsystems.
         */
        ledger_init();
         *      Initialize the IPC, task, and thread subsystems.
         */
        ledger_init();

-       swapper_init();

        task_init();
        act_init();
        thread_init();
        task_init();
        act_init();
        thread_init();

-       subsystem_init();

 
        /*
         *      Initialize the Event Trace Analysis Package.
 
        /*
         *      Initialize the Event Trace Analysis Package.


@@ -165,23 +162,20 @@ setup_main(void)
        
        /*
         *      Create a kernel thread to start the other kernel
        
        /*
         *      Create a kernel thread to start the other kernel

-        *      threads.  Thread_resume (from kernel_thread) calls
-        *      thread_setrun, which may look at current thread;
-        *      we must avoid this, since there is no current thread.
+        *      threads.

         */
         */

-       startup_thread = kernel_thread_with_priority(kernel_task, MAXPRI_KERNBAND,
-                                                                                       start_kernel_threads, FALSE);
-                                                       
+       startup_thread = kernel_thread_with_priority(
+                                                                               kernel_task, MAXPRI_KERNEL,
+                                                                                       start_kernel_threads, TRUE, FALSE);

        /*
        /*

-        * Pretend it is already running, and resume it.
-        * Since it looks as if it is running, thread_resume
-        * will not try to put it on the run queues.
+        * Pretend it is already running.

         *
         *

-        * We can do all of this without locking, because nothing
+        * We can do this without locking, because nothing

         * else is running yet.
         */
        startup_thread->state = TH_RUN;
         * else is running yet.
         */
        startup_thread->state = TH_RUN;

-       (void) thread_resume(startup_thread->top_act);
+       hw_atomic_add(&startup_thread->processor_set->run_count, 1);
+

        /*
         * Start the thread.
         */
        /*
         * Start the thread.
         */


@@ -206,50 +200,50 @@ start_kernel_threads(void)
         *      service threads.
         */
        for (i = 0; i < NCPUS; i++) {
         *      service threads.
         */
        for (i = 0; i < NCPUS; i++) {

-         if (1 /*machine_slot[i].is_cpu*/) {
-                       processor_t             processor = cpu_to_processor(i);
-                       thread_t                thread;
-                       spl_t                   s;
-
-                       thread = kernel_thread_with_priority(kernel_task,
-                                                                               MAXPRI_KERNBAND, idle_thread, FALSE);
-                       s = splsched();
-                       thread_lock(thread);
-                       thread_bind_locked(thread, processor);
-                       processor->idle_thread = thread;
-                       thread->state |= TH_IDLE;
-                       thread_go_locked(thread, THREAD_AWAKENED);
-                       thread_unlock(thread);
-                       splx(s);
-           }
+               processor_t             processor = cpu_to_processor(i);
+               thread_t                thread;
+               spl_t                   s;
+
+               thread = kernel_thread_with_priority(
+                                                                       kernel_task, MAXPRI_KERNEL,
+                                                                                       idle_thread, TRUE, FALSE);
+               s = splsched();
+               thread_lock(thread);
+               thread_bind_locked(thread, processor);
+               processor->idle_thread = thread;
+               thread->ref_count++;
+               thread->state |= TH_IDLE;
+               thread_go_locked(thread, THREAD_AWAKENED);
+               thread_unlock(thread);
+               splx(s);

        }
 
        /*
        }
 
        /*

-        * Initialize the thread callout mechanism.
+        * Initialize the thread reaper mechanism.

         */
         */

-       thread_call_initialize();
+       thread_reaper_init();

 
        /*
 
        /*

-        * Invoke some black magic.
+        * Initialize the stack swapin mechanism.

         */
         */

-#if __ppc__
-       mapping_adjust();
-#endif
+       swapin_init();

 
        /*
 
        /*

-        *      Invoke the thread reaper mechanism.
+        * Initialize the periodic scheduler mechanism.

         */
         */

-       thread_reaper();
+       sched_tick_init();

 
        /*
 
        /*

-        *      Start the stack swapin thread
+        * Initialize the thread callout mechanism.

         */
         */

-       kernel_thread(kernel_task, swapin_thread);
+       thread_call_initialize();

 
        /*
 
        /*

-        *      Invoke the periodic scheduler mechanism.
+        * Invoke some black magic.

         */
         */

-       kernel_thread(kernel_task, sched_tick_thread);
+#if __ppc__
+       mapping_adjust();
+#endif

 
        /*
         *      Create the clock service.
 
        /*
         *      Create the clock service.


@@ -298,12 +292,17 @@ slave_main(void)
        processor_t             myprocessor = current_processor();
        thread_t                thread;
 
        processor_t             myprocessor = current_processor();
        thread_t                thread;
 

+       myprocessor->cpu_data = get_cpu_data();

        thread = myprocessor->next_thread;
        myprocessor->next_thread = THREAD_NULL;
        if (thread == THREAD_NULL) {
                thread = machine_wake_thread;
                machine_wake_thread = THREAD_NULL;
        }
        thread = myprocessor->next_thread;
        myprocessor->next_thread = THREAD_NULL;
        if (thread == THREAD_NULL) {
                thread = machine_wake_thread;
                machine_wake_thread = THREAD_NULL;
        }

+        thread_machine_set_current(thread);
+       if (thread == machine_wake_thread)
+               thread_bind(thread, myprocessor);
+

        cpu_launch_first_thread(thread);
        /*NOTREACHED*/
        panic("slave_main");
        cpu_launch_first_thread(thread);
        /*NOTREACHED*/
        panic("slave_main");


@@ -326,11 +325,6 @@ start_cpu_thread(void)
                ipc_processor_enable(processor);
        }
 
                ipc_processor_enable(processor);
        }
 

-#if 0
-       printf("start_cpu_thread done on cpu %x\n", cpu_number());
-#endif
-       /* TODO: Mark this processor ready to dispatch threads */
-

        (void) thread_terminate(current_act());
 }
 
        (void) thread_terminate(current_act());
 }
 


@@ -342,18 +336,16 @@ cpu_launch_first_thread(
        thread_t                thread)
 {
        register int    mycpu = cpu_number();
        thread_t                thread)
 {
        register int    mycpu = cpu_number();

+       processor_t             processor = cpu_to_processor(mycpu);

 
 

-       /* initialize preemption disabled */
-       cpu_data[mycpu].preemption_level = 1;
+       processor->cpu_data->preemption_level = 0;

 
        cpu_up(mycpu);
        start_timer(&kernel_timer[mycpu]);
 
        cpu_up(mycpu);
        start_timer(&kernel_timer[mycpu]);

+       clock_get_uptime(&processor->last_dispatch);

 
 

-       if (thread == THREAD_NULL) {
-           thread = cpu_to_processor(mycpu)->idle_thread;
-               if (thread == THREAD_NULL)
-                   panic("cpu_launch_first_thread");
-       }
+       if (thread == THREAD_NULL || thread == processor->idle_thread)
+               panic("cpu_launch_first_thread");

 
        rtclock_reset();                /* start realtime clock ticking */
        PMAP_ACTIVATE_KERNEL(mycpu);
 
        rtclock_reset();                /* start realtime clock ticking */
        PMAP_ACTIVATE_KERNEL(mycpu);


@@ -361,6 +353,9 @@ cpu_launch_first_thread(
        thread_machine_set_current(thread);
        thread_lock(thread);
        thread->state &= ~TH_UNINT;
        thread_machine_set_current(thread);
        thread_lock(thread);
        thread->state &= ~TH_UNINT;

+       thread->last_processor = processor;
+       processor->current_pri = thread->sched_pri;
+       _mk_sp_thread_begin(thread, processor);

        thread_unlock(thread);
        timer_switch(&thread->system_timer);
 
        thread_unlock(thread);
        timer_switch(&thread->system_timer);