?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / cmd / picl / plugins / sun4v / snmp / snmpplugin.c
blob62e97e1a0091022010a3bbe971c86d90d7a6f8cf
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 2010 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /*
28 * The SNMP picl plugin connects to the agent on the SP and creates
29 * and populates the /physical-platform subtree in picl tree for use
30 * by picl consumers.
31 */
32
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <syslog.h>
37 #include <stdarg.h>
38 #include <libgen.h>
39 #include <libintl.h>
40 #include <thread.h>
41 #include <synch.h>
42 #include <errno.h>
43 #include <time.h>
44 #include <signal.h>
45
46 #include <picldefs.h>
47 #include <picl.h>
48 #include <picltree.h>
49
50 #include "picloids.h"
51 #include "libpiclsnmp.h"
52 #include "snmpplugin.h"
53
54 #pragma init(snmpplugin_register) /* place in .init section */
55
56 picld_plugin_reg_t snmpplugin_reg = {
57 PICLD_PLUGIN_VERSION_1,
58 PICLD_PLUGIN_NON_CRITICAL,
59 "snmp_plugin",
60 snmpplugin_init,
61 snmpplugin_fini
62 };
63
64 static picl_snmphdl_t hdl;
65
66 /*
67 * The stale_tree_rwlp protects the stale_xxx vars. The 'stale_tree' flag
68 * and the 'rebuild_tree' flag below are both initialized to B_TRUE to
69 * let the tree_builder() thread build the initial tree without blocking.
70 */
71 static rwlock_t stale_tree_rwlp;
72 static boolean_t stale_tree = B_TRUE;
73
74 /*
75 * vol_props, volprop_ndx and n_vol_props are protected by the stale_tree
76 * flag. They are read only when the stale_tree flag is B_FALSE and written
77 * to only when the flag is B_TRUE.
78 *
79 * The change_time (last changed time) is read by only one thread at a
80 * time when stale_tree is B_FALSE (protected by stale_tree_rwlp). It is
81 * written by only one thread (the tree builder) when stale_tree is B_TRUE.
82 *
83 * Note that strictly speaking, change_time should be uint_t (timeticks32).
84 * But keeping it as int is fine, since we don't do any arithmetic on it
85 * except equality check.
86 */
87 static vol_prophdl_t *vol_props = NULL;
88 static int volprop_ndx = 0, n_vol_props = 0;
89 static int change_time = 0;
90 static time_t change_time_check;
91
92 /*
93 * The rebuild_tree_lock and cv are used by the tree builder thread.
94 * rebuild_tree has to be initialized to B_TRUE to let the tree_builder
95 * do the first build without blocking.
96 */
97 static mutex_t rebuild_tree_lock;
98 static cond_t rebuild_tree_cv;
99 static boolean_t rebuild_tree = B_TRUE;
100 static boolean_t tree_builder_thr_exit = B_FALSE;
101 static thread_t tree_builder_thr_id;
102
103 /*
104 * The cache_refresh thread periodically queries the snmp cache refresh work
105 * queue and processes jobs from it to keep cache entries from expiring. It
106 * attempts to run in cycles of CACHE_REFRESH_CYCLE seconds each, first
107 * processing cache refresh jobs and then sleeping for the remainder of the
108 * cycle once the next refresh job expiration is at least
109 * CACHE_REFRESH_MIN_WINDOW seconds in the future.
110 *
111 * NOTE: By using a thread to keep the SNMP cache refreshed in the background,
112 * we are both adding load to the system and reducing the system's ability to
113 * operate in power-saving mode when there is minimal load. While these
114 * tradeoffs are acceptable at this time in light of customer concerns about
115 * performance, it may be desirable in the future to move this work into the
116 * firmware. Also, while the current cycle times performed well on the largest
117 * sun4v config currently available (Batoka), they may need to be revisited for
118 * future systems if the number of sensors increases significantly.
119 */
120 #define CACHE_REFRESH_CYCLE 60
121 #define CACHE_REFRESH_MIN_WINDOW 75
122 static mutex_t cache_refresh_lock;
123 static cond_t cache_refresh_cv;
124 static boolean_t cache_refresh_thr_exit = B_FALSE;
125 static thread_t cache_refresh_thr_id;
126
127 /*
128 * These two should really not be global
129 */
130 static picl_nodehdl_t *physplat_nodes = NULL;
131 static int n_physplat_nodes = 0;
132
133 static char *group1[] = {
134 OID_entPhysicalDescr,
135 OID_entPhysicalContainedIn,
136 OID_entPhysicalClass,
137 OID_entPhysicalName,
138 OID_entPhysicalHardwareRev,
139 OID_entPhysicalFirmwareRev,
140 OID_entPhysicalSerialNum,
141 OID_entPhysicalMfgName,
142 OID_entPhysicalModelName,
143 OID_entPhysicalIsFRU,
144 0
145 };
146
147 static char *group2[] = {
148 OID_sunPlatEquipmentHolderAcceptableTypes,
149 OID_sunPlatCircuitPackReplaceable,
150 OID_sunPlatCircuitPackHotSwappable,
151 OID_sunPlatPhysicalClass,
152 OID_sunPlatSensorClass,
153 OID_sunPlatSensorType,
154 OID_sunPlatAlarmType,
155 OID_sunPlatPowerSupplyClass,
156 0
157 };
158
159 static char *group3[] = {
160 OID_sunPlatNumericSensorEnabledThresholds,
161 OID_sunPlatNumericSensorBaseUnits,
162 OID_sunPlatNumericSensorRateUnits,
163 0
164 };
165
166 static char *group4[] = {
167 OID_sunPlatBinarySensorInterpretTrue,
168 OID_sunPlatBinarySensorInterpretFalse,
169 0
170 };
171
172 static char *volgroup1[] = {
173 OID_sunPlatBinarySensorCurrent,
174 OID_sunPlatBinarySensorExpected,
175 0
176 };
177
178 static char *volgroup2[] = {
179 OID_sunPlatNumericSensorExponent,
180 OID_sunPlatNumericSensorCurrent,
181 OID_sunPlatNumericSensorLowerThresholdFatal,
182 OID_sunPlatNumericSensorLowerThresholdCritical,
183 OID_sunPlatNumericSensorLowerThresholdNonCritical,
184 OID_sunPlatNumericSensorUpperThresholdNonCritical,
185 OID_sunPlatNumericSensorUpperThresholdCritical,
186 OID_sunPlatNumericSensorUpperThresholdFatal,
187 0
188 };
189
190 static char *volgroup3[] = {
191 OID_sunPlatEquipmentOperationalState,
192 0
193 };
194
195 static char *volgroup4[] = {
196 OID_sunPlatAlarmState,
197 0
198 };
199
200 static char *volgroup5[] = {
201 OID_sunPlatBatteryStatus,
202 0
203 };
204
205 /*
206 * The following two items must match the Sun Platform MIB specification
207 * in their indices and values.
208 */
209 static char *sensor_baseunits[] = {
210 "", "other", "unknown", "degC", "degF", "degK", "volts", "amps",
211 "watts", "joules", "coulombs", "va", "nits", "lumens", "lux",
212 "candelas", "kPa", "psi", "newtons", "cfm", "rpm", "hertz",
213 "seconds", "minutes", "hours", "days", "weeks", "mils", "inches",
214 "feet", "cubicInches", "cubicFeet", "meters", "cubicCentimeters",
215 "cubicMeters", "liters", "fluidOunces", "radians", "steradians",
216 "revolutions", "cycles", "gravities", "ounces", "pounds", "footPounds",
217 "ounceInches", "gauss", "gilberts", "henries", "farads", "ohms",
218 "siemens", "moles", "becquerels", "ppm", "decibels", "dBA", "dbC",
219 "grays", "sieverts", "colorTemperatureDegK", "bits", "bytes", "words",
220 "doubleWords", "quadWords", "percentage"
221 };
222 static const int n_baseunits = sizeof (sensor_baseunits) / sizeof (char *);
223
224 static char *sensor_rateunits[] = {
225 "",
226 "none",
227 "perMicroSecond",
228 "perMilliSecond",
229 "perSecond",
230 "perMinute",
231 "perHour",
232 "perDay",
233 "perWeek",
234 "perMonth",
235 "perYear"
236 };
237 static const int n_rateunits = sizeof (sensor_rateunits) / sizeof (char *);
238
239 /*
240 * Local declarations
241 */
242 static void snmpplugin_register(void);
243 static void register_group(char **g, int is_volatile);
244 static void *tree_builder(void *arg);
245 static int build_physplat(picl_nodehdl_t *subtree_rootp);
246 static void free_resources(picl_nodehdl_t subtree_root);
247
248 static picl_nodehdl_t make_node(picl_nodehdl_t subtree_root, int row,
249 int *snmp_syserr_p);
250 static void save_nodeh(picl_nodehdl_t nodeh, int row);
251 static picl_nodehdl_t lookup_nodeh(int row);
252
253 static void save_volprop(picl_prophdl_t prop, char *oidstr, int row,
254 int proptype);
255 static void check_for_stale_data(boolean_t nocache);
256 static int read_volprop(ptree_rarg_t *parg, void *buf);
257
258 static void threshold(picl_nodehdl_t node, char *oidstr, int row,
259 char *propname, int *snmp_syserr_p);
260 static void add_thresholds(picl_nodehdl_t node, int row, int *snmp_syserr_p);
261
262 static char *get_slot_type(int row, int *snmp_syserr_p);
263 static int add_volatile_prop(picl_nodehdl_t nodeh, char *name,
264 int type, int access, int size, int (*rdfunc)(ptree_rarg_t *, void *),
265 int (*wrfunc)(ptree_warg_t *, const void *), picl_prophdl_t *propp);
266 static int add_string_prop(picl_nodehdl_t node, char *propname, char *propval);
267 static int add_void_prop(picl_nodehdl_t node, char *propname);
268 static void add_prop(picl_nodehdl_t nodeh, picl_prophdl_t *php, char *label,
269 int row, sp_propid_t pp, int *snmp_syserr_p);
270
271 static void *cache_refresher(void *arg);
272 static void cache_refresher_fini(void);
273
274 static void log_msg(int pri, const char *fmt, ...);
275
276 #ifdef SNMPPLUGIN_DEBUG
277 static mutex_t snmpplugin_dbuf_lock;
278 static char *snmpplugin_dbuf = NULL;
279 static char *snmpplugin_dbuf_curp = NULL;
280 static int snmpplugin_dbuf_sz = 0;
281 static int snmpplugin_dbuf_overflow = 0;
282 static char snmpplugin_lbuf[SNMPPLUGIN_DMAX_LINE];
283
284 static void snmpplugin_log_init(void);
285 static void snmpplugin_log(const char *fmt, ...);
286 static void snmpplugin_log_append(void);
287 static void snmpplugin_dbuf_realloc(void);
288 #endif
289
290 static void
291 snmpplugin_register(void)
292 {
293 (void) picld_plugin_register(&snmpplugin_reg);
294 }
295
296 static void
297 register_group(char **g, int is_volatile)
298 {
299 int i, len = 0;
300 int n_oids;
301 char *p, *oidstrs;
302
303 for (i = 0; g[i]; i++)
304 len += strlen(g[i]) + 1;
305 n_oids = i;
306
307 if ((oidstrs = (char *)calloc(1, len)) == NULL)
308 return;
309
310 for (p = oidstrs, i = 0; g[i]; i++) {
311 (void) strcpy(p, g[i]);
312 p += strlen(g[i]) + 1;
313 }
314
315 snmp_register_group(hdl, oidstrs, n_oids, is_volatile);
316 free(oidstrs);
317 }
318
319 void
320 snmpplugin_init(void)
321 {
322 int ret;
323
324 (void) mutex_init(&rebuild_tree_lock, USYNC_THREAD, NULL);
325 (void) cond_init(&rebuild_tree_cv, USYNC_THREAD, NULL);
326 (void) rwlock_init(&stale_tree_rwlp, USYNC_THREAD, NULL);
327 tree_builder_thr_exit = B_FALSE;
328
329 LOGINIT();
330
331 /*
332 * Create the tree-builder thread and let it take over
333 */
334 LOGPRINTF("Tree-builder thread being created.\n");
335 if ((ret = thr_create(NULL, NULL, tree_builder, NULL,
336 THR_BOUND, &tree_builder_thr_id)) < 0) {
337 log_msg(LOG_ERR, SNMPP_CANT_CREATE_TREE_BUILDER, ret);
338 snmp_fini(hdl);
339 hdl = NULL;
340 (void) rwlock_destroy(&stale_tree_rwlp);
341 (void) cond_destroy(&rebuild_tree_cv);
342 (void) mutex_destroy(&rebuild_tree_lock);
343 tree_builder_thr_exit = B_TRUE;
344
345 return;
346 }
347
348 /*
349 * While the cache refresher thread does improve performance, it is not
350 * integral to the proper function of the plugin. If we fail to create
351 * the thread for some reason, we will simply continue without
352 * refreshing.
353 */
354 (void) mutex_init(&cache_refresh_lock, USYNC_THREAD, NULL);
355 (void) cond_init(&cache_refresh_cv, USYNC_THREAD, NULL);
356 cache_refresh_thr_exit = B_FALSE;
357
358 LOGPRINTF("Cache refresher thread being created.\n");
359 if (thr_create(NULL, NULL, cache_refresher, NULL, THR_BOUND,
360 &cache_refresh_thr_id) < 0) {
361 (void) cond_destroy(&cache_refresh_cv);
362 (void) mutex_destroy(&cache_refresh_lock);
363 cache_refresh_thr_exit = B_TRUE;
364 }
365 }
366
367 void
368 snmpplugin_fini(void)
369 {
370
371 if (tree_builder_thr_exit == B_TRUE)
372 return;
373
374 /*
375 * Make reads of volatile properties return PICL_PROPUNAVAILABLE
376 * since we're about to recycle the plug-in. No need to worry
377 * about removing /physical-platform since tree_builder() will
378 * take care of recycling it for us.
379 */
380 (void) rw_wrlock(&stale_tree_rwlp);
381 stale_tree = B_TRUE;
382 if (vol_props) {
383 free(vol_props);
384 }
385 vol_props = NULL;
386 volprop_ndx = 0;
387 n_vol_props = 0;
388 (void) rw_unlock(&stale_tree_rwlp);
389
390 /* clean up the cache_refresher thread and structures */
391 cache_refresher_fini();
392
393 /* wake up the tree_builder thread, tell it to exit */
394 (void) mutex_lock(&rebuild_tree_lock);
395 rebuild_tree = B_TRUE;
396 tree_builder_thr_exit = B_TRUE;
397 (void) cond_signal(&rebuild_tree_cv);
398 (void) mutex_unlock(&rebuild_tree_lock);
399
400 /* send SIGUSR1 to get tree_builder out of a blocked system call */
401 (void) thr_kill(tree_builder_thr_id, SIGUSR1);
402
403 /* reap the thread */
404 (void) thr_join(tree_builder_thr_id, NULL, NULL);
405
406 /* close the channel */
407 if (hdl != NULL) {
408 snmp_fini(hdl);
409 hdl = NULL;
410 }
411
412 /* finish cleanup... */
413 (void) rwlock_destroy(&stale_tree_rwlp);
414 (void) cond_destroy(&rebuild_tree_cv);
415 (void) mutex_destroy(&rebuild_tree_lock);
416 }
417
418 /*ARGSUSED*/
419 static void
420 usr1_handler(int sig, siginfo_t *siginfo, void *sigctx)
421 {
422 /*
423 * Nothing to do here.
424 * The act of catching the signal causes any cond_wait() or blocked
425 * system call to return EINTR. This is used to trigger early exit from
426 * the tree builder thread which may be blocked in snmp_init. More work
427 * would be required to allow early exit if the tree builder thread is
428 * already in its main processing loop and not blocked in cond_wait.
429 */
430 }
431
432 /*ARGSUSED*/
433 static void *
434 tree_builder(void *arg)
435 {
436 int ret, rv;
437 picl_nodehdl_t root_node;
438 picl_nodehdl_t physplat_root;
439 picl_nodehdl_t old_physplat_root;
440 struct sigaction act;
441
442 /*
443 * catch SIGUSR1 to allow early exit from snmp_init which may block
444 * indefinitely in a guest domain.
445 */
446 act.sa_sigaction = usr1_handler;
447 (void) sigemptyset(&act.sa_mask);
448 act.sa_flags = 0;
449 if (sigaction(SIGUSR1, &act, NULL) == -1) {
450 syslog(LOG_ERR, SIGACT_FAILED, strsignal(SIGUSR1),
451 strerror(errno));
452 }
453
454 /*
455 * Initialize SNMP service
456 */
457 LOGPRINTF("Initializing SNMP service.\n");
458 if ((hdl = snmp_init()) == NULL) {
459 log_msg(LOG_ERR, SNMPP_CANT_INIT);
460 return ((void *)-1);
461 }
462
463 /*
464 * Register OID groupings for BULKGET optimizations
465 */
466 LOGPRINTF("Registering OID groups.\n");
467 register_group(group1, 0);
468 register_group(group2, 0);
469 register_group(group3, 0);
470 register_group(group4, 0);
471 register_group(volgroup1, 1);
472 register_group(volgroup2, 1);
473 register_group(volgroup3, 1);
474 register_group(volgroup4, 1);
475 register_group(volgroup5, 1);
476
477 (void) mutex_lock(&rebuild_tree_lock);
478
479 for (;;) {
480 LOGPRINTF("tree_builder: check whether to rebuild subtree\n");
481 while (rebuild_tree == B_FALSE)
482 (void) cond_wait(&rebuild_tree_cv, &rebuild_tree_lock);
483
484 LOGPRINTF("tree_builder: woke up\n");
485
486 if (tree_builder_thr_exit == B_TRUE) {
487 (void) mutex_unlock(&rebuild_tree_lock);
488 LOGPRINTF("tree_builder: time to exit\n");
489 return (NULL);
490 }
491
492 old_physplat_root = NULL;
493 physplat_root = NULL;
494
495 LOGPRINTF("tree_builder: getting root node\n");
496 if ((ret = ptree_get_root(&root_node)) != PICL_SUCCESS) {
497 (void) mutex_unlock(&rebuild_tree_lock);
498 log_msg(LOG_ERR, SNMPP_NO_ROOT, ret);
499 return ((void *)-2);
500 }
501
502 LOGPRINTF("tree_builder: getting existing physplat node\n");
503 rv = ptree_find_node(root_node, PICL_PROP_NAME,
504 PICL_PTYPE_CHARSTRING, PICL_NODE_PHYSPLAT,
505 sizeof (PICL_NODE_PHYSPLAT), &old_physplat_root);
506
507 LOGPRINTF("tree_builder: building physical-platform\n");
508 if ((ret = build_physplat(&physplat_root)) < 0) {
509 (void) mutex_unlock(&rebuild_tree_lock);
510 log_msg(LOG_ERR, SNMPP_CANT_CREATE_PHYSPLAT, ret);
511 cache_refresher_fini();
512 snmp_fini(hdl);
513 hdl = NULL;
514 return ((void *)-3);
515 }
516
517 if (rv == PICL_SUCCESS && old_physplat_root != NULL) {
518 LOGPRINTF("tree_builder: destroying existing nodes\n");
519 ptree_delete_node(old_physplat_root);
520 ptree_destroy_node(old_physplat_root);
521 }
522
523 LOGPRINTF("tree_builder: attaching new subtree\n");
524 if ((ret = ptree_add_node(root_node, physplat_root)) < 0) {
525 (void) mutex_unlock(&rebuild_tree_lock);
526 free_resources(physplat_root);
527 log_msg(LOG_ERR, SNMPP_CANT_CREATE_PHYSPLAT, ret);
528 cache_refresher_fini();
529 snmp_fini(hdl);
530 hdl = NULL;
531 return ((void *)-4);
532 }
533
534 LOGPRINTF("tree_builder: setting stale_tree to FALSE\n");
535 (void) rw_wrlock(&stale_tree_rwlp);
536 stale_tree = B_FALSE;
537 (void) rw_unlock(&stale_tree_rwlp);
538
539 LOGPRINTF("tree_builder: setting rebuild_tree to FALSE\n");
540 rebuild_tree = B_FALSE;
541 }
542
543 /*NOTREACHED*/
544 return (NULL);
545 }
546
547 static int
548 build_physplat(picl_nodehdl_t *subtree_rootp)
549 {
550 int change_time1;
551 int row, nxtrow;
552 int clr_linkreset = 0;
553 int ret = 0;
554 int snmp_syserr = 0;
555
556 retry:
557 (void) snmp_reinit(hdl, clr_linkreset);
558 clr_linkreset = 0;
559
560 /*
561 * Record LastChangeTime before we start building the tree
562 */
563 ret = snmp_get_int(hdl, OID_entLastChangeTime, 0,
564 &change_time1, &snmp_syserr);
565 if (ret < 0) {
566 if (snmp_syserr == ECANCELED) {
567 LOGPRINTF(SNMPP_LINK_RESET);
568 clr_linkreset = 1;
569 goto retry;
570 }
571 log_msg(LOG_WARNING, SNMPP_CANT_FETCH_OBJECT_VAL,
572 snmp_syserr ? snmp_syserr : ret, OID_entLastChangeTime, 0);
573 }
574
575 /*
576 * Create the physical-platform node
577 */
578 ret = ptree_create_node(PICL_NODE_PHYSPLAT, PICL_CLASS_PICL,
579 subtree_rootp);
580 if (ret != PICL_SUCCESS)
581 return (-1);
582
583 /*
584 * Scan entPhysicalTable and build the "physical-platform" subtree
585 */
586 ret = 0;
587 for (row = -1; ret == 0; row = nxtrow) {
588 ret = snmp_get_nextrow(hdl, OID_entPhysicalDescr,
589 row, &nxtrow, &snmp_syserr);
590 if (ret == 0)
591 (void) make_node(*subtree_rootp, nxtrow, &snmp_syserr);
592 switch (snmp_syserr) {
593 case ECANCELED:
594 /*
595 * If we get this error, a link reset must've
596 * happened and we need to throw away everything
597 * we have now and rebuild the tree again.
598 */
599 log_msg(LOG_WARNING, SNMPP_LINK_RESET);
600 free_resources(*subtree_rootp);
601 clr_linkreset = 1;
602 goto retry;
603 /*NOTREACHED*/
604 break;
605 case ENOSPC: /* end of MIB */
606 LOGPRINTF("build_physplat: end of MIB\n");
607 break;
608 case ENOENT: /* end of table */
609 LOGPRINTF("build_physplat: end of table\n");
610 break;
611 default:
612 /*
613 * make_node() will print messages so don't
614 * repeat that exercise here.
615 */
616 if (ret == -1) {
617 log_msg(LOG_WARNING,
618 SNMPP_CANT_FETCH_OBJECT_VAL,
619 snmp_syserr ? snmp_syserr : ret,
620 OID_entPhysicalDescr, row);
621 }
622 }
623 }
624
625 /*
626 * Record LastChangeTime after we're done building the tree
627 */
628 ret = snmp_get_int(hdl, OID_entLastChangeTime, 0,
629 &change_time, &snmp_syserr);
630 if (ret < 0) {
631 if (snmp_syserr == ECANCELED) {
632 log_msg(LOG_WARNING, SNMPP_LINK_RESET);
633 free_resources(*subtree_rootp);
634 clr_linkreset = 1;
635 goto retry;
636 } else
637 log_msg(LOG_WARNING, SNMPP_CANT_FETCH_OBJECT_VAL,
638 snmp_syserr ? snmp_syserr : ret,
639 OID_entLastChangeTime, row);
640 }
641
642 /*
643 * If they don't match, some hotplugging must've happened,
644 * free resources we've created and still holding, then go
645 * back and retry
646 */
647 if (change_time != change_time1) {
648 LOGPRINTF("build_physplat: entLastChangeTime has changed!\n");
649 free_resources(*subtree_rootp);
650 change_time1 = change_time;
651 goto retry;
652 }
653
654 /*
655 * The physplat_nodes table is no longer needed, free it
656 */
657 if (physplat_nodes) {
658 free(physplat_nodes);
659 physplat_nodes = NULL;
660 n_physplat_nodes = 0;
661 }
662
663 return (0);
664 }
665
666 /*
667 * Destroy all resources that were created during the building
668 * of the subtree
669 */
670 static void
671 free_resources(picl_nodehdl_t subtree_root)
672 {
673 if (physplat_nodes) {
674 free(physplat_nodes);
675 physplat_nodes = NULL;
676 n_physplat_nodes = 0;
677 }
678
679 if (subtree_root) {
680 (void) ptree_delete_node(subtree_root);
681 (void) ptree_destroy_node(subtree_root);
682 }
683
684 if (vol_props) {
685 free(vol_props);
686 vol_props = NULL;
687 n_vol_props = 0;
688 volprop_ndx = 0;
689 }
690 }
691
692 static picl_nodehdl_t
693 make_node(picl_nodehdl_t subtree_root, int row, int *snmp_syserr_p)
694 {
695 picl_nodehdl_t nodeh, parenth;
696 picl_prophdl_t proph;
697 char *phys_name, *node_name;
698 int parent_row;
699 int ent_physclass, sunplat_physclass;
700 int sensor_class, sensor_type;
701 int alarm_type;
702 int ps_class;
703 int ret;
704
705 /*
706 * If we've already created this picl node, just return it
707 */
708 if ((nodeh = lookup_nodeh(row)) != NULL)
709 return (nodeh);
710
711 /*
712 * If we are creating it only now, make sure we have the parent
713 * created first; if there's no parent, then parent it to the
714 * subtree's root node
715 */
716 ret = snmp_get_int(hdl, OID_entPhysicalContainedIn, row,
717 &parent_row, snmp_syserr_p);
718 CHECK_LINKRESET(snmp_syserr_p, NULL)
719 if (ret < 0 || parent_row <= 0)
720 parenth = subtree_root;
721 else {
722 parenth = make_node(subtree_root, parent_row, snmp_syserr_p);
723 CHECK_LINKRESET(snmp_syserr_p, NULL)
724 if (parenth == NULL)
725 parenth = subtree_root;
726 }
727
728 /*
729 * Figure out the physical-platform node name from entPhysicalName;
730 * all rows in the MIB that have a valid entPhysicalIndex should
731 * have a physical name.
732 */
733 ret = snmp_get_str(hdl, OID_entPhysicalName, row,
734 &phys_name, snmp_syserr_p);
735 CHECK_LINKRESET(snmp_syserr_p, NULL)
736 if (ret < 0 || phys_name == NULL) {
737 log_msg(LOG_WARNING, SNMPP_NO_ENTPHYSNAME, row);
738 return (NULL);
739 }
740
741 node_name = basename(phys_name);
742
743 ret = snmp_get_int(hdl, OID_entPhysicalClass, row,
744 &ent_physclass, snmp_syserr_p);
745 CHECK_LINKRESET(snmp_syserr_p, NULL)
746 if (ret < 0) {
747 log_msg(LOG_WARNING, SNMPP_CANT_FETCH_OBJECT_VAL,
748 *snmp_syserr_p ? *snmp_syserr_p : ret,
749 OID_entPhysicalClass, row);
750 free(phys_name);
751 return (NULL);
752 }
753
754 switch (ent_physclass) {
755 case SPC_OTHER:
756 ret = snmp_get_int(hdl, OID_sunPlatPhysicalClass, row,
757 &sunplat_physclass, snmp_syserr_p);
758 CHECK_LINKRESET(snmp_syserr_p, NULL)
759 if (ret < 0) {
760 log_msg(LOG_WARNING, SNMPP_CANT_FETCH_OBJECT_VAL,
761 *snmp_syserr_p ? *snmp_syserr_p : ret,
762 OID_sunPlatPhysicalClass, row);
763 free(phys_name);
764 return (NULL);
765 }
766
767 if (sunplat_physclass == SSPC_ALARM) {
768 ret = snmp_get_int(hdl, OID_sunPlatAlarmType,
769 row, &alarm_type, snmp_syserr_p);
770 CHECK_LINKRESET(snmp_syserr_p, NULL)
771 if (ret < 0) {
772 log_msg(LOG_WARNING,
773 SNMPP_CANT_FETCH_OBJECT_VAL,
774 *snmp_syserr_p ? *snmp_syserr_p : ret,
775 OID_sunPlatAlarmType, row);
776 free(phys_name);
777 return (NULL);
778 }
779
780 if (alarm_type == SSAT_VISIBLE) {
781 ADD_NODE(PICL_CLASS_LED)
782 } else {
783 ADD_NODE(PICL_CLASS_ALARM)
784 }
785
786 add_prop(nodeh, &proph, node_name, row, PP_STATE,
787 snmp_syserr_p);
788 CHECK_LINKRESET(snmp_syserr_p, NULL)
789 } else {
790 ADD_NODE(PICL_CLASS_OTHER)
791 }
792
793 add_prop(nodeh, &proph, node_name, row, PP_OPSTATUS,
794 snmp_syserr_p);
795 CHECK_LINKRESET(snmp_syserr_p, NULL)
796 break;
797
798 case SPC_UNKNOWN:
799 ADD_NODE(PICL_CLASS_UNKNOWN)
800 break;
801
802 case SPC_CHASSIS:
803 ADD_NODE(PICL_CLASS_CHASSIS)
804 add_prop(nodeh, &proph, node_name, row, PP_OPSTATUS,
805 snmp_syserr_p);
806 CHECK_LINKRESET(snmp_syserr_p, NULL)
807 break;
808
809 case SPC_BACKPLANE:
810 ADD_NODE(PICL_CLASS_BACKPLANE)
811 add_prop(nodeh, &proph, node_name, row, PP_OPSTATUS,
812 snmp_syserr_p);
813 CHECK_LINKRESET(snmp_syserr_p, NULL)
814 break;
815
816 case SPC_CONTAINER:
817 ADD_NODE(PICL_CLASS_CONTAINER)
818
819 add_prop(nodeh, &proph, node_name, row, PP_OPSTATUS,
820 snmp_syserr_p);
821 CHECK_LINKRESET(snmp_syserr_p, NULL)
822
823 add_prop(nodeh, &proph, node_name, row, PP_SLOT_TYPE,
824 snmp_syserr_p);
825 CHECK_LINKRESET(snmp_syserr_p, NULL)
826 break;
827
828 case SPC_POWERSUPPLY:
829 ret = snmp_get_int(hdl, OID_sunPlatPowerSupplyClass,
830 row, &ps_class, snmp_syserr_p);
831 CHECK_LINKRESET(snmp_syserr_p, NULL)
832 if (ret < 0) {
833 log_msg(LOG_WARNING, SNMPP_CANT_FETCH_OBJECT_VAL,
834 *snmp_syserr_p ? *snmp_syserr_p : ret,
835 OID_sunPlatPowerSupplyClass, row);
836 free(phys_name);
837 return (NULL);
838 }
839
840 if (ps_class == SSPSC_BATTERY) {
841 ADD_NODE(PICL_CLASS_BATTERY)
842 add_prop(nodeh, &proph, node_name, row,
843 PP_BATT_STATUS, snmp_syserr_p);
844 CHECK_LINKRESET(snmp_syserr_p, NULL)
845 } else {
846 ADD_NODE(PICL_CLASS_POWERSUPPLY)
847 }
848 add_prop(nodeh, &proph, node_name, row, PP_OPSTATUS,
849 snmp_syserr_p);
850 CHECK_LINKRESET(snmp_syserr_p, NULL)
851 break;
852
853 case SPC_FAN:
854 ADD_NODE(PICL_CLASS_FAN)
855 add_prop(nodeh, &proph, node_name, row, PP_OPSTATUS,
856 snmp_syserr_p);
857 CHECK_LINKRESET(snmp_syserr_p, NULL)
858 break;
859
860 case SPC_SENSOR:
861 ret = snmp_get_int(hdl, OID_sunPlatSensorClass,
862 row, &sensor_class, snmp_syserr_p);
863 CHECK_LINKRESET(snmp_syserr_p, NULL)
864 if (ret < 0) {
865 log_msg(LOG_WARNING, SNMPP_CANT_FETCH_OBJECT_VAL,
866 *snmp_syserr_p ? *snmp_syserr_p : ret,
867 OID_sunPlatSensorClass, row);
868 free(phys_name);
869 return (NULL);
870 }
871
872 ret = snmp_get_int(hdl, OID_sunPlatSensorType,
873 row, &sensor_type, snmp_syserr_p);
874 CHECK_LINKRESET(snmp_syserr_p, NULL)
875 if (ret < 0) {
876 log_msg(LOG_WARNING, SNMPP_CANT_FETCH_OBJECT_VAL,
877 *snmp_syserr_p ? *snmp_syserr_p : ret,
878 OID_sunPlatSensorType, row);
879 free(phys_name);
880 return (NULL);
881 }
882
883 if (sensor_class == SSSC_NUMERIC) {
884 if (sensor_type == SSST_TEMPERATURE) {
885 ADD_NODE(PICL_CLASS_TEMPERATURE_SENSOR)
886 add_prop(nodeh, &proph, node_name, row,
887 PP_TEMPERATURE, snmp_syserr_p);
888 } else if (sensor_type == SSST_VOLTAGE) {
889 ADD_NODE(PICL_CLASS_VOLTAGE_SENSOR)
890 add_prop(nodeh, &proph, node_name, row,
891 PP_VOLTAGE, snmp_syserr_p);
892 } else if (sensor_type == SSST_CURRENT) {
893 ADD_NODE(PICL_CLASS_CURRENT_SENSOR)
894 add_prop(nodeh, &proph, node_name, row,
895 PP_CURRENT, snmp_syserr_p);
896 } else if (sensor_type == SSST_TACHOMETER) {
897 ADD_NODE(PICL_CLASS_RPM_SENSOR)
898 add_prop(nodeh, &proph, node_name, row,
899 PP_SPEED, snmp_syserr_p);
900 } else {
901 ADD_NODE(PICL_CLASS_SENSOR)
902 add_prop(nodeh, &proph, node_name, row,
903 PP_SENSOR_VALUE, snmp_syserr_p);
904 }
905 CHECK_LINKRESET(snmp_syserr_p, NULL)
906
907 add_prop(nodeh, &proph, node_name, row,
908 PP_OPSTATUS, snmp_syserr_p);
909 CHECK_LINKRESET(snmp_syserr_p, NULL)
910
911 add_prop(nodeh, &proph, node_name, row,
912 PP_BASE_UNITS, snmp_syserr_p);
913 CHECK_LINKRESET(snmp_syserr_p, NULL)
914
915 add_prop(nodeh, &proph, node_name, row,
916 PP_EXPONENT, snmp_syserr_p);
917 CHECK_LINKRESET(snmp_syserr_p, NULL)
918
919 add_prop(nodeh, &proph, node_name, row,
920 PP_RATE_UNITS, snmp_syserr_p);
921 CHECK_LINKRESET(snmp_syserr_p, NULL)
922
923 add_thresholds(nodeh, row, snmp_syserr_p);
924 CHECK_LINKRESET(snmp_syserr_p, NULL)
925
926 } else if (sensor_class == SSSC_BINARY) {
927 if (sensor_type == SSST_TEMPERATURE) {
928 ADD_NODE(PICL_CLASS_TEMPERATURE_INDICATOR)
929 } else if (sensor_type == SSST_VOLTAGE) {
930 ADD_NODE(PICL_CLASS_VOLTAGE_INDICATOR)
931 } else if (sensor_type == SSST_CURRENT) {
932 ADD_NODE(PICL_CLASS_CURRENT_INDICATOR)
933 } else if (sensor_type == SSST_TACHOMETER) {
934 ADD_NODE(PICL_CLASS_RPM_INDICATOR)
935 } else if (sensor_type == SSST_PRESENCE) {
936 ADD_NODE(PICL_CLASS_PRESENCE_INDICATOR)
937 } else {
938 ADD_NODE(PICL_CLASS_INDICATOR)
939 }
940
941 add_prop(nodeh, &proph, node_name, row, PP_OPSTATUS,
942 snmp_syserr_p);
943 CHECK_LINKRESET(snmp_syserr_p, NULL)
944
945 add_prop(nodeh, &proph, node_name, row, PP_CONDITION,
946 snmp_syserr_p);
947 CHECK_LINKRESET(snmp_syserr_p, NULL)
948
949 add_prop(nodeh, &proph, node_name, row, PP_EXPECTED,
950 snmp_syserr_p);
951 CHECK_LINKRESET(snmp_syserr_p, NULL)
952 } else {
953 log_msg(LOG_ERR,
954 SNMPP_UNSUPP_SENSOR_CLASS, sensor_class, row);
955 return (NULL);
956 }
957 break;
958
959 case SPC_MODULE:
960 ADD_NODE(PICL_CLASS_MODULE)
961
962 add_prop(nodeh, &proph, node_name, row, PP_OPSTATUS,
963 snmp_syserr_p);
964 CHECK_LINKRESET(snmp_syserr_p, NULL)
965
966 add_prop(nodeh, &proph, node_name, row, PP_REPLACEABLE,
967 snmp_syserr_p);
968 CHECK_LINKRESET(snmp_syserr_p, NULL)
969
970 add_prop(nodeh, &proph, node_name, row, PP_HOTSWAPPABLE,
971 snmp_syserr_p);
972 CHECK_LINKRESET(snmp_syserr_p, NULL)
973 break;
974
975 case SPC_PORT:
976 ADD_NODE(PICL_CLASS_PORT)
977 break;
978
979 case SPC_STACK:
980 ADD_NODE(PICL_CLASS_STACK)
981 break;
982
983 default:
984 log_msg(LOG_WARNING,
985 SNMPP_UNKNOWN_ENTPHYSCLASS, ent_physclass, row);
986 free(phys_name);
987 return (NULL);
988 }
989
990 add_prop(nodeh, &proph, node_name, row, PP_DESCRIPTION, snmp_syserr_p);
991 CHECK_LINKRESET(snmp_syserr_p, NULL)
992
993 add_prop(nodeh, &proph, node_name, row, PP_LABEL, snmp_syserr_p);
994 CHECK_LINKRESET(snmp_syserr_p, NULL)
995
996 add_prop(nodeh, &proph, node_name, row, PP_HW_REVISION, snmp_syserr_p);
997 CHECK_LINKRESET(snmp_syserr_p, NULL)
998
999 add_prop(nodeh, &proph, node_name, row, PP_FW_REVISION, snmp_syserr_p);
1000 CHECK_LINKRESET(snmp_syserr_p, NULL)
1001
1002 add_prop(nodeh, &proph, node_name, row, PP_SERIAL_NUM, snmp_syserr_p);
1003 CHECK_LINKRESET(snmp_syserr_p, NULL)
1004
1005 add_prop(nodeh, &proph, node_name, row, PP_MFG_NAME, snmp_syserr_p);
1006 CHECK_LINKRESET(snmp_syserr_p, NULL)
1007
1008 add_prop(nodeh, &proph, node_name, row, PP_MODEL_NAME, snmp_syserr_p);
1009 CHECK_LINKRESET(snmp_syserr_p, NULL)
1010
1011 add_prop(nodeh, &proph, node_name, row, PP_IS_FRU, snmp_syserr_p);
1012 CHECK_LINKRESET(snmp_syserr_p, NULL)
1013
1014 free(phys_name);
1015 save_nodeh(nodeh, row);
1016
1017 return (nodeh);
1018 }
1019
1020 /*
1021 * Saves the node handle and the row id into physplat_nodes[]. If we're
1022 * doing this in response to a hotplug event, we should've freed the
1023 * old physplat_nodes before entering here to save the first node of the
1024 * new physplat subtree.
1025 */
1026 static void
1027 save_nodeh(picl_nodehdl_t nodeh, int row)
1028 {
1029 size_t sz, count;
1030 picl_nodehdl_t *p;
1031
1032 if (row >= n_physplat_nodes) {
1033 count = (((size_t)row >> NODE_BLOCK_SHIFT) + 1) *
1034 N_ELEMS_IN_NODE_BLOCK;
1035 sz = count * sizeof (picl_nodehdl_t);
1036
1037 p = (picl_nodehdl_t *)calloc(count, sizeof (picl_nodehdl_t));
1038 if (p == NULL) {
1039 log_msg(LOG_ERR, SNMPP_NO_MEM, sz);
1040 return;
1041 }
1042
1043 if (physplat_nodes) {
1044 (void) memcpy((void *) p, (void *) physplat_nodes,
1045 n_physplat_nodes * sizeof (picl_nodehdl_t));
1046 free((void *) physplat_nodes);
1047 }
1048
1049 physplat_nodes = p;
1050 n_physplat_nodes = count;
1051 }
1052
1053 physplat_nodes[row] = nodeh;
1054 }
1055
1056 static picl_nodehdl_t
1057 lookup_nodeh(int row)
1058 {
1059 if (row >= n_physplat_nodes)
1060 return (NULL);
1061
1062 return (physplat_nodes[row]);
1063 }
1064
1065 /*
1066 * We enter this routine only when we are building the physical-platform
1067 * subtree, whether for the first time or in response to a hotplug event.
1068 * If we're here for rebuilding the tree, we have already set stale_tree
1069 * to be B_TRUE, so no one else would be accessing vol_props, n_vol_props
1070 * or volprop_ndx. If we're here to build the tree for the first time,
1071 * picld hasn't yet created doors and is running single-threaded, so no
1072 * one else would be accessing them anyway.
1073 */
1074 static void
1075 save_volprop(picl_prophdl_t prop, char *oidstr, int row, int proptype)
1076 {
1077 vol_prophdl_t *p;
1078 int count;
1079
1080 if (volprop_ndx == n_vol_props) {
1081 count = n_vol_props + N_ELEMS_IN_VOLPROP_BLOCK;
1082 p = (vol_prophdl_t *)calloc(count, sizeof (vol_prophdl_t));
1083 if (p == NULL) {
1084 log_msg(LOG_ERR, SNMPP_NO_MEM,
1085 count * sizeof (vol_prophdl_t));
1086 return;
1087 }
1088
1089 if (vol_props) {
1090 (void) memcpy((void *) p, (void *) vol_props,
1091 n_vol_props * sizeof (vol_prophdl_t));
1092 free((void *) vol_props);
1093 }
1094
1095 vol_props = p;
1096 n_vol_props += N_ELEMS_IN_VOLPROP_BLOCK;
1097 }
1098
1099 vol_props[volprop_ndx].prop = prop;
1100 vol_props[volprop_ndx].oidstr = oidstr;
1101 vol_props[volprop_ndx].row = row;
1102 vol_props[volprop_ndx].proptype = proptype;
1103
1104 volprop_ndx++;
1105 }
1106
1107 static void
1108 check_for_stale_data(boolean_t nocache)
1109 {
1110 int cur_change_time;
1111 int ret;
1112 int snmp_syserr;
1113
1114 (void) rw_wrlock(&stale_tree_rwlp);
1115
1116 /*
1117 * Check if some other thread beat us to it
1118 */
1119 if (stale_tree == B_TRUE) {
1120 (void) rw_unlock(&stale_tree_rwlp);
1121 return;
1122 }
1123
1124 /*
1125 * Cache OID_entLastChangeTime for up to 10 seconds before
1126 * fetching it from ILOM again. This prevents us from fetching
1127 * this value from ILOM when the we're filling or refreshing a
1128 * whole bunch of items in the cache around the same time.
1129 */
1130 if (nocache == B_FALSE && time(NULL) - change_time_check <= 10) {
1131 (void) rw_unlock(&stale_tree_rwlp);
1132 return;
1133 }
1134
1135 /*
1136 * Check if mib data has changed (hotplug? link-reset?)
1137 */
1138 do {
1139 snmp_syserr = 0;
1140 ret = snmp_get_int(hdl, OID_entLastChangeTime, 0,
1141 &cur_change_time, &snmp_syserr);
1142 (void) time(&change_time_check);
1143 if ((ret == 0) && (cur_change_time == change_time)) {
1144 (void) rw_unlock(&stale_tree_rwlp);
1145 return;
1146 }
1147 } while (ret != 0 && snmp_syserr == EINTR);
1148
1149 /*
1150 * If we can't read entLastChangeTime we assume we need to rebuild
1151 * the tree. This will also cover the case when we need to rebuild
1152 * the tree because a link reset had happened.
1153 */
1154 LOGPRINTF2("check_for_stale_data: LastChange times have changed, "
1155 "(%#x != %#x)\n", change_time, cur_change_time);
1156
1157 /*
1158 * If the mib data has changed, we need to rebuild the physical-platform
1159 * subtree. To do this, we set a flag to mark the tree stale,
1160 * so that any future reads to get value of volatile properties will
1161 * return PICL_PROPVALUNAVAILABLE, until the stale_tree flag
1162 * is reset by the tree builder thread.
1163 */
1164 stale_tree = B_TRUE;
1165 if (vol_props) {
1166 free(vol_props);
1167 }
1168 vol_props = NULL;
1169 volprop_ndx = 0;
1170 n_vol_props = 0;
1171
1172 (void) rw_unlock(&stale_tree_rwlp);
1173
1174 (void) mutex_lock(&rebuild_tree_lock);
1175 rebuild_tree = B_TRUE;
1176 (void) cond_signal(&rebuild_tree_cv);
1177 LOGPRINTF("check_for_stale_data: signalled tree builder\n");
1178 (void) mutex_unlock(&rebuild_tree_lock);
1179 }
1180
1181 /*
1182 * This is the critical routine. This callback is invoked by picl whenever
1183 * it needs to fetch the value of a volatile property. The first thing we
1184 * must do, however, is to see if there has been a hotplug or a link-reset
1185 * event since the last time we built the tree and whether we need to
1186 * rebuild the tree. If so, we do whatever is necessary to make that happen,
1187 * but return PICL_PROPVALUNAVAILABLE for now, without making any further
1188 * snmp requests or accessing any globals.
1189 */
1190 static int
1191 read_volprop(ptree_rarg_t *parg, void *buf)
1192 {
1193 char *pstr;
1194 int propval;
1195 int i, ndx;
1196 int ret;
1197 int snmp_syserr = 0;
1198
1199 /*
1200 * First check for any event that would make us throw away
1201 * the existing /physical-platform subtree and rebuild
1202 * another one. If we are rebuilding the subtree, we just
1203 * return the stale value until the tree is fully built.
1204 */
1205 check_for_stale_data(B_FALSE);
1206
1207 (void) rw_rdlock(&stale_tree_rwlp);
1208
1209 if (stale_tree == B_TRUE) {
1210 (void) rw_unlock(&stale_tree_rwlp);
1211 return (PICL_PROPVALUNAVAILABLE);
1212 }
1213
1214 for (i = 0; i < volprop_ndx; i++) {
1215 if (vol_props[i].prop == parg->proph) {
1216 ndx = i;
1217 break;
1218 }
1219 }
1220 if (i == volprop_ndx) {
1221 (void) rw_unlock(&stale_tree_rwlp);
1222 log_msg(LOG_ERR, SNMPP_CANT_FIND_VOLPROP, parg->proph);
1223 return (PICL_FAILURE);
1224 }
1225
1226 /*
1227 * If we can't read the value, return failure. Even if this was
1228 * due to a link reset, between the check for stale data and now,
1229 * the next volatile callback by picl will initiate a tree-rebuild.
1230 */
1231 ret = snmp_get_int(hdl, vol_props[ndx].oidstr, vol_props[ndx].row,
1232 &propval, &snmp_syserr);
1233 if (ret < 0) {
1234 (void) rw_unlock(&stale_tree_rwlp);
1235 check_for_stale_data(B_TRUE);
1236 if (stale_tree == B_TRUE) {
1237 return (PICL_PROPVALUNAVAILABLE);
1238 }
1239 log_msg(LOG_ERR, SNMPP_CANT_FETCH_OBJECT_VAL,
1240 snmp_syserr ? snmp_syserr : ret,
1241 vol_props[ndx].oidstr, vol_props[ndx].row);
1242 return (PICL_FAILURE);
1243 }
1244
1245 switch (vol_props[ndx].proptype) {
1246 case VPT_PLATOPSTATE:
1247 if (propval == SSOS_DISABLED) {
1248 (void) strlcpy(buf, STR_SSOS_DISABLED, MAX_OPSTATE_LEN);
1249 } else if (propval == SSOS_ENABLED) {
1250 (void) strlcpy(buf, STR_SSOS_ENABLED, MAX_OPSTATE_LEN);
1251 } else {
1252 (void) rw_unlock(&stale_tree_rwlp);
1253 log_msg(LOG_ERR, SNMPP_INV_PLAT_EQUIP_OPSTATE,
1254 propval, vol_props[ndx].row);
1255 return (PICL_FAILURE);
1256 }
1257 break;
1258
1259 case VPT_NUMSENSOR:
1260 (void) memcpy(buf, &propval, sizeof (propval));
1261 break;
1262
1263 case VPT_BINSENSOR:
1264 if (propval == ST_TRUE) {
1265 ret = snmp_get_str(hdl,
1266 OID_sunPlatBinarySensorInterpretTrue,
1267 vol_props[ndx].row, &pstr, &snmp_syserr);
1268 if (snmp_syserr == ECANCELED) {
1269 (void) rw_unlock(&stale_tree_rwlp);
1270 if (pstr)
1271 free(pstr);
1272 return (PICL_FAILURE);
1273 }
1274 if (ret < 0 || pstr == NULL) {
1275 log_msg(LOG_ERR, SNMPP_CANT_FETCH_OBJECT_VAL,
1276 snmp_syserr ? snmp_syserr : ret,
1277 OID_sunPlatBinarySensorInterpretTrue,
1278 vol_props[ndx].row);
1279 (void) strlcpy(buf, STR_ST_TRUE,
1280 MAX_TRUTHVAL_LEN);
1281 } else {
1282 (void) strlcpy(buf, pstr, MAX_TRUTHVAL_LEN);
1283 }
1284 if (pstr)
1285 free(pstr);
1286 } else if (propval == ST_FALSE) {
1287 ret = snmp_get_str(hdl,
1288 OID_sunPlatBinarySensorInterpretFalse,
1289 vol_props[ndx].row, &pstr, &snmp_syserr);
1290 if (snmp_syserr == ECANCELED) {
1291 (void) rw_unlock(&stale_tree_rwlp);
1292 if (pstr)
1293 free(pstr);
1294 return (PICL_FAILURE);
1295 }
1296 if (ret < 0 || pstr == NULL) {
1297 log_msg(LOG_ERR, SNMPP_CANT_FETCH_OBJECT_VAL,
1298 snmp_syserr ? snmp_syserr : ret,
1299 OID_sunPlatBinarySensorInterpretFalse,
1300 vol_props[ndx].row);
1301 (void) strlcpy(buf, STR_ST_FALSE,
1302 MAX_TRUTHVAL_LEN);
1303 } else {
1304 (void) strlcpy(buf, pstr, MAX_TRUTHVAL_LEN);
1305 }
1306 if (pstr)
1307 free(pstr);
1308 } else {
1309 (void) rw_unlock(&stale_tree_rwlp);
1310 log_msg(LOG_ERR, SNMPP_INV_PLAT_BINSNSR_CURRENT,
1311 propval, vol_props[ndx].row);
1312 return (PICL_FAILURE);
1313 }
1314 break;
1315
1316 case VPT_ALARMSTATE:
1317 if (propval == SSAS_OFF) {
1318 (void) strlcpy(buf, STR_SSAS_OFF, MAX_ALARMSTATE_LEN);
1319 } else if (propval == SSAS_STEADY) {
1320 (void) strlcpy(buf, STR_SSAS_STEADY,
1321 MAX_ALARMSTATE_LEN);
1322 } else if (propval == SSAS_ALTERNATING) {
1323 (void) strlcpy(buf, STR_SSAS_ALTERNATING,
1324 MAX_ALARMSTATE_LEN);
1325 } else {
1326 (void) strlcpy(buf, STR_SSAS_UNKNOWN,
1327 MAX_ALARMSTATE_LEN);
1328 }
1329 break;
1330
1331 case VPT_BATTERYSTATUS:
1332 switch (propval) {
1333 case SSBS_OTHER:
1334 (void) strlcpy(buf, STR_SSBS_OTHER,
1335 MAX_BATTERYSTATUS_LEN);
1336 break;
1337 case SSBS_FULLYCHARGED:
1338 (void) strlcpy(buf, STR_SSBS_FULLYCHARGED,
1339 MAX_BATTERYSTATUS_LEN);
1340 break;
1341 case SSBS_LOW:
1342 (void) strlcpy(buf, STR_SSBS_LOW,
1343 MAX_BATTERYSTATUS_LEN);
1344 break;
1345 case SSBS_CRITICAL:
1346 (void) strlcpy(buf, STR_SSBS_CRITICAL,
1347 MAX_BATTERYSTATUS_LEN);
1348 break;
1349 case SSBS_CHARGING:
1350 (void) strlcpy(buf, STR_SSBS_CHARGING,
1351 MAX_BATTERYSTATUS_LEN);
1352 break;
1353 case SSBS_CHARGING_AND_LOW:
1354 (void) strlcpy(buf, STR_SSBS_CHARGING_AND_LOW,
1355 MAX_BATTERYSTATUS_LEN);
1356 break;
1357 case SSBS_CHARGING_AND_HIGH:
1358 (void) strlcpy(buf, STR_SSBS_CHARGING_AND_HIGH,
1359 MAX_BATTERYSTATUS_LEN);
1360 break;
1361 case SSBS_CHARGING_AND_CRITICAL:
1362 (void) strlcpy(buf, STR_SSBS_CHARGING_AND_CRITICAL,
1363 MAX_BATTERYSTATUS_LEN);
1364 break;
1365 case SSBS_UNDEFINED:
1366 (void) strlcpy(buf, STR_SSBS_UNDEFINED,
1367 MAX_BATTERYSTATUS_LEN);
1368 break;
1369 case SSBS_PARTIALLY_CHARGED:
1370 (void) strlcpy(buf, STR_SSBS_PARTIALLY_CHARGED,
1371 MAX_BATTERYSTATUS_LEN);
1372 break;
1373 case SSBS_UNKNOWN:
1374 default:
1375 (void) strlcpy(buf, STR_SSBS_UNKNOWN,
1376 MAX_BATTERYSTATUS_LEN);
1377 break;
1378 }
1379 break;
1380 }
1381
1382 (void) rw_unlock(&stale_tree_rwlp);
1383
1384 return (PICL_SUCCESS);
1385 }
1386
1387 static void
1388 threshold(picl_nodehdl_t node, char *oidstr, int row, char *propname,
1389 int *snmp_syserr_p)
1390 {
1391 picl_prophdl_t prop;
1392 int err;
1393 int val;
1394
1395 if ((err = snmp_get_int(hdl, oidstr, row, &val, snmp_syserr_p)) != -1) {
1396 err = add_volatile_prop(node, propname, PICL_PTYPE_INT,
1397 PICL_READ, sizeof (int), read_volprop, NULL, &prop);
1398 if (err == PICL_SUCCESS)
1399 save_volprop(prop, oidstr, row, VPT_NUMSENSOR);
1400 } else
1401 log_msg(LOG_ERR, SNMPP_CANT_FETCH_OBJECT_VAL,
1402 *snmp_syserr_p ? *snmp_syserr_p : err, oidstr, row);
1403 }
1404
1405 static void
1406 add_thresholds(picl_nodehdl_t node, int row, int *snmp_syserr_p)
1407 {
1408 uchar_t *bitstr = NULL;
1409 uchar_t enabled;
1410 uint_t nbytes;
1411 int ret;
1412
1413 ret = snmp_get_str(hdl,
1414 OID_sunPlatNumericSensorEnabledThresholds,
1415 row, (char **)&bitstr, snmp_syserr_p);
1416 if (ret == -1) {
1417 log_msg(LOG_ERR, SNMPP_CANT_FETCH_OBJECT_VAL,
1418 *snmp_syserr_p ? *snmp_syserr_p : ret,
1419 OID_sunPlatNumericSensorEnabledThresholds, row);
1420 } else {
1421 nbytes = strlen((const char *)bitstr);
1422 }
1423
1424 CHECK_LINKRESET_VOID(snmp_syserr_p);
1425
1426 /*
1427 * No bit string of threshold masks was returned, so we can't
1428 * assume that any thresholds exist.
1429 *
1430 * This mask prevents us from attempting to fetch thresholds
1431 * which don't apply to the sensor or that aren't there anyway,
1432 * That speeds up the plug-in significantly since otherwise it
1433 * takes several seconds to time out.
1434 */
1435 if (ret < 0 || bitstr == NULL || nbytes == 0 || 2 < nbytes) {
1436 if (bitstr)
1437 free(bitstr);
1438 return;
1439 } else if (nbytes == 1) {
1440 /*
1441 * The ALOM snmp agent doesn't adhere to the BER rules for
1442 * encoding bit strings. While the BER states that bitstrings
1443 * must begin from the second octet after length, and the
1444 * first octet after length must indicate the number of unused
1445 * bits in the last octet, the snmp agent simply sends the
1446 * bitstring data as if it were octet string -- that is, the
1447 * "unused bits" octet is missing.
1448 */
1449 enabled = bitstr[0];
1450 } else if (nbytes == 2)
1451 enabled = bitstr[1];
1452
1453 if (bitstr) {
1454 free(bitstr);
1455 }
1456
1457 if (enabled & LOWER_FATAL) {
1458 threshold(node,
1459 OID_sunPlatNumericSensorLowerThresholdFatal, row,
1460 PICL_PROP_LOW_POWER_OFF, snmp_syserr_p);
1461 CHECK_LINKRESET_VOID(snmp_syserr_p)
1462 }
1463 if (enabled & LOWER_CRITICAL) {
1464 threshold(node,
1465 OID_sunPlatNumericSensorLowerThresholdCritical, row,
1466 PICL_PROP_LOW_SHUTDOWN, snmp_syserr_p);
1467 CHECK_LINKRESET_VOID(snmp_syserr_p)
1468 }
1469 if (enabled & LOWER_NON_CRITICAL) {
1470 threshold(node,
1471 OID_sunPlatNumericSensorLowerThresholdNonCritical, row,
1472 PICL_PROP_LOW_WARNING, snmp_syserr_p);
1473 CHECK_LINKRESET_VOID(snmp_syserr_p)
1474 }
1475 if (enabled & UPPER_NON_CRITICAL) {
1476 threshold(node,
1477 OID_sunPlatNumericSensorUpperThresholdNonCritical, row,
1478 PICL_PROP_HIGH_WARNING, snmp_syserr_p);
1479 CHECK_LINKRESET_VOID(snmp_syserr_p)
1480 }
1481 if (enabled & UPPER_CRITICAL) {
1482 threshold(node,
1483 OID_sunPlatNumericSensorUpperThresholdCritical, row,
1484 PICL_PROP_HIGH_SHUTDOWN, snmp_syserr_p);
1485 CHECK_LINKRESET_VOID(snmp_syserr_p)
1486 }
1487 if (enabled & UPPER_FATAL) {
1488 threshold(node,
1489 OID_sunPlatNumericSensorUpperThresholdFatal, row,
1490 PICL_PROP_HIGH_POWER_OFF, snmp_syserr_p);
1491 CHECK_LINKRESET_VOID(snmp_syserr_p)
1492 }
1493 }
1494
1495 static char *
1496 get_slot_type(int row, int *snmp_syserr_p)
1497 {
1498 char *p;
1499 char *slott = NULL;
1500 int ret;
1501
1502 ret = snmp_get_str(hdl, OID_sunPlatEquipmentHolderAcceptableTypes,
1503 row, &p, snmp_syserr_p);
1504 CHECK_LINKRESET(snmp_syserr_p, NULL)
1505
1506 if ((ret == 0) && p && *p) {
1507 slott = p;
1508 if ((p = strchr(slott, '\n')) != NULL)
1509 *p = 0;
1510 } else {
1511 log_msg(LOG_WARNING, SNMPP_NO_SLOT_TYPE, row);
1512 if (p) {
1513 free(p);
1514 }
1515 }
1516
1517 return (slott);
1518 }
1519
1520 /*
1521 * Create and add the specified volatile property
1522 */
1523 static int
1524 add_volatile_prop(picl_nodehdl_t node, char *name, int type, int access,
1525 int size, int (*rdfunc)(ptree_rarg_t *, void *),
1526 int (*wrfunc)(ptree_warg_t *, const void *), picl_prophdl_t *propp)
1527 {
1528 ptree_propinfo_t propinfo;
1529 picl_prophdl_t prop;
1530 int err;
1531
1532 err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
1533 type, (access|PICL_VOLATILE), size, name, rdfunc, wrfunc);
1534 if (err != PICL_SUCCESS) {
1535 log_msg(LOG_ERR, SNMPP_CANT_INIT_PROPINFO, err);
1536 return (err);
1537 }
1538
1539 err = ptree_create_and_add_prop(node, &propinfo, NULL, &prop);
1540 if (err != PICL_SUCCESS) {
1541 log_msg(LOG_ERR, SNMPP_CANT_ADD_PROP, err, node);
1542 return (err);
1543 }
1544
1545 if (propp)
1546 *propp = prop;
1547
1548 return (PICL_SUCCESS);
1549 }
1550
1551 /*
1552 * Add the specified string property to the node
1553 */
1554 static int
1555 add_string_prop(picl_nodehdl_t node, char *propname, char *propval)
1556 {
1557 ptree_propinfo_t propinfo;
1558 int err;
1559
1560 if (*propval == '\0')
1561 return (PICL_SUCCESS);
1562
1563 err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
1564 PICL_PTYPE_CHARSTRING, PICL_READ, strlen(propval) + 1,
1565 propname, NULL, NULL);
1566 if (err != PICL_SUCCESS) {
1567 log_msg(LOG_ERR, SNMPP_CANT_INIT_STR_PROPINFO, err);
1568 return (err);
1569 }
1570
1571 err = ptree_create_and_add_prop(node, &propinfo, propval, NULL);
1572 if (err != PICL_SUCCESS) {
1573 log_msg(LOG_ERR, SNMPP_CANT_ADD_STR_PROP, err, node);
1574 return (err);
1575 }
1576
1577 return (PICL_SUCCESS);
1578 }
1579
1580 /*
1581 * Add the specified void property to the node
1582 */
1583 static int
1584 add_void_prop(picl_nodehdl_t node, char *propname)
1585 {
1586 ptree_propinfo_t propinfo;
1587 int err;
1588
1589 err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
1590 PICL_PTYPE_VOID, PICL_READ, 0, propname, NULL, NULL);
1591 if (err != PICL_SUCCESS) {
1592 log_msg(LOG_ERR, SNMPP_CANT_INIT_VOID_PROPINFO, err);
1593 return (err);
1594 }
1595
1596 err = ptree_create_and_add_prop(node, &propinfo, NULL, NULL);
1597 if (err != PICL_SUCCESS) {
1598 log_msg(LOG_ERR, SNMPP_CANT_ADD_VOID_PROP, err, node);
1599 return (err);
1600 }
1601
1602 return (PICL_SUCCESS);
1603 }
1604
1605 static void
1606 add_prop(picl_nodehdl_t nodeh, picl_prophdl_t *php, char *label,
1607 int row, sp_propid_t pp, int *snmp_syserr_p)
1608 {
1609 char *serial_num;
1610 char *slot_type;
1611 char *fw_revision, *hw_revision;
1612 char *mfg_name, *model_name;
1613 char *phys_descr;
1614 int val;
1615 int ret;
1616
1617 switch (pp) {
1618 case PP_SERIAL_NUM:
1619 ret = snmp_get_str(hdl, OID_entPhysicalSerialNum,
1620 row, &serial_num, snmp_syserr_p);
1621 CHECK_LINKRESET_VOID(snmp_syserr_p)
1622 if ((ret == 0) && serial_num) {
1623 (void) add_string_prop(nodeh,
1624 PICL_PROP_SERIAL_NUMBER, serial_num);
1625 free((void *) serial_num);
1626 }
1627 if (ret == -1)
1628 log_msg(LOG_ERR, SNMPP_CANT_FETCH_OBJECT_VAL,
1629 *snmp_syserr_p ? *snmp_syserr_p : ret,
1630 OID_entPhysicalSerialNum, row);
1631 break;
1632
1633 case PP_SLOT_TYPE:
1634 if ((slot_type = get_slot_type(row, snmp_syserr_p)) == NULL) {
1635 CHECK_LINKRESET_VOID(snmp_syserr_p)
1636 (void) add_string_prop(nodeh,
1637 PICL_PROP_SLOT_TYPE, DEFAULT_SLOT_TYPE);
1638 } else {
1639 (void) add_string_prop(nodeh,
1640 PICL_PROP_SLOT_TYPE, slot_type);
1641 free((void *) slot_type);
1642 }
1643 break;
1644
1645 case PP_STATE:
1646 ret = add_volatile_prop(nodeh, PICL_PROP_STATE,
1647 PICL_PTYPE_CHARSTRING, PICL_READ, MAX_ALARMSTATE_LEN,
1648 read_volprop, NULL, php);
1649 if (ret == PICL_SUCCESS) {
1650 save_volprop(*php, OID_sunPlatAlarmState, row,
1651 VPT_ALARMSTATE);
1652 }
1653 break;
1654
1655 case PP_OPSTATUS:
1656 ret = add_volatile_prop(nodeh, PICL_PROP_OPERATIONAL_STATUS,
1657 PICL_PTYPE_CHARSTRING, PICL_READ, MAX_OPSTATE_LEN,
1658 read_volprop, NULL, php);
1659 if (ret == PICL_SUCCESS) {
1660 save_volprop(*php,
1661 OID_sunPlatEquipmentOperationalState, row,
1662 VPT_PLATOPSTATE);
1663 }
1664 break;
1665
1666 case PP_BATT_STATUS:
1667 ret = add_volatile_prop(nodeh, PICL_PROP_BATTERY_STATUS,
1668 PICL_PTYPE_CHARSTRING, PICL_READ, MAX_BATTERYSTATUS_LEN,
1669 read_volprop, NULL, php);
1670 if (ret == PICL_SUCCESS) {
1671 save_volprop(*php, OID_sunPlatBatteryStatus, row,
1672 VPT_BATTERYSTATUS);
1673 }
1674 break;
1675
1676 case PP_TEMPERATURE:
1677 ret = add_volatile_prop(nodeh, PICL_PROP_TEMPERATURE,
1678 PICL_PTYPE_INT, PICL_READ, sizeof (int), read_volprop,
1679 NULL, php);
1680 if (ret == PICL_SUCCESS) {
1681 save_volprop(*php, OID_sunPlatNumericSensorCurrent,
1682 row, VPT_NUMSENSOR);
1683 }
1684 break;
1685
1686 case PP_VOLTAGE:
1687 ret = add_volatile_prop(nodeh, PICL_PROP_VOLTAGE,
1688 PICL_PTYPE_INT, PICL_READ, sizeof (int), read_volprop,
1689 NULL, php);
1690 if (ret == PICL_SUCCESS) {
1691 save_volprop(*php, OID_sunPlatNumericSensorCurrent,
1692 row, VPT_NUMSENSOR);
1693 }
1694 break;
1695
1696 case PP_CURRENT:
1697 ret = add_volatile_prop(nodeh, PICL_PROP_CURRENT,
1698 PICL_PTYPE_INT, PICL_READ, sizeof (int), read_volprop,
1699 NULL, php);
1700 if (ret == PICL_SUCCESS) {
1701 save_volprop(*php, OID_sunPlatNumericSensorCurrent,
1702 row, VPT_NUMSENSOR);
1703 }
1704 break;
1705
1706 case PP_SPEED:
1707 ret = add_volatile_prop(nodeh, PICL_PROP_SPEED, PICL_PTYPE_INT,
1708 PICL_READ, sizeof (int), read_volprop, NULL, php);
1709 if (ret == PICL_SUCCESS) {
1710 save_volprop(*php, OID_sunPlatNumericSensorCurrent,
1711 row, VPT_NUMSENSOR);
1712 }
1713 break;
1714
1715 case PP_SENSOR_VALUE:
1716 ret = add_volatile_prop(nodeh, PICL_PROP_SENSOR_VALUE,
1717 PICL_PTYPE_INT, PICL_READ, sizeof (int), read_volprop,
1718 NULL, php);
1719 if (ret == PICL_SUCCESS) {
1720 save_volprop(*php, OID_sunPlatNumericSensorCurrent,
1721 row, VPT_NUMSENSOR);
1722 }
1723 break;
1724
1725 case PP_CONDITION:
1726 ret = add_volatile_prop(nodeh, PICL_PROP_CONDITION,
1727 PICL_PTYPE_CHARSTRING, PICL_READ, MAX_TRUTHVAL_LEN,
1728 read_volprop, NULL, php);
1729 if (ret == PICL_SUCCESS) {
1730 save_volprop(*php, OID_sunPlatBinarySensorCurrent,
1731 row, VPT_BINSENSOR);
1732 }
1733 break;
1734
1735 case PP_EXPECTED:
1736 ret = add_volatile_prop(nodeh, PICL_PROP_EXPECTED,
1737 PICL_PTYPE_CHARSTRING, PICL_READ, MAX_TRUTHVAL_LEN,
1738 read_volprop, NULL, php);
1739 if (ret == PICL_SUCCESS) {
1740 save_volprop(*php, OID_sunPlatBinarySensorExpected,
1741 row, VPT_BINSENSOR);
1742 }
1743 break;
1744
1745 case PP_EXPONENT:
1746 ret = add_volatile_prop(nodeh, PICL_PROP_EXPONENT,
1747 PICL_PTYPE_INT, PICL_READ, sizeof (int), read_volprop,
1748 NULL, php);
1749 if (ret == PICL_SUCCESS) {
1750 save_volprop(*php, OID_sunPlatNumericSensorExponent,
1751 row, VPT_NUMSENSOR);
1752 }
1753 break;
1754
1755 case PP_REPLACEABLE:
1756 ret = snmp_get_int(hdl, OID_sunPlatCircuitPackReplaceable,
1757 row, &val, snmp_syserr_p);
1758 CHECK_LINKRESET_VOID(snmp_syserr_p)
1759 if ((ret == 0) && (val == ST_TRUE))
1760 (void) add_void_prop(nodeh, PICL_PROP_IS_REPLACEABLE);
1761 if (ret == -1)
1762 log_msg(LOG_ERR, SNMPP_CANT_FETCH_OBJECT_VAL,
1763 *snmp_syserr_p ? *snmp_syserr_p : ret,
1764 OID_sunPlatCircuitPackReplaceable, row);
1765 break;
1766
1767 case PP_HOTSWAPPABLE:
1768 ret = snmp_get_int(hdl, OID_sunPlatCircuitPackHotSwappable,
1769 row, &val, snmp_syserr_p);
1770 CHECK_LINKRESET_VOID(snmp_syserr_p)
1771 if ((ret == 0) && (val == ST_TRUE))
1772 (void) add_void_prop(nodeh, PICL_PROP_IS_HOT_SWAPPABLE);
1773 if (ret == -1)
1774 log_msg(LOG_ERR, SNMPP_CANT_FETCH_OBJECT_VAL,
1775 *snmp_syserr_p ? *snmp_syserr_p : ret,
1776 OID_sunPlatCircuitPackHotSwappable, row);
1777 break;
1778
1779 case PP_IS_FRU:
1780 ret = snmp_get_int(hdl, OID_entPhysicalIsFRU, row,
1781 &val, snmp_syserr_p);
1782 CHECK_LINKRESET_VOID(snmp_syserr_p)
1783 if ((ret == 0) && (val == ST_TRUE))
1784 (void) add_void_prop(nodeh, PICL_PROP_IS_FRU);
1785 if (ret == -1)
1786 log_msg(LOG_ERR, SNMPP_CANT_FETCH_OBJECT_VAL,
1787 *snmp_syserr_p ? *snmp_syserr_p : ret,
1788 OID_entPhysicalIsFRU, row);
1789 break;
1790
1791 case PP_HW_REVISION:
1792 ret = snmp_get_str(hdl, OID_entPhysicalHardwareRev,
1793 row, &hw_revision, snmp_syserr_p);
1794 CHECK_LINKRESET_VOID(snmp_syserr_p)
1795 if ((ret == 0) && hw_revision) {
1796 (void) add_string_prop(nodeh,
1797 PICL_PROP_HW_REVISION, hw_revision);
1798 free((void *) hw_revision);
1799 }
1800 if (ret == -1)
1801 log_msg(LOG_ERR, SNMPP_CANT_FETCH_OBJECT_VAL,
1802 *snmp_syserr_p ? *snmp_syserr_p : ret,
1803 OID_entPhysicalHardwareRev, row);
1804 break;
1805
1806 case PP_FW_REVISION:
1807 ret = snmp_get_str(hdl, OID_entPhysicalFirmwareRev,
1808 row, &fw_revision, snmp_syserr_p);
1809 CHECK_LINKRESET_VOID(snmp_syserr_p)
1810 if ((ret == 0) && fw_revision) {
1811 (void) add_string_prop(nodeh,
1812 PICL_PROP_FW_REVISION, fw_revision);
1813 free((void *) fw_revision);
1814 }
1815 if (ret == -1)
1816 log_msg(LOG_ERR, SNMPP_CANT_FETCH_OBJECT_VAL,
1817 *snmp_syserr_p ? *snmp_syserr_p : ret,
1818 OID_entPhysicalFirmwareRev, row);
1819 break;
1820
1821 case PP_MFG_NAME:
1822 ret = snmp_get_str(hdl, OID_entPhysicalMfgName,
1823 row, &mfg_name, snmp_syserr_p);
1824 CHECK_LINKRESET_VOID(snmp_syserr_p)
1825 if ((ret == 0) && mfg_name) {
1826 (void) add_string_prop(nodeh,
1827 PICL_PROP_MFG_NAME, mfg_name);
1828 free((void *) mfg_name);
1829 }
1830 if (ret == -1)
1831 log_msg(LOG_ERR, SNMPP_CANT_FETCH_OBJECT_VAL,
1832 *snmp_syserr_p ? *snmp_syserr_p : ret,
1833 OID_entPhysicalMfgName, row);
1834 break;
1835
1836 case PP_MODEL_NAME:
1837 ret = snmp_get_str(hdl, OID_entPhysicalModelName,
1838 row, &model_name, snmp_syserr_p);
1839 CHECK_LINKRESET_VOID(snmp_syserr_p)
1840 if ((ret == 0) && model_name) {
1841 (void) add_string_prop(nodeh,
1842 PICL_PROP_MODEL_NAME, model_name);
1843 free((void *) model_name);
1844 }
1845 if (ret == -1)
1846 log_msg(LOG_ERR, SNMPP_CANT_FETCH_OBJECT_VAL,
1847 *snmp_syserr_p ? *snmp_syserr_p : ret,
1848 OID_entPhysicalModelName, row);
1849 break;
1850
1851 case PP_DESCRIPTION:
1852 ret = snmp_get_str(hdl, OID_entPhysicalDescr,
1853 row, &phys_descr, snmp_syserr_p);
1854 CHECK_LINKRESET_VOID(snmp_syserr_p)
1855 if ((ret == 0) && phys_descr) {
1856 (void) add_string_prop(nodeh,
1857 PICL_PROP_PHYS_DESCRIPTION, phys_descr);
1858 free((void *) phys_descr);
1859 }
1860 if (ret == -1)
1861 log_msg(LOG_ERR, SNMPP_CANT_FETCH_OBJECT_VAL,
1862 *snmp_syserr_p ? *snmp_syserr_p : ret,
1863 OID_entPhysicalDescr, row);
1864 break;
1865
1866 case PP_LABEL:
1867 if (label && *label)
1868 (void) add_string_prop(nodeh, PICL_PROP_LABEL, label);
1869 break;
1870
1871 case PP_BASE_UNITS:
1872 ret = snmp_get_int(hdl, OID_sunPlatNumericSensorBaseUnits,
1873 row, &val, snmp_syserr_p);
1874 CHECK_LINKRESET_VOID(snmp_syserr_p)
1875 if ((ret == 0) && (val > 0) && (val < n_baseunits)) {
1876 (void) add_string_prop(nodeh,
1877 PICL_PROP_BASE_UNITS, sensor_baseunits[val]);
1878 }
1879 if (ret == -1)
1880 log_msg(LOG_ERR, SNMPP_CANT_FETCH_OBJECT_VAL,
1881 *snmp_syserr_p ? *snmp_syserr_p : ret,
1882 OID_sunPlatNumericSensorBaseUnits, row);
1883 break;
1884
1885 case PP_RATE_UNITS:
1886 ret = snmp_get_int(hdl, OID_sunPlatNumericSensorRateUnits,
1887 row, &val, snmp_syserr_p);
1888 CHECK_LINKRESET_VOID(snmp_syserr_p)
1889 if ((ret == 0) && (val > 0) && (val < n_rateunits)) {
1890 (void) add_string_prop(nodeh,
1891 PICL_PROP_RATE_UNITS, sensor_rateunits[val]);
1892 }
1893 if (ret == -1)
1894 log_msg(LOG_ERR, SNMPP_CANT_FETCH_OBJECT_VAL,
1895 *snmp_syserr_p ? *snmp_syserr_p : ret,
1896 OID_sunPlatNumericSensorRateUnits, row);
1897 break;
1898 }
1899 }
1900
1901 /*
1902 * Initialize the SNMP library's cache refresh subsystem, then periodically
1903 * process refresh job to prevent cache entries from expiring.
1904 */
1905 /*ARGSUSED*/
1906 static void *
1907 cache_refresher(void *arg)
1908 {
1909 int jobs;
1910 int next_expiration;
1911 timestruc_t to;
1912 hrtime_t cycle_start, cycle_elapsed;
1913
1914 /*
1915 * Initialize refresh subsystem
1916 */
1917 LOGPRINTF("Initializing SNMP refresh subsystem.\n");
1918 if (snmp_refresh_init() < 0) {
1919 return ((void *)-1);
1920 }
1921
1922 (void) mutex_lock(&cache_refresh_lock);
1923
1924
1925 for (;;) {
1926 cycle_start = gethrtime();
1927
1928 /*
1929 * Process jobs from the snmp cache refresh work queue until one
1930 * of the following conditions is true:
1931 * 1) we are told to exit, or
1932 * 2) we have processed at least as many jobs as recommended by
1933 * the library, and the next job expiration is at least
1934 * CACHE_REFRESH_MIN_WINDOW * seconds away.
1935 */
1936 jobs = snmp_refresh_get_cycle_hint(CACHE_REFRESH_CYCLE);
1937 while ((cache_refresh_thr_exit == B_FALSE) && (jobs > 0)) {
1938 (void) snmp_refresh_process_job();
1939 jobs--;
1940 }
1941
1942 next_expiration = snmp_refresh_get_next_expiration();
1943 while ((cache_refresh_thr_exit == B_FALSE) &&
1944 ((next_expiration >= 0) &&
1945 (next_expiration < CACHE_REFRESH_MIN_WINDOW))) {
1946 (void) snmp_refresh_process_job();
1947 next_expiration = snmp_refresh_get_next_expiration();
1948 }
1949
1950 /*
1951 * As long as we haven't been told to exit, sleep for
1952 * CACHE_REFRESH_CYCLE seconds minus the amount of time that has
1953 * elapsed since this cycle started. If the elapsed time is
1954 * equal to or greater than 60 seconds, skip sleeping entirely.
1955 */
1956 cycle_elapsed = (gethrtime() - cycle_start) / NANOSEC;
1957 if ((cache_refresh_thr_exit == B_FALSE) &&
1958 (cycle_elapsed < CACHE_REFRESH_CYCLE)) {
1959 to.tv_sec = CACHE_REFRESH_CYCLE - cycle_elapsed;
1960 to.tv_nsec = 0;
1961 (void) cond_reltimedwait(&cache_refresh_cv,
1962 &cache_refresh_lock, &to);
1963 }
1964
1965 /*
1966 * If we have been told to exit, clean up and bail out.
1967 */
1968 if (cache_refresh_thr_exit == B_TRUE) {
1969 snmp_refresh_fini();
1970 (void) mutex_unlock(&cache_refresh_lock);
1971 LOGPRINTF("cache_refresher: time to exit\n");
1972 return (NULL);
1973 }
1974
1975 }
1976
1977 /*NOTREACHED*/
1978 return (NULL);
1979 }
1980
1981 /*
1982 * Check to see if the cache_refresher thread is running. If it is, signal it
1983 * to terminate and clean up associated data structures.
1984 */
1985 void
1986 cache_refresher_fini(void)
1987 {
1988 /* if the thread isn't running, there is nothing to do */
1989 if (cache_refresh_thr_exit == B_TRUE)
1990 return;
1991
1992 /* wake up the cache_refresher thread, tell it to exit */
1993 (void) mutex_lock(&cache_refresh_lock);
1994 cache_refresh_thr_exit = B_TRUE;
1995 (void) cond_signal(&cache_refresh_cv);
1996 (void) mutex_unlock(&cache_refresh_lock);
1997
1998 /* reap the thread */
1999 (void) thr_join(cache_refresh_thr_id, NULL, NULL);
2000
2001 /* finish cleanup... */
2002 (void) cond_destroy(&cache_refresh_cv);
2003 (void) mutex_destroy(&cache_refresh_lock);
2004 }
2005
2006 /*VARARGS2*/
2007 static void
2008 log_msg(int pri, const char *fmt, ...)
2009 {
2010 va_list ap;
2011
2012 va_start(ap, fmt);
2013 vsyslog(pri, fmt, ap);
2014 va_end(ap);
2015 }
2016
2017 #ifdef SNMPPLUGIN_DEBUG
2018
2019 static void
2020 snmpplugin_log_init(void)
2021 {
2022 (void) mutex_init(&snmpplugin_dbuf_lock, USYNC_THREAD, NULL);
2023 }
2024
2025 static void
2026 snmpplugin_log(const char *fmt, ...)
2027 {
2028 va_list ap;
2029
2030 (void) mutex_lock(&snmpplugin_dbuf_lock);
2031
2032 va_start(ap, fmt);
2033 (void) vsnprintf(snmpplugin_lbuf, SNMPPLUGIN_DMAX_LINE, fmt, ap);
2034 snmpplugin_log_append();
2035 va_end(ap);
2036
2037 (void) mutex_unlock(&snmpplugin_dbuf_lock);
2038 }
2039
2040 static void
2041 snmpplugin_log_append(void)
2042 {
2043 int len;
2044
2045 len = strlen(snmpplugin_lbuf);
2046
2047 if ((snmpplugin_dbuf_curp + len) >=
2048 (snmpplugin_dbuf + snmpplugin_dbuf_sz)) {
2049 snmpplugin_dbuf_realloc();
2050 if (snmpplugin_dbuf == NULL) {
2051 return;
2052 }
2053 }
2054
2055 (void) strcpy(snmpplugin_dbuf_curp, snmpplugin_lbuf);
2056 snmpplugin_dbuf_curp += len;
2057 }
2058
2059 static void
2060 snmpplugin_dbuf_realloc(void)
2061 {
2062 char *p;
2063 size_t offset = 0;
2064 size_t count;
2065
2066 count = snmpplugin_dbuf_sz + SNMPPLUGIN_DBLOCK_SZ;
2067 if ((p = (char *)calloc(count, 1)) == NULL) {
2068 snmpplugin_dbuf_overflow++;
2069 snmpplugin_dbuf_curp = snmpplugin_dbuf;
2070 return;
2071 }
2072
2073 if (snmpplugin_dbuf) {
2074 offset = snmpplugin_dbuf_curp - snmpplugin_dbuf;
2075 (void) memcpy(p, snmpplugin_dbuf, snmpplugin_dbuf_sz);
2076 free(snmpplugin_dbuf);
2077 }
2078
2079 snmpplugin_dbuf = p;
2080 snmpplugin_dbuf_sz += SNMPPLUGIN_DBLOCK_SZ;
2081
2082 snmpplugin_dbuf_curp = snmpplugin_dbuf + offset;
2083 }
2084 #endif
unleashed repo fork