?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dmake: do not set MAKEFLAGS=k
[unleashed/tickless.git] / usr / src / cmd / picl / plugins / sun4u / psvc / psvcpolicy / psvcpolicy.c
blob2dd40aea7f30fd7e8bc60518368fbeb8efc59099
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 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 *
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 /*
30 * This file contains routines to support the Platform Services Plugin
31 * These routines implement the platform independent environment monitoring
32 * and control policies that may be invoked by a daemon thread within
33 * the plugin
34 */
35
36 #include <syslog.h>
37 #include <unistd.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <libintl.h>
41 #include <errno.h>
42 #include <fcntl.h>
43 #include <strings.h>
44 #include <libintl.h>
45 #include <sys/types.h>
46 #include <string.h>
47 #include <limits.h>
48 #include <picl.h>
49 #include <picltree.h>
50 #include <sys/types.h>
51 #include <string.h>
52 #include <psvc_objects.h>
53
54 #define LOWTEMP_CRITICAL_MSG \
55 gettext("CRITICAL : LOW TEMPERATURE DETECTED %d, %s")
56 #define LOWTEMP_WARNING_MSG \
57 gettext("WARNING : LOW TEMPERATURE DETECTED %d, %s")
58 #define HIGHTEMP_CRITICAL_MSG \
59 gettext("CRITICAL : HIGH TEMPERATURE DETECTED %d, %s")
60 #define HIGHTEMP_WARNING_MSG \
61 gettext("WARNING : HIGH TEMPERATURE DETECTED %d, %s")
62 #define DEVICE_INSERTED_MSG gettext("Device %s inserted")
63 #define DEVICE_REMOVED_MSG gettext("Device %s removed")
64 #define DEVICE_FAILURE_MSG \
65 gettext("CRITICAL: Device %s failure detected by sensor %s\n")
66 #define DEVICE_OK_MSG gettext("Device %s OK")
67 #define SECONDARY_FAN_FAIL_MSG gettext("Secondary fan failure, device %s")
68 #define KEYSWITCH_POS_READ_FAILED_MSG \
69 gettext("Keyswitch position could not be determined")
70 #define KEYSWITCH_POS_CHANGED_MSG gettext("Keyswitch position changed to %s")
71 #define GET_PRESENCE_FAILED_MSG \
72 gettext("Failed to get presence attribute, id = %s, errno = %d\n")
73 #define GET_SENSOR_FAILED_MSG \
74 gettext("Failed to get sensor value, id = %s, errno = %d\n")
75 #define PS_OVER_CURRENT_MSG \
76 gettext("WARNING: Power Supply overcurrent detected for %s\n")
77 #define SET_LED_FAILED_MSG \
78 gettext("Failed to set LED state, id = %s, errno = %d\n")
79 #define SET_FANSPEED_FAILED_MSG \
80 gettext("Failed to set fan speed, id = %s, errno = %d\n")
81 #define FAN_MISSING_MSG \
82 gettext("WARNING: Fan missing, id = %s\n")
83 #define TEMP_SENSOR_FAULT \
84 gettext("WARNING: Temperature Sensor %s returning faulty temp\n")
85 #define TEMP_OFFSET 17
86
87 static char *shutdown_string = "shutdown -y -g 60 -i 5 \"OVERTEMP condition\"";
88
89 static int cpus_online = 0;
90
91 typedef struct seg_desc {
92 int32_t segdesc;
93 int16_t segoffset;
94 int16_t seglength;
95 } seg_desc_t;
96
97 static int32_t threshold_names[] = {
98 PSVC_HW_LO_SHUT_ATTR,
99 PSVC_LO_SHUT_ATTR,
100 PSVC_LO_WARN_ATTR,
101 PSVC_NOT_USED, /* LOW MODE which is not used */
102 PSVC_OPTIMAL_TEMP_ATTR,
103 PSVC_HI_WARN_ATTR,
104 PSVC_HI_SHUT_ATTR,
105 PSVC_HW_HI_SHUT_ATTR
106 };
107
108 /*
109 * The I2C bus is noisy, and the state may be incorrectly reported as
110 * having changed. When the state changes, we attempt to confirm by
111 * retrying. If any retries indicate that the state has not changed, we
112 * assume the state change(s) were incorrect and the state has not changed.
113 * The following variables are used to store the tuneable values read in
114 * from the optional i2cparam.conf file for this shared object library.
115 */
116 static int n_read_temp = PSVC_THRESHOLD_COUNTER;
117 static int n_retry_keyswitch = PSVC_NUM_OF_RETRIES;
118 static int retry_sleep_keyswitch = 1;
119 static int n_retry_hotplug = PSVC_NUM_OF_RETRIES;
120 static int retry_sleep_hotplug = 1;
121 static int n_retry_fan_hotplug = PSVC_NUM_OF_RETRIES;
122 static int retry_sleep_fan_hotplug = 1;
123 static int n_retry_fan_present = PSVC_NUM_OF_RETRIES;
124 static int retry_sleep_fan_present = 1;
125
126 typedef struct {
127 int *pvar;
128 char *texttag;
129 } i2c_noise_param_t;
130
131 static i2c_noise_param_t i2cparams_sun4u[] = {
132 &n_read_temp, "n_read_temp",
133 &n_retry_keyswitch, "n_retry_keyswitch",
134 &retry_sleep_keyswitch, "retry_sleep_keyswitch",
135 &n_retry_hotplug, "n_retry_hotplug",
136 &retry_sleep_hotplug, "retry_sleep_hotplug",
137 &n_retry_fan_hotplug, "n_retry_fan_hotplug",
138 &retry_sleep_fan_hotplug, "retry_sleep_fan_hotplug",
139 &n_retry_fan_present, "n_retry_fan_present",
140 &retry_sleep_fan_present, "retry_sleep_fan_present",
141 NULL, NULL
142 };
143
144 #pragma init(i2cparams_sun4u_load)
145
146 static void
147 i2cparams_sun4u_debug(i2c_noise_param_t *pi2cparams, int usingDefaults)
148 {
149 char s[128];
150 i2c_noise_param_t *p;
151
152 if (!usingDefaults) {
153 (void) strncpy(s,
154 "# Values from /usr/platform/sun4u/lib/i2cparam.conf\n",
155 sizeof (s) - 1);
156 syslog(LOG_WARNING, "%s", s);
157 } else {
158 /* no file - we're using the defaults */
159 (void) strncpy(s,
160 "# No /usr/platform/sun4u/lib/i2cparam.conf file, using defaults\n",
161 sizeof (s) - 1);
162 }
163 (void) fputs(s, stdout);
164 p = pi2cparams;
165 while (p->pvar != NULL) {
166 (void) snprintf(s, sizeof (s), "%s %d\n", p->texttag,
167 *(p->pvar));
168 if (!usingDefaults)
169 syslog(LOG_WARNING, "%s", s);
170 (void) fputs(s, stdout);
171 p++;
172 }
173 }
174
175 static void
176 i2cparams_sun4u_load(void)
177 {
178 FILE *fp;
179 char *filename = "/usr/platform/sun4u/lib/i2cparam.conf";
180 char s[128];
181 char var[128];
182 int val;
183 i2c_noise_param_t *p;
184
185 /* read thru the i2cparam.conf file and set variables */
186 if ((fp = fopen(filename, "r")) != NULL) {
187 while (fgets(s, sizeof (s), fp) != NULL) {
188 if (s[0] == '#') /* skip comment lines */
189 continue;
190 /* try to find a string match and get the value */
191 if (sscanf(s, "%127s %d", var, &val) != 2)
192 continue;
193 if (val < 1)
194 val = 1; /* clamp min value */
195 p = &(i2cparams_sun4u[0]);
196 while (p->pvar != NULL) {
197 if (strncmp(p->texttag, var, sizeof (var)) ==
198 0) {
199 *(p->pvar) = val;
200 break;
201 }
202 p++;
203 }
204 }
205 (void) fclose(fp);
206 }
207 /* output the values of the parameters */
208 i2cparams_sun4u_debug(&(i2cparams_sun4u[0]), ((fp == NULL)? 1 : 0));
209 }
210
211
212 int32_t
213 psvc_update_thresholds_0(psvc_opaque_t hdlp, char *id)
214 {
215 int32_t status = PSVC_SUCCESS;
216 fru_info_t fru_data;
217 char *fru, seg_name[2];
218 int8_t seg_count, temp_array[8];
219 int32_t match_count, i, j, seg_desc_start = 0x1806, temp_address;
220 int32_t seg_found, temp;
221 boolean_t present;
222 seg_desc_t segment;
223
224 status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &present);
225 if ((status != PSVC_SUCCESS) || (present != PSVC_PRESENT))
226 return (status);
227
228 status = psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &match_count,
229 PSVC_FRU);
230 if (status == PSVC_FAILURE)
231 return (status);
232
233 for (i = 0; i < match_count; i++) {
234 seg_found = 0;
235 status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
236 &fru, PSVC_FRU, i);
237 if (status != PSVC_SUCCESS)
238 return (status);
239
240 fru_data.buf_start = 0x1805;
241 fru_data.buf = (char *)&seg_count;
242 fru_data.read_size = 1;
243
244 status = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR,
245 &fru_data);
246 if (status != PSVC_SUCCESS) {
247 return (status);
248 }
249 for (j = 0; (j < seg_count) && (!seg_found); j++) {
250 fru_data.buf_start = seg_desc_start;
251 fru_data.buf = seg_name;
252 fru_data.read_size = 2;
253
254 status = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR,
255 &fru_data);
256
257 seg_desc_start = seg_desc_start + 2;
258 fru_data.buf_start = seg_desc_start;
259 fru_data.buf = (char *)&segment;
260 fru_data.read_size = sizeof (seg_desc_t);
261
262 status = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR,
263 &fru_data);
264 if (status != PSVC_SUCCESS) {
265 syslog(LOG_ERR,
266 "Failed psvc_get_attr for FRU info\n");
267 return (status);
268 }
269 seg_desc_start = seg_desc_start + sizeof (seg_desc_t);
270 if (memcmp(seg_name, "SC", 2) == 0)
271 seg_found = 1;
272 }
273 if (seg_found) {
274 temp_address = segment.segoffset + TEMP_OFFSET;
275 fru_data.buf_start = temp_address;
276 fru_data.buf = (char *)&temp_array;
277 fru_data.read_size = sizeof (temp_array);
278 status = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR,
279 &fru_data);
280 if (status != PSVC_SUCCESS) {
281 syslog(LOG_ERR,
282 "Failed psvc_get_attr for FRU info\n");
283 return (status);
284 } else {
285 for (j = 0; j < sizeof (temp_array); j++) {
286 if (threshold_names[j] == PSVC_NOT_USED)
287 continue;
288 temp = temp_array[j];
289 status = psvc_set_attr(hdlp, id,
290 threshold_names[j], &temp);
291 if (status != PSVC_SUCCESS) {
292 return (status);
293 }
294 }
295 }
296 } else {
297 syslog(LOG_ERR, "No FRU Information for %s"
298 " using default temperatures\n", id);
299 }
300 }
301 return (status);
302 }
303
304 #define MAX_TEMP_SENSORS 256
305
306 static int32_t
307 check_temp(psvc_opaque_t hdlp, char *id, int32_t silent)
308 {
309 int32_t lo_warn, hi_warn, lo_shut, hi_shut;
310 uint64_t features;
311 int32_t temp;
312 char previous_state[32];
313 char led_state[32];
314 char state[32];
315 char fault[32];
316 char label[32];
317 boolean_t pr;
318 int32_t status = PSVC_SUCCESS;
319 int8_t fail = 0;
320 static int threshold_low_shut[MAX_TEMP_SENSORS] = {0};
321 static int threshold_high_shut[MAX_TEMP_SENSORS] = {0};
322 static int threshold_low_warn[MAX_TEMP_SENSORS] = {0};
323 static int threshold_high_warn[MAX_TEMP_SENSORS] = {0};
324 int32_t instance;
325
326 status = psvc_get_attr(hdlp, id, PSVC_INSTANCE_ATTR, &instance);
327 if (status != PSVC_SUCCESS)
328 return (status);
329
330 status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &pr);
331 if ((status != PSVC_SUCCESS) || (pr != PSVC_PRESENT)) {
332 return (status);
333 }
334
335 status = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR, state);
336 if (status == PSVC_FAILURE)
337 return (status);
338
339 if ((strcmp(state, PSVC_HOTPLUGGED) == 0)) {
340 return (PSVC_SUCCESS);
341 }
342
343 status = psvc_get_attr(hdlp, id, PSVC_FEATURES_ATTR, &features);
344 if (status != PSVC_SUCCESS)
345 return (status);
346
347 status = psvc_get_attr(hdlp, id, PSVC_LO_WARN_ATTR, &lo_warn);
348 if (status != PSVC_SUCCESS)
349 return (status);
350
351 status = psvc_get_attr(hdlp, id, PSVC_LO_SHUT_ATTR, &lo_shut);
352 if (status != PSVC_SUCCESS)
353 return (status);
354
355 status = psvc_get_attr(hdlp, id, PSVC_HI_WARN_ATTR, &hi_warn);
356 if (status != PSVC_SUCCESS)
357 return (status);
358
359 status = psvc_get_attr(hdlp, id, PSVC_HI_SHUT_ATTR, &hi_shut);
360 if (status != PSVC_SUCCESS)
361 return (status);
362
363 status = psvc_get_attr(hdlp, id, PSVC_SENSOR_VALUE_ATTR, &temp);
364 if (status != PSVC_SUCCESS) {
365 return (status);
366 }
367
368 /*
369 * The following code is to check to see if the temp sensor is
370 * returning a faulty reading due to it either being bad or the
371 * CPU being powered off for some reason. Is so we will alert the user
372 * and just label the sensor bad but not the WHOLE CPU module.
373 */
374 if ((temp == 127) && (strcmp(state, PSVC_ERROR) != 0)) {
375 status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, PSVC_ERROR);
376 if (status != PSVC_SUCCESS)
377 return (status);
378 status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR,
379 PSVC_GEN_FAULT);
380 if (status != PSVC_SUCCESS)
381 return (status);
382 syslog(LOG_ERR, TEMP_SENSOR_FAULT, id);
383 return (status);
384 }
385
386 status = psvc_get_attr(hdlp, id, PSVC_LABEL_ATTR, label);
387 if (status != PSVC_SUCCESS)
388 return (status);
389
390 /*
391 * if any of the four temperature states (lo_shut, lo_warn,
392 * hi_shut, hi_warn) is detected we will not take an action
393 * until the number of similar back-to-back readings equals
394 * 'n_read_temp' (default is PSVC_THRESHOLD_COUNTER).
395 */
396 if ((features & PSVC_LOW_SHUT) && temp < lo_shut) {
397 /*
398 * once we are in one state, clear all the
399 * counters for the other three states since
400 * back-to-back readings of these other three
401 * states could not happen anymore.
402 */
403 threshold_low_warn[instance] = 0;
404 threshold_high_shut[instance] = 0;
405 threshold_high_warn[instance] = 0;
406 threshold_low_shut[instance]++;
407 if (threshold_low_shut[instance] == n_read_temp) {
408 threshold_low_shut[instance] = 0;
409 fail = 1;
410 strcpy(state, PSVC_ERROR);
411 strcpy(fault, PSVC_TEMP_LO_SHUT);
412 strcpy(led_state, PSVC_LED_ON);
413 if (silent == 0)
414 syslog(LOG_ERR, LOWTEMP_CRITICAL_MSG,
415 temp, label);
416 } else { /* Threshold for showing error not reached */
417 return (PSVC_SUCCESS);
418 }
419 } else if ((features & PSVC_LOW_WARN) && temp < lo_warn) {
420 threshold_low_shut[instance] = 0;
421 threshold_high_shut[instance] = 0;
422 threshold_high_warn[instance] = 0;
423 threshold_low_warn[instance]++;
424 if (threshold_low_warn[instance] == n_read_temp) {
425 threshold_low_warn[instance] = 0;
426 fail = 1;
427 strcpy(state, PSVC_ERROR);
428 strcpy(fault, PSVC_TEMP_LO_WARN);
429 strcpy(led_state, PSVC_LED_ON);
430 if (silent == 0)
431 syslog(LOG_ERR, LOWTEMP_WARNING_MSG,
432 temp, label);
433 } else { /* Threshold for showing error not reached */
434 return (PSVC_SUCCESS);
435 }
436 } else if ((features & PSVC_HIGH_SHUT) && temp > hi_shut) {
437 threshold_low_warn[instance] = 0;
438 threshold_low_shut[instance] = 0;
439 threshold_high_warn[instance] = 0;
440 threshold_high_shut[instance]++;
441 if (threshold_high_shut[instance] == n_read_temp) {
442 threshold_high_shut[instance] = 0;
443 fail = 1;
444 strcpy(state, PSVC_ERROR);
445 strcpy(fault, PSVC_TEMP_HI_SHUT);
446 strcpy(led_state, PSVC_LED_ON);
447 if (silent == 0)
448 syslog(LOG_ERR, HIGHTEMP_CRITICAL_MSG,
449 temp, label);
450 } else { /* Threshold for showing error not reached */
451 return (PSVC_SUCCESS);
452 }
453 } else if ((features & PSVC_HIGH_WARN) && temp > hi_warn) {
454 threshold_low_warn[instance] = 0;
455 threshold_low_shut[instance] = 0;
456 threshold_high_shut[instance] = 0;
457 threshold_high_warn[instance]++;
458 if (threshold_high_warn[instance] == n_read_temp) {
459 threshold_high_warn[instance] = 0;
460 fail = 1;
461 strcpy(state, PSVC_ERROR);
462 strcpy(fault, PSVC_TEMP_HI_WARN);
463 strcpy(led_state, PSVC_LED_ON);
464 if (silent == 0)
465 syslog(LOG_ERR, HIGHTEMP_WARNING_MSG,
466 temp, label);
467 } else { /* Threshold for showing error not reached */
468 return (PSVC_SUCCESS);
469 }
470 }
471
472 /*
473 * If we reached this point then that means that we are either
474 * okay, or we have showed error n_read_temp times.
475 */
476 if (fail != 1) {
477 /* within limits */
478 strcpy(state, PSVC_OK);
479 strcpy(fault, PSVC_NO_FAULT);
480 strcpy(led_state, PSVC_LED_OFF);
481 }
482
483 status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, state);
484 if (status != PSVC_SUCCESS)
485 return (status);
486 status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR, fault);
487 if (status != PSVC_SUCCESS)
488 return (status);
489 status = psvc_get_attr(hdlp, id, PSVC_PREV_STATE_ATTR,
490 previous_state);
491 if (status != PSVC_SUCCESS)
492 return (status);
493
494 if (strcmp(previous_state, state) != 0) {
495 char *led_id;
496 int32_t led_count;
497 int32_t i;
498
499 /* change state of fault LEDs */
500 psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &led_count,
501 PSVC_TS_OVERTEMP_LED);
502 for (i = 0; i < led_count; ++i) {
503 status = psvc_get_attr(hdlp, id,
504 PSVC_ASSOC_ID_ATTR, &led_id,
505 PSVC_TS_OVERTEMP_LED, i);
506 if (status == PSVC_FAILURE)
507 return (status);
508 status = psvc_set_attr(hdlp, led_id,
509 PSVC_LED_STATE_ATTR, led_state);
510 if (status == PSVC_FAILURE)
511 return (status);
512 }
513 }
514
515 return (PSVC_SUCCESS);
516 }
517
518 int32_t
519 psvc_check_temperature_policy_0(psvc_opaque_t hdlp, char *id)
520 {
521 return (check_temp(hdlp, id, 0));
522 }
523
524 int32_t
525 psvc_check_temperature_silent_policy_0(psvc_opaque_t hdlp, char *id)
526 {
527 return (check_temp(hdlp, id, 1));
528 }
529
530 int32_t
531 psvc_fan_enable_disable_policy_0(psvc_opaque_t hdlp, char *id)
532 {
533 char state[32], previous_state[32];
534 char *backup_fan;
535 int32_t status = PSVC_SUCCESS;
536 uint64_t features;
537 char label[32];
538 boolean_t presence;
539 boolean_t enable;
540 int retry;
541
542 status = psvc_get_attr(hdlp, id, PSVC_FEATURES_ATTR, &features);
543 if (status != PSVC_SUCCESS)
544 return (status);
545
546 retry = 0;
547 do {
548 if (retry)
549 (void) sleep(retry_sleep_fan_present);
550
551 status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &presence);
552 if (status != PSVC_SUCCESS)
553 return (status);
554 retry++;
555 } while ((retry < n_retry_fan_present) && (presence == PSVC_ABSENT));
556
557 if (presence == PSVC_ABSENT) {
558 status = psvc_get_attr(hdlp, id, PSVC_LABEL_ATTR, label);
559 if (status != PSVC_SUCCESS)
560 return (status);
561
562 status = psvc_get_attr(hdlp, id, PSVC_ENABLE_ATTR, &enable);
563 if (status != PSVC_SUCCESS)
564 return (status);
565
566 if (features & PSVC_DEV_PRIMARY) {
567 status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
568 &backup_fan, PSVC_ALTERNATE, 0);
569 if (status != PSVC_SUCCESS)
570 return (status);
571
572 enable = PSVC_DISABLED;
573 status = psvc_set_attr(hdlp, id, PSVC_ENABLE_ATTR,
574 &enable);
575 if (status != PSVC_SUCCESS)
576 return (status);
577
578 enable = PSVC_ENABLED;
579 status = psvc_set_attr(hdlp, backup_fan,
580 PSVC_ENABLE_ATTR, &enable);
581 if (status != PSVC_SUCCESS)
582 return (status);
583 } else {
584 enable = PSVC_DISABLED;
585 status = psvc_set_attr(hdlp, id, PSVC_ENABLE_ATTR,
586 &enable);
587 if (status != PSVC_SUCCESS)
588 return (status);
589 }
590 return (PSVC_SUCCESS);
591 }
592
593 /* device was present */
594 status = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR, state);
595 if (status != PSVC_SUCCESS)
596 return (status);
597
598 status = psvc_get_attr(hdlp, id, PSVC_PREV_STATE_ATTR, previous_state);
599 if (status != PSVC_SUCCESS)
600 return (status);
601
602 if (features & PSVC_DEV_PRIMARY) {
603 status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
604 &backup_fan, PSVC_ALTERNATE, 0);
605 if (status != PSVC_SUCCESS)
606 return (status);
607
608 if (strcmp(state, PSVC_OK) == 0) {
609 enable = PSVC_ENABLED;
610 status = psvc_set_attr(hdlp, id, PSVC_ENABLE_ATTR,
611 &enable);
612 if (status != PSVC_SUCCESS)
613 return (status);
614
615 enable = PSVC_DISABLED;
616 status = psvc_set_attr(hdlp, backup_fan,
617 PSVC_ENABLE_ATTR, &enable);
618 if (status != PSVC_SUCCESS)
619 return (status);
620 }
621 if ((strcmp(state, PSVC_ERROR) == 0) &&
622 (strcmp(previous_state, PSVC_ERROR) != 0)) {
623 enable = PSVC_DISABLED;
624 status = psvc_set_attr(hdlp, id, PSVC_ENABLE_ATTR,
625 &enable);
626 if (status != PSVC_SUCCESS)
627 return (status);
628
629 enable = PSVC_ENABLED;
630 status = psvc_set_attr(hdlp, backup_fan,
631 PSVC_ENABLE_ATTR, &enable);
632 if (status != PSVC_SUCCESS)
633 return (status);
634 }
635 } else {
636 if ((strcmp(state, PSVC_ERROR) == 0) &&
637 (strcmp(previous_state, PSVC_ERROR) != 0)) {
638 status = psvc_get_attr(hdlp, id, PSVC_LABEL_ATTR,
639 label);
640 if (status != PSVC_SUCCESS)
641 return (status);
642 syslog(LOG_ERR, SECONDARY_FAN_FAIL_MSG, label);
643 }
644 }
645 return (status);
646 }
647
648 /*
649 * psvc_switch_fan_onoff_policy_0
650 * Turn a fan on if it is enabled, turn it off if it is disabled.
651 */
652 int32_t
653 psvc_switch_fan_onoff_policy_0(psvc_opaque_t hdlp, char *id)
654 {
655 boolean_t enable;
656 char *switchid;
657 char state[32];
658 int32_t status = PSVC_SUCCESS;
659
660 status = psvc_get_attr(hdlp, id, PSVC_ENABLE_ATTR, &enable);
661 if (status != PSVC_SUCCESS)
662 return (status);
663
664 status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR, &switchid,
665 PSVC_FAN_ONOFF_SENSOR, 0);
666 if (status != PSVC_SUCCESS)
667 return (status);
668
669 if (enable == PSVC_DISABLED) {
670 strcpy(state, PSVC_SWITCH_OFF);
671 } else {
672 strcpy(state, PSVC_SWITCH_ON);
673 }
674
675 status = psvc_set_attr(hdlp, switchid, PSVC_SWITCH_STATE_ATTR, state);
676 return (status);
677 }
678
679 static int32_t
680 check_cpu_temp_fault(psvc_opaque_t hdlp, char *cpu, int32_t cpu_count)
681 {
682 char *sensorid;
683 int32_t sensor_count;
684 int32_t status = PSVC_SUCCESS;
685 int32_t i;
686 uint64_t features;
687 char fault[32];
688
689 status = psvc_get_attr(hdlp, cpu, PSVC_FEATURES_ATTR, &features);
690 if (status == PSVC_FAILURE)
691 return (status);
692
693 psvc_get_attr(hdlp, cpu, PSVC_ASSOC_MATCHES_ATTR, &sensor_count,
694 PSVC_DEV_TEMP_SENSOR);
695 for (i = 0; i < sensor_count; ++i) {
696 status = psvc_get_attr(hdlp, cpu, PSVC_ASSOC_ID_ATTR,
697 &sensorid, PSVC_DEV_TEMP_SENSOR, i);
698 if (status == PSVC_FAILURE)
699 return (status);
700
701 status = psvc_get_attr(hdlp, sensorid, PSVC_FAULTID_ATTR,
702 fault);
703 if (status == PSVC_FAILURE)
704 return (status);
705
706 if ((strcmp(fault, PSVC_TEMP_HI_SHUT) == 0) ||
707 (strcmp(fault, PSVC_TEMP_LO_SHUT) == 0)) {
708 if (cpu_count == 1 || cpus_online == 1 ||
709 !(features & PSVC_DEV_HOTPLUG)) {
710 system(shutdown_string);
711 } else {
712 /* FIX offline cpu */
713 --cpus_online;
714 }
715 }
716 }
717
718 return (status);
719 }
720
721 int32_t
722 psvc_shutdown_policy_0(psvc_opaque_t hdlp, char *id)
723 {
724 int32_t cpu_count;
725 char *cpuid;
726 int32_t i;
727 boolean_t present;
728 int32_t status = PSVC_SUCCESS;
729
730 if (cpus_online == 0) {
731 /* obviously, zero isn't correct, count present cpu's */
732 psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &cpu_count,
733 PSVC_CPU);
734 for (i = 0; i < cpu_count; ++i) {
735 status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
736 &cpuid, PSVC_CPU, i);
737 if (status == PSVC_FAILURE)
738 return (status);
739
740 status = psvc_get_attr(hdlp, cpuid,
741 PSVC_PRESENCE_ATTR, &present);
742 if (status == PSVC_FAILURE && present == PSVC_PRESENT)
743 return (status);
744 if (present == PSVC_PRESENT)
745 ++cpus_online;
746 }
747 }
748 psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &cpu_count,
749 PSVC_CPU);
750 for (i = 0; i < cpu_count; ++i) {
751 status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR, &cpuid,
752 PSVC_CPU, i);
753 if (status == PSVC_FAILURE)
754 return (status);
755 status = check_cpu_temp_fault(hdlp, cpuid, cpu_count);
756 if (status == PSVC_FAILURE && errno != ENODEV)
757 return (status);
758 }
759
760 return (PSVC_SUCCESS);
761 }
762
763 /*
764 * psvc_keyswitch_position_policy_0
765 * Checks the state of the keyswitch sensors.
766 * If a keyswitch position sensor's state is on, the position
767 * of the key is written to syslog. If none of the sensors
768 * are on (keyswitch is not at one of the detents), a message is sent
769 * to syslog stating that the position is unknown.
770 */
771 int32_t
772 psvc_keyswitch_position_policy_0(psvc_opaque_t hdlp, char *id)
773 {
774 char position[32];
775 int32_t status = PSVC_SUCCESS;
776 static int error_reported = 0;
777 static char local_previous_position[32];
778 static int32_t first_time = 1;
779 int retry;
780
781 if (first_time) {
782 first_time = 0;
783 status = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR,
784 local_previous_position);
785 if (status != PSVC_SUCCESS)
786 return (status);
787 }
788
789 retry = 0;
790 do {
791 if (retry)
792 (void) sleep(retry_sleep_keyswitch);
793
794 status = psvc_get_attr(hdlp, id, PSVC_SWITCH_STATE_ATTR,
795 position);
796 if (status != PSVC_SUCCESS)
797 return (status);
798
799 if (strcmp(position, PSVC_ERROR) == 0) {
800 if ((errno == EINVAL) && (!(error_reported))) {
801 syslog(LOG_ERR,
802 KEYSWITCH_POS_READ_FAILED_MSG);
803 error_reported = 1;
804 return (PSVC_SUCCESS);
805 }
806 }
807 retry++;
808 } while ((retry < n_retry_keyswitch) &&
809 (strcmp(position, local_previous_position) != 0));
810
811 status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, position);
812 if (status != PSVC_SUCCESS)
813 return (status);
814
815 if (strcmp(position, local_previous_position) != 0) {
816 error_reported = 0;
817 strcpy(local_previous_position, position);
818 syslog(LOG_ERR, KEYSWITCH_POS_CHANGED_MSG, position);
819 }
820
821 return (status);
822 }
823
824 int32_t
825 psvc_hotplug_notifier_policy_0(psvc_opaque_t hdlp, char *id)
826 {
827 boolean_t presence, previous_presence;
828 int32_t status = PSVC_SUCCESS;
829 char label[32];
830 int retry;
831
832 status = psvc_get_attr(hdlp, id, PSVC_PREV_PRESENCE_ATTR,
833 &previous_presence);
834 if (status != PSVC_SUCCESS)
835 return (status);
836
837 retry = 0;
838 do {
839 if (retry)
840 (void) sleep(retry_sleep_hotplug);
841 status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &presence);
842 if (status != PSVC_SUCCESS)
843 return (status);
844 retry++;
845 } while ((retry < n_retry_hotplug) &&
846 (presence != previous_presence));
847
848
849 if (presence != previous_presence) {
850 char parent_path[256];
851 picl_nodehdl_t child_node;
852
853 status = psvc_get_attr(hdlp, id, PSVC_LABEL_ATTR, label);
854 if (status != PSVC_SUCCESS)
855 return (status);
856
857 /* return parent path and node for an object */
858 psvcplugin_lookup(id, parent_path, &child_node);
859
860 if (presence == PSVC_PRESENT) {
861 char state[32], fault[32];
862 picl_nodehdl_t parent_node;
863
864 syslog(LOG_ERR, DEVICE_INSERTED_MSG, label);
865 strcpy(state, PSVC_OK);
866 status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR,
867 state);
868 if (status != PSVC_SUCCESS)
869 return (status);
870 strcpy(fault, PSVC_NO_FAULT);
871 status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR,
872 fault);
873 if (status != PSVC_SUCCESS) {
874 return (status);
875 }
876
877 status = ptree_get_node_by_path(parent_path,
878 &parent_node);
879 if (status != 0)
880 return (PSVC_FAILURE);
881 status = ptree_add_node(parent_node, child_node);
882 if (status != 0)
883 return (PSVC_FAILURE);
884 } else {
885 syslog(LOG_ERR, DEVICE_REMOVED_MSG, label);
886
887 ptree_delete_node(child_node);
888
889 }
890 }
891
892 status = psvc_set_attr(hdlp, id, PSVC_PREV_PRESENCE_ATTR, &presence);
893 if (status != PSVC_SUCCESS)
894 return (status);
895
896 return (status);
897 }
898
899 int32_t
900 psvc_fan_hotplug_policy_0(psvc_opaque_t hdlp, char *id)
901 {
902 boolean_t presence, previous_presence;
903 int32_t status = PSVC_SUCCESS;
904 char label[32];
905 int retry;
906
907 status = psvc_get_attr(hdlp, id, PSVC_PREV_PRESENCE_ATTR,
908 &previous_presence);
909 if (status != PSVC_SUCCESS)
910 return (status);
911
912 retry = 0;
913 do {
914 if (retry)
915 (void) sleep(retry_sleep_fan_hotplug);
916
917 status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &presence);
918 if (status != PSVC_SUCCESS)
919 return (status);
920 retry++;
921 } while ((retry < n_retry_fan_hotplug) &&
922 (presence != previous_presence));
923
924
925 if (presence != previous_presence) {
926 char parent_path[256];
927 picl_nodehdl_t child_node;
928
929 status = psvc_get_attr(hdlp, id, PSVC_LABEL_ATTR, label);
930 if (status != PSVC_SUCCESS)
931 return (status);
932
933 /* return parent path and node for an object */
934 psvcplugin_lookup(id, parent_path, &child_node);
935
936 if (presence == PSVC_PRESENT) {
937 char state[32], fault[32];
938 char *slot_id;
939 char *led_id;
940 int32_t i, led_count;
941 char led_state[32];
942 picl_nodehdl_t parent_node;
943
944 syslog(LOG_ERR, DEVICE_INSERTED_MSG, label);
945
946 strcpy(state, PSVC_OK);
947 status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR,
948 state);
949 if (status != PSVC_SUCCESS)
950 return (status);
951 strcpy(fault, PSVC_NO_FAULT);
952 status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR,
953 fault);
954 if (status != PSVC_SUCCESS)
955 return (status);
956
957 /* turn off fault LEDs */
958 psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR,
959 &led_count, PSVC_DEV_FAULT_LED);
960 strcpy(led_state, PSVC_LED_OFF);
961 for (i = 0; i < led_count; ++i) {
962 status = psvc_get_attr(hdlp, id,
963 PSVC_ASSOC_ID_ATTR, &led_id,
964 PSVC_DEV_FAULT_LED, i);
965 if (status == PSVC_FAILURE)
966 return (status);
967 status = psvc_set_attr(hdlp, led_id,
968 PSVC_LED_STATE_ATTR, led_state);
969 if (status == PSVC_FAILURE)
970 return (status);
971 }
972
973 /* turn off OK to remove LEDs */
974 status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
975 &slot_id, PSVC_PARENT, 0);
976 if (status != PSVC_SUCCESS)
977 return (status);
978
979 psvc_get_attr(hdlp, slot_id, PSVC_ASSOC_MATCHES_ATTR,
980 &led_count, PSVC_SLOT_REMOVE_LED);
981 strcpy(led_state, PSVC_LED_OFF);
982 for (i = 0; i < led_count; ++i) {
983 status = psvc_get_attr(hdlp, slot_id,
984 PSVC_ASSOC_ID_ATTR, &led_id,
985 PSVC_SLOT_REMOVE_LED, i);
986 if (status == PSVC_FAILURE)
987 return (status);
988
989 status = psvc_set_attr(hdlp, led_id,
990 PSVC_LED_STATE_ATTR, led_state);
991 if (status == PSVC_FAILURE)
992 return (status);
993 }
994
995 ptree_get_node_by_path(parent_path, &parent_node);
996 ptree_add_node(parent_node, child_node);
997 } else {
998 syslog(LOG_ERR, DEVICE_REMOVED_MSG, label);
999 ptree_delete_node(child_node);
1000 }
1001 }
1002
1003 status = psvc_set_attr(hdlp, id, PSVC_PREV_PRESENCE_ATTR, &presence);
1004 if (status != PSVC_SUCCESS)
1005 return (status);
1006
1007 return (status);
1008 }
1009
1010 int32_t
1011 psvc_init_led_policy_0(psvc_opaque_t hdlp, char *id)
1012 {
1013 int32_t status;
1014
1015 status = psvc_set_attr(hdlp, id, PSVC_LED_STATE_ATTR, PSVC_LED_OFF);
1016 return (status);
1017 }
1018
1019 int32_t
1020 psvc_init_state_policy_0(psvc_opaque_t hdlp, char *id)
1021 {
1022 int32_t status;
1023
1024 status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, PSVC_OK);
1025 status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR, PSVC_NO_FAULT);
1026 return (status);
1027 }
1028
1029 int32_t
1030 psvc_ps_overcurrent_check_policy_0(psvc_opaque_t hdlp, char *power_supply_id)
1031 {
1032 int32_t status = PSVC_SUCCESS;
1033 boolean_t present;
1034 char *sensor_id;
1035 int32_t sensor_count;
1036 int32_t i;
1037 int32_t amps, hi_warn;
1038
1039 status = psvc_get_attr(hdlp, power_supply_id, PSVC_PRESENCE_ATTR,
1040 &present);
1041 if (status == PSVC_FAILURE) {
1042 syslog(LOG_ERR, GET_PRESENCE_FAILED_MSG, power_supply_id,
1043 errno);
1044 return (status);
1045 }
1046
1047 if (present == PSVC_ABSENT) {
1048 errno = ENODEV;
1049 return (PSVC_FAILURE);
1050 }
1051
1052 psvc_get_attr(hdlp, power_supply_id, PSVC_ASSOC_MATCHES_ATTR,
1053 &sensor_count, PSVC_PS_I_SENSOR);
1054 for (i = 0; i < sensor_count; ++i) {
1055 status = psvc_get_attr(hdlp, power_supply_id,
1056 PSVC_ASSOC_ID_ATTR, &sensor_id, PSVC_PS_I_SENSOR, i);
1057 if (status != PSVC_SUCCESS)
1058 return (status);
1059
1060 status = psvc_get_attr(hdlp, sensor_id, PSVC_HI_WARN_ATTR,
1061 &hi_warn);
1062 if (status != PSVC_SUCCESS)
1063 return (status);
1064
1065 status = psvc_get_attr(hdlp, sensor_id,
1066 PSVC_SENSOR_VALUE_ATTR, &amps);
1067 if (status != PSVC_SUCCESS) {
1068 syslog(LOG_ERR, GET_SENSOR_FAILED_MSG, sensor_id,
1069 errno);
1070 return (status);
1071 }
1072
1073 if (amps >= hi_warn) {
1074 char label[32];
1075
1076 status = psvc_get_attr(hdlp, power_supply_id,
1077 PSVC_LABEL_ATTR, &label);
1078 if (status != PSVC_SUCCESS)
1079 return (status);
1080
1081 syslog(LOG_ERR, PS_OVER_CURRENT_MSG, label);
1082 }
1083 }
1084
1085 return (PSVC_SUCCESS);
1086
1087 }
1088
1089 int32_t
1090 psvc_device_fail_notifier_policy_0(psvc_opaque_t hdlp, char *id)
1091 {
1092 int32_t led_count, sensor_count;
1093 char *led_id, *sensor_id;
1094 int i;
1095 char state[32], fault[32], previous_state[32];
1096 char led_state[32];
1097 int32_t status = PSVC_SUCCESS;
1098 boolean_t present;
1099
1100 status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &present);
1101 if (status == PSVC_FAILURE)
1102 return (status);
1103
1104 if (present == PSVC_ABSENT) {
1105 errno = ENODEV;
1106 return (PSVC_FAILURE);
1107 }
1108
1109 psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &sensor_count,
1110 PSVC_DEV_FAULT_SENSOR);
1111 for (i = 0; i < sensor_count; ++i) {
1112 status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
1113 &sensor_id, PSVC_DEV_FAULT_SENSOR, i);
1114 if (status != PSVC_SUCCESS)
1115 return (status);
1116
1117 status = psvc_get_attr(hdlp, sensor_id,
1118 PSVC_SWITCH_STATE_ATTR, state);
1119 if (status != PSVC_SUCCESS)
1120 return (status);
1121
1122 if (strcmp(state, PSVC_SWITCH_ON) == 0) {
1123 strcpy(state, PSVC_ERROR);
1124 strcpy(fault, PSVC_GEN_FAULT);
1125 } else {
1126 strcpy(state, PSVC_OK);
1127 strcpy(fault, PSVC_NO_FAULT);
1128 }
1129
1130 status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, state);
1131 if (status != PSVC_SUCCESS)
1132 return (status);
1133 status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR, fault);
1134 if (status != PSVC_SUCCESS)
1135 return (status);
1136 status = psvc_get_attr(hdlp, id, PSVC_PREV_STATE_ATTR,
1137 previous_state);
1138 if (status != PSVC_SUCCESS)
1139 return (status);
1140
1141 if (strcmp(state, previous_state) != 0) {
1142 char sensor_label[32];
1143 char dev_label[32];
1144 int32_t j;
1145
1146 psvc_get_attr(hdlp, id, PSVC_LABEL_ATTR, dev_label);
1147 psvc_get_attr(hdlp, sensor_id, PSVC_LABEL_ATTR,
1148 sensor_label);
1149
1150 if (strcmp(state, PSVC_ERROR) == 0) {
1151 syslog(LOG_ERR, DEVICE_FAILURE_MSG, dev_label,
1152 sensor_label);
1153 strcpy(led_state, PSVC_LED_ON);
1154 } else {
1155 syslog(LOG_ERR, DEVICE_OK_MSG, dev_label);
1156 strcpy(led_state, PSVC_LED_OFF);
1157 }
1158
1159 psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR,
1160 &led_count, PSVC_DEV_FAULT_LED);
1161 for (j = 0; j < led_count; j++) {
1162 status = psvc_get_attr(hdlp, id,
1163 PSVC_ASSOC_ID_ATTR, &led_id,
1164 PSVC_DEV_FAULT_LED, j);
1165 if (status != PSVC_SUCCESS)
1166 return (status);
1167 status = psvc_set_attr(hdlp, led_id,
1168 PSVC_LED_STATE_ATTR, led_state);
1169 if (status != PSVC_SUCCESS) {
1170 syslog(LOG_ERR, SET_LED_FAILED_MSG,
1171 led_id, errno);
1172 return (status);
1173 }
1174 }
1175 }
1176 }
1177
1178 return (PSVC_SUCCESS);
1179 }
1180
1181 static float
1182 get_filtered_error(float *last_errors, int current_error)
1183 {
1184 float error;
1185 float adder;
1186 int i = 0;
1187
1188 adder = last_errors[0];
1189 for (i = 1; i < PSVC_MAXERRORS; i++) {
1190 adder = adder + last_errors[i];
1191 }
1192 adder = adder + current_error;
1193 error = adder/(PSVC_MAXERRORS+1);
1194
1195 return (error);
1196 }
1197
1198 static int32_t
1199 change_cpu_fans(psvc_opaque_t hdlp, char *fan_id, int32_t fan_speed)
1200 {
1201 int err = PSVC_SUCCESS;
1202 int i;
1203 int32_t control_count;
1204 char *control_id;
1205 int32_t old_fan_speed;
1206
1207 psvc_get_attr(hdlp, fan_id, PSVC_ASSOC_MATCHES_ATTR, &control_count,
1208 PSVC_FAN_DRIVE_CONTROL);
1209 if (control_count == 0)
1210 return (PSVC_SUCCESS);
1211
1212 err = psvc_get_attr(hdlp, fan_id, PSVC_ASSOC_ID_ATTR, &control_id,
1213 PSVC_FAN_DRIVE_CONTROL, 0);
1214 if (err != PSVC_SUCCESS)
1215 return (err);
1216
1217 /*
1218 * this call will return PSVC_FAILURE on the first pass,
1219 * because no value has been set.
1220 */
1221 err = psvc_get_attr(hdlp, control_id, PSVC_CONTROL_VALUE_ATTR,
1222 &old_fan_speed);
1223 if (err == PSVC_SUCCESS && old_fan_speed == fan_speed)
1224 return (PSVC_SUCCESS);
1225
1226 for (i = 0; i < control_count; i++) {
1227 err = psvc_get_attr(hdlp, fan_id, PSVC_ASSOC_ID_ATTR,
1228 &control_id, PSVC_FAN_DRIVE_CONTROL, i);
1229 if (err != PSVC_SUCCESS)
1230 return (err);
1231
1232 err = psvc_set_attr(hdlp, control_id, PSVC_CONTROL_VALUE_ATTR,
1233 &fan_speed);
1234 if (err == PSVC_FAILURE) {
1235 syslog(LOG_ERR, SET_FANSPEED_FAILED_MSG, control_id,
1236 errno);
1237 return (err);
1238 }
1239 }
1240 return (err);
1241 }
1242
1243 static int32_t
1244 device_temp_check(psvc_opaque_t hdlp, char *fan_id, int32_t *hot_device)
1245 {
1246 int i;
1247 int32_t err = PSVC_SUCCESS;
1248 char *sensor_id;
1249 int32_t sensor_count;
1250 int32_t temp;
1251
1252 *hot_device = 0;
1253
1254 psvc_get_attr(hdlp, fan_id, PSVC_ASSOC_MATCHES_ATTR, &sensor_count,
1255 PSVC_DEV_TEMP_SENSOR);
1256 for (i = 0; i < sensor_count; i++) {
1257 err = psvc_get_attr(hdlp, fan_id, PSVC_ASSOC_ID_ATTR,
1258 &sensor_id, PSVC_DEV_TEMP_SENSOR, i);
1259 if (err == PSVC_FAILURE)
1260 return (err);
1261 err = psvc_get_attr(hdlp, sensor_id, PSVC_SENSOR_VALUE_ATTR,
1262 &temp);
1263 if (err == PSVC_FAILURE) {
1264 if (errno == ENODEV) {
1265 temp = 0;
1266 } else {
1267 syslog(LOG_ERR, GET_SENSOR_FAILED_MSG,
1268 sensor_id, errno);
1269 return (err);
1270 }
1271 }
1272
1273 if (*hot_device < temp)
1274 *hot_device = temp;
1275 }
1276 return (PSVC_SUCCESS);
1277 }
1278
1279 int32_t
1280 psvc_fan_control_policy_0(psvc_opaque_t hdlp, char *fan_id)
1281 {
1282 boolean_t is_enabled;
1283 int32_t err = PSVC_SUCCESS;
1284 int16_t setpoint, hysteresis, loopgain, loopbias;
1285 int current_error; /* Holds current error */
1286 /* Signal before signaling */
1287 float filtered_error; /* Holds the filtered error signal */
1288 int ampout; /* output of loop amplifier */
1289 int hot_device;
1290
1291 int16_t error_number;
1292 float last_errors[PSVC_MAXERRORS]; /* Holds the filtered error */
1293 /* from the last n iterations */
1294
1295 psvc_get_attr(hdlp, fan_id, PSVC_ENABLE_ATTR, &is_enabled);
1296 if (is_enabled == PSVC_DISABLED)
1297 return (PSVC_SUCCESS);
1298
1299 err = psvc_get_attr(hdlp, fan_id, PSVC_SETPOINT_ATTR, &setpoint);
1300 if (err != PSVC_SUCCESS)
1301 return (err);
1302
1303 err = psvc_get_attr(hdlp, fan_id, PSVC_HYSTERESIS_ATTR,
1304 &hysteresis);
1305 if (err != PSVC_SUCCESS)
1306 return (err);
1307
1308 err = psvc_get_attr(hdlp, fan_id, PSVC_LOOPGAIN_ATTR, &loopgain);
1309 if (err != PSVC_SUCCESS)
1310 return (err);
1311
1312 err = psvc_get_attr(hdlp, fan_id, PSVC_LOOPBIAS_ATTR, &loopbias);
1313 if (err != PSVC_SUCCESS)
1314 return (err);
1315
1316 err = psvc_get_attr(hdlp, fan_id, PSVC_TEMP_DIFFERENTIAL_ATTR,
1317 last_errors);
1318 if (err != PSVC_SUCCESS)
1319 return (err);
1320
1321 err = psvc_get_attr(hdlp, fan_id, PSVC_TEMP_DIFFERENTIAL_INDEX_ATTR,
1322 &error_number);
1323 if (err != PSVC_SUCCESS)
1324 return (err);
1325
1326 err = device_temp_check(hdlp, fan_id, &hot_device);
1327 if (err != PSVC_SUCCESS) {
1328 printf("psvc_fan_control failure in device_temp_check\n");
1329 return (err);
1330 }
1331 current_error = setpoint - hot_device;
1332 filtered_error = get_filtered_error(last_errors, current_error);
1333 if (filtered_error <= 0 || filtered_error > hysteresis) {
1334 ampout = (int)((filtered_error * loopgain) + loopbias);
1335 if (ampout < 0)
1336 ampout = 0;
1337 if (ampout > 1023)
1338 ampout = 1023;
1339 err = change_cpu_fans(hdlp, fan_id, ampout);
1340 if (err != PSVC_SUCCESS)
1341 return (err);
1342 }
1343 last_errors[error_number++] = current_error;
1344 if (error_number == PSVC_MAXERRORS)
1345 error_number = 0;
1346
1347 err = psvc_set_attr(hdlp, fan_id, PSVC_TEMP_DIFFERENTIAL_ATTR,
1348 last_errors);
1349 if (err != PSVC_SUCCESS)
1350 return (err);
1351
1352 err = psvc_set_attr(hdlp, fan_id, PSVC_TEMP_DIFFERENTIAL_INDEX_ATTR,
1353 &error_number);
1354 if (err != PSVC_SUCCESS)
1355 return (err);
1356
1357 return (PSVC_SUCCESS);
1358 }
1359
1360 int32_t
1361 psvc_fan_present_policy_0(psvc_opaque_t hdlp, char *id)
1362 {
1363 int32_t status = PSVC_SUCCESS;
1364 boolean_t presence;
1365 int fd;
1366 FILE *fp;
1367 int retry;
1368
1369 retry = 0;
1370 do {
1371 if (retry)
1372 (void) sleep(retry_sleep_fan_present);
1373
1374 status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &presence);
1375 if (status != PSVC_SUCCESS)
1376 return (status);
1377 retry++;
1378 } while ((retry < n_retry_fan_present) && (presence == PSVC_ABSENT));
1379
1380 if (presence == PSVC_ABSENT) {
1381 /*
1382 * We make this open, write, close, call because picld
1383 * starts in rcS.d while print services does not start
1384 * until later (either rc2.d or rc3.d)
1385 */
1386 fd = open("/dev/console", O_WRONLY | O_NOCTTY);
1387 if (fd != -1) {
1388 fp = fdopen(fd, "w+");
1389 if (fp != NULL) {
1390 fprintf(fp, FAN_MISSING_MSG, id);
1391 fclose(fp);
1392 }
1393 close(fd);
1394 }
1395 syslog(LOG_ERR, FAN_MISSING_MSG, id);
1396 }
1397 return (status);
1398 }
unleashed repo fork