/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <fm/fmd_adm.h>
#include <fm/fmd_snmp.h>
#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>
#include <pthread.h>
#include <stddef.h>
#include <errno.h>
#include <libuutil.h>
#include "sunFM_impl.h"
#include "module.h"

static uu_avl_pool_t	*mod_name_avl_pool;
static uu_avl_pool_t	*mod_index_avl_pool;
static uu_avl_t		*mod_name_avl;
static uu_avl_t		*mod_index_avl;

#define	VALID_AVL_STATE	(mod_name_avl_pool != NULL &&		\
	mod_index_avl_pool != NULL && mod_name_avl != NULL &&	\
	mod_index_avl != NULL)

#define	UPDATE_WAIT_MILLIS	10	/* poll interval in milliseconds */

/*
 * Update types.  Single-index and all are mutually exclusive.
 */
#define	UCT_INDEX	0x1
#define	UCT_ALL		0x2
#define	UCT_FLAGS	0x3

#define	MODULE_DATA_VALID(d)	((d)->d_valid == valid_stamp)

/*
 * Locking rules are straightforward.  There is only one updater thread
 * for each table, and requests for update that are received while
 * another update is in progress are ignored.  The single per-table lock
 * protects all the data for the table, the valid_stamp and max_index
 * tags for new data, and - importantly - all the hidden static data
 * used by the Net-SNMP library.  The result return callbacks are always
 * called in the master agent thread; holding the table lock is
 * therefore sufficient since only one table's callback can be run at
 * any one time.  Finer-grained locking is possible here but
 * substantially more difficult because nearly all Net-SNMP functions
 * are unsafe.
 *
 * In practice this is more than adequate, since the purpose of
 * threading out the update is to prevent excessively time-consuming
 * data collection from bottlenecking the entire agent, not to improve
 * result throughput (SNMP is not intended to be used for applications
 * requiring high throughput anyway).  If the agent itself ever becomes
 * multithreaded, locking requirements become limited to our local
 * per-table data (the tree, max_index, and valid_stamp), and the
 * implementation could be revisited for better performance.
 */

static ulong_t		max_index;
static int		valid_stamp;
static pthread_mutex_t	update_lock;
static pthread_cond_t	update_cv;
static volatile enum { US_QUIET, US_NEEDED, US_INPROGRESS } update_status;

static Netsnmp_Node_Handler	sunFmModuleTable_handler;

static sunFmModule_data_t *
key_build(const char *name, const ulong_t index)
{
	static sunFmModule_data_t	key;

	key.d_index = index;
	if (name)
		strlcpy(key.d_ami_name, name, sizeof (key.d_ami_name));
	else
		key.d_ami_name[0] = '\0';

	return (&key);
}

/*
 * If name is the name of a module we have previously seen and indexed, return
 * data for it.  Otherwise, return NULL.  Note that the module may not be
 * valid; that is, it may have been removed from the fault manager since its
 * information was last updated.
 */
static sunFmModule_data_t *
module_lookup_name(const char *name)
{
	sunFmModule_data_t	*key;

	key = key_build(name, 0);
	return (uu_avl_find(mod_name_avl, key, NULL, NULL));
}

/*
 * If index corresponds to a module we have previously seen and indexed, return
 * data for it.  Otherwise, return NULL.  Note that the module may not be
 * valid; that is, it may have been removed from the fault manager since its
 * information was last updated.
 */
static sunFmModule_data_t *
module_lookup_index_exact(const ulong_t index)
{
	sunFmModule_data_t	*key;

	key = key_build(NULL, index);
	return (uu_avl_find(mod_index_avl, key, NULL, NULL));
}

/*
 * If index corresponds to a valid (that is, extant as of latest information
 * from the fault manager) fmd module, return the data for that module.
 * Otherwise, return the data for the valid module whose index is as close as
 * possible to index but not lower.  This preserves the lexicographical
 * ordering required for GETNEXT processing.
 */
