![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to machine.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / kern|
Return to machine.c CVS log | Up to [Apple XNU] / XNU / osfmk / kern |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* ! 23: * @OSF_COPYRIGHT@ ! 24: */ ! 25: /* ! 26: * Mach Operating System ! 27: * Copyright (c) 1991,1990,1989,1988,1987 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: /* ! 53: * File: kern/machine.c ! 54: * Author: Avadis Tevanian, Jr. ! 55: * Date: 1987 ! 56: * ! 57: * Support for machine independent machine abstraction. ! 58: */ ! 59: ! 60: #include <cpus.h> ! 61: #include <mach_host.h> ! 62: ! 63: #include <string.h> ! 64: #include <mach/boolean.h> ! 65: #include <mach/kern_return.h> ! 66: #include <mach/mach_types.h> ! 67: #include <mach/machine.h> ! 68: #include <mach/host_info.h> ! 69: #include <mach/host_reboot.h> ! 70: #include <kern/counters.h> ! 71: #include <kern/cpu_data.h> ! 72: #include <kern/ipc_host.h> ! 73: #include <kern/host.h> ! 74: #include <kern/lock.h> ! 75: #include <kern/machine.h> ! 76: #include <kern/processor.h> ! 77: #include <kern/queue.h> ! 78: #include <kern/sched.h> ! 79: #include <kern/task.h> ! 80: #include <kern/thread.h> ! 81: #include <kern/thread_swap.h> ! 82: #include <kern/misc_protos.h> ! 83: ! 84: #include <mach/mach_host_server.h> ! 85: ! 86: ! 87: /* ! 88: * Exported variables: ! 89: */ ! 90: ! 91: struct machine_info machine_info; ! 92: struct machine_slot machine_slot[NCPUS]; ! 93: ! 94: queue_head_t action_queue; /* assign/shutdown queue */ ! 95: decl_simple_lock_data(,action_lock) ! 96: ! 97: static thread_call_t processor_action_call; ! 98: ! 99: /* Forwards */ ! 100: processor_set_t processor_request_action( ! 101: processor_t processor, ! 102: processor_set_t new_pset); ! 103: ! 104: void processor_doaction( ! 105: processor_t processor); ! 106: ! 107: void processor_doshutdown( ! 108: processor_t processor); ! 109: ! 110: int thread_stop_freeze( ! 111: thread_t thread, ! 112: processor_set_t pset); ! 113: ! 114: /* ! 115: * cpu_up: ! 116: * ! 117: * Flag specified cpu as up and running. Called when a processor comes ! 118: * online. ! 119: */ ! 120: void ! 121: cpu_up( ! 122: int cpu) ! 123: { ! 124: processor_t processor; ! 125: struct machine_slot *ms; ! 126: spl_t s; ! 127: ! 128: processor = cpu_to_processor(cpu); ! 129: /* ! 130: * Can't risk blocking with no current thread established. ! 131: * Just twiddle our thumbs; we've got nothing better to do ! 132: * yet, anyway. ! 133: */ ! 134: while (!pset_lock_try(&default_pset)) ! 135: continue; ! 136: ! 137: s = splsched(); ! 138: processor_lock(processor); ! 139: #if NCPUS > 1 ! 140: init_ast_check(processor); ! 141: #endif /* NCPUS > 1 */ ! 142: ms = &machine_slot[cpu]; ! 143: ms->running = TRUE; ! 144: machine_info.avail_cpus++; ! 145: pset_add_processor(&default_pset, processor); ! 146: processor->state = PROCESSOR_RUNNING; ! 147: processor_unlock(processor); ! 148: splx(s); ! 149: pset_unlock(&default_pset); ! 150: } ! 151: ! 152: /* ! 153: * cpu_down: ! 154: * ! 155: * Flag specified cpu as down. Called when a processor is about to ! 156: * go offline. ! 157: */ ! 158: ! 159: void ! 160: cpu_down( ! 161: int cpu) ! 162: { ! 163: processor_t processor; ! 164: struct machine_slot *ms; ! 165: spl_t s; ! 166: ! 167: processor = cpu_to_processor(cpu); ! 168: ! 169: s = splsched(); ! 170: processor_lock(processor); ! 171: ms = &machine_slot[cpu]; ! 172: ms->running = FALSE; ! 173: machine_info.avail_cpus--; ! 174: /* ! 175: * processor has already been removed from pset. ! 176: */ ! 177: processor->processor_set_next = PROCESSOR_SET_NULL; ! 178: processor->state = PROCESSOR_OFF_LINE; ! 179: processor_unlock(processor); ! 180: splx(s); ! 181: } ! 182: ! 183: kern_return_t ! 184: host_reboot( ! 185: host_t host, ! 186: int options) ! 187: { ! 188: if (host == HOST_NULL) ! 189: return (KERN_INVALID_HOST); ! 190: ! 191: if (options & HOST_REBOOT_DEBUGGER) { ! 192: Debugger("Debugger"); ! 193: } ! 194: else ! 195: halt_all_cpus(!(options & HOST_REBOOT_HALT)); ! 196: ! 197: return (KERN_SUCCESS); ! 198: } ! 199: ! 200: #if NCPUS > 1 ! 201: /* ! 202: * processor_request_action - common internals of processor_assign ! 203: * and processor_shutdown. If new_pset is null, this is ! 204: * a shutdown, else it's an assign and caller must donate ! 205: * a reference. For assign operations, it returns ! 206: * an old pset that must be deallocated if it's not NULL. For ! 207: * shutdown operations, it always returns PROCESSOR_SET_NULL. ! 208: */ ! 209: processor_set_t ! 210: processor_request_action( ! 211: processor_t processor, ! 212: processor_set_t new_pset) ! 213: { ! 214: register processor_set_t pset, old_next_pset; ! 215: ! 216: /* ! 217: * Processor must be in a processor set. Must lock its idle lock to ! 218: * get at processor state. ! 219: */ ! 220: pset = processor->processor_set; ! 221: simple_lock(&pset->idle_lock); ! 222: ! 223: /* ! 224: * If the processor is dispatching, let it finish - it will set its ! 225: * state to running very soon. ! 226: */ ! 227: while (*(volatile int *)&processor->state == PROCESSOR_DISPATCHING) ! 228: continue; ! 229: ! 230: /* ! 231: * Now lock the action queue and do the dirty work. ! 232: */ ! 233: simple_lock(&action_lock); ! 234: ! 235: switch (processor->state) { ! 236: ! 237: case PROCESSOR_IDLE: ! 238: /* ! 239: * Remove from idle queue. ! 240: */ ! 241: queue_remove(&pset->idle_queue, ! 242: processor, processor_t, processor_queue); ! 243: pset->idle_count--; ! 244: ! 245: /* fall through ... */ ! 246: case PROCESSOR_RUNNING: ! 247: /* ! 248: * Put it on the action queue. ! 249: */ ! 250: queue_enter(&action_queue, ! 251: processor, processor_t,processor_queue); ! 252: ! 253: /* fall through ... */ ! 254: case PROCESSOR_ASSIGN: ! 255: /* ! 256: * And ask the action_thread to do the work. ! 257: */ ! 258: ! 259: if (new_pset == PROCESSOR_SET_NULL) { ! 260: processor->state = PROCESSOR_SHUTDOWN; ! 261: old_next_pset = PROCESSOR_SET_NULL; ! 262: } ! 263: else { ! 264: processor->state = PROCESSOR_ASSIGN; ! 265: old_next_pset = processor->processor_set_next; ! 266: processor->processor_set_next = new_pset; ! 267: } ! 268: break; ! 269: ! 270: default: ! 271: printf("state: %d\n", processor->state); ! 272: panic("processor_request_action: bad state"); ! 273: } ! 274: ! 275: simple_unlock(&action_lock); ! 276: simple_unlock(&pset->idle_lock); ! 277: ! 278: thread_call_enter(processor_action_call); ! 279: ! 280: return (old_next_pset); ! 281: } ! 282: ! 283: #if MACH_HOST ! 284: /* ! 285: * processor_assign() changes the processor set that a processor is ! 286: * assigned to. Any previous assignment in progress is overriden. ! 287: * Synchronizes with assignment completion if wait is TRUE. ! 288: */ ! 289: kern_return_t ! 290: processor_assign( ! 291: processor_t processor, ! 292: processor_set_t new_pset, ! 293: boolean_t wait) ! 294: { ! 295: register processor_set_t old_next_pset; ! 296: spl_t s; ! 297: ! 298: /* ! 299: * Check for null arguments. ! 300: * XXX Can't assign master processor. ! 301: */ ! 302: if ( processor == PROCESSOR_NULL || ! 303: new_pset == PROCESSOR_SET_NULL || ! 304: processor == master_processor) ! 305: return (KERN_FAILURE); ! 306: ! 307: /* ! 308: * Get pset reference to donate to processor_request_action. ! 309: */ ! 310: pset_reference(new_pset); ! 311: ! 312: s = splsched(); ! 313: processor_lock(processor); ! 314: if ( processor->state == PROCESSOR_OFF_LINE || ! 315: processor->state == PROCESSOR_SHUTDOWN) { ! 316: /* ! 317: * Already shutdown or being shutdown -- Can't reassign. ! 318: */ ! 319: processor_unlock(processor); ! 320: splx(s); ! 321: pset_deallocate(new_pset); ! 322: ! 323: return (KERN_FAILURE); ! 324: } ! 325: ! 326: old_next_pset = processor_request_action(processor, new_pset); ! 327: ! 328: ! 329: /* ! 330: * Synchronization with completion. ! 331: */ ! 332: while ( wait && (processor->state == PROCESSOR_ASSIGN || ! 333: processor->state == PROCESSOR_SHUTDOWN)) { ! 334: assert_wait((event_t)processor, THREAD_ABORTSAFE); ! 335: processor_unlock(processor); ! 336: splx(s); ! 337: ! 338: thread_block((void (*)(void)) 0); ! 339: ! 340: s = splsched(); ! 341: processor_lock(processor); ! 342: } ! 343: ! 344: processor_unlock(processor); ! 345: splx(s); ! 346: ! 347: if (old_next_pset != PROCESSOR_SET_NULL) ! 348: pset_deallocate(old_next_pset); ! 349: ! 350: return (KERN_SUCCESS); ! 351: } ! 352: ! 353: #else /* MACH_HOST */ ! 354: ! 355: kern_return_t ! 356: processor_assign( ! 357: processor_t processor, ! 358: processor_set_t new_pset, ! 359: boolean_t wait) ! 360: { ! 361: #ifdef lint ! 362: processor++; new_pset++; wait++; ! 363: #endif /* lint */ ! 364: return (KERN_FAILURE); ! 365: } ! 366: ! 367: #endif /* MACH_HOST */ ! 368: ! 369: /* ! 370: * processor_shutdown() queues a processor up for shutdown. ! 371: * Any assignment in progress is overriden. It does not synchronize ! 372: * with the shutdown (can be called from interrupt level). ! 373: */ ! 374: kern_return_t ! 375: processor_shutdown( ! 376: processor_t processor) ! 377: { ! 378: spl_t s; ! 379: ! 380: s = splsched(); ! 381: processor_lock(processor); ! 382: if ( processor->state == PROCESSOR_OFF_LINE || ! 383: processor->state == PROCESSOR_SHUTDOWN) { ! 384: /* ! 385: * Already shutdown or being shutdown -- nothing to do. ! 386: */ ! 387: processor_unlock(processor); ! 388: splx(s); ! 389: ! 390: return (KERN_SUCCESS); ! 391: } ! 392: ! 393: (void) processor_request_action(processor, PROCESSOR_SET_NULL); ! 394: processor_unlock(processor); ! 395: splx(s); ! 396: ! 397: return (KERN_SUCCESS); ! 398: } ! 399: ! 400: /* ! 401: * processor_action() shuts down processors or changes their assignment. ! 402: */ ! 403: ! 404: static thread_call_data_t processor_action_call_data; ! 405: ! 406: void ! 407: processor_action(void) ! 408: { ! 409: register processor_t processor; ! 410: spl_t s; ! 411: ! 412: s = splsched(); ! 413: simple_lock(&action_lock); ! 414: ! 415: if (processor_action_call == NULL) { ! 416: thread_call_setup(&processor_action_call_data, ! 417: processor_action, NULL); ! 418: processor_action_call = &processor_action_call_data; ! 419: } ! 420: ! 421: while (!queue_empty(&action_queue)) { ! 422: processor = (processor_t) queue_first(&action_queue); ! 423: queue_remove(&action_queue, processor, processor_t, processor_queue); ! 424: simple_unlock(&action_lock); ! 425: splx(s); ! 426: ! 427: processor_doaction(processor); ! 428: ! 429: s = splsched(); ! 430: simple_lock(&action_lock); ! 431: } ! 432: ! 433: simple_unlock(&action_lock); ! 434: splx(s); ! 435: } ! 436: ! 437: /* ! 438: * thread_stop_freeze ! 439: * Block the thread in the kernel and freeze the processor set. ! 440: * return value: ! 441: * TRUE - the thread has blocked interruptibly, is stopped, and ! 442: * the processor set assignment is frozen ! 443: * FALSE - the thread is no longer in the processor set, so it ! 444: * isn't stopped, and the processor set assignment ! 445: * is released. ! 446: */ ! 447: int ! 448: thread_stop_freeze( ! 449: thread_t thread, ! 450: processor_set_t pset) ! 451: { ! 452: #if 0 /* HACK ALERT!!!! (TEST/DEBUG) */ ! 453: thread_act_t thr_act; ! 454: spl_t s; ! 455: ! 456: /* ! 457: * hold it, and wait for it to stop. ! 458: */ ! 459: thr_act = thread_lock_act(thread); ! 460: thread_hold(thr_act); ! 461: act_unlock_thread(thr_act); ! 462: ! 463: thread_stop(thread); ! 464: ! 465: s = splsched(); ! 466: wake_lock(thread); ! 467: while( thread->state & (TH_RUN|TH_UNINT) ) { ! 468: thread->wake_active = TRUE; ! 469: assert_wait((event_t)&thread->wake_active, THREAD_UNINT); ! 470: wake_unlock(thread); ! 471: splx(s); ! 472: thread_block( (void (*)(void)) 0 ); ! 473: (void) splsched(); ! 474: wake_lock(thread); ! 475: } ! 476: ! 477: /* ! 478: * Now, the thread has blocked uninterruptibly; freeze the ! 479: * assignment and make sure it's still part of the processor set. ! 480: */ ! 481: wake_unlock(thread); ! 482: thread_freeze(thread); ! 483: thread_lock(thread); ! 484: ! 485: /* ! 486: * if the processor set has changed, release the freeze and ! 487: * then unstop it. ! 488: */ ! 489: if( thread->processor_set != pset ) { ! 490: thread_unlock(thread); ! 491: splx(s); ! 492: thread_unfreeze(thread); ! 493: thread_unstop(thread); ! 494: return FALSE; ! 495: } ! 496: thread_unlock(thread); ! 497: splx(s); ! 498: #endif /* HACK ALERT!!!! */ ! 499: ! 500: return TRUE; ! 501: } ! 502: ! 503: /* ! 504: * processor_doaction actually does the shutdown. The trick here ! 505: * is to schedule ourselves onto a cpu and then save our ! 506: * context back into the runqs before taking out the cpu. ! 507: */ ! 508: ! 509: void ! 510: processor_doaction( ! 511: processor_t processor) ! 512: { ! 513: thread_t this_thread; ! 514: spl_t s; ! 515: register processor_set_t pset; ! 516: #if MACH_HOST ! 517: register processor_set_t new_pset; ! 518: register thread_t thread; ! 519: register thread_t prev_thread = THREAD_NULL; ! 520: thread_act_t thr_act; ! 521: boolean_t have_pset_ref = FALSE; ! 522: #endif /* MACH_HOST */ ! 523: ! 524: /* ! 525: * Get onto the processor to shutdown ! 526: */ ! 527: this_thread = current_thread(); ! 528: thread_bind(this_thread, processor); ! 529: thread_block((void (*)(void)) 0); ! 530: ! 531: pset = processor->processor_set; ! 532: #if MACH_HOST ! 533: /* ! 534: * If this is the last processor in the processor_set, ! 535: * stop all the threads first. ! 536: */ ! 537: pset_lock(pset); ! 538: if (pset->processor_count == 1) { ! 539: thread = (thread_t) queue_first(&pset->threads); ! 540: prev_thread = THREAD_NULL; ! 541: pset->ref_count++; ! 542: have_pset_ref = TRUE; ! 543: pset->empty = TRUE; ! 544: ! 545: /* ! 546: * loop through freezing the processor set assignment ! 547: * and reference counting the threads; ! 548: */ ! 549: while (!queue_end(&pset->threads, (queue_entry_t) thread)) { ! 550: thread_reference(thread); ! 551: pset_unlock(pset); ! 552: ! 553: /* ! 554: * Freeze the thread on the processor set. ! 555: * If it's moved, just release the reference. ! 556: * Get the next thread in the processor set list ! 557: * from the last one which was frozen. ! 558: */ ! 559: if (thread_stop_freeze(thread, pset)) ! 560: prev_thread = thread; ! 561: else ! 562: thread_deallocate(thread); ! 563: ! 564: pset_lock(pset); ! 565: if (prev_thread != THREAD_NULL) ! 566: thread = (thread_t)queue_next(&prev_thread->pset_threads); ! 567: else ! 568: thread = (thread_t) queue_first(&pset->threads); ! 569: } ! 570: ! 571: /* ! 572: * Remove the processor from the set so that when the threads ! 573: * are unstopped below the ones blocked in the kernel don't ! 574: * start running again. ! 575: */ ! 576: s = splsched(); ! 577: processor_lock(processor); ! 578: pset_remove_processor(pset, processor); ! 579: ! 580: /* ! 581: * Prevent race with another processor being added to the set ! 582: * See code after Restart_pset: ! 583: * while(new_pset->empty && new_pset->processor_count > 0) ! 584: * ! 585: * ... it tests for the condition where a new processor is ! 586: * added to the set while the last one is still being removed. ! 587: */ ! 588: pset->processor_count++; /* block new processors being added */ ! 589: assert(pset->processor_count == 1); ! 590: ! 591: /* ! 592: * Release the thread assignment locks, unstop the threads and ! 593: * release the thread references which were taken above. ! 594: */ ! 595: thread = (thread_t) queue_first(&pset->threads); ! 596: while(!queue_empty(&pset->threads) && (thread != THREAD_NULL)) { ! 597: prev_thread = thread; ! 598: if (queue_end(&pset->threads, (queue_entry_t) thread)) ! 599: thread = THREAD_NULL; ! 600: else ! 601: thread = (thread_t) queue_next(&prev_thread->pset_threads); ! 602: ! 603: pset_unlock(pset); ! 604: thread_unfreeze(prev_thread); ! 605: thread_unstop(prev_thread); ! 606: thread_deallocate(prev_thread); ! 607: pset_lock(pset); ! 608: } ! 609: /* ! 610: * allow a processor to be added to the empty pset ! 611: */ ! 612: pset->processor_count--; ! 613: } ! 614: else { ! 615: /* not last processor in set */ ! 616: #endif /* MACH_HOST */ ! 617: /* ! 618: * At this point, it is ok to rm the processor from the pset. ! 619: */ ! 620: s = splsched(); ! 621: processor_lock(processor); ! 622: pset_remove_processor(pset, processor); ! 623: #if MACH_HOST ! 624: } ! 625: pset_unlock(pset); ! 626: ! 627: /* ! 628: * Copy the next pset pointer into a local variable and clear ! 629: * it because we are taking over its reference. ! 630: */ ! 631: new_pset = processor->processor_set_next; ! 632: processor->processor_set_next = PROCESSOR_SET_NULL; ! 633: ! 634: if (processor->state == PROCESSOR_ASSIGN) { ! 635: ! 636: Restart_pset: ! 637: /* ! 638: * Nasty problem: we want to lock the target pset, but ! 639: * we have to enable interrupts to do that which requires ! 640: * dropping the processor lock. While the processor ! 641: * is unlocked, it could be reassigned or shutdown. ! 642: */ ! 643: processor_unlock(processor); ! 644: splx(s); ! 645: ! 646: /* ! 647: * Lock target pset and handle remove last / assign first race. ! 648: * Only happens if there is more than one action thread. ! 649: */ ! 650: pset_lock(new_pset); ! 651: while (new_pset->empty && new_pset->processor_count > 0) { ! 652: pset_unlock(new_pset); ! 653: while ( *(volatile boolean_t *)&new_pset->empty && ! 654: *(volatile int *)&new_pset->processor_count > 0) ! 655: continue; ! 656: pset_lock(new_pset); ! 657: } ! 658: ! 659: /* ! 660: * Finally relock the processor and see if something changed. ! 661: * The only possibilities are assignment to a different pset ! 662: * and shutdown. ! 663: */ ! 664: s = splsched(); ! 665: processor_lock(processor); ! 666: ! 667: if (processor->state == PROCESSOR_SHUTDOWN) { ! 668: pset_unlock(new_pset); ! 669: goto shutdown; /* will release pset reference */ ! 670: } ! 671: ! 672: if (processor->processor_set_next != PROCESSOR_SET_NULL) { ! 673: /* ! 674: * Processor was reassigned. Drop the reference ! 675: * we have on the wrong new_pset, and get the ! 676: * right one. Involves lots of lock juggling. ! 677: */ ! 678: processor_unlock(processor); ! 679: splx(s); ! 680: pset_unlock(new_pset); ! 681: pset_deallocate(new_pset); ! 682: ! 683: s = splsched(); ! 684: processor_lock(processor); ! 685: new_pset = processor->processor_set_next; ! 686: processor->processor_set_next = PROCESSOR_SET_NULL; ! 687: goto Restart_pset; ! 688: } ! 689: ! 690: /* ! 691: * If the pset has been deactivated since the operation ! 692: * was requested, redirect to the default pset. ! 693: */ ! 694: if (!new_pset->active) { ! 695: pset_unlock(new_pset); ! 696: pset_deallocate(new_pset); ! 697: new_pset = &default_pset; ! 698: apset_lock(new_pset); ! 699: new_pset->ref_count++; ! 700: } ! 701: ! 702: /* ! 703: * Do assignment, then wakeup anyone waiting for it. ! 704: * Finally context switch to have it take effect. ! 705: */ ! 706: pset_add_processor(new_pset, processor); ! 707: if (new_pset->empty) { ! 708: /* ! 709: * Set all the threads loose ! 710: */ ! 711: thread = (thread_t) queue_first(&new_pset->threads); ! 712: while (!queue_end(&new_pset->threads,(queue_entry_t)thread)) { ! 713: thr_act = thread_lock_act(thread); ! 714: thread_release(thread->top_act); ! 715: act_unlock_thread(thr_act); ! 716: thread = (thread_t) queue_next(&thread->pset_threads); ! 717: } ! 718: ! 719: new_pset->empty = FALSE; ! 720: } ! 721: processor->processor_set_next = PROCESSOR_SET_NULL; ! 722: processor->state = PROCESSOR_RUNNING; ! 723: thread_wakeup((event_t)processor); ! 724: processor_unlock(processor); ! 725: splx(s); ! 726: pset_unlock(new_pset); ! 727: ! 728: /* ! 729: * Clean up dangling references, and release our binding. ! 730: */ ! 731: pset_deallocate(new_pset); ! 732: if (have_pset_ref) ! 733: pset_deallocate(pset); ! 734: ! 735: if (prev_thread != THREAD_NULL) ! 736: thread_deallocate(prev_thread); ! 737: ! 738: thread_bind(this_thread, PROCESSOR_NULL); ! 739: ! 740: thread_block((void (*)(void)) 0); ! 741: return; ! 742: } ! 743: ! 744: shutdown: ! 745: #endif /* MACH_HOST */ ! 746: ! 747: /* ! 748: * Do shutdown, make sure we live when processor dies. ! 749: */ ! 750: if (processor->state != PROCESSOR_SHUTDOWN) { ! 751: printf("state: %d\n", processor->state); ! 752: panic("action_thread -- bad processor state"); ! 753: } ! 754: processor_unlock(processor); ! 755: /* ! 756: * Clean up dangling references, and release our binding. ! 757: */ ! 758: #if MACH_HOST ! 759: if (new_pset != PROCESSOR_SET_NULL) ! 760: pset_deallocate(new_pset); ! 761: if (have_pset_ref) ! 762: pset_deallocate(pset); ! 763: if (prev_thread != THREAD_NULL) ! 764: thread_deallocate(prev_thread); ! 765: #endif /* MACH_HOST */ ! 766: ! 767: thread_bind(this_thread, PROCESSOR_NULL); ! 768: switch_to_shutdown_context(this_thread, processor_doshutdown, processor); ! 769: splx(s); ! 770: } ! 771: ! 772: /* ! 773: * Actually do the processor shutdown. This is called at splsched, ! 774: * running on the processor's shutdown stack. ! 775: */ ! 776: ! 777: void ! 778: processor_doshutdown( ! 779: processor_t processor) ! 780: { ! 781: register int cpu = processor->slot_num; ! 782: ! 783: timer_switch(&kernel_timer[cpu]); ! 784: ! 785: /* ! 786: * OK, now exit this cpu. ! 787: */ ! 788: PMAP_DEACTIVATE_KERNEL(cpu); ! 789: cpu_data[cpu].active_thread = THREAD_NULL; ! 790: active_kloaded[cpu] = THR_ACT_NULL; ! 791: cpu_down(cpu); ! 792: thread_wakeup((event_t)processor); ! 793: halt_cpu(); ! 794: panic("zombie processor"); ! 795: ! 796: /* ! 797: * The action thread returns to life after the call to ! 798: * switch_to_shutdown_context above, on some other cpu. ! 799: */ ! 800: ! 801: /*NOTREACHED*/ ! 802: } ! 803: #else /* NCPUS > 1 */ ! 804: ! 805: kern_return_t ! 806: processor_assign( ! 807: processor_t processor, ! 808: processor_set_t new_pset, ! 809: boolean_t wait) ! 810: { ! 811: #ifdef lint ! 812: processor++; new_pset++; wait++; ! 813: #endif /* lint */ ! 814: return (KERN_FAILURE); ! 815: } ! 816: ! 817: #endif /* NCPUS > 1 */ ! 818: ! 819: kern_return_t ! 820: host_get_boot_info( ! 821: host_t priv_host, ! 822: kernel_boot_info_t boot_info) ! 823: { ! 824: char *src = ""; ! 825: extern char *machine_boot_info( ! 826: kernel_boot_info_t boot_info, ! 827: vm_size_t buf_len); ! 828: ! 829: if (priv_host == HOST_NULL) ! 830: return (KERN_INVALID_HOST); ! 831: ! 832: /* ! 833: * Copy first operator string terminated by '\0' followed by ! 834: * standardized strings generated from boot string. ! 835: */ ! 836: src = machine_boot_info(boot_info, KERNEL_BOOT_INFO_MAX); ! 837: if (src != boot_info) ! 838: (void) strncpy(boot_info, src, KERNEL_BOOT_INFO_MAX); ! 839: ! 840: return (KERN_SUCCESS); ! 841: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.