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 }