1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * Solaris x86 ACPI ThermalZone Monitor 29 */ 30 31 32 #include <sys/errno.h> 33 #include <sys/conf.h> 34 #include <sys/modctl.h> 35 #include <sys/open.h> 36 #include <sys/stat.h> 37 #include <sys/ddi.h> 38 #include <sys/sunddi.h> 39 #include <sys/ksynch.h> 40 #include <sys/uadmin.h> 41 #include <sys/acpi/acpi.h> 42 #include <sys/acpica.h> 43 #include <sys/sdt.h> 44 45 #include "tzmon.h" 46 47 48 #define TZMON_ENUM_TRIP_POINTS 1 49 #define TZMON_ENUM_DEV_LISTS 2 50 #define TZMON_ENUM_ALL (TZMON_ENUM_TRIP_POINTS | TZMON_ENUM_DEV_LISTS) 51 52 /* 53 * TZ_TASKQ_NAME_LEN is precisely the length of the string "AcpiThermalMonitor" 54 * plus a two-digit instance number plus a NULL. If the taskq name is changed 55 * (particularly if it is lengthened), then this value needs to change. 56 */ 57 #define TZ_TASKQ_NAME_LEN 21 58 59 /* 60 * Kelvin to Celsius conversion 61 * The formula for converting degrees Kelvin to degrees Celsius is 62 * C = K - 273.15 (we round to 273.2). The unit for thermal zone 63 * temperatures is tenths of a degree Kelvin. Use tenth of a degree 64 * to convert, then make a whole number out of it. 65 */ 66 #define K_TO_C(temp) (((temp) - 2732) / 10) 67 68 69 /* cb_ops or dev_ops forward declarations */ 70 static int tzmon_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, 71 void *arg, void **result); 72 static int tzmon_attach(dev_info_t *dip, ddi_attach_cmd_t cmd); 73 static int tzmon_detach(dev_info_t *dip, ddi_detach_cmd_t cmd); 74 75 /* other forward declarations */ 76 static void tzmon_notify_zone(ACPI_HANDLE obj, UINT32 val, void *ctx); 77 static void tzmon_eval_int(ACPI_HANDLE obj, char *method, int *rv); 78 static thermal_zone_t *tzmon_alloc_zone(); 79 static void tzmon_free_zone_list(); 80 static void tzmon_discard_buffers(thermal_zone_t *tzp); 81 static void tzmon_enumerate_zone(ACPI_HANDLE obj, thermal_zone_t *tzp, 82 int enum_flag); 83 static ACPI_STATUS tzmon_zone_callback(ACPI_HANDLE obj, UINT32 nest, 84 void *ctx, void **rv); 85 static void tzmon_find_zones(void); 86 static void tzmon_monitor(void *ctx); 87 static void tzmon_set_power_device(ACPI_HANDLE dev, int on_off, char *tz_name); 88 static void tzmon_set_power(ACPI_BUFFER devlist, int on_off, char *tz_name); 89 static void tzmon_eval_zone(thermal_zone_t *tzp); 90 static void tzmon_do_shutdown(void); 91 92 extern void halt(char *); 93 94 static struct cb_ops tzmon_cb_ops = { 95 nodev, /* no open routine */ 96 nodev, /* no close routine */ 97 nodev, /* not a block driver */ 98 nodev, /* no print routine */ 99 nodev, /* no dump routine */ 100 nodev, /* no read routine */ 101 nodev, /* no write routine */ 102 nodev, /* no ioctl routine */ 103 nodev, /* no devmap routine */ 104 nodev, /* no mmap routine */ 105 nodev, /* no segmap routine */ 106 nochpoll, /* no chpoll routine */ 107 ddi_prop_op, 108 0, /* not a STREAMS driver */ 109 D_NEW | D_MP, /* safe for multi-thread/multi-processor */ 110 }; 111 112 static struct dev_ops tzmon_ops = { 113 DEVO_REV, /* devo_rev */ 114 0, /* devo_refcnt */ 115 tzmon_getinfo, /* devo_getinfo */ 116 nulldev, /* devo_identify */ 117 nulldev, /* devo_probe */ 118 tzmon_attach, /* devo_attach */ 119 tzmon_detach, /* devo_detach */ 120 nodev, /* devo_reset */ 121 &tzmon_cb_ops, /* devo_cb_ops */ 122 (struct bus_ops *)0, /* devo_bus_ops */ 123 NULL, /* devo_power */ 124 ddi_quiesce_not_needed, /* devo_quiesce */ 125 }; 126 127 extern struct mod_ops mod_driverops; 128 129 static struct modldrv modldrv = { 130 &mod_driverops, 131 "ACPI Thermal Zone Monitor", 132 &tzmon_ops, 133 }; 134 135 static struct modlinkage modlinkage = { 136 MODREV_1, /* MODREV_1 indicated by manual */ 137 (void *)&modldrv, 138 NULL, /* termination of list of linkage structures */ 139 }; 140 141 /* globals for this module */ 142 static dev_info_t *tzmon_dip; 143 static thermal_zone_t *zone_list; 144 static int zone_count; 145 static kmutex_t zone_list_lock; 146 static kcondvar_t zone_list_condvar; 147 148 149 /* 150 * _init, _info, and _fini support loading and unloading the driver. 151 */ 152 int 153 _init(void) 154 { 155 return (mod_install(&modlinkage)); 156 } 157 158 159 int 160 _info(struct modinfo *modinfop) 161 { 162 return (mod_info(&modlinkage, modinfop)); 163 } 164 165 166 int 167 _fini(void) 168 { 169 return (mod_remove(&modlinkage)); 170 } 171 172 173 static int 174 tzmon_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 175 { 176 if (cmd != DDI_ATTACH) 177 return (DDI_FAILURE); 178 179 if (tzmon_dip != NULL) 180 return (DDI_FAILURE); 181 182 /* 183 * Check to see if ACPI CA services are available 184 */ 185 if (AcpiSubsystemStatus() != AE_OK) 186 return (DDI_FAILURE); 187 188 mutex_init(&zone_list_lock, NULL, MUTEX_DRIVER, NULL); 189 cv_init(&zone_list_condvar, NULL, CV_DRIVER, NULL); 190 191 tzmon_find_zones(); 192 mutex_enter(&zone_list_lock); 193 if (zone_count < 1) { 194 mutex_exit(&zone_list_lock); 195 mutex_destroy(&zone_list_lock); 196 cv_destroy(&zone_list_condvar); 197 return (DDI_FAILURE); 198 } 199 mutex_exit(&zone_list_lock); 200 201 if (ddi_create_minor_node(dip, ddi_get_name(dip), S_IFCHR, 0, 202 DDI_PSEUDO, 0) == DDI_FAILURE) { 203 tzmon_free_zone_list(); 204 mutex_destroy(&zone_list_lock); 205 cv_destroy(&zone_list_condvar); 206 return (DDI_FAILURE); 207 } 208 209 tzmon_dip = dip; 210 211 ddi_report_dev(dip); 212 213 return (DDI_SUCCESS); 214 } 215 216 217 /*ARGSUSED*/ 218 static int 219 tzmon_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result) 220 { 221 int error; 222 223 switch (infocmd) { 224 case DDI_INFO_DEVT2DEVINFO: 225 *result = tzmon_dip; 226 if (tzmon_dip == NULL) 227 error = DDI_FAILURE; 228 else 229 error = DDI_SUCCESS; 230 break; 231 case DDI_INFO_DEVT2INSTANCE: 232 *result = 0; 233 error = DDI_SUCCESS; 234 break; 235 default: 236 *result = NULL; 237 error = DDI_FAILURE; 238 } 239 240 return (error); 241 } 242 243 244 static int 245 tzmon_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 246 { 247 thermal_zone_t *tzp = zone_list; 248 249 if (cmd != DDI_DETACH) 250 return (DDI_FAILURE); 251 252 /* free allocated thermal zone name(s) */ 253 while (tzp != NULL) { 254 AcpiOsFree(tzp->zone_name); 255 tzp = tzp->next; 256 } 257 258 /* discard zone list assets */ 259 tzmon_free_zone_list(); 260 261 ddi_remove_minor_node(dip, NULL); 262 tzmon_dip = NULL; 263 264 mutex_destroy(&zone_list_lock); 265 cv_destroy(&zone_list_condvar); 266 267 return (DDI_SUCCESS); 268 } 269 270 271 /* 272 * tzmon_notify_zone 273 * Thermal zone notification handler. 274 */ 275 static void 276 tzmon_notify_zone(ACPI_HANDLE obj, UINT32 val, void *ctx) 277 { 278 thermal_zone_t *tzp = (thermal_zone_t *)ctx; 279 280 switch (val) { 281 case 0x80: /* Thermal Zone status changed */ 282 tzmon_eval_zone(tzp); 283 break; 284 case 0x81: /* Thermal Zone trip points changed */ 285 tzmon_enumerate_zone(obj, tzp, TZMON_ENUM_TRIP_POINTS); 286 break; 287 case 0x82: /* Device Lists changed */ 288 tzmon_enumerate_zone(obj, tzp, TZMON_ENUM_DEV_LISTS); 289 break; 290 case 0x83: /* Thermal Relationship Table changed */ 291 /* not handling _TRT objects, so not handling this event */ 292 DTRACE_PROBE1(trt__change, char *, (char *)tzp->zone_name); 293 break; 294 default: 295 break; 296 } 297 } 298 299 300 /* 301 * tzmon_eval_int 302 * Evaluate the object/method as an integer. 303 */ 304 static void 305 tzmon_eval_int(ACPI_HANDLE obj, char *method, int *rv) 306 { 307 308 if (acpica_eval_int(obj, method, rv) != AE_OK) 309 *rv = -1; 310 } 311 312 313 /* 314 * tzmon_alloc_zone 315 * Allocate memory for the zone structure and initialize it lock mutex. 316 */ 317 static thermal_zone_t * 318 tzmon_alloc_zone() 319 { 320 thermal_zone_t *tzp; 321 322 tzp = kmem_zalloc(sizeof (thermal_zone_t), KM_SLEEP); 323 mutex_init(&tzp->lock, NULL, MUTEX_DRIVER, NULL); 324 325 return (tzp); 326 } 327 328 329 /* 330 * tzmon_free_zone_list 331 * Free the zone list, either because attach failed or detach initiated. 332 */ 333 static void 334 tzmon_free_zone_list() 335 { 336 thermal_zone_t *tzp = zone_list; 337 338 while (tzp != NULL) { 339 thermal_zone_t *next; 340 341 mutex_enter(&tzp->lock); 342 343 /* 344 * Remove the notify handler for the zone. Not much to 345 * do if this fails (since we are on our way out), so 346 * just ignore failure. 347 */ 348 (void) AcpiRemoveNotifyHandler(tzp->obj, ACPI_DEVICE_NOTIFY, 349 tzmon_notify_zone); 350 351 /* Shut down monitor thread, if running */ 352 if (tzp->taskq != NULL) { 353 tzp->polling_period = 0; 354 cv_broadcast(&zone_list_condvar); 355 356 /* Drop mutex to allow the thread to run */ 357 mutex_exit(&tzp->lock); 358 ddi_taskq_destroy(tzp->taskq); 359 mutex_enter(&tzp->lock); 360 } 361 362 tzmon_discard_buffers(tzp); 363 mutex_exit(&tzp->lock); 364 mutex_destroy(&tzp->lock); 365 366 next = tzp->next; 367 kmem_free(tzp, sizeof (thermal_zone_t)); 368 tzp = next; 369 } 370 } 371 372 373 static void 374 tzmon_discard_buffers(thermal_zone_t *tzp) 375 { 376 int level; 377 378 for (level = 0; level < TZ_NUM_LEVELS; level++) { 379 if (tzp->al[level].Pointer != NULL) 380 AcpiOsFree(tzp->al[level].Pointer); 381 } 382 383 if (tzp->psl.Pointer != NULL) 384 AcpiOsFree(tzp->psl.Pointer); 385 } 386 387 388 /* 389 * tzmon_enumerate_zone 390 * Enumerates the contents of a thermal zone and updates passed-in 391 * thermal_zone or creates a new one if tzp is NULL. Newly-created 392 * zones are linked into the global zone_list. 393 */ 394 static void 395 tzmon_enumerate_zone(ACPI_HANDLE obj, thermal_zone_t *tzp, int enum_flag) 396 { 397 ACPI_STATUS status; 398 ACPI_BUFFER zone_name; 399 int level; 400 int instance; 401 char abuf[5]; 402 403 /* 404 * Newly-created zones and existing zones both require 405 * some individual attention. 406 */ 407 if (tzp == NULL) { 408 /* New zone required */ 409 tzp = tzmon_alloc_zone(); 410 mutex_enter(&zone_list_lock); 411 tzp->next = zone_list; 412 zone_list = tzp; 413 414 /* 415 * It is exceedingly unlikely that instance will exceed 99. 416 * However, if it does, this will cause problems when 417 * creating the taskq for this thermal zone. 418 */ 419 instance = zone_count; 420 zone_count++; 421 mutex_exit(&zone_list_lock); 422 mutex_enter(&tzp->lock); 423 tzp->obj = obj; 424 425 /* 426 * Set to a low level. Will get set to the actual 427 * current power level when the thread monitor polls 428 * the current temperature. 429 */ 430 tzp->current_level = 0; 431 432 /* Get the zone name in case we need to display it later */ 433 zone_name.Length = ACPI_ALLOCATE_BUFFER; 434 zone_name.Pointer = NULL; 435 436 status = AcpiGetName(obj, ACPI_FULL_PATHNAME, &zone_name); 437 ASSERT(status == AE_OK); 438 439 tzp->zone_name = zone_name.Pointer; 440 441 status = AcpiInstallNotifyHandler(obj, ACPI_DEVICE_NOTIFY, 442 tzmon_notify_zone, (void *)tzp); 443 ASSERT(status == AE_OK); 444 } else { 445 /* Existing zone - toss out allocated items */ 446 mutex_enter(&tzp->lock); 447 ASSERT(tzp->obj == obj); 448 449 if (enum_flag & TZMON_ENUM_DEV_LISTS) 450 tzmon_discard_buffers(tzp); 451 } 452 453 if (enum_flag & TZMON_ENUM_TRIP_POINTS) { 454 for (level = 0; level < TZ_NUM_LEVELS; level++) { 455 (void) snprintf(abuf, 5, "_AC%d", level); 456 tzmon_eval_int(obj, abuf, &tzp->ac[level]); 457 458 } 459 460 tzmon_eval_int(obj, "_CRT", &tzp->crt); 461 tzmon_eval_int(obj, "_HOT", &tzp->hot); 462 tzmon_eval_int(obj, "_PSV", &tzp->psv); 463 } 464 465 if (enum_flag & TZMON_ENUM_DEV_LISTS) { 466 for (level = 0; level < TZ_NUM_LEVELS; level++) { 467 if (tzp->ac[level] == -1) { 468 tzp->al[level].Length = 0; 469 tzp->al[level].Pointer = NULL; 470 } else { 471 (void) snprintf(abuf, 5, "_AL%d", level); 472 tzp->al[level].Length = ACPI_ALLOCATE_BUFFER; 473 tzp->al[level].Pointer = NULL; 474 if (AcpiEvaluateObjectTyped(obj, abuf, NULL, 475 &tzp->al[level], ACPI_TYPE_PACKAGE) != 476 AE_OK) { 477 DTRACE_PROBE2(alx__missing, int, level, 478 char *, (char *)tzp->zone_name); 479 480 tzp->al[level].Length = 0; 481 tzp->al[level].Pointer = NULL; 482 } 483 } 484 } 485 486 tzp->psl.Length = ACPI_ALLOCATE_BUFFER; 487 tzp->psl.Pointer = NULL; 488 (void) AcpiEvaluateObjectTyped(obj, "_PSL", NULL, &tzp->psl, 489 ACPI_TYPE_PACKAGE); 490 } 491 492 tzmon_eval_int(obj, "_TC1", &tzp->tc1); 493 tzmon_eval_int(obj, "_TC2", &tzp->tc2); 494 tzmon_eval_int(obj, "_TSP", &tzp->tsp); 495 tzmon_eval_int(obj, "_TZP", &tzp->tzp); 496 497 if (tzp->tzp == 0) { 498 tzp->polling_period = 0; 499 } else { 500 if (tzp->tzp < 0) 501 tzp->polling_period = TZ_DEFAULT_PERIOD; 502 else 503 tzp->polling_period = tzp->tzp/10; 504 505 /* start monitor thread if needed */ 506 if (tzp->taskq == NULL) { 507 char taskq_name[TZ_TASKQ_NAME_LEN]; 508 509 (void) snprintf(taskq_name, TZ_TASKQ_NAME_LEN, 510 "AcpiThermalMonitor%02d", instance); 511 tzp->taskq = ddi_taskq_create(tzmon_dip, 512 taskq_name, 1, TASKQ_DEFAULTPRI, 0); 513 if (tzp->taskq == NULL) { 514 tzp->polling_period = 0; 515 cmn_err(CE_WARN, "tzmon: could not create " 516 "monitor thread for thermal zone %s - " 517 "monitor by notify only", 518 (char *)tzp->zone_name); 519 } else { 520 (void) ddi_taskq_dispatch(tzp->taskq, 521 tzmon_monitor, tzp, DDI_SLEEP); 522 } 523 } 524 } 525 526 mutex_exit(&tzp->lock); 527 } 528 529 530 /* 531 * tzmon_zone_callback 532 * Enumerate the thermal zone if it has a _TMP (current thermal zone 533 * operating temperature) method. 534 */ 535 /*ARGSUSED*/ 536 static ACPI_STATUS 537 tzmon_zone_callback(ACPI_HANDLE obj, UINT32 nest, void *ctx, void **rv) 538 { 539 ACPI_HANDLE tmpobj; 540 541 /* 542 * We get both ThermalZone() and Scope(\_TZ) objects here; 543 * look for _TMP (without which a zone is invalid) to pick 544 * between them (and ignore invalid zones) 545 */ 546 if (AcpiGetHandle(obj, "_TMP", &tmpobj) == AE_OK) { 547 tzmon_enumerate_zone(obj, NULL, TZMON_ENUM_ALL); 548 } 549 550 return (AE_OK); 551 } 552 553 554 /* 555 * tzmon_find_zones 556 * Find all of the thermal zones by calling a ACPICA function that 557 * walks the ACPI namespace and invokes a callback for each thermal 558 * object found. 559 */ 560 static void 561 tzmon_find_zones() 562 { 563 ACPI_STATUS status; 564 int retval; 565 566 status = AcpiWalkNamespace(ACPI_TYPE_THERMAL, ACPI_ROOT_OBJECT, 567 8, tzmon_zone_callback, NULL, NULL, (void **)&retval); 568 569 ASSERT(status == AE_OK); 570 } 571 572 573 /* 574 * tzmon_monitor 575 * Run as a separate thread, this wakes according to polling period and 576 * checks particular objects in the thermal zone. One instance per 577 * thermal zone. 578 */ 579 static void 580 tzmon_monitor(void *ctx) 581 { 582 thermal_zone_t *tzp = (thermal_zone_t *)ctx; 583 clock_t ticks; 584 585 do { 586 /* Check out the zone */ 587 tzmon_eval_zone(tzp); 588 589 /* Go back to sleep */ 590 mutex_enter(&tzp->lock); 591 ticks = drv_usectohz(tzp->polling_period * 1000000); 592 if (ticks > 0) 593 (void) cv_reltimedwait(&zone_list_condvar, 594 &tzp->lock, ticks, TR_CLOCK_TICK); 595 mutex_exit(&tzp->lock); 596 } while (ticks > 0); 597 } 598 599 600 /* 601 * tzmon_set_power_device 602 */ 603 static void 604 tzmon_set_power_device(ACPI_HANDLE dev, int on_off, char *tz_name) 605 { 606 ACPI_BUFFER rb; 607 ACPI_OBJECT *pr0; 608 ACPI_STATUS status; 609 int i; 610 611 rb.Length = ACPI_ALLOCATE_BUFFER; 612 rb.Pointer = NULL; 613 status = AcpiEvaluateObjectTyped(dev, "_PR0", NULL, &rb, 614 ACPI_TYPE_PACKAGE); 615 if (status != AE_OK) { 616 DTRACE_PROBE2(alx__error, int, 2, char *, tz_name); 617 return; 618 } 619 620 pr0 = ((ACPI_OBJECT *)rb.Pointer); 621 for (i = 0; i < pr0->Package.Count; i++) { 622 status = AcpiEvaluateObject( 623 pr0->Package.Elements[i].Reference.Handle, 624 on_off ? "_ON" : "_OFF", NULL, NULL); 625 if (status != AE_OK) { 626 DTRACE_PROBE2(alx__error, int, 4, char *, tz_name); 627 } 628 } 629 630 AcpiOsFree(rb.Pointer); 631 } 632 633 634 /* 635 * tzmon_set_power 636 * Turn on or turn off all devices in the supplied list. 637 */ 638 static void 639 tzmon_set_power(ACPI_BUFFER devlist, int on_off, char *tz_name) 640 { 641 ACPI_OBJECT *devs; 642 int i; 643 644 devs = ((ACPI_OBJECT *)devlist.Pointer); 645 if (devs->Type != ACPI_TYPE_PACKAGE) { 646 DTRACE_PROBE2(alx__error, int, 1, char *, tz_name); 647 return; 648 } 649 650 for (i = 0; i < devs->Package.Count; i++) 651 tzmon_set_power_device( 652 devs->Package.Elements[i].Reference.Handle, on_off, 653 tz_name); 654 } 655 656 657 /* 658 * tzmon_eval_zone 659 * Evaluate the current conditions within the thermal zone. 660 */ 661 static void 662 tzmon_eval_zone(thermal_zone_t *tzp) 663 { 664 int tmp, new_level, level; 665 666 mutex_enter(&tzp->lock); 667 668 /* get the current temperature from ACPI */ 669 tzmon_eval_int(tzp->obj, "_TMP", &tmp); 670 DTRACE_PROBE4(tz__temp, int, tmp, int, tzp->crt, int, tzp->hot, 671 char *, (char *)tzp->zone_name); 672 673 /* _HOT handling */ 674 if (tzp->hot > 0 && tmp >= tzp->hot) { 675 cmn_err(CE_WARN, 676 "tzmon: Thermal zone (%s) is too hot (%d C); " 677 "initiating shutdown\n", 678 (char *)tzp->zone_name, K_TO_C(tmp)); 679 680 tzmon_do_shutdown(); 681 } 682 683 /* _CRT handling */ 684 if (tzp->crt > 0 && tmp >= tzp->crt) { 685 cmn_err(CE_WARN, 686 "tzmon: Thermal zone (%s) is critically hot (%d C); " 687 "initiating rapid shutdown\n", 688 (char *)tzp->zone_name, K_TO_C(tmp)); 689 690 /* shut down (fairly) immediately */ 691 mdboot(A_REBOOT, AD_HALT, NULL, B_FALSE); 692 } 693 694 /* 695 * use the temperature to determine whether the thermal zone 696 * is at a new active cooling threshold level 697 */ 698 for (level = 0, new_level = -1; level < TZ_NUM_LEVELS; level++) { 699 if (tzp->ac[level] >= 0 && (tmp >= tzp->ac[level])) { 700 new_level = level; 701 break; 702 } 703 } 704 705 /* 706 * if the active cooling threshold has changed, turn off the 707 * devices associated with the old one and turn on the new one 708 */ 709 if (tzp->current_level != new_level) { 710 if ((tzp->current_level >= 0) && 711 (tzp->al[tzp->current_level].Length != 0)) 712 tzmon_set_power(tzp->al[tzp->current_level], 0, 713 (char *)tzp->zone_name); 714 715 if ((new_level >= 0) && 716 (tzp->al[new_level].Length != 0)) 717 tzmon_set_power(tzp->al[new_level], 1, 718 (char *)tzp->zone_name); 719 720 tzp->current_level = new_level; 721 } 722 723 mutex_exit(&tzp->lock); 724 } 725 726 727 /* 728 * tzmon_do_shutdown 729 * Initiates shutdown by sending a SIGPWR signal to init. 730 */ 731 static void 732 tzmon_do_shutdown(void) 733 { 734 proc_t *initpp; 735 736 mutex_enter(&pidlock); 737 initpp = prfind(P_INITPID); 738 mutex_exit(&pidlock); 739 740 /* if we can't find init, just halt */ 741 if (initpp == NULL) { 742 mdboot(A_REBOOT, AD_HALT, NULL, B_FALSE); 743 } 744 745 /* graceful shutdown with inittab and all getting involved */ 746 psignal(initpp, SIGPWR); 747 } 748