xref: /titanic_51/usr/src/lib/fm/libfmd_snmp/common/resource.c (revision 545758327e65fa2c3d514152f4c010e8faddfa6d)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #include <fm/fmd_adm.h>
28 #include <fm/fmd_snmp.h>
29 #include <net-snmp/net-snmp-config.h>
30 #include <net-snmp/net-snmp-includes.h>
31 #include <net-snmp/agent/net-snmp-agent-includes.h>
32 #include <pthread.h>
33 #include <stddef.h>
34 #include <errno.h>
35 #include <libuutil.h>
36 #include "sunFM_impl.h"
37 #include "resource.h"
38 
39 static uu_avl_pool_t	*rsrc_fmri_avl_pool;
40 static uu_avl_pool_t	*rsrc_index_avl_pool;
41 static uu_avl_t		*rsrc_fmri_avl;
42 static uu_avl_t		*rsrc_index_avl;
43 
44 #define	VALID_AVL_STATE	(rsrc_fmri_avl_pool != NULL &&		\
45 	rsrc_index_avl_pool != NULL && rsrc_fmri_avl != NULL &&	\
46 	rsrc_index_avl != NULL)
47 
48 #define	UPDATE_WAIT_MILLIS	10	/* poll interval in milliseconds */
49 
50 /*
51  * Update types: single-index and all are mutually exclusive; a count
52  * update is optional.
53  */
54 #define	UCT_INDEX	0x1
55 #define	UCT_ALL		0x2
56 #define	UCT_COUNT	0x4
57 #define	UCT_FLAGS	0x7
58 
59 #define	RESOURCE_DATA_VALID(d)	((d)->d_valid == valid_stamp)
60 
61 /*
62  * Locking strategy is described in module.c.
63  */
64 static ulong_t		max_index;
65 static int		valid_stamp;
66 static uint32_t		rsrc_count;
67 static pthread_mutex_t	update_lock;
68 static pthread_cond_t	update_cv;
69 static volatile enum { US_QUIET, US_NEEDED, US_INPROGRESS } update_status;
70 
71 static Netsnmp_Node_Handler	sunFmResourceTable_handler;
72 static Netsnmp_Node_Handler	sunFmResourceCount_handler;
73 
74 static sunFmResource_data_t *
75 key_build(const char *fmri, const ulong_t index)
76 {
77 	static sunFmResource_data_t	key;
78 
79 	key.d_index = index;
80 	if (fmri)
81 		(void) strlcpy(key.d_ari_fmri, fmri, sizeof (key.d_ari_fmri));
82 	else
83 		key.d_ari_fmri[0] = '\0';
84 
85 	return (&key);
86 }
87 
88 /*
89  * If fmri is the fmri of a resource we have previously seen and indexed, return
90  * data for it.  Otherwise, return NULL.  Note that the resource may not be
91  * valid; that is, it may have been removed from the fault manager since its
92  * information was last updated.
93  */
94 static sunFmResource_data_t *
95 resource_lookup_fmri(const char *fmri)
96 {
97 	sunFmResource_data_t	*key;
98 
99 	key = key_build(fmri, 0);
100 	return (uu_avl_find(rsrc_fmri_avl, key, NULL, NULL));
101 }
102 
103 /*
104  * If index corresponds to a resource we have previously seen and indexed,
105  * return data for it.  Otherwise, return NULL.  Note that the resource may
106  * not be valid; that is, it may have been expired from the fault manager
107  * since its information was last updated.
108  */
109 static sunFmResource_data_t *
110 resource_lookup_index_exact(const ulong_t index)
111 {
112 	sunFmResource_data_t	*key;
113 
114 	key = key_build(NULL, index);
115 	return (uu_avl_find(rsrc_index_avl, key, NULL, NULL));
116 }
117 
118 /*
119  * If index corresponds to a valid (that is, extant as of latest information
120  * from the fault manager) resource, return the data for that resource.
121  * Otherwise, return the data for the valid resource whose index is as close as
122  * possible to index but not lower.  This preserves the lexicographical
123  * ordering required for GETNEXT processing.
124  */
125 static sunFmResource_data_t *
126 resource_lookup_index_nextvalid(const ulong_t index)
127 {
128 	sunFmResource_data_t	*key, *data;
129 	uu_avl_index_t		idx;
130 
131 	key = key_build(NULL, index);
132 
133 	if ((data = uu_avl_find(rsrc_index_avl, key, NULL, &idx)) != NULL &&
134 	    RESOURCE_DATA_VALID(data))
135 		return (data);
136 
137 	data = uu_avl_nearest_next(rsrc_index_avl, idx);
138 
139 	while (data != NULL && !RESOURCE_DATA_VALID(data))
140 		data = uu_avl_next(rsrc_index_avl, data);
141 
142 	return (data);
143 }
144 
145 /*
146  * Possible update the contents of a single resource within the cache.  This
147  * is our callback from fmd_rsrc_iter.
148  */
149 static int
150 rsrcinfo_update_one(const fmd_adm_rsrcinfo_t *rsrcinfo, void *arg)
151 {
152 	const sunFmResource_update_ctx_t *update_ctx =
153 	    (sunFmResource_update_ctx_t *)arg;
154 	sunFmResource_data_t *data = resource_lookup_fmri(rsrcinfo->ari_fmri);
155 
156 	++rsrc_count;
157 
158 	/*
159 	 * A resource we haven't seen before.  We're obligated to index
160 	 * it and link it into our cache so that we can find it, but we're
161 	 * not obligated to fill it in completely unless we're doing a
162 	 * full update or this is the resource we were asked for.  This
163 	 * avoids unnecessary iteration and memory manipulation for data
164 	 * we're not going to return for this request.
165 	 */
166 	if (data == NULL) {
167 		uu_avl_index_t idx;
168 
169 		DEBUGMSGTL((MODNAME_STR, "found new resource %s\n",
170 		    rsrcinfo->ari_fmri));
171 		if ((data = SNMP_MALLOC_TYPEDEF(sunFmResource_data_t)) ==
172 		    NULL) {
173 			(void) snmp_log(LOG_ERR, MODNAME_STR ": Out of memory "
174 			    "for new resource data at %s:%d\n", __FILE__,
175 			    __LINE__);
176 			return (1);
177 		}
178 		/*
179 		 * We allocate indices sequentially and never reuse them.
180 		 * This ensures we can always return valid GETNEXT responses
181 		 * without having to reindex, and it provides the user a
182 		 * more consistent view of the fault manager.
183 		 */
184 		data->d_index = ++max_index;
185 		DEBUGMSGTL((MODNAME_STR, "index %lu is %s@%p\n", data->d_index,
186 		    rsrcinfo->ari_fmri, data));
187 
188 		(void) strlcpy(data->d_ari_fmri, rsrcinfo->ari_fmri,
189 		    sizeof (data->d_ari_fmri));
190 
191 		uu_avl_node_init(data, &data->d_fmri_avl, rsrc_fmri_avl_pool);
192 		(void) uu_avl_find(rsrc_fmri_avl, data, NULL, &idx);
193 		uu_avl_insert(rsrc_fmri_avl, data, idx);
194 
195 		uu_avl_node_init(data, &data->d_index_avl, rsrc_index_avl_pool);
196 		(void) uu_avl_find(rsrc_index_avl, data, NULL, &idx);
197 		uu_avl_insert(rsrc_index_avl, data, idx);
198 
199 		DEBUGMSGTL((MODNAME_STR, "completed new resource %lu/%s@%p\n",
200 		    data->d_index, data->d_ari_fmri, data));
201 	}
202 
203 	data->d_valid = valid_stamp;
204 
205 	DEBUGMSGTL((MODNAME_STR, "timestamp updated for %lu/%s@%p: %d\n",
206 	    data->d_index, data->d_ari_fmri, data, data->d_valid));
207 
208 	if ((update_ctx->uc_type & UCT_ALL) ||
209 	    update_ctx->uc_index == data->d_index) {
210 		(void) strlcpy(data->d_ari_case, rsrcinfo->ari_case,
211 		    sizeof (data->d_ari_case));
212 		data->d_ari_flags = rsrcinfo->ari_flags;
213 	}
214 
215 	return (!(update_ctx->uc_type & UCT_ALL) &&
216 	    update_ctx->uc_index == data->d_index);
217 }
218 
219 /*
220  * Update some or all resource data from fmd.  If type includes UCT_ALL, all
221  * resources will be indexed and their data cached.  If type includes
222  * UCT_INDEX, updates will stop once the resource matching index has been
223  * updated.  If UCT_COUNT is set, the number of faulted resources will be
224  * set.
225  *
226  * Returns appropriate SNMP error codes.
227  */
228 static int
229 rsrcinfo_update(sunFmResource_update_ctx_t *update_ctx)
230 {
231 	fmd_adm_t *adm;
232 	int err;
233 
234 	ASSERT(update_ctx != NULL);
235 	ASSERT((update_ctx->uc_type & (UCT_ALL|UCT_INDEX)) !=
236 	    (UCT_ALL|UCT_INDEX));
237 	ASSERT((update_ctx->uc_type & ~UCT_FLAGS) == 0);
238 	ASSERT(VALID_AVL_STATE);
239 
240 	if ((adm = fmd_adm_open(update_ctx->uc_host, update_ctx->uc_prog,
241 	    update_ctx->uc_version)) == NULL) {
242 		(void) snmp_log(LOG_ERR, MODNAME_STR ": Communication with fmd "
243 		    "failed: %s\n", strerror(errno));
244 		return (SNMP_ERR_RESOURCEUNAVAILABLE);
245 	}
246 
247 	if (update_ctx->uc_type == UCT_COUNT) {
248 		err = fmd_adm_rsrc_count(adm, update_ctx->uc_all, &rsrc_count);
249 	} else {
250 		++valid_stamp;
251 		rsrc_count = 0;
252 		err = fmd_adm_rsrc_iter(adm, update_ctx->uc_all,
253 		    rsrcinfo_update_one, update_ctx);
254 		DEBUGMSGTL((MODNAME_STR, "resource iteration completed\n"));
255 	}
256 
257 	fmd_adm_close(adm);
258 
259 	if (err != 0) {
260 		(void) snmp_log(LOG_ERR, MODNAME_STR ": fmd resource "
261 		    "information update failed: %s\n", fmd_adm_errmsg(adm));
262 		return (SNMP_ERR_RESOURCEUNAVAILABLE);
263 	}
264 
265 	return (SNMP_ERR_NOERROR);
266 }
267 
268 /*ARGSUSED*/
269 static void
270 update_thread(void *arg)
271 {
272 	/*
273 	 * The current rsrcinfo_update implementation offers minimal savings
274 	 * for the use of index-only updates; therefore we always do a full
275 	 * update.  If it becomes advantageous to limit updates to a single
276 	 * index, the contexts can be queued by the handler instead.
277 	 */
278 	sunFmResource_update_ctx_t	uc;
279 
280 	uc.uc_host = NULL;
281 	uc.uc_prog = FMD_ADM_PROGRAM;
282 	uc.uc_version = FMD_ADM_VERSION;
283 
284 	uc.uc_all = 0;
285 	uc.uc_index = 0;
286 	uc.uc_type = UCT_ALL;
287 
288 	for (;;) {
289 		(void) pthread_mutex_lock(&update_lock);
290 		update_status = US_QUIET;
291 		while (update_status == US_QUIET)
292 			(void) pthread_cond_wait(&update_cv, &update_lock);
293 		update_status = US_INPROGRESS;
294 		(void) pthread_mutex_unlock(&update_lock);
295 		(void) rsrcinfo_update(&uc);
296 	}
297 }
298 
299 static void
300 request_update(void)
301 {
302 	(void) pthread_mutex_lock(&update_lock);
303 	if (update_status != US_QUIET) {
304 		(void) pthread_mutex_unlock(&update_lock);
305 		return;
306 	}
307 	update_status = US_NEEDED;
308 	(void) pthread_cond_signal(&update_cv);
309 	(void) pthread_mutex_unlock(&update_lock);
310 }
311 
312 /*ARGSUSED*/
313 static int
314 resource_compare_fmri(const void *l, const void *r, void *private)
315 {
316 	sunFmResource_data_t	*l_data = (sunFmResource_data_t *)l;
317 	sunFmResource_data_t	*r_data = (sunFmResource_data_t *)r;
318 
319 	ASSERT(l_data != NULL && r_data != NULL);
320 
321 	return (strcmp(l_data->d_ari_fmri, r_data->d_ari_fmri));
322 }
323 
324 /*ARGSUSED*/
325 static int
326 resource_compare_index(const void *l, const void *r, void *private)
327 {
328 	sunFmResource_data_t	*l_data = (sunFmResource_data_t *)l;
329 	sunFmResource_data_t	*r_data = (sunFmResource_data_t *)r;
330 
331 	ASSERT(l_data != NULL && r_data != NULL);
332 
333 	return (l_data->d_index < r_data->d_index ? -1 :
334 	    l_data->d_index > r_data->d_index ? 1 : 0);
335 }
336 
337 int
338 sunFmResourceTable_init(void)
339 {
340 	static oid sunFmResourceTable_oid[] = { SUNFMRESOURCETABLE_OID };
341 	static oid sunFmResourceCount_oid[] = { SUNFMRESOURCECOUNT_OID, 0 };
342 	netsnmp_table_registration_info *table_info;
343 	netsnmp_handler_registration *handler;
344 	int err;
345 
346 	if ((err = pthread_mutex_init(&update_lock, NULL)) != 0) {
347 		(void) snmp_log(LOG_ERR, MODNAME_STR ": mutex_init failure: "
348 		    "%s\n", strerror(err));
349 		return (MIB_REGISTRATION_FAILED);
350 	}
351 	if ((err = pthread_cond_init(&update_cv, NULL)) != 0) {
352 		(void) snmp_log(LOG_ERR, MODNAME_STR ": cond_init failure: "
353 		    "%s\n", strerror(err));
354 		return (MIB_REGISTRATION_FAILED);
355 	}
356 
357 	if ((err = pthread_create(NULL, NULL, (void *(*)(void *))update_thread,
358 	    NULL)) != 0) {
359 		(void) snmp_log(LOG_ERR, MODNAME_STR ": error creating update "
360 		    "thread: %s\n", strerror(err));
361 		return (MIB_REGISTRATION_FAILED);
362 	}
363 
364 	if ((table_info =
365 	    SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info)) == NULL)
366 		return (MIB_REGISTRATION_FAILED);
367 
368 	if ((handler = netsnmp_create_handler_registration("sunFmResourceTable",
369 	    sunFmResourceTable_handler, sunFmResourceTable_oid,
370 	    OID_LENGTH(sunFmResourceTable_oid), HANDLER_CAN_RONLY)) == NULL) {
371 		SNMP_FREE(table_info);
372 		return (MIB_REGISTRATION_FAILED);
373 	}
374 
375 	/*
376 	 * The Net-SNMP template uses add_indexes here, but that
377 	 * function is unsafe because it does not check for failure.
378 	 */
379 	if (netsnmp_table_helper_add_index(table_info, ASN_UNSIGNED) == NULL) {
380 		SNMP_FREE(table_info);
381 		SNMP_FREE(handler);
382 		return (MIB_REGISTRATION_FAILED);
383 	}
384 
385 	table_info->min_column = SUNFMRESOURCE_COLMIN;
386 	table_info->max_column = SUNFMRESOURCE_COLMAX;
387 
388 	if ((rsrc_fmri_avl_pool = uu_avl_pool_create("rsrc_fmri",
389 	    sizeof (sunFmResource_data_t),
390 	    offsetof(sunFmResource_data_t, d_fmri_avl), resource_compare_fmri,
391 	    UU_AVL_DEBUG)) == NULL) {
392 		(void) snmp_log(LOG_ERR, MODNAME_STR ": rsrc_fmri avl pool "
393 		    "creation failed: %s\n", uu_strerror(uu_error()));
394 		snmp_free_varbind(table_info->indexes);
395 		SNMP_FREE(table_info);
396 		SNMP_FREE(handler);
397 	}
398 
399 	if ((rsrc_fmri_avl = uu_avl_create(rsrc_fmri_avl_pool, NULL,
400 	    UU_AVL_DEBUG)) == NULL) {
401 		(void) snmp_log(LOG_ERR, MODNAME_STR ": rsrc_fmri avl creation "
402 		    "failed: %s\n", uu_strerror(uu_error()));
403 		snmp_free_varbind(table_info->indexes);
404 		SNMP_FREE(table_info);
405 		SNMP_FREE(handler);
406 		uu_avl_pool_destroy(rsrc_fmri_avl_pool);
407 		return (MIB_REGISTRATION_FAILED);
408 	}
409 
410 	if ((rsrc_index_avl_pool = uu_avl_pool_create("rsrc_index",
411 	    sizeof (sunFmResource_data_t),
412 	    offsetof(sunFmResource_data_t, d_index_avl),
413 	    resource_compare_index, UU_AVL_DEBUG)) == NULL) {
414 		(void) snmp_log(LOG_ERR, MODNAME_STR ": rsrc_index avl pool "
415 		    "creation failed: %s\n", uu_strerror(uu_error()));
416 		snmp_free_varbind(table_info->indexes);
417 		SNMP_FREE(table_info);
418 		SNMP_FREE(handler);
419 		uu_avl_destroy(rsrc_fmri_avl);
420 		uu_avl_pool_destroy(rsrc_fmri_avl_pool);
421 	}
422 
423 	if ((rsrc_index_avl = uu_avl_create(rsrc_index_avl_pool, NULL,
424 	    UU_AVL_DEBUG)) == NULL) {
425 		(void) snmp_log(LOG_ERR, MODNAME_STR ": rsrc_index avl "
426 		    "creation failed: %s\n", uu_strerror(uu_error()));
427 		snmp_free_varbind(table_info->indexes);
428 		SNMP_FREE(table_info);
429 		SNMP_FREE(handler);
430 		uu_avl_destroy(rsrc_fmri_avl);
431 		uu_avl_pool_destroy(rsrc_fmri_avl_pool);
432 		uu_avl_pool_destroy(rsrc_index_avl_pool);
433 		return (MIB_REGISTRATION_FAILED);
434 	}
435 
436 	if ((err = netsnmp_register_table(handler, table_info)) !=
437 	    MIB_REGISTERED_OK) {
438 		snmp_free_varbind(table_info->indexes);
439 		SNMP_FREE(table_info);
440 		SNMP_FREE(handler);
441 		uu_avl_destroy(rsrc_fmri_avl);
442 		uu_avl_pool_destroy(rsrc_fmri_avl_pool);
443 		uu_avl_destroy(rsrc_index_avl);
444 		uu_avl_pool_destroy(rsrc_index_avl_pool);
445 		return (err);
446 	}
447 
448 	if ((err = netsnmp_register_read_only_instance(
449 	    netsnmp_create_handler_registration("sunFmResourceCount",
450 	    sunFmResourceCount_handler, sunFmResourceCount_oid,
451 	    OID_LENGTH(sunFmResourceCount_oid), HANDLER_CAN_RONLY))) !=
452 	    MIB_REGISTERED_OK) {
453 		/*
454 		 * There's no way to unregister the table handler, so we
455 		 * can't free any of the data, either.
456 		 */
457 		return (err);
458 	}
459 
460 	return (MIB_REGISTERED_OK);
461 }
462 
463 /*
464  * These two functions form the core of GET/GETNEXT/GETBULK handling (the
465  * only kind we do).  They perform two functions:
466  *
467  * - First, frob the request to set all the index variables to correspond
468  *   to the value that's going to be returned.  For GET, this is a nop;
469  *   for GETNEXT/GETBULK it always requires some work.
470  * - Second, find and return the fmd resource information corresponding to
471  *   the (possibly updated) indices.
472  *
473  * These should be as fast as possible; they run in the agent thread.
474  */
475 static sunFmResource_data_t *
476 sunFmResourceTable_nextrsrc(netsnmp_handler_registration *reginfo,
477     netsnmp_table_request_info *table_info)
478 {
479 	sunFmResource_data_t	*data;
480 	netsnmp_variable_list	*var;
481 	ulong_t index;
482 
483 	/*
484 	 * If we have no index, we must make one.
485 	 */
486 	if (table_info->number_indexes < 1) {
487 		oid tmpoid[MAX_OID_LEN];
488 		index = 1;
489 
490 		DEBUGMSGTL((MODNAME_STR, "nextrsrc: no indexes given\n"));
491 		var = SNMP_MALLOC_TYPEDEF(netsnmp_variable_list);
492 		(void) snmp_set_var_typed_value(var, ASN_UNSIGNED,
493 		    (uchar_t *)&index, sizeof (index));
494 		(void) memcpy(tmpoid, reginfo->rootoid,
495 		    reginfo->rootoid_len * sizeof (oid));
496 		tmpoid[reginfo->rootoid_len] = 1;
497 		tmpoid[reginfo->rootoid_len + 1] = table_info->colnum;
498 		if (build_oid(&var->name, &var->name_length, tmpoid,
499 		    reginfo->rootoid_len + 2, var) != SNMPERR_SUCCESS) {
500 			snmp_free_varbind(var);
501 			return (NULL);
502 		}
503 		DEBUGMSGTL((MODNAME_STR, "nextrsrc: built fake index:\n"));
504 		DEBUGMSGVAR((MODNAME_STR, var));
505 		DEBUGMSG((MODNAME_STR, "\n"));
506 	} else {
507 		var = snmp_clone_varbind(table_info->indexes);
508 		index = *var->val.integer;
509 		DEBUGMSGTL((MODNAME_STR, "nextrsrc: received index:\n"));
510 		DEBUGMSGVAR((MODNAME_STR, var));
511 		DEBUGMSG((MODNAME_STR, "\n"));
512 		index++;
513 	}
514 
515 	snmp_free_varbind(table_info->indexes);
516 	table_info->indexes = NULL;
517 	table_info->number_indexes = 0;
518 
519 	if ((data = resource_lookup_index_nextvalid(index)) == NULL) {
520 		DEBUGMSGTL((MODNAME_STR, "nextrsrc: exact match not found for "
521 		    "index %lu; trying next column\n", index));
522 		if (table_info->colnum >=
523 		    netsnmp_find_table_registration_info(reginfo)->max_column) {
524 			snmp_free_varbind(var);
525 			DEBUGMSGTL((MODNAME_STR, "nextrsrc: out of columns\n"));
526 			return (NULL);
527 		}
528 		table_info->colnum++;
529 		index = 1;
530 
531 		data = resource_lookup_index_nextvalid(index);
532 	}
533 
534 	if (data == NULL) {
535 		DEBUGMSGTL((MODNAME_STR, "nextrsrc: exact match not found for "
536 		    "index %lu; stopping\n", index));
537 		snmp_free_varbind(var);
538 		return (NULL);
539 	}
540 
541 	*var->val.integer = data->d_index;
542 	table_info->indexes = var;
543 	table_info->number_indexes = 1;
544 
545 	DEBUGMSGTL((MODNAME_STR, "matching data is %lu/%s@%p\n", data->d_index,
546 	    data->d_ari_fmri, data));
547 
548 	return (data);
549 }
550 
551 /*ARGSUSED*/
552 static sunFmResource_data_t *
553 sunFmResourceTable_rsrc(netsnmp_handler_registration *reginfo,
554     netsnmp_table_request_info *table_info)
555 {
556 	ASSERT(table_info->number_indexes == 1);
557 
558 	return (resource_lookup_index_exact(table_info->index_oid[0]));
559 }
560 
561 /*ARGSUSED*/
562 static void
563 sunFmResourceTable_return(unsigned int reg, void *arg)
564 {
565 	netsnmp_delegated_cache		*cache = (netsnmp_delegated_cache *)arg;
566 	netsnmp_request_info		*request;
567 	netsnmp_agent_request_info	*reqinfo;
568 	netsnmp_handler_registration	*reginfo;
569 	netsnmp_table_request_info	*table_info;
570 	sunFmResource_data_t		*data;
571 	ulong_t				rsrcstate;
572 
573 	ASSERT(netsnmp_handler_check_cache(cache) != NULL);
574 
575 	(void) pthread_mutex_lock(&update_lock);
576 	if (update_status != US_QUIET) {
577 		struct timeval			tv;
578 
579 		tv.tv_sec = UPDATE_WAIT_MILLIS / 1000;
580 		tv.tv_usec = (UPDATE_WAIT_MILLIS % 1000) * 1000;
581 
582 		(void) snmp_alarm_register_hr(tv, 0, sunFmResourceTable_return,
583 		    cache);
584 		(void) pthread_mutex_unlock(&update_lock);
585 		return;
586 	}
587 
588 	request = cache->requests;
589 	reqinfo = cache->reqinfo;
590 	reginfo = cache->reginfo;
591 
592 	table_info = netsnmp_extract_table_info(request);
593 	request->delegated = 0;
594 
595 	ASSERT(table_info->colnum >= SUNFMRESOURCE_COLMIN);
596 	ASSERT(table_info->colnum <= SUNFMRESOURCE_COLMAX);
597 
598 	/*
599 	 * table_info->colnum contains the column number requested.
600 	 * table_info->indexes contains a linked list of snmp variable
601 	 * bindings for the indexes of the table.  Values in the list
602 	 * have been set corresponding to the indexes of the
603 	 * request.  We have other guarantees as well:
604 	 *
605 	 * - The column number is always within range.
606 	 * - If we have no index data, table_info->index_oid_len is 0.
607 	 * - We will never receive requests outside our table nor
608 	 *   those with the first subid anything other than 1 (Entry)
609 	 *   nor those without a column number.  This is true even
610 	 *   for GETNEXT requests.
611 	 */
612 
613 	switch (reqinfo->mode) {
614 	case MODE_GET:
615 		if ((data = sunFmResourceTable_rsrc(reginfo, table_info)) ==
616 		    NULL) {
617 			netsnmp_free_delegated_cache(cache);
618 			(void) pthread_mutex_unlock(&update_lock);
619 			return;
620 		}
621 		break;
622 	case MODE_GETNEXT:
623 	case MODE_GETBULK:
624 		if ((data = sunFmResourceTable_nextrsrc(reginfo, table_info)) ==
625 		    NULL) {
626 			netsnmp_free_delegated_cache(cache);
627 			(void) pthread_mutex_unlock(&update_lock);
628 			return;
629 		}
630 		break;
631 	default:
632 		(void) snmp_log(LOG_ERR, MODNAME_STR ": Unsupported request "
633 		    "mode %d\n", reqinfo->mode);
634 		netsnmp_free_delegated_cache(cache);
635 		(void) pthread_mutex_unlock(&update_lock);
636 		return;
637 	}
638 
639 	switch (table_info->colnum) {
640 	case SUNFMRESOURCE_COL_FMRI:
641 		(void) netsnmp_table_build_result(reginfo, request, table_info,
642 		    ASN_OCTET_STR, (uchar_t *)data->d_ari_fmri,
643 		    strlen(data->d_ari_fmri));
644 		break;
645 	case SUNFMRESOURCE_COL_STATUS:
646 		switch (data->d_ari_flags &
647 		    (FMD_ADM_RSRC_FAULTY|FMD_ADM_RSRC_UNUSABLE)) {
648 		default:
649 			rsrcstate = SUNFMRESOURCE_STATE_OK;
650 			break;
651 		case FMD_ADM_RSRC_FAULTY:
652 			rsrcstate = SUNFMRESOURCE_STATE_DEGRADED;
653 			break;
654 		case FMD_ADM_RSRC_UNUSABLE:
655 			rsrcstate = SUNFMRESOURCE_STATE_UNKNOWN;
656 			break;
657 		case FMD_ADM_RSRC_FAULTY | FMD_ADM_RSRC_UNUSABLE:
658 			rsrcstate = SUNFMRESOURCE_STATE_FAULTED;
659 			break;
660 		}
661 		(void) netsnmp_table_build_result(reginfo, request, table_info,
662 		    ASN_INTEGER, (uchar_t *)&rsrcstate,
663 		    sizeof (rsrcstate));
664 		break;
665 	case SUNFMRESOURCE_COL_DIAGNOSISUUID:
666 		(void) netsnmp_table_build_result(reginfo, request, table_info,
667 		    ASN_OCTET_STR, (uchar_t *)data->d_ari_case,
668 		    strlen(data->d_ari_case));
669 		break;
670 	default:
671 		break;
672 	}
673 	netsnmp_free_delegated_cache(cache);
674 	(void) pthread_mutex_unlock(&update_lock);
675 }
676 
677 static int
678 sunFmResourceTable_handler(netsnmp_mib_handler *handler,
679     netsnmp_handler_registration *reginfo, netsnmp_agent_request_info *reqinfo,
680     netsnmp_request_info *requests)
681 {
682 	netsnmp_request_info		*request;
683 	struct timeval			tv;
684 
685 	tv.tv_sec = UPDATE_WAIT_MILLIS / 1000;
686 	tv.tv_usec = (UPDATE_WAIT_MILLIS % 1000) * 1000;
687 
688 	request_update();
689 
690 	for (request = requests; request; request = request->next) {
691 		if (request->processed != 0)
692 			continue;
693 
694 		if (netsnmp_extract_table_info(request) == NULL)
695 			continue;
696 
697 		request->delegated = 1;
698 		(void) snmp_alarm_register_hr(tv, 0, sunFmResourceTable_return,
699 		    (void *) netsnmp_create_delegated_cache(handler, reginfo,
700 		    reqinfo, request, NULL));
701 	}
702 
703 	return (SNMP_ERR_NOERROR);
704 }
705 
706 /*ARGSUSED*/
707 static void
708 sunFmResourceCount_return(unsigned int reg, void *arg)
709 {
710 	netsnmp_delegated_cache		*cache = (netsnmp_delegated_cache *)arg;
711 	netsnmp_request_info		*request;
712 	netsnmp_agent_request_info	*reqinfo;
713 	ulong_t				rsrc_count_long;
714 
715 	ASSERT(netsnmp_handler_check_cache(cache) != NULL);
716 
717 	(void) pthread_mutex_lock(&update_lock);
718 	if (update_status != US_QUIET) {
719 		struct timeval	tv;
720 
721 		tv.tv_sec = UPDATE_WAIT_MILLIS / 1000;
722 		tv.tv_usec = (UPDATE_WAIT_MILLIS % 1000) * 1000;
723 
724 		(void) snmp_alarm_register_hr(tv, 0, sunFmResourceCount_return,
725 		    cache);
726 		(void) pthread_mutex_unlock(&update_lock);
727 		return;
728 	}
729 
730 	request = cache->requests;
731 	reqinfo = cache->reqinfo;
732 
733 	request->delegated = 0;
734 
735 	switch (reqinfo->mode) {
736 	/*
737 	 * According to the documentation, it's not possible for us ever to
738 	 * be called with MODE_GETNEXT.  However, Net-SNMP does the following:
739 	 * - set reqinfo->mode to MODE_GET
740 	 * - invoke the handler
741 	 * - set reqinfo->mode to MODE_GETNEXT (even if the request was not
742 	 *   actually processed; i.e. it's been delegated)
743 	 * Since we're called back later with the same reqinfo, we see
744 	 * GETNEXT.  Therefore this case is needed to work around the
745 	 * Net-SNMP bug.
746 	 */
747 	case MODE_GET:
748 	case MODE_GETNEXT:
749 		DEBUGMSGTL((MODNAME_STR, "resource count is %u\n", rsrc_count));
750 		rsrc_count_long = (ulong_t)rsrc_count;
751 		(void) snmp_set_var_typed_value(request->requestvb, ASN_GAUGE,
752 		    (uchar_t *)&rsrc_count_long, sizeof (rsrc_count_long));
753 		break;
754 	default:
755 		(void) snmp_log(LOG_ERR, MODNAME_STR ": Unsupported request "
756 		    "mode %d\n", reqinfo->mode);
757 	}
758 
759 	netsnmp_free_delegated_cache(cache);
760 	(void) pthread_mutex_unlock(&update_lock);
761 }
762 
763 static int
764 sunFmResourceCount_handler(netsnmp_mib_handler *handler,
765     netsnmp_handler_registration *reginfo, netsnmp_agent_request_info *reqinfo,
766     netsnmp_request_info *requests)
767 {
768 	struct timeval	tv;
769 
770 	tv.tv_sec = UPDATE_WAIT_MILLIS / 1000;
771 	tv.tv_usec = (UPDATE_WAIT_MILLIS % 1000) * 1000;
772 
773 	request_update();
774 
775 	/*
776 	 * We are never called for a GETNEXT when registered as an
777 	 * instance; it's handled for us and converted to a GET.
778 	 * Also, an instance handler is given only one request at a time, so
779 	 * we don't need to loop over a list of requests.
780 	 */
781 
782 	if (requests->processed != 0)
783 		return (SNMP_ERR_NOERROR);
784 
785 	requests->delegated = 1;
786 	(void) snmp_alarm_register_hr(tv, 0, sunFmResourceCount_return,
787 	    (void *) netsnmp_create_delegated_cache(handler, reginfo,
788 	    reqinfo, requests, NULL));
789 
790 	return (SNMP_ERR_NOERROR);
791 }
792