X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/0c530ab8987f0ae6a1a3d9284f40182b88852816..d1ecb069dfe24481e4a83f44cb5217a2b06746d7:/osfmk/kern/bsd_kern.c diff --git a/osfmk/kern/bsd_kern.c b/osfmk/kern/bsd_kern.c index a9a805928..822c07ce9 100644 --- a/osfmk/kern/bsd_kern.c +++ b/osfmk/kern/bsd_kern.c @@ -1,25 +1,32 @@ /* - * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved. + * Copyright (c) 2000-2007 Apple, Inc. All rights reserved. * - * @APPLE_LICENSE_HEADER_START@ + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ * - * The contents of this file constitute Original Code as defined in and - * are subject to the Apple Public Source License Version 1.1 (the - * "License"). You may not use this file except in compliance with the - * License. Please obtain a copy of the License at - * http://www.apple.com/publicsource and read it before using this file. + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apple Public Source License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. The rights granted to you under the License + * may not be used to create, or enable the creation or redistribution of, + * unlawful or unlicensed copies of an Apple operating system, or to + * circumvent, violate, or enable the circumvention or violation of, any + * terms of an Apple operating system software license agreement. * - * This Original Code and all software distributed under the License are - * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the - * License for the specific language governing rights and limitations - * under the License. + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. * - * @APPLE_LICENSE_HEADER_END@ + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ #include +#include #include #include @@ -51,9 +58,10 @@ boolean_t thread_should_abort(thread_t); boolean_t current_thread_aborted(void); void task_act_iterate_wth_args(task_t, void(*)(thread_t, void *), void *); void ipc_port_release(ipc_port_t); -boolean_t is_thread_active(thread_t); kern_return_t get_signalact(task_t , thread_t *, int); int get_vmsubmap_entries(vm_map_t, vm_object_offset_t, vm_object_offset_t); +void syscall_exit_funnelcheck(void); + /* * @@ -63,6 +71,14 @@ void *get_bsdtask_info(task_t t) return(t->bsd_info); } +/* + * + */ +void *get_bsdthreadtask_info(thread_t th) +{ + return(th->task != TASK_NULL ? th->task->bsd_info : NULL); +} + /* * */ @@ -117,15 +133,15 @@ get_signalact( for (inc = (thread_t)queue_first(&task->threads); !queue_end(&task->threads, (queue_entry_t)inc); ) { - thread_mtx_lock(inc); - if (inc->active && - (inc->state & (TH_ABORT|TH_ABORT_SAFELY)) != TH_ABORT) { - thread = inc; - break; - } - thread_mtx_unlock(inc); - - inc = (thread_t)queue_next(&inc->task_threads); + thread_mtx_lock(inc); + if (inc->active && + (inc->sched_mode & TH_MODE_ISABORTED) != TH_MODE_ABORT) { + thread = inc; + break; + } + thread_mtx_unlock(inc); + + inc = (thread_t)queue_next(&inc->task_threads); } if (result_out) @@ -169,7 +185,7 @@ check_actforsig( thread_mtx_lock(inc); if (inc->active && - (inc->state & (TH_ABORT|TH_ABORT_SAFELY)) != TH_ABORT) { + (inc->sched_mode & TH_MODE_ISABORTED) != TH_MODE_ABORT) { result = KERN_SUCCESS; break; } @@ -230,6 +246,22 @@ ipc_space_t get_task_ipcspace(task_t t) return(t->itk_space); } +int get_task_numactivethreads(task_t task) +{ + thread_t inc; + int num_active_thr=0; + task_lock(task); + + for (inc = (thread_t)queue_first(&task->threads); + !queue_end(&task->threads, (queue_entry_t)inc); inc = (thread_t)queue_next(&inc->task_threads)) + { + if(inc->active) + num_active_thr++; + } + task_unlock(task); + return num_active_thr; +} + int get_task_numacts(task_t t) { return(t->thread_count); @@ -246,12 +278,12 @@ int is_64signalregset(void) } /* - * The old map reference is returned. + * Swap in a new map for the task/thread pair; the old map reference is + * returned. */ vm_map_t -swap_task_map(task_t task,vm_map_t map) +swap_task_map(task_t task, thread_t thread, vm_map_t map) { - thread_t thread = current_thread(); vm_map_t old_map; if (task != thread->task) @@ -262,7 +294,9 @@ swap_task_map(task_t task,vm_map_t map) thread->map = task->map = map; task_unlock(task); +#if (defined(__i386__) || defined(__x86_64__)) && NCOPY_WINDOWS > 0 inval_copy_windows(thread); +#endif return old_map; } @@ -278,53 +312,27 @@ pmap_t get_task_pmap(task_t t) /* * */ -pmap_t get_map_pmap(vm_map_t map) -{ - return(map->pmap); -} -/* - * - */ -task_t get_threadtask(thread_t th) -{ - return(th->task); -} - - -/* - * - */ -boolean_t is_thread_idle(thread_t th) +uint64_t get_task_resident_size(task_t task) { - return((th->state & TH_IDLE) == TH_IDLE); -} - -/* - * - */ -boolean_t is_thread_running(thread_t th) -{ - return((th->state & TH_RUN) == TH_RUN); + vm_map_t map; + + map = (task == kernel_task) ? kernel_map: task->map; + return((uint64_t)pmap_resident_count(map->pmap) * PAGE_SIZE_64); } /* * */ -thread_t -getshuttle_thread( - thread_t th) +pmap_t get_map_pmap(vm_map_t map) { - return(th); + return(map->pmap); } - /* * */ -thread_t -getact_thread( - thread_t th) +task_t get_threadtask(thread_t th) { - return(th); + return(th->task); } /* @@ -444,7 +452,7 @@ boolean_t thread_should_abort( thread_t th) { - return ((th->state & (TH_ABORT|TH_ABORT_SAFELY)) == TH_ABORT); + return ((th->sched_mode & TH_MODE_ISABORTED) == TH_MODE_ABORT); } /* @@ -462,14 +470,14 @@ current_thread_aborted ( thread_t th = current_thread(); spl_t s; - if ((th->state & (TH_ABORT|TH_ABORT_SAFELY)) == TH_ABORT && + if ((th->sched_mode & TH_MODE_ISABORTED) == TH_MODE_ABORT && (th->options & TH_OPT_INTMASK) != THREAD_UNINT) return (TRUE); - if (th->state & TH_ABORT_SAFELY) { + if (th->sched_mode & TH_MODE_ABORTSAFELY) { s = splsched(); thread_lock(th); - if (th->state & TH_ABORT_SAFELY) - th->state &= ~(TH_ABORT|TH_ABORT_SAFELY); + if (th->sched_mode & TH_MODE_ABORTSAFELY) + th->sched_mode &= ~TH_MODE_ISABORTED; thread_unlock(th); splx(s); } @@ -505,13 +513,6 @@ ipc_port_release( ipc_object_release(&(port)->ip_object); } -boolean_t -is_thread_active( - thread_t th) -{ - return(th->active); -} - void astbsd_on(void) { @@ -531,13 +532,14 @@ fill_taskprocinfo(task_t task, struct proc_taskinfo_internal * ptinfo) vm_map_t map; task_absolutetime_info_data_t tinfo; thread_t thread; - int numrunning = 0; + int cswitch = 0, numrunning = 0; map = (task == kernel_task)? kernel_map: task->map; ptinfo->pti_virtual_size = map->size; - ptinfo->pti_resident_size = (mach_vm_size_t)(pmap_resident_count(map->pmap) - * PAGE_SIZE); + ptinfo->pti_resident_size = + (mach_vm_size_t)(pmap_resident_count(map->pmap)) + * PAGE_SIZE_64; task_lock(task); @@ -553,6 +555,7 @@ fill_taskprocinfo(task_t task, struct proc_taskinfo_internal * ptinfo) if ((thread->state & TH_RUN) == TH_RUN) numrunning++; + cswitch += thread->c_switch; tval = timer_grab(&thread->user_timer); tinfo.threads_user += tval; tinfo.total_user += tval; @@ -574,7 +577,7 @@ fill_taskprocinfo(task_t task, struct proc_taskinfo_internal * ptinfo) ptinfo->pti_messages_received = task->messages_received; ptinfo->pti_syscalls_mach = task->syscalls_mach; ptinfo->pti_syscalls_unix = task->syscalls_unix; - ptinfo->pti_csw = task->csw; + ptinfo->pti_csw = task->c_switch + cswitch; ptinfo->pti_threadnum = task->thread_count; ptinfo->pti_numrunning = numrunning; ptinfo->pti_priority = task->priority; @@ -583,10 +586,11 @@ fill_taskprocinfo(task_t task, struct proc_taskinfo_internal * ptinfo) } int -fill_taskthreadinfo(task_t task, uint64_t thaddr, struct proc_threadinfo_internal * ptinfo) +fill_taskthreadinfo(task_t task, uint64_t thaddr, struct proc_threadinfo_internal * ptinfo, void * vpp, int *vidp) { thread_t thact; - int err=0, count; + int err=0; + mach_msg_type_number_t count; thread_basic_info_data_t basic_info; kern_return_t kret; @@ -594,9 +598,9 @@ fill_taskthreadinfo(task_t task, uint64_t thaddr, struct proc_threadinfo_interna for (thact = (thread_t)queue_first(&task->threads); !queue_end(&task->threads, (queue_entry_t)thact); ) { -#if defined(__ppc__) +#if defined(__ppc__) || defined(__arm__) if (thact->machine.cthread_self == thaddr) -#elif defined (__i386__) +#elif defined (__i386__) || defined (__x86_64__) if (thact->machine.pcb->cthread_self == thaddr) #else #error architecture not supported @@ -604,7 +608,7 @@ fill_taskthreadinfo(task_t task, uint64_t thaddr, struct proc_threadinfo_interna { count = THREAD_BASIC_INFO_COUNT; - if ((kret = thread_info_internal(thact, THREAD_BASIC_INFO, &basic_info, &count)) != KERN_SUCCESS) { + if ((kret = thread_info_internal(thact, THREAD_BASIC_INFO, (thread_info_t)&basic_info, &count)) != KERN_SUCCESS) { err = 1; goto out; } @@ -625,6 +629,9 @@ fill_taskthreadinfo(task_t task, uint64_t thaddr, struct proc_threadinfo_interna ptinfo->pth_priority = thact->priority; ptinfo->pth_maxpriority = thact->max_priority; + if ((vpp != NULL) && (thact->uthread != NULL)) + bsd_threadcdir(thact->uthread, vpp, vidp); + bsd_getthreadname(thact->uthread,ptinfo->pth_name); err = 0; goto out; } @@ -651,9 +658,9 @@ fill_taskthreadlist(task_t task, void * buffer, int thcount) for (thact = (thread_t)queue_first(&task->threads); !queue_end(&task->threads, (queue_entry_t)thact); ) { -#if defined(__ppc__) +#if defined(__ppc__) || defined(__arm__) thaddr = thact->machine.cthread_self; -#elif defined (__i386__) +#elif defined (__i386__) || defined (__x86_64__) thaddr = thact->machine.pcb->cthread_self; #else #error architecture not supported @@ -667,7 +674,7 @@ fill_taskthreadlist(task_t task, void * buffer, int thcount) out: task_unlock(task); - return(numthr * sizeof(uint64_t)); + return (int)(numthr * sizeof(uint64_t)); } @@ -677,3 +684,13 @@ get_numthreads(task_t task) return(task->thread_count); } +void +syscall_exit_funnelcheck(void) +{ + thread_t thread; + + thread = current_thread(); + + if (thread->funnel_lock) + panic("syscall exit with funnel held\n"); +}