![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to task.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / kern|
Return to task.c CVS log | Up to [Apple XNU] / XNU / osfmk / kern |
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 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: * File: kern/task.c
52: * Author: Avadis Tevanian, Jr., Michael Wayne Young, David Golub,
53: * David Black
54: *
55: * Task management primitives implementation.
56: */
57: /*
58: * Copyright (c) 1993 The University of Utah and
59: * the Computer Systems Laboratory (CSL). All rights reserved.
60: *
61: * Permission to use, copy, modify and distribute this software and its
62: * documentation is hereby granted, provided that both the copyright
63: * notice and this permission notice appear in all copies of the
64: * software, derivative works or modified versions, and any portions
65: * thereof, and that both notices appear in supporting documentation.
66: *
67: * THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS
68: * IS" CONDITION. THE UNIVERSITY OF UTAH AND CSL DISCLAIM ANY LIABILITY OF
69: * ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
70: *
71: * CSL requests users of this software to return to [email protected] any
72: * improvements that they make and grant CSL redistribution rights.
73: *
74: */
75:
76: #include <mach_kdb.h>
77: #include <mach_host.h>
78: #include <mach_prof.h>
79: #include <fast_tas.h>
80: #include <task_swapper.h>
81: #include <platforms.h>
82:
83: #include <mach/boolean.h>
84: #include <mach/machine/vm_types.h>
85: #include <mach/vm_param.h>
86: #include <mach/task_info.h>
87: #include <mach/task_special_ports.h>
88: #include <mach/mach_types.h>
89: #include <mach/machine/rpc.h>
90: #include <ipc/ipc_space.h>
91: #include <ipc/ipc_entry.h>
92: #include <kern/mach_param.h>
93: #include <kern/misc_protos.h>
94: #include <kern/task.h>
95: #include <kern/thread.h>
96: #include <kern/zalloc.h>
97: #include <kern/kalloc.h>
98: #include <kern/rtmalloc.h>
99: #include <kern/processor.h>
100: #include <kern/sched_prim.h> /* for thread_wakeup */
101: #include <kern/sf.h>
102: #include <kern/mk_sp.h> /*** ??? fix so this can be removed ***/
103: #include <kern/ipc_tt.h>
104: #include <kern/ledger.h>
105: #include <kern/host.h>
106: #include <vm/vm_kern.h> /* for kernel_map, ipc_kernel_map */
107: #include <kern/profile.h>
108: #include <kern/assert.h>
109: #include <kern/sync_lock.h>
110: #include <kern/sync_sema.h>
111: #if MACH_KDB
112: #include <ddb/db_sym.h>
113: #endif /* MACH_KDB */
114:
115: #if TASK_SWAPPER
116: #include <kern/task_swap.h>
117: #endif /* TASK_SWAPPER */
118:
119: /*
120: * Exported interfaces
121: */
122:
123: #include <mach/task_server.h>
124: #include <mach/mach_host_server.h>
125: #include <mach/host_security_server.h>
126:
127: security_token_t DEFAULT_USER_SECURITY_TOKEN = { {930624, 610120} };
128:
129: task_t kernel_task;
130: zone_t task_zone;
131:
132: /* Forwards */
133:
134: kern_return_t task_hold_locked(
135: task_t task);
136: void task_wait_locked(
137: task_t task);
138: kern_return_t task_release(
139: task_t task);
140: void task_collect_scan(void);
141: void task_act_iterate(
142: task_t task,
143: kern_return_t (*func)(thread_act_t inc));
144: void task_free(
145: task_t task );
146: void task_synchronizer_destroy_all(
147: task_t task);
148: void task_subsystem_destroy_all(
149: task_t task);
150:
151: kern_return_t task_set_ledger(
152: task_t task,
153: ledger_t wired,
154: ledger_t paged);
155:
156: void
157: task_init(void)
158: {
159: task_zone = zinit(
160: sizeof(struct task),
161: TASK_MAX * sizeof(struct task),
162: TASK_CHUNK * sizeof(struct task),
163: "tasks");
164:
165: eml_init();
166:
167: /*
168: * Create the kernel task as the first task.
169: * Task_create_local must assign to kernel_task as a side effect,
170: * for other initialization. (:-()
171: */
172: if (task_create_local(
173: TASK_NULL, FALSE, FALSE, &kernel_task) != KERN_SUCCESS)
174: panic("task_init\n");
175: vm_map_deallocate(kernel_task->map);
176: kernel_task->map = kernel_map;
177:
178: #if MACH_ASSERT
179: if (watchacts & WA_TASK)
180: printf("task_init: kernel_task = %x map=%x\n",
181: kernel_task, kernel_map);
182: #endif /* MACH_ASSERT */
183: }
184:
185: #if MACH_HOST
186: void
187: task_freeze(
188: task_t task)
189: {
190: task_lock(task);
191: /*
192: * If may_assign is false, task is already being assigned,
193: * wait for that to finish.
194: */
195: while (task->may_assign == FALSE) {
196: task->assign_active = TRUE;
197: thread_sleep_mutex((event_t) &task->assign_active,
198: &task->lock, THREAD_INTERRUPTIBLE);
199: task_lock(task);
200: }
201: task->may_assign = FALSE;
202: task_unlock(task);
203:
204: return;
205: }
206:
207: void
208: task_unfreeze(
209: task_t task)
210: {
211: task_lock(task);
212: assert(task->may_assign == FALSE);
213: task->may_assign = TRUE;
214: if (task->assign_active == TRUE) {
215: task->assign_active = FALSE;
216: thread_wakeup((event_t)&task->assign_active);
217: }
218: task_unlock(task);
219:
220: return;
221: }
222: #endif /* MACH_HOST */
223:
224: /*
225: * Create a task running in the kernel address space. It may
226: * have its own map of size mem_size and may have ipc privileges.
227: */
228: kern_return_t
229: kernel_task_create(
230: task_t parent_task,
231: vm_offset_t map_base,
232: vm_size_t map_size,
233: task_t *child_task)
234: {
235: kern_return_t result;
236: task_t new_task;
237: vm_map_t old_map;
238:
239: /*
240: * Create the task.
241: */
242: result = task_create_local(parent_task, FALSE, TRUE, &new_task);
243: if (result != KERN_SUCCESS)
244: return (result);
245:
246: /*
247: * Task_create_local creates the task with a user-space map.
248: * We attempt to replace the map and free it afterwards; else
249: * task_deallocate will free it (can NOT set map to null before
250: * task_deallocate, this impersonates a norma placeholder task).
251: * _Mark the memory as pageable_ -- this is what we
252: * want for images (like servers) loaded into the kernel.
253: */
254: if (map_size == 0) {
255: vm_map_deallocate(new_task->map);
256: new_task->map = kernel_map;
257: *child_task = new_task;
258: } else {
259: old_map = new_task->map;
260: if ((result = kmem_suballoc(kernel_map, &map_base,
261: map_size, TRUE, FALSE,
262: &new_task->map)) != KERN_SUCCESS) {
263: /*
264: * New task created with ref count of 2 -- decrement by
265: * one to force task deletion.
266: */
267: printf("kmem_suballoc(%x,%x,%x,1,0,&new) Fails\n",
268: kernel_map, map_base, map_size);
269: --new_task->ref_count;
270: task_deallocate(new_task);
271: return (result);
272: }
273: vm_map_deallocate(old_map);
274: *child_task = new_task;
275: }
276: return (KERN_SUCCESS);
277: }
278:
279: kern_return_t
280: task_create(
281: task_t parent_task,
282: ledger_port_array_t ledger_ports,
283: mach_msg_type_number_t num_ledger_ports,
284: boolean_t inherit_memory,
285: task_t *child_task) /* OUT */
286: {
287: if (parent_task == TASK_NULL)
288: return(KERN_INVALID_ARGUMENT);
289:
290: return task_create_local(
291: parent_task, inherit_memory, FALSE, child_task);
292: }
293:
294: kern_return_t
295: host_security_create_task_token(
296: host_security_t host_security,
297: task_t parent_task,
298: security_token_t sec_token,
299: ledger_port_array_t ledger_ports,
300: mach_msg_type_number_t num_ledger_ports,
301: boolean_t inherit_memory,
302: task_t *child_task) /* OUT */
303: {
304: kern_return_t result;
305:
306: if (parent_task == TASK_NULL)
307: return(KERN_INVALID_ARGUMENT);
308:
309: if (host_security == HOST_NULL)
310: return(KERN_INVALID_SECURITY);
311:
312: result = task_create_local(
313: parent_task, inherit_memory, FALSE, child_task);
314:
315: if (result != KERN_SUCCESS)
316: return(result);
317: result = host_security_set_task_token(host_security,
318: *child_task,
319: sec_token);
320: return(result);
321: }
322:
323: kern_return_t
324: task_create_local(
325: task_t parent_task,
326: boolean_t inherit_memory,
327: boolean_t kernel_loaded,
328: task_t *child_task) /* OUT */
329: {
330: task_t new_task;
331: processor_set_t pset;
332:
333: new_task = (task_t) zalloc(task_zone);
334:
335: if (new_task == TASK_NULL)
336: return(KERN_RESOURCE_SHORTAGE);
337:
338: /* one ref for just being alive; one for our caller */
339: new_task->ref_count = 2;
340:
341: if (inherit_memory)
342: new_task->map = vm_map_fork(parent_task->map);
343: else
344: new_task->map = vm_map_create(pmap_create(0),
345: round_page(VM_MIN_ADDRESS),
346: trunc_page(VM_MAX_ADDRESS), TRUE);
347:
348: mutex_init(&new_task->lock, ETAP_THREAD_TASK_NEW);
349: queue_init(&new_task->subsystem_list);
350: queue_init(&new_task->thr_acts);
351: mutex_init(&new_task->act_list_lock, ETAP_THREAD_ACT_LIST);
352: new_task->suspend_count = 0;
353: new_task->thr_act_count = 0;
354: new_task->user_stop_count = 0;
355: new_task->active = TRUE;
356: new_task->kernel_loaded = kernel_loaded;
357: new_task->user_data = 0;
358: new_task->faults = 0;
359: new_task->cow_faults = 0;
360: new_task->pageins = 0;
361: new_task->messages_sent = 0;
362: new_task->messages_received = 0;
363: new_task->syscalls_mach = 0;
364: new_task->syscalls_unix=0;
365: new_task->csw=0;
366:
367: #ifdef MACH_BSD
368: new_task->bsd_info = 0;
369: #endif /* MACH_BSD */
370:
371: new_task->res_act_count = 0; /* used unconditionally */
372: #if TASK_SWAPPER
373: new_task->swap_state = TASK_SW_IN;
374: new_task->swap_flags = 0;
375: new_task->swap_ast_waiting = 0;
376: new_task->swap_stamp = sched_tick;
377: new_task->swap_rss = 0;
378: new_task->swap_nswap = 0;
379: #endif /* TASK_SWAPPER */
380:
381: queue_init(&new_task->semaphore_list);
382: queue_init(&new_task->lock_set_list);
383: new_task->semaphores_owned = 0;
384: new_task->lock_sets_owned = 0;
385:
386: #if MACH_HOST
387: new_task->may_assign = TRUE;
388: new_task->assign_active = FALSE;
389: #endif /* MACH_HOST */
390: eml_task_reference(new_task, parent_task);
391:
392: ipc_task_init(new_task, parent_task);
393:
394: new_task->total_user_time.seconds = 0;
395: new_task->total_user_time.microseconds = 0;
396: new_task->total_system_time.seconds = 0;
397: new_task->total_system_time.microseconds = 0;
398:
399: task_prof_init(new_task);
400:
401: if (parent_task != TASK_NULL) {
402: #if MACH_HOST
403: /*
404: * Freeze the parent, so that parent_task->processor_set
405: * cannot change.
406: */
407: task_freeze(parent_task);
408: #endif /* MACH_HOST */
409: pset = parent_task->processor_set;
410: if (!pset->active)
411: pset = &default_pset;
412: new_task->policy = parent_task->policy;
413:
414: /* allocate space for scheduling attributes */
415: new_task->sp_attributes = (sp_attributes_t)kalloc(
416: sched_policy[new_task->policy].sched_attributes_size);
417:
418: if (new_task->sp_attributes == SP_ATTRIBUTES_NULL) {
419: zfree(task_zone, (vm_offset_t) new_task);
420:
421: return(KERN_RESOURCE_SHORTAGE);
422: }
423:
424: /* initialize scheduling attributes */
425: bcopy((char *)parent_task->sp_attributes,
426: (char *)new_task->sp_attributes,
427: sched_policy[new_task->policy].sched_attributes_size);
428:
429: new_task->sec_token = parent_task->sec_token;
430: new_task->wired_ledger_port = ledger_copy(
431: convert_port_to_ledger(parent_task->wired_ledger_port));
432: new_task->paged_ledger_port = ledger_copy(
433: convert_port_to_ledger(parent_task->paged_ledger_port));
434: }
435: else {
436: pset = &default_pset;
437: /*** ??? fix me, so that I am policy independent ***/
438: if (kernel_task == TASK_NULL)
439: new_task->policy = POLICY_FIFO;
440: else
441: new_task->policy = POLICY_TIMESHARE;
442:
443: /* allocate space for scheduling attributes */
444: new_task->sp_attributes =
445: (sp_attributes_t)kalloc(sizeof(mk_sp_attribute_struct_t));
446:
447: if (new_task->sp_attributes == SP_ATTRIBUTES_NULL) {
448: zfree(task_zone, (vm_offset_t) new_task);
449:
450: return(KERN_RESOURCE_SHORTAGE);
451: }
452:
453: /* initialize scheduling attributes */
454: {
455: /*** ??? fix me ***/
456: mk_sp_attributes_t sched_attribute;
457:
458: sched_attribute = (mk_sp_attributes_t)new_task->sp_attributes;
459: if (kernel_task == TASK_NULL) {
460: sched_attribute->policy_id = POLICY_FIFO;
461: sched_attribute->priority = BASEPRI_SYSTEM;
462: sched_attribute->max_priority = BASEPRI_SYSTEM;
463: }
464: else {
465: sched_attribute->policy_id = POLICY_TIMESHARE;
466: sched_attribute->priority = BASEPRI_USER;
467: sched_attribute->max_priority = BASEPRI_USER;
468: }
469:
470: sched_attribute->sched_data = 0;
471: sched_attribute->unconsumed_quantum = 0;
472: }
473:
474: new_task->sec_token = DEFAULT_USER_SECURITY_TOKEN;
475: new_task->wired_ledger_port = ledger_copy(root_wired_ledger);
476: new_task->paged_ledger_port = ledger_copy(root_paged_ledger);
477: }
478: pset_lock(pset);
479: pset_add_task(pset, new_task);
480: pset_unlock(pset);
481: #if MACH_HOST
482: if (parent_task != TASK_NULL)
483: task_unfreeze(parent_task);
484: #endif /* MACH_HOST */
485:
486: #if FAST_TAS
487: if (inherit_memory) {
488: new_task->fast_tas_base = parent_task->fast_tas_base;
489: new_task->fast_tas_end = parent_task->fast_tas_end;
490: } else {
491: new_task->fast_tas_base = (vm_offset_t)0;
492: new_task->fast_tas_end = (vm_offset_t)0;
493: }
494: #endif /* FAST_TAS */
495:
496: ipc_task_enable(new_task);
497:
498: #if TASK_SWAPPER
499: task_swapout_eligible(new_task);
500: #endif /* TASK_SWAPPER */
501:
502: #if MACH_ASSERT
503: if (watchacts & WA_TASK)
504: printf("*** task_create_local(par=%x inh=%x) == 0x%x\n",
505: parent_task, inherit_memory, new_task);
506: #endif /* MACH_ASSERT */
507:
508: *child_task = new_task;
509: return(KERN_SUCCESS);
510: }
511:
512: /*
513: * task_free:
514: *
515: * Called by task_deallocate when the task's reference count drops to zero.
516: * Task is locked.
517: */
518: void
519: task_free(
520: task_t task)
521: {
522: processor_set_t pset;
523:
524: #if MACH_ASSERT
525: assert(task != 0);
526: if (watchacts & (WA_EXIT|WA_TASK))
527: printf("task_free(%x(%d)) map ref %d\n", task, task->ref_count,
528: task->map->ref_count);
529: #endif /* MACH_ASSERT */
530:
531: #if TASK_SWAPPER
532: /* task_terminate guarantees that this task is off the list */
533: assert((task->swap_state & TASK_SW_ELIGIBLE) == 0);
534: #endif /* TASK_SWAPPER */
535:
536: eml_task_deallocate(task);
537:
538: /*
539: * Temporarily restore the reference we dropped above, then
540: * freeze the task so that the task->processor_set field
541: * cannot change. In the !MACH_HOST case, the logic can be
542: * simplified, since the default_pset is the only pset.
543: */
544: ++task->ref_count;
545: task_unlock(task);
546: #if MACH_HOST
547: task_freeze(task);
548: #endif /* MACH_HOST */
549:
550: pset = task->processor_set;
551: pset_lock(pset);
552: task_lock(task);
553: if (--task->ref_count > 0) {
554: /*
555: * A new reference appeared (probably from the pset).
556: * Back out. Must unfreeze inline since we'already
557: * dropped our reference.
558: */
559: #if MACH_HOST
560: assert(task->may_assign == FALSE);
561: task->may_assign = TRUE;
562: if (task->assign_active == TRUE) {
563: task->assign_active = FALSE;
564: thread_wakeup((event_t)&task->assign_active);
565: }
566: #endif /* MACH_HOST */
567: task_unlock(task);
568: pset_unlock(pset);
569: return;
570: }
571: ipc_port_release_send(task->wired_ledger_port);
572: ipc_port_release_send(task->paged_ledger_port);
573: pset_remove_task(pset,task);
574: task_unlock(task);
575: pset_unlock(pset);
576: pset_deallocate(pset);
577: if (task->kernel_loaded)
578: vm_map_remove(kernel_map, task->map->min_offset,
579: task->map->max_offset, VM_MAP_NO_FLAGS);
580: vm_map_deallocate(task->map);
581: is_release(task->itk_space);
582: task_prof_deallocate(task);
583: kfree((vm_offset_t)task->sp_attributes,
584: sched_policy[task->policy].sched_attributes_size);
585: zfree(task_zone, (vm_offset_t) task);
586: }
587:
588: /*
589: * task_act_iterate
590: *
591: * Ignores returncodes from called function.
592: * Already locked: Task
593: */
594: void
595: task_act_iterate(
596: task_t task,
597: kern_return_t (*func)(thread_act_t inc))
598: {
599: thread_act_t inc, ninc;
600: #if MACH_ASSERT
601: int c1 = task->thr_act_count, c2 = 0;
602: if (watchacts & WA_TASK)
603: printf("\ttask_act_iterate(task=%x, func=%x)\n", task, func);
604: #endif /* MACH_ASSERT */
605:
606: /* During iteration, find the next act _before_ calling the function,
607: because the function might remove the act from the task. */
608: for (inc = (thread_act_t)queue_first(&task->thr_acts);
609: inc != (thread_act_t)&task->thr_acts;
610: inc = ninc) {
611: ninc = (thread_act_t)queue_next(&inc->thr_acts);
612: #if MACH_ASSERT
613: c2++;
614: #endif
615: (void) (*func)(inc);
616: }
617:
618: #if MACH_ASSERT
619: if (c1 != c2) {
620: printf("task_act_iterate: thr_act_count %d not %d\n", c1, c2);
621: /* Recount in case above (*func)() changed list */
622: for (c2 = 0, inc = (thread_act_t)queue_first(&task->thr_acts);
623: inc != (thread_act_t)&task->thr_acts; inc = ninc) {
624: ninc = (thread_act_t)queue_next(&inc->thr_acts);
625: c2++;
626: }
627: printf("\t reset thr_act_count to %d\n",
628: task->thr_act_count = c2);
629: }
630: #endif
631: }
632:
633: void
634: task_deallocate(
635: task_t task)
636: {
637: if (task != TASK_NULL) {
638: int c;
639:
640: task_lock(task);
641: c = --task->ref_count;
642: if (c == 0)
643: task_free(task); /* unlocks task */
644: else
645: task_unlock(task);
646: }
647: }
648:
649: void
650: task_reference(
651: task_t task)
652: {
653: if (task != TASK_NULL) {
654: task_lock(task);
655: task->ref_count++;
656: task_unlock(task);
657: }
658: }
659:
660: /*
661: * task_terminate:
662: *
663: * Terminate the specified task. See comments on thread_terminate
664: * (kern/thread.c) about problems with terminating the "current task."
665: */
666:
667: kern_return_t
668: task_terminate(
669: task_t task)
670: {
671: if (task == TASK_NULL)
672: return(KERN_INVALID_ARGUMENT);
673: if (task->bsd_info)
674: return(KERN_FAILURE);
675: return (task_terminate_internal(task));
676: }
677:
678: kern_return_t
679: task_terminate_internal(
680: task_t task)
681: {
682: register thread_t thread, cur_thread;
683: register queue_head_t *list;
684: register task_t cur_task;
685: thread_act_t thr_act, next_thr_act, cur_thr_act;
686: spl_t s;
687:
688: assert(task != kernel_task);
689:
690: list = &task->thr_acts;
691: cur_task = current_task();
692: cur_thr_act = current_thread()->top_act;
693:
694: #if TASK_SWAPPER
695: /*
696: * If task is not resident (swapped out, or being swapped
697: * out), we want to bring it back in (this can block).
698: * NOTE: The only way that this can happen in the current
699: * system is if the task is swapped while it has a thread
700: * in exit(), and the thread does not hit a clean point
701: * to swap itself before getting here.
702: * Terminating other tasks is another way to this code, but
703: * it is not yet fully supported.
704: * The task_swapin is unconditional. It used to be done
705: * only if the task is not resident. Swapping in a
706: * resident task will prevent it from being swapped out
707: * while it terminates.
708: */
709: task_swapin(task, TRUE); /* TRUE means make it unswappable */
710: #endif /* TASK_SWAPPER */
711:
712: /*
713: * Deactivate task so that it can't be terminated again,
714: * and so lengthy operations in progress will abort.
715: *
716: * If the current thread is in this task, remove it from
717: * the task's thread list to keep the thread-termination
718: * loop simple.
719: */
720: if (task == cur_task) {
721: task_lock(task);
722: if (!task->active) {
723: /*
724: * Task is already being terminated.
725: */
726: task_unlock(task);
727: thread_block((void (*)(void)) 0);
728: return(KERN_FAILURE);
729: }
730:
731: task_hold_locked(task);
732:
733: task->active = FALSE;
734:
735: /*
736: * Make sure current thread is not being terminated.
737: */
738: mutex_lock(&task->act_list_lock);
739: cur_thread = act_lock_thread(cur_thr_act);
740: if (!cur_thr_act->active) {
741: act_unlock_thread(cur_thr_act);
742: mutex_unlock(&task->act_list_lock);
743: task_unlock(task);
744: task_release(task);
745: thread_terminate(cur_thr_act);
746: return(KERN_FAILURE);
747: }
748:
749: /*
750: * make sure that this thread is the last one in the list
751: */
752: queue_remove(list, cur_thr_act, thread_act_t, thr_acts);
753: queue_enter(list, cur_thr_act, thread_act_t, thr_acts);
754: act_unlock_thread(cur_thr_act);
755: mutex_unlock(&task->act_list_lock);
756:
757: /*
758: * Shut down this thread's ipc now because it must
759: * be left alone to terminate the task.
760: */
761: ipc_thr_act_disable(cur_thr_act);
762: ipc_thr_act_terminate(cur_thr_act);
763: }
764: else {
765: /*
766: * Lock both current and victim task to check for
767: * potential deadlock.
768: */
769: if (task < cur_task) {
770: task_lock(task);
771: task_lock(cur_task);
772: }
773: else {
774: task_lock(cur_task);
775: task_lock(task);
776: }
777: /*
778: * Check if current thread_act or task is being terminated.
779: */
780: cur_thread = act_lock_thread(cur_thr_act);
781: if ((!cur_task->active) || (!cur_thr_act->active)) {
782: /*
783: * Current task or thread is being terminated.
784: */
785: act_unlock_thread(cur_thr_act);
786: task_unlock(task);
787: task_unlock(cur_task);
788: return(KERN_FAILURE);
789: }
790: act_unlock_thread(cur_thr_act);
791: task_unlock(cur_task);
792:
793: if (!task->active) {
794: /*
795: * Task is already being terminated.
796: */
797: task_unlock(task);
798: thread_block((void (*)(void)) 0);
799: return(KERN_FAILURE);
800: }
801: task_hold_locked(task);
802: task->active = FALSE;
803: }
804:
805: /*
806: * Prevent further execution of the task. ipc_task_disable
807: * prevents further task operations via the task port.
808: * If this is the current task, the current thread will
809: * be left running.
810: */
811: ipc_task_disable(task);
812: task_wait_locked(task);
813:
814: /*
815: * Terminate each thread in the task. Depending on the
816: * state of the thread, this can mean a number of things.
817: * However, we just call thread_terminate(), which
818: * takes care of all cases (see that code for details).
819: *
820: * The task_port is closed down, so no more thread_create
821: * operations can be done. Thread_terminate closes the
822: * thread port for each thread; when that is done, the
823: * thread will eventually disappear. Thus the loop will
824: * terminate.
825: * Need to call thread_block() inside loop because some
826: * other thread (e.g., the reaper) may have to run to get rid
827: * of all references to the thread; it won't vanish from
828: * the task's thread list until the last one is gone.
829: */
830: thr_act = (thread_act_t)queue_first(&task->thr_acts);
831: while ( thr_act!= (thread_act_t)&task->thr_acts) {
832: act_reference(thr_act);
833: next_thr_act = (thread_act_t)queue_next(&thr_act->thr_acts);
834: task_unlock(task);
835: thread_terminate(thr_act);
836: act_deallocate(thr_act);
837: task_lock(task);
838: thr_act = next_thr_act;
839: }
840:
841: task_unlock(task);
842:
843: /*
844: * Destroy all synchronizers owned by the task.
845: */
846: task_synchronizer_destroy_all(task);
847:
848: /*
849: * Shut down IPC.
850: */
851: ipc_task_terminate(task);
852:
853: /*
854: * Deallocate all subsystems owned by the task.
855: */
856: task_subsystem_destroy_all(task);
857:
858: /*
859: * If the current thread is a member of the task
860: * being terminated, then the last reference to
861: * the task will not be dropped until the thread
862: * is finally reaped. To avoid incurring the
863: * expense of removing the address space regions
864: * at reap time, we do it explictly here.
865: */
866: (void) vm_map_remove(task->map,
867: task->map->min_offset,
868: task->map->max_offset, VM_MAP_NO_FLAGS);
869:
870: /*
871: * Deallocate the task's reference to itself.
872: */
873: task_deallocate(task);
874:
875: return(KERN_SUCCESS);
876: }
877:
878: /*
879: * Wait for all threads in task to terminate (except current).
880: * We rely on the fact that all the other threads cache references
881: * to the task's VM map, and when we are alone in the task the
882: * reference count on the map should reach two (one for the task
883: * itself and one for the current act).
884: */
885: void
886: task_halt_wait(
887: register task_t task)
888: {
889: vm_map_t map = task->map;
890:
891: assert(current_thread()->top_act->task == task);
892:
893: /*
894: * Wait for the current thread to become the only thread in
895: * this task.
896: */
897: /*
898: * Now wait for the map users to settle down.
899: */
900: mutex_lock(&map->s_lock);
901: while (map->ref_count > 2) {
902: assert_wait(&map->ref_count, THREAD_UNINT);
903: mutex_unlock(&map->s_lock);
904: thread_block(0);
905: mutex_lock(&map->s_lock);
906: }
907: mutex_unlock(&map->s_lock);
908: }
909:
910: /*
911: * task_halt - Shut the current task down (except for the current thread) in
912: * preparation for dramatic changes to the task (probably exec).
913: * We hold the task, terminate all other threads in the task and
914: * wait for them to terminate, clean up the portspace, and when
915: * all done, let the current thread go.
916: */
917: kern_return_t
918: task_halt(
919: task_t task)
920: {
921: register thread_t thread, cur_thread;
922: register queue_head_t *list;
923: register task_t cur_task;
924: thread_act_t thr_act, cur_thr_act;
925: spl_t s;
926:
927: assert(task != kernel_task);
928:
929: cur_task = current_task();
930: if (task != cur_task) {
931: return(KERN_INVALID_ARGUMENT);
932: }
933:
934: #if TASK_SWAPPER
935: /*
936: * If task is not resident (swapped out, or being swapped
937: * out), we want to bring it back in (this can block).
938: * NOTE: The only way that this can happen in the current
939: * system is if the task is swapped while it has a thread
940: * in exit(), and the thread does not hit a clean point
941: * to swap itself before getting here.
942: * Terminating other tasks is another way to this code, but
943: * it is not yet fully supported.
944: * The task_swapin is unconditional. It used to be done
945: * only if the task is not resident. Swapping in a
946: * resident task will prevent it from being swapped out
947: * while it terminates.
948: */
949: task_swapin(task, TRUE); /* TRUE means make it unswappable */
950: #endif /* TASK_SWAPPER */
951:
952: /*
953: * Deactivate task so that it can't be terminated again,
954: * and so lengthy operations in progress will abort.
955: *
956: * If the current thread is in this task, remove it from
957: * the task's thread list to keep the thread-termination
958: * loop simple.
959: */
960: task_lock(task);
961: if (!task->active) {
962: /*
963: * Task is already being terminated.
964: */
965: task_unlock(task);
966: thread_block((void (*)(void)) 0);
967: return(KERN_FAILURE);
968: }
969: task_hold_locked(task);
970:
971: /*
972: * Make sure current thread is not being terminated.
973: */
974: cur_thr_act = current_thread()->top_act;
975: mutex_lock(&task->act_list_lock);
976: cur_thread = act_lock_thread(cur_thr_act);
977: if (!cur_thr_act->active) {
978: act_unlock_thread(cur_thr_act);
979: mutex_unlock(&task->act_list_lock);
980: task_unlock(task);
981: task_release(task);
982: thread_terminate(cur_thr_act);
983: return(KERN_FAILURE);
984: }
985:
986: task->active = FALSE;
987:
988: /*
989: * Make sure that this thread is the last one in the list
990: */
991: list = &task->thr_acts;
992: queue_remove(list, cur_thr_act, thread_act_t, thr_acts);
993: queue_enter(list, cur_thr_act, thread_act_t, thr_acts);
994: act_unlock_thread(cur_thr_act);
995: mutex_unlock(&task->act_list_lock);
996:
997: /*
998: * Wait for threads to get to clean points.
999: */
1000: task_wait_locked(task);
1001:
1002: /*
1003: * Now that each thread in the task is at a clean point (and the
1004: * task is temporarily marked inactive so no new threads can be
1005: * created), we terminate each of those other threads.
1006: */
1007: for (thr_act = (thread_act_t)queue_first(&task->thr_acts);
1008: thr_act != (thread_act_t)cur_thr_act;
1009: thr_act = (thread_act_t)queue_next(&thr_act->thr_acts)) {
1010: act_reference(thr_act);
1011: task_unlock(task);
1012: thread_terminate(thr_act);
1013: act_deallocate(thr_act);
1014: task_lock(task);
1015: }
1016: task_unlock(task);
1017:
1018: /*
1019: * Wait for the the other threads to exit.
1020: */
1021: task_halt_wait(task);
1022:
1023: /*
1024: * Put it back as active and release the hold on the task
1025: */
1026: task_lock(task);
1027: task->active = TRUE;
1028: task_unlock(task);
1029: task_release(task);
1030: return(KERN_SUCCESS);
1031: }
1032:
1033: /*
1034: * Clean up a task for possible reuse (like after exec).
1035: */
1036: void
1037: task_ipc_cleanup(
1038: task_t task)
1039: {
1040: /*
1041: * Remove all the port rights from the task's IPC port space.
1042: */
1043: ipc_space_clean(task->itk_space);
1044:
1045: /*
1046: * Destroy all synchronizers owned by the task.
1047: */
1048: task_synchronizer_destroy_all(task);
1049:
1050: /*
1051: * Deallocate all subsystems owned by the task.
1052: */
1053: task_subsystem_destroy_all(task);
1054:
1055: }
1056:
1057: /*
1058: * task_hold_locked:
1059: *
1060: * Suspend execution of the specified task.
1061: * This is a recursive-style suspension of the task, a count of
1062: * suspends is maintained.
1063: *
1064: * CONDITIONS: the task is locked.
1065: */
1066: kern_return_t
1067: task_hold_locked(
1068: register task_t task)
1069: {
1070: register queue_head_t *list;
1071: register thread_act_t thr_act, cur_thr_act;
1072:
1073: cur_thr_act = current_act();
1074:
1075: if (!task->active) {
1076: return(KERN_FAILURE);
1077: }
1078:
1079: task->suspend_count++;
1080:
1081: /*
1082: * Iterate through all the thread_act's and hold them.
1083: * Do not hold the current thread_act if it is within the
1084: * task.
1085: */
1086: list = &task->thr_acts;
1087: thr_act = (thread_act_t) queue_first(list);
1088: while (!queue_end(list, (queue_entry_t) thr_act)) {
1089: (void)act_lock_thread(thr_act);
1090: thread_hold(thr_act);
1091: act_unlock_thread(thr_act);
1092: thr_act = (thread_act_t) queue_next(&thr_act->thr_acts);
1093: }
1094: return(KERN_SUCCESS);
1095: }
1096:
1097: kern_return_t
1098: task_release(
1099: register task_t task)
1100: {
1101: register queue_head_t *list;
1102: register thread_act_t thr_act, next;
1103:
1104: task_lock(task);
1105: if (!task->active) {
1106: task_unlock(task);
1107: return(KERN_FAILURE);
1108: }
1109:
1110: task->suspend_count--;
1111:
1112: /*
1113: * Iterate through all the thread_act's and release them.
1114: */
1115: list = &task->thr_acts;
1116: thr_act = (thread_act_t) queue_first(list);
1117: while (!queue_end(list, (queue_entry_t) thr_act)) {
1118: next = (thread_act_t) queue_next(&thr_act->thr_acts);
1119: (void)act_lock_thread(thr_act);
1120: thread_release(thr_act);
1121: act_unlock_thread(thr_act);
1122: thr_act = next;
1123: }
1124: task_unlock(task);
1125: return(KERN_SUCCESS);
1126: }
1127:
1128: kern_return_t
1129: task_threads(
1130: task_t task,
1131: thread_act_array_t *thr_act_list,
1132: mach_msg_type_number_t *count)
1133: {
1134: unsigned int actual; /* this many thr_acts */
1135: thread_act_t thr_act;
1136: thread_act_t *thr_acts;
1137: thread_t thread;
1138: int i, j;
1139: boolean_t rt = FALSE; /* ### This boolean is FALSE, because there
1140: * currently exists no mechanism to determine
1141: * whether or not the reply port is an RT port
1142: */
1143:
1144:
1145: vm_size_t size, size_needed;
1146: vm_offset_t addr;
1147:
1148: if (task == TASK_NULL)
1149: return KERN_INVALID_ARGUMENT;
1150:
1151: size = 0; addr = 0;
1152:
1153: for (;;) {
1154: task_lock(task);
1155: if (!task->active) {
1156: task_unlock(task);
1157: if (size != 0)
1158: KFREE(addr, size, rt);
1159: return KERN_FAILURE;
1160: }
1161:
1162: actual = task->thr_act_count;
1163:
1164: /* do we have the memory we need? */
1165: size_needed = actual * sizeof(mach_port_t);
1166: if (size_needed <= size)
1167: break;
1168:
1169: /* unlock the task and allocate more memory */
1170: task_unlock(task);
1171:
1172: if (size != 0)
1173: KFREE(addr, size, rt);
1174:
1175: assert(size_needed > 0);
1176: size = size_needed;
1177:
1178: addr = KALLOC(size, rt);
1179: if (addr == 0)
1180: return KERN_RESOURCE_SHORTAGE;
1181: }
1182:
1183: /* OK, have memory and the task is locked & active */
1184: thr_acts = (thread_act_t *) addr;
1185:
1186: for (i = j = 0, thr_act = (thread_act_t) queue_first(&task->thr_acts);
1187: i < actual;
1188: i++, thr_act = (thread_act_t) queue_next(&thr_act->thr_acts)) {
1189: act_reference(thr_act);
1190: thr_acts[j++] = thr_act;
1191: }
1192: assert(queue_end(&task->thr_acts, (queue_entry_t) thr_act));
1193: actual = j;
1194:
1195: /* can unlock task now that we've got the thr_act refs */
1196: task_unlock(task);
1197:
1198: if (actual == 0) {
1199: /* no thr_acts, so return null pointer and deallocate memory */
1200:
1201: *thr_act_list = 0;
1202: *count = 0;
1203:
1204: if (size != 0)
1205: KFREE(addr, size, rt);
1206: } else {
1207: /* if we allocated too much, must copy */
1208:
1209: if (size_needed < size) {
1210: vm_offset_t newaddr;
1211:
1212: newaddr = KALLOC(size_needed, rt);
1213: if (newaddr == 0) {
1214: for (i = 0; i < actual; i++)
1215: act_deallocate(thr_acts[i]);
1216: KFREE(addr, size, rt);
1217: return KERN_RESOURCE_SHORTAGE;
1218: }
1219:
1220: bcopy((char *) addr, (char *) newaddr, size_needed);
1221: KFREE(addr, size, rt);
1222: thr_acts = (thread_act_t *) newaddr;
1223: }
1224:
1225: *thr_act_list = thr_acts;
1226: *count = actual;
1227:
1228: /* do the conversion that Mig should handle */
1229:
1230: for (i = 0; i < actual; i++)
1231: ((ipc_port_t *) thr_acts)[i] =
1232: convert_act_to_port(thr_acts[i]);
1233: }
1234:
1235: return KERN_SUCCESS;
1236: }
1237:
1238: kern_return_t
1239: task_suspend(
1240: register task_t task)
1241: {
1242: if (task == TASK_NULL)
1243: return (KERN_INVALID_ARGUMENT);
1244:
1245: task_lock(task);
1246: if (!task->active) {
1247: task_unlock(task);
1248: return (KERN_FAILURE);
1249: }
1250: if ((task->user_stop_count)++ > 0) {
1251: /*
1252: * If the stop count was positive, the task is
1253: * already stopped and we can exit.
1254: */
1255: task_unlock(task);
1256: return (KERN_SUCCESS);
1257: }
1258:
1259: /*
1260: * Hold all of the threads in the task, and wait for
1261: * them to stop. If the current thread is within
1262: * this task, hold it separately so that all of the
1263: * other threads can stop first.
1264: */
1265: if (task_hold_locked(task) != KERN_SUCCESS) {
1266: task_unlock(task);
1267: return (KERN_FAILURE);
1268: }
1269:
1270: task_wait_locked(task);
1271: task_unlock(task);
1272: return (KERN_SUCCESS);
1273: }
1274:
1275: /*
1276: * Wait for all threads in task to stop. Called with task locked.
1277: */
1278: void
1279: task_wait_locked(
1280: register task_t task)
1281: {
1282: register queue_head_t *list;
1283: register thread_act_t thr_act, refd_thr_act;
1284: register thread_t thread, cur_thr;
1285:
1286: cur_thr = current_thread();
1287: /*
1288: * Iterate through all the thread's and wait for them to
1289: * stop. Do not wait for the current thread if it is within
1290: * the task.
1291: */
1292: list = &task->thr_acts;
1293: refd_thr_act = THR_ACT_NULL;
1294: for (;;) {
1295: thr_act = (thread_act_t) queue_first(list);
1296: while (!queue_end(list, (queue_entry_t) thr_act)) {
1297: thread = act_lock_thread(thr_act);
1298: if (refd_thr_act != THR_ACT_NULL) {
1299: act_deallocate(refd_thr_act);
1300: refd_thr_act = THR_ACT_NULL;
1301: }
1302: if (thread != THREAD_NULL &&
1303: thr_act == thread->top_act &&
1304: thread != cur_thr) {
1305: refd_thr_act = thr_act;
1306: act_locked_act_reference(thr_act);
1307: act_unlock_thread(thr_act);
1308: task_unlock(task);
1309: (void)thread_wait(thread);
1310: task_lock(task);
1311: thread = act_lock_thread(thr_act);
1312: if (!thr_act->active) {
1313: act_unlock_thread(thr_act);
1314: /* drop reference to act immediately */
1315: task_unlock(task);
1316: act_deallocate(refd_thr_act);
1317: refd_thr_act = THR_ACT_NULL;
1318: task_lock(task);
1319: break;
1320: }
1321: }
1322: act_unlock_thread(thr_act);
1323: thr_act = (thread_act_t)queue_next(&thr_act->thr_acts);
1324: }
1325: if (queue_end(list, (queue_entry_t)thr_act))
1326: break;
1327: }
1328: if (refd_thr_act != THR_ACT_NULL) {
1329: act_deallocate(refd_thr_act);
1330: refd_thr_act = THR_ACT_NULL;
1331: }
1332: }
1333:
1334: kern_return_t
1335: task_resume(register task_t task)
1336: {
1337: register boolean_t release;
1338:
1339: if (task == TASK_NULL)
1340: return(KERN_INVALID_ARGUMENT);
1341:
1342: release = FALSE;
1343: task_lock(task);
1344: if (!task->active) {
1345: task_unlock(task);
1346: return(KERN_FAILURE);
1347: }
1348: if (task->user_stop_count > 0) {
1349: if (--(task->user_stop_count) == 0)
1350: release = TRUE;
1351: }
1352: else {
1353: task_unlock(task);
1354: return(KERN_FAILURE);
1355: }
1356: task_unlock(task);
1357:
1358: /*
1359: * Release the task if necessary.
1360: */
1361: if (release)
1362: return(task_release(task));
1363:
1364: return(KERN_SUCCESS);
1365: }
1366:
1367: kern_return_t
1368: host_security_set_task_token(
1369: host_security_t host_security,
1370: task_t task,
1371: security_token_t sec_token)
1372: {
1373: if (task == TASK_NULL)
1374: return(KERN_INVALID_ARGUMENT);
1375:
1376: if (host_security == HOST_NULL)
1377: return(KERN_INVALID_SECURITY);
1378:
1379: task_lock(task);
1380: task->sec_token = sec_token;
1381: task_unlock(task);
1382:
1383: return(KERN_SUCCESS);
1384: }
1385:
1386: /*
1387: * Utility routine to set a ledger
1388: */
1389: kern_return_t
1390: task_set_ledger(
1391: task_t task,
1392: ledger_t wired,
1393: ledger_t paged)
1394: {
1395: if (task == TASK_NULL)
1396: return(KERN_INVALID_ARGUMENT);
1397:
1398: task_lock(task);
1399: if (wired) {
1400: ipc_port_release_send(task->wired_ledger_port);
1401: task->wired_ledger_port = ledger_copy(wired);
1402: }
1403: if (paged) {
1404: ipc_port_release_send(task->paged_ledger_port);
1405: task->paged_ledger_port = ledger_copy(paged);
1406: }
1407: task_unlock(task);
1408:
1409: return(KERN_SUCCESS);
1410: }
1411:
1412: /*
1413: * This routine was added, pretty much exclusively, for registering the
1414: * RPC glue vector for in-kernel short circuited tasks. Rather than
1415: * removing it completely, I have only disabled that feature (which was
1416: * the only feature at the time). It just appears that we are going to
1417: * want to add some user data to tasks in the future (i.e. bsd info,
1418: * task names, etc...), so I left it in the formal task interface.
1419: */
1420: kern_return_t
1421: task_set_info(
1422: task_t task,
1423: task_flavor_t flavor,
1424: task_info_t task_info_in, /* pointer to IN array */
1425: mach_msg_type_number_t task_info_count)
1426: {
1427: vm_map_t map;
1428:
1429: if (task == TASK_NULL)
1430: return(KERN_INVALID_ARGUMENT);
1431:
1432: switch (flavor) {
1433: default:
1434: return (KERN_INVALID_ARGUMENT);
1435: }
1436: return (KERN_SUCCESS);
1437: }
1438:
1439: kern_return_t
1440: task_info(
1441: task_t task,
1442: task_flavor_t flavor,
1443: task_info_t task_info_out,
1444: mach_msg_type_number_t *task_info_count)
1445: {
1446: thread_t thread;
1447: vm_map_t map;
1448:
1449: if (task == TASK_NULL)
1450: return(KERN_INVALID_ARGUMENT);
1451:
1452: switch (flavor) {
1453:
1454: case TASK_BASIC_INFO:
1455: {
1456: register task_basic_info_t basic_info;
1457:
1458: if (*task_info_count < TASK_BASIC_INFO_COUNT) {
1459: return(KERN_INVALID_ARGUMENT);
1460: }
1461:
1462: basic_info = (task_basic_info_t) task_info_out;
1463:
1464: map = (task == kernel_task) ? kernel_map : task->map;
1465:
1466: basic_info->virtual_size = map->size;
1467: basic_info->resident_size = pmap_resident_count(map->pmap)
1468: * PAGE_SIZE;
1469:
1470: task_lock(task);
1471: basic_info->policy = task->policy;
1472: basic_info->suspend_count = task->user_stop_count;
1473: basic_info->user_time.seconds
1474: = task->total_user_time.seconds;
1475: basic_info->user_time.microseconds
1476: = task->total_user_time.microseconds;
1477: basic_info->system_time.seconds
1478: = task->total_system_time.seconds;
1479: basic_info->system_time.microseconds
1480: = task->total_system_time.microseconds;
1481: task_unlock(task);
1482:
1483: *task_info_count = TASK_BASIC_INFO_COUNT;
1484: break;
1485: }
1486:
1487: case TASK_THREAD_TIMES_INFO:
1488: {
1489: register task_thread_times_info_t times_info;
1490: register thread_t thread;
1491: register thread_act_t thr_act;
1492:
1493: if (*task_info_count < TASK_THREAD_TIMES_INFO_COUNT) {
1494: return (KERN_INVALID_ARGUMENT);
1495: }
1496:
1497: times_info = (task_thread_times_info_t) task_info_out;
1498: times_info->user_time.seconds = 0;
1499: times_info->user_time.microseconds = 0;
1500: times_info->system_time.seconds = 0;
1501: times_info->system_time.microseconds = 0;
1502:
1503: task_lock(task);
1504: queue_iterate(&task->thr_acts, thr_act,
1505: thread_act_t, thr_acts)
1506: {
1507: time_value_t user_time, system_time;
1508: spl_t s;
1509:
1510: thread = act_lock_thread(thr_act);
1511:
1512: /* Skip empty threads and threads that have migrated
1513: * into this task:
1514: */
1515: if (thr_act->pool_port) {
1516: act_unlock_thread(thr_act);
1517: continue;
1518: }
1519: assert(thread); /* Must have thread, if no thread_pool*/
1520: s = splsched();
1521: thread_lock(thread);
1522:
1523: thread_read_times(thread, &user_time, &system_time);
1524:
1525: thread_unlock(thread);
1526: splx(s);
1527: act_unlock_thread(thr_act);
1528:
1529: time_value_add(×_info->user_time, &user_time);
1530: time_value_add(×_info->system_time, &system_time);
1531: }
1532: task_unlock(task);
1533:
1534: *task_info_count = TASK_THREAD_TIMES_INFO_COUNT;
1535: break;
1536: }
1537:
1538: case TASK_SCHED_FIFO_INFO:
1539: {
1540: register policy_fifo_base_t fifo_base;
1541:
1542: if (*task_info_count < POLICY_FIFO_BASE_COUNT)
1543: return(KERN_INVALID_ARGUMENT);
1544:
1545: fifo_base = (policy_fifo_base_t) task_info_out;
1546:
1547: task_lock(task);
1548: if (task->policy != POLICY_FIFO) {
1549: task_unlock(task);
1550: return(KERN_INVALID_POLICY);
1551: }
1552: /*** ??? fix me ***/
1553: assert(task->sp_attributes != SP_ATTRIBUTES_NULL);
1554: fifo_base->base_priority =
1555: ((mk_sp_attributes_t)task->sp_attributes)->priority;
1556: task_unlock(task);
1557:
1558: *task_info_count = POLICY_FIFO_BASE_COUNT;
1559: break;
1560: }
1561:
1562: case TASK_SCHED_RR_INFO:
1563: {
1564: register policy_rr_base_t rr_base;
1565:
1566: if (*task_info_count < POLICY_RR_BASE_COUNT)
1567: return(KERN_INVALID_ARGUMENT);
1568:
1569: rr_base = (policy_rr_base_t) task_info_out;
1570:
1571: task_lock(task);
1572: if (task->policy != POLICY_RR) {
1573: task_unlock(task);
1574: return(KERN_INVALID_POLICY);
1575: }
1576: /*** ??? fix me ***/
1577: assert(task->sp_attributes != SP_ATTRIBUTES_NULL);
1578: rr_base->base_priority =
1579: ((mk_sp_attributes_t)task->sp_attributes)->priority;
1580: rr_base->quantum =
1581: (((mk_sp_attributes_t)task->sp_attributes)->sched_data
1582: * tick) / 1000;
1583: task_unlock(task);
1584:
1585: *task_info_count = POLICY_RR_BASE_COUNT;
1586: break;
1587: }
1588:
1589: case TASK_SCHED_TIMESHARE_INFO:
1590: {
1591: register policy_timeshare_base_t ts_base;
1592:
1593: if (*task_info_count < POLICY_TIMESHARE_BASE_COUNT)
1594: return(KERN_INVALID_ARGUMENT);
1595:
1596: ts_base = (policy_timeshare_base_t) task_info_out;
1597:
1598: task_lock(task);
1599: if (task->policy != POLICY_TIMESHARE) {
1600: task_unlock(task);
1601: return(KERN_INVALID_POLICY);
1602: }
1603: /*** ??? fix me ***/
1604: assert(task->sp_attributes != SP_ATTRIBUTES_NULL);
1605: ts_base->base_priority =
1606: ((mk_sp_attributes_t)task->sp_attributes)->priority;
1607: task_unlock(task);
1608:
1609: *task_info_count = POLICY_TIMESHARE_BASE_COUNT;
1610: break;
1611: }
1612:
1613: case TASK_SECURITY_TOKEN:
1614: {
1615: register security_token_t *sec_token_p;
1616:
1617: if (*task_info_count < TASK_SECURITY_TOKEN_COUNT) {
1618: return(KERN_INVALID_ARGUMENT);
1619: }
1620:
1621: sec_token_p = (security_token_t *) task_info_out;
1622:
1623: task_lock(task);
1624: *sec_token_p = task->sec_token;
1625: task_unlock(task);
1626:
1627: *task_info_count = TASK_SECURITY_TOKEN_COUNT;
1628: break;
1629: }
1630:
1631: case TASK_SCHED_INFO:
1632: {
1633: int count = sched_policy[task->policy].sched_attributes_size;
1634:
1635: if (*task_info_count < (((count-1)/sizeof(int)) + 1))
1636: return(KERN_INVALID_ARGUMENT);
1637:
1638: task_lock(task);
1639:
1640: bcopy((char *)task->sp_attributes,
1641: (char *)task_info_out,
1642: count);
1643:
1644: task_unlock(task);
1645:
1646: *task_info_count = count;
1647: break;
1648: }
1649:
1650: case TASK_EVENTS_INFO:
1651: {
1652: register task_events_info_t events_info;
1653:
1654: if (*task_info_count < TASK_EVENTS_INFO_COUNT) {
1655: return(KERN_INVALID_ARGUMENT);
1656: }
1657:
1658: events_info = (task_events_info_t) task_info_out;
1659:
1660: task_lock(task);
1661: events_info->faults = task->faults;
1662: events_info->pageins = task->pageins;
1663: events_info->cow_faults = task->cow_faults;
1664: events_info->messages_sent = task->messages_sent;
1665: events_info->messages_received = task->messages_received;
1666: events_info->syscalls_mach = task->syscalls_mach;
1667: events_info->syscalls_unix = task->syscalls_unix;
1668: events_info->csw = task->csw;
1669: task_unlock(task);
1670:
1671: *task_info_count = TASK_EVENTS_INFO_COUNT;
1672: break;
1673: }
1674:
1675: default:
1676: return (KERN_INVALID_ARGUMENT);
1677: }
1678:
1679: return(KERN_SUCCESS);
1680: }
1681:
1682: #if MACH_HOST
1683:
1684: /*
1685: * task_assign:
1686: *
1687: * Change the assigned processor set for the task
1688: */
1689: kern_return_t
1690: task_assign(
1691: task_t task,
1692: processor_set_t new_pset,
1693: boolean_t assign_threads)
1694: {
1695: kern_return_t ret = KERN_SUCCESS;
1696: register thread_t thread, prev_thread;
1697: register queue_head_t *list;
1698: register processor_set_t pset;
1699: int max_priority;
1700:
1701: if (task == TASK_NULL || new_pset == PROCESSOR_SET_NULL) {
1702: return(KERN_INVALID_ARGUMENT);
1703: }
1704:
1705: task_lock(task);
1706:
1707: /*
1708: * If may_assign is false, task is already being assigned,
1709: * wait for that to finish.
1710: */
1711: while (task->may_assign == FALSE) {
1712: task->assign_active = TRUE;
1713: assert_wait((event_t)&task->assign_active, THREAD_ABORTSAFE);
1714: task_unlock(task);
1715: thread_block((void (*)(void)) 0);
1716: task_lock(task);
1717: }
1718:
1719: /*
1720: * Do assignment. If new pset is dead, redirect to default.
1721: */
1722: pset = task->processor_set;
1723: pset_lock(pset);
1724: pset_remove_task(pset,task);
1725: pset_unlock(pset);
1726: pset_deallocate(pset);
1727:
1728: pset_lock(new_pset);
1729: if (!new_pset->active) {
1730: pset_unlock(new_pset);
1731: new_pset = &default_pset;
1732: pset_lock(new_pset);
1733: }
1734:
1735: /*
1736: * Reset policy and priorities if needed.
1737: *
1738: * There are three rules for tasks under assignment:
1739: *
1740: * (1) If the new pset has the old policy enabled, keep the
1741: * old policy. Otherwise, use the default policy for the pset.
1742: * (2) The new limits will be the pset limits for the new policy.
1743: * (3) The new base will be the same as the old base unless either
1744: * (a) the new policy changed to the pset default policy;
1745: * in this case, the new base is the default policy
1746: * base,
1747: * or
1748: * (b) the new limits are different from the old limits;
1749: * in this case, the new base is the new limits.
1750: */
1751: max_priority = pset_max_priority(new_pset, task->policy);
1752: if ((task->policy & new_pset->policies) == 0) {
1753: task->policy = new_pset->policy_default;
1754: task->sched_data = pset_sched_data(new_pset, task->policy);
1755: task->priority = pset_base_priority(new_pset, task->policy);
1756: max_priority = pset_max_priority(new_pset, task->policy);
1757: }
1758: else if (task->max_priority != max_priority) {
1759: task->priority = max_priority;
1760: }
1761:
1762: task->max_priority = max_priority;
1763:
1764: pset_add_task(new_pset,task);
1765: pset_unlock(new_pset);
1766:
1767: if (assign_threads == FALSE) {
1768: task_unlock(task);
1769: return(KERN_SUCCESS);
1770: }
1771:
1772: /*
1773: * Now freeze this assignment while we get the threads
1774: * to catch up to it.
1775: */
1776: task->may_assign = FALSE;
1777:
1778: /*
1779: * If current thread is in task, freeze its assignment.
1780: */
1781: if (current_act()->task == task) {
1782: task_unlock(task);
1783: thread_freeze(current_thread());
1784: task_lock(task);
1785: }
1786:
1787: /*
1788: * Iterate down the thread list reassigning all the threads.
1789: * ("Base" threads only, please; psets belong to them)
1790: * New threads pick up task's new processor set automatically.
1791: * Do current thread last because new pset may be empty.
1792: */
1793: { thread_act_t thr_act;
1794: int i;
1795:
1796: prev_thread = THREAD_NULL;
1797: for (i = 0, thr_act = (thread_act_t) queue_first(&task->thr_acts);
1798: i < task->thr_act_count;
1799: i++, thr_act = (thread_act_t)queue_next(&thr_act->thr_acts)) {
1800:
1801: thread = act_lock_thread(thr_act);
1802: if (thr_act->pool_port) {
1803: act_unlock_thread(thr_act);
1804: continue;
1805: }
1806: if (!(task->active)) {
1807: ret = KERN_FAILURE;
1808: act_unlock_thread(thr_act);
1809: break;
1810: }
1811: assert(thread);
1812: if (thread == current_thread())
1813: act_unlock_thread(thr_act);
1814: else {
1815: thread_reference(thread);
1816: task_unlock(task);
1817: if (prev_thread != THREAD_NULL)
1818: thread_deallocate(prev_thread); /* may block */
1819: assert(thread->top_act);
1820: assert(thread->top_act->thread == thread);
1821: /*
1822: * Inline thread_assign() here to avoid silly double
1823: * conversion.
1824: */
1825: thread_freeze(thread);
1826: thread_doassign(thread, new_pset, TRUE);
1827: /*
1828: * All thread-related locks released at this point.
1829: */
1830: prev_thread = thread;
1831: task_lock(task);
1832: }
1833: }
1834: assert(queue_end(&task->thr_acts, (queue_entry_t)thr_act));
1835: }
1836:
1837: /*
1838: * Done, wakeup anyone waiting for us.
1839: */
1840: task->may_assign = TRUE;
1841: if (task->assign_active) {
1842: task->assign_active = FALSE;
1843: thread_wakeup((event_t)&task->assign_active);
1844: }
1845: task_unlock(task);
1846: if (prev_thread != THREAD_NULL)
1847: thread_deallocate(prev_thread); /* may block */
1848:
1849: /*
1850: * Finish assignment of current thread.
1851: */
1852: if (current_act()->task == task) {
1853: thread = act_lock_thread(current_act());
1854: thread_doassign(thread, new_pset, TRUE);
1855: /*
1856: * All thread-related locks released at this point.
1857: */
1858: }
1859:
1860: return(ret);
1861: }
1862: #else /* MACH_HOST */
1863: /*
1864: * task_assign:
1865: *
1866: * Change the assigned processor set for the task
1867: */
1868: kern_return_t
1869: task_assign(
1870: task_t task,
1871: processor_set_t new_pset,
1872: boolean_t assign_threads)
1873: {
1874: #ifdef lint
1875: task++; new_pset++; assign_threads++;
1876: #endif /* lint */
1877: return(KERN_FAILURE);
1878: }
1879: #endif /* MACH_HOST */
1880:
1881:
1882: /*
1883: * task_assign_default:
1884: *
1885: * Version of task_assign to assign to default processor set.
1886: */
1887: kern_return_t
1888: task_assign_default(
1889: task_t task,
1890: boolean_t assign_threads)
1891: {
1892: return (task_assign(task, &default_pset, assign_threads));
1893: }
1894:
1895: /*
1896: * task_get_assignment
1897: *
1898: * Return name of processor set that task is assigned to.
1899: */
1900: kern_return_t
1901: task_get_assignment(
1902: task_t task,
1903: processor_set_t *pset)
1904: {
1905: if (!task->active)
1906: return(KERN_FAILURE);
1907:
1908: *pset = task->processor_set;
1909: pset_reference(*pset);
1910: return(KERN_SUCCESS);
1911: }
1912:
1913:
1914: /*
1915: * task_policy
1916: *
1917: * Set scheduling policy and parameters, both base and limit, for
1918: * the given task. Policy must be a policy which is enabled for the
1919: * processor set. Change contained threads if requested.
1920: */
1921: kern_return_t
1922: task_policy(
1923: task_t task,
1924: policy_t policy_id,
1925: policy_base_t base,
1926: mach_msg_type_number_t count,
1927: boolean_t set_limit,
1928: boolean_t change)
1929: {
1930: policy_limit_t limit;
1931: int limcount;
1932: processor_set_t pset;
1933: kern_return_t result = KERN_SUCCESS;
1934: sched_policy_t *policy;
1935:
1936: if ( task == TASK_NULL ||
1937: (pset = task->processor_set) == PROCESSOR_SET_NULL )
1938: return(KERN_INVALID_ARGUMENT);
1939:
1940: if (invalid_policy(policy_id) || (pset->policies & policy_id) == 0)
1941: return(KERN_INVALID_POLICY);
1942:
1943: /* call policy-specific routine */
1944: policy = &sched_policy[policy_id];
1945: result = policy->sp_ops.
1946: sp_task_policy(policy, task, policy_id,
1947: base, count, set_limit, change, &limit, &limcount);
1948:
1949: if (result != KERN_SUCCESS)
1950: return(result);
1951:
1952: result = task_set_policy(task, pset, policy_id,
1953: base, count, limit, limcount, change);
1954:
1955: return(result);
1956: }
1957:
1958: /*
1959: * task_set_policy
1960: *
1961: * Set scheduling policy and parameters, both base and limit, for
1962: * the given task. Policy can be any policy implemented by the
1963: * processor set, whether enabled or not. Change contained threads
1964: * if requested.
1965: */
1966: kern_return_t
1967: task_set_policy(
1968: task_t task,
1969: processor_set_t pset,
1970: policy_t policy_id,
1971: policy_base_t base,
1972: mach_msg_type_number_t base_count,
1973: policy_limit_t limit,
1974: mach_msg_type_number_t limit_count,
1975: boolean_t change)
1976: {
1977: kern_return_t result = KERN_SUCCESS;
1978: sched_policy_t *policy;
1979:
1980: if (task == TASK_NULL || pset == PROCESSOR_SET_NULL)
1981: return(KERN_INVALID_ARGUMENT);
1982:
1983: if (pset != task->processor_set)
1984: return(KERN_FAILURE);
1985:
1986: task_lock(task);
1987:
1988: /* call policy-specific routine */
1989: policy = &sched_policy[policy_id];
1990: result = policy->sp_ops.
1991: sp_task_set_policy(policy, task, pset, policy_id,
1992: base, base_count, limit, limit_count, change);
1993:
1994: if (result != KERN_SUCCESS) {
1995: task_unlock(task);
1996: return(result);
1997: }
1998:
1999: if (change) {
2000: register thread_act_t thr_act;
2001: register queue_head_t *list;
2002:
2003: list = &task->thr_acts;
2004: thr_act = (thread_act_t) queue_first(list);
2005: while (!queue_end(list, (queue_entry_t) thr_act)) {
2006: /*** ??? fix to call policy-dependent routine ***/
2007: thread_set_policy(thr_act, pset, policy_id,
2008: base, base_count,
2009: limit, limit_count);
2010: thr_act = (thread_act_t)queue_next(&thr_act->thr_acts);
2011: }
2012: }
2013:
2014: task_unlock(task);
2015: return(result);
2016: }
2017:
2018: /*
2019: * task_set_sched
2020: *
2021: * Set scheduling policy and parameters for the given task.
2022: * Policy must be a policy which is enabled for the
2023: * processor set. Change contained threads if requested.
2024: * (This should replace `task_policy()' with the addition
2025: * of the MK Scheduling Framework to the kernel.)
2026: */
2027: kern_return_t
2028: task_set_sched(
2029: task_t task,
2030: policy_t policy_id,
2031: sched_attr_t sched_attr,
2032: mach_msg_type_number_t sched_attrCnt,
2033: boolean_t set_limit,
2034: boolean_t change)
2035: {
2036: processor_set_t pset;
2037: sched_policy_t *policy;
2038:
2039: if ( task == TASK_NULL ||
2040: (pset = task->processor_set) == PROCESSOR_SET_NULL )
2041: return(KERN_INVALID_ARGUMENT);
2042:
2043: if (invalid_policy(policy_id) || (pset->policies & policy_id) == 0)
2044: return(KERN_INVALID_POLICY);
2045:
2046: /* call policy-specific routine */
2047: policy = &sched_policy[policy_id];
2048: return (policy->sp_ops.sp_task_set_sched(policy, task, policy_id,
2049: sched_attr, sched_attrCnt, set_limit, change));
2050: }
2051:
2052:
2053: /*
2054: * task_get_sched
2055: *
2056: * Get scheduling policy and parameters for the given task.
2057: * (This was added as part of the MK Scheduling Framework.)
2058: */
2059: kern_return_t
2060: task_get_sched(
2061: task_t task,
2062: policy_t policy_id,
2063: sched_attr_t sched_attr,
2064: mach_msg_type_number_t sched_attrCnt,
2065: int sched_attr_size)
2066: {
2067: processor_set_t pset;
2068: sched_policy_t *policy;
2069:
2070: if ( task == TASK_NULL ||
2071: (pset = task->processor_set) == PROCESSOR_SET_NULL )
2072: return(KERN_INVALID_ARGUMENT);
2073:
2074: /* call policy-specific routine */
2075: policy = &sched_policy[task->policy];
2076: return (policy->sp_ops.sp_task_get_sched(policy, task, policy_id,
2077: sched_attr, sched_attrCnt, sched_attr_size));
2078: }
2079:
2080:
2081: /*
2082: * task_collect_scan:
2083: *
2084: * Attempt to free resources owned by tasks.
2085: */
2086:
2087: void
2088: task_collect_scan(void)
2089: {
2090: register task_t task, prev_task;
2091: processor_set_t pset, prev_pset;
2092:
2093: prev_task = TASK_NULL;
2094: prev_pset = PROCESSOR_SET_NULL;
2095:
2096: mutex_lock(&all_psets_lock);
2097: pset = (processor_set_t) queue_first(&all_psets);
2098: while (!queue_end(&all_psets, (queue_entry_t) pset)) {
2099: pset_lock(pset);
2100: task = (task_t) queue_first(&pset->tasks);
2101: while (!queue_end(&pset->tasks, (queue_entry_t) task)) {
2102: task_reference(task);
2103: pset->ref_count++;
2104: pset_unlock(pset);
2105: mutex_unlock(&all_psets_lock);
2106:
2107: pmap_collect(task->map->pmap);
2108:
2109: if (prev_task != TASK_NULL)
2110: task_deallocate(prev_task);
2111: prev_task = task;
2112:
2113: if (prev_pset != PROCESSOR_SET_NULL)
2114: pset_deallocate(prev_pset);
2115: prev_pset = pset;
2116:
2117: mutex_lock(&all_psets_lock);
2118: pset_lock(pset);
2119: task = (task_t) queue_next(&task->pset_tasks);
2120: }
2121: pset_unlock(pset);
2122: pset = (processor_set_t) queue_next(&pset->all_psets);
2123: }
2124: mutex_unlock(&all_psets_lock);
2125:
2126: if (prev_task != TASK_NULL)
2127: task_deallocate(prev_task);
2128: if (prev_pset != PROCESSOR_SET_NULL)
2129: pset_deallocate(prev_pset);
2130: }
2131:
2132: boolean_t task_collect_allowed = TRUE;
2133: unsigned task_collect_last_tick = 0;
2134: unsigned task_collect_max_rate = 0; /* in ticks */
2135:
2136: /*
2137: * consider_task_collect:
2138: *
2139: * Called by the pageout daemon when the system needs more free pages.
2140: */
2141:
2142: void
2143: consider_task_collect(void)
2144: {
2145: /*
2146: * By default, don't attempt task collection more frequently
2147: * than once a second (a scheduler tick).
2148: */
2149:
2150: if (task_collect_max_rate == 0)
2151: task_collect_max_rate = 2; /* sched_tick is a 1 second resolution 2 here insures at least 1 second interval */
2152:
2153: if (task_collect_allowed &&
2154: (sched_tick > (task_collect_last_tick + task_collect_max_rate))) {
2155: task_collect_last_tick = sched_tick;
2156: task_collect_scan();
2157: }
2158: }
2159:
2160: kern_return_t
2161: task_set_ras_pc(
2162: task_t task,
2163: vm_offset_t pc,
2164: vm_offset_t endpc)
2165: {
2166: #if FAST_TAS
2167: extern int fast_tas_debug;
2168:
2169: if (fast_tas_debug) {
2170: printf("task 0x%x: setting fast_tas to [0x%x, 0x%x]\n",
2171: task, pc, endpc);
2172: }
2173: task_lock(task);
2174: task->fast_tas_base = pc;
2175: task->fast_tas_end = endpc;
2176: task_unlock(task);
2177: return KERN_SUCCESS;
2178:
2179: #else /* FAST_TAS */
2180: #ifdef lint
2181: task++;
2182: pc++;
2183: endpc++;
2184: #endif /* lint */
2185:
2186: return KERN_FAILURE;
2187:
2188: #endif /* FAST_TAS */
2189: }
2190:
2191: void
2192: task_synchronizer_destroy_all(task_t task)
2193: {
2194: semaphore_t semaphore;
2195: lock_set_t lock_set;
2196:
2197: /*
2198: * Destroy owned semaphores
2199: */
2200:
2201: while (!queue_empty(&task->semaphore_list)) {
2202: semaphore = (semaphore_t) queue_first(&task->semaphore_list);
2203: (void) semaphore_destroy(task, semaphore);
2204: }
2205:
2206: /*
2207: * Destroy owned lock sets
2208: */
2209:
2210: while (!queue_empty(&task->lock_set_list)) {
2211: lock_set = (lock_set_t) queue_first(&task->lock_set_list);
2212: (void) lock_set_destroy(task, lock_set);
2213: }
2214: }
2215:
2216: void
2217: task_subsystem_destroy_all(task_t task)
2218: {
2219: subsystem_t subsystem;
2220:
2221: /*
2222: * Destroy owned subsystems
2223: */
2224:
2225: while (!queue_empty(&task->subsystem_list)) {
2226: subsystem = (subsystem_t) queue_first(&task->subsystem_list);
2227: subsystem_deallocate(subsystem);
2228: }
2229: }
2230:
2231: /*
2232: * task_set_port_space:
2233: *
2234: * Set port name space of task to specified size.
2235: */
2236:
2237: kern_return_t
2238: task_set_port_space(
2239: task_t task,
2240: int table_entries)
2241: {
2242: kern_return_t kr;
2243:
2244: is_write_lock(task->itk_space);
2245: kr = ipc_entry_grow_table(task->itk_space, table_entries);
2246: if (kr == KERN_SUCCESS)
2247: is_write_unlock(task->itk_space);
2248: return kr;
2249: }
2250:
2251: /*
2252: * We need to export some functions to other components that
2253: * are currently implemented in macros within the osfmk
2254: * component. Just export them as functions of the same name.
2255: */
2256: boolean_t is_kerneltask(task_t t)
2257: {
2258: if (t == kernel_task)
2259: return(TRUE);
2260: else
2261: return((t->kernel_loaded));
2262: }
2263:
2264: #undef current_task
2265: task_t current_task()
2266: {
2267: return (current_task_fast());
2268: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.