static sunFmModule_data_t *
module_lookup_index_nextvalid(const ulong_t index)
{
	sunFmModule_data_t	*key, *data;
	uu_avl_index_t		idx;

	key = key_build(NULL, index);

	if ((data = uu_avl_find(mod_index_avl, key, NULL, &idx)) != NULL &&
	    MODULE_DATA_VALID(data))
		return (data);

	data = uu_avl_nearest_next(mod_index_avl, idx);

	while (data != NULL && !MODULE_DATA_VALID(data)) {
		(void) uu_avl_find(mod_index_avl, data, NULL, &idx);
		data = uu_avl_nearest_next(mod_index_avl, idx);
	}

	return (data);
}

/*
 * Possible update the contents of a single module within the cache.  This
 * is our callback from fmd_module_iter.
 */
static int
modinfo_update_one(const fmd_adm_modinfo_t *modinfo, void *arg)
{
	const sunFmModule_update_ctx_t *update_ctx =
	    (sunFmModule_update_ctx_t *)arg;
	sunFmModule_data_t *data = module_lookup_name(modinfo->ami_name);

	/*
	 * An fmd module we haven't seen before.  We're obligated to index
	 * it and link it into our cache so that we can find it, but we're
	 * not obligated to fill it in completely unless we're doing a
	 * thorough update or this is the module we were asked for.  This
	 * avoids unnecessary iteration and memory manipulation for data
	 * we're not going to return for this request.
	 */
	if (data == NULL) {
		uu_avl_index_t idx;

		DEBUGMSGTL((MODNAME_STR, "found new fmd module %s\n",
		    modinfo->ami_name));
		if ((data = SNMP_MALLOC_TYPEDEF(sunFmModule_data_t)) == NULL) {
			snmp_log(LOG_ERR, MODNAME_STR ": Out of memory for "
			    "new module data at %s:%d\n", __FILE__, __LINE__);
			return (1);
		}
		/*
		 * We allocate indices sequentially and never reuse them.
		 * This ensures we can always return valid GETNEXT responses
		 * without having to reindex, and it provides the user a
		 * more consistent view of the fault manager.
		 */
		data->d_index = ++max_index;
		DEBUGMSGTL((MODNAME_STR, "index %lu is %s@%p\n", data->d_index,
		    modinfo->ami_name, data));

		strlcpy(data->d_ami_name, modinfo->ami_name,
		    sizeof (data->d_ami_name));

		uu_avl_node_init(data, &data->d_name_avl, mod_name_avl_pool);
		(void) uu_avl_find(mod_name_avl, data, NULL, &idx);
		uu_avl_insert(mod_name_avl, data, idx);

		uu_avl_node_init(data, &data->d_index_avl, mod_index_avl_pool);
		(void) uu_avl_find(mod_index_avl, data, NULL, &idx);
		uu_avl_insert(mod_index_avl, data, idx);

		DEBUGMSGTL((MODNAME_STR, "completed new module %lu/%s@%p\n",
		    data->d_index, data->d_ami_name, data));
	}

	data->d_valid = valid_stamp;

	DEBUGMSGTL((MODNAME_STR, "timestamp updated for %lu/%s@%p: %lu\n",
	    data->d_index, data->d_ami_name, data, data->d_valid));

	if ((update_ctx->uc_type & UCT_ALL) ||
	    update_ctx->uc_index == data->d_index) {
		strlcpy(data->d_ami_vers, modinfo->ami_vers,
		    sizeof (data->d_ami_vers));
		strlcpy(data->d_ami_desc, modinfo->ami_desc,
		    sizeof (data->d_ami_desc));
		data->d_ami_flags = modinfo->ami_flags;
	}

	return (!(update_ctx->uc_type & UCT_ALL) &&
	    update_ctx->uc_index == data->d_index);
}

/*
 * Update some or all module data from fmd.  If thorough is set, all modules
 * will be indexed and their data cached.  Otherwise, updates will stop once
 * the module matching index has been updated.
 *
 * Returns appropriate SNMP error codes.
 */
