mmi_register_config_cb

NAME

mmi_register_config_cb - Register callback for configuration events

SYNOPSIS

#include "mmi.h"

typedef enum {MMI_CONFIG_NEW_MODULE, MMI_CONFIG_DELETE_MODULE, MMI_CONFIG_INIT_DONE} mmi_config_t;

typedef void (*fn_config_cb) (void *cb_data, module_t *target, const char *target_name, mmi_config_t event);

bool_t mmi_register_config_cb (module_t *module, fn_config_cb config_cb);

DESCRIPTION

Register config_cb callback for module.

The callback is used to act on configuration events:

MMI_CONFIG_NEW_MODULE: reports that target has been loaded. At this point, it is possible to call mmi_get_interface for target.

MMI_CONFIG_DELETE_MODULE: reports that target has been unloaded. There are two uses:

1) A module detects that itself is being unloaded, and frees any resources.
2) A module detects that another module it has in interface or other reference to is unloaded. Dangling pointers must be deleted.

MMI_CONFIG_INIT_DONE: reports that simulator initialization is complete. The module can reference CPU and other data structures at this point.

mmi_register_config_cb has several side effects:

1) all other modules are notified that the caller is available (MMI_CONFIG_NEW_MODULE),
2) the caller is notified of all modules already loaded (MMI_CONFIG_NEW_MODULE), and
3) the caller is notified immediately if simulator initialization is complete (MMI_CONFIG_INIT_DONE).

RETURN VALUES

ERRORS

USAGE

// config callback
static void module_reconfig(void *cb_data, module_t *target, const char *target_name, mmi_config_t ev)
{
    Module *module = (Module*)cb_data;

    if (target == module->getInstance()) {
	if (ev == MMI_CONFIG_DELETE_MODULE)
	    delete module;
	else if (ev == MMI_CONFIG_INIT_DONE)
	    module->init_done();
    } else if (ev == MMI_CONFIG_NEW_MODULE) {
	module->module_added(target, target_name);
    } else if (ev == MMI_CONFIG_DELETE_MODULE) {
	module->module_deleted(target, target_name);
    }
}

// called during ldm and sysconf, after _init
static void module_create_instance(const char *modname, const char *instance_name)
{
    module_t *instance = mmi_register_module(modname, instance_name, Module::get_help_string());
    if (instance) {
	Module *module = Module::create(modname, instance_name);
	if (!module) {
	    fprintf(stderr, "Module: Could not create object for <%s>\n", instance_name);
	    mmi_unregister_module(instance);
	} else {
	    fprintf(stderr, "Module: modname <%s> instance_name <%s>\n", modname, instance_name);
	    module_parse_args(module, instance);
	    if (!module->check_args()) {
		mmi_unregister_module(instance);
	    } else {
		mmi_register_cb_data(instance, module);
		mmi_register_interface_cb(instance, module_get_interface);
		mmi_register_modinfo_cb(instance, module_get_modinfo);
		mmi_register_config_cb(instance, module_reconfig);
	    }
	}
    }
}

// module init, called during dlopen
extern "C" void _init()
{
    fprintf (stderr, MODNAME ": _init()\n");
    if (! mmi_register_instance_creator (MODNAME, module_create_instance )) {
        fprintf (stderr, MODNAME ": Failed to load\n");
    }
}

// called by dlclose during uldm and exit
extern "C" void _fini()
{
}

SEE ALSO

intro,      mmi_unregister_module

WARNINGS