static int
_ipmi_oem (pstdout_state_t pstate,
const char *hostname,
void *arg)
{
ipmi_oem_state_data_t state_data;
ipmi_oem_prog_data_t *prog_data;
int exit_code = EXIT_FAILURE;
assert (pstate);
assert (arg);
prog_data = (ipmi_oem_prog_data_t *)arg;
if (prog_data->args->common_args.flush_cache)
{
if (sdr_cache_flush_cache (pstate,
hostname,
&prog_data->args->common_args) < 0)
return (EXIT_FAILURE);
return (EXIT_SUCCESS);
}
memset (&state_data, '\0', sizeof (ipmi_oem_state_data_t));
state_data.prog_data = prog_data;
state_data.pstate = pstate;
state_data.hostname = (char *)hostname;
/* Special case, we're going to output help info, don't do an IPMI connection */
if (prog_data->args->oem_command)
{
if (!(state_data.ipmi_ctx = ipmi_open (prog_data->progname,
hostname,
&(prog_data->args->common_args),
state_data.pstate)))
goto cleanup;
}
if (!(state_data.sdr_ctx = ipmi_sdr_ctx_create ()))
{
pstdout_perror (pstate, "ipmi_sdr_ctx_create()");
goto cleanup;
}
if (run_cmd_args (&state_data) < 0)
goto cleanup;
exit_code = EXIT_SUCCESS;
cleanup:
ipmi_sdr_ctx_destroy (state_data.sdr_ctx);
ipmi_ctx_close (state_data.ipmi_ctx);
ipmi_ctx_destroy (state_data.ipmi_ctx);
return (exit_code);
}
static void ipmi_free_close(struct ipmi_intf * intf)
{
if (dev) {
#if IPMI_INTF_FREE_0_3_0
ipmi_close_device(dev);
#elif IPMI_INTF_FREE_0_4_0 || IPMI_INTF_FREE_0_5_0
ipmi_close_device(dev);
ipmi_device_destroy(dev);
#elif IPMI_INTF_FREE_0_6_0
ipmi_ctx_close(dev);
ipmi_ctx_destroy(dev);
#endif
}
intf->opened = 0;
}
static void ipmi_free_close(struct ipmi_intf * intf)
{
if (dev) {
#if IPMI_INTF_FREE_0_3_0
ipmi_close_device(dev);
#elif IPMI_INTF_FREE_0_4_0 || IPMI_INTF_FREE_0_5_0
ipmi_close_device(dev);
ipmi_device_destroy(dev);
#elif IPMI_INTF_FREE_0_6_0
ipmi_ctx_close(dev);
ipmi_ctx_destroy(dev);
#endif
}
intf->opened = 0;
intf->manufacturer_id = IPMI_OEM_UNKNOWN;
}
int
main (int argc, char **argv)
{
err_init (argv[0]);
err_set_flags (ERROR_STDERR);
ipmi_disable_coredump ();
bmc_watchdog_argp_parse (argc, argv, &cmd_args);
/* Early initialization. Daemon must do all initialization in
* daemon_init() b/c daemon_init() needs to close all formerly open
* file descriptors.
*/
if (!cmd_args.daemon)
_init_bmc_watchdog ();
if (cmd_args.set)
_set_cmd ();
else if (cmd_args.get)
_get_cmd ();
else if (cmd_args.reset)
_reset_cmd ();
else if (cmd_args.start)
_start_cmd ();
else if (cmd_args.stop)
_stop_cmd ();
else if (cmd_args.clear)
_clear_cmd ();
else if (cmd_args.daemon)
_daemon_cmd (argv[0]);
else
err_exit ("internal error, command not set");
ipmi_ctx_close (ipmi_ctx);
ipmi_ctx_destroy (ipmi_ctx);
closelog ();
exit (EXIT_SUCCESS);
}
/*
* _init_ipmi_config initializes parameters for freeipmi library
*/
static int _init_ipmi_config (void)
{
int ret = 0;
unsigned int workaround_flags_mask =
(IPMI_WORKAROUND_FLAGS_INBAND_ASSUME_IO_BASE_ADDRESS
| IPMI_WORKAROUND_FLAGS_INBAND_SPIN_POLL);
if (ipmi_ctx) {
debug("ipmi_ctx already initialized\n");
return SLURM_SUCCESS;
}
if (!(ipmi_ctx = ipmi_ctx_create())) {
error("ipmi_ctx_create: %s\n", strerror(errno));
goto cleanup;
}
if (getuid() != 0) {
error ("%s: error : must be root to open ipmi devices\n",
__func__);
goto cleanup;
}
/* XCC OEM commands always require to use in-band communication */
if (((slurm_ipmi_conf.driver_type > 0) &&
(slurm_ipmi_conf.driver_type != NO_VAL) &&
(slurm_ipmi_conf.driver_type != IPMI_DEVICE_KCS) &&
(slurm_ipmi_conf.driver_type != IPMI_DEVICE_SSIF) &&
(slurm_ipmi_conf.driver_type != IPMI_DEVICE_OPENIPMI) &&
(slurm_ipmi_conf.driver_type != IPMI_DEVICE_SUNBMC))
|| (slurm_ipmi_conf.workaround_flags & ~workaround_flags_mask)) {
/* IPMI ERROR PARAMETERS */
error ("%s: error: XCC Lenovo plugin only supports in-band communication, incorrect driver type or workaround flags",
__func__);
debug("slurm_ipmi_conf.driver_type=%u slurm_ipmi_conf.workaround_flags=%u",
slurm_ipmi_conf.driver_type,
slurm_ipmi_conf.workaround_flags);
goto cleanup;
}
if (slurm_ipmi_conf.driver_type == NO_VAL) {
if ((ret = ipmi_ctx_find_inband(
ipmi_ctx,
NULL,
slurm_ipmi_conf.disable_auto_probe,
slurm_ipmi_conf.driver_address,
slurm_ipmi_conf.register_spacing,
slurm_ipmi_conf.driver_device,
slurm_ipmi_conf.workaround_flags,
slurm_ipmi_conf.ipmi_flags)) <= 0) {
error("%s: error on ipmi_ctx_find_inband: %s",
__func__, ipmi_ctx_errormsg(ipmi_ctx));
debug("slurm_ipmi_conf.driver_type=%u\n"
"slurm_ipmi_conf.disable_auto_probe=%u\n"
"slurm_ipmi_conf.driver_address=%u\n"
"slurm_ipmi_conf.register_spacing=%u\n"
"slurm_ipmi_conf.driver_device=%s\n"
"slurm_ipmi_conf.workaround_flags=%u\n"
"slurm_ipmi_conf.ipmi_flags=%u",
slurm_ipmi_conf.driver_type,
slurm_ipmi_conf.disable_auto_probe,
slurm_ipmi_conf.driver_address,
slurm_ipmi_conf.register_spacing,
slurm_ipmi_conf.driver_device,
slurm_ipmi_conf.workaround_flags,
slurm_ipmi_conf.ipmi_flags);
goto cleanup;
}
} else {
if ((ipmi_ctx_open_inband(ipmi_ctx,
slurm_ipmi_conf.driver_type,
slurm_ipmi_conf.disable_auto_probe,
slurm_ipmi_conf.driver_address,
slurm_ipmi_conf.register_spacing,
slurm_ipmi_conf.driver_device,
slurm_ipmi_conf.workaround_flags,
slurm_ipmi_conf.ipmi_flags) < 0)) {
error ("%s: error on ipmi_ctx_open_inband: %s",
__func__, ipmi_ctx_errormsg (ipmi_ctx));
debug("slurm_ipmi_conf.driver_type=%u\n"
"slurm_ipmi_conf.disable_auto_probe=%u\n"
"slurm_ipmi_conf.driver_address=%u\n"
"slurm_ipmi_conf.register_spacing=%u\n"
"slurm_ipmi_conf.driver_device=%s\n"
"slurm_ipmi_conf.workaround_flags=%u\n"
"slurm_ipmi_conf.ipmi_flags=%u",
slurm_ipmi_conf.driver_type,
slurm_ipmi_conf.disable_auto_probe,
slurm_ipmi_conf.driver_address,
slurm_ipmi_conf.register_spacing,
slurm_ipmi_conf.driver_device,
slurm_ipmi_conf.workaround_flags,
slurm_ipmi_conf.ipmi_flags);
goto cleanup;
}
}
if (slurm_ipmi_conf.target_channel_number_is_set
|| slurm_ipmi_conf.target_slave_address_is_set) {
if (ipmi_ctx_set_target(
ipmi_ctx,
slurm_ipmi_conf.target_channel_number_is_set ?
&slurm_ipmi_conf.target_channel_number : NULL,
slurm_ipmi_conf.target_slave_address_is_set ?
&slurm_ipmi_conf.target_slave_address : NULL) < 0) {
error ("%s: error on ipmi_ctx_set_target: %s",
__func__, ipmi_ctx_errormsg (ipmi_ctx));
goto cleanup;
}
}
return SLURM_SUCCESS;
cleanup:
ipmi_ctx_close(ipmi_ctx);
ipmi_ctx_destroy(ipmi_ctx);
return SLURM_ERROR;
}
static int ipmi_free_open(struct ipmi_intf * intf)
{
if (getuid() != 0) {
fprintf(stderr, "Permission denied, must be root\n");
return -1;
}
#if IPMI_INTF_FREE_0_3_0
if (!(dev = ipmi_open_inband (IPMI_DEVICE_KCS,
0,
0,
0,
NULL,
IPMI_FLAGS_DEFAULT))) {
if (!(dev = ipmi_open_inband (IPMI_DEVICE_SSIF,
0,
0,
0,
NULL,
IPMI_FLAGS_DEFAULT))) {
perror("ipmi_open_inband()");
goto cleanup;
}
}
#elif IPMI_INTF_FREE_0_4_0
if (!(dev = ipmi_device_create())) {
perror("ipmi_device_create");
goto cleanup;
}
if (ipmi_open_inband (dev,
IPMI_DEVICE_KCS,
0,
0,
0,
NULL,
IPMI_FLAGS_DEFAULT) < 0) {
if (ipmi_open_inband (dev,
IPMI_DEVICE_SSIF,
0,
0,
0,
NULL,
IPMI_FLAGS_DEFAULT) < 0) {
fprintf(stderr,
"ipmi_open_inband(): %s\n",
ipmi_device_strerror(ipmi_device_errnum(dev)));
goto cleanup;
}
}
#elif IPMI_INTF_FREE_0_5_0
if (!(dev = ipmi_device_create())) {
perror("ipmi_device_create");
goto cleanup;
}
if (ipmi_open_inband (dev,
IPMI_DEVICE_KCS,
0,
0,
0,
NULL,
0,
IPMI_FLAGS_DEFAULT) < 0) {
if (ipmi_open_inband (dev,
IPMI_DEVICE_SSIF,
0,
0,
0,
NULL,
0,
IPMI_FLAGS_DEFAULT) < 0) {
fprintf(stderr,
"ipmi_open_inband(): %s\n",
ipmi_device_strerror(ipmi_device_errnum(dev)));
goto cleanup;
}
}
#elif IPMI_INTF_FREE_0_6_0
if (!(dev = ipmi_ctx_create())) {
perror("ipmi_ctx_create");
goto cleanup;
}
if (ipmi_ctx_open_inband (dev,
IPMI_DEVICE_KCS,
0,
0,
0,
NULL,
0,
IPMI_FLAGS_DEFAULT) < 0) {
if (ipmi_ctx_open_inband (dev,
IPMI_DEVICE_SSIF,
0,
0,
0,
NULL,
0,
IPMI_FLAGS_DEFAULT) < 0) {
fprintf(stderr,
"ipmi_open_inband(): %s\n",
ipmi_ctx_strerror(ipmi_ctx_errnum(dev)));
goto cleanup;
}
}
#endif
intf->opened = 1;
return 0;
cleanup:
if (dev) {
#if IPMI_INTF_FREE_0_3_0
ipmi_close_device(dev);
#elif IPMI_INTF_FREE_0_4_0 || IPMI_INTF_FREE_0_5_0
ipmi_close_device(dev);
ipmi_device_destroy(dev);
#elif IPMI_INTF_FREE_0_6_0
ipmi_ctx_close(dev);
ipmi_ctx_destroy(dev);
#endif
}
return -1;
}
ipmi_ctx_t
ipmi_open (const char *progname,
const char *hostname,
struct common_cmd_args *common_args,
pstdout_state_t pstate)
{
ipmi_ctx_t ipmi_ctx = NULL;
unsigned int workaround_flags = 0;
assert (progname);
assert (common_args);
if (!(ipmi_ctx = ipmi_ctx_create ()))
{
PSTDOUT_FPRINTF (pstate,
stderr,
"ipmi_ctx_create: %s",
strerror (errno));
goto cleanup;
}
if (hostname
&& strcasecmp (hostname, "localhost") != 0
&& strcmp (hostname, "127.0.0.1") != 0)
{
if (common_args->driver_type == IPMI_DEVICE_LAN_2_0)
{
parse_get_freeipmi_outofband_2_0_flags (common_args->workaround_flags_outofband_2_0,
&workaround_flags);
if (ipmi_ctx_open_outofband_2_0 (ipmi_ctx,
hostname,
common_args->username,
common_args->password,
(common_args->k_g_len) ? common_args->k_g : NULL,
(common_args->k_g_len) ? common_args->k_g_len : 0,
common_args->privilege_level,
common_args->cipher_suite_id,
common_args->session_timeout,
common_args->retransmission_timeout,
workaround_flags,
(common_args->debug) ? IPMI_FLAGS_DEBUG_DUMP : IPMI_FLAGS_DEFAULT) < 0)
{
if (ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_USERNAME_INVALID
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PASSWORD_INVALID
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_K_G_INVALID
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PRIVILEGE_LEVEL_INSUFFICIENT
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PRIVILEGE_LEVEL_CANNOT_BE_OBTAINED
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_AUTHENTICATION_TYPE_UNAVAILABLE
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_CIPHER_SUITE_ID_UNAVAILABLE
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PASSWORD_VERIFICATION_TIMEOUT
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_HOSTNAME_INVALID
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_IPMI_2_0_UNAVAILABLE
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_CONNECTION_TIMEOUT)
PSTDOUT_FPRINTF (pstate,
stderr,
"%s: %s\n",
progname,
ipmi_ctx_errormsg (ipmi_ctx));
else
PSTDOUT_FPRINTF (pstate,
stderr,
"ipmi_ctx_open_outofband_2_0: %s\n",
ipmi_ctx_errormsg (ipmi_ctx));
goto cleanup;
}
}
else
{
parse_get_freeipmi_outofband_flags (common_args->workaround_flags_outofband,
&workaround_flags);
if (ipmi_ctx_open_outofband (ipmi_ctx,
hostname,
common_args->username,
common_args->password,
common_args->authentication_type,
common_args->privilege_level,
common_args->session_timeout,
common_args->retransmission_timeout,
workaround_flags,
(common_args->debug) ? IPMI_FLAGS_DEBUG_DUMP : IPMI_FLAGS_DEFAULT) < 0)
{
if (ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_USERNAME_INVALID
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PASSWORD_INVALID
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PRIVILEGE_LEVEL_INSUFFICIENT
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PRIVILEGE_LEVEL_CANNOT_BE_OBTAINED
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_AUTHENTICATION_TYPE_UNAVAILABLE
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PASSWORD_VERIFICATION_TIMEOUT
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_HOSTNAME_INVALID
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_CONNECTION_TIMEOUT)
PSTDOUT_FPRINTF (pstate,
stderr,
"%s: %s\n",
progname,
ipmi_ctx_errormsg (ipmi_ctx));
else
PSTDOUT_FPRINTF (pstate,
stderr,
"ipmi_ctx_open_outofband: %s\n",
ipmi_ctx_errormsg (ipmi_ctx));
goto cleanup;
}
}
}
else
{
if (!ipmi_is_root ())
{
PSTDOUT_FPRINTF (pstate,
stderr,
"%s: %s\n",
progname,
ipmi_ctx_strerror (IPMI_ERR_PERMISSION));
goto cleanup;
}
parse_get_freeipmi_inband_flags (common_args->workaround_flags_inband,
&workaround_flags);
if (common_args->driver_type == IPMI_DEVICE_UNKNOWN)
{
int ret;
if ((ret = ipmi_ctx_find_inband (ipmi_ctx,
NULL,
common_args->disable_auto_probe,
common_args->driver_address,
common_args->register_spacing,
common_args->driver_device,
workaround_flags,
(common_args->debug) ? IPMI_FLAGS_DEBUG_DUMP : IPMI_FLAGS_DEFAULT)) < 0)
{
PSTDOUT_FPRINTF (pstate,
stderr,
"ipmi_ctx_find_inband: %s\n",
ipmi_ctx_errormsg (ipmi_ctx));
goto cleanup;
}
if (!ret)
{
PSTDOUT_FPRINTF (pstate,
stderr,
"could not find inband device");
goto cleanup;
}
}
else
{
if (ipmi_ctx_open_inband (ipmi_ctx,
common_args->driver_type,
common_args->disable_auto_probe,
common_args->driver_address,
common_args->register_spacing,
common_args->driver_device,
workaround_flags,
(common_args->debug) ? IPMI_FLAGS_DEBUG_DUMP : IPMI_FLAGS_DEFAULT) < 0)
{
if (ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_DEVICE_NOT_FOUND)
PSTDOUT_FPRINTF (pstate,
stderr,
"%s: %s\n",
progname,
ipmi_ctx_errormsg (ipmi_ctx));
else
PSTDOUT_FPRINTF (pstate,
stderr,
"ipmi_ctx_open_inband: %s\n",
ipmi_ctx_errormsg (ipmi_ctx));
goto cleanup;
}
}
}
if (common_args->target_channel_number_is_set
|| common_args->target_slave_address_is_set)
{
if (ipmi_ctx_set_target (ipmi_ctx,
common_args->target_channel_number_is_set ? &common_args->target_channel_number : NULL,
common_args->target_slave_address_is_set ? &common_args->target_slave_address : NULL) < 0)
{
PSTDOUT_FPRINTF (pstate,
stderr,
"ipmi_ctx_set_target: %s\n",
ipmi_ctx_errormsg (ipmi_ctx));
goto cleanup;
}
}
return (ipmi_ctx);
cleanup:
ipmi_ctx_close (ipmi_ctx);
ipmi_ctx_destroy (ipmi_ctx);
return (NULL);
}
int main(int argc, char *argv[])
{
uint8_t threadid_main = 0;
pthread_key_create(&threadid_key, NULL);
pthread_setspecific(threadid_key, &threadid_main);
mprintf("University of Wisconsin IPMI MicroTCA System Manager\n");
if (argc > 1 && strcmp(argv[1], "--version") == 0) {
mprintf("\nCompiled from %s@%s\n", (GIT_BRANCH[0] ? GIT_BRANCH : "git-archive"), (GIT_COMMIT[0] ? GIT_COMMIT : "27868b9b800d107fbb53b68c2fce207144f97a98"));
if (strlen(GIT_DIRTY) > 1)
mprintf("%s", GIT_DIRTY);
mprintf("\n");
return 0;
}
/*
* Parse Configuration
*/
cfg_opt_t opts_auth[] =
{
CFG_STR_LIST(const_cast<char *>("raw"), const_cast<char *>("{}"), CFGF_NONE),
CFG_STR_LIST(const_cast<char *>("manage"), const_cast<char *>("{}"), CFGF_NONE),
CFG_STR_LIST(const_cast<char *>("read"), const_cast<char *>("{}"), CFGF_NONE),
CFG_END()
};
cfg_opt_t opts_crate[] =
{
CFG_STR(const_cast<char *>("host"), const_cast<char *>(""), CFGF_NONE),
CFG_STR(const_cast<char *>("description"), const_cast<char *>(""), CFGF_NONE),
CFG_STR(const_cast<char *>("username"), const_cast<char *>(""), CFGF_NONE),
CFG_STR(const_cast<char *>("password"), const_cast<char *>(""), CFGF_NONE),
CFG_INT_CB(const_cast<char *>("authtype"), 0, CFGF_NONE, cfg_parse_authtype),
CFG_INT_CB(const_cast<char *>("mch"), 0, CFGF_NONE, cfg_parse_MCH),
CFG_BOOL(const_cast<char *>("enabled"), cfg_true, CFGF_NONE),
CFG_END()
};
cfg_opt_t opts_cardmodule[] =
{
CFG_STR(const_cast<char *>("module"), const_cast<char *>(""), CFGF_NONE),
CFG_STR_LIST(const_cast<char *>("config"), const_cast<char *>("{}"), CFGF_NONE),
CFG_END()
};
cfg_opt_t opts[] =
{
CFG_SEC(const_cast<char *>("authentication"), opts_auth, CFGF_NONE),
CFG_SEC(const_cast<char *>("crate"), opts_crate, CFGF_MULTI),
CFG_SEC(const_cast<char *>("cardmodule"), opts_cardmodule, CFGF_MULTI),
CFG_INT(const_cast<char *>("socket_port"), 4681, CFGF_NONE),
CFG_INT(const_cast<char *>("ratelimit_delay"), 0, CFGF_NONE),
CFG_BOOL(const_cast<char *>("daemonize"), cfg_false, CFGF_NONE),
CFG_END()
};
cfg_t *cfg = cfg_init(opts, CFGF_NONE);
cfg_set_validate_func(cfg, "crate|host", &cfg_validate_hostname);
cfg_set_validate_func(cfg, "socket_port", &cfg_validate_port);
if (argc >= 2 && access(argv[1], R_OK) == 0) {
if(cfg_parse(cfg, argv[1]) == CFG_PARSE_ERROR)
exit(1);
}
else if (access(CONFIG_PATH "/" CONFIG_FILE, R_OK) == 0) {
if(cfg_parse(cfg, CONFIG_PATH "/" CONFIG_FILE) == CFG_PARSE_ERROR)
exit(1);
}
else {
printf("Config file %s not found, and no argument supplied.\n", CONFIG_PATH "/" CONFIG_FILE);
printf("Try: %s sysmgr.conf\n", argv[0]);
exit(1);
}
bool crate_found = false;
bool crate_enabled = false;
cfg_t *cfgauth = cfg_getsec(cfg, "authentication");
for(unsigned int i = 0; i < cfg_size(cfgauth, "raw"); i++)
config_authdata.raw.push_back(std::string(cfg_getnstr(cfgauth, "raw", i)));
for(unsigned int i = 0; i < cfg_size(cfgauth, "manage"); i++)
config_authdata.manage.push_back(std::string(cfg_getnstr(cfgauth, "manage", i)));
for(unsigned int i = 0; i < cfg_size(cfgauth, "read"); i++)
config_authdata.read.push_back(std::string(cfg_getnstr(cfgauth, "read", i)));
for(unsigned int i = 0; i < cfg_size(cfg, "crate"); i++) {
cfg_t *cfgcrate = cfg_getnsec(cfg, "crate", i);
crate_found = true;
enum Crate::Mfgr MCH;
switch (cfg_getint(cfgcrate, "mch")) {
case Crate::VADATECH: MCH = Crate::VADATECH; break;
case Crate::NAT: MCH = Crate::NAT; break;
}
const char *user = cfg_getstr(cfgcrate, "username");
const char *pass = cfg_getstr(cfgcrate, "password");
Crate *crate = new Crate(i+1, MCH, cfg_getstr(cfgcrate, "host"), (user[0] ? user : NULL), (pass[0] ? pass : NULL), cfg_getint(cfgcrate, "authtype"), cfg_getstr(cfgcrate, "description"));
bool enabled = (cfg_getbool(cfgcrate, "enabled") == cfg_true);
if (enabled)
crate_enabled = true;
threadlocal.push_back(threadlocaldata_t(crate, enabled));
}
for(unsigned int i = 0; i < cfg_size(cfg, "cardmodule"); i++) {
cfg_t *cfgmodule = cfg_getnsec(cfg, "cardmodule", i);
const char *module = cfg_getstr(cfgmodule, "module");
std::vector<std::string> configdata;
for(unsigned int i = 0; i < cfg_size(cfgmodule, "config"); i++)
configdata.push_back(std::string(cfg_getnstr(cfgmodule, "config", i)));
std::string default_module_path = DEFAULT_MODULE_PATH;
if (getenv("SYSMGR_MODULE_PATH") != NULL)
default_module_path = getenv("SYSMGR_MODULE_PATH");
std::string modulepath = module;
if (modulepath.find("/") == std::string::npos)
modulepath = default_module_path +"/"+ modulepath;
cardmodule_t cm;
cm.dl_addr = dlopen(modulepath.c_str(), RTLD_NOW|RTLD_GLOBAL);
if (cm.dl_addr == NULL) {
printf("Error loading module %s:\n\t%s\n", module, dlerror());
exit(2);
}
void *sym;
#define LOAD_SYM(name, type) \
sym = dlsym(cm.dl_addr, #name); \
if (sym == NULL) { \
mprintf("Error loading module %s " type " " #name ":\n\t%s\n", module, dlerror()); \
exit(2); \
}
LOAD_SYM(APIVER, "variable");
cm.APIVER = *reinterpret_cast<uint32_t*>(sym);
LOAD_SYM(MIN_APIVER, "variable");
cm.MIN_APIVER = *reinterpret_cast<uint32_t*>(sym);
if (cm.APIVER < 2 || cm.MIN_APIVER > 2) {
mprintf("Error loading module %s: Incompatible API version %u\n", module, cm.APIVER);
}
LOAD_SYM(initialize_module, "function");
cm.initialize_module = reinterpret_cast<bool (*)(std::vector<std::string>)>(sym);
LOAD_SYM(instantiate_card, "function");
cm.instantiate_card = reinterpret_cast<Card* (*)(Crate*, std::string, void*, uint8_t)>(sym);
#undef LOAD_SYM
if (!cm.initialize_module(configdata)) {
printf("Error loading module %s: initialize_module() returned false\n", module);
exit(2);
}
card_modules.insert(card_modules.begin(), cm);
}
uint16_t port = cfg_getint(cfg, "socket_port");
config_ratelimit_delay = cfg_getint(cfg, "ratelimit_delay");
bool daemonize = (cfg_getbool(cfg, "daemonize") == cfg_true);
cfg_free(cfg);
if (!crate_found) {
printf("No crate specified in the configuration file.\n");
exit(1);
}
if (!crate_enabled) {
printf("No crates are enabled in the configuration file.\n");
printf("No crates to service.\n");
exit(1);
}
if (daemonize) {
do_fork();
stdout_use_syslog = true;
mprintf("University of Wisconsin IPMI MicroTCA System Manager\n");
}
/*
* Initialize library crypto routines before spawning threads.
* This connect will fail due to hostname too long, after running the crypt init functions.
*
* Max Hostname Limit: 64
*/
ipmi_ctx_t dummy_ipmi_ctx = ipmi_ctx_create();
if (ipmi_ctx_open_outofband_2_0(dummy_ipmi_ctx,
".................................................................", // hostname
NULL, // username
NULL, // password
NULL, // k_g
0, // k_g_len,
4, // privilege_level
0, // cipher_suite_id
0, // session_timeout
5, // retransmission_timeout
IPMI_WORKAROUND_FLAGS_OUTOFBAND_2_0_OPEN_SESSION_PRIVILEGE, // workaround_flags
IPMI_FLAGS_DEFAULT // flags
) == 0) {
ipmi_ctx_close(dummy_ipmi_ctx);
}
ipmi_ctx_destroy(dummy_ipmi_ctx);
/*
* Instantiate Worker Threads
*/
for (std::vector<threadlocaldata_t>::iterator it = threadlocal.begin(); it != threadlocal.end(); it++)
if (it->enabled)
pthread_create(&it->thread, NULL, crate_monitor, (void *)it->crate->get_number());
#ifndef DEBUG_ONESHOT
protocol_server(port);
#endif
for (std::vector<threadlocaldata_t>::iterator it = threadlocal.begin(); it != threadlocal.end(); it++)
if (it->enabled)
pthread_join(it->thread, NULL);
}
static int
_ipmi_sensors_config (pstdout_state_t pstate,
const char *hostname,
void *arg)
{
ipmi_sensors_config_state_data_t state_data;
ipmi_sensors_config_prog_data_t *prog_data;
int exit_code = EXIT_FAILURE;
config_err_t ret = 0;
int file_opened = 0;
FILE *fp = NULL; /* init NULL to remove warnings */
assert (pstate);
assert (arg);
prog_data = (ipmi_sensors_config_prog_data_t *) arg;
if (prog_data->args->config_args.common_args.flush_cache)
{
if (sdr_cache_flush_cache (pstate,
hostname,
&prog_data->args->config_args.common_args) < 0)
return (EXIT_FAILURE);
return (EXIT_SUCCESS);
}
memset (&state_data, '\0', sizeof (ipmi_sensors_config_state_data_t));
state_data.prog_data = prog_data;
state_data.pstate = pstate;
if (!(state_data.ipmi_ctx = ipmi_open (prog_data->progname,
hostname,
&(prog_data->args->config_args.common_args),
state_data.pstate)))
goto cleanup;
if (!(state_data.sdr_ctx = ipmi_sdr_ctx_create ()))
{
pstdout_perror (pstate, "ipmi_sdr_ctx_create()");
goto cleanup;
}
if (sdr_cache_create_and_load (state_data.sdr_ctx,
NULL,
state_data.ipmi_ctx,
hostname,
&state_data.prog_data->args->config_args.common_args) < 0)
goto cleanup;
if (!(state_data.sections = ipmi_sensors_config_sections_create (&state_data)))
goto cleanup;
if (prog_data->args->config_args.action == CONFIG_ACTION_CHECKOUT)
{
if (prog_data->args->config_args.filename)
{
if (prog_data->hosts_count > 1)
{
pstdout_fprintf (pstate,
stderr,
"Cannot output multiple host checkout into a single file\n");
goto cleanup;
}
if (!(fp = fopen (prog_data->args->config_args.filename, "w")))
{
pstdout_perror (pstate, "fopen");
goto cleanup;
}
file_opened++;
}
else
fp = stdout;
}
else if (prog_data->args->config_args.action == CONFIG_ACTION_COMMIT
|| prog_data->args->config_args.action == CONFIG_ACTION_DIFF)
{
if (prog_data->args->config_args.filename
&& strcmp (prog_data->args->config_args.filename, "-"))
{
if (!(fp = fopen (prog_data->args->config_args.filename, "r")))
{
pstdout_perror (pstate, "fopen");
goto cleanup;
}
file_opened++;
}
else
fp = stdin;
}
/* parse if there is an input file or no pairs at all */
if ((prog_data->args->config_args.action == CONFIG_ACTION_COMMIT
&& prog_data->args->config_args.filename)
|| (prog_data->args->config_args.action == CONFIG_ACTION_COMMIT
&& !prog_data->args->config_args.filename
&& !prog_data->args->config_args.keypairs)
|| (prog_data->args->config_args.action == CONFIG_ACTION_DIFF
&& prog_data->args->config_args.filename)
|| (prog_data->args->config_args.action == CONFIG_ACTION_DIFF
&& !prog_data->args->config_args.filename
&& !prog_data->args->config_args.keypairs))
{
if (config_parse (pstate,
state_data.sections,
&(prog_data->args->config_args),
fp) < 0)
{
/* errors printed in function call */
goto cleanup;
}
}
/* note: argp validation catches if user specified keypair and
filename for a diff
*/
if ((prog_data->args->config_args.action == CONFIG_ACTION_CHECKOUT
|| prog_data->args->config_args.action == CONFIG_ACTION_COMMIT
|| prog_data->args->config_args.action == CONFIG_ACTION_DIFF)
&& prog_data->args->config_args.keypairs)
{
if (config_sections_insert_keyvalues (pstate,
state_data.sections,
prog_data->args->config_args.keypairs) < 0)
{
/* errors printed in function call */
goto cleanup;
}
}
if (prog_data->args->config_args.action == CONFIG_ACTION_COMMIT
|| prog_data->args->config_args.action == CONFIG_ACTION_DIFF)
{
int num;
if ((num = config_sections_validate_keyvalue_inputs (pstate,
state_data.sections,
&state_data)) < 0)
goto cleanup;
/* some errors found */
if (num)
goto cleanup;
}
if (prog_data->args->config_args.action == CONFIG_ACTION_CHECKOUT
&& prog_data->args->config_args.section_strs)
{
struct config_section_str *sstr;
sstr = prog_data->args->config_args.section_strs;
while (sstr)
{
if (!config_find_section (state_data.sections,
sstr->section_name))
{
pstdout_fprintf (pstate,
stderr,
"Unknown section `%s'\n",
sstr->section_name);
goto cleanup;
}
sstr = sstr->next;
}
}
switch (prog_data->args->config_args.action)
{
case CONFIG_ACTION_CHECKOUT:
if (prog_data->args->config_args.section_strs)
{
struct config_section_str *sstr;
/* note: argp validation catches if user specified --section
* and --keypair, so all_keys_if_none_specified should be '1'.
*/
sstr = prog_data->args->config_args.section_strs;
while (sstr)
{
struct config_section *s;
config_err_t this_ret;
if (!(s = config_find_section (state_data.sections,
sstr->section_name)))
{
pstdout_fprintf (pstate,
stderr,
"## FATAL: Cannot checkout section '%s'\n",
sstr->section_name);
continue;
}
this_ret = config_checkout_section (pstate,
s,
&(prog_data->args->config_args),
1,
fp,
75,
&state_data);
if (this_ret != CONFIG_ERR_SUCCESS)
ret = this_ret;
if (ret == CONFIG_ERR_FATAL_ERROR)
break;
sstr = sstr->next;
}
}
else
{
int all_keys_if_none_specified = 0;
if (!prog_data->args->config_args.keypairs)
all_keys_if_none_specified++;
ret = config_checkout (pstate,
state_data.sections,
&(prog_data->args->config_args),
all_keys_if_none_specified,
fp,
75,
&state_data);
}
break;
case CONFIG_ACTION_COMMIT:
ret = config_commit (pstate,
state_data.sections,
&(prog_data->args->config_args),
&state_data);
break;
case CONFIG_ACTION_DIFF:
ret = config_diff (pstate,
state_data.sections,
&(prog_data->args->config_args),
&state_data);
break;
case CONFIG_ACTION_LIST_SECTIONS:
ret = config_output_sections_list (pstate, state_data.sections);
break;
}
if (ret == CONFIG_ERR_FATAL_ERROR)
{
exit_code = CONFIG_FATAL_EXIT_VALUE;
goto cleanup;
}
if (ret == CONFIG_ERR_NON_FATAL_ERROR)
{
exit_code = CONFIG_NON_FATAL_EXIT_VALUE;
goto cleanup;
}
exit_code = EXIT_SUCCESS;
cleanup:
ipmi_sdr_ctx_destroy (state_data.sdr_ctx);
ipmi_ctx_close (state_data.ipmi_ctx);
ipmi_ctx_destroy (state_data.ipmi_ctx);
config_sections_destroy (state_data.sections);
if (file_opened)
fclose (fp);
return (exit_code);
}