static int
modinfo_update(sunFmModule_update_ctx_t *update_ctx)
{
	fmd_adm_t *adm;

	ASSERT(update_ctx != NULL);
	ASSERT((update_ctx->uc_type & (UCT_INDEX|UCT_ALL)) !=
	    (UCT_INDEX|UCT_ALL));
	ASSERT((update_ctx->uc_type & ~UCT_FLAGS) == 0);
	ASSERT(VALID_AVL_STATE);

	if ((adm = fmd_adm_open(update_ctx->uc_host, update_ctx->uc_prog,
	    update_ctx->uc_version)) == NULL) {
		snmp_log(LOG_ERR, MODNAME_STR ": Communication with fmd "
		    "failed: %s\n", strerror(errno));
		return (SNMP_ERR_RESOURCEUNAVAILABLE);
	}

	++valid_stamp;
	if (fmd_adm_module_iter(adm, modinfo_update_one, update_ctx) != 0) {
		snmp_log(LOG_ERR, MODNAME_STR ": fmd module information update "
		    "failed: %s\n", fmd_adm_errmsg(adm));
		fmd_adm_close(adm);
		return (SNMP_ERR_RESOURCEUNAVAILABLE);
	}

	DEBUGMSGTL((MODNAME_STR, "module iteration completed\n"));

	fmd_adm_close(adm);
	return (SNMP_ERR_NOERROR);
}

/*ARGSUSED*/
static void
update_thread(void *arg)
{
	/*
	 * The current modinfo_update implementation offers minimal savings
	 * for the use of index-only updates; therefore we always do a full
	 * update.  If it becomes advantageous to limit updates to a single
	 * index, the contexts can be queued by the handler instead.
	 */
	sunFmModule_update_ctx_t	uc;

	uc.uc_host = NULL;
	uc.uc_prog = FMD_ADM_PROGRAM;
	uc.uc_version = FMD_ADM_VERSION;

	uc.uc_index = 0;
	uc.uc_type = UCT_ALL;

	for (;;) {
		(void) pthread_mutex_lock(&update_lock);
		update_status = US_QUIET;
		while (update_status == US_QUIET)
			(void) pthread_cond_wait(&update_cv, &update_lock);
		update_status = US_INPROGRESS;
		(void) pthread_mutex_unlock(&update_lock);
		(void) modinfo_update(&uc);
	}
}

static void
request_update(void)
{
	(void) pthread_mutex_lock(&update_lock);
	if (update_status != US_QUIET) {
		(void) pthread_mutex_unlock(&update_lock);
		return;
	}
	update_status = US_NEEDED;
	(void) pthread_cond_signal(&update_cv);
	(void) pthread_mutex_unlock(&update_lock);
}

/*ARGSUSED*/
static int
module_compare_name(const void *l, const void *r, void *private)
{
	sunFmModule_data_t	*l_data = (sunFmModule_data_t *)l;
	sunFmModule_data_t	*r_data = (sunFmModule_data_t *)r;

	ASSERT(l_data != NULL && r_data != NULL);

	return (strcmp(l_data->d_ami_name, r_data->d_ami_name));
}

/*ARGSUSED*/
static int
module_compare_index(const void *l, const void *r, void *private)
{
	sunFmModule_data_t	*l_data = (sunFmModule_data_t *)l;
	sunFmModule_data_t	*r_data = (sunFmModule_data_t *)r;

	ASSERT(l_data != NULL && r_data != NULL);

	return (l_data->d_index < r_data->d_index ? -1 :
	    l_data->d_index > r_data->d_index ? 1 : 0);
}

