xnu-1228.5.18.tar.gz

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

diff --git a/osfmk/kern/processor.c b/osfmk/kern/processor.c
index 6f93f5ef4d706fdeca14fffba0000b868d2f7515..518891c79c9de2144f1babd19ea97f1a765c9fc7 100644 (file)
--- a/osfmk/kern/processor.c
+++ b/osfmk/kern/processor.c
@@ -1,23 +1,29 @@
 /*
 /*

- * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2008 Apple Inc. All rights reserved.

  *
  *

- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

  * 
  * 

- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License").  You may not use this file except in compliance with the
- * License.  Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.

  * 
  * 

- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER

  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
- * License for the specific language governing rights and limitations
- * under the License.
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.

  * 
  * 

- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

  */
 /*
  * @OSF_COPYRIGHT@
  */
 /*
  * @OSF_COPYRIGHT@


@@ -78,32 +84,27 @@
 #include <mach/mach_host_server.h>
 #include <mach/processor_set_server.h>
 
 #include <mach/mach_host_server.h>
 #include <mach/processor_set_server.h>
 

-/*
- *     Exported variables.
- */
-struct processor_set   default_pset;
+struct processor_set   pset0;
+struct pset_node               pset_node0;
+decl_simple_lock_data(static,pset_node_lock)
+
+queue_head_t                   tasks;
+int                                            tasks_count;
+queue_head_t                   threads;
+int                                            threads_count;
+decl_mutex_data(,tasks_threads_lock)

 
 processor_t                            processor_list;
 unsigned int                   processor_count;
 static processor_t             processor_list_tail;
 decl_simple_lock_data(,processor_list_lock)
 
 
 processor_t                            processor_list;
 unsigned int                   processor_count;
 static processor_t             processor_list_tail;
 decl_simple_lock_data(,processor_list_lock)
 

+uint32_t                               processor_avail_count;
+

 processor_t    master_processor;
 int            master_cpu = 0;
 
 /* Forwards */
 processor_t    master_processor;
 int            master_cpu = 0;
 
 /* Forwards */

