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