int
sunFmModuleTable_init(void)
{
	static oid sunFmModuleTable_oid[] = { SUNFMMODULETABLE_OID };
	netsnmp_table_registration_info *table_info;
	netsnmp_handler_registration *handler;
	int err;

	if ((err = pthread_mutex_init(&update_lock, NULL)) != 0) {
		snmp_log(LOG_ERR, MODNAME_STR ": mutex_init failure: %s\n",
		    strerror(err));
		return (MIB_REGISTRATION_FAILED);
	}
	if ((err = pthread_cond_init(&update_cv, NULL)) != 0) {
		snmp_log(LOG_ERR, MODNAME_STR ": cond_init failure: %s\n",
		    strerror(err));
		return (MIB_REGISTRATION_FAILED);
	}

	if ((err = pthread_create(NULL, NULL, (void *(*)(void *))update_thread,
	    NULL)) != 0) {
		snmp_log(LOG_ERR, MODNAME_STR ": error creating update "
		    "thread: %s\n", strerror(err));
		return (MIB_REGISTRATION_FAILED);
	}

	if ((table_info =
	    SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info)) == NULL)
		return (MIB_REGISTRATION_FAILED);

	if ((handler = netsnmp_create_handler_registration("sunFmModuleTable",
	    sunFmModuleTable_handler, sunFmModuleTable_oid,
	    OID_LENGTH(sunFmModuleTable_oid), HANDLER_CAN_RONLY)) == NULL) {
		SNMP_FREE(table_info);
		return (MIB_REGISTRATION_FAILED);
	}

	/*
	 * The Net-SNMP template uses add_indexes here, but that
	 * function is unsafe because it does not check for failure.
	 */
	if (netsnmp_table_helper_add_index(table_info, ASN_UNSIGNED) == NULL) {
		SNMP_FREE(table_info);
		SNMP_FREE(handler);
		return (MIB_REGISTRATION_FAILED);
	}

	table_info->min_column = SUNFMMODULE_COLMIN;
	table_info->max_column = SUNFMMODULE_COLMAX;

	if ((mod_name_avl_pool = uu_avl_pool_create("mod_name",
	    sizeof (sunFmModule_data_t),
	    offsetof(sunFmModule_data_t, d_name_avl), module_compare_name,
	    UU_AVL_DEBUG)) == NULL) {
		snmp_free_varbind(table_info->indexes);
		SNMP_FREE(table_info);
		SNMP_FREE(handler);
	}

	if ((mod_name_avl = uu_avl_create(mod_name_avl_pool, NULL,
	    UU_AVL_DEBUG)) == NULL) {
		snmp_log(LOG_ERR, MODNAME_STR ": mod_name_avl creation "
		    "failed: %s\n", uu_strerror(uu_error()));
		snmp_free_varbind(table_info->indexes);
		SNMP_FREE(table_info);
		SNMP_FREE(handler);
		uu_avl_pool_destroy(mod_name_avl_pool);
		return (MIB_REGISTRATION_FAILED);
	}

	if ((mod_index_avl_pool = uu_avl_pool_create("mod_index",
	    sizeof (sunFmModule_data_t),
	    offsetof(sunFmModule_data_t, d_index_avl),
	    module_compare_index, UU_AVL_DEBUG)) == NULL) {
		snmp_free_varbind(table_info->indexes);
		SNMP_FREE(table_info);
		SNMP_FREE(handler);
		uu_avl_destroy(mod_name_avl);
		uu_avl_pool_destroy(mod_name_avl_pool);
	}

	if ((mod_index_avl = uu_avl_create(mod_index_avl_pool, NULL,
	    UU_AVL_DEBUG)) == NULL) {
		snmp_log(LOG_ERR, MODNAME_STR ": mod_index_avl creation "
		    "failed: %s\n", uu_strerror(uu_error()));
		snmp_free_varbind(table_info->indexes);
		SNMP_FREE(table_info);
		SNMP_FREE(handler);
		uu_avl_destroy(mod_name_avl);
		uu_avl_pool_destroy(mod_name_avl_pool);
		uu_avl_pool_destroy(mod_index_avl_pool);
		return (MIB_REGISTRATION_FAILED);
	}

	if ((err = netsnmp_register_table(handler, table_info)) !=
	    MIB_REGISTERED_OK) {
		snmp_free_varbind(table_info->indexes);
		SNMP_FREE(table_info);
		SNMP_FREE(handler);
		uu_avl_destroy(mod_name_avl);
		uu_avl_pool_destroy(mod_name_avl_pool);
		uu_avl_destroy(mod_index_avl);
		uu_avl_pool_destroy(mod_index_avl_pool);
		return (err);
	}

	return (MIB_REGISTERED_OK);
}

/*
 * These two functions form the core of GET/GETNEXT/GETBULK handling (the
 * only kind we do).  They perform two functions:
 *
 * - First, frob the request to set all the index variables to correspond
 *   to the value that's going to be returned.  For GET, this is a nop;
 *   for GETNEXT/GETBULK it always requires some work.
 * - Second, find and return the fmd module information corresponding to
 *   the (possibly updated) indices.
 *
 * These should be as fast as possible; they run in the agent thread.
 */
static sunFmModule_data_t *
sunFmModuleTable_nextmod(netsnmp_handler_registration *reginfo,
    netsnmp_table_request_info *table_info)
{
	sunFmModule_data_t	*data;
	netsnmp_variable_list	*var;
	ulong_t index;

	/*
	 * If we have no index, we must make one.
	 */
	if (table_info->number_indexes < 1) {
		oid tmpoid[MAX_OID_LEN];
		index = 1;

		DEBUGMSGTL((MODNAME_STR, "nextmod: no indexes given\n"));
		var = SNMP_MALLOC_TYPEDEF(netsnmp_variable_list);
		snmp_set_var_typed_value(var, ASN_UNSIGNED, (uchar_t *)&index,
		    sizeof (index));
		memcpy(tmpoid, reginfo->rootoid,
		    reginfo->rootoid_len * sizeof (oid));
		tmpoid[reginfo->rootoid_len] = 1;	/* Entry is .1 */
		tmpoid[reginfo->rootoid_len + 1] = table_info->colnum;
		if (build_oid(&var->name, &var->name_length, tmpoid,
		    reginfo->rootoid_len + 2, var) != SNMPERR_SUCCESS)
			return (NULL);
		DEBUGMSGTL((MODNAME_STR, "nextmod: built fake index:\n"));
		DEBUGMSGVAR((MODNAME_STR, var));
		DEBUGMSG((MODNAME_STR, "\n"));
	} else {
		var = table_info->indexes;
		index = *var->val.integer;
		DEBUGMSGTL((MODNAME_STR, "nextmod: received index:\n"));
		DEBUGMSGVAR((MODNAME_STR, var));
		DEBUGMSG((MODNAME_STR, "\n"));
		index++;
	}

	if ((data = module_lookup_index_nextvalid(index)) == NULL) {
		DEBUGMSGTL((MODNAME_STR, "nextmod: exact match not found for "
		    "index %lu; trying next column\n", index));
		if (table_info->colnum >= SUNFMMODULE_COLMAX) {
			snmp_free_varbind(var);
			table_info->indexes = NULL;
			table_info->number_indexes = 0;
			DEBUGMSGTL((MODNAME_STR, "nextmod: out of columns\n"));
			return (NULL);
		}
		table_info->colnum++;
		index = 1;

		data = module_lookup_index_nextvalid(index);
	}

	if (data == NULL) {
		DEBUGMSGTL((MODNAME_STR, "nextmod: exact match not found for "
		    "index %lu; stopping\n", index));
		snmp_free_varbind(var);
		table_info->indexes = NULL;
		table_info->number_indexes = 0;
		return (NULL);
	}

	*var->val.integer = index;
	table_info->indexes = var;

	DEBUGMSGTL((MODNAME_STR, "matching data is %lu/%s@%p\n", data->d_index,
	    data->d_ami_name, data));

	return (data);
}

/*ARGSUSED*/
static sunFmModule_data_t *
sunFmModuleTable_mod(netsnmp_handler_registration *reginfo,
    netsnmp_table_request_info *table_info)
{
	sunFmModule_data_t	*data;
	netsnmp_variable_list	*var;

	ASSERT(table_info->number_indexes == 1);

	return (module_lookup_index_exact(table_info->index_oid[0]));
}

static void
sunFmModuleTable_return(unsigned int reg, void *arg)
{
	netsnmp_delegated_cache		*cache = (netsnmp_delegated_cache *)arg;
	netsnmp_request_info		*request;
	netsnmp_agent_request_info	*reqinfo;
	netsnmp_handler_registration	*reginfo;
	netsnmp_mib_handler		*handler;
	netsnmp_table_request_info	*table_info;
	netsnmp_variable_list		*var;
	sunFmModule_data_t		*data;
	ulong_t				modstate;

	ASSERT(netsnmp_handler_check_cache(cache) != NULL);

	(void) pthread_mutex_lock(&update_lock);
	if (update_status != US_QUIET) {
		struct timeval			tv;

		tv.tv_sec = UPDATE_WAIT_MILLIS / 1000;
		tv.tv_usec = (UPDATE_WAIT_MILLIS % 1000) * 1000;

		(void) snmp_alarm_register_hr(tv, 0, sunFmModuleTable_return,
		    cache);
		(void) pthread_mutex_unlock(&update_lock);
		return;
	}

	request = cache->requests;
	reqinfo = cache->reqinfo;
	reginfo = cache->reginfo;
	handler = cache->handler;

	var = request->requestvb;
	table_info = netsnmp_extract_table_info(request);
	request->delegated = 0;

	ASSERT(table_info->colnum >= SUNFMMODULE_COLMIN);
	ASSERT(table_info->colnum <= SUNFMMODULE_COLMAX);

	/*
	 * table_info->colnum contains the column number requested.
	 * table_info->indexes contains a linked list of snmp variable
	 * bindings for the indexes of the table.  Values in the list
	 * have been set corresponding to the indexes of the
	 * request.  We have other guarantees as well:
	 *
	 * - The column number is always within range.
	 * - If we have no index data, table_info->index_oid_len is 0.
	 * - We will never receive requests outside our table nor
	 *   those with the first subid anything other than 1 (Entry)
	 *   nor those without a column number.  This is true even
	 *   for GETNEXT requests.
	 */

	switch (reqinfo->mode) {
	case MODE_GET:
		if ((data = sunFmModuleTable_mod(reginfo, table_info)) ==
		    NULL) {
			netsnmp_free_delegated_cache(cache);
			(void) pthread_mutex_unlock(&update_lock);
			return;
		}
		break;
	case MODE_GETNEXT:
	case MODE_GETBULK:
		if ((data = sunFmModuleTable_nextmod(reginfo, table_info)) ==
		    NULL) {
			netsnmp_free_delegated_cache(cache);
			(void) pthread_mutex_unlock(&update_lock);
			return;
		}
		break;
	default:
		snmp_log(LOG_ERR, MODNAME_STR ": Unsupported request "
		    "mode %d\n", reqinfo->mode);
		netsnmp_free_delegated_cache(cache);
		(void) pthread_mutex_unlock(&update_lock);
		return;
	}

	switch (table_info->colnum) {
	case SUNFMMODULE_COL_NAME:
		netsnmp_table_build_result(reginfo, request, table_info,
		    ASN_OCTET_STR, (uchar_t *)data->d_ami_name,
		    strlen(data->d_ami_name));
		break;
	case SUNFMMODULE_COL_VERSION:
		netsnmp_table_build_result(reginfo, request, table_info,
		    ASN_OCTET_STR, (uchar_t *)data->d_ami_vers,
		    strlen(data->d_ami_vers));
		break;
	case SUNFMMODULE_COL_STATUS:
		modstate = (data->d_ami_flags & FMD_ADM_MOD_FAILED) ?
		    SUNFMMODULE_STATE_FAILED : SUNFMMODULE_STATE_ACTIVE;
		netsnmp_table_build_result(reginfo, request, table_info,
		    ASN_INTEGER, (uchar_t *)&modstate,
		    sizeof (modstate));
		break;
	case SUNFMMODULE_COL_DESCRIPTION:
		netsnmp_table_build_result(reginfo, request, table_info,
		    ASN_OCTET_STR, (uchar_t *)data->d_ami_desc,
		    strlen(data->d_ami_desc));
		break;
	default:
		break;
	}
	netsnmp_free_delegated_cache(cache);
	(void) pthread_mutex_unlock(&update_lock);
}

static int
sunFmModuleTable_handler(netsnmp_mib_handler *handler,
    netsnmp_handler_registration *reginfo, netsnmp_agent_request_info *reqinfo,
    netsnmp_request_info *requests)
{
	netsnmp_request_info		*request;
	struct timeval			tv;

	tv.tv_sec = UPDATE_WAIT_MILLIS / 1000;
	tv.tv_usec = (UPDATE_WAIT_MILLIS % 1000) * 1000;

	request_update();

	for (request = requests; request; request = request->next) {
		if (request->processed != 0)
			continue;

		if (netsnmp_extract_table_info(request) == NULL)
			continue;

		request->delegated = 1;
		(void) snmp_alarm_register_hr(tv, 0, sunFmModuleTable_return,
		    (void *) netsnmp_create_delegated_cache(handler, reginfo,
		    reqinfo, request, NULL));
	}

	return (SNMP_ERR_NOERROR);
}