-kern_return_t  processor_set_base(
-               processor_set_t         pset,
-               policy_t                policy,
-               policy_base_t           base,
-               boolean_t               change);
-
-kern_return_t  processor_set_limit(
-               processor_set_t         pset,
-               policy_t                policy,
-               policy_limit_t          limit,
-               boolean_t               change);
-

 kern_return_t  processor_set_things(
                processor_set_t         pset,
                mach_port_t             **thing_list,
 kern_return_t  processor_set_things(
                processor_set_t         pset,
                mach_port_t             **thing_list,


@@ -113,84 +114,47 @@ kern_return_t     processor_set_things(
 void
 processor_bootstrap(void)
 {
 void
 processor_bootstrap(void)
 {

-       simple_lock_init(&processor_list_lock, 0);
+       pset_init(&pset0, &pset_node0);
+       pset_node0.psets = &pset0;

 
 

-       master_processor = cpu_to_processor(master_cpu);
+       simple_lock_init(&pset_node_lock, 0);

 
 

-       processor_init(master_processor, master_cpu);
-}
+       mutex_init(&tasks_threads_lock, 0);
+       queue_init(&tasks);
+       queue_init(&threads);

 
 

-/*
- *     Initialize the given processor_set structure.
- */
-
-void
-pset_init(
-       register processor_set_t        pset)
-{
-       register int    i;
+       simple_lock_init(&processor_list_lock, 0);

 
 

-       /* setup run queue */
-       pset->runq.highq = IDLEPRI;
-       for (i = 0; i < NRQBM; i++)
-           pset->runq.bitmap[i] = 0;
-       setbit(MAXPRI - IDLEPRI, pset->runq.bitmap); 
-       pset->runq.urgency = pset->runq.count = 0;
-       for (i = 0; i < NRQS; i++)
-           queue_init(&pset->runq.queues[i]);
+       master_processor = cpu_to_processor(master_cpu);

 
 

-       queue_init(&pset->idle_queue);
-       pset->idle_count = 0;
-       queue_init(&pset->active_queue);
-       simple_lock_init(&pset->sched_lock, 0);
-       pset->run_count = pset->share_count = 0;
-       pset->mach_factor = pset->load_average = 0;
-       pset->pri_shift = INT8_MAX;
-       queue_init(&pset->processors);
-       pset->processor_count = 0;
-       queue_init(&pset->tasks);
-       pset->task_count = 0;
-       queue_init(&pset->threads);
-       pset->thread_count = 0;
-       pset->ref_count = 1;
-       pset->active = TRUE;
-       mutex_init(&pset->lock, 0);
-       pset->pset_self = IP_NULL;
-       pset->pset_name_self = IP_NULL;
-       pset->timeshare_quanta = 1;
+       processor_init(master_processor, master_cpu, &pset0);

 }
 
 /*
 }
 
 /*

- *     Initialize the given processor structure for the processor in
- *     the slot specified by slot_num.
+ *     Initialize the given processor for the cpu
+ *     indicated by slot_num, and assign to the
+ *     specified processor set.

  */
 void
 processor_init(
  */
 void
 processor_init(

-       register processor_t    p,
-       int                                             slot_num)
+       processor_t             p,
+       int                             slot_num,
+       processor_set_t pset)

 {
 {

-       register int    i;
-
-       /* setup run queue */
-       p->runq.highq = IDLEPRI;
-       for (i = 0; i < NRQBM; i++)
-           p->runq.bitmap[i] = 0;
-       setbit(MAXPRI - IDLEPRI, p->runq.bitmap); 
-       p->runq.urgency = p->runq.count = 0;
-       for (i = 0; i < NRQS; i++)
-           queue_init(&p->runq.queues[i]);
+       run_queue_init(&p->runq);

 
        p->state = PROCESSOR_OFF_LINE;
        p->active_thread = p->next_thread = p->idle_thread = THREAD_NULL;
 
        p->state = PROCESSOR_OFF_LINE;
        p->active_thread = p->next_thread = p->idle_thread = THREAD_NULL;

-       p->processor_set = PROCESSOR_SET_NULL;
+       p->processor_set = pset;

        p->current_pri = MINPRI;
        p->current_pri = MINPRI;

-       p->deadline = UINT64_MAX;

        timer_call_setup(&p->quantum_timer, thread_quantum_expire, p);
        timer_call_setup(&p->quantum_timer, thread_quantum_expire, p);

+       p->deadline = UINT64_MAX;

        p->timeslice = 0;
        p->timeslice = 0;

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

        p->processor_self = IP_NULL;
        p->processor_self = IP_NULL;

+       simple_lock_init(&p->lock, 0);

        processor_data_init(p);
        PROCESSOR_DATA(p, slot_num) = slot_num;
        processor_data_init(p);
        PROCESSOR_DATA(p, slot_num) = slot_num;

+       p->processor_list = NULL;

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


@@ -199,167 +163,65 @@ processor_init(
                processor_list_tail->processor_list = p;
        processor_list_tail = p;
        processor_count++;
                processor_list_tail->processor_list = p;
        processor_list_tail = p;
        processor_count++;

-       p->processor_list = NULL;

        simple_unlock(&processor_list_lock);
 }
 
        simple_unlock(&processor_list_lock);
 }
 

-/*
- *     pset_deallocate:
- *
- *     Remove one reference to the processor set.  Destroy processor_set
- *     if this was the last reference.
- */
-void
-pset_deallocate(
-       processor_set_t pset)
+processor_set_t
+processor_pset(
+       processor_t     processor)

 {
 {

-       if (pset == PROCESSOR_SET_NULL)
-               return;
-
-       assert(pset == &default_pset);
-       return;
+       return (processor->processor_set);

 }
 
 }
 

-/*
- *     pset_reference:
- *
- *     Add one reference to the processor set.
- */
-void
-pset_reference(
-       processor_set_t pset)
+pset_node_t
+pset_node_root(void)

 {
 {

-       if (pset == PROCESSOR_SET_NULL)
-               return;
-
-       assert(pset == &default_pset);
+       return &pset_node0;

 }
 
 }
 

-#define pset_reference_locked(pset) assert(pset == &default_pset)
-
-/*
- *     pset_remove_processor() removes a processor from a processor_set.
- *     It can only be called on the current processor.  Caller must
- *     hold lock on current processor and processor set.
- */
-void
-pset_remove_processor(
-       processor_set_t pset,
-       processor_t     processor)
+processor_set_t
+pset_create(
+       pset_node_t                     node)

 {
 {

-       if (pset != processor->processor_set)
-               panic("pset_remove_processor: wrong pset");
+       processor_set_t         *prev, pset = kalloc(sizeof (*pset));

 
 

-       queue_remove(&pset->processors, processor, processor_t, processors);
-       processor->processor_set = PROCESSOR_SET_NULL;
-       pset->processor_count--;
-       timeshare_quanta_update(pset);
-}
+       if (pset != PROCESSOR_SET_NULL) {
+               pset_init(pset, node);

 
 

-/*
- *     pset_add_processor() adds a  processor to a processor_set.
- *     It can only be called on the current processor.  Caller must
- *     hold lock on curent processor and on pset.  No reference counting on
- *     processors.  Processor reference to pset is implicit.
- */
-void
-pset_add_processor(
-       processor_set_t pset,
-       processor_t     processor)
-{
-       queue_enter(&pset->processors, processor, processor_t, processors);
-       processor->processor_set = pset;
-       pset->processor_count++;
-       timeshare_quanta_update(pset);
-}
+               simple_lock(&pset_node_lock);

 
 

-/*
- *     pset_remove_task() removes a task from a processor_set.
- *     Caller must hold locks on pset and task (unless task has
- *     no references left, in which case just the pset lock is
- *     needed).  Pset reference count is not decremented;
- *     caller must explicitly pset_deallocate.
- */
-void
-pset_remove_task(
-       processor_set_t pset,
-       task_t          task)
-{
-       if (pset != task->processor_set)
-               return;
+               prev = &node->psets;
+               while (*prev != PROCESSOR_SET_NULL)
+                       prev = &(*prev)->pset_list;

 
 

-       queue_remove(&pset->tasks, task, task_t, pset_tasks);
-       pset->task_count--;
-}
+               *prev = pset;

 
 

-/*
- *     pset_add_task() adds a  task to a processor_set.
- *     Caller must hold locks on pset and task.  Pset references to
- *     tasks are implicit.
- */
-void
-pset_add_task(
-       processor_set_t pset,
-       task_t          task)
-{
-       queue_enter(&pset->tasks, task, task_t, pset_tasks);
-       task->processor_set = pset;
-       pset->task_count++;
-       pset_reference_locked(pset);
-}
+               simple_unlock(&pset_node_lock);
+       }

 
 

-/*
- *     pset_remove_thread() removes a thread from a processor_set.
- *     Caller must hold locks on pset and thread (but only if thread
- *  has outstanding references that could be used to lookup the pset).
- *  The pset reference count is not decremented; caller must explicitly
- *  pset_deallocate.
- */
-void
-pset_remove_thread(
-       processor_set_t pset,
-       thread_t        thread)
-{
-       queue_remove(&pset->threads, thread, thread_t, pset_threads);
-       pset->thread_count--;
+       return (pset);

 }
 
 /*
 }
 
 /*

- *     pset_add_thread() adds a  thread to a processor_set.
- *     Caller must hold locks on pset and thread.  Pset references to
- *     threads are implicit.
+ *     Initialize the given processor_set structure.

  */
 void
  */
 void

-pset_add_thread(
-       processor_set_t pset,
-       thread_t        thread)
+pset_init(
+       processor_set_t         pset,
+       pset_node_t                     node)

 {
 {

-       queue_enter(&pset->threads, thread, thread_t, pset_threads);
-       thread->processor_set = pset;
-       pset->thread_count++;
-       pset_reference_locked(pset);
+       queue_init(&pset->active_queue);
+       queue_init(&pset->idle_queue);
+       pset->idle_count = 0;
+       pset->processor_count = 0;
+       pset->low_pri = PROCESSOR_NULL;
+       pset_lock_init(pset);
+       pset->pset_self = IP_NULL;
+       pset->pset_name_self = IP_NULL;
+       pset->pset_list = PROCESSOR_SET_NULL;
+       pset->node = node;

 }
 
 }
 

-/*
- *     thread_change_psets() changes the pset of a thread.  Caller must
- *     hold locks on both psets and thread.  The old pset must be
- *     explicitly pset_deallocat()'ed by caller.
- */
-void
-thread_change_psets(
-       thread_t        thread,
-       processor_set_t old_pset,
-       processor_set_t new_pset)
-{
-       queue_remove(&old_pset->threads, thread, thread_t, pset_threads);
-       old_pset->thread_count--;
-       queue_enter(&new_pset->threads, thread, thread_t, pset_threads);
-       thread->processor_set = new_pset;
-       new_pset->thread_count++;
-       pset_reference_locked(new_pset);
-}      
-
-

 kern_return_t
 processor_info_count(
        processor_flavor_t              flavor,
 kern_return_t
 processor_info_count(
        processor_flavor_t              flavor,


@@ -391,7 +253,7 @@ processor_info(
        processor_info_t                info,
        mach_msg_type_number_t  *count)
 {
        processor_info_t                info,
        mach_msg_type_number_t  *count)
 {

-       register int    i, slot_num, state;
+       register int    slot_num, state;

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


@@ -431,15 +293,18 @@ processor_info(
        case PROCESSOR_CPU_LOAD_INFO:
        {
                register processor_cpu_load_info_t      cpu_load_info;
        case PROCESSOR_CPU_LOAD_INFO:
        {
                register processor_cpu_load_info_t      cpu_load_info;

-               register integer_t                                      *cpu_ticks;

 
            if (*count < PROCESSOR_CPU_LOAD_INFO_COUNT)
                        return (KERN_FAILURE);
 
            cpu_load_info = (processor_cpu_load_info_t) info;
 
            if (*count < PROCESSOR_CPU_LOAD_INFO_COUNT)
                        return (KERN_FAILURE);
 
            cpu_load_info = (processor_cpu_load_info_t) info;

-               cpu_ticks = PROCESSOR_DATA(processor, cpu_ticks);
-           for (i=0; i < CPU_STATE_MAX; i++)
-                       cpu_load_info->cpu_ticks[i] = cpu_ticks[i];
+               cpu_load_info->cpu_ticks[CPU_STATE_USER] =
+                                                       timer_grab(&PROCESSOR_DATA(processor, user_state)) / hz_tick_interval;
+               cpu_load_info->cpu_ticks[CPU_STATE_SYSTEM] =
+                                                       timer_grab(&PROCESSOR_DATA(processor, system_state)) / hz_tick_interval;
+               cpu_load_info->cpu_ticks[CPU_STATE_IDLE] =
+                                                       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;
            *host = &realhost;
 
            *count = PROCESSOR_CPU_LOAD_INFO_COUNT;
            *host = &realhost;


@@ -458,40 +323,41 @@ processor_info(
 
 kern_return_t
 processor_start(
 
 kern_return_t
 processor_start(

-       processor_t     processor)
+       processor_t                     processor)

 {
 {

-       kern_return_t   result;
-       thread_t                thread;   
-       spl_t                   s;
+       processor_set_t         pset;
+       thread_t                        thread;   
+       kern_return_t           result;
+       spl_t                           s;

 
 

-       if (processor == PROCESSOR_NULL)
+       if (processor == PROCESSOR_NULL || processor->processor_set == PROCESSOR_SET_NULL)

                return (KERN_INVALID_ARGUMENT);
 
        if (processor == master_processor) {
                return (KERN_INVALID_ARGUMENT);
 
        if (processor == master_processor) {

-               thread_t                self = current_thread();

                processor_t             prev;
 
                processor_t             prev;
 

-               prev = thread_bind(self, processor);
+               prev = thread_bind(processor);

                thread_block(THREAD_CONTINUE_NULL);
 
                result = cpu_start(PROCESSOR_DATA(processor, slot_num));
 
                thread_block(THREAD_CONTINUE_NULL);
 
                result = cpu_start(PROCESSOR_DATA(processor, slot_num));
 

-               thread_bind(self, prev);
+               thread_bind(prev);

 
                return (result);
        }
 
        s = splsched();
 
                return (result);
        }
 
        s = splsched();

-       processor_lock(processor);
+       pset = processor->processor_set;
+       pset_lock(pset);

        if (processor->state != PROCESSOR_OFF_LINE) {
        if (processor->state != PROCESSOR_OFF_LINE) {

-               processor_unlock(processor);
+               pset_unlock(pset);

                splx(s);
 
                return (KERN_FAILURE);
        }
 
        processor->state = PROCESSOR_START;
                splx(s);
 
                return (KERN_FAILURE);
        }
 
        processor->state = PROCESSOR_START;

-       processor_unlock(processor);
+       pset_unlock(pset);

        splx(s);
 
        /*
        splx(s);
 
        /*


@@ -501,9 +367,9 @@ processor_start(
                result = idle_thread_create(processor);
                if (result != KERN_SUCCESS) {
                        s = splsched();
                result = idle_thread_create(processor);
                if (result != KERN_SUCCESS) {
                        s = splsched();

-                       processor_lock(processor);
+                       pset_lock(pset);

                        processor->state = PROCESSOR_OFF_LINE;
                        processor->state = PROCESSOR_OFF_LINE;

-                       processor_unlock(processor);
+                       pset_unlock(pset);

                        splx(s);
 
                        return (result);
                        splx(s);
 
                        return (result);


@@ -520,9 +386,9 @@ processor_start(
                result = kernel_thread_create((thread_continue_t)processor_start_thread, NULL, MAXPRI_KERNEL, &thread);
                if (result != KERN_SUCCESS) {
                        s = splsched();
                result = kernel_thread_create((thread_continue_t)processor_start_thread, NULL, MAXPRI_KERNEL, &thread);
                if (result != KERN_SUCCESS) {
                        s = splsched();

-                       processor_lock(processor);
+                       pset_lock(pset);

                        processor->state = PROCESSOR_OFF_LINE;
                        processor->state = PROCESSOR_OFF_LINE;

-                       processor_unlock(processor);
+                       pset_unlock(pset);

                        splx(s);
 
                        return (result);
                        splx(s);
 
                        return (result);


@@ -545,10 +411,10 @@ processor_start(
        result = cpu_start(PROCESSOR_DATA(processor, slot_num));
        if (result != KERN_SUCCESS) {
                s = splsched();
        result = cpu_start(PROCESSOR_DATA(processor, slot_num));
        if (result != KERN_SUCCESS) {
                s = splsched();

-               processor_lock(processor);
+               pset_lock(pset);

                processor->state = PROCESSOR_OFF_LINE;
                timer_call_shutdown(processor);
                processor->state = PROCESSOR_OFF_LINE;
                timer_call_shutdown(processor);

-               processor_unlock(processor);
+               pset_unlock(pset);

                splx(s);
 
                return (result);
                splx(s);
 
                return (result);


@@ -580,28 +446,6 @@ processor_control(
 
        return(cpu_control(PROCESSOR_DATA(processor, slot_num), info, count));
 }
 
        return(cpu_control(PROCESSOR_DATA(processor, slot_num), info, count));
 }

-
-/*
- *     Calculate the appropriate timesharing quanta based on set load.
- */
-
-void
-timeshare_quanta_update(
-       processor_set_t         pset)
-{
-       int             pcount = pset->processor_count;
-       int             i = pset->runq.count;
-
-       if (i >= pcount)
-               i = 1;
-       else
-       if (i <= 1)
-               i = pcount;
-       else
-               i = (pcount + (i / 2)) / i;
-
-       pset->timeshare_quanta = i;
-}

            
 kern_return_t
 processor_set_create(
            
 kern_return_t
 processor_set_create(


@@ -624,14 +468,14 @@ processor_get_assignment(
        processor_t     processor,
        processor_set_t *pset)
 {
        processor_t     processor,
        processor_set_t *pset)
 {

-       int state;
+       int state;

 
        state = processor->state;
        if (state == PROCESSOR_SHUTDOWN || state == PROCESSOR_OFF_LINE)
                return(KERN_FAILURE);
 
 
        state = processor->state;
        if (state == PROCESSOR_SHUTDOWN || state == PROCESSOR_OFF_LINE)
                return(KERN_FAILURE);
 

-       *pset = processor->processor_set;
-       pset_reference(*pset);
+       *pset = &pset0;
+

        return(KERN_SUCCESS);
 }
 
        return(KERN_SUCCESS);
 }
 


@@ -653,7 +497,7 @@ processor_set_info(
                        return(KERN_FAILURE);
 
                basic_info = (processor_set_basic_info_t) info;
                        return(KERN_FAILURE);
 
                basic_info = (processor_set_basic_info_t) info;

-               basic_info->processor_count = pset->processor_count;
+               basic_info->processor_count = processor_avail_count;

                basic_info->default_policy = POLICY_TIMESHARE;
 
                *count = PROCESSOR_SET_BASIC_INFO_COUNT;
                basic_info->default_policy = POLICY_TIMESHARE;
 
                *count = PROCESSOR_SET_BASIC_INFO_COUNT;


@@ -770,29 +614,28 @@ processor_set_statistics(
        processor_set_info_t    info,
        mach_msg_type_number_t  *count)
 {
        processor_set_info_t    info,
        mach_msg_type_number_t  *count)
 {

-        if (pset == PROCESSOR_SET_NULL)
-                return (KERN_INVALID_PROCESSOR_SET);
+       if (pset == PROCESSOR_SET_NULL || pset != &pset0)
+               return (KERN_INVALID_PROCESSOR_SET);
+
+       if (flavor == PROCESSOR_SET_LOAD_INFO) {
+               register processor_set_load_info_t     load_info;

 
 

-        if (flavor == PROCESSOR_SET_LOAD_INFO) {
-                register processor_set_load_info_t     load_info;
+               if (*count < PROCESSOR_SET_LOAD_INFO_COUNT)
+                       return(KERN_FAILURE);

 
 

-                if (*count < PROCESSOR_SET_LOAD_INFO_COUNT)
-                        return(KERN_FAILURE);
+               load_info = (processor_set_load_info_t) info;

 
 

-                load_info = (processor_set_load_info_t) info;
+               load_info->mach_factor = sched_mach_factor;
+               load_info->load_average = sched_load_average;

 
 

-                pset_lock(pset);
-                load_info->task_count = pset->task_count;
-                load_info->thread_count = pset->thread_count;
-                load_info->mach_factor = pset->mach_factor;
-                load_info->load_average = pset->load_average;
-                pset_unlock(pset);
+               load_info->task_count = tasks_count;
+               load_info->thread_count = threads_count;

 
 

-                *count = PROCESSOR_SET_LOAD_INFO_COUNT;
-                return(KERN_SUCCESS);
-        }
+               *count = PROCESSOR_SET_LOAD_INFO_COUNT;
+               return(KERN_SUCCESS);
+       }

 
 

-        return(KERN_INVALID_ARGUMENT);
+       return(KERN_INVALID_ARGUMENT);

 }
 
 /*
 }
 
 /*


@@ -862,23 +705,19 @@ processor_set_things(
        vm_size_t size, size_needed;
        void  *addr;
 
        vm_size_t size, size_needed;
        void  *addr;
 

-       if (pset == PROCESSOR_SET_NULL)
+       if (pset == PROCESSOR_SET_NULL || pset != &pset0)

                return (KERN_INVALID_ARGUMENT);
 
                return (KERN_INVALID_ARGUMENT);
 

-       size = 0; addr = 0;
+       size = 0;
+       addr = NULL;

 
        for (;;) {
 
        for (;;) {

-               pset_lock(pset);
-               if (!pset->active) {
-                       pset_unlock(pset);
-
-                       return (KERN_FAILURE);
-               }
+               mutex_lock(&tasks_threads_lock);

 
                if (type == THING_TASK)
 
                if (type == THING_TASK)

-                       maxthings = pset->task_count;
+                       maxthings = tasks_count;

                else
                else

-                       maxthings = pset->thread_count;
+                       maxthings = threads_count;

 
                /* do we have the memory we need? */
 
 
                /* do we have the memory we need? */
 


@@ -886,8 +725,8 @@ processor_set_things(
                if (size_needed <= size)
                        break;
 
                if (size_needed <= size)
                        break;
 

-               /* unlock the pset and allocate more memory */
-               pset_unlock(pset);
+               /* unlock and allocate more memory */
+               mutex_unlock(&tasks_threads_lock);

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


@@ -900,48 +739,53 @@ processor_set_things(
                        return (KERN_RESOURCE_SHORTAGE);
        }
 
                        return (KERN_RESOURCE_SHORTAGE);
        }
 

-       /* OK, have memory and the processor_set is locked & active */
+       /* OK, have memory and the list locked */

 
        actual = 0;
        switch (type) {
 
 
        actual = 0;
        switch (type) {
 

-       case THING_TASK:
-       {
-               task_t          task, *tasks = (task_t *)addr;
-
-               for (task = (task_t)queue_first(&pset->tasks);
-                               !queue_end(&pset->tasks, (queue_entry_t)task);
-                                       task = (task_t)queue_next(&task->pset_tasks)) {
-                       task_reference_internal(task);
-                       tasks[actual++] = task;
+       case THING_TASK: {
+               task_t          task, *task_list = (task_t *)addr;
+
+               for (task = (task_t)queue_first(&tasks);
+                                               !queue_end(&tasks, (queue_entry_t)task);
+                                                               task = (task_t)queue_next(&task->tasks)) {
+#if defined(SECURE_KERNEL)
+                       if (task != kernel_task) {
+#endif
+                               task_reference_internal(task);
+                               task_list[actual++] = task;
+#if defined(SECURE_KERNEL)
+                       }
+#endif

                }
 
                break;
        }
 
                }
 
                break;
        }
 

-       case THING_THREAD:
-       {
-               thread_t        thread, *threads = (thread_t *)addr;
+       case THING_THREAD: {
+               thread_t        thread, *thread_list = (thread_t *)addr;

 
 

-               for (i = 0, thread = (thread_t)queue_first(&pset->threads);
-                               !queue_end(&pset->threads, (queue_entry_t)thread);
-                                       thread = (thread_t)queue_next(&thread->pset_threads)) {
+               for (thread = (thread_t)queue_first(&threads);
+                                               !queue_end(&threads, (queue_entry_t)thread);
+                                                               thread = (thread_t)queue_next(&thread->threads)) {

                        thread_reference_internal(thread);
                        thread_reference_internal(thread);

-                       threads[actual++] = thread;
+                       thread_list[actual++] = thread;

                }
 
                break;
        }
                }
 
                break;
        }

+

        }
                
        }
                

-       pset_unlock(pset);
+       mutex_unlock(&tasks_threads_lock);

 
        if (actual < maxthings)
                size_needed = actual * sizeof (mach_port_t);
 
        if (actual == 0) {
                /* no things, so return null pointer and deallocate memory */
 
        if (actual < maxthings)
                size_needed = actual * sizeof (mach_port_t);
 
        if (actual == 0) {
                /* no things, so return null pointer and deallocate memory */

-               *thing_list = 0;
+               *thing_list = NULL;

                *count = 0;
 
                if (size != 0)
                *count = 0;
 
                if (size != 0)


@@ -957,23 +801,22 @@ processor_set_things(
                        if (newaddr == 0) {
                                switch (type) {
 
                        if (newaddr == 0) {
                                switch (type) {
 

-                               case THING_TASK:
-                               {
-                                       task_t          *tasks = (task_t *)addr;
+                               case THING_TASK: {
+                                       task_t          *task_list = (task_t *)addr;

 
                                        for (i = 0; i < actual; i++)
 
                                        for (i = 0; i < actual; i++)

-                                               task_deallocate(tasks[i]);
+                                               task_deallocate(task_list[i]);

                                        break;
                                }
 
                                        break;
                                }
 

-                               case THING_THREAD:
-                               {
-                                       thread_t        *threads = (thread_t *)addr;
+                               case THING_THREAD: {
+                                       thread_t        *thread_list = (thread_t *)addr;

 
                                        for (i = 0; i < actual; i++)
 
                                        for (i = 0; i < actual; i++)

-                                               thread_deallocate(threads[i]);
+                                               thread_deallocate(thread_list[i]);

                                        break;
                                }
                                        break;
                                }

+

                                }
 
                                kfree(addr, size);
                                }
 
                                kfree(addr, size);


@@ -992,23 +835,22 @@ processor_set_things(
 
                switch (type) {
 
 
                switch (type) {
 

-               case THING_TASK:
-               {
-                       task_t          *tasks = (task_t *)addr;
+               case THING_TASK: {
+                       task_t          *task_list = (task_t *)addr;

 
                        for (i = 0; i < actual; i++)
 
                        for (i = 0; i < actual; i++)

-                               (*thing_list)[i] = convert_task_to_port(tasks[i]);
+                               (*thing_list)[i] = convert_task_to_port(task_list[i]);

                        break;
                }
 
                        break;
                }
 

-               case THING_THREAD:
-               {
-                       thread_t        *threads = (thread_t *)addr;
+               case THING_THREAD: {
+                       thread_t        *thread_list = (thread_t *)addr;

 
                        for (i = 0; i < actual; i++)
 
                        for (i = 0; i < actual; i++)

-                               (*thing_list)[i] = convert_thread_to_port(threads[i]);
+                               (*thing_list)[i] = convert_thread_to_port(thread_list[i]);

                        break;
                }
                        break;
                }

+

                }
        }
 
                }
        }
 


@@ -1035,6 +877,16 @@ processor_set_tasks(
  *
  *     List all threads in the processor set.
  */
  *
  *     List all threads in the processor set.
  */

+#if defined(SECURE_KERNEL)
+kern_return_t
+processor_set_threads(
+       __unused processor_set_t                pset,
+       __unused thread_array_t         *thread_list,
+       __unused mach_msg_type_number_t *count)
+{
+    return KERN_FAILURE;
+}
+#else

 kern_return_t
 processor_set_threads(
        processor_set_t         pset,
 kern_return_t
 processor_set_threads(
        processor_set_t         pset,


@@ -1043,40 +895,7 @@ processor_set_threads(
 {
     return(processor_set_things(pset, (mach_port_t **)thread_list, count, THING_THREAD));
 }
 {
     return(processor_set_things(pset, (mach_port_t **)thread_list, count, THING_THREAD));
 }

-
-/*
- *      processor_set_base:
- *
- *      Specify per-policy base priority for a processor set.  Set processor
- *     set default policy to the given policy. This affects newly created
- *      and assigned threads.  Optionally change existing ones.
- */
-kern_return_t
-processor_set_base(
-       __unused processor_set_t        pset,
-       __unused policy_t               policy,
-       __unused policy_base_t  base,
-       __unused boolean_t              change)
-{
-       return (KERN_INVALID_ARGUMENT);
-}
-
-/*
- *      processor_set_limit:
- *
- *      Specify per-policy limits for a processor set.  This affects
- *      newly created and assigned threads.  Optionally change existing
- *      ones.
- */
-kern_return_t
-processor_set_limit(
-       __unused processor_set_t        pset,
-       __unused policy_t               policy,
-       __unused policy_limit_t         limit,
-       __unused boolean_t              change)
-{
-       return (KERN_POLICY_LIMIT);
-}
+#endif

 
 /*
  *     processor_set_policy_control
 
 /*
  *     processor_set_policy_control


@@ -1095,3 +914,21 @@ processor_set_policy_control(
 {
        return (KERN_INVALID_ARGUMENT);
 }
 {
        return (KERN_INVALID_ARGUMENT);
 }

+
+#undef pset_deallocate
+void pset_deallocate(processor_set_t pset);
+void
+pset_deallocate(
+__unused processor_set_t       pset)
+{
+       return;
+}
+
+#undef pset_reference
+void pset_reference(processor_set_t pset);
+void
+pset_reference(
+__unused processor_set_t       pset)
+{
+       return;
+}