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 "module.h"
38
39 static uu_avl_pool_t *mod_name_avl_pool;
40 static uu_avl_pool_t *mod_index_avl_pool;
41 static uu_avl_t *mod_name_avl;
42 static uu_avl_t *mod_index_avl;
43
44 #define VALID_AVL_STATE (mod_name_avl_pool != NULL && \
45 mod_index_avl_pool != NULL && mod_name_avl != NULL && \
46 mod_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.
52 */
53 #define UCT_INDEX 0x1
54 #define UCT_ALL 0x2
55 #define UCT_FLAGS 0x3
56
57 #define MODULE_DATA_VALID(d) ((d)->d_valid == valid_stamp)
58
59 /*
60 * Locking rules are straightforward. There is only one updater thread
61 * for each table, and requests for update that are received while
62 * another update is in progress are ignored. The single per-table lock
63 * protects all the data for the table, the valid_stamp and max_index
64 * tags for new data, and - importantly - all the hidden static data
65 * used by the Net-SNMP library. The result return callbacks are always
66 * called in the master agent thread; holding the table lock is
67 * therefore sufficient since only one table's callback can be run at
68 * any one time. Finer-grained locking is possible here but
69 * substantially more difficult because nearly all Net-SNMP functions
70 * are unsafe.
71 *
72 * In practice this is more than adequate, since the purpose of
73 * threading out the update is to prevent excessively time-consuming
74 * data collection from bottlenecking the entire agent, not to improve
75 * result throughput (SNMP is not intended to be used for applications
76 * requiring high throughput anyway). If the agent itself ever becomes
77 * multithreaded, locking requirements become limited to our local
78 * per-table data (the tree, max_index, and valid_stamp), and the
79 * implementation could be revisited for better performance.
80 */
81
82 static ulong_t max_index;
83 static int valid_stamp;
84 static pthread_mutex_t update_lock;
85 static pthread_cond_t update_cv;
86 static volatile enum { US_QUIET, US_NEEDED, US_INPROGRESS } update_status;
87
88 static Netsnmp_Node_Handler sunFmModuleTable_handler;
89
90 static sunFmModule_data_t *
key_build(const char * name,const ulong_t index)91 key_build(const char *name, const ulong_t index)
92 {
93 static sunFmModule_data_t key;
94
95 key.d_index = index;
96 if (name)
97 (void) strlcpy(key.d_ami_name, name, sizeof (key.d_ami_name));
98 else
99 key.d_ami_name[0] = '\0';
100
101 return (&key);
102 }
103
104 /*
105 * If name is the name of a module we have previously seen and indexed, return
106 * data for it. Otherwise, return NULL. Note that the module may not be
107 * valid; that is, it may have been removed from the fault manager since its
108 * information was last updated.
109 */
110 static sunFmModule_data_t *
module_lookup_name(const char * name)111 module_lookup_name(const char *name)
112 {
113 sunFmModule_data_t *key;
114
115 key = key_build(name, 0);
116 return (uu_avl_find(mod_name_avl, key, NULL, NULL));
117 }
118
119 /*
120 * If index corresponds to a module we have previously seen and indexed, return
121 * data for it. Otherwise, return NULL. Note that the module may not be
122 * valid; that is, it may have been removed from the fault manager since its
123 * information was last updated.
124 */
125 static sunFmModule_data_t *
module_lookup_index_exact(const ulong_t index)126 module_lookup_index_exact(const ulong_t index)
127 {
128 sunFmModule_data_t *key;
129
130 key = key_build(NULL, index);
131 return (uu_avl_find(mod_index_avl, key, NULL, NULL));
132 }
133
134 /*
135 * If index corresponds to a valid (that is, extant as of latest information
136 * from the fault manager) fmd module, return the data for that module.
137 * Otherwise, return the data for the valid module whose index is as close as
138 * possible to index but not lower. This preserves the lexicographical
139 * ordering required for GETNEXT processing.
140 */
141 static sunFmModule_data_t *
module_lookup_index_nextvalid(const ulong_t index)142 module_lookup_index_nextvalid(const ulong_t index)
143 {
144 sunFmModule_data_t *key, *data;
145 uu_avl_index_t idx;
146
147 key = key_build(NULL, index);
148
149 if ((data = uu_avl_find(mod_index_avl, key, NULL, &idx)) != NULL &&
150 MODULE_DATA_VALID(data))
151 return (data);
152
153 data = uu_avl_nearest_next(mod_index_avl, idx);
154
155 while (data != NULL && !MODULE_DATA_VALID(data))
156 data = uu_avl_next(mod_index_avl, data);
157
158 return (data);
159 }
160
161 /*
162 * Possible update the contents of a single module within the cache. This
163 * is our callback from fmd_module_iter.
164 */
165 static int
modinfo_update_one(const fmd_adm_modinfo_t * modinfo,void * arg)166 modinfo_update_one(const fmd_adm_modinfo_t *modinfo, void *arg)
167 {
168 const sunFmModule_update_ctx_t *update_ctx =
169 (sunFmModule_update_ctx_t *)arg;
170 sunFmModule_data_t *data = module_lookup_name(modinfo->ami_name);
171
172 /*
173 * An fmd module we haven't seen before. We're obligated to index
174 * it and link it into our cache so that we can find it, but we're
175 * not obligated to fill it in completely unless we're doing a
176 * thorough update or this is the module we were asked for. This
177 * avoids unnecessary iteration and memory manipulation for data
178 * we're not going to return for this request.
179 */
180 if (data == NULL) {
181 uu_avl_index_t idx;
182
183 DEBUGMSGTL((MODNAME_STR, "found new fmd module %s\n",
184 modinfo->ami_name));
185 if ((data = SNMP_MALLOC_TYPEDEF(sunFmModule_data_t)) == NULL) {
186 (void) snmp_log(LOG_ERR, MODNAME_STR ": Out of memory "
187 "for new module data at %s:%d\n", __FILE__,
188 __LINE__);
189 return (1);
190 }
191 /*
192 * We allocate indices sequentially and never reuse them.
193 * This ensures we can always return valid GETNEXT responses
194 * without having to reindex, and it provides the user a
195 * more consistent view of the fault manager.
196 */
197 data->d_index = ++max_index;
198 DEBUGMSGTL((MODNAME_STR, "index %lu is %s@%p\n", data->d_index,
199 modinfo->ami_name, data));
200
201 (void) strlcpy(data->d_ami_name, modinfo->ami_name,
202 sizeof (data->d_ami_name));
203
204 uu_avl_node_init(data, &data->d_name_avl, mod_name_avl_pool);
205 (void) uu_avl_find(mod_name_avl, data, NULL, &idx);
206 uu_avl_insert(mod_name_avl, data, idx);
207
208 uu_avl_node_init(data, &data->d_index_avl, mod_index_avl_pool);
209 (void) uu_avl_find(mod_index_avl, data, NULL, &idx);
210 uu_avl_insert(mod_index_avl, data, idx);
211
212 DEBUGMSGTL((MODNAME_STR, "completed new module %lu/%s@%p\n",
213 data->d_index, data->d_ami_name, data));
214 }
215
216 data->d_valid = valid_stamp;
217
218 DEBUGMSGTL((MODNAME_STR, "timestamp updated for %lu/%s@%p: %d\n",
219 data->d_index, data->d_ami_name, data, data->d_valid));
220
221 if ((update_ctx->uc_type & UCT_ALL) ||
222 update_ctx->uc_index == data->d_index) {
223 (void) strlcpy(data->d_ami_vers, modinfo->ami_vers,
224 sizeof (data->d_ami_vers));
225 (void) strlcpy(data->d_ami_desc, modinfo->ami_desc,
226 sizeof (data->d_ami_desc));
227 data->d_ami_flags = modinfo->ami_flags;
228 }
229
230 return (!(update_ctx->uc_type & UCT_ALL) &&
231 update_ctx->uc_index == data->d_index);
232 }
233
234 /*
235 * Update some or all module data from fmd. If thorough is set, all modules
236 * will be indexed and their data cached. Otherwise, updates will stop once
237 * the module matching index has been updated.
238 *
239 * Returns appropriate SNMP error codes.
240 */
241 static int
modinfo_update(sunFmModule_update_ctx_t * update_ctx)242 modinfo_update(sunFmModule_update_ctx_t *update_ctx)
243 {
244 fmd_adm_t *adm;
245
246 ASSERT(update_ctx != NULL);
247 ASSERT((update_ctx->uc_type & (UCT_INDEX|UCT_ALL)) !=
248 (UCT_INDEX|UCT_ALL));
249 ASSERT((update_ctx->uc_type & ~UCT_FLAGS) == 0);
250 ASSERT(VALID_AVL_STATE);
251
252 if ((adm = fmd_adm_open(update_ctx->uc_host, update_ctx->uc_prog,
253 update_ctx->uc_version)) == NULL) {
254 (void) snmp_log(LOG_ERR, MODNAME_STR ": Communication with fmd "
255 "failed: %s\n", strerror(errno));
256 return (SNMP_ERR_RESOURCEUNAVAILABLE);
257 }
258
259 ++valid_stamp;
260 if (fmd_adm_module_iter(adm, modinfo_update_one, update_ctx) != 0) {
261 (void) snmp_log(LOG_ERR, MODNAME_STR ": fmd module information "
262 "update failed: %s\n", fmd_adm_errmsg(adm));
263 fmd_adm_close(adm);
264 return (SNMP_ERR_RESOURCEUNAVAILABLE);
265 }
266
267 DEBUGMSGTL((MODNAME_STR, "module iteration completed\n"));
268
269 fmd_adm_close(adm);
270 return (SNMP_ERR_NOERROR);
271 }
272
273 __NORETURN static void *
update_thread(void * arg __unused)274 update_thread(void *arg __unused)
275 {
276 /*
277 * The current modinfo_update implementation offers minimal savings
278 * for the use of index-only updates; therefore we always do a full
279 * update. If it becomes advantageous to limit updates to a single
280 * index, the contexts can be queued by the handler instead.
281 */
282 sunFmModule_update_ctx_t uc;
283
284 uc.uc_host = NULL;
285 uc.uc_prog = FMD_ADM_PROGRAM;
286 uc.uc_version = FMD_ADM_VERSION;
287
288 uc.uc_index = 0;
289 uc.uc_type = UCT_ALL;
290
291 for (;;) {
292 (void) pthread_mutex_lock(&update_lock);
293 update_status = US_QUIET;
294 while (update_status == US_QUIET)
295 (void) pthread_cond_wait(&update_cv, &update_lock);
296 update_status = US_INPROGRESS;
297 (void) pthread_mutex_unlock(&update_lock);
298 (void) modinfo_update(&uc);
299 }
300 }
301
302 static void
request_update(void)303 request_update(void)
304 {
305 (void) pthread_mutex_lock(&update_lock);
306 if (update_status != US_QUIET) {
307 (void) pthread_mutex_unlock(&update_lock);
308 return;
309 }
310 update_status = US_NEEDED;
311 (void) pthread_cond_signal(&update_cv);
312 (void) pthread_mutex_unlock(&update_lock);
313 }
314
315 /*ARGSUSED*/
316 static int
module_compare_name(const void * l,const void * r,void * private)317 module_compare_name(const void *l, const void *r, void *private)
318 {
319 sunFmModule_data_t *l_data = (sunFmModule_data_t *)l;
320 sunFmModule_data_t *r_data = (sunFmModule_data_t *)r;
321
322 ASSERT(l_data != NULL && r_data != NULL);
323
324 return (strcmp(l_data->d_ami_name, r_data->d_ami_name));
325 }
326
327 /*ARGSUSED*/
328 static int
module_compare_index(const void * l,const void * r,void * private)329 module_compare_index(const void *l, const void *r, void *private)
330 {
331 sunFmModule_data_t *l_data = (sunFmModule_data_t *)l;
332 sunFmModule_data_t *r_data = (sunFmModule_data_t *)r;
333
334 ASSERT(l_data != NULL && r_data != NULL);
335
336 return (l_data->d_index < r_data->d_index ? -1 :
337 l_data->d_index > r_data->d_index ? 1 : 0);
338 }
339
340 int
sunFmModuleTable_init(void)341 sunFmModuleTable_init(void)
342 {
343 static oid sunFmModuleTable_oid[] = { SUNFMMODULETABLE_OID };
344 netsnmp_table_registration_info *table_info;
345 netsnmp_handler_registration *handler;
346 int err;
347
348 if ((err = pthread_mutex_init(&update_lock, NULL)) != 0) {
349 (void) snmp_log(LOG_ERR, MODNAME_STR ": mutex_init failure: "
350 "%s\n", strerror(err));
351 return (MIB_REGISTRATION_FAILED);
352 }
353 if ((err = pthread_cond_init(&update_cv, NULL)) != 0) {
354 (void) snmp_log(LOG_ERR, MODNAME_STR ": cond_init failure: "
355 "%s\n", strerror(err));
356 return (MIB_REGISTRATION_FAILED);
357 }
358
359 if ((err = pthread_create(NULL, NULL, update_thread, NULL)) != 0) {
360 (void) snmp_log(LOG_ERR, MODNAME_STR ": error creating update "
361 "thread: %s\n", strerror(err));
362 return (MIB_REGISTRATION_FAILED);
363 }
364
365 if ((table_info =
366 SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info)) == NULL)
367 return (MIB_REGISTRATION_FAILED);
368
369 if ((handler = netsnmp_create_handler_registration("sunFmModuleTable",
370 sunFmModuleTable_handler, sunFmModuleTable_oid,
371 OID_LENGTH(sunFmModuleTable_oid), HANDLER_CAN_RONLY)) == NULL) {
372 SNMP_FREE(table_info);
373 return (MIB_REGISTRATION_FAILED);
374 }
375
376 /*
377 * The Net-SNMP template uses add_indexes here, but that
378 * function is unsafe because it does not check for failure.
379 */
380 if (netsnmp_table_helper_add_index(table_info, ASN_UNSIGNED) == NULL) {
381 SNMP_FREE(table_info);
382 SNMP_FREE(handler);
383 return (MIB_REGISTRATION_FAILED);
384 }
385
386 table_info->min_column = SUNFMMODULE_COLMIN;
387 table_info->max_column = SUNFMMODULE_COLMAX;
388
389 if ((mod_name_avl_pool = uu_avl_pool_create("mod_name",
390 sizeof (sunFmModule_data_t),
391 offsetof(sunFmModule_data_t, d_name_avl), module_compare_name,
392 UU_AVL_DEBUG)) == NULL) {
393 snmp_free_varbind(table_info->indexes);
394 SNMP_FREE(table_info);
395 SNMP_FREE(handler);
396 }
397
398 if ((mod_name_avl = uu_avl_create(mod_name_avl_pool, NULL,
399 UU_AVL_DEBUG)) == NULL) {
400 (void) snmp_log(LOG_ERR, MODNAME_STR ": mod_name_avl creation "
401 "failed: %s\n", uu_strerror(uu_error()));
402 snmp_free_varbind(table_info->indexes);
403 SNMP_FREE(table_info);
404 SNMP_FREE(handler);
405 uu_avl_pool_destroy(mod_name_avl_pool);
406 return (MIB_REGISTRATION_FAILED);
407 }
408
409 if ((mod_index_avl_pool = uu_avl_pool_create("mod_index",
410 sizeof (sunFmModule_data_t),
411 offsetof(sunFmModule_data_t, d_index_avl),
412 module_compare_index, UU_AVL_DEBUG)) == NULL) {
413 snmp_free_varbind(table_info->indexes);
414 SNMP_FREE(table_info);
415 SNMP_FREE(handler);
416 uu_avl_destroy(mod_name_avl);
417 uu_avl_pool_destroy(mod_name_avl_pool);
418 }
419
420 if ((mod_index_avl = uu_avl_create(mod_index_avl_pool, NULL,
421 UU_AVL_DEBUG)) == NULL) {
422 (void) snmp_log(LOG_ERR, MODNAME_STR ": mod_index_avl creation "
423 "failed: %s\n", uu_strerror(uu_error()));
424 snmp_free_varbind(table_info->indexes);
425 SNMP_FREE(table_info);
426 SNMP_FREE(handler);
427 uu_avl_destroy(mod_name_avl);
428 uu_avl_pool_destroy(mod_name_avl_pool);
429 uu_avl_pool_destroy(mod_index_avl_pool);
430 return (MIB_REGISTRATION_FAILED);
431 }
432
433 if ((err = netsnmp_register_table(handler, table_info)) !=
434 MIB_REGISTERED_OK) {
435 snmp_free_varbind(table_info->indexes);
436 SNMP_FREE(table_info);
437 SNMP_FREE(handler);
438 uu_avl_destroy(mod_name_avl);
439 uu_avl_pool_destroy(mod_name_avl_pool);
440 uu_avl_destroy(mod_index_avl);
441 uu_avl_pool_destroy(mod_index_avl_pool);
442 return (err);
443 }
444
445 return (MIB_REGISTERED_OK);
446 }
447
448 /*
449 * These two functions form the core of GET/GETNEXT/GETBULK handling (the
450 * only kind we do). They perform two functions:
451 *
452 * - First, frob the request to set all the index variables to correspond
453 * to the value that's going to be returned. For GET, this is a nop;
454 * for GETNEXT/GETBULK it always requires some work.
455 * - Second, find and return the fmd module information corresponding to
456 * the (possibly updated) indices.
457 *
458 * These should be as fast as possible; they run in the agent thread.
459 */
460 static sunFmModule_data_t *
sunFmModuleTable_nextmod(netsnmp_handler_registration * reginfo,netsnmp_table_request_info * table_info)461 sunFmModuleTable_nextmod(netsnmp_handler_registration *reginfo,
462 netsnmp_table_request_info *table_info)
463 {
464 sunFmModule_data_t *data;
465 netsnmp_variable_list *var;
466 ulong_t index;
467
468 /*
469 * If we have no index, we must make one.
470 */
471 if (table_info->number_indexes < 1) {
472 oid tmpoid[MAX_OID_LEN];
473 index = 1;
474
475 DEBUGMSGTL((MODNAME_STR, "nextmod: no indexes given\n"));
476 var = SNMP_MALLOC_TYPEDEF(netsnmp_variable_list);
477 (void) snmp_set_var_typed_value(var, ASN_UNSIGNED,
478 (uchar_t *)&index, sizeof (index));
479 (void) memcpy(tmpoid, reginfo->rootoid,
480 reginfo->rootoid_len * sizeof (oid));
481 tmpoid[reginfo->rootoid_len] = 1; /* Entry is .1 */
482 tmpoid[reginfo->rootoid_len + 1] = table_info->colnum;
483 if (build_oid(&var->name, &var->name_length, tmpoid,
484 reginfo->rootoid_len + 2, var) != SNMPERR_SUCCESS) {
485 snmp_free_varbind(var);
486 return (NULL);
487 }
488 DEBUGMSGTL((MODNAME_STR, "nextmod: built fake index:\n"));
489 DEBUGMSGVAR((MODNAME_STR, var));
490 DEBUGMSG((MODNAME_STR, "\n"));
491 } else {
492 var = snmp_clone_varbind(table_info->indexes);
493 index = *var->val.integer;
494 DEBUGMSGTL((MODNAME_STR, "nextmod: received index:\n"));
495 DEBUGMSGVAR((MODNAME_STR, var));
496 DEBUGMSG((MODNAME_STR, "\n"));
497 index++;
498 }
499
500 snmp_free_varbind(table_info->indexes);
501 table_info->indexes = NULL;
502 table_info->number_indexes = 0;
503
504 if ((data = module_lookup_index_nextvalid(index)) == NULL) {
505 DEBUGMSGTL((MODNAME_STR, "nextmod: exact match not found for "
506 "index %lu; trying next column\n", index));
507 if (table_info->colnum >=
508 netsnmp_find_table_registration_info(reginfo)->max_column) {
509 snmp_free_varbind(var);
510 DEBUGMSGTL((MODNAME_STR, "nextmod: out of columns\n"));
511 return (NULL);
512 }
513 table_info->colnum++;
514 index = 1;
515
516 data = module_lookup_index_nextvalid(index);
517 }
518
519 if (data == NULL) {
520 DEBUGMSGTL((MODNAME_STR, "nextmod: exact match not found for "
521 "index %lu; stopping\n", index));
522 snmp_free_varbind(var);
523 return (NULL);
524 }
525
526 *var->val.integer = data->d_index;
527 table_info->indexes = var;
528 table_info->number_indexes = 1;
529
530 DEBUGMSGTL((MODNAME_STR, "matching data is %lu/%s@%p\n", data->d_index,
531 data->d_ami_name, data));
532
533 return (data);
534 }
535
536 /*ARGSUSED*/
537 static sunFmModule_data_t *
sunFmModuleTable_mod(netsnmp_handler_registration * reginfo,netsnmp_table_request_info * table_info)538 sunFmModuleTable_mod(netsnmp_handler_registration *reginfo,
539 netsnmp_table_request_info *table_info)
540 {
541 ASSERT(table_info->number_indexes == 1);
542
543 return (module_lookup_index_exact(table_info->index_oid[0]));
544 }
545
546 /*ARGSUSED*/
547 static void
sunFmModuleTable_return(unsigned int reg,void * arg)548 sunFmModuleTable_return(unsigned int reg, void *arg)
549 {
550 netsnmp_delegated_cache *cache = (netsnmp_delegated_cache *)arg;
551 netsnmp_request_info *request;
552 netsnmp_agent_request_info *reqinfo;
553 netsnmp_handler_registration *reginfo;
554 netsnmp_table_request_info *table_info;
555 sunFmModule_data_t *data;
556 ulong_t modstate;
557
558 ASSERT(netsnmp_handler_check_cache(cache) != NULL);
559
560 (void) pthread_mutex_lock(&update_lock);
561 if (update_status != US_QUIET) {
562 struct timeval tv;
563
564 tv.tv_sec = UPDATE_WAIT_MILLIS / 1000;
565 tv.tv_usec = (UPDATE_WAIT_MILLIS % 1000) * 1000;
566
567 (void) snmp_alarm_register_hr(tv, 0, sunFmModuleTable_return,
568 cache);
569 (void) pthread_mutex_unlock(&update_lock);
570 return;
571 }
572
573 request = cache->requests;
574 reqinfo = cache->reqinfo;
575 reginfo = cache->reginfo;
576
577 table_info = netsnmp_extract_table_info(request);
578 request->delegated = 0;
579
580 ASSERT(table_info->colnum >= SUNFMMODULE_COLMIN);
581 ASSERT(table_info->colnum <= SUNFMMODULE_COLMAX);
582
583 /*
584 * table_info->colnum contains the column number requested.
585 * table_info->indexes contains a linked list of snmp variable
586 * bindings for the indexes of the table. Values in the list
587 * have been set corresponding to the indexes of the
588 * request. We have other guarantees as well:
589 *
590 * - The column number is always within range.
591 * - If we have no index data, table_info->index_oid_len is 0.
592 * - We will never receive requests outside our table nor
593 * those with the first subid anything other than 1 (Entry)
594 * nor those without a column number. This is true even
595 * for GETNEXT requests.
596 */
597
598 switch (reqinfo->mode) {
599 case MODE_GET:
600 if ((data = sunFmModuleTable_mod(reginfo, table_info)) ==
601 NULL) {
602 netsnmp_free_delegated_cache(cache);
603 (void) pthread_mutex_unlock(&update_lock);
604 return;
605 }
606 break;
607 case MODE_GETNEXT:
608 case MODE_GETBULK:
609 if ((data = sunFmModuleTable_nextmod(reginfo, table_info)) ==
610 NULL) {
611 netsnmp_free_delegated_cache(cache);
612 (void) pthread_mutex_unlock(&update_lock);
613 return;
614 }
615 break;
616 default:
617 (void) snmp_log(LOG_ERR, MODNAME_STR ": Unsupported request "
618 "mode %d\n", reqinfo->mode);
619 netsnmp_free_delegated_cache(cache);
620 (void) pthread_mutex_unlock(&update_lock);
621 return;
622 }
623
624 switch (table_info->colnum) {
625 case SUNFMMODULE_COL_NAME:
626 (void) netsnmp_table_build_result(reginfo, request, table_info,
627 ASN_OCTET_STR, (uchar_t *)data->d_ami_name,
628 strlen(data->d_ami_name));
629 break;
630 case SUNFMMODULE_COL_VERSION:
631 (void) netsnmp_table_build_result(reginfo, request, table_info,
632 ASN_OCTET_STR, (uchar_t *)data->d_ami_vers,
633 strlen(data->d_ami_vers));
634 break;
635 case SUNFMMODULE_COL_STATUS:
636 modstate = (data->d_ami_flags & FMD_ADM_MOD_FAILED) ?
637 SUNFMMODULE_STATE_FAILED : SUNFMMODULE_STATE_ACTIVE;
638 (void) netsnmp_table_build_result(reginfo, request, table_info,
639 ASN_INTEGER, (uchar_t *)&modstate,
640 sizeof (modstate));
641 break;
642 case SUNFMMODULE_COL_DESCRIPTION:
643 (void) netsnmp_table_build_result(reginfo, request, table_info,
644 ASN_OCTET_STR, (uchar_t *)data->d_ami_desc,
645 strlen(data->d_ami_desc));
646 break;
647 default:
648 break;
649 }
650 netsnmp_free_delegated_cache(cache);
651 (void) pthread_mutex_unlock(&update_lock);
652 }
653
654 static int
sunFmModuleTable_handler(netsnmp_mib_handler * handler,netsnmp_handler_registration * reginfo,netsnmp_agent_request_info * reqinfo,netsnmp_request_info * requests)655 sunFmModuleTable_handler(netsnmp_mib_handler *handler,
656 netsnmp_handler_registration *reginfo, netsnmp_agent_request_info *reqinfo,
657 netsnmp_request_info *requests)
658 {
659 netsnmp_request_info *request;
660 struct timeval tv;
661
662 tv.tv_sec = UPDATE_WAIT_MILLIS / 1000;
663 tv.tv_usec = (UPDATE_WAIT_MILLIS % 1000) * 1000;
664
665 request_update();
666
667 for (request = requests; request; request = request->next) {
668 if (request->processed != 0)
669 continue;
670
671 if (netsnmp_extract_table_info(request) == NULL)
672 continue;
673
674 request->delegated = 1;
675 (void) snmp_alarm_register_hr(tv, 0, sunFmModuleTable_return,
676 (void *) netsnmp_create_delegated_cache(handler, reginfo,
677 reqinfo, request, NULL));
678 }
679
680 return (SNMP_ERR_NOERROR);
681 }
682