Return to thread.c CVS log

Up to [Apple XNU] / XNU / osfmk / kern

Annotation of XNU/osfmk/kern/thread.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
        !             3:  *
        !             4:  * @APPLE_LICENSE_HEADER_START@
        !             5:  * 
        !             6:  * The contents of this file constitute Original Code as defined in and
        !             7:  * are subject to the Apple Public Source License Version 1.1 (the
        !             8:  * "License").  You may not use this file except in compliance with the
        !             9:  * License.  Please obtain a copy of the License at
        !            10:  * http://www.apple.com/publicsource and read it before using this file.
        !            11:  * 
        !            12:  * This Original Code and all software distributed under the License are
        !            13:  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
        !            14:  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
        !            15:  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
        !            16:  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
        !            17:  * License for the specific language governing rights and limitations
        !            18:  * under the License.
        !            19:  * 
        !            20:  * @APPLE_LICENSE_HEADER_END@
        !            21:  */
        !            22: /*
        !            23:  * @OSF_FREE_COPYRIGHT@
        !            24:  */
        !            25: /* 
        !            26:  * Mach Operating System
        !            27:  * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
        !            28:  * All Rights Reserved.
        !            29:  * 
        !            30:  * Permission to use, copy, modify and distribute this software and its
        !            31:  * documentation is hereby granted, provided that both the copyright
        !            32:  * notice and this permission notice appear in all copies of the
        !            33:  * software, derivative works or modified versions, and any portions
        !            34:  * thereof, and that both notices appear in supporting documentation.
        !            35:  * 
        !            36:  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
        !            37:  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
        !            38:  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
        !            39:  * 
        !            40:  * Carnegie Mellon requests users of this software to return to
        !            41:  * 
        !            42:  *  Software Distribution Coordinator  or  [email protected]
        !            43:  *  School of Computer Science
        !            44:  *  Carnegie Mellon University
        !            45:  *  Pittsburgh PA 15213-3890
        !            46:  * 
        !            47:  * any improvements or extensions that they make and grant Carnegie Mellon
        !            48:  * the rights to redistribute these changes.
        !            49:  */
        !            50: /*
        !            51:  */
        !            52: /*
        !            53:  *     File:   kern/thread.c
        !            54:  *     Author: Avadis Tevanian, Jr., Michael Wayne Young, David Golub
        !            55:  *     Date:   1986
        !            56:  *
        !            57:  *     Thread/thread_shuttle management primitives implementation.
        !            58:  */
        !            59: /*
        !            60:  * Copyright (c) 1993 The University of Utah and
        !            61:  * the Computer Systems Laboratory (CSL).  All rights reserved.
        !            62:  *
        !            63:  * Permission to use, copy, modify and distribute this software and its
        !            64:  * documentation is hereby granted, provided that both the copyright
        !            65:  * notice and this permission notice appear in all copies of the
        !            66:  * software, derivative works or modified versions, and any portions
        !            67:  * thereof, and that both notices appear in supporting documentation.
        !            68:  *
        !            69:  * THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS
        !            70:  * IS" CONDITION.  THE UNIVERSITY OF UTAH AND CSL DISCLAIM ANY LIABILITY OF
        !            71:  * ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
        !            72:  *
        !            73:  * CSL requests users of this software to return to [email protected] any
        !            74:  * improvements that they make and grant CSL redistribution rights.
        !            75:  *
        !            76:  */
        !            77: 
        !            78: #include <cpus.h>
        !            79: #include <mach_host.h>
        !            80: #include <simple_clock.h>
        !            81: #include <mach_debug.h>
        !            82: #include <mach_prof.h>
        !            83: #include <dipc.h>
        !            84: #include <stack_usage.h>
        !            85: 
        !            86: #include <mach/boolean.h>
        !            87: #include <mach/policy.h>
        !            88: #include <mach/thread_info.h>
        !            89: #include <mach/thread_special_ports.h>
        !            90: #include <mach/thread_status.h>
        !            91: #include <mach/time_value.h>
        !            92: #include <mach/vm_param.h>
        !            93: #include <kern/ast.h>
        !            94: #include <kern/cpu_data.h>
        !            95: #include <kern/counters.h>
        !            96: #include <kern/etap_macros.h>
        !            97: #include <kern/ipc_mig.h>
        !            98: #include <kern/ipc_tt.h>
        !            99: #include <kern/mach_param.h>
        !           100: #include <kern/machine.h>
        !           101: #include <kern/misc_protos.h>
        !           102: #include <kern/processor.h>
        !           103: #include <kern/queue.h>
        !           104: #include <kern/sched.h>
        !           105: #include <kern/sched_prim.h>
        !           106: #include <kern/sf.h>
        !           107: #include <kern/mk_sp.h>        /*** ??? fix so this can be removed ***/
        !           108: #include <kern/task.h>
        !           109: #include <kern/thread.h>
        !           110: #include <kern/thread_act.h>
        !           111: #include <kern/thread_swap.h>
        !           112: #include <kern/host.h>
        !           113: #include <kern/zalloc.h>
        !           114: #include <vm/vm_kern.h>
        !           115: #include <ipc/ipc_kmsg.h>
        !           116: #include <ipc/ipc_port.h>
        !           117: #include <machine/thread.h>            /* for MACHINE_STACK */
        !           118: #include <kern/profile.h>
        !           119: #include <kern/assert.h>
        !           120: #include <sys/kdebug.h>
        !           121: 
        !           122: /*
        !           123:  * Exported interfaces
        !           124:  */
        !           125: 
        !           126: #include <mach/thread_act_server.h>
        !           127: #include <mach/mach_host_server.h>
        !           128: 
        !           129: /*
        !           130:  * Per-Cpu stashed global state
        !           131:  */
        !           132: vm_offset_t                    active_stacks[NCPUS];   /* per-cpu active stacks        */
        !           133: vm_offset_t                    kernel_stack[NCPUS];    /* top of active stacks         */
        !           134: thread_act_t           active_kloaded[NCPUS];  /*  + act if kernel loaded      */
        !           135: 
        !           136: decl_mutex_data(,      funnel_lock)
        !           137: 
        !           138: struct zone                    *thread_shuttle_zone;
        !           139: 
        !           140: queue_head_t           reaper_queue;
        !           141: decl_simple_lock_data(,reaper_lock)
        !           142: thread_call_t          thread_reaper_call;
        !           143: 
        !           144: extern int             tick;
        !           145: 
        !           146: extern void            pcb_module_init(void);
        !           147: 
        !           148: /* private */
        !           149: static struct thread_shuttle   thr_sh_template;
        !           150: 
        !           151: #if    MACH_DEBUG
        !           152: #if    STACK_USAGE
        !           153: static void    stack_init(vm_offset_t stack, unsigned int bytes);
        !           154: void           stack_finalize(vm_offset_t stack);
        !           155: vm_size_t      stack_usage(vm_offset_t stack);
        !           156: #else  /*STACK_USAGE*/
        !           157: #define stack_init(stack, size)
        !           158: #define stack_finalize(stack)
        !           159: #define stack_usage(stack) (vm_size_t)0
        !           160: #endif /*STACK_USAGE*/
        !           161: 
        !           162: #ifdef MACHINE_STACK
        !           163: extern
        !           164: #endif
        !           165:     void       stack_statistics(
        !           166:                        unsigned int    *totalp,
        !           167:                        vm_size_t       *maxusagep);
        !           168: 
        !           169: #define        STACK_MARKER    0xdeadbeef
        !           170: #if    STACK_USAGE
        !           171: boolean_t              stack_check_usage = TRUE;
        !           172: #else  /* STACK_USAGE */
        !           173: boolean_t              stack_check_usage = FALSE;
        !           174: #endif /* STACK_USAGE */
        !           175: decl_simple_lock_data(,stack_usage_lock)
        !           176: vm_size_t              stack_max_usage = 0;
        !           177: vm_size_t              stack_max_use = KERNEL_STACK_SIZE - 64;
        !           178: #endif /* MACH_DEBUG */
        !           179: 
        !           180: /* Forwards */
        !           181: void           thread_collect_scan(void);
        !           182: 
        !           183: kern_return_t thread_create_shuttle(
        !           184:        thread_act_t                    thr_act,
        !           185:        sp_attributes_t                 policy_attributes,
        !           186:        void                                    (*start_at)(void),
        !           187:        thread_t                                *new_thread);
        !           188: 
        !           189: extern void            Load_context(
        !           190:        thread_t                thread);
        !           191: 
        !           192: 
        !           193: /*
        !           194:  *     Machine-dependent code must define:
        !           195:  *             thread_machine_init
        !           196:  *             thread_machine_terminate
        !           197:  *             thread_machine_collect
        !           198:  *
        !           199:  *     The thread->pcb field is reserved for machine-dependent code.
        !           200:  */
        !           201: 
        !           202: #ifdef MACHINE_STACK
        !           203: /*
        !           204:  *     Machine-dependent code must define:
        !           205:  *             stack_alloc_try
        !           206:  *             stack_alloc
        !           207:  *             stack_free
        !           208:  *             stack_collect
        !           209:  *     and if MACH_DEBUG:
        !           210:  *             stack_statistics
        !           211:  */
        !           212: #else  /* MACHINE_STACK */
        !           213: /*
        !           214:  *     We allocate stacks from generic kernel VM.
        !           215:  *     Machine-dependent code must define:
        !           216:  *             machine_kernel_stack_init
        !           217:  *
        !           218:  *     The stack_free_list can only be accessed at splsched,
        !           219:  *     because stack_alloc_try/thread_invoke operate at splsched.
        !           220:  */
        !           221: 
        !           222: decl_simple_lock_data(,stack_lock_data)         /* splsched only */
        !           223: #define stack_lock()   simple_lock(&stack_lock_data)
        !           224: #define stack_unlock() simple_unlock(&stack_lock_data)
        !           225: 
        !           226: vm_offset_t stack_free_list;           /* splsched only */
        !           227: unsigned int stack_free_count = 0;     /* splsched only */
        !           228: unsigned int stack_free_limit = 1;     /* patchable */
        !           229: 
        !           230: unsigned int stack_alloc_hits = 0;     /* debugging */
        !           231: unsigned int stack_alloc_misses = 0;   /* debugging */
        !           232: unsigned int stack_alloc_max = 0;      /* debugging */
        !           233: 
        !           234: unsigned int stack_alloc_total = 0;
        !           235: unsigned int stack_alloc_hiwater = 0;
        !           236: 
        !           237: /*
        !           238:  *     The next field is at the base of the stack,
        !           239:  *     so the low end is left unsullied.
        !           240:  */
        !           241: 
        !           242: #define stack_next(stack) (*((vm_offset_t *)((stack) + KERNEL_STACK_SIZE) - 1))
        !           243: 
        !           244: /*
        !           245:  *     stack_alloc:
        !           246:  *
        !           247:  *     Allocate a kernel stack for an activation.
        !           248:  *     May block.
        !           249:  */
        !           250: vm_offset_t
        !           251: stack_alloc(
        !           252:        thread_t thread,
        !           253:        void (*continuation)(void))
        !           254: {
        !           255:        vm_offset_t stack;
        !           256:        spl_t   s;
        !           257: 
        !           258:        /*
        !           259:         *      We first try the free list.  It is probably empty,
        !           260:         *      or stack_alloc_try would have succeeded, but possibly
        !           261:         *      a stack was freed before the swapin thread got to us.
        !           262:         */
        !           263: 
        !           264:        s = splsched();
        !           265:        stack_lock();
        !           266:        stack = stack_free_list;
        !           267:        if (stack != 0) {
        !           268:                stack_free_list = stack_next(stack);
        !           269:                stack_free_count--;
        !           270:        }
        !           271:        stack_unlock();
        !           272:        splx(s);
        !           273: 
        !           274:        if (stack == 0) {
        !           275:                /*
        !           276:                 *      Kernel stacks should be naturally aligned,
        !           277:                 *      so that it is easy to find the starting/ending
        !           278:                 *      addresses of a stack given an address in the middle.
        !           279:                 */
        !           280: 
        !           281:                if (kmem_alloc_aligned(kernel_map, &stack,
        !           282:                                round_page(KERNEL_STACK_SIZE)) != KERN_SUCCESS)
        !           283:                        panic("stack_alloc");
        !           284: 
        !           285:                stack_alloc_total++;
        !           286:                if (stack_alloc_total > stack_alloc_hiwater)
        !           287:                  stack_alloc_hiwater = stack_alloc_total;
        !           288: 
        !           289: #if    MACH_DEBUG
        !           290:                stack_init(stack, round_page(KERNEL_STACK_SIZE));
        !           291: #endif /* MACH_DEBUG */
        !           292: 
        !           293:                /*
        !           294:                 * If using fractional pages, free the remainder(s)
        !           295:                 */
        !           296:                if (KERNEL_STACK_SIZE < round_page(KERNEL_STACK_SIZE)) {
        !           297:                    vm_offset_t ptr  = stack + KERNEL_STACK_SIZE;
        !           298:                    vm_offset_t endp = stack + round_page(KERNEL_STACK_SIZE);
        !           299:                    while (ptr < endp) {
        !           300: #if    MACH_DEBUG
        !           301:                            /*
        !           302:                             * We need to initialize just the end of the 
        !           303:                             * region.
        !           304:                             */
        !           305:                            stack_init(ptr, (unsigned int) (endp - ptr));
        !           306: #endif
        !           307:                                stack_lock();
        !           308:                                stack_next(stack) = stack_free_list;
        !           309:                                stack_free_list = stack;
        !           310:                                if (++stack_free_count > stack_alloc_max)
        !           311:                                  stack_alloc_max = stack_free_count;
        !           312:                                stack_unlock();
        !           313:                            ptr += KERNEL_STACK_SIZE;
        !           314:                    }
        !           315:                }
        !           316:        }
        !           317:        stack_attach(thread, stack, continuation);
        !           318:        return (stack);
        !           319: }
        !           320: 
        !           321: /*
        !           322:  *     stack_free:
        !           323:  *
        !           324:  *     Free a kernel stack.
        !           325:  *     Called at splsched.
        !           326:  */
        !           327: 
        !           328: void
        !           329: stack_free(
        !           330:        thread_t thread)
        !           331: {
        !           332:     vm_offset_t stack = stack_detach(thread);
        !           333:        assert(stack);
        !           334:        if (stack != thread->stack_privilege) {
        !           335:          stack_lock();
        !           336:          stack_next(stack) = stack_free_list;
        !           337:          stack_free_list = stack;
        !           338:          if (++stack_free_count > stack_alloc_max)
        !           339:                stack_alloc_max = stack_free_count;
        !           340:          stack_unlock();
        !           341:        }
        !           342: }
        !           343: 
        !           344: /*
        !           345:  *     stack_collect:
        !           346:  *
        !           347:  *     Free excess kernel stacks.
        !           348:  *     May block.
        !           349:  */
        !           350: 
        !           351: void
        !           352: stack_collect(void)
        !           353: {
        !           354:        register vm_offset_t stack;
        !           355:        spl_t   s;
        !           356: 
        !           357:        /* If using fractional pages, Cannot just call kmem_free(),
        !           358:         * and we're too lazy to coalesce small chunks.
        !           359:         */
        !           360:        if (KERNEL_STACK_SIZE < round_page(KERNEL_STACK_SIZE))
        !           361:                return;
        !           362: 
        !           363:        s = splsched();
        !           364:        stack_lock();
        !           365:        while (stack_free_count > stack_free_limit) {
        !           366:                stack = stack_free_list;
        !           367:                stack_free_list = stack_next(stack);
        !           368:                stack_free_count--;
        !           369:                stack_unlock();
        !           370:                splx(s);
        !           371: 
        !           372: #if    MACH_DEBUG
        !           373:                stack_finalize(stack);
        !           374: #endif /* MACH_DEBUG */
        !           375:                kmem_free(kernel_map, stack, KERNEL_STACK_SIZE);
        !           376: 
        !           377:                s = splsched();
        !           378:                stack_alloc_total--;
        !           379:                stack_lock();
        !           380:        }
        !           381:        stack_unlock();
        !           382:        splx(s);
        !           383: }
        !           384: 
        !           385: 
        !           386: #if    MACH_DEBUG
        !           387: /*
        !           388:  *     stack_statistics:
        !           389:  *
        !           390:  *     Return statistics on cached kernel stacks.
        !           391:  *     *maxusagep must be initialized by the caller.
        !           392:  */
        !           393: 
        !           394: void
        !           395: stack_statistics(
        !           396:        unsigned int    *totalp,
        !           397:        vm_size_t       *maxusagep)
        !           398: {
        !           399:        spl_t   s;
        !           400: 
        !           401:        s = splsched();
        !           402:        stack_lock();
        !           403: 
        !           404: #if    STACK_USAGE
        !           405:        if (stack_check_usage) {
        !           406:                vm_offset_t stack;
        !           407: 
        !           408:                /*
        !           409:                 *      This is pretty expensive to do at splsched,
        !           410:                 *      but it only happens when someone makes
        !           411:                 *      a debugging call, so it should be OK.
        !           412:                 */
        !           413: 
        !           414:                for (stack = stack_free_list; stack != 0;
        !           415:                     stack = stack_next(stack)) {
        !           416:                        vm_size_t usage = stack_usage(stack);
        !           417: 
        !           418:                        if (usage > *maxusagep)
        !           419:                                *maxusagep = usage;
        !           420:                }
        !           421:        }
        !           422: #endif /* STACK_USAGE */
        !           423: 
        !           424:        *totalp = stack_free_count;
        !           425:        stack_unlock();
        !           426:        splx(s);
        !           427: }
        !           428: #endif /* MACH_DEBUG */
        !           429: 
        !           430: #endif /* MACHINE_STACK */
        !           431: 
        !           432: 
        !           433: /*
        !           434:  *     stack_privilege:
        !           435:  *
        !           436:  *     stack_alloc_try on this thread must always succeed.
        !           437:  */
        !           438: 
        !           439: void
        !           440: stack_privilege(
        !           441:        register thread_t thread)
        !           442: {
        !           443:        /*
        !           444:         *      This implementation only works for the current thread.
        !           445:         */
        !           446: 
        !           447:        if (thread != current_thread())
        !           448:                panic("stack_privilege");
        !           449: 
        !           450:        if (thread->stack_privilege == 0)
        !           451:                thread->stack_privilege = current_stack();
        !           452: }
        !           453: 
        !           454: /*
        !           455:  *     stack_alloc_try:
        !           456:  *
        !           457:  *     Non-blocking attempt to allocate a kernel stack.
        !           458:  *     Called at splsched with the thread locked.
        !           459:  */
        !           460: 
        !           461: boolean_t stack_alloc_try(
        !           462:        thread_t        thread,
        !           463:        void            (*resume)(void))
        !           464: {
        !           465:        register vm_offset_t stack;
        !           466: 
        !           467:        if ((stack = thread->stack_privilege) == (vm_offset_t)0) {
        !           468:          stack_lock();
        !           469:          stack = stack_free_list;
        !           470:          if (stack != (vm_offset_t)0) {
        !           471:            stack_free_list = stack_next(stack);
        !           472:            stack_free_count--;
        !           473:          }
        !           474:          stack_unlock();
        !           475:        }
        !           476: 
        !           477:        if (stack != 0) {
        !           478:                stack_attach(thread, stack, resume);
        !           479:                stack_alloc_hits++;
        !           480:                return TRUE;
        !           481:        } else {
        !           482:                stack_alloc_misses++;
        !           483:                return FALSE;
        !           484:        }
        !           485: }
        !           486: 
        !           487: void
        !           488: thread_init(void)
        !           489: {
        !           490:        thread_shuttle_zone = zinit(
        !           491:                        sizeof(struct thread_shuttle),
        !           492:                        THREAD_MAX * sizeof(struct thread_shuttle),
        !           493:                        THREAD_CHUNK * sizeof(struct thread_shuttle),
        !           494:                        "threads");
        !           495: 
        !           496:        /*
        !           497:         *      Fill in a template thread_shuttle for fast initialization.
        !           498:         *      [Fields that must be (or are typically) reset at
        !           499:         *      time of creation are so noted.]
        !           500:         */
        !           501: 
        !           502:        /* thr_sh_template.links (none) */
        !           503:        thr_sh_template.runq = RUN_QUEUE_NULL;
        !           504: 
        !           505: 
        !           506:        /* thr_sh_template.task (later) */
        !           507:        /* thr_sh_template.thread_list (later) */
        !           508:        /* thr_sh_template.pset_threads (later) */
        !           509: 
        !           510:        /* one ref for being alive, one to return to the creator */
        !           511:        thr_sh_template.ref_count = 2;
        !           512: 
        !           513:        thr_sh_template.wait_event = NO_EVENT;
        !           514:        thr_sh_template.wait_result = KERN_SUCCESS;
        !           515:        thr_sh_template.wait_queue = WAIT_QUEUE_NULL;
        !           516:        thr_sh_template.wake_active = FALSE;
        !           517:        /*thr_sh_template.state = TH_SUSP;*/
        !           518:        thr_sh_template.state = 0;
        !           519:        thr_sh_template.continuation = (void (*)(void))thread_bootstrap_return;
        !           520:        thr_sh_template.top_act = THR_ACT_NULL;
        !           521: 
        !           522: /*     thr_sh_template.priority (later) */
        !           523: /***???        thr_sh_template.max_priority = BASEPRI_USER; ***/
        !           524: /*     thr_sh_template.sched_pri (later - compute_priority) */
        !           525: /***???        thr_sh_template.sched_data = 0; ***/
        !           526:        thr_sh_template.policy = POLICY_TIMESHARE;
        !           527: /***???        thr_sh_template.depress_priority = -1; ***/
        !           528: /***???        thr_sh_template.cpu_usage = 0; ***/
        !           529: /***???        thr_sh_template.sched_usage = 0; ***/
        !           530:        /* thr_sh_template.sched_stamp (later) */
        !           531: /***???        thr_sh_template.sched_change_stamp = 1; ***/
        !           532: 
        !           533:        thr_sh_template.vm_privilege = FALSE;
        !           534: 
        !           535:        /* thr_sh_template.<IPC structures> (later) */
        !           536: 
        !           537:        timer_init(&(thr_sh_template.user_timer));
        !           538:        timer_init(&(thr_sh_template.system_timer));
        !           539:        thr_sh_template.user_timer_save.low = 0;
        !           540:        thr_sh_template.user_timer_save.high = 0;
        !           541:        thr_sh_template.system_timer_save.low = 0;
        !           542:        thr_sh_template.system_timer_save.high = 0;
        !           543:        thr_sh_template.cpu_delta = 0;
        !           544:        thr_sh_template.sched_delta = 0;
        !           545: 
        !           546:        thr_sh_template.active = FALSE; /* reset */
        !           547: 
        !           548:        /* thr_sh_template.processor_set (later) */
        !           549: #if    NCPUS > 1
        !           550:        thr_sh_template.bound_processor = PROCESSOR_NULL;
        !           551: #endif /*NCPUS > 1*/
        !           552: #if    MACH_HOST
        !           553:        thr_sh_template.may_assign = TRUE;
        !           554:        thr_sh_template.assign_active = FALSE;
        !           555: #endif /* MACH_HOST */
        !           556:        thr_sh_template.funnel_state = 0;
        !           557: 
        !           558: #if    NCPUS > 1
        !           559:        /* thr_sh_template.last_processor  (later) */
        !           560: #endif /* NCPUS > 1 */
        !           561: 
        !           562:        /*
        !           563:         *      Initialize other data structures used in
        !           564:         *      this module.
        !           565:         */
        !           566: 
        !           567:        queue_init(&reaper_queue);
        !           568:        simple_lock_init(&reaper_lock, ETAP_THREAD_REAPER);
        !           569:        mutex_init(&funnel_lock,0);
        !           570: 
        !           571: #ifndef MACHINE_STACK
        !           572:        simple_lock_init(&stack_lock_data, ETAP_THREAD_STACK);
        !           573: #endif  /* MACHINE_STACK */
        !           574: 
        !           575: #if    MACH_DEBUG
        !           576:        simple_lock_init(&stack_usage_lock, ETAP_THREAD_STACK_USAGE);
        !           577: #endif /* MACH_DEBUG */
        !           578: 
        !           579: #if    MACH_LDEBUG
        !           580:        thr_sh_template.kthread = FALSE;
        !           581:        thr_sh_template.mutex_count = 0;
        !           582: #endif /* MACH_LDEBUG */
        !           583: 
        !           584:        /*
        !           585:         *      Initialize any machine-dependent
        !           586:         *      per-thread structures necessary.
        !           587:         */
        !           588:        thread_machine_init();
        !           589: }
        !           590: 
        !           591: void
        !           592: thread_reaper_enqueue(
        !           593:        thread_t                thread)
        !           594: {
        !           595:        /*
        !           596:         * thread lock is already held, splsched()
        !           597:         * not necessary here.
        !           598:         */
        !           599:        simple_lock(&reaper_lock);
        !           600: 
        !           601:        enqueue_tail(&reaper_queue, (queue_entry_t)thread);
        !           602: #if 0 /* CHECKME! */
        !           603:        /*
        !           604:         * Since thread has been put in the reaper_queue, it must no longer
        !           605:         * be preempted (otherwise, it could be put back in a run queue).
        !           606:         */
        !           607:        thread->preempt = TH_NOT_PREEMPTABLE;
        !           608: #endif
        !           609: 
        !           610:        simple_unlock(&reaper_lock);
        !           611: 
        !           612:        thread_call_enter(thread_reaper_call);
        !           613: }
        !           614: 
        !           615: void
        !           616: thread_terminate_self(void)
        !           617: {
        !           618:        register thread_t       thread = current_thread();
        !           619:        thread_act_t            thr_act, prev_act;
        !           620:        task_t                          task;
        !           621:        sched_policy_t          *policy;
        !           622:        spl_t                           s;
        !           623: 
        !           624:        /*      
        !           625:         *      Check for rpc chain. If so, switch to the previous 
        !           626:         *      activation, set error code, switch stacks and jump
        !           627:         *      to mach_rpc_return_error.
        !           628:         */
        !           629:        thr_act = thread->top_act;
        !           630:        thread = thr_act->thread;
        !           631:        task = thr_act->task;
        !           632: 
        !           633:        if (task) {
        !           634:                time_value_t    user_time, system_time;
        !           635:                void                    *proc = NULL;
        !           636: 
        !           637:                /*
        !           638:                 * Accumulate times for dead threads into task.
        !           639:                 */
        !           640:                thread_read_times(thread, &user_time, &system_time);
        !           641: 
        !           642:                task_lock(task);
        !           643:                time_value_add(&task->total_user_time, &user_time);
        !           644:                time_value_add(&task->total_system_time, &system_time);
        !           645:                if (task->thr_act_count == 1)
        !           646:                        proc = task->bsd_info;
        !           647:                task_unlock(task);
        !           648: 
        !           649:                if (proc)
        !           650:                        proc_exit(proc);
        !           651:        }
        !           652: 
        !           653:        thread = act_lock_thread(thr_act);
        !           654: 
        !           655:        /* Unlink the thr_act from the task's thr_act list,
        !           656:         * so it doesn't appear in calls to task_threads and such.
        !           657:         * The thr_act still keeps its ref on the task, however.
        !           658:         */
        !           659:        task_lock(task);
        !           660:        mutex_lock(&task->act_list_lock);
        !           661:        queue_remove(&task->thr_acts, thr_act, thread_act_t, thr_acts);
        !           662: 
        !           663:        /*
        !           664:         * Decrement the act count for this task.
        !           665:         */
        !           666:        task->thr_act_count--;
        !           667:                
        !           668: #if    THREAD_SWAPPER
        !           669:        /*
        !           670:         * Thread is supposed to be unswappable by now...
        !           671:         */
        !           672:        assert(thr_act->swap_state == TH_SW_UNSWAPPABLE ||
        !           673:                       !(thread_swap_unwire_stack ||
        !           674:                         thread_swap_unwire_user_stack));
        !           675: #endif /* THREAD_SWAPPER */
        !           676:        task->res_act_count--;
        !           677:        thr_act->thr_acts.next = NULL;
        !           678:        mutex_unlock(&task->act_list_lock);
        !           679:        task_unlock(task);
        !           680: 
        !           681: #ifdef CALLOUT_RPC_MODEL
        !           682:        if (thr_act->lower) {
        !           683:                /*
        !           684:                 * JMM - RPC will not be using a callout/stack manipulation
        !           685:                 * mechanism.  instead we will let it return normally as if
        !           686:                 * from a continuation.  Accordingly, these need to be cleaned
        !           687:                 * up a bit.
        !           688:                 */
        !           689:                act_unlock(thr_act);
        !           690:                act_switch_swapcheck(thread, (ipc_port_t)0);
        !           691:                act_lock(thr_act);      /* hierarchy violation XXX */
        !           692:                (void) switch_act(THR_ACT_NULL);
        !           693:                assert(thr_act->ref_count == 1);        /* XXX */
        !           694:                /* act_deallocate(thr_act);                XXX */
        !           695:                prev_act = thread->top_act;
        !           696:                /* disable preemption to protect kernel stack changes */
        !           697:                disable_preemption();
        !           698:                MACH_RPC_RET(prev_act) = KERN_RPC_SERVER_TERMINATED;
        !           699:                 * machine_kernel_stack_init(thread, 
        !           700:                 *      (void (*)(void)) mach_rpc_return_error);
        !           701:                 * Load_context(thread);
        !           702:                 */
        !           703:                /* NOTREACHED */
        !           704:        }
        !           705: 
        !           706: #else /* !CALLOUT_RPC_MODEL */
        !           707: 
        !           708:        assert(!thr_act->lower);
        !           709: 
        !           710: #endif /* CALLOUT_RPC_MODEL */
        !           711: 
        !           712:        act_unlock_thread(thr_act);
        !           713: 
        !           714:        s = splsched();
        !           715:        thread_lock(thread);
        !           716:        policy = &sched_policy[thread->policy];
        !           717:        thr_act = thread->top_act;
        !           718:        thread->active = FALSE;
        !           719:        thread_unlock(thread);
        !           720:        splx(s);
        !           721: 
        !           722:        policy->sp_ops.sp_thread_depress_abort(policy, thread);
        !           723:        thread_cancel_timer();
        !           724: 
        !           725:        /* flush any lazy HW state while in own context */
        !           726:        thread_machine_flush(thr_act);
        !           727: 
        !           728:        /* Reap times from dying threads */
        !           729:        ipc_thr_act_disable(thr_act);
        !           730: 
        !           731:        /*
        !           732:         * the test for task_active seems unnecessary because
        !           733:         * the thread holds a reference to the task (so it
        !           734:         * can't be deleted out from under it).
        !           735:         */
        !           736:        if( task && task->active) {
        !           737: #if    THREAD_SWAPPER
        !           738:                thread_swap_disable(thr_act);
        !           739: #endif /* THREAD_SWAPPER */
        !           740: 
        !           741:                task_lock(task);
        !           742: 
        !           743:                /* Make act inactive iff it was born as a base activation */
        !           744:                act_lock_thread(thr_act);
        !           745:                if( thr_act->active && (thr_act->pool_port == IP_NULL))
        !           746:                        act_disable_task_locked( thr_act );
        !           747:                act_unlock_thread(thr_act);
        !           748:                task_unlock( task );
        !           749:        }
        !           750: 
        !           751:        thread_deallocate(thread); /* take caller's ref; 1 left for reaper */
        !           752: 
        !           753:        ipc_thread_terminate(thread);
        !           754: 
        !           755:        s = splsched();
        !           756:        thread_lock(thread);
        !           757:        thread->state |= (TH_HALTED|TH_TERMINATE);
        !           758:        assert((thread->state & TH_UNINT) == 0);
        !           759: #if 0 /* CHECKME! */
        !           760:        /*
        !           761:         * Since thread has been put in the reaper_queue, it must no longer
        !           762:         * be preempted (otherwise, it could be put back in a run queue).
        !           763:         */
        !           764:        thread->preempt = TH_NOT_PREEMPTABLE;
        !           765: #endif
        !           766:        thread_mark_wait_locked(thread);
        !           767:        thread_unlock(thread);
        !           768:        /* splx(s); */
        !           769: 
        !           770:        ETAP_SET_REASON(thread, BLOCKED_ON_TERMINATION);
        !           771:        thread_block((void (*)(void)) 0);
        !           772:        panic("the zombie walks!");
        !           773:        /*NOTREACHED*/
        !           774: }
        !           775: 
        !           776: 
        !           777: /*
        !           778:  * Create a new thread in the specified activation (i.e. "populate" the
        !           779:  * activation).  The activation can be either user or kernel, but it must
        !           780:  * be brand-new: no thread, no pool_port, nobody else knows about it.
        !           781:  * Doesn't start the thread running; use thread_setrun to start it.
        !           782:  */
        !           783: kern_return_t
        !           784: thread_create_shuttle(
        !           785:        thread_act_t                    thr_act,
        !           786:        sp_attributes_t                 attributes,
        !           787:        void                                    (*start_at)(void),
        !           788:        thread_t                                *new_thread)
        !           789: {
        !           790:        thread_t                                new_shuttle;
        !           791:        task_t                                  parent_task = thr_act->task;
        !           792:        processor_set_t                 pset;
        !           793:        kern_return_t                   result;
        !           794:        sched_policy_t                  *policy;
        !           795:        sf_return_t                             sfr;
        !           796:        int                                             suspcnt;
        !           797: 
        !           798:        /*
        !           799:         *      Allocate a thread and initialize static fields
        !           800:         */
        !           801:        new_shuttle = (thread_t)zalloc(thread_shuttle_zone);
        !           802:        if (new_shuttle == THREAD_NULL)
        !           803:                return (KERN_RESOURCE_SHORTAGE);
        !           804: 
        !           805:        *new_shuttle = thr_sh_template;
        !           806: 
        !           807:        /* Allocate space for scheduling information and attributes */
        !           808:        /*** Think about integrating with shuttle structure someday ***/
        !           809:        new_shuttle->sp_info = (sp_info_t)kalloc(max_sched_info_size);
        !           810:        if (new_shuttle->sp_info == SP_INFO_NULL) {
        !           811:                zfree(thread_shuttle_zone, (vm_offset_t)new_shuttle);
        !           812:                return (KERN_RESOURCE_SHORTAGE);
        !           813:        }
        !           814:        new_shuttle->pending_sched_attr =
        !           815:                                        (sp_attributes_t)kalloc(max_sched_attributes_size);
        !           816:        if (new_shuttle->pending_sched_attr == SP_ATTRIBUTES_NULL) {
        !           817:                kfree((vm_offset_t)new_shuttle->sp_info,
        !           818:                                                        (vm_size_t)max_sched_info_size);
        !           819:                zfree(thread_shuttle_zone, (vm_offset_t)new_shuttle);
        !           820:                return (KERN_RESOURCE_SHORTAGE);
        !           821:        }
        !           822: 
        !           823:        thread_lock_init(new_shuttle);
        !           824:        rpc_lock_init(new_shuttle);
        !           825:        wake_lock_init(new_shuttle);
        !           826:        new_shuttle->sleep_stamp = sched_tick;
        !           827: 
        !           828:        /*
        !           829:         * No need to lock thr_act, since it can't be known to anyone --
        !           830:         * we set its suspend_count to one more than the task suspend_count
        !           831:         * by calling thread_hold.
        !           832:         */
        !           833:        thr_act->user_stop_count = 1;
        !           834:        for (suspcnt = thr_act->task->suspend_count + 1; suspcnt; --suspcnt)
        !           835:                thread_hold(thr_act);
        !           836: 
        !           837:        simple_lock_init(&new_shuttle->lock, ETAP_THREAD_NEW);
        !           838: 
        !           839:        /*
        !           840:         * Initialize system-dependent part.
        !           841:         */
        !           842:        result = thread_machine_create(new_shuttle, thr_act, start_at);
        !           843:        if (result != KERN_SUCCESS) {
        !           844:                kfree((vm_offset_t)new_shuttle->pending_sched_attr,
        !           845:                                                        (vm_size_t)max_sched_attributes_size);
        !           846:                kfree((vm_offset_t)new_shuttle->sp_info,
        !           847:                                                        (vm_size_t)max_sched_info_size);
        !           848:                zfree(thread_shuttle_zone, (vm_offset_t)new_shuttle);
        !           849:                return (result);
        !           850:        }
        !           851: 
        !           852:        /* Attach the thread to the activation.  */
        !           853:        assert(!thr_act->thread);
        !           854:        assert(!thr_act->pool_port);
        !           855:        /* Synchronize with act_lock_thread() et al. */
        !           856:        act_lock(thr_act);
        !           857:        /* Thread holds a ref to the thr_act */
        !           858:        act_locked_act_reference(thr_act);
        !           859:        act_attach(thr_act, new_shuttle, 0);
        !           860:        act_unlock(thr_act);
        !           861: 
        !           862:        /*
        !           863:         *      Initialize runtime-dependent fields
        !           864:         */
        !           865:        thread_timer_setup(new_shuttle);
        !           866:        machine_kernel_stack_init(new_shuttle, (void (*)(void))thread_continue);
        !           867:        ipc_thread_init(new_shuttle);
        !           868:        thread_start(new_shuttle, start_at);
        !           869: 
        !           870:        pset = parent_task->processor_set;
        !           871:        if (!pset->active) {
        !           872:                pset = &default_pset;
        !           873:        }
        !           874:        pset_lock(pset);
        !           875: 
        !           876:        task_lock(parent_task);
        !           877: 
        !           878:        if (attributes == SP_ATTRIBUTES_NULL)
        !           879:                attributes = parent_task->sp_attributes;
        !           880: 
        !           881:        /* Associate the thread with that scheduling policy */
        !           882:        new_shuttle->policy = attributes->policy_id;
        !           883:        policy = &sched_policy[new_shuttle->policy];
        !           884:        sfr = policy->sp_ops.sp_thread_attach(policy, new_shuttle);
        !           885:        if (sfr != SF_SUCCESS)
        !           886:                panic("thread_create_shuttle: sp_thread_attach");
        !           887: 
        !           888:        /* Indicate that no change in scheduling policy is pending */
        !           889:        new_shuttle->pending_policy = POLICY_NULL;
        !           890: 
        !           891:        /* Associate the thread with the processor set */
        !           892:        sfr = policy->sp_ops.sp_thread_processor_set(policy, new_shuttle, pset);
        !           893:        if (sfr != SF_SUCCESS)
        !           894:                panic("thread_create_shuttle: sp_thread_proceessor_set");
        !           895: 
        !           896:        /* Set the thread's scheduling parameters */
        !           897:        sfr = policy->sp_ops.sp_thread_set(policy, new_shuttle, attributes);
        !           898:        if (sfr != SF_SUCCESS)
        !           899:                panic("thread_create_shuttle: sp_thread_set");
        !           900: 
        !           901:        /***
        !           902:         *** ??? Have to do something here.  I want the call above to
        !           903:         *** send the parameters to the policy and have the policy do
        !           904:         *** its thing.  Unfortunately, I can't see the "artful" way
        !           905:         *** to use the current MK SP routines to do this without
        !           906:         *** alteration.
        !           907:         ***
        !           908:         *** I must return to this.
        !           909:         ***
        !           910:         *** Perhaps a state bit should be associated with each thread
        !           911:         *** under the MK SP indicating whether that thread is runnable.
        !           912:         *** If it is not, `compute_priority()' or one of its siblings
        !           913:         *** is used to adjust scheduling parameter values; if it is
        !           914:         *** runnable, then the scheduling parameter adjustments can be
        !           915:         *** followed by code that tries to place the thread on the
        !           916:         *** appropriate run queue, or tries to run it immediately.
        !           917:         ***/
        !           918: 
        !           919: #if    ETAP_EVENT_MONITOR
        !           920:        new_thread->etap_reason = 0;
        !           921:        new_thread->etap_trace  = FALSE;
        !           922: #endif /* ETAP_EVENT_MONITOR */
        !           923: 
        !           924:        new_shuttle->active = TRUE;
        !           925: 
        !           926:        /*
        !           927:         *      Don't need to initialize because the context switch
        !           928:         *      code will set it before it can be used.
        !           929:         */
        !           930:        if (!parent_task->active) {
        !           931:                task_unlock(parent_task);
        !           932:                pset_unlock(pset);
        !           933:                thread_deallocate(new_shuttle);
        !           934:                /* Drop ref we'd have given caller */
        !           935:                thread_deallocate(new_shuttle);
        !           936: 
        !           937:                return (KERN_FAILURE);
        !           938:        }
        !           939: 
        !           940:        task_unlock(parent_task);
        !           941:        pset_unlock(pset);
        !           942: 
        !           943:        *new_thread = new_shuttle;
        !           944: 
        !           945:        {
        !           946:          long dbg_arg1, dbg_arg2, dbg_arg3, dbg_arg4;
        !           947: 
        !           948:          KERNEL_DEBUG_CONSTANT((TRACEDBG_CODE(DBG_TRACE_DATA, 1)) | DBG_FUNC_NONE,
        !           949:                                new_shuttle, 0,0,0,0);
        !           950: 
        !           951:          kdbg_trace_string(parent_task->bsd_info, &dbg_arg1, &dbg_arg2, &dbg_arg3, 
        !           952:                            &dbg_arg4);
        !           953:           KERNEL_DEBUG_CONSTANT((TRACEDBG_CODE(DBG_TRACE_STRING, 1)) | DBG_FUNC_NONE,
        !           954:                                dbg_arg1, dbg_arg2, dbg_arg3, dbg_arg4, 0);
        !           955:        }
        !           956: 
        !           957:        return (KERN_SUCCESS);
        !           958: }
        !           959: 
        !           960: kern_return_t
        !           961: thread_create(
        !           962:        task_t                          task,
        !           963:        thread_act_t            *new_act)
        !           964: {
        !           965:        thread_act_t            thr_act;
        !           966:        thread_t                        thread;
        !           967:        kern_return_t           result;
        !           968:        sched_policy_t          *policy;
        !           969:        sf_return_t                     sfr;
        !           970:        spl_t                           s;
        !           971:        extern void                     thread_bootstrap_return(void);
        !           972: 
        !           973:        result = act_create(task, NULL_PARAMS, &thr_act);
        !           974:        if (result != KERN_SUCCESS)
        !           975:                return (result);
        !           976: 
        !           977:        result = thread_create_shuttle(thr_act, SP_ATTRIBUTES_NULL,
        !           978:                                                                                thread_bootstrap_return, &thread);
        !           979:        if (result != KERN_SUCCESS) {
        !           980:                thread_terminate(thr_act);
        !           981:                act_deallocate(thr_act);
        !           982:                return (result);
        !           983:        }
        !           984: 
        !           985:        if (task->kernel_loaded)
        !           986:                thread_user_to_kernel(thread);
        !           987: 
        !           988:        /* Start the thread running (it will immediately suspend itself).  */
        !           989:        s = splsched();
        !           990:        thread_ast_set(thr_act, AST_APC);
        !           991:        thread_lock(thread);
        !           992:        thread->state |= TH_RUN;        /*** ??? I think this is okay ***/
        !           993: 
        !           994:        /* Allow the thread to execute */
        !           995:        policy = &sched_policy[thread->policy];
        !           996:        sfr = policy->sp_ops.sp_thread_dispatch(policy, thread);
        !           997:        if (sfr != SF_SUCCESS)
        !           998:                panic("thread_create: sp_thread_dispatch");
        !           999: 
        !          1000:        thread_unlock(thread);
        !          1001:        splx(s);
        !          1002:        
        !          1003:        /*****
        !          1004:        act_lock_thread(thr_act);
        !          1005:        thread_dowait( thr_act, FALSE);
        !          1006:        act_unlock_thread(thr_act);
        !          1007:        *****/
        !          1008: 
        !          1009:        *new_act = thr_act;
        !          1010: 
        !          1011:        return (KERN_SUCCESS);
        !          1012: }
        !          1013: 
        !          1014: /*
        !          1015:  * Update thread that belongs to a task created via kernel_task_create().
        !          1016:  */
        !          1017: void
        !          1018: thread_user_to_kernel(
        !          1019:        thread_t                thread)
        !          1020: {
        !          1021:        /*
        !          1022:         * Used to set special swap_func here...
        !          1023:         */
        !          1024: }
        !          1025: 
        !          1026: kern_return_t
        !          1027: thread_create_running(
        !          1028:        register task_t         parent_task,
        !          1029:        int                     flavor,
        !          1030:        thread_state_t          new_state,
        !          1031:        mach_msg_type_number_t  new_state_count,
        !          1032:        thread_act_t                    *child_act)             /* OUT */
        !          1033: {
        !          1034:        register kern_return_t  result;
        !          1035: 
        !          1036:        result = thread_create(parent_task, child_act);
        !          1037:        if (result != KERN_SUCCESS)
        !          1038:                return (result);
        !          1039: 
        !          1040:        result = act_set_state(*child_act, flavor, new_state, new_state_count);
        !          1041:        if (result != KERN_SUCCESS) {
        !          1042:                (void) thread_terminate(*child_act);
        !          1043:                return (result);
        !          1044:        }
        !          1045: 
        !          1046:        result = thread_resume(*child_act);
        !          1047:        if (result != KERN_SUCCESS) {
        !          1048:                (void) thread_terminate(*child_act);
        !          1049:                return (result);
        !          1050:        }
        !          1051: 
        !          1052:        return (result);
        !          1053: }
        !          1054: 
        !          1055: /*
        !          1056:  *     kernel_thread:
        !          1057:  *
        !          1058:  *     Create and kernel thread in the specified task, and
        !          1059:  *     optionally start it running.
        !          1060:  */
        !          1061: thread_t
        !          1062: kernel_thread_with_attributes(
        !          1063:        task_t                          task,
        !          1064:        sp_attributes_t         attributes,
        !          1065:        void                            (*start_at)(void),
        !          1066:        boolean_t                       start_running)
        !          1067: {
        !          1068:        kern_return_t           result;
        !          1069:        thread_t                        thread;
        !          1070:        thread_act_t            thr_act;
        !          1071:        sched_policy_t          *policy;
        !          1072:        sf_return_t                     sfr;
        !          1073:        spl_t                           s;
        !          1074: 
        !          1075:        result = act_create(task, NULL_PARAMS, &thr_act);
        !          1076:        if (result != KERN_SUCCESS) {
        !          1077:                printf("kernel_thread act_create %x\n", result);
        !          1078:                panic("act_create failure");
        !          1079:        }
        !          1080: 
        !          1081:        result = thread_create_shuttle(thr_act, attributes, start_at, &thread);
        !          1082:        if (result != KERN_SUCCESS) {
        !          1083:                printf("kernel_thread create_shuttle %x\n", result);
        !          1084:                panic("create_shuttle failure");
        !          1085:        }
        !          1086: 
        !          1087:        thread_swappable(thr_act, FALSE);
        !          1088: 
        !          1089:        s = splsched();
        !          1090:        thread_lock(thread);
        !          1091: 
        !          1092:        thr_act = thread->top_act;
        !          1093: #if    MACH_LDEBUG
        !          1094:        thread->kthread = TRUE;
        !          1095: #endif /* MACH_LDEBUG */
        !          1096: 
        !          1097:        if (start_running) {
        !          1098:                policy = &sched_policy[thread->policy];
        !          1099:                thread->state |= TH_RUN;
        !          1100:                sfr = policy->sp_ops.sp_thread_unblock(policy, thread);
        !          1101:                if (sfr != SF_SUCCESS)
        !          1102:                        panic("kernel_thread: sp_thread_unblock");
        !          1103:        }
        !          1104: 
        !          1105:        thread_unlock(thread);
        !          1106:        splx(s);
        !          1107: 
        !          1108:        act_deallocate(thr_act);
        !          1109: 
        !          1110:        if (start_running)
        !          1111:                thread_resume(thr_act);
        !          1112: 
        !          1113:        return (thread);
        !          1114: }
        !          1115: 
        !          1116: thread_t
        !          1117: kernel_thread(
        !          1118:        task_t                  task,
        !          1119:        void                    (*start_at)(void))
        !          1120: {
        !          1121:        return kernel_thread_with_attributes(
        !          1122:                                                task, SP_ATTRIBUTES_NULL, start_at, TRUE);
        !          1123: }
        !          1124: 
        !          1125: unsigned int c_weird_pset_ref_exit = 0;        /* pset code raced us */
        !          1126: 
        !          1127: void
        !          1128: thread_deallocate(
        !          1129:        thread_t                        thread)
        !          1130: {
        !          1131:        task_t                          task;
        !          1132:        processor_set_t         pset;
        !          1133:        sched_policy_t          *policy;
        !          1134:        sf_return_t                     sfr;
        !          1135:        spl_t                           s;
        !          1136: 
        !          1137:        if (thread == THREAD_NULL)
        !          1138:                return;
        !          1139: 
        !          1140:        /*
        !          1141:         *      First, check for new count > 0 (the common case).
        !          1142:         *      Only the thread needs to be locked.
        !          1143:         */
        !          1144:        s = splsched();
        !          1145:        thread_lock(thread);
        !          1146:        if (--thread->ref_count > 0) {
        !          1147:                thread_unlock(thread);
        !          1148:                splx(s);
        !          1149:                return;
        !          1150:        }
        !          1151: 
        !          1152:        /*
        !          1153:         *      Count is zero.  However, the processor set's
        !          1154:         *      thread list has an implicit reference to
        !          1155:         *      the thread, and may make new ones.  Its lock also
        !          1156:         *      dominate the thread lock.  To check for this, we
        !          1157:         *      temporarily restore the one thread reference, unlock
        !          1158:         *      the thread, and then lock the pset in the proper order.
        !          1159:         */
        !          1160:        assert(thread->ref_count == 0); /* Else this is an extra dealloc! */
        !          1161:        thread->ref_count++;
        !          1162:        thread_unlock(thread);
        !          1163:        splx(s);
        !          1164: 
        !          1165: #if    MACH_HOST
        !          1166:        thread_freeze(thread);
        !          1167: #endif /* MACH_HOST */
        !          1168: 
        !          1169:        pset = thread->processor_set;
        !          1170:        pset_lock(pset);
        !          1171: 
        !          1172:        s = splsched();
        !          1173:        thread_lock(thread);
        !          1174: 
        !          1175:        if (--thread->ref_count > 0) {
        !          1176: #if    MACH_HOST
        !          1177:                boolean_t need_wakeup = FALSE;
        !          1178:                /*
        !          1179:                 *      processor_set made extra reference.
        !          1180:                 */
        !          1181:                /* Inline the unfreeze */
        !          1182:                thread->may_assign = TRUE;
        !          1183:                if (thread->assign_active) {
        !          1184:                        need_wakeup = TRUE;
        !          1185:                        thread->assign_active = FALSE;
        !          1186:                }
        !          1187: #endif /* MACH_HOST */
        !          1188:                thread_unlock(thread);
        !          1189:                splx(s);
        !          1190:                pset_unlock(pset);
        !          1191: #if    MACH_HOST
        !          1192:                if (need_wakeup)
        !          1193:                        thread_wakeup((event_t)&thread->assign_active);
        !          1194: #endif /* MACH_HOST */
        !          1195:                c_weird_pset_ref_exit++;
        !          1196:                return;
        !          1197:        }
        !          1198: #if    MACH_HOST
        !          1199:        assert(thread->assign_active == FALSE);
        !          1200: #endif /* MACH_HOST */
        !          1201: 
        !          1202:        /*
        !          1203:         *      Thread has no references - we can remove it.
        !          1204:         */
        !          1205: 
        !          1206:        /*
        !          1207:         *      A quick sanity check
        !          1208:         */
        !          1209:        if (thread == current_thread())
        !          1210:            panic("thread deallocating itself");
        !          1211: 
        !          1212:        /* Detach thread (shuttle) from its sched policy */
        !          1213:        policy = &sched_policy[thread->policy];
        !          1214:        sfr = policy->sp_ops.sp_thread_detach(policy, thread);
        !          1215:        if (sfr != SF_SUCCESS)
        !          1216:                panic("thread_deallocate: sp_thread_detach");
        !          1217: 
        !          1218:        /* Release storage used for scheduling info and attributes */
        !          1219:        assert(thread->pending_sched_attr != SP_ATTRIBUTES_NULL);
        !          1220:        kfree((vm_offset_t) thread->pending_sched_attr,
        !          1221:              (vm_size_t) max_sched_attributes_size);
        !          1222:        assert(thread->sp_info != SP_INFO_NULL);
        !          1223:        kfree((vm_offset_t) thread->sp_info,
        !          1224:              (vm_size_t) max_sched_info_size);
        !          1225: 
        !          1226:        pset_remove_thread(pset, thread);
        !          1227: 
        !          1228:        thread_unlock(thread);          /* no more references - safe */
        !          1229:        splx(s);
        !          1230:        pset_unlock(pset);
        !          1231: 
        !          1232:        pset_deallocate(thread->processor_set);
        !          1233: 
        !          1234:        /* frees kernel stack & other MD resources */
        !          1235:        thread->stack_privilege = 0;
        !          1236:        thread_machine_destroy(thread);
        !          1237: 
        !          1238:        zfree(thread_shuttle_zone, (vm_offset_t) thread);
        !          1239: }
        !          1240: 
        !          1241: void
        !          1242: thread_reference(
        !          1243:        thread_t        thread)
        !          1244: {
        !          1245:        spl_t           s;
        !          1246: 
        !          1247:        if (thread == THREAD_NULL)
        !          1248:                return;
        !          1249: 
        !          1250:        s = splsched();
        !          1251:        thread_lock(thread);
        !          1252:        thread->ref_count++;
        !          1253:        thread_unlock(thread);
        !          1254:        splx(s);
        !          1255: }
        !          1256: 
        !          1257: /*
        !          1258:  * Called with "appropriate" thread-related locks held on
        !          1259:  * thread and its top_act for synchrony with RPC (see
        !          1260:  * act_lock_thread()).
        !          1261:  */
        !          1262: kern_return_t
        !          1263: thread_info_shuttle(
        !          1264:        register thread_act_t   thr_act,
        !          1265:        thread_flavor_t                 flavor,
        !          1266:        thread_info_t                   thread_info_out,        /* ptr to OUT array */
        !          1267:        mach_msg_type_number_t  *thread_info_count)     /*IN/OUT*/
        !          1268: {
        !          1269:        register thread_t               thread = thr_act->thread;
        !          1270:        int                                             state, flags;
        !          1271:        spl_t                                   s;
        !          1272: 
        !          1273:        if (thread == THREAD_NULL)
        !          1274:                return (KERN_INVALID_ARGUMENT);
        !          1275: 
        !          1276:        if (flavor == THREAD_BASIC_INFO) {
        !          1277:            register thread_basic_info_t        basic_info;
        !          1278: 
        !          1279:            if (*thread_info_count < THREAD_BASIC_INFO_COUNT)
        !          1280:                        return (KERN_INVALID_ARGUMENT);
        !          1281: 
        !          1282:            basic_info = (thread_basic_info_t) thread_info_out;
        !          1283: 
        !          1284:            s = splsched();
        !          1285:            thread_lock(thread);
        !          1286: 
        !          1287:            /* fill in info */
        !          1288: 
        !          1289:            thread_read_times(thread, &basic_info->user_time,
        !          1290:                                                                        &basic_info->system_time);
        !          1291: 
        !          1292:            /*** ??? fix me ***/
        !          1293:            if (thread->policy & (POLICY_TIMESHARE|POLICY_RR|POLICY_FIFO)) {
        !          1294:                        mk_sp_info_t    sp_info = (mk_sp_info_t)thread->sp_info;
        !          1295: 
        !          1296:                        /*
        !          1297:                         *      Update lazy-evaluated scheduler info because someone wants it.
        !          1298:                         */
        !          1299:                    assert(sp_info != SP_INFO_NULL);
        !          1300:                        if (sp_info->sched_stamp != sched_tick)
        !          1301:                                update_priority(thread);
        !          1302: 
        !          1303:                        basic_info->sleep_time = 0;
        !          1304: 
        !          1305:                        /*
        !          1306:                         *      To calculate cpu_usage, first correct for timer rate,
        !          1307:                         *      then for 5/8 ageing.  The correction factor [3/5] is
        !          1308:                         *      (1/(5/8) - 1).
        !          1309:                         */
        !          1310:                        basic_info->cpu_usage = sp_info->cpu_usage /
        !          1311:                                                                                        (TIMER_RATE / TH_USAGE_SCALE);
        !          1312:                        basic_info->cpu_usage = (basic_info->cpu_usage * 3) / 5;
        !          1313: #if    SIMPLE_CLOCK
        !          1314:                        /*
        !          1315:                         *      Clock drift compensation.
        !          1316:                         */
        !          1317:                        basic_info->cpu_usage =
        !          1318:                                        (basic_info->cpu_usage * 1000000) / sched_usec;
        !          1319: #endif /* SIMPLE_CLOCK */
        !          1320:            }
        !          1321:                else
        !          1322:                        basic_info->sleep_time = basic_info->cpu_usage = 0;
        !          1323: 
        !          1324:            basic_info->policy  = thread->policy;
        !          1325: 
        !          1326:            flags = 0;
        !          1327:            if (thread->state & TH_SWAPPED_OUT)
        !          1328:                        flags = TH_FLAGS_SWAPPED;
        !          1329:            else
        !          1330:                if (thread->state & TH_IDLE)
        !          1331:                        flags = TH_FLAGS_IDLE;
        !          1332: 
        !          1333:            state = 0;
        !          1334:            if (thread->state & TH_HALTED)
        !          1335:                        state = TH_STATE_HALTED;
        !          1336:            else
        !          1337:                if (thread->state & TH_RUN)
        !          1338:                        state = TH_STATE_RUNNING;
        !          1339:            else
        !          1340:                if (thread->state & TH_UNINT)
        !          1341:                        state = TH_STATE_UNINTERRUPTIBLE;
        !          1342:            else
        !          1343:                if (thread->state & TH_SUSP)
        !          1344:                        state = TH_STATE_STOPPED;
        !          1345:            else
        !          1346:                if (thread->state & TH_WAIT)
        !          1347:                        state = TH_STATE_WAITING;
        !          1348: 
        !          1349:            basic_info->run_state = state;
        !          1350:            basic_info->flags = flags;
        !          1351: 
        !          1352:            basic_info->suspend_count = thr_act->user_stop_count;
        !          1353: 
        !          1354:            thread_unlock(thread);
        !          1355:            splx(s);
        !          1356: 
        !          1357:            *thread_info_count = THREAD_BASIC_INFO_COUNT;
        !          1358: 
        !          1359:            return (KERN_SUCCESS);
        !          1360:        }
        !          1361:        else
        !          1362:        if (flavor == THREAD_SCHED_TIMESHARE_INFO) {
        !          1363:                policy_timeshare_info_t         ts_info;
        !          1364:                mk_sp_info_t                            sp_info = (mk_sp_info_t)thread->sp_info;
        !          1365: 
        !          1366:                if (*thread_info_count < POLICY_TIMESHARE_INFO_COUNT)
        !          1367:                        return (KERN_INVALID_ARGUMENT);
        !          1368: 
        !          1369:                ts_info = (policy_timeshare_info_t)thread_info_out;
        !          1370: 
        !          1371:            s = splsched();
        !          1372:                thread_lock(thread);
        !          1373: 
        !          1374:            if (thread->policy != POLICY_TIMESHARE) {
        !          1375:                thread_unlock(thread);
        !          1376:                        splx(s);
        !          1377: 
        !          1378:                        return (KERN_INVALID_POLICY);
        !          1379:            }
        !          1380: 
        !          1381:            /*** ??? fix me ***/
        !          1382:            assert(sp_info != SP_INFO_NULL);
        !          1383:                ts_info->base_priority = sp_info->priority;
        !          1384:                ts_info->max_priority = sp_info->max_priority;
        !          1385:                ts_info->cur_priority = thread->sched_pri;
        !          1386: 
        !          1387:                ts_info->depressed = (sp_info->depress_priority >= 0);
        !          1388:                ts_info->depress_priority = sp_info->depress_priority;
        !          1389: 
        !          1390:                thread_unlock(thread);
        !          1391:            splx(s);
        !          1392: 
        !          1393:                *thread_info_count = POLICY_TIMESHARE_INFO_COUNT;
        !          1394: 
        !          1395:                return (KERN_SUCCESS);  
        !          1396:        }
        !          1397:        else
        !          1398:        if (flavor == THREAD_SCHED_FIFO_INFO) {
        !          1399:                policy_fifo_info_t                      fifo_info;
        !          1400:                mk_sp_info_t                            sp_info = (mk_sp_info_t)thread->sp_info;
        !          1401: 
        !          1402:                if (*thread_info_count < POLICY_FIFO_INFO_COUNT)
        !          1403:                        return (KERN_INVALID_ARGUMENT);
        !          1404: 
        !          1405:                fifo_info = (policy_fifo_info_t)thread_info_out;
        !          1406: 
        !          1407:            s = splsched();
        !          1408:                thread_lock(thread);
        !          1409: 
        !          1410:            if (thread->policy != POLICY_FIFO) {
        !          1411:                thread_unlock(thread);
        !          1412:                        splx(s);
        !          1413: 
        !          1414:                        return (KERN_INVALID_POLICY);
        !          1415:            }
        !          1416: 
        !          1417:            /*** ??? fix me ***/
        !          1418:            assert(sp_info != SP_INFO_NULL);
        !          1419:                fifo_info->base_priority = sp_info->priority;
        !          1420:                fifo_info->max_priority = sp_info->max_priority;
        !          1421: 
        !          1422:                fifo_info->depressed = (sp_info->depress_priority >= 0);
        !          1423:                fifo_info->depress_priority = sp_info->depress_priority;
        !          1424: 
        !          1425:                thread_unlock(thread);
        !          1426:            splx(s);
        !          1427: 
        !          1428:                *thread_info_count = POLICY_FIFO_INFO_COUNT;
        !          1429: 
        !          1430:                return (KERN_SUCCESS);  
        !          1431:        }
        !          1432:        else
        !          1433:        if (flavor == THREAD_SCHED_RR_INFO) {
        !          1434:                policy_rr_info_t                        rr_info;
        !          1435:                mk_sp_info_t                            sp_info = (mk_sp_info_t)thread->sp_info;
        !          1436: 
        !          1437:                if (*thread_info_count < POLICY_RR_INFO_COUNT)
        !          1438:                        return (KERN_INVALID_ARGUMENT);
        !          1439: 
        !          1440:                rr_info = (policy_rr_info_t) thread_info_out;
        !          1441: 
        !          1442:            s = splsched();
        !          1443:                thread_lock(thread);
        !          1444: 
        !          1445:            if (thread->policy != POLICY_RR) {
        !          1446:                thread_unlock(thread);
        !          1447:                        splx(s);
        !          1448: 
        !          1449:                        return (KERN_INVALID_POLICY);
        !          1450:            }
        !          1451: 
        !          1452:            /*** ??? fix me ***/
        !          1453:            assert(sp_info != SP_INFO_NULL);
        !          1454:                rr_info->base_priority = sp_info->priority;
        !          1455:                rr_info->max_priority = sp_info->max_priority;
        !          1456: 
        !          1457:            rr_info->quantum = (sp_info->sched_data * tick) / 1000;
        !          1458: 
        !          1459:                rr_info->depressed = (sp_info->depress_priority >= 0);
        !          1460:                rr_info->depress_priority = sp_info->depress_priority;
        !          1461: 
        !          1462:                thread_unlock(thread);
        !          1463:            splx(s);
        !          1464: 
        !          1465:                *thread_info_count = POLICY_RR_INFO_COUNT;
        !          1466: 
        !          1467:                return (KERN_SUCCESS);  
        !          1468:        }
        !          1469: 
        !          1470:        return (KERN_INVALID_ARGUMENT);
        !          1471: }
        !          1472: 
        !          1473: void
        !          1474: thread_doreap(
        !          1475:        register thread_t       thread)
        !          1476: {
        !          1477:        thread_act_t            thr_act;
        !          1478:        struct ipc_port         *pool_port;
        !          1479: 
        !          1480: 
        !          1481:        thr_act = thread_lock_act(thread);
        !          1482:        assert(thr_act && thr_act->thread == thread);
        !          1483: 
        !          1484:        act_locked_act_reference(thr_act);
        !          1485:        pool_port = thr_act->pool_port;
        !          1486: 
        !          1487:        /*
        !          1488:         * Replace `act_unlock_thread()' with individual
        !          1489:         * calls.  (`act_detach()' can change fields used
        !          1490:         * to determine which locks are held, confusing
        !          1491:         * `act_unlock_thread()'.)
        !          1492:         */
        !          1493:        rpc_unlock(thread);
        !          1494:        if (pool_port != IP_NULL)
        !          1495:                ip_unlock(pool_port);
        !          1496:        act_unlock(thr_act);
        !          1497: 
        !          1498:        /* Remove the reference held by a rooted thread */
        !          1499:        if (pool_port == IP_NULL)
        !          1500:                act_deallocate(thr_act);
        !          1501: 
        !          1502:        /* Remove the reference held by the thread: */
        !          1503:        act_deallocate(thr_act);
        !          1504: }
        !          1505: 
        !          1506: static thread_call_data_t      thread_reaper_call_data;
        !          1507: 
        !          1508: /*
        !          1509:  *     reaper_thread:
        !          1510:  *
        !          1511:  *     This kernel thread runs forever looking for threads to destroy
        !          1512:  *     (when they request that they be destroyed, of course).
        !          1513:  *
        !          1514:  *     The reaper thread will disappear in the next revision of thread
        !          1515:  *     control when it's function will be moved into thread_dispatch.
        !          1516:  */
        !          1517: void
        !          1518: thread_reaper(void)
        !          1519: {
        !          1520:        register thread_t       thread;
        !          1521:        spl_t                           s;
        !          1522: 
        !          1523:        s = splsched();
        !          1524:        simple_lock(&reaper_lock);
        !          1525: 
        !          1526:        if (thread_reaper_call == NULL) {
        !          1527:                thread_call_setup(&thread_reaper_call_data,     thread_reaper, NULL);
        !          1528:                thread_reaper_call = &thread_reaper_call_data;
        !          1529:        }
        !          1530: 
        !          1531:        while ((thread = (thread_t) dequeue_head(&reaper_queue)) != THREAD_NULL) {
        !          1532:                simple_unlock(&reaper_lock);
        !          1533: 
        !          1534:                /*
        !          1535:                 * wait for run bit to clear
        !          1536:                 */
        !          1537:                thread_lock(thread);
        !          1538:                if (thread->state & TH_RUN)
        !          1539:                        panic("thread reaper: TH_RUN");
        !          1540:                thread_unlock(thread);
        !          1541:                splx(s);
        !          1542: 
        !          1543:                thread_doreap(thread);
        !          1544: 
        !          1545:                s = splsched();
        !          1546:                simple_lock(&reaper_lock);
        !          1547:        }
        !          1548: 
        !          1549:        simple_unlock(&reaper_lock);
        !          1550:        splx(s);
        !          1551: }
        !          1552: 
        !          1553: #if    MACH_HOST
        !          1554: /*
        !          1555:  *     thread_assign:
        !          1556:  *
        !          1557:  *     Change processor set assignment.
        !          1558:  *     Caller must hold an extra reference to the thread (if this is
        !          1559:  *     called directly from the ipc interface, this is an operation
        !          1560:  *     in progress reference).  Caller must hold no locks -- this may block.
        !          1561:  */
        !          1562: 
        !          1563: kern_return_t
        !          1564: thread_assign(
        !          1565:        thread_act_t    thr_act,
        !          1566:        processor_set_t new_pset)
        !          1567: {
        !          1568:        thread_t        thread;
        !          1569: 
        !          1570:        if (thr_act == THR_ACT_NULL || new_pset == PROCESSOR_SET_NULL)
        !          1571:                return(KERN_INVALID_ARGUMENT);
        !          1572:        thread = act_lock_thread(thr_act);
        !          1573:        if (thread == THREAD_NULL) {
        !          1574:                act_unlock_thread(thr_act);
        !          1575:                return(KERN_INVALID_ARGUMENT);
        !          1576:        }
        !          1577: 
        !          1578:        thread_freeze(thread);
        !          1579:        thread_doassign(thread, new_pset, TRUE);
        !          1580:        act_unlock_thread(thr_act);
        !          1581:        return(KERN_SUCCESS);
        !          1582: }
        !          1583: 
        !          1584: /*
        !          1585:  *     thread_freeze:
        !          1586:  *
        !          1587:  *     Freeze thread's assignment.  Prelude to assigning thread.
        !          1588:  *     Only one freeze may be held per thread.  
        !          1589:  */
        !          1590: void
        !          1591: thread_freeze(
        !          1592:        thread_t        thread)
        !          1593: {
        !          1594:        spl_t   s;
        !          1595: 
        !          1596:        /*
        !          1597:         *      Freeze the assignment, deferring to a prior freeze.
        !          1598:         */
        !          1599: 
        !          1600:        s = splsched();
        !          1601:        thread_lock(thread);
        !          1602:        while (thread->may_assign == FALSE) {
        !          1603:                thread->assign_active = TRUE;
        !          1604:                thread_sleep_simple_lock((event_t) &thread->assign_active,
        !          1605:                                        simple_lock_addr(thread->lock), TRUE);
        !          1606:                thread_lock(thread);
        !          1607:        }
        !          1608:        thread->may_assign = FALSE;
        !          1609:        thread_unlock(thread);
        !          1610:        splx(s);
        !          1611: 
        !          1612: }
        !          1613: 
        !          1614: /*
        !          1615:  *     thread_unfreeze: release freeze on thread's assignment.
        !          1616:  */
        !          1617: void
        !          1618: thread_unfreeze(
        !          1619:        thread_t        thread)
        !          1620: {
        !          1621:        spl_t   s;
        !          1622: 
        !          1623:        s = splsched();
        !          1624:        thread_lock(thread);
        !          1625:        thread->may_assign = TRUE;
        !          1626:        if (thread->assign_active) {
        !          1627:                thread->assign_active = FALSE;
        !          1628:                thread_unlock(thread);
        !          1629:                splx(s);
        !          1630:                thread_wakeup((event_t)&thread->assign_active);
        !          1631:                return;
        !          1632:        }
        !          1633:        thread_unlock(thread);
        !          1634:        splx(s);
        !          1635: }
        !          1636: 
        !          1637: /*
        !          1638:  *     thread_doassign:
        !          1639:  *
        !          1640:  *     Actually do thread assignment.  thread_will_assign must have been
        !          1641:  *     called on the thread.  release_freeze argument indicates whether
        !          1642:  *     to release freeze on thread.
        !          1643:  *
        !          1644:  *     Called with "appropriate" thread-related locks held on thread (see
        !          1645:  *     act_lock_thread()).  Returns with thread unlocked.
        !          1646:  */
        !          1647: 
        !          1648: void
        !          1649: thread_doassign(
        !          1650:        register thread_t               thread,
        !          1651:        register processor_set_t        new_pset,
        !          1652:        boolean_t                       release_freeze)
        !          1653: {
        !          1654:        register boolean_t              old_empty, new_empty;
        !          1655:        register processor_set_t        pset;
        !          1656:        boolean_t                       recompute_pri = FALSE;
        !          1657:        int                             max_priority;
        !          1658:        spl_t                           s;
        !          1659:        thread_act_t                    thr_act = thread->top_act;
        !          1660:        
        !          1661:        /*
        !          1662:         *      Check for silly no-op.
        !          1663:         */
        !          1664:        pset = thread->processor_set;
        !          1665:        if (pset == new_pset) {
        !          1666:                if (release_freeze)
        !          1667:                        thread_unfreeze(thread);
        !          1668:                return;
        !          1669:        }
        !          1670:        /*
        !          1671:         *      Suspend the thread and stop it if it's not the current thread.
        !          1672:         */
        !          1673:        thread_hold(thr_act);
        !          1674:        act_locked_act_reference(thr_act);
        !          1675:        act_unlock_thread(thr_act);
        !          1676:        if (thread != current_thread()) {
        !          1677:                if (thread_stop_wait(thread) == FALSE ){
        !          1678:                        (void)act_lock_thread(thr_act);
        !          1679:                        thread_release(thr_act);
        !          1680:                        act_locked_act_deallocate(thr_act);
        !          1681:                        act_unlock_thread(thr_act);
        !          1682:                        if (release_freeze )
        !          1683:                                thread_unfreeze(thread);
        !          1684:                        return;
        !          1685:                }
        !          1686:        }
        !          1687:        /*
        !          1688:         *      Had to release thread-related locks before acquiring pset
        !          1689:         *      locks.
        !          1690:         */
        !          1691: 
        !          1692:        /*
        !          1693:         *      Lock both psets now, use ordering to avoid deadlocks.
        !          1694:         */
        !          1695: Restart:
        !          1696:        if (pset < new_pset) {
        !          1697:            pset_lock(pset);
        !          1698:            pset_lock(new_pset);
        !          1699:        } else {
        !          1700:            pset_lock(new_pset);
        !          1701:            pset_lock(pset);
        !          1702:        }
        !          1703: 
        !          1704:        /*
        !          1705:         *      Check if new_pset is ok to assign to.  If not, reassign
        !          1706:         *      to default_pset.
        !          1707:         */
        !          1708:        if (!new_pset->active) {
        !          1709:            pset_unlock(pset);
        !          1710:            pset_unlock(new_pset);
        !          1711:            new_pset = &default_pset;
        !          1712:            goto Restart;
        !          1713:        }
        !          1714: 
        !          1715:        /*
        !          1716:         *      Grab the thread lock and move the thread.
        !          1717:         *      Then drop the lock on the old pset and the thread's
        !          1718:         *      reference to it.
        !          1719:         */
        !          1720: 
        !          1721:        s = splsched();
        !          1722:        thread_lock(thread);
        !          1723: 
        !          1724:        thread_change_psets(thread, pset, new_pset);
        !          1725: 
        !          1726:        old_empty = pset->empty;
        !          1727:        new_empty = new_pset->empty;
        !          1728: 
        !          1729:        pset_unlock(pset);
        !          1730:        pset_deallocate(pset);
        !          1731: 
        !          1732:         /*
        !          1733:         *      Reset policy and priorities if needed. 
        !          1734:         *
        !          1735:         *      There are three rules for threads under assignment:
        !          1736:         *
        !          1737:          *      (1) If the new pset has the old policy enabled, keep the
        !          1738:          *          old policy. Otherwise, use the default policy for the pset.
        !          1739:          *      (2) The new limits will be the pset limits for the new policy.
        !          1740:          *      (3) The new base will be the same as the old base unless either
        !          1741:          *              (a) the new policy changed to the pset default policy;
        !          1742:          *                  in this case, the new base is the default policy
        !          1743:          *                  base,
        !          1744:          *          or
        !          1745:          *              (b) the new limits are different from the old limits;
        !          1746:          *                  in this case, the new base is the new limits.
        !          1747:          */
        !          1748:        /*** ??? fix me to fit into MK Scheduling Framework ***/
        !          1749:        max_priority = pset_max_priority(new_pset, thread->policy);
        !          1750:        if ((thread->policy & new_pset->policies) == 0) {
        !          1751:                thread->policy = new_pset->policy_default;
        !          1752:                thread->sched_data =
        !          1753:                        pset_sched_data(new_pset, thread->policy);
        !          1754:                thread->unconsumed_quantum = thread->sched_data;
        !          1755:                thread->priority =
        !          1756:                        pset_base_priority(new_pset, thread->policy);
        !          1757:                max_priority = pset_max_priority(new_pset, thread->policy);
        !          1758:                recompute_pri = TRUE;
        !          1759:        } 
        !          1760:        else if (thread->max_priority != max_priority) {
        !          1761:                thread->priority = max_priority;
        !          1762:                 recompute_pri = TRUE;
        !          1763:        }
        !          1764: 
        !          1765:        thread->max_priority = max_priority;
        !          1766:        if ((thread->depress_priority >= 0) &&
        !          1767:                (thread->depress_priority > thread->max_priority)) {
        !          1768:                         thread->depress_priority = thread->max_priority;
        !          1769:        }
        !          1770: 
        !          1771:        pset_unlock(new_pset);
        !          1772: 
        !          1773:        if (recompute_pri)
        !          1774:                compute_priority(thread, TRUE);
        !          1775: 
        !          1776:        if (release_freeze) {
        !          1777:                boolean_t need_wakeup = FALSE;
        !          1778:                thread->may_assign = TRUE;
        !          1779:                if (thread->assign_active) {
        !          1780:                        thread->assign_active = FALSE;
        !          1781:                        need_wakeup = TRUE;
        !          1782:                }
        !          1783:                thread_unlock(thread);
        !          1784:                splx(s);
        !          1785:                if (need_wakeup)
        !          1786:                        thread_wakeup((event_t)&thread->assign_active);
        !          1787:        } else {
        !          1788:                thread_unlock(thread);
        !          1789:                splx(s);
        !          1790:        }
        !          1791:        if (thread != current_thread())
        !          1792:                thread_unstop(thread);
        !          1793:        /*
        !          1794:         *      Figure out hold status of thread.  Threads assigned to empty
        !          1795:         *      psets must be held.  Therefore:
        !          1796:         *              If old pset was empty release its hold.
        !          1797:         *              Release our hold from above unless new pset is empty.
        !          1798:         */
        !          1799: 
        !          1800:        (void)act_lock_thread(thr_act);
        !          1801:        if (old_empty)
        !          1802:                thread_release(thr_act);
        !          1803:        if (!new_empty)
        !          1804:                thread_release(thr_act);
        !          1805:        act_locked_act_deallocate(thr_act);
        !          1806:        act_unlock_thread(thr_act);
        !          1807: 
        !          1808:        /*
        !          1809:         *      If current_thread is assigned, context switch to force
        !          1810:         *      assignment to happen.  This also causes hold to take
        !          1811:         *      effect if the new pset is empty.
        !          1812:         */
        !          1813:        if (thread == current_thread()) {
        !          1814:                s = splsched();
        !          1815:                mp_disable_preemption();
        !          1816:                ast_on(AST_BLOCK);
        !          1817:                mp_enable_preemption();
        !          1818:                splx(s);
        !          1819:        }
        !          1820: }
        !          1821: 
        !          1822: #else  /* MACH_HOST */
        !          1823: 
        !          1824: kern_return_t
        !          1825: thread_assign(
        !          1826:        thread_act_t    thr_act,
        !          1827:        processor_set_t new_pset)
        !          1828: {
        !          1829: #ifdef lint
        !          1830:        thread++; new_pset++;
        !          1831: #endif /* lint */
        !          1832:        return(KERN_FAILURE);
        !          1833: }
        !          1834: #endif /* MACH_HOST */
        !          1835: 
        !          1836: /*
        !          1837:  *     thread_assign_default:
        !          1838:  *
        !          1839:  *     Special version of thread_assign for assigning threads to default
        !          1840:  *     processor set.
        !          1841:  */
        !          1842: kern_return_t
        !          1843: thread_assign_default(
        !          1844:        thread_act_t    thr_act)
        !          1845: {
        !          1846:        return (thread_assign(thr_act, &default_pset));
        !          1847: }
        !          1848: 
        !          1849: /*
        !          1850:  *     thread_get_assignment
        !          1851:  *
        !          1852:  *     Return current assignment for this thread.
        !          1853:  */        
        !          1854: kern_return_t
        !          1855: thread_get_assignment(
        !          1856:        thread_act_t    thr_act,
        !          1857:        processor_set_t *pset)
        !          1858: {
        !          1859:        thread_t        thread;
        !          1860: 
        !          1861:        if (thr_act == THR_ACT_NULL)
        !          1862:                return(KERN_INVALID_ARGUMENT);
        !          1863:        thread = act_lock_thread(thr_act);
        !          1864:        if (thread == THREAD_NULL) {
        !          1865:                act_unlock_thread(thr_act);
        !          1866:                return(KERN_INVALID_ARGUMENT);
        !          1867:        }
        !          1868:        *pset = thread->processor_set;
        !          1869:        act_unlock_thread(thr_act);
        !          1870:        pset_reference(*pset);
        !          1871:        return(KERN_SUCCESS);
        !          1872: }
        !          1873: 
        !          1874: /*
        !          1875:  *     thread_wire:
        !          1876:  *
        !          1877:  *     Specify that the target thread must always be able
        !          1878:  *     to run and to allocate memory.
        !          1879:  */
        !          1880: kern_return_t
        !          1881: thread_wire(
        !          1882:        host_t          host,
        !          1883:        thread_act_t    thr_act,
        !          1884:        boolean_t       wired)
        !          1885: {
        !          1886:        spl_t           s;
        !          1887:        thread_t        thread;
        !          1888:        extern void vm_page_free_reserve(int pages);
        !          1889: 
        !          1890:        if (thr_act == THR_ACT_NULL || host == HOST_NULL)
        !          1891:                return (KERN_INVALID_ARGUMENT);
        !          1892:        thread = act_lock_thread(thr_act);
        !          1893:        if (thread ==THREAD_NULL) {
        !          1894:                act_unlock_thread(thr_act);
        !          1895:                return(KERN_INVALID_ARGUMENT);
        !          1896:        }
        !          1897: 
        !          1898:        /*
        !          1899:         * This implementation only works for the current thread.
        !          1900:         * See stack_privilege.
        !          1901:         */
        !          1902:        if (thr_act != current_act())
        !          1903:            return KERN_INVALID_ARGUMENT;
        !          1904: 
        !          1905:        s = splsched();
        !          1906:        thread_lock(thread);
        !          1907: 
        !          1908:        if (wired) {
        !          1909:            if (thread->vm_privilege == FALSE) 
        !          1910:                    vm_page_free_reserve(1);    /* XXX */
        !          1911:            thread->vm_privilege = TRUE;
        !          1912:        } else {
        !          1913:            if (thread->vm_privilege == TRUE) 
        !          1914:                    vm_page_free_reserve(-1);   /* XXX */
        !          1915:            thread->vm_privilege = FALSE;
        !          1916:        }
        !          1917: 
        !          1918:        thread_unlock(thread);
        !          1919:        splx(s);
        !          1920:        act_unlock_thread(thr_act);
        !          1921: 
        !          1922:        /*
        !          1923:         * Make the thread unswappable.
        !          1924:         */
        !          1925:        thread_swappable(thr_act, FALSE);
        !          1926: 
        !          1927:        return KERN_SUCCESS;
        !          1928: }
        !          1929: 
        !          1930: /*
        !          1931:  *     thread_collect_scan:
        !          1932:  *
        !          1933:  *     Attempt to free resources owned by threads.
        !          1934:  */
        !          1935: 
        !          1936: void
        !          1937: thread_collect_scan(void)
        !          1938: {
        !          1939:        /* This code runs very quickly! */
        !          1940: }
        !          1941: 
        !          1942: boolean_t thread_collect_allowed = TRUE;
        !          1943: unsigned thread_collect_last_tick = 0;
        !          1944: unsigned thread_collect_max_rate = 0;          /* in ticks */
        !          1945: 
        !          1946: /*
        !          1947:  *     consider_thread_collect:
        !          1948:  *
        !          1949:  *     Called by the pageout daemon when the system needs more free pages.
        !          1950:  */
        !          1951: 
        !          1952: void
        !          1953: consider_thread_collect(void)
        !          1954: {
        !          1955:        /*
        !          1956:         *      By default, don't attempt thread collection more frequently
        !          1957:         *      than once a second (one scheduler tick).
        !          1958:         */
        !          1959: 
        !          1960:        if (thread_collect_max_rate == 0)
        !          1961:                thread_collect_max_rate = 2;            /* sched_tick is a 1 second resolution 2 here insures at least 1 second interval */
        !          1962: 
        !          1963:        if (thread_collect_allowed &&
        !          1964:            (sched_tick >
        !          1965:             (thread_collect_last_tick + thread_collect_max_rate))) {
        !          1966:                thread_collect_last_tick = sched_tick;
        !          1967:                thread_collect_scan();
        !          1968:        }
        !          1969: }
        !          1970: 
        !          1971: #if    MACH_DEBUG
        !          1972: #if    STACK_USAGE
        !          1973: 
        !          1974: vm_size_t
        !          1975: stack_usage(
        !          1976:        register vm_offset_t stack)
        !          1977: {
        !          1978:        int i;
        !          1979: 
        !          1980:        for (i = 0; i < KERNEL_STACK_SIZE/sizeof(unsigned int); i++)
        !          1981:            if (((unsigned int *)stack)[i] != STACK_MARKER)
        !          1982:                break;
        !          1983: 
        !          1984:        return KERNEL_STACK_SIZE - i * sizeof(unsigned int);
        !          1985: }
        !          1986: 
        !          1987: /*
        !          1988:  *     Machine-dependent code should call stack_init
        !          1989:  *     before doing its own initialization of the stack.
        !          1990:  */
        !          1991: 
        !          1992: static void
        !          1993: stack_init(
        !          1994:           register vm_offset_t stack,
        !          1995:           unsigned int bytes)
        !          1996: {
        !          1997:        if (stack_check_usage) {
        !          1998:            int i;
        !          1999: 
        !          2000:            for (i = 0; i < bytes / sizeof(unsigned int); i++)
        !          2001:                ((unsigned int *)stack)[i] = STACK_MARKER;
        !          2002:        }
        !          2003: }
        !          2004: 
        !          2005: /*
        !          2006:  *     Machine-dependent code should call stack_finalize
        !          2007:  *     before releasing the stack memory.
        !          2008:  */
        !          2009: 
        !          2010: void
        !          2011: stack_finalize(
        !          2012:        register vm_offset_t stack)
        !          2013: {
        !          2014:        if (stack_check_usage) {
        !          2015:            vm_size_t used = stack_usage(stack);
        !          2016: 
        !          2017:            simple_lock(&stack_usage_lock);
        !          2018:            if (used > stack_max_usage)
        !          2019:                stack_max_usage = used;
        !          2020:            simple_unlock(&stack_usage_lock);
        !          2021:            if (used > stack_max_use) {
        !          2022:                printf("stack usage = %x\n", used);
        !          2023:                panic("stack overflow");
        !          2024:            }
        !          2025:        }
        !          2026: }
        !          2027: 
        !          2028: #endif /*STACK_USAGE*/
        !          2029: #endif /* MACH_DEBUG */
        !          2030: 
        !          2031: kern_return_t
        !          2032: host_stack_usage(
        !          2033:        host_t          host,
        !          2034:        vm_size_t       *reservedp,
        !          2035:        unsigned int    *totalp,
        !          2036:        vm_size_t       *spacep,
        !          2037:        vm_size_t       *residentp,
        !          2038:        vm_size_t       *maxusagep,
        !          2039:        vm_offset_t     *maxstackp)
        !          2040: {
        !          2041: #if !MACH_DEBUG
        !          2042:         return KERN_NOT_SUPPORTED;
        !          2043: #else
        !          2044:        unsigned int total;
        !          2045:        vm_size_t maxusage;
        !          2046: 
        !          2047:        if (host == HOST_NULL)
        !          2048:                return KERN_INVALID_HOST;
        !          2049: 
        !          2050:        simple_lock(&stack_usage_lock);
        !          2051:        maxusage = stack_max_usage;
        !          2052:        simple_unlock(&stack_usage_lock);
        !          2053: 
        !          2054:        stack_statistics(&total, &maxusage);
        !          2055: 
        !          2056:        *reservedp = 0;
        !          2057:        *totalp = total;
        !          2058:        *spacep = *residentp = total * round_page(KERNEL_STACK_SIZE);
        !          2059:        *maxusagep = maxusage;
        !          2060:        *maxstackp = 0;
        !          2061:        return KERN_SUCCESS;
        !          2062: 
        !          2063: #endif /* MACH_DEBUG */
        !          2064: }
        !          2065: 
        !          2066: /*
        !          2067:  * Return info on stack usage for threads in a specific processor set
        !          2068:  */
        !          2069: kern_return_t
        !          2070: processor_set_stack_usage(
        !          2071:        processor_set_t pset,
        !          2072:        unsigned int    *totalp,
        !          2073:        vm_size_t       *spacep,
        !          2074:        vm_size_t       *residentp,
        !          2075:        vm_size_t       *maxusagep,
        !          2076:        vm_offset_t     *maxstackp)
        !          2077: {
        !          2078: #if !MACH_DEBUG
        !          2079:         return KERN_NOT_SUPPORTED;
        !          2080: #else
        !          2081:        unsigned int total;
        !          2082:        vm_size_t maxusage;
        !          2083:        vm_offset_t maxstack;
        !          2084: 
        !          2085:        register thread_t *threads;
        !          2086:        register thread_t thread;
        !          2087: 
        !          2088:        unsigned int actual;    /* this many things */
        !          2089:        unsigned int i;
        !          2090: 
        !          2091:        vm_size_t size, size_needed;
        !          2092:        vm_offset_t addr;
        !          2093: 
        !          2094:        if (pset == PROCESSOR_SET_NULL)
        !          2095:                return KERN_INVALID_ARGUMENT;
        !          2096: 
        !          2097:        size = 0; addr = 0;
        !          2098: 
        !          2099:        for (;;) {
        !          2100:                pset_lock(pset);
        !          2101:                if (!pset->active) {
        !          2102:                        pset_unlock(pset);
        !          2103:                        return KERN_INVALID_ARGUMENT;
        !          2104:                }
        !          2105: 
        !          2106:                actual = pset->thread_count;
        !          2107: 
        !          2108:                /* do we have the memory we need? */
        !          2109: 
        !          2110:                size_needed = actual * sizeof(thread_t);
        !          2111:                if (size_needed <= size)
        !          2112:                        break;
        !          2113: 
        !          2114:                /* unlock the pset and allocate more memory */
        !          2115:                pset_unlock(pset);
        !          2116: 
        !          2117:                if (size != 0)
        !          2118:                        kfree(addr, size);
        !          2119: 
        !          2120:                assert(size_needed > 0);
        !          2121:                size = size_needed;
        !          2122: 
        !          2123:                addr = kalloc(size);
        !          2124:                if (addr == 0)
        !          2125:                        return KERN_RESOURCE_SHORTAGE;
        !          2126:        }
        !          2127: 
        !          2128:        /* OK, have memory and the processor_set is locked & active */
        !          2129: 
        !          2130:        threads = (thread_t *) addr;
        !          2131:        for (i = 0, thread = (thread_t) queue_first(&pset->threads);
        !          2132:             i < actual;
        !          2133:             i++,
        !          2134:             thread = (thread_t) queue_next(&thread->pset_threads)) {
        !          2135:                thread_reference(thread);
        !          2136:                threads[i] = thread;
        !          2137:        }
        !          2138:        assert(queue_end(&pset->threads, (queue_entry_t) thread));
        !          2139: 
        !          2140:        /* can unlock processor set now that we have the thread refs */
        !          2141:        pset_unlock(pset);
        !          2142: 
        !          2143:        /* calculate maxusage and free thread references */
        !          2144: 
        !          2145:        total = 0;
        !          2146:        maxusage = 0;
        !          2147:        maxstack = 0;
        !          2148:        for (i = 0; i < actual; i++) {
        !          2149:                int cpu;
        !          2150:                thread_t thread = threads[i];
        !          2151:                vm_offset_t stack = 0;
        !          2152: 
        !          2153:                /*
        !          2154:                 *      thread->kernel_stack is only accurate if the
        !          2155:                 *      thread isn't swapped and is not executing.
        !          2156:                 *
        !          2157:                 *      Of course, we don't have the appropriate locks
        !          2158:                 *      for these shenanigans.
        !          2159:                 */
        !          2160: 
        !          2161:                stack = thread->kernel_stack;
        !          2162: 
        !          2163:                for (cpu = 0; cpu < NCPUS; cpu++)
        !          2164:                        if (cpu_data[cpu].active_thread == thread) {
        !          2165:                                stack = active_stacks[cpu];
        !          2166:                                break;
        !          2167:                        }
        !          2168: 
        !          2169:                if (stack != 0) {
        !          2170:                        total++;
        !          2171: 
        !          2172:                        if (stack_check_usage) {
        !          2173:                                vm_size_t usage = stack_usage(stack);
        !          2174: 
        !          2175:                                if (usage > maxusage) {
        !          2176:                                        maxusage = usage;
        !          2177:                                        maxstack = (vm_offset_t) thread;
        !          2178:                                }
        !          2179:                        }
        !          2180:                }
        !          2181: 
        !          2182:                thread_deallocate(thread);
        !          2183:        }
        !          2184: 
        !          2185:        if (size != 0)
        !          2186:                kfree(addr, size);
        !          2187: 
        !          2188:        *totalp = total;
        !          2189:        *residentp = *spacep = total * round_page(KERNEL_STACK_SIZE);
        !          2190:        *maxusagep = maxusage;
        !          2191:        *maxstackp = maxstack;
        !          2192:        return KERN_SUCCESS;
        !          2193: 
        !          2194: #endif /* MACH_DEBUG */
        !          2195: }
        !          2196: 
        !          2197: 
        !          2198: /*
        !          2199:  * We consider a thread not preemptable if it is marked as either
        !          2200:  * suspended or waiting.
        !          2201:  */
        !          2202: 
        !          2203: boolean_t thread_not_preemptable(
        !          2204:        thread_t        thread)
        !          2205: {
        !          2206: 
        !          2207:        /* XXX - when scheduling framework and such is done, the
        !          2208:           thread state check can be eliminated */
        !          2209: 
        !          2210:        if ((thread->state & (TH_WAIT|TH_SUSP)) || thread->preempt)
        !          2211:                return (TRUE);
        !          2212:        else
        !          2213:                return (FALSE);
        !          2214: }
        !          2215: 
        !          2216: 
        !          2217: /*
        !          2218:  *     thread_set_sched
        !          2219:  *
        !          2220:  *      Set scheduling policy and parameters for the given thread.
        !          2221:  *      Policy must be a policy which is enabled for the
        !          2222:  *      processor set.
        !          2223:  *      (This should replace `thread_set_policy()' with the addition
        !          2224:  *      of the MK Scheduling Framework to the kernel.)
        !          2225:  */
        !          2226: kern_return_t
        !          2227: thread_set_sched(
        !          2228:        thread_act_t                    thr_act,
        !          2229:        policy_t                                policy_id,
        !          2230:        sched_attr_t                    sched_attr,
        !          2231:        mach_msg_type_number_t  sched_attrCnt)
        !          2232: {
        !          2233:        thread_t                                thread;
        !          2234:        processor_set_t                 pset;
        !          2235:        kern_return_t                   result = KERN_SUCCESS;
        !          2236:        sched_policy_t                  *policy;
        !          2237:        sf_return_t                             sfr;
        !          2238:        boolean_t                               do_dispatch = FALSE;
        !          2239:        spl_t                                   s;
        !          2240: 
        !          2241:        if (thr_act == THR_ACT_NULL)
        !          2242:                return (KERN_INVALID_ARGUMENT);
        !          2243: 
        !          2244:        thread = act_lock_thread(thr_act);
        !          2245:        if (    thread == THREAD_NULL                                                           ||
        !          2246:                        (sched_attrCnt * sizeof(int)) !=
        !          2247:                                sched_policy[policy_id].sched_attributes_size           ) {
        !          2248:                act_unlock_thread(thr_act);
        !          2249:                return(KERN_INVALID_ARGUMENT);
        !          2250:        }
        !          2251: 
        !          2252:        if (invalid_policy(policy_id)) {
        !          2253:                act_unlock_thread(thr_act);
        !          2254:                return(KERN_INVALID_POLICY);
        !          2255:        }
        !          2256: 
        !          2257:        /* coordinate changes to thread scheduling state with others */
        !          2258:        s = splsched();
        !          2259:        thread_lock(thread);
        !          2260: 
        !          2261:        /* see if thread's policy is to be changed */
        !          2262:        if (thread->policy != policy_id) {
        !          2263:                /* it is; see if the target is executing */
        !          2264:                if (thread != current_thread()) {       /*** fix for SMP ***/
        !          2265:                        /* it is not; detach from old policy */
        !          2266:                        policy = &sched_policy[thread->policy];
        !          2267:                        sfr = policy->sp_ops.sp_thread_detach(policy, thread);
        !          2268:                        if (sfr != SF_SUCCESS)
        !          2269:                                panic("thread_set_sched: sp_thread_detach");
        !          2270: 
        !          2271:                        /* attach to this policy */
        !          2272:                        policy = &sched_policy[policy_id];
        !          2273:                        sfr = policy->sp_ops.sp_thread_attach(policy, thread);
        !          2274:                        if (sfr != SF_SUCCESS) {
        !          2275:                                thread_unlock(thread);
        !          2276:                                splx(s);
        !          2277:                                act_unlock_thread(thr_act);
        !          2278:                                return(KERN_FAILURE);
        !          2279:                        }
        !          2280: 
        !          2281:                        /* remember to dispatch thread after setting parms */
        !          2282:                        do_dispatch = TRUE;
        !          2283:                }
        !          2284:                else {
        !          2285:                        /* target is currently executing */
        !          2286:                        /* defer policy change until thread leaves processor */
        !          2287:                        thread->pending_policy = policy_id;
        !          2288:                        bcopy((char *)sched_attr,
        !          2289:                              (char *)thread->pending_sched_attr,
        !          2290:                              (sched_attrCnt * sizeof(int)));
        !          2291: 
        !          2292:                        /* try to get off processor to effect change */
        !          2293:                        thread_unlock(thread);
        !          2294:                        splx(s);
        !          2295:                        act_unlock_thread(thr_act);
        !          2296:                        thread_block((void (*)(void)) 0);
        !          2297: 
        !          2298:                        /* by now, new attributes have been installed */
        !          2299:                        act_lock_thread(thr_act);
        !          2300:                        /*** check to see it's same thread? ***/
        !          2301: 
        !          2302:                        s = splsched();
        !          2303:                        thread_lock(thread);
        !          2304:                        result = (thread->change_sfr == SF_SUCCESS)?
        !          2305:                                                KERN_SUCCESS : KERN_FAILURE;
        !          2306:                        thread_unlock(thread);
        !          2307:                        splx(s);
        !          2308:                        act_unlock_thread(thr_act);
        !          2309:                        return(result);
        !          2310:                }
        !          2311: 
        !          2312:        }
        !          2313: 
        !          2314:        /* call policy-specific routine to install new scheduling parameters */
        !          2315:        policy = &sched_policy[policy_id];
        !          2316:        sfr = policy->sp_ops.sp_thread_set(
        !          2317:                                                policy, thread, (sp_attributes_t)sched_attr);
        !          2318: 
        !          2319:        /* dispatch thread under new policy, if appropriate */
        !          2320:        if (do_dispatch == TRUE && sfr == SF_SUCCESS) {
        !          2321:                sfr = policy->sp_ops.sp_thread_dispatch(policy, thread);
        !          2322:        }
        !          2323: 
        !          2324:        thread_unlock(thread);
        !          2325:        splx(s);
        !          2326: 
        !          2327:        if (sfr != SF_SUCCESS)
        !          2328:                result = KERN_FAILURE;
        !          2329: 
        !          2330:        act_unlock_thread(thr_act);
        !          2331:        return(result);
        !          2332: }
        !          2333: 
        !          2334: 
        !          2335: /*
        !          2336:  *     thread_get_sched
        !          2337:  *
        !          2338:  *      Get scheduling policy and parameters for the given thread.
        !          2339:  *      (This was added as part of the MK Scheduling Framework.)
        !          2340:  */
        !          2341: kern_return_t
        !          2342: thread_get_sched(
        !          2343:        thread_act_t                    thr_act,
        !          2344:        policy_t                                *policy_id_out,
        !          2345:        sched_attr_t                    sched_attr,
        !          2346:        mach_msg_type_number_t  *sched_attrCnt)
        !          2347: {
        !          2348:        thread_t                                thread;
        !          2349:        kern_return_t                   result = KERN_SUCCESS;
        !          2350:        policy_t                                policy_id;
        !          2351:        sched_policy_t                  *policy;
        !          2352:        sf_return_t                             sfr;
        !          2353:        int                                             size;
        !          2354:        spl_t                                   s;
        !          2355: 
        !          2356:        if (thr_act == THR_ACT_NULL)
        !          2357:                return (KERN_INVALID_ARGUMENT);
        !          2358: 
        !          2359:        thread = act_lock_thread(thr_act);
        !          2360:        if (thread == THREAD_NULL) {
        !          2361:                act_unlock_thread(thr_act);
        !          2362:                *policy_id_out = POLICY_NULL;
        !          2363:                return(KERN_INVALID_ARGUMENT);
        !          2364:        }
        !          2365: 
        !          2366:        size = *sched_attrCnt * sizeof(int);
        !          2367: 
        !          2368:        /* coordinate changes to thread scheduling state with others */
        !          2369:        s = splsched();
        !          2370:        thread_lock(thread);
        !          2371: 
        !          2372:        policy_id = thread->policy;
        !          2373:        if (size < sched_policy[policy_id].sched_attributes_size) {
        !          2374:                thread_unlock(thread);
        !          2375:                splx(s);
        !          2376:                act_unlock_thread(thr_act);
        !          2377:                *policy_id_out = policy_id;
        !          2378:                return(KERN_INVALID_ARGUMENT);
        !          2379:        }
        !          2380: 
        !          2381:        /* note policy for caller */
        !          2382:        *policy_id_out = policy_id;
        !          2383: 
        !          2384:        /* call policy-specific routine */
        !          2385:        policy = &sched_policy[policy_id];
        !          2386:        sfr = policy->sp_ops.sp_thread_get(
        !          2387:                                                policy, thread, (sp_attributes_t)sched_attr, size);
        !          2388: 
        !          2389:        if (sfr != SF_SUCCESS)
        !          2390:                result = KERN_FAILURE;
        !          2391: 
        !          2392:        *sched_attrCnt = policy->sched_attributes_size / sizeof(int);
        !          2393: 
        !          2394:        thread_unlock(thread);
        !          2395:        splx(s);
        !          2396:        act_unlock_thread(thr_act);
        !          2397:        return(result);
        !          2398: }
        !          2399: 
        !          2400: boolean_t
        !          2401: thread_get_funneled(
        !          2402:        void)
        !          2403: {
        !          2404:        return((current_thread()->funnel_state & TH_FN_OWNED) == TH_FN_OWNED);
        !          2405: }
        !          2406: 
        !          2407: boolean_t
        !          2408: thread_set_funneled(
        !          2409:        boolean_t       funneled)
        !          2410: {
        !          2411:        thread_t        cur_thread;
        !          2412:        boolean_t       funnel_state_prev;
        !          2413: 
        !          2414:        cur_thread = current_thread();
        !          2415:        funnel_state_prev = ((cur_thread->funnel_state & TH_FN_OWNED) == TH_FN_OWNED);
        !          2416: 
        !          2417:        if (funnel_state_prev != funneled) {
        !          2418:                if (funneled == TRUE) {
        !          2419:                        mutex_lock(&funnel_lock);
        !          2420:                        cur_thread->funnel_state |= TH_FN_OWNED;
        !          2421:                } else {
        !          2422:                        cur_thread->funnel_state &= ~TH_FN_OWNED;
        !          2423:                        mutex_unlock(&funnel_lock);
        !          2424:                }
        !          2425:        }
        !          2426:        return(funnel_state_prev);
        !          2427: }
        !          2428: 
        !          2429: void
        !          2430: thread_set_cont_arg(int arg)
        !          2431: {
        !          2432:   thread_t th = current_thread();
        !          2433:   th->cont_arg = arg; 
        !          2434: }
        !          2435: 
        !          2436: int
        !          2437: thread_get_cont_arg(void)
        !          2438: {
        !          2439:   thread_t th = current_thread();
        !          2440:   return(th->cont_arg); 
        !          2441: }
        !          2442: 
        !          2443: /*
        !          2444:  * Export routines to other components for things that are done as macros
        !          2445:  * within the osfmk component.
        !          2446:  */
        !          2447: #undef thread_should_halt
        !          2448: boolean_t
        !          2449: thread_should_halt(
        !          2450:        thread_shuttle_t th)
        !          2451: {
        !          2452:        return(thread_should_halt_fast(th));
        !          2453: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.