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 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <pthread.h>
27 #include <assert.h>
28 #include <errno.h>
29 #include <dirent.h>
30 #include <limits.h>
31 #include <alloca.h>
32 #include <unistd.h>
33 #include <stdio.h>
34 #include <strings.h>
35
36 #include <topo_mod.h>
37
38 #include <topo_error.h>
39 #include <topo_module.h>
40 #include <topo_subr.h>
41 #include <topo_tree.h>
42
43 topo_imethod_t *
topo_method_lookup(tnode_t * node,const char * name)44 topo_method_lookup(tnode_t *node, const char *name)
45 {
46 topo_imethod_t *mp;
47
48 for (mp = topo_list_next(&node->tn_methods); mp != NULL;
49 mp = topo_list_next(mp)) {
50 if (strcmp(name, mp->tim_name) == 0) {
51 topo_node_unlock(node);
52 return (mp);
53 }
54 }
55
56 return (NULL);
57 }
58
59 /*
60 * Simple API to determine if the specified node supports a given topo method
61 * (specified by the method name and version). Returns true if supported, false
62 * otherwise.
63 */
64 boolean_t
topo_method_supported(tnode_t * node,const char * name,topo_version_t vers)65 topo_method_supported(tnode_t *node, const char *name, topo_version_t vers)
66 {
67 topo_imethod_t *mp;
68
69 topo_node_lock(node);
70 for (mp = topo_list_next(&node->tn_methods); mp != NULL;
71 mp = topo_list_next(mp)) {
72 if ((strcmp(name, mp->tim_name) == 0) &&
73 (vers == mp->tim_version)) {
74 topo_node_unlock(node);
75 return (B_TRUE);
76 }
77 }
78 topo_node_unlock(node);
79 return (B_FALSE);
80 }
81
82 static void
topo_method_enter(topo_imethod_t * mp)83 topo_method_enter(topo_imethod_t *mp)
84 {
85 (void) pthread_mutex_lock(&mp->tim_lock);
86
87 while (mp->tim_busy != 0)
88 (void) pthread_cond_wait(&mp->tim_cv, &mp->tim_lock);
89
90 ++mp->tim_busy;
91
92 (void) pthread_mutex_unlock(&mp->tim_lock);
93 }
94
95 static void
topo_method_exit(topo_imethod_t * mp)96 topo_method_exit(topo_imethod_t *mp)
97 {
98 (void) pthread_mutex_lock(&mp->tim_lock);
99 --mp->tim_busy;
100
101 assert(mp->tim_busy == 0);
102
103 (void) pthread_cond_broadcast(&mp->tim_cv);
104 (void) pthread_mutex_unlock(&mp->tim_lock);
105 }
106
107 static int
set_methregister_error(topo_mod_t * mod,tnode_t * node,topo_imethod_t * mp,int err)108 set_methregister_error(topo_mod_t *mod, tnode_t *node, topo_imethod_t *mp,
109 int err)
110 {
111 if (mp != NULL) {
112 topo_list_delete(&node->tn_methods, mp);
113 if (mp->tim_name != NULL)
114 topo_mod_strfree(mod, mp->tim_name);
115 if (mp->tim_desc != NULL)
116 topo_mod_strfree(mod, mp->tim_desc);
117
118 topo_mod_free(mod, mp, sizeof (topo_imethod_t));
119 }
120
121 topo_node_unlock(node);
122
123 topo_dprintf(mod->tm_hdl, TOPO_DBG_ERR,
124 "method registration failed for %s: %s\n",
125 mod->tm_name, topo_strerror(err));
126
127 return (topo_mod_seterrno(mod, err));
128 }
129
130 int
topo_method_register(topo_mod_t * mod,tnode_t * node,const topo_method_t * mp)131 topo_method_register(topo_mod_t *mod, tnode_t *node, const topo_method_t *mp)
132 {
133 topo_imethod_t *imp;
134 const topo_method_t *meth;
135
136 /*
137 * Initialize module methods
138 */
139 for (meth = &mp[0]; meth->tm_name != NULL; meth++) {
140
141 topo_node_lock(node);
142 if (topo_method_lookup(node, meth->tm_name) != NULL) {
143 topo_node_unlock(node);
144 continue;
145 }
146
147 if (meth->tm_stability < TOPO_STABILITY_INTERNAL ||
148 meth->tm_stability > TOPO_STABILITY_MAX ||
149 meth->tm_func == NULL)
150 return (set_methregister_error(mod, node, NULL,
151 ETOPO_METHOD_INVAL));
152
153 imp = topo_mod_zalloc(mod, sizeof (topo_imethod_t));
154 if (imp == NULL)
155 return (set_methregister_error(mod, node, imp,
156 ETOPO_METHOD_NOMEM));
157
158 if ((imp->tim_name = topo_mod_strdup(mod, meth->tm_name))
159 == NULL)
160 return (set_methregister_error(mod, node, imp,
161 ETOPO_METHOD_NOMEM));
162
163 if ((imp->tim_desc = topo_mod_strdup(mod, meth->tm_desc))
164 == NULL)
165 return (set_methregister_error(mod, node, imp,
166 ETOPO_METHOD_NOMEM));
167
168
169 imp->tim_stability = meth->tm_stability;
170 imp->tim_version = meth->tm_version;
171 imp->tim_func = meth->tm_func;
172 imp->tim_mod = mod;
173
174 topo_list_append(&node->tn_methods, imp);
175 topo_node_unlock(node);
176
177 topo_dprintf(mod->tm_hdl, TOPO_DBG_MODSVC,
178 "registered module %s method "
179 "%s for %s=%d\n", mod->tm_name, imp->tim_name,
180 topo_node_name(node), topo_node_instance(node));
181
182 }
183
184 return (0);
185 }
186
187 void
topo_method_unregister(topo_mod_t * mod,tnode_t * node,const char * name)188 topo_method_unregister(topo_mod_t *mod, tnode_t *node, const char *name)
189 {
190 topo_imethod_t *mp;
191
192 topo_node_lock(node);
193 for (mp = topo_list_next(&node->tn_methods); mp != NULL;
194 mp = topo_list_next(mp)) {
195 if (strcmp(name, mp->tim_name) == 0)
196 break;
197 }
198
199 if (mp == NULL) {
200 topo_node_unlock(node);
201 return;
202 }
203
204 topo_list_delete(&node->tn_methods, mp);
205 topo_node_unlock(node);
206
207 if (mp->tim_name != NULL)
208 topo_mod_strfree(mod, mp->tim_name);
209 if (mp->tim_desc != NULL)
210 topo_mod_strfree(mod, mp->tim_desc);
211
212 topo_mod_free(mod, mp, sizeof (topo_imethod_t));
213 }
214
215 void
topo_method_unregister_all(topo_mod_t * mod,tnode_t * node)216 topo_method_unregister_all(topo_mod_t *mod, tnode_t *node)
217 {
218 topo_imethod_t *mp;
219
220 topo_node_lock(node);
221 while ((mp = topo_list_next(&node->tn_methods)) != NULL) {
222 topo_list_delete(&node->tn_methods, mp);
223 if (mp->tim_name != NULL)
224 topo_mod_strfree(mod, mp->tim_name);
225 if (mp->tim_desc != NULL)
226 topo_mod_strfree(mod, mp->tim_desc);
227 topo_mod_free(mod, mp, sizeof (topo_imethod_t));
228 }
229 topo_node_unlock(node);
230 }
231
232
233 int
topo_method_call(tnode_t * node,const char * method,topo_version_t version,nvlist_t * in,nvlist_t ** out,int * err)234 topo_method_call(tnode_t *node, const char *method,
235 topo_version_t version, nvlist_t *in, nvlist_t **out, int *err)
236 {
237 int rc, save;
238 topo_imethod_t *mp;
239
240 for (mp = topo_list_next(&node->tn_methods); mp != NULL;
241 mp = topo_list_next(mp)) {
242 if (strcmp(method, mp->tim_name) != 0)
243 continue;
244
245 if (version < mp->tim_version) {
246 *err = ETOPO_METHOD_VEROLD;
247 return (-1);
248 } else if (version > mp->tim_version) {
249 *err = ETOPO_METHOD_VERNEW;
250 return (-1);
251 }
252
253 topo_method_enter(mp);
254 save = mp->tim_mod->tm_errno;
255 mp->tim_mod->tm_errno = 0;
256 if ((rc = mp->tim_func(mp->tim_mod, node, version, in, out))
257 < 0) {
258 if (mp->tim_mod->tm_errno == 0)
259 *err = ETOPO_METHOD_FAIL;
260 else
261 *err = mp->tim_mod->tm_errno;
262 }
263 mp->tim_mod->tm_errno = save;
264 topo_method_exit(mp);
265
266 return (rc);
267
268 }
269
270 *err = ETOPO_METHOD_NOTSUP;
271 return (-1);
272 }
273
274 int
topo_method_invoke(tnode_t * node,const char * method,topo_version_t version,nvlist_t * in,nvlist_t ** out,int * err)275 topo_method_invoke(tnode_t *node, const char *method,
276 topo_version_t version, nvlist_t *in, nvlist_t **out, int *err)
277 {
278 int rc;
279
280 topo_node_hold(node);
281 rc = topo_method_call(node, method, version, in, out, err);
282 topo_node_rele(node);
283
284 return (rc);
285 }
286
287 struct sensor_errinfo
288 {
289 boolean_t se_predictive;
290 boolean_t se_nonrecov;
291 uint32_t se_src;
292 };
293
294 static boolean_t
topo_sensor_failed(int32_t type,uint32_t state,struct sensor_errinfo * seinfo)295 topo_sensor_failed(int32_t type, uint32_t state, struct sensor_errinfo *seinfo)
296 {
297 boolean_t failed;
298
299 failed = B_FALSE;
300 /*
301 * Unless the sensor explicitely says otherwise, all failures are
302 * non-recoverable, hard failures, coming from an unknown source.
303 */
304 seinfo->se_predictive = B_FALSE;
305 seinfo->se_nonrecov = B_TRUE;
306 seinfo->se_src = TOPO_SENSOR_ERRSRC_UNKNOWN;
307
308 switch (type) {
309 case TOPO_SENSOR_TYPE_THRESHOLD_STATE:
310 if (state & (TOPO_SENSOR_STATE_THRESH_LOWER_NONREC |
311 TOPO_SENSOR_STATE_THRESH_UPPER_NONREC)) {
312 failed = B_TRUE;
313 } else if (state & (TOPO_SENSOR_STATE_THRESH_LOWER_CRIT |
314 TOPO_SENSOR_STATE_THRESH_UPPER_CRIT)) {
315 failed = B_TRUE;
316 seinfo->se_nonrecov = B_FALSE;
317 }
318 break;
319
320 case TOPO_SENSOR_TYPE_POWER_SUPPLY:
321 if (state & TOPO_SENSOR_STATE_POWER_SUPPLY_PREDFAIL) {
322 failed = B_TRUE;
323 seinfo->se_predictive = B_TRUE;
324 seinfo->se_src = TOPO_SENSOR_ERRSRC_INTERNAL;
325 } else if (state & TOPO_SENSOR_STATE_POWER_SUPPLY_FAILURE) {
326 failed = B_TRUE;
327 seinfo->se_src = TOPO_SENSOR_ERRSRC_INTERNAL;
328 } else if (state &
329 (TOPO_SENSOR_STATE_POWER_SUPPLY_INPUT_LOST |
330 TOPO_SENSOR_STATE_POWER_SUPPLY_INPUT_RANGE |
331 TOPO_SENSOR_STATE_POWER_SUPPLY_INPUT_RANGE_PRES)) {
332 seinfo->se_src = TOPO_SENSOR_ERRSRC_EXTERNAL;
333 failed = B_TRUE;
334 }
335 break;
336
337 case TOPO_SENSOR_TYPE_GENERIC_FAILURE:
338 if (state & TOPO_SENSOR_STATE_GENERIC_FAIL_NONRECOV) {
339 failed = B_TRUE;
340 } else if (state & TOPO_SENSOR_STATE_GENERIC_FAIL_CRITICAL) {
341 failed = B_TRUE;
342 seinfo->se_nonrecov = B_FALSE;
343 }
344 break;
345
346 case TOPO_SENSOR_TYPE_GENERIC_OK:
347 if (state & TOPO_SENSOR_STATE_GENERIC_OK_DEASSERTED)
348 failed = B_TRUE;
349 break;
350 case TOPO_SENSOR_TYPE_GENERIC_PREDFAIL:
351 if (state & TOPO_SENSOR_STATE_GENERIC_PREDFAIL_ASSERTED) {
352 failed = B_TRUE;
353 seinfo->se_predictive = B_TRUE;
354 }
355 break;
356 }
357
358 return (failed);
359 }
360
361 /*
362 * Determine whether there are any sensors indicating failure. This function
363 * is used internally to determine whether a given component is usable, as well
364 * by external monitoring software that wants additional information such as
365 * which sensors indicated failure. The return value is an nvlist of nvlists
366 * indexed by sensor name, each entry with the following contents:
367 *
368 * type, state, units, reading
369 *
370 * Identical to sensor node.
371 *
372 * nonrecov
373 *
374 * Boolean value that is set to indicate that the error is
375 * non-recoverable (the unit is out of service). The default is
376 * critical failure, which indicates a fault but the unit is still
377 * operating.
378 */
379 /*ARGSUSED*/
380 int
topo_method_sensor_failure(topo_mod_t * mod,tnode_t * node,topo_version_t version,nvlist_t * in,nvlist_t ** out)381 topo_method_sensor_failure(topo_mod_t *mod, tnode_t *node,
382 topo_version_t version, nvlist_t *in, nvlist_t **out)
383 {
384 const char *name = topo_node_name(node);
385 topo_faclist_t faclist, *fp;
386 int err;
387 nvlist_t *nvl, *props, *propval, *tmp;
388 int ret = -1;
389 uint32_t type, state, units;
390 nvpair_t *elem;
391 double reading;
392 char *propname;
393 boolean_t has_reading;
394 struct sensor_errinfo seinfo;
395
396 if (strcmp(name, PSU) != 0 && strcmp(name, FAN) != 0)
397 return (topo_mod_seterrno(mod, ETOPO_METHOD_NOTSUP));
398
399 if (topo_node_facility(mod->tm_hdl, node, TOPO_FAC_TYPE_SENSOR,
400 TOPO_FAC_TYPE_ANY, &faclist, &err) != 0)
401 return (topo_mod_seterrno(mod, ETOPO_METHOD_NOTSUP));
402
403 if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0)
404 goto error;
405
406 for (fp = topo_list_next(&faclist.tf_list); fp != NULL;
407 fp = topo_list_next(fp)) {
408 if (topo_prop_getpgrp(fp->tf_node, TOPO_PGROUP_FACILITY,
409 &props, &err) != 0) {
410 nvlist_free(nvl);
411 goto error;
412 }
413 type = state = units = 0;
414 reading = 0;
415 has_reading = B_FALSE;
416
417 elem = NULL;
418 while ((elem = nvlist_next_nvpair(props, elem)) != NULL) {
419 if (strcmp(nvpair_name(elem), TOPO_PROP_VAL) != 0 ||
420 nvpair_type(elem) != DATA_TYPE_NVLIST)
421 continue;
422
423 (void) nvpair_value_nvlist(elem, &propval);
424 if (nvlist_lookup_string(propval,
425 TOPO_PROP_VAL_NAME, &propname) != 0)
426 continue;
427
428 if (strcmp(propname, TOPO_FACILITY_TYPE) == 0) {
429 (void) nvlist_lookup_uint32(propval,
430 TOPO_PROP_VAL_VAL, &type);
431 } else if (strcmp(propname, TOPO_SENSOR_STATE) == 0) {
432 (void) nvlist_lookup_uint32(propval,
433 TOPO_PROP_VAL_VAL, &state);
434 } else if (strcmp(propname, TOPO_SENSOR_UNITS) == 0) {
435 (void) nvlist_lookup_uint32(propval,
436 TOPO_PROP_VAL_VAL, &units);
437 } else if (strcmp(propname, TOPO_SENSOR_READING) == 0) {
438 has_reading = B_TRUE;
439 (void) nvlist_lookup_double(propval,
440 TOPO_PROP_VAL_VAL, &reading);
441 }
442 }
443
444 if (topo_sensor_failed(type, state, &seinfo)) {
445 tmp = NULL;
446 if (topo_mod_nvalloc(mod, &tmp, NV_UNIQUE_NAME) != 0 ||
447 nvlist_add_uint32(tmp, TOPO_FACILITY_TYPE,
448 type) != 0 ||
449 nvlist_add_uint32(tmp, TOPO_SENSOR_STATE,
450 state) != 0 ||
451 nvlist_add_uint32(tmp, TOPO_SENSOR_UNITS,
452 units) != 0 ||
453 nvlist_add_boolean_value(tmp,
454 "nonrecov", seinfo.se_nonrecov) != 0 ||
455 nvlist_add_boolean_value(tmp,
456 "predictive", seinfo.se_predictive) != 0 ||
457 nvlist_add_uint32(tmp, "source",
458 seinfo.se_src) != 0 ||
459 (has_reading && nvlist_add_double(tmp,
460 TOPO_SENSOR_READING, reading) != 0) ||
461 nvlist_add_nvlist(nvl, topo_node_name(fp->tf_node),
462 tmp) != 0) {
463 nvlist_free(props);
464 nvlist_free(tmp);
465 nvlist_free(nvl);
466 ret = topo_mod_seterrno(mod,
467 ETOPO_METHOD_NOMEM);
468 goto error;
469 }
470
471 nvlist_free(tmp);
472 }
473
474 nvlist_free(props);
475 }
476
477 *out = nvl;
478 ret = 0;
479 error:
480 while ((fp = topo_list_next(&faclist.tf_list)) != NULL) {
481 topo_list_delete(&faclist.tf_list, fp);
482 topo_mod_free(mod, fp, sizeof (topo_faclist_t));
483 }
484 return (ret);
485 }
486