![[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 Darwin 0.x] / kernel / kern|
Return to task.c CVS log | Up to [Apple Darwin 0.x] / kernel / kern |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: * Mach Operating System
27: * Copyright (c) 1993-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: #include <mach_host.h>
59: #include <norma_task.h>
60:
61: #include <mach/machine/vm_types.h>
62: #include <mach/vm_param.h>
63: #include <mach/task_info.h>
64: #include <mach/task_special_ports.h>
65: #include <ipc/ipc_space.h>
66: #include <kern/mach_param.h>
67: #include <kern/task.h>
68: #include <kern/thread.h>
69: #include <kern/zalloc.h>
70: #include <kern/kalloc.h>
71: #include <kern/processor.h>
72: #include <kern/sched_prim.h> /* for thread_wakeup */
73: #include <kern/ipc_tt.h>
74: #include <vm/vm_kern.h> /* for kernel_map, ipc_kernel_map */
75:
76: #if NORMA_TASK
77: #define task_create task_create_local
78: #endif /* NORMA_TASK */
79:
80: task_t kernel_task = TASK_NULL;
81: zone_t task_zone;
82:
83: extern zone_t u_task_zone; /* UNIX */
84:
85: void task_init(void)
86: {
87: task_zone = zinit(
88: sizeof(struct task),
89: TASK_MAX * sizeof(struct task),
90: TASK_CHUNK * sizeof(struct task),
91: FALSE, "tasks");
92:
93: /*
94: * Create the kernel task as the first task.
95: * Task_create must assign to kernel_task as a side effect,
96: * for other initialization. (:-()
97: */
98: (void) task_create(TASK_NULL, FALSE, &kernel_task);
99:
100: kernel_task->kernel_privilege = TRUE;
101: kernel_task->kernel_vm_space = TRUE;
102: }
103:
104: /*
105: * Create a task running in the kernel address space. It may
106: * have its own map of size mem_size (if 0, it uses the kernel map),
107: * and may have ipc privileges.
108: */
109: task_t kernel_task_create(
110: task_t parent_task,
111: vm_size_t map_size)
112: {
113: task_t new_task;
114: vm_offset_t min, max;
115:
116: /*
117: * Create the task.
118: */
119: (void) task_create(parent_task, FALSE, &new_task);
120: task_deallocate(new_task); // extra ref for convert_task_to_port()
121:
122: /*
123: * Task_create creates the task with a user-space map.
124: * Remove the map and replace it with the kernel map
125: * or a submap of the kernel map.
126: */
127: vm_map_deallocate(new_task->map);
128: if (map_size == 0)
129: new_task->map = kernel_map;
130: else
131: new_task->map = kmem_suballoc(kernel_map, &min, &max,
132: map_size, FALSE);
133:
134: new_task->kernel_vm_space = TRUE;
135:
136: return new_task;
137: }
138:
139: kern_return_t task_create(
140: task_t parent_task,
141: boolean_t inherit_memory,
142: task_t *child_task) /* OUT */
143: {
144: register task_t new_task;
145: register processor_set_t pset;
146: int i;
147:
148: new_task = (task_t) zalloc(task_zone);
149: if (new_task == TASK_NULL) {
150: panic("task_create: no memory for task structure");
151: }
152:
153: /* one ref for just being alive; one for our caller */
154: new_task->ref_count = 2;
155:
156: if (child_task == &kernel_task) {
157: new_task->map = kernel_map;
158: } else if (inherit_memory) {
159: new_task->map = vm_map_fork(parent_task->map);
160: } else {
161: new_task->map = vm_map_create(pmap_create(0),
162: round_page(VM_MIN_ADDRESS),
163: trunc_page(VM_MAX_ADDRESS), TRUE);
164: }
165:
166: simple_lock_init(&new_task->lock);
167: queue_init(&new_task->thread_list);
168: simple_lock_init(&new_task->thread_list_lock);
169: new_task->suspend_count = 0;
170: new_task->active = TRUE;
171: new_task->user_stop_count = 0;
172: new_task->thread_count = 0;
173:
174: new_task->pcb_common = 0;
175: pcb_common_init(new_task);
176:
177: new_task->proc = 0;
178:
179: new_task->kernel_vm_space = FALSE;
180:
181: ipc_task_init(new_task, parent_task);
182:
183: new_task->total_user_time.seconds = 0;
184: new_task->total_user_time.microseconds = 0;
185: new_task->total_system_time.seconds = 0;
186: new_task->total_system_time.microseconds = 0;
187:
188: if (parent_task != TASK_NULL) {
189: new_task->kernel_privilege = parent_task->kernel_privilege;
190: task_lock(parent_task);
191: pset = parent_task->processor_set;
192: if (!pset->active)
193: pset = &default_pset;
194: pset_reference(pset);
195: new_task->priority = parent_task->priority;
196: task_unlock(parent_task);
197: }
198: else {
199: new_task->kernel_privilege = FALSE;
200: pset = &default_pset;
201: pset_reference(pset);
202: new_task->priority = BASEPRI_USER;
203: }
204: pset_lock(pset);
205: pset_add_task(pset, new_task);
206: pset_unlock(pset);
207:
208: new_task->may_assign = TRUE;
209: new_task->assign_active = FALSE;
210:
211: ipc_task_enable(new_task);
212:
213: #if NORMA_TASK
214: new_task->child_node = -1;
215: #endif /* NORMA_TASK */
216:
217: *child_task = new_task;
218: return KERN_SUCCESS;
219: }
220:
221: /*
222: * task_deallocate:
223: *
224: * Give up a reference to the specified task and destroy it if there
225: * are no other references left. It is assumed that the current thread
226: * is never in this task.
227: */
228: void task_deallocate(
229: register task_t task)
230: {
231: register int c;
232: register processor_set_t pset;
233:
234: if (task == TASK_NULL)
235: return;
236:
237: task_lock(task);
238: c = --(task->ref_count);
239: task_unlock(task);
240: if (c != 0)
241: return;
242:
243: #if NORMA_TASK
244: if (task->map == VM_MAP_NULL) {
245: /* norma placeholder task */
246: zfree(task_zone, (vm_offset_t) task);
247: return;
248: }
249: #endif /* NORMA_TASK */
250:
251: pset = task->processor_set;
252: pset_lock(pset);
253: pset_remove_task(pset,task);
254: pset_unlock(pset);
255: pset_deallocate(pset);
256: vm_map_deallocate(task->map);
257: is_release(task->itk_space);
258: pcb_common_terminate(task);
259: zfree(task_zone, (vm_offset_t) task);
260: }
261:
262: void task_reference(
263: register task_t task)
264: {
265: if (task == TASK_NULL)
266: return;
267:
268: task_lock(task);
269: task->ref_count++;
270: task_unlock(task);
271: }
272:
273: /*
274: * task_terminate:
275: *
276: * Terminate the specified task. See comments on thread_terminate
277: * (kern/thread.c) about problems with terminating the "current task."
278: */
279: kern_return_t task_terminate(
280: register task_t task)
281: {
282: register thread_t thread, cur_thread;
283: register queue_head_t *list;
284: register task_t cur_task;
285: int s;
286:
287: if (task == TASK_NULL)
288: return KERN_INVALID_ARGUMENT;
289:
290: /* Disallow termination of U**X proc tasks */
291: if (task->proc)
292: return KERN_FAILURE;
293:
294: list = &task->thread_list;
295: cur_task = current_task();
296: cur_thread = current_thread();
297:
298: /*
299: * Deactivate task so that it can't be terminated again,
300: * and so lengthy operations in progress will abort.
301: *
302: * If the current thread is in this task, remove it from
303: * the task's thread list to keep the thread-termination
304: * loop simple.
305: */
306: if (task == cur_task) {
307: task_lock(task);
308: if (!task->active) {
309: /*
310: * Task is already being terminated.
311: */
312: task_unlock(task);
313: return KERN_FAILURE;
314: }
315: /*
316: * Make sure current thread is not being terminated.
317: */
318: s = splsched();
319: simple_lock(&task->thread_list_lock);
320: thread_lock(cur_thread);
321: if (!cur_thread->active) {
322: thread_unlock(cur_thread);
323: simple_unlock(&task->thread_list_lock);
324: (void) splx(s);
325: task_unlock(task);
326: thread_terminate(cur_thread);
327: return KERN_FAILURE;
328: }
329: task->active = FALSE;
330: queue_remove(list, cur_thread, thread_t, thread_list);
331: thread_unlock(cur_thread);
332: simple_unlock(&task->thread_list_lock);
333: (void) splx(s);
334: task_unlock(task);
335:
336: /*
337: * Shut down this thread's ipc now because it must
338: * be left alone to terminate the task.
339: */
340: ipc_thread_disable(cur_thread);
341: ipc_thread_terminate(cur_thread);
342: }
343: else {
344: /*
345: * Lock both current and victim task to check for
346: * potential deadlock.
347: */
348: if ((vm_offset_t)task < (vm_offset_t)cur_task) {
349: task_lock(task);
350: task_lock(cur_task);
351: }
352: else {
353: task_lock(cur_task);
354: task_lock(task);
355: }
356: /*
357: * Check if current thread or task is being terminated.
358: */
359: s = splsched();
360: thread_lock(cur_thread);
361: if ((!cur_task->active) ||(!cur_thread->active)) {
362: /*
363: * Current task or thread is being terminated.
364: */
365: thread_unlock(cur_thread);
366: (void) splx(s);
367: task_unlock(task);
368: task_unlock(cur_task);
369: thread_terminate(cur_thread);
370: return KERN_FAILURE;
371: }
372: thread_unlock(cur_thread);
373: (void) splx(s);
374: task_unlock(cur_task);
375:
376: if (!task->active) {
377: /*
378: * Task is already being terminated.
379: */
380: task_unlock(task);
381: return KERN_FAILURE;
382: }
383: task->active = FALSE;
384: task_unlock(task);
385: }
386:
387: /*
388: * Prevent further execution of the task. ipc_task_disable
389: * prevents further task operations via the task port.
390: * If this is the current task, the current thread will
391: * be left running.
392: */
393: ipc_task_disable(task);
394: (void) task_hold(task);
395: (void) task_dowait(task,TRUE); /* may block */
396:
397: /*
398: * Terminate each thread in the task.
399: *
400: * The task_port is closed down, so no more thread_create
401: * operations can be done. Thread_force_terminate closes the
402: * thread port for each thread; when that is done, the
403: * thread will eventually disappear. Thus the loop will
404: * terminate. Call thread_force_terminate instead of
405: * thread_terminate to avoid deadlock checks. Need
406: * to call thread_block() inside loop because some other
407: * thread (e.g., the reaper) may have to run to get rid
408: * of all references to the thread; it won't vanish from
409: * the task's thread list until the last one is gone.
410: */
411: task_lock(task);
412: while (!queue_empty(list)) {
413: thread = (thread_t) queue_first(list);
414: thread_reference(thread);
415: task_unlock(task);
416: thread_force_terminate(thread);
417: thread_deallocate(thread);
418: thread_block_with_continuation((void (*)()) 0);
419: task_lock(task);
420: }
421: task_unlock(task);
422:
423: /*
424: * Shut down IPC.
425: */
426: ipc_task_terminate(task);
427:
428:
429: /*
430: * Deallocate the task's reference to itself.
431: */
432: task_deallocate(task);
433:
434: /*
435: * If the current thread is in this task, it has not yet
436: * been terminated (since it was removed from the task's
437: * thread-list). Put it back in the thread list (for
438: * completeness), and terminate it. Since it holds the
439: * last reference to the task, terminating it will deallocate
440: * the task.
441: */
442: if (cur_thread->task == task) {
443: task_lock(task);
444: s = splsched();
445: simple_lock(&task->thread_list_lock);
446: queue_enter(list, cur_thread, thread_t, thread_list);
447: simple_unlock(&task->thread_list_lock);
448: (void) splx(s);
449: task_unlock(task);
450: (void) thread_terminate(cur_thread);
451: }
452:
453: return KERN_SUCCESS;
454: }
455:
456: /*
457: * task_hold:
458: *
459: * Suspend execution of the specified task.
460: * This is a recursive-style suspension of the task, a count of
461: * suspends is maintained.
462: */
463: kern_return_t task_hold(
464: register task_t task)
465: {
466: register queue_head_t *list;
467: register thread_t thread, cur_thread;
468:
469: cur_thread = current_thread();
470:
471: task_lock(task);
472: if (!task->active) {
473: task_unlock(task);
474: return KERN_FAILURE;
475: }
476:
477: task->suspend_count++;
478:
479: /*
480: * Iterate through all the threads and hold them.
481: * Do not hold the current thread if it is within the
482: * task.
483: */
484: list = &task->thread_list;
485: queue_iterate(list, thread, thread_t, thread_list) {
486: if (thread != cur_thread)
487: thread_hold(thread);
488: }
489: task_unlock(task);
490: return KERN_SUCCESS;
491: }
492:
493: /*
494: * task_dowait:
495: *
496: * Wait until the task has really been suspended (all of the threads
497: * are stopped). Skip the current thread if it is within the task.
498: *
499: * If task is deactivated while waiting, return a failure code unless
500: * must_wait is true.
501: */
502: kern_return_t task_dowait(
503: register task_t task,
504: boolean_t must_wait)
505: {
506: register queue_head_t *list;
507: register thread_t thread, cur_thread, prev_thread;
508: register kern_return_t ret = KERN_SUCCESS;
509:
510: /*
511: * Iterate through all the threads.
512: * While waiting for each thread, we gain a reference to it
513: * to prevent it from going away on us. This guarantees
514: * that the "next" thread in the list will be a valid thread.
515: *
516: * We depend on the fact that if threads are created while
517: * we are looping through the threads, they will be held
518: * automatically. We don't care about threads that get
519: * deallocated along the way (the reference prevents it
520: * from happening to the thread we are working with).
521: *
522: * If the current thread is in the affected task, it is skipped.
523: *
524: * If the task is deactivated before we're done, and we don't
525: * have to wait for it (must_wait is FALSE), just bail out.
526: */
527: cur_thread = current_thread();
528:
529: list = &task->thread_list;
530: prev_thread = THREAD_NULL;
531: task_lock(task);
532: queue_iterate(list, thread, thread_t, thread_list) {
533: if (!(task->active) && !(must_wait)) {
534: ret = KERN_FAILURE;
535: break;
536: }
537: if (thread != cur_thread) {
538: thread_reference(thread);
539: task_unlock(task);
540: if (prev_thread != THREAD_NULL)
541: thread_deallocate(prev_thread);
542: /* may block */
543: (void) thread_dowait(thread, TRUE); /* may block */
544: prev_thread = thread;
545: task_lock(task);
546: }
547: }
548: task_unlock(task);
549: if (prev_thread != THREAD_NULL)
550: thread_deallocate(prev_thread); /* may block */
551: return ret;
552: }
553:
554: kern_return_t task_release(
555: register task_t task)
556: {
557: register queue_head_t *list;
558: register thread_t thread, next;
559:
560: task_lock(task);
561: if (!task->active) {
562: task_unlock(task);
563: return KERN_FAILURE;
564: }
565:
566: task->suspend_count--;
567:
568: /*
569: * Iterate through all the threads and release them
570: */
571: list = &task->thread_list;
572: thread = (thread_t) queue_first(list);
573: while (!queue_end(list, (queue_entry_t) thread)) {
574: next = (thread_t) queue_next(&thread->thread_list);
575: thread_release(thread);
576: thread = next;
577: }
578: task_unlock(task);
579: return KERN_SUCCESS;
580: }
581:
582: /*
583: * task_halt:
584: *
585: * Halt all threads in the task. Do not halt the current thread if
586: * it is within the task.
587: *
588: * Only called from exit().
589: */
590: kern_return_t task_halt(task)
591: register task_t task;
592: {
593: register queue_head_t *list;
594: register thread_t thread, cur_thread, prev_thread;
595: register kern_return_t ret = KERN_SUCCESS;
596:
597: /*
598: * Iterate through all the threads.
599: * While waiting for each thread, we gain a reference to it
600: * to prevent it from going away on us. This guarantees
601: * that the "next" thread in the list will be a valid thread.
602: *
603: * If the current thread is in the affected task, it is skipped.
604: */
605: cur_thread = current_thread();
606:
607: list = &task->thread_list;
608: prev_thread = THREAD_NULL;
609: task_lock(task);
610: thread = (thread_t) queue_first(list);
611: while (!queue_end(list, (queue_entry_t) thread)) {
612: if (thread != cur_thread) {
613: thread_reference(thread);
614: task_unlock(task);
615: if (prev_thread != THREAD_NULL)
616: thread_deallocate(prev_thread); /* may block */
617: #if MACH_HOST
618: thread_freeze(thread);
619: if (thread->processor_set != &default_pset)
620: thread_doassign(thread, &default_pset, FALSE);
621: #endif MACH_HOST
622: thread_halt(thread, TRUE); /* may block */
623: #if MACH_HOST
624: thread_unfreeze(thread);
625: #endif MACH_HOST
626: prev_thread = thread;
627: task_lock(task);
628: }
629: thread = (thread_t) queue_next(&thread->thread_list);
630: }
631: task_unlock(task);
632: if (prev_thread != THREAD_NULL)
633: thread_deallocate(prev_thread); /* may block */
634: return(ret);
635: }
636:
637: kern_return_t task_threads(
638: task_t task,
639: thread_array_t *thread_list,
640: natural_t *count)
641: {
642: unsigned int actual; /* this many threads */
643: thread_t thread;
644: thread_t *threads;
645: int i;
646:
647: vm_size_t size, size_needed;
648: vm_offset_t addr;
649:
650: if (task == TASK_NULL)
651: return KERN_INVALID_ARGUMENT;
652:
653: size = 0; addr = 0;
654:
655: for (;;) {
656: task_lock(task);
657: if (!task->active) {
658: task_unlock(task);
659: return KERN_FAILURE;
660: }
661:
662: actual = task->thread_count;
663:
664: /* do we have the memory we need? */
665:
666: size_needed = actual * sizeof(mach_port_t);
667: if (size_needed <= size)
668: break;
669:
670: /* unlock the task and allocate more memory */
671: task_unlock(task);
672:
673: if (size != 0)
674: kfree(addr, size);
675:
676: assert(size_needed > 0);
677: size = size_needed;
678:
679: addr = kalloc(size);
680: if (addr == 0)
681: return KERN_RESOURCE_SHORTAGE;
682: }
683:
684: /* OK, have memory and the task is locked & active */
685:
686: threads = (thread_t *) addr;
687:
688: for (i = 0, thread = (thread_t) queue_first(&task->thread_list);
689: i < actual;
690: i++, thread = (thread_t) queue_next(&thread->thread_list)) {
691: /* take ref for convert_thread_to_port */
692: thread_reference(thread);
693: threads[i] = thread;
694: }
695: assert(queue_end(&task->thread_list, (queue_entry_t) thread));
696:
697: /* can unlock task now that we've got the thread refs */
698: task_unlock(task);
699:
700: if (actual == 0) {
701: /* no threads, so return null pointer and deallocate memory */
702:
703: *thread_list = 0;
704: *count = 0;
705:
706: if (size != 0)
707: kfree(addr, size);
708: } else {
709: /* if we allocated too much, must copy */
710:
711: if (size_needed < size) {
712: vm_offset_t newaddr;
713:
714: newaddr = kalloc(size_needed);
715: if (newaddr == 0) {
716: for (i = 0; i < actual; i++)
717: thread_deallocate(threads[i]);
718: kfree(addr, size);
719: return KERN_RESOURCE_SHORTAGE;
720: }
721:
722: bcopy((char *) addr, (char *) newaddr, size_needed);
723: kfree(addr, size);
724: threads = (thread_t *) newaddr;
725: }
726:
727: *thread_list = (mach_port_t *) threads;
728: *count = actual;
729:
730: /* do the conversion that Mig should handle */
731:
732: for (i = 0; i < actual; i++)
733: ((ipc_port_t *) threads)[i] =
734: convert_thread_to_port(threads[i]);
735: }
736:
737: return KERN_SUCCESS;
738: }
739:
740: kern_return_t task_suspend(
741: register task_t task)
742: {
743: register boolean_t hold;
744:
745: if (task == TASK_NULL)
746: return KERN_INVALID_ARGUMENT;
747:
748: hold = FALSE;
749: task_lock(task);
750: if ((task->user_stop_count)++ == 0)
751: hold = TRUE;
752: task_unlock(task);
753:
754: /*
755: * If the stop count was positive, the task is
756: * already stopped and we can exit.
757: */
758: if (!hold) {
759: return KERN_SUCCESS;
760: }
761:
762: /*
763: * Hold all of the threads in the task, and wait for
764: * them to stop. If the current thread is within
765: * this task, hold it separately so that all of the
766: * other threads can stop first.
767: */
768:
769: if (task_hold(task) != KERN_SUCCESS)
770: return KERN_FAILURE;
771:
772: if (task_dowait(task, FALSE) != KERN_SUCCESS)
773: return KERN_FAILURE;
774:
775: if (current_task() == task) {
776: int s;
777:
778: thread_hold(current_thread());
779: /*
780: * We want to call thread_block on our way out,
781: * to stop running.
782: */
783: s = splsched();
784: ast_on(cpu_number(), AST_BLOCK);
785: (void) splx(s);
786: }
787:
788: return KERN_SUCCESS;
789: }
790:
791: kern_return_t task_resume(
792: register task_t task)
793: {
794: register boolean_t release;
795:
796: if (task == TASK_NULL)
797: return KERN_INVALID_ARGUMENT;
798:
799: release = FALSE;
800: task_lock(task);
801: if (task->user_stop_count > 0) {
802: if (--(task->user_stop_count) == 0)
803: release = TRUE;
804: }
805: else {
806: task_unlock(task);
807: return KERN_FAILURE;
808: }
809: task_unlock(task);
810:
811: /*
812: * Release the task if necessary.
813: */
814: if (release)
815: return task_release(task);
816:
817: return KERN_SUCCESS;
818: }
819:
820: kern_return_t task_info(
821: task_t task,
822: int flavor,
823: task_info_t task_info_out, /* pointer to OUT array */
824: natural_t *task_info_count) /* IN/OUT */
825: {
826: vm_map_t map;
827:
828: if (task == TASK_NULL)
829: return KERN_INVALID_ARGUMENT;
830:
831: switch (flavor) {
832: case TASK_BASIC_INFO:
833: {
834: register task_basic_info_t basic_info;
835:
836: if (*task_info_count < TASK_BASIC_INFO_COUNT) {
837: return KERN_INVALID_ARGUMENT;
838: }
839:
840: basic_info = (task_basic_info_t) task_info_out;
841:
842: map = (task == kernel_task) ? kernel_map : task->map;
843:
844: basic_info->virtual_size = map->size;
845: basic_info->resident_size = pmap_resident_count(map->pmap)
846: * PAGE_SIZE;
847:
848: task_lock(task);
849: basic_info->base_priority = task->priority;
850: basic_info->suspend_count = task->user_stop_count;
851: basic_info->user_time.seconds
852: = task->total_user_time.seconds;
853: basic_info->user_time.microseconds
854: = task->total_user_time.microseconds;
855: basic_info->system_time.seconds
856: = task->total_system_time.seconds;
857: basic_info->system_time.microseconds
858: = task->total_system_time.microseconds;
859: task_unlock(task);
860:
861: *task_info_count = TASK_BASIC_INFO_COUNT;
862: break;
863: }
864:
865: case TASK_THREAD_TIMES_INFO:
866: {
867: register task_thread_times_info_t times_info;
868: register thread_t thread;
869:
870: if (*task_info_count < TASK_THREAD_TIMES_INFO_COUNT) {
871: return KERN_INVALID_ARGUMENT;
872: }
873:
874: times_info = (task_thread_times_info_t) task_info_out;
875: times_info->user_time.seconds = 0;
876: times_info->user_time.microseconds = 0;
877: times_info->system_time.seconds = 0;
878: times_info->system_time.microseconds = 0;
879:
880: task_lock(task);
881: queue_iterate(&task->thread_list, thread,
882: thread_t, thread_list)
883: {
884: time_value_t user_time, system_time;
885: int s;
886:
887: s = splsched();
888: thread_lock(thread);
889:
890: thread_read_times(thread, &user_time, &system_time);
891:
892: thread_unlock(thread);
893: splx(s);
894:
895: time_value_add(×_info->user_time, &user_time);
896: time_value_add(×_info->system_time, &system_time);
897: }
898: task_unlock(task);
899:
900: *task_info_count = TASK_THREAD_TIMES_INFO_COUNT;
901: break;
902: }
903:
904: default:
905: return KERN_INVALID_ARGUMENT;
906: }
907:
908: return KERN_SUCCESS;
909: }
910:
911: /*
912: * Special version of task_suspend that doesn't wait.
913: * Called only from interrupt level (U*X psignal).
914: * Will go away when signal code becomes sane.
915: */
916: kern_return_t task_suspend_nowait(task)
917: register task_t task;
918: {
919: register boolean_t hold;
920:
921: if (task == TASK_NULL)
922: return(KERN_INVALID_ARGUMENT);
923:
924: hold = FALSE;
925: task_lock(task);
926: if ((task->user_stop_count)++ == 0)
927: hold = TRUE;
928: task_unlock(task);
929:
930: /*
931: * If the stop count was positive, the task is
932: * already stopped and we can exit.
933: */
934: if (!hold) {
935: return (KERN_SUCCESS);
936: }
937:
938: /*
939: * Hold all of the threads in the task.
940: * If the current thread is within
941: * this task, hold it separately so that all of the
942: * other threads can stop first.
943: */
944:
945: if (task_hold(task) != KERN_SUCCESS)
946: return(KERN_FAILURE);
947:
948: if (current_task() == task) {
949: thread_hold(current_thread());
950: }
951:
952: return(KERN_SUCCESS);
953: }
954:
955: #if MACH_HOST
956: /*
957: * task_assign:
958: *
959: * Change the assigned processor set for the task
960: */
961: kern_return_t
962: task_assign(
963: task_t task,
964: processor_set_t new_pset,
965: boolean_t assign_threads)
966: {
967: kern_return_t ret = KERN_SUCCESS;
968: register thread_t thread, prev_thread;
969: register queue_head_t *list;
970: register processor_set_t pset;
971:
972: if (task == TASK_NULL || new_pset == PROCESSOR_SET_NULL) {
973: return KERN_INVALID_ARGUMENT;
974: }
975:
976: /*
977: * Freeze task`s assignment. Prelude to assigning
978: * task. Only one freeze may be held per task.
979: */
980:
981: task_lock(task);
982: while (task->may_assign == FALSE) {
983: task->assign_active = TRUE;
984: assert_wait((event_t)&task->assign_active, TRUE);
985: task_unlock(task);
986: thread_block((void (*)()) 0);
987: task_lock(task);
988: }
989:
990: /*
991: * Avoid work if task already in this processor set.
992: */
993: if (task->processor_set == new_pset) {
994: /*
995: * No need for task->assign_active wakeup:
996: * task->may_assign is still TRUE.
997: */
998: task_unlock(task);
999: return KERN_SUCCESS;
1000: }
1001:
1002: task->may_assign = FALSE;
1003: task_unlock(task);
1004:
1005: /*
1006: * Safe to get the task`s pset: it cannot change while
1007: * task is frozen.
1008: */
1009: pset = task->processor_set;
1010:
1011: /*
1012: * Lock both psets now. Use ordering to avoid deadlock.
1013: */
1014: Restart:
1015: if ((vm_offset_t) pset < (vm_offset_t) new_pset) {
1016: pset_lock(pset);
1017: pset_lock(new_pset);
1018: }
1019: else {
1020: pset_lock(new_pset);
1021: pset_lock(pset);
1022: }
1023:
1024: /*
1025: * Check if new_pset is ok to assign to. If not,
1026: * reassign to default_pset.
1027: */
1028: if (!new_pset->active) {
1029: pset_unlock(pset);
1030: pset_unlock(new_pset);
1031: new_pset = &default_pset;
1032: goto Restart;
1033: }
1034:
1035: pset_reference(new_pset);
1036:
1037: /*
1038: * Now grab the task lock and move the task.
1039: */
1040:
1041: task_lock(task);
1042: pset_remove_task(pset, task);
1043: pset_add_task(new_pset, task);
1044:
1045: pset_unlock(pset);
1046: pset_unlock(new_pset);
1047:
1048: if (assign_threads == FALSE) {
1049: /*
1050: * We leave existing threads at their
1051: * old assignments. Unfreeze task`s
1052: * assignment.
1053: */
1054: task->may_assign = TRUE;
1055: if (task->assign_active) {
1056: task->assign_active = FALSE;
1057: thread_wakeup((event_t) &task->assign_active);
1058: }
1059: task_unlock(task);
1060: pset_deallocate(pset);
1061: return KERN_SUCCESS;
1062: }
1063:
1064: /*
1065: * If current thread is in task, freeze its assignment.
1066: */
1067: if (current_thread()->task == task) {
1068: task_unlock(task);
1069: thread_freeze(current_thread());
1070: task_lock(task);
1071: }
1072:
1073: /*
1074: * Iterate down the thread list reassigning all the threads.
1075: * New threads pick up task's new processor set automatically.
1076: * Do current thread last because new pset may be empty.
1077: */
1078: list = &task->thread_list;
1079: prev_thread = THREAD_NULL;
1080: queue_iterate(list, thread, thread_t, thread_list) {
1081: if (!(task->active)) {
1082: ret = KERN_FAILURE;
1083: break;
1084: }
1085: if (thread != current_thread()) {
1086: thread_reference(thread);
1087: task_unlock(task);
1088: if (prev_thread != THREAD_NULL)
1089: thread_deallocate(prev_thread); /* may block */
1090: thread_assign(thread,new_pset); /* may block */
1091: prev_thread = thread;
1092: task_lock(task);
1093: }
1094: }
1095:
1096: /*
1097: * Done, wakeup anyone waiting for us.
1098: */
1099: task->may_assign = TRUE;
1100: if (task->assign_active) {
1101: task->assign_active = FALSE;
1102: thread_wakeup((event_t)&task->assign_active);
1103: }
1104: task_unlock(task);
1105: if (prev_thread != THREAD_NULL)
1106: thread_deallocate(prev_thread); /* may block */
1107:
1108: /*
1109: * Finish assignment of current thread.
1110: */
1111: if (current_thread()->task == task)
1112: thread_doassign(current_thread(), new_pset, TRUE);
1113:
1114: pset_deallocate(pset);
1115:
1116: return ret;
1117: }
1118: #else /* MACH_HOST */
1119: /*
1120: * task_assign:
1121: *
1122: * Change the assigned processor set for the task
1123: */
1124: kern_return_t
1125: task_assign(
1126: task_t task,
1127: processor_set_t new_pset,
1128: boolean_t assign_threads)
1129: {
1130: return KERN_FAILURE;
1131: }
1132: #endif /* MACH_HOST */
1133:
1134:
1135: /*
1136: * task_assign_default:
1137: *
1138: * Version of task_assign to assign to default processor set.
1139: */
1140: kern_return_t
1141: task_assign_default(
1142: task_t task,
1143: boolean_t assign_threads)
1144: {
1145: return task_assign(task, &default_pset, assign_threads);
1146: }
1147:
1148: /*
1149: * task_get_assignment
1150: *
1151: * Return name of processor set that task is assigned to.
1152: */
1153: kern_return_t task_get_assignment(
1154: task_t task,
1155: processor_set_t *pset)
1156: {
1157: if (!task->active)
1158: return KERN_FAILURE;
1159:
1160: *pset = task->processor_set;
1161: pset_reference(*pset);
1162: return KERN_SUCCESS;
1163: }
1164:
1165: /*
1166: * task_priority
1167: *
1168: * Set priority of task; used only for newly created threads.
1169: * Optionally change priorities of threads.
1170: */
1171: kern_return_t
1172: task_priority(
1173: task_t task,
1174: int priority,
1175: boolean_t change_threads)
1176: {
1177: kern_return_t ret = KERN_SUCCESS;
1178:
1179: if (task == TASK_NULL || invalid_pri(priority))
1180: return KERN_INVALID_ARGUMENT;
1181:
1182: task_lock(task);
1183: task->priority = priority;
1184:
1185: if (change_threads) {
1186: register thread_t thread;
1187: register queue_head_t *list;
1188:
1189: list = &task->thread_list;
1190: queue_iterate(list, thread, thread_t, thread_list) {
1191: if (thread_priority(thread, priority, FALSE)
1192: != KERN_SUCCESS)
1193: ret = KERN_FAILURE;
1194: }
1195: }
1196:
1197: task_unlock(task);
1198: return ret;
1199: }
1200:
1201: task_t current_task_EXTERNAL()
1202: {
1203: return current_task();
1204: }
1205:
1206: /*
1207: * Loadable servers need to be able to find their task map.
1208: */
1209: vm_map_t current_map_EXTERNAL()
1210: {
1211: return current_task()->map;
1212: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.