xnu-1504.9.37.tar.gz

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

diff --git a/osfmk/kern/processor.c b/osfmk/kern/processor.c
index 9436505b341d4e763cfa214f7a56735c9ddf3322..ca65ceca63674b73db6d379aa313b2c54f25382e 100644 (file)
--- a/osfmk/kern/processor.c
+++ b/osfmk/kern/processor.c
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 2000-2008 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2009 Apple Inc. All rights reserved.

  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 


@@ -92,7 +92,7 @@ queue_head_t                  tasks;
 int                                            tasks_count;
 queue_head_t                   threads;
 int                                            threads_count;
 int                                            tasks_count;
 queue_head_t                   threads;
 int                                            threads_count;

-decl_mutex_data(,tasks_threads_lock)
+decl_lck_mtx_data(,tasks_threads_lock)

 
 processor_t                            processor_list;
 unsigned int                   processor_count;
 
 processor_t                            processor_list;
 unsigned int                   processor_count;


@@ -101,8 +101,8 @@ decl_simple_lock_data(,processor_list_lock)
 
 uint32_t                               processor_avail_count;
 
 
 uint32_t                               processor_avail_count;
 

-processor_t    master_processor;
-int            master_cpu = 0;
+processor_t            master_processor;
+int                    master_cpu = 0;

 
 /* Forwards */
 kern_return_t  processor_set_things(
 
 /* Forwards */
 kern_return_t  processor_set_things(


@@ -119,7 +119,6 @@ processor_bootstrap(void)
 
        simple_lock_init(&pset_node_lock, 0);
 
 
        simple_lock_init(&pset_node_lock, 0);
 

-       mutex_init(&tasks_threads_lock, 0);

        queue_init(&tasks);
        queue_init(&threads);
 
        queue_init(&tasks);
        queue_init(&threads);
 


@@ -132,13 +131,13 @@ processor_bootstrap(void)
 
 /*
  *     Initialize the given processor for the cpu
 
 /*
  *     Initialize the given processor for the cpu

- *     indicated by cpu_num, and assign to the
+ *     indicated by cpu_id, and assign to the

  *     specified processor set.
  */
 void
 processor_init(
        processor_t                     processor,
  *     specified processor set.
  */
 void
 processor_init(
        processor_t                     processor,

-       int                                     cpu_num,
+       int                                     cpu_id,

        processor_set_t         pset)
 {
        run_queue_init(&processor->runq);
        processor_set_t         pset)
 {
        run_queue_init(&processor->runq);


@@ -147,15 +146,24 @@ processor_init(
        processor->active_thread = processor->next_thread = processor->idle_thread = THREAD_NULL;
        processor->processor_set = pset;
        processor->current_pri = MINPRI;
        processor->active_thread = processor->next_thread = processor->idle_thread = THREAD_NULL;
        processor->processor_set = pset;
        processor->current_pri = MINPRI;

-       processor->cpu_num = cpu_num;
+       processor->cpu_id = cpu_id;

        timer_call_setup(&processor->quantum_timer, thread_quantum_expire, processor);
        processor->deadline = UINT64_MAX;
        processor->timeslice = 0;
        timer_call_setup(&processor->quantum_timer, thread_quantum_expire, processor);
        processor->deadline = UINT64_MAX;
        processor->timeslice = 0;

+       processor->processor_meta = PROCESSOR_META_NULL;

        processor->processor_self = IP_NULL;
        processor->processor_self = IP_NULL;

-       simple_lock_init(&processor->lock, 0);

        processor_data_init(processor);
        processor->processor_list = NULL;
 
        processor_data_init(processor);
        processor->processor_list = NULL;
 

+       pset_lock(pset);
+       if (pset->cpu_set_count++ == 0)
+               pset->cpu_set_low = pset->cpu_set_hi = cpu_id;
+       else {
+               pset->cpu_set_low = (cpu_id < pset->cpu_set_low)? cpu_id: pset->cpu_set_low;
+               pset->cpu_set_hi = (cpu_id > pset->cpu_set_hi)? cpu_id: pset->cpu_set_hi;
+       }
+       pset_unlock(pset);
+

        simple_lock(&processor_list_lock);
        if (processor_list == NULL)
                processor_list = processor;
        simple_lock(&processor_list_lock);
        if (processor_list == NULL)
                processor_list = processor;


@@ -166,6 +174,24 @@ processor_init(
        simple_unlock(&processor_list_lock);
 }
 
        simple_unlock(&processor_list_lock);
 }
 

+void
+processor_meta_init(
+       processor_t             processor,
+       processor_t             primary)
+{
+       processor_meta_t        pmeta = primary->processor_meta;
+
+       if (pmeta == PROCESSOR_META_NULL) {
+               pmeta = kalloc(sizeof (*pmeta));
+
+               queue_init(&pmeta->idle_queue);
+
+               pmeta->primary = primary;
+       }
+
+       processor->processor_meta = pmeta;
+}
+

 processor_set_t
 processor_pset(
        processor_t     processor)
 processor_set_t
 processor_pset(
        processor_t     processor)


@@ -214,6 +240,8 @@ pset_init(
        queue_init(&pset->idle_queue);
        pset->processor_count = 0;
        pset->low_pri = pset->low_count = PROCESSOR_NULL;
        queue_init(&pset->idle_queue);
        pset->processor_count = 0;
        pset->low_pri = pset->low_count = PROCESSOR_NULL;

+       pset->cpu_set_low = pset->cpu_set_hi = 0;
+       pset->cpu_set_count = 0;

        pset_lock_init(pset);
        pset->pset_self = IP_NULL;
        pset->pset_name_self = IP_NULL;
        pset_lock_init(pset);
        pset->pset_self = IP_NULL;
        pset->pset_name_self = IP_NULL;


@@ -252,13 +280,13 @@ processor_info(
        processor_info_t                info,
        mach_msg_type_number_t  *count)
 {
        processor_info_t                info,
        mach_msg_type_number_t  *count)
 {

-       register int    cpu_num, state;
+       register int    cpu_id, state;

        kern_return_t   result;
 
        if (processor == PROCESSOR_NULL)
                return (KERN_INVALID_ARGUMENT);
 
        kern_return_t   result;
 
        if (processor == PROCESSOR_NULL)
                return (KERN_INVALID_ARGUMENT);
 

-       cpu_num = processor->cpu_num;
+       cpu_id = processor->cpu_id;

 
        switch (flavor) {
 
 
        switch (flavor) {
 


@@ -270,14 +298,14 @@ processor_info(
                        return (KERN_FAILURE);
 
                basic_info = (processor_basic_info_t) info;
                        return (KERN_FAILURE);
 
                basic_info = (processor_basic_info_t) info;

-               basic_info->cpu_type = slot_type(cpu_num);
-               basic_info->cpu_subtype = slot_subtype(cpu_num);
+               basic_info->cpu_type = slot_type(cpu_id);
+               basic_info->cpu_subtype = slot_subtype(cpu_id);

                state = processor->state;
                if (state == PROCESSOR_OFF_LINE)
                        basic_info->running = FALSE;
                else
                        basic_info->running = TRUE;
                state = processor->state;
                if (state == PROCESSOR_OFF_LINE)
                        basic_info->running = FALSE;
                else
                        basic_info->running = TRUE;

-               basic_info->slot_num = cpu_num;
+               basic_info->slot_num = cpu_id;

                if (processor == master_processor) 
                        basic_info->is_master = TRUE;
                else
                if (processor == master_processor) 
                        basic_info->is_master = TRUE;
                else


@@ -298,11 +326,11 @@ processor_info(
 
            cpu_load_info = (processor_cpu_load_info_t) info;
                cpu_load_info->cpu_ticks[CPU_STATE_USER] =
 
            cpu_load_info = (processor_cpu_load_info_t) info;
                cpu_load_info->cpu_ticks[CPU_STATE_USER] =

-                                                       timer_grab(&PROCESSOR_DATA(processor, user_state)) / hz_tick_interval;
+                                                       (uint32_t)(timer_grab(&PROCESSOR_DATA(processor, user_state)) / hz_tick_interval);

                cpu_load_info->cpu_ticks[CPU_STATE_SYSTEM] =
                cpu_load_info->cpu_ticks[CPU_STATE_SYSTEM] =

-                                                       timer_grab(&PROCESSOR_DATA(processor, system_state)) / hz_tick_interval;
+                                                       (uint32_t)(timer_grab(&PROCESSOR_DATA(processor, system_state)) / hz_tick_interval);

                cpu_load_info->cpu_ticks[CPU_STATE_IDLE] =
                cpu_load_info->cpu_ticks[CPU_STATE_IDLE] =

-                                                       timer_grab(&PROCESSOR_DATA(processor, idle_state)) / hz_tick_interval;
+                                                       (uint32_t)(timer_grab(&PROCESSOR_DATA(processor, idle_state)) / hz_tick_interval);

                cpu_load_info->cpu_ticks[CPU_STATE_NICE] = 0;
 
            *count = PROCESSOR_CPU_LOAD_INFO_COUNT;
                cpu_load_info->cpu_ticks[CPU_STATE_NICE] = 0;
 
            *count = PROCESSOR_CPU_LOAD_INFO_COUNT;


@@ -312,7 +340,7 @@ processor_info(
        }
 
        default:
        }
 
        default:

-           result = cpu_info(flavor, cpu_num, info, count);
+           result = cpu_info(flavor, cpu_id, info, count);

            if (result == KERN_SUCCESS)
                        *host = &realhost;                 
 
            if (result == KERN_SUCCESS)
                        *host = &realhost;                 
 


@@ -338,7 +366,7 @@ processor_start(
                prev = thread_bind(processor);
                thread_block(THREAD_CONTINUE_NULL);
 
                prev = thread_bind(processor);
                thread_block(THREAD_CONTINUE_NULL);
 

-               result = cpu_start(processor->cpu_num);
+               result = cpu_start(processor->cpu_id);

 
                thread_bind(prev);
 
 
                thread_bind(prev);
 


@@ -407,7 +435,7 @@ processor_start(
        if (processor->processor_self == IP_NULL)
                ipc_processor_init(processor);
 
        if (processor->processor_self == IP_NULL)
                ipc_processor_init(processor);
 

-       result = cpu_start(processor->cpu_num);
+       result = cpu_start(processor->cpu_id);

        if (result != KERN_SUCCESS) {
                s = splsched();
                pset_lock(pset);
        if (result != KERN_SUCCESS) {
                s = splsched();
                pset_lock(pset);


@@ -442,7 +470,7 @@ processor_control(
        if (processor == PROCESSOR_NULL)
                return(KERN_INVALID_ARGUMENT);
 
        if (processor == PROCESSOR_NULL)
                return(KERN_INVALID_ARGUMENT);
 

-       return(cpu_control(processor->cpu_num, info, count));
+       return(cpu_control(processor->cpu_id, info, count));

 }
            
 kern_return_t
 }
            
 kern_return_t


@@ -710,7 +738,7 @@ processor_set_things(
        addr = NULL;
 
        for (;;) {
        addr = NULL;
 
        for (;;) {

-               mutex_lock(&tasks_threads_lock);
+               lck_mtx_lock(&tasks_threads_lock);

 
                if (type == THING_TASK)
                        maxthings = tasks_count;
 
                if (type == THING_TASK)
                        maxthings = tasks_count;


@@ -724,7 +752,7 @@ processor_set_things(
                        break;
 
                /* unlock and allocate more memory */
                        break;
 
                /* unlock and allocate more memory */

-               mutex_unlock(&tasks_threads_lock);
+               lck_mtx_unlock(&tasks_threads_lock);

 
                if (size != 0)
                        kfree(addr, size);
 
                if (size != 0)
                        kfree(addr, size);


@@ -776,7 +804,7 @@ processor_set_things(
 
        }
                
 
        }
                

-       mutex_unlock(&tasks_threads_lock);
+       lck_mtx_unlock(&tasks_threads_lock);

 
        if (actual < maxthings)
                size_needed = actual * sizeof (mach_port_t);
 
        if (actual < maxthings)
                size_needed = actual * sizeof (mach_port_t);