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