![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to processor.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 processor.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: * processor.c: processor and processor_set manipulation routines.
28: */
29:
30: #include <cpus.h>
31: #include <mach_fixpri.h>
32: #include <mach_host.h>
33:
34: #include <mach/boolean.h>
35: #include <mach/policy.h>
36: #include <mach/processor_info.h>
37: #include <mach/vm_param.h>
38: #include <kern/cpu_number.h>
39: #include <kern/lock.h>
40: #include <kern/host.h>
41: #include <kern/processor.h>
42: #include <kern/sched.h>
43: #include <kern/task.h>
44: #include <kern/thread.h>
45: #include <kern/ipc_host.h>
46: #include <ipc/ipc_port.h>
47:
48: #if MACH_HOST
49: #include <kern/zalloc.h>
50: zone_t pset_zone;
51: #endif /* MACH_HOST */
52:
53:
54: /*
55: * Exported variables.
56: */
57: struct processor_set default_pset;
58: struct processor processor_array[NCPUS];
59:
60: queue_head_t all_psets;
61: int all_psets_count;
62: decl_simple_lock_data(, all_psets_lock);
63:
64: processor_t master_processor;
65: processor_t processor_ptr[NCPUS];
66:
67: /*
68: * Forward declarations.
69: */
70: void quantum_set(processor_set_t);
71: void pset_init(processor_set_t);
72: void processor_init(processor_t, int);
73:
74: /*
75: * Bootstrap the processor/pset system so the scheduler can run.
76: */
77: void pset_sys_bootstrap(void)
78: {
79: register int i;
80:
81: pset_init(&default_pset);
82: default_pset.empty = FALSE;
83: for (i = 0; i < NCPUS; i++) {
84: /*
85: * Initialize processor data structures.
86: * Note that cpu_to_processor(i) is processor_ptr[i].
87: */
88: processor_ptr[i] = &processor_array[i];
89: processor_init(processor_ptr[i], i);
90: }
91: master_processor = cpu_to_processor(master_cpu);
92: queue_init(&all_psets);
93: simple_lock_init(&all_psets_lock);
94: queue_enter(&all_psets, &default_pset, processor_set_t, all_psets);
95: all_psets_count = 1;
96: default_pset.active = TRUE;
97: default_pset.empty = FALSE;
98:
99: /*
100: * Note: the default_pset has a max_priority of BASEPRI_USER.
101: * Internal kernel threads override this in kernel_thread.
102: */
103: }
104:
105: #if MACH_HOST
106: /*
107: * Rest of pset system initializations.
108: */
109: void pset_sys_init(void)
110: {
111: register int i;
112: register processor_t processor;
113:
114: /*
115: * Allocate the zone for processor sets.
116: */
117: pset_zone = zinit(sizeof(struct processor_set), 128*PAGE_SIZE,
118: PAGE_SIZE, 0, "processor sets");
119:
120: /*
121: * Give each processor a control port.
122: * The master processor already has one.
123: */
124: for (i = 0; i < NCPUS; i++) {
125: processor = cpu_to_processor(i);
126: if (processor != master_processor &&
127: machine_slot[i].is_cpu)
128: {
129: ipc_processor_init(processor);
130: }
131: }
132: }
133: #endif /* MACH_HOST */
134:
135: /*
136: * Initialize the given processor_set structure.
137: */
138:
139: void pset_init(
140: register processor_set_t pset)
141: {
142: int i;
143:
144: simple_lock_init(&pset->runq.lock);
145: pset->runq.low = 0;
146: pset->runq.count = 0;
147: for (i = 0; i < NRQS; i++) {
148: queue_init(&(pset->runq.runq[i]));
149: }
150: queue_init(&pset->idle_queue);
151: pset->idle_count = 0;
152: simple_lock_init(&pset->idle_lock);
153: queue_init(&pset->processors);
154: pset->processor_count = 0;
155: pset->empty = TRUE;
156: queue_init(&pset->tasks);
157: pset->task_count = 0;
158: queue_init(&pset->threads);
159: pset->thread_count = 0;
160: pset->ref_count = 1;
161: simple_lock_init(&pset->ref_lock);
162: queue_init(&pset->all_psets);
163: pset->active = FALSE;
164: simple_lock_init(&pset->lock);
165: pset->pset_self = IP_NULL;
166: pset->pset_name_self = IP_NULL;
167: pset->max_priority = BASEPRI_USER;
168: #if MACH_FIXPRI
169: pset->policies = POLICY_TIMESHARE;
170: #endif /* MACH_FIXPRI */
171: pset->set_quantum = min_quantum;
172: #if NCPUS > 1
173: pset->quantum_adj_index = 0;
174: simple_lock_init(&pset->quantum_adj_lock);
175:
176: for (i = 0; i <= NCPUS; i++) {
177: pset->machine_quantum[i] = min_quantum;
178: }
179: #endif /* NCPUS > 1 */
180: pset->mach_factor = 0;
181: pset->load_average = 0;
182: pset->sched_load = SCHED_SCALE; /* i.e. 1 */
183: }
184:
185: /*
186: * Initialize the given processor structure for the processor in
187: * the slot specified by slot_num.
188: */
189:
190: void processor_init(
191: register processor_t pr,
192: int slot_num)
193: {
194: int i;
195:
196: simple_lock_init(&pr->runq.lock);
197: pr->runq.low = 0;
198: pr->runq.count = 0;
199: for (i = 0; i < NRQS; i++) {
200: queue_init(&(pr->runq.runq[i]));
201: }
202: queue_init(&pr->processor_queue);
203: pr->state = PROCESSOR_OFF_LINE;
204: pr->next_thread = THREAD_NULL;
205: pr->idle_thread = THREAD_NULL;
206: pr->quantum = 0;
207: pr->first_quantum = FALSE;
208: pr->last_quantum = 0;
209: pr->processor_set = PROCESSOR_SET_NULL;
210: pr->processor_set_next = PROCESSOR_SET_NULL;
211: queue_init(&pr->processors);
212: simple_lock_init(&pr->lock);
213: pr->processor_self = IP_NULL;
214: pr->slot_num = slot_num;
215: }
216:
217: /*
218: * pset_remove_processor() removes a processor from a processor_set.
219: * It can only be called on the current processor. Caller must
220: * hold lock on current processor and processor set.
221: */
222:
223: void pset_remove_processor(
224: processor_set_t pset,
225: processor_t processor)
226: {
227: if (pset != processor->processor_set)
228: panic("pset_remove_processor: wrong pset");
229:
230: queue_remove(&pset->processors, processor, processor_t, processors);
231: processor->processor_set = PROCESSOR_SET_NULL;
232: pset->processor_count--;
233: quantum_set(pset);
234: }
235:
236: /*
237: * pset_add_processor() adds a processor to a processor_set.
238: * It can only be called on the current processor. Caller must
239: * hold lock on curent processor and on pset. No reference counting on
240: * processors. Processor reference to pset is implicit.
241: */
242:
243: void pset_add_processor(
244: processor_set_t pset,
245: processor_t processor)
246: {
247: queue_enter(&pset->processors, processor, processor_t, processors);
248: processor->processor_set = pset;
249: pset->processor_count++;
250: quantum_set(pset);
251: }
252:
253: /*
254: * pset_remove_task() removes a task from a processor_set.
255: * Caller must hold locks on pset and task. Pset reference count
256: * is not decremented; caller must explicitly pset_deallocate.
257: */
258:
259: void pset_remove_task(
260: processor_set_t pset,
261: task_t task)
262: {
263: if (pset != task->processor_set)
264: return;
265:
266: queue_remove(&pset->tasks, task, task_t, pset_tasks);
267: task->processor_set = PROCESSOR_SET_NULL;
268: pset->task_count--;
269: }
270:
271: /*
272: * pset_add_task() adds a task to a processor_set.
273: * Caller must hold locks on pset and task. Pset references to
274: * tasks are implicit.
275: */
276:
277: void pset_add_task(
278: processor_set_t pset,
279: task_t task)
280: {
281: queue_enter(&pset->tasks, task, task_t, pset_tasks);
282: task->processor_set = pset;
283: pset->task_count++;
284: }
285:
286: /*
287: * pset_remove_thread() removes a thread from a processor_set.
288: * Caller must hold locks on pset and thread. Pset reference count
289: * is not decremented; caller must explicitly pset_deallocate.
290: */
291:
292: void pset_remove_thread(
293: processor_set_t pset,
294: thread_t thread)
295: {
296: queue_remove(&pset->threads, thread, thread_t, pset_threads);
297: thread->processor_set = PROCESSOR_SET_NULL;
298: pset->thread_count--;
299: }
300:
301: /*
302: * pset_add_thread() adds a thread to a processor_set.
303: * Caller must hold locks on pset and thread. Pset references to
304: * threads are implicit.
305: */
306:
307: void pset_add_thread(
308: processor_set_t pset,
309: thread_t thread)
310: {
311: queue_enter(&pset->threads, thread, thread_t, pset_threads);
312: thread->processor_set = pset;
313: pset->thread_count++;
314: }
315:
316: /*
317: * thread_change_psets() changes the pset of a thread. Caller must
318: * hold locks on both psets and thread. The old pset must be
319: * explicitly pset_deallocat()'ed by caller.
320: */
321:
322: void thread_change_psets(
323: thread_t thread,
324: processor_set_t old_pset,
325: processor_set_t new_pset)
326: {
327: queue_remove(&old_pset->threads, thread, thread_t, pset_threads);
328: old_pset->thread_count--;
329: queue_enter(&new_pset->threads, thread, thread_t, pset_threads);
330: thread->processor_set = new_pset;
331: new_pset->thread_count++;
332: }
333:
334: /*
335: * pset_deallocate:
336: *
337: * Remove one reference to the processor set. Destroy processor_set
338: * if this was the last reference.
339: */
340: void pset_deallocate(
341: processor_set_t pset)
342: {
343: if (pset == PROCESSOR_SET_NULL)
344: return;
345:
346: pset_ref_lock(pset);
347: if (--pset->ref_count > 0) {
348: pset_ref_unlock(pset);
349: return;
350: }
351: #if !MACH_HOST
352: panic("pset_deallocate: default_pset destroyed");
353: #endif /* !MACH_HOST */
354:
355: #if MACH_HOST
356: /*
357: * Reference count is zero, however the all_psets list
358: * holds an implicit reference and may make new ones.
359: * Its lock also dominates the pset lock. To check for this,
360: * temporarily restore one reference, and then lock the
361: * other structures in the right order.
362: */
363: pset->ref_count = 1;
364: pset_ref_unlock(pset);
365:
366: simple_lock(&all_psets_lock);
367: pset_ref_lock(pset);
368: if (--pset->ref_count > 0) {
369: /*
370: * Made an extra reference.
371: */
372: pset_ref_unlock(pset);
373: simple_unlock(&all_psets_lock);
374: return;
375: }
376:
377: /*
378: * Ok to destroy pset. Make a few paranoia checks.
379: */
380:
381: if ((pset == &default_pset) || (pset->thread_count > 0) ||
382: (pset->task_count > 0) || pset->processor_count > 0) {
383: panic("pset_deallocate: destroy default or active pset");
384: }
385: /*
386: * Remove from all_psets queue.
387: */
388: queue_remove(&all_psets, pset, processor_set_t, all_psets);
389: all_psets_count--;
390:
391: pset_ref_unlock(pset);
392: simple_unlock(&all_psets_lock);
393:
394: /*
395: * That's it, free data structure.
396: */
397: zfree(pset_zone, (vm_offset_t)pset);
398: #endif /* MACH_HOST */
399: }
400:
401: /*
402: * pset_reference:
403: *
404: * Add one reference to the processor set.
405: */
406: void pset_reference(
407: processor_set_t pset)
408: {
409: pset_ref_lock(pset);
410: pset->ref_count++;
411: pset_ref_unlock(pset);
412: }
413:
414: kern_return_t
415: processor_info(
416: register processor_t processor,
417: int flavor,
418: host_t *host,
419: processor_info_t info,
420: natural_t *count)
421: {
422: register int slot_num, state;
423: register processor_basic_info_t basic_info;
424:
425: if (processor == PROCESSOR_NULL)
426: return KERN_INVALID_ARGUMENT;
427:
428: if (flavor != PROCESSOR_BASIC_INFO ||
429: *count < PROCESSOR_BASIC_INFO_COUNT)
430: return KERN_FAILURE;
431:
432: basic_info = (processor_basic_info_t) info;
433:
434: slot_num = processor->slot_num;
435: basic_info->cpu_type = machine_slot[slot_num].cpu_type;
436: basic_info->cpu_subtype = machine_slot[slot_num].cpu_subtype;
437: state = processor->state;
438: if (state == PROCESSOR_SHUTDOWN || state == PROCESSOR_OFF_LINE)
439: basic_info->running = FALSE;
440: else
441: basic_info->running = TRUE;
442: basic_info->slot_num = slot_num;
443: if (processor == master_processor)
444: basic_info->is_master = TRUE;
445: else
446: basic_info->is_master = FALSE;
447:
448: *count = PROCESSOR_BASIC_INFO_COUNT;
449: *host = &realhost;
450: return KERN_SUCCESS;
451: }
452:
453: kern_return_t processor_start(
454: processor_t processor)
455: {
456: if (processor == PROCESSOR_NULL)
457: return KERN_INVALID_ARGUMENT;
458: #if NCPUS > 1
459: return cpu_start(processor->slot_num);
460: #else /* NCPUS > 1 */
461: return KERN_FAILURE;
462: #endif /* NCPUS > 1 */
463: }
464:
465: kern_return_t processor_exit(
466: processor_t processor)
467: {
468: if (processor == PROCESSOR_NULL)
469: return KERN_INVALID_ARGUMENT;
470:
471: #if NCPUS > 1
472: return processor_shutdown(processor);
473: #else /* NCPUS > 1 */
474: return KERN_FAILURE;
475: #endif /* NCPUS > 1 */
476: }
477:
478: kern_return_t
479: processor_control(
480: processor_t processor,
481: processor_info_t info,
482: natural_t count)
483: {
484: if (processor == PROCESSOR_NULL)
485: return KERN_INVALID_ARGUMENT;
486:
487: #if NCPUS > 1
488: return cpu_control(processor->slot_num, (int *)info, count);
489: #else /* NCPUS > 1 */
490: return KERN_FAILURE;
491: #endif /* NCPUS > 1 */
492: }
493:
494: /*
495: * Precalculate the appropriate system quanta based on load. The
496: * index into machine_quantum is the number of threads on the
497: * processor set queue. It is limited to the number of processors in
498: * the set.
499: */
500:
501: void quantum_set(
502: processor_set_t pset)
503: {
504: #if NCPUS > 1
505: register int i,ncpus;
506:
507: ncpus = pset->processor_count;
508:
509: for ( i=1 ; i <= ncpus ; i++) {
510: pset->machine_quantum[i] =
511: ((min_quantum * ncpus) + (i/2)) / i ;
512: }
513: pset->machine_quantum[0] = 2 * pset->machine_quantum[1];
514:
515: i = ((pset->runq.count > pset->processor_count) ?
516: pset->processor_count : pset->runq.count);
517: pset->set_quantum = pset->machine_quantum[i];
518: #else /* NCPUS > 1 */
519: default_pset.set_quantum = min_quantum;
520: #endif /* NCPUS > 1 */
521: }
522:
523: #if MACH_HOST
524: /*
525: * processor_set_create:
526: *
527: * Create and return a new processor set.
528: */
529:
530: kern_return_t
531: processor_set_create(
532: host_t host,
533: processor_set_t *new_set,
534: processor_set_t *new_name)
535: {
536: processor_set_t pset;
537:
538: if (host == HOST_NULL)
539: return KERN_INVALID_ARGUMENT;
540:
541: pset = (processor_set_t) zalloc(pset_zone);
542: pset_init(pset);
543: pset_reference(pset); /* for new_set out argument */
544: pset_reference(pset); /* for new_name out argument */
545: ipc_pset_init(pset);
546: pset->active = TRUE;
547:
548: simple_lock(&all_psets_lock);
549: queue_enter(&all_psets, pset, processor_set_t, all_psets);
550: all_psets_count++;
551: simple_unlock(&all_psets_lock);
552:
553: ipc_pset_enable(pset);
554:
555: *new_set = pset;
556: *new_name = pset;
557: return KERN_SUCCESS;
558: }
559:
560: /*
561: * processor_set_destroy:
562: *
563: * destroy a processor set. Any tasks, threads or processors
564: * currently assigned to it are reassigned to the default pset.
565: */
566: kern_return_t processor_set_destroy(
567: processor_set_t pset)
568: {
569: register queue_entry_t elem;
570: register queue_head_t *list;
571:
572: if (pset == PROCESSOR_SET_NULL || pset == &default_pset)
573: return KERN_INVALID_ARGUMENT;
574:
575: /*
576: * Handle multiple termination race. First one through sets
577: * active to FALSE and disables ipc access.
578: */
579: pset_lock(pset);
580: if (!(pset->active)) {
581: pset_unlock(pset);
582: return KERN_FAILURE;
583: }
584:
585: pset->active = FALSE;
586: ipc_pset_disable(pset);
587:
588:
589: /*
590: * Now reassign everything in this set to the default set.
591: */
592:
593: if (pset->task_count > 0) {
594: list = &pset->tasks;
595: while (!queue_empty(list)) {
596: elem = queue_first(list);
597: task_reference((task_t) elem);
598: pset_unlock(pset);
599: task_assign((task_t) elem, &default_pset, FALSE);
600: task_deallocate((task_t) elem);
601: pset_lock(pset);
602: }
603: }
604:
605: if (pset->thread_count > 0) {
606: list = &pset->threads;
607: while (!queue_empty(list)) {
608: elem = queue_first(list);
609: thread_reference((thread_t) elem);
610: pset_unlock(pset);
611: thread_assign((thread_t) elem, &default_pset);
612: thread_deallocate((thread_t) elem);
613: pset_lock(pset);
614: }
615: }
616:
617: if (pset->processor_count > 0) {
618: list = &pset->processors;
619: while(!queue_empty(list)) {
620: elem = queue_first(list);
621: pset_unlock(pset);
622: processor_assign((processor_t) elem, &default_pset, TRUE);
623: pset_lock(pset);
624: }
625: }
626:
627: pset_unlock(pset);
628:
629: /*
630: * Destroy ipc state.
631: */
632: ipc_pset_terminate(pset);
633:
634: /*
635: * Deallocate pset's reference to itself.
636: */
637: pset_deallocate(pset);
638: return KERN_SUCCESS;
639: }
640:
641: #else /* MACH_HOST */
642:
643: kern_return_t
644: processor_set_create(
645: host_t host,
646: processor_set_t *new_set,
647: processor_set_t *new_name)
648: {
649: #ifdef lint
650: host++; new_set++; new_name++;
651: #endif /* lint */
652: return KERN_FAILURE;
653: }
654:
655: kern_return_t processor_set_destroy(
656: processor_set_t pset)
657: {
658: #ifdef lint
659: pset++;
660: #endif /* lint */
661: return KERN_FAILURE;
662: }
663:
664: #endif /* MACH_HOST */
665:
666: kern_return_t
667: processor_get_assignment(
668: processor_t processor,
669: processor_set_t *pset)
670: {
671: int state;
672:
673: state = processor->state;
674: if (state == PROCESSOR_SHUTDOWN || state == PROCESSOR_OFF_LINE)
675: return KERN_FAILURE;
676:
677: *pset = processor->processor_set;
678: pset_reference(*pset);
679: return KERN_SUCCESS;
680: }
681:
682: kern_return_t
683: processor_set_info(
684: processor_set_t pset,
685: int flavor,
686: host_t *host,
687: processor_set_info_t info,
688: natural_t *count)
689: {
690: if (pset == PROCESSOR_SET_NULL)
691: return KERN_INVALID_ARGUMENT;
692:
693: if (flavor == PROCESSOR_SET_BASIC_INFO) {
694: register processor_set_basic_info_t basic_info;
695:
696: if (*count < PROCESSOR_SET_BASIC_INFO_COUNT)
697: return KERN_FAILURE;
698:
699: basic_info = (processor_set_basic_info_t) info;
700:
701: pset_lock(pset);
702: basic_info->processor_count = pset->processor_count;
703: basic_info->task_count = pset->task_count;
704: basic_info->thread_count = pset->thread_count;
705: basic_info->mach_factor = pset->mach_factor;
706: basic_info->load_average = pset->load_average;
707: pset_unlock(pset);
708:
709: *count = PROCESSOR_SET_BASIC_INFO_COUNT;
710: *host = &realhost;
711: return KERN_SUCCESS;
712: }
713: else if (flavor == PROCESSOR_SET_SCHED_INFO) {
714: register processor_set_sched_info_t sched_info;
715:
716: if (*count < PROCESSOR_SET_SCHED_INFO_COUNT)
717: return KERN_FAILURE;
718:
719: sched_info = (processor_set_sched_info_t) info;
720:
721: pset_lock(pset);
722: #if MACH_FIXPRI
723: sched_info->policies = pset->policies;
724: #else /* MACH_FIXPRI */
725: sched_info->policies = POLICY_TIMESHARE;
726: #endif /* MACH_FIXPRI */
727: sched_info->max_priority = pset->max_priority;
728: pset_unlock(pset);
729:
730: *count = PROCESSOR_SET_SCHED_INFO_COUNT;
731: *host = &realhost;
732: return KERN_SUCCESS;
733: }
734:
735: *host = HOST_NULL;
736: return KERN_INVALID_ARGUMENT;
737: }
738:
739: /*
740: * processor_set_max_priority:
741: *
742: * Specify max priority permitted on processor set. This affects
743: * newly created and assigned threads. Optionally change existing
744: * ones.
745: */
746: kern_return_t
747: processor_set_max_priority(
748: processor_set_t pset,
749: int max_priority,
750: boolean_t change_threads)
751: {
752: if (pset == PROCESSOR_SET_NULL || invalid_pri(max_priority))
753: return KERN_INVALID_ARGUMENT;
754:
755: pset_lock(pset);
756: pset->max_priority = max_priority;
757:
758: if (change_threads) {
759: register queue_head_t *list;
760: register thread_t thread;
761:
762: list = &pset->threads;
763: queue_iterate(list, thread, thread_t, pset_threads) {
764: if (thread->max_priority < max_priority)
765: thread_max_priority(thread, pset, max_priority);
766: }
767: }
768:
769: pset_unlock(pset);
770:
771: return KERN_SUCCESS;
772: }
773:
774: /*
775: * processor_set_policy_enable:
776: *
777: * Allow indicated policy on processor set.
778: */
779:
780: kern_return_t
781: processor_set_policy_enable(
782: processor_set_t pset,
783: int policy)
784: {
785: if ((pset == PROCESSOR_SET_NULL) || invalid_policy(policy))
786: return KERN_INVALID_ARGUMENT;
787:
788: #if MACH_FIXPRI
789: pset_lock(pset);
790: pset->policies |= policy;
791: pset_unlock(pset);
792:
793: return KERN_SUCCESS;
794: #else /* MACH_FIXPRI */
795: if (policy == POLICY_TIMESHARE)
796: return KERN_SUCCESS;
797: else
798: return KERN_FAILURE;
799: #endif /* MACH_FIXPRI */
800: }
801:
802: /*
803: * processor_set_policy_disable:
804: *
805: * Forbid indicated policy on processor set. Time sharing cannot
806: * be forbidden.
807: */
808:
809: kern_return_t
810: processor_set_policy_disable(
811: processor_set_t pset,
812: int policy,
813: boolean_t change_threads)
814: {
815: if ((pset == PROCESSOR_SET_NULL) || policy == POLICY_TIMESHARE ||
816: invalid_policy(policy))
817: return KERN_INVALID_ARGUMENT;
818:
819: #if MACH_FIXPRI
820: pset_lock(pset);
821:
822: /*
823: * Check if policy enabled. Disable if so, then handle
824: * change_threads.
825: */
826: if (pset->policies & policy) {
827: pset->policies &= ~policy;
828:
829: if (change_threads) {
830: register queue_head_t *list;
831: register thread_t thread;
832:
833: list = &pset->threads;
834: queue_iterate(list, thread, thread_t, pset_threads) {
835: if (thread->policy == policy)
836: thread_policy(thread, POLICY_TIMESHARE, 0);
837: }
838: }
839: }
840: pset_unlock(pset);
841: #endif /* MACH_FIXPRI */
842:
843: return KERN_SUCCESS;
844: }
845:
846: #define THING_TASK 0
847: #define THING_THREAD 1
848:
849: /*
850: * processor_set_things:
851: *
852: * Common internals for processor_set_{threads,tasks}
853: */
854: kern_return_t
855: processor_set_things(
856: processor_set_t pset,
857: mach_port_t **thing_list,
858: natural_t *count,
859: int type)
860: {
861: unsigned int actual; /* this many things */
862: int i;
863:
864: vm_size_t size, size_needed;
865: vm_offset_t addr;
866:
867: if (pset == PROCESSOR_SET_NULL)
868: return KERN_INVALID_ARGUMENT;
869:
870: size = 0; addr = 0;
871:
872: for (;;) {
873: pset_lock(pset);
874: if (!pset->active) {
875: pset_unlock(pset);
876: return KERN_FAILURE;
877: }
878:
879: if (type == THING_TASK)
880: actual = pset->task_count;
881: else
882: actual = pset->thread_count;
883:
884: /* do we have the memory we need? */
885:
886: size_needed = actual * sizeof(mach_port_t);
887: if (size_needed <= size)
888: break;
889:
890: /* unlock the pset and allocate more memory */
891: pset_unlock(pset);
892:
893: if (size != 0)
894: kfree(addr, size);
895:
896: assert(size_needed > 0);
897: size = size_needed;
898:
899: addr = kalloc(size);
900: if (addr == 0)
901: return KERN_RESOURCE_SHORTAGE;
902: }
903:
904: /* OK, have memory and the processor_set is locked & active */
905:
906: switch (type) {
907: case THING_TASK: {
908: task_t *tasks = (task_t *) addr;
909: task_t task;
910:
911: for (i = 0, task = (task_t) queue_first(&pset->tasks);
912: i < actual;
913: i++, task = (task_t) queue_next(&task->pset_tasks)) {
914: /* take ref for convert_task_to_port */
915: task_reference(task);
916: tasks[i] = task;
917: }
918: assert(queue_end(&pset->tasks, (queue_entry_t) task));
919: break;
920: }
921:
922: case THING_THREAD: {
923: thread_t *threads = (thread_t *) addr;
924: thread_t thread;
925:
926: for (i = 0, thread = (thread_t) queue_first(&pset->threads);
927: i < actual;
928: i++,
929: thread = (thread_t) queue_next(&thread->pset_threads)) {
930: /* take ref for convert_thread_to_port */
931: thread_reference(thread);
932: threads[i] = thread;
933: }
934: assert(queue_end(&pset->threads, (queue_entry_t) thread));
935: break;
936: }
937: }
938:
939: /* can unlock processor set now that we have the task/thread refs */
940: pset_unlock(pset);
941:
942: if (actual == 0) {
943: /* no things, so return null pointer and deallocate memory */
944: *thing_list = 0;
945: *count = 0;
946:
947: if (size != 0)
948: kfree(addr, size);
949: } else {
950: /* if we allocated too much, must copy */
951:
952: if (size_needed < size) {
953: vm_offset_t newaddr;
954:
955: newaddr = kalloc(size_needed);
956: if (newaddr == 0) {
957: switch (type) {
958: case THING_TASK: {
959: task_t *tasks = (task_t *) addr;
960:
961: for (i = 0; i < actual; i++)
962: task_deallocate(tasks[i]);
963: break;
964: }
965:
966: case THING_THREAD: {
967: thread_t *threads = (thread_t *) addr;
968:
969: for (i = 0; i < actual; i++)
970: thread_deallocate(threads[i]);
971: break;
972: }
973: }
974: kfree(addr, size);
975: return KERN_RESOURCE_SHORTAGE;
976: }
977:
978: bcopy((char *) addr, (char *) newaddr, size_needed);
979: kfree(addr, size);
980: addr = newaddr;
981: }
982:
983: *thing_list = (mach_port_t *) addr;
984: *count = actual;
985:
986: /* do the conversion that Mig should handle */
987:
988: switch (type) {
989: case THING_TASK: {
990: task_t *tasks = (task_t *) addr;
991:
992: for (i = 0; i < actual; i++)
993: ((mach_port_t *) tasks)[i] =
994: (mach_port_t)convert_task_to_port(tasks[i]);
995: break;
996: }
997:
998: case THING_THREAD: {
999: thread_t *threads = (thread_t *) addr;
1000:
1001: for (i = 0; i < actual; i++)
1002: ((mach_port_t *) threads)[i] =
1003: (mach_port_t)convert_thread_to_port(threads[i]);
1004: break;
1005: }
1006: }
1007: }
1008:
1009: return KERN_SUCCESS;
1010: }
1011:
1012:
1013: /*
1014: * processor_set_tasks:
1015: *
1016: * List all tasks in the processor set.
1017: */
1018: kern_return_t
1019: processor_set_tasks(
1020: processor_set_t pset,
1021: task_array_t *task_list,
1022: natural_t *count)
1023: {
1024: return processor_set_things(pset, task_list, count, THING_TASK);
1025: }
1026:
1027: /*
1028: * processor_set_threads:
1029: *
1030: * List all threads in the processor set.
1031: */
1032: kern_return_t
1033: processor_set_threads(
1034: processor_set_t pset,
1035: thread_array_t *thread_list,
1036: natural_t *count)
1037: {
1038: return processor_set_things(pset, thread_list, count, THING_THREAD);
1039: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.