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