static int
display_locator_state(picl_nodehdl_t locator_node,
locator_info_t *locator_info)
{
char state[PICL_PROPNAMELEN_MAX];
char *display_state;
int err;
err = picl_get_propval_by_name(locator_node, "State",
state, sizeof (state));
if (err != PICL_SUCCESS) {
(void) fprintf(stderr,
gettext("picl_get_propval_by_name failed: %s\n"),
picl_strerror(err));
return (err);
}
if (strcmp(state, locator_info->on) == 0)
display_state = gettext("on");
else if (strcmp(state, locator_info->off) == 0)
display_state = gettext("off");
else
display_state = state;
(void) printf(gettext("The '%s' locator is %s.\n"),
locator_info->name, display_state);
return (err);
}
static int
change_locator_state(picl_nodehdl_t locator_node, locator_info_t *locator_info)
{
picl_prophdl_t state_prop;
char state[PICL_PROPNAMELEN_MAX];
int err;
char *new_state;
err = picl_get_prop_by_name(locator_node, "State", &state_prop);
if (err != PICL_SUCCESS) {
(void) fprintf(stderr,
gettext("picl_get_prop_by_name failed: %s\n"),
picl_strerror(err));
return (err);
}
err = picl_get_propval(state_prop, state, sizeof (state));
if (err != PICL_SUCCESS) {
(void) fprintf(stderr,
gettext("picl_get_propval failed: %s\n"),
picl_strerror(err));
return (err);
}
new_state = (locator_info->new_state) ? locator_info->on :
locator_info->off;
if (strcmp(state, new_state) != 0) {
picl_propinfo_t prop_info;
err = picl_get_propinfo(state_prop, &prop_info);
if (err != PICL_SUCCESS) {
(void) fprintf(stderr,
gettext("picl_get_propinfo failed: %s\n"),
picl_strerror(err));
return (err);
}
err = picl_set_propval(state_prop, new_state, prop_info.size);
if (err != PICL_SUCCESS) {
(void) fprintf(stderr,
gettext("picl_set_propval failed: %s\n"),
picl_strerror(err));
return (err);
}
}
return (err);
}
int32_t
fill_device_from_id(picl_nodehdl_t device_id, char *assoc_id,
picl_nodehdl_t *device)
{
int32_t err;
picl_prophdl_t tbl_hdl;
picl_prophdl_t reference_property;
err = picl_get_propval_by_name(device_id, assoc_id, &tbl_hdl,
sizeof (picl_prophdl_t));
if (err != PICL_SUCCESS) {
#ifdef WORKFILE_DEBUG
if (err != PICL_INVALIDHANDLE) {
log_printf(dgettext(TEXT_DOMAIN,
"fill_device_from_id failure in "
"picl_get_propval_by_name err is %s\n"),
picl_strerror(err));
}
#endif
return (err);
}
err = picl_get_next_by_row(tbl_hdl, &reference_property);
if (err != PICL_SUCCESS) {
#ifdef WORKFILE_DEBUG
log_printf(dgettext(TEXT_DOMAIN,
"fill_device_from_id failure in picl_get_next_by_row"
" err is %s\n"), picl_strerror(err));
#endif
return (err);
}
/* get node associated with reference property */
err = picl_get_propval(reference_property, &(*device),
sizeof (picl_nodehdl_t));
#ifdef WORKFILE_DEBUG
if (err != 0) {
log_printf(dgettext(TEXT_DOMAIN,
"fill_device_from_id failure in picl_get_propval"
" err is %s\n"), picl_strerror(err));
}
#endif
return (err);
}
static void
disp_envc_status()
{
int err;
char *system = "SYSTEM";
picl_nodehdl_t system_node, root;
log_printf(dgettext(TEXT_DOMAIN,
"\n"
"========================= Environmental Status "
"=========================\n\n"));
err = picl_initialize();
if (err != PICL_SUCCESS) {
exit_code = PD_INTERNAL_FAILURE;
goto err_out;
}
err = picl_get_root(&root);
if (err != PICL_SUCCESS) {
exit_code = PD_INTERNAL_FAILURE;
goto err_out;
}
err = find_child_device(root, system, &system_node);
if (err != PICL_SUCCESS) {
exit_code = PD_INTERNAL_FAILURE;
goto err_out;
}
err = print_temps(system_node);
err |= print_keyswitch(system_node);
err |= print_FSP_LEDS(system_node);
err |= print_disk(system_node);
err |= print_fans(system_node);
err |= print_ps(system_node);
if (err != PICL_SUCCESS)
goto err_out;
return;
err_out:
log_printf(dgettext(TEXT_DOMAIN,
"\nEnvironmental reporting error: %s\n"),
picl_strerror(err));
}
int
main(int argc, char **argv)
{
locator_info_t locator_info = {0, 0, 0, 0, 0};
picl_nodehdl_t rooth;
int err;
int c;
int on_flag = 0;
int off_flag = 0;
char *progname;
char *locator_name = DEFAULT_NAME;
(void) setlocale(LC_ALL, "");
(void) textdomain(TEXT_DOMAIN);
if ((progname = strrchr(argv[0], '/')) == NULL)
progname = argv[0];
else
progname++;
while ((c = getopt(argc, argv, "nf")) != EOF) {
switch (c) {
case 'n':
on_flag++;
break;
case 'f':
off_flag++;
break;
case '?':
/*FALLTHROUGH*/
default:
usage(progname);
}
}
if (argc != optind)
usage(progname);
/* We only take one option */
if (on_flag && off_flag)
usage(progname);
err = picl_initialize();
if (err != PICL_SUCCESS) {
(void) fprintf(stderr, gettext("picl_initialize failed: %s\n"),
picl_strerror(err));
exit(2);
}
err = picl_get_root(&rooth);
if (err != PICL_SUCCESS) {
(void) fprintf(stderr, gettext("picl_get_root failed: %s\n"),
picl_strerror(err));
err = 2;
goto OUT;
}
if (on_flag) {
locator_info.locator_func = change_locator_state;
locator_info.new_state = 1;
} else if (off_flag) {
locator_info.locator_func = change_locator_state;
locator_info.new_state = 0;
} else {
locator_info.locator_func = display_locator_state;
}
locator_info.name = locator_name;
err = picl_walk_tree_by_class(rooth, "led", &locator_info,
locator_walker_func);
if (err != PICL_SUCCESS) {
(void) fprintf(stderr,
gettext("picl_walk_tree_by_class failed: %s\n"),
picl_strerror(err));
err = 2;
goto OUT;
}
if (locator_info.found == 0) {
(void) fprintf(stderr, gettext("'%s' locator not found\n"),
locator_name);
err = 2;
}
if (locator_info.err != PICL_SUCCESS)
err = 2;
OUT:
(void) picl_shutdown();
return (err);
}
void
psvc_psr_plugin_init(void)
{
char *funcname = "psvc_plugin_psr_init";
int32_t i;
int err;
boolean_t present;
/*
* So the volatile read/write routines can retrieve data from
* psvc or picl
*/
err = psvc_init(&hdlp);
if (err != 0) {
init_err(PSVC_INIT_ERR, funcname, strerror(errno));
}
/*
* Remove nodes whose devices aren't present from the picl tree.
*/
for (i = 0; i < psvc_hdl.obj_count; ++i) {
picl_psvc_t *objp;
uint64_t features;
objp = &psvc_hdl.objects[i];
err = psvc_get_attr(hdlp, objp->name, PSVC_PRESENCE_ATTR,
&present);
if (err != PSVC_SUCCESS)
continue;
err = psvc_get_attr(hdlp, objp->name, PSVC_FEATURES_ATTR,
&features);
if (err != PSVC_SUCCESS)
continue;
if ((features & (PSVC_DEV_HOTPLUG | PSVC_DEV_OPTION)) &&
(present == PSVC_ABSENT)) {
err = ptree_delete_node(objp->node);
if (err != 0) {
init_err(PTREE_DELETE_NODE_ERR, funcname,
picl_strerror(err));
return;
}
}
}
/*
* Remove PICL device nodes if their /devices file isn't present or
* if the device file is present but the open returns ENXIO
* which indicates that the node file doesn't represent a device
* tree node and is probably a relic from some previous boot config
*/
for (i = 0; i < DEV_PR_COUNT; ++i) {
picl_nodehdl_t dev_pr_node;
int fd;
fd = open(dev_pr_info[i].file, O_RDONLY);
if (fd != -1) {
close(fd);
continue;
}
if ((errno != ENOENT) && (errno != ENXIO))
continue;
err = ptree_get_node_by_path(dev_pr_info[i].path, &dev_pr_node);
if (err != 0) {
syslog(LOG_ERR, "Bad path: %s", dev_pr_info[i].path);
init_err(PTREE_GET_NODE_ERR, funcname,
picl_strerror(err));
return;
}
err = ptree_delete_node(dev_pr_node);
if (err != 0) {
init_err(PTREE_DELETE_NODE_ERR, funcname,
picl_strerror(err));
return;
}
}
free(psvc_hdl.objects);
}
int32_t
fill_device_array_from_id(picl_nodehdl_t device_id, char *assoc_id,
int32_t *number_of_devices, picl_nodehdl_t *device_array[])
{
int32_t err;
int i;
picl_prophdl_t tbl_hdl;
picl_prophdl_t entry;
int devs = 0;
err = picl_get_propval_by_name(device_id, assoc_id, &tbl_hdl,
sizeof (picl_prophdl_t));
if ((err != PICL_SUCCESS) && (err != PICL_INVALIDHANDLE)) {
#ifdef WORKFILE_DEBUG
log_printf(dgettext(TEXT_DOMAIN,
"fill_device_array_from_id failure in "
"picl_get_propval_by_name err is %s\n"), picl_strerror(err));
#endif
return (err);
}
entry = tbl_hdl;
while (picl_get_next_by_row(entry, &entry) == 0)
++devs;
*device_array = calloc((devs), sizeof (picl_nodehdl_t));
if (*device_array == NULL) {
#ifdef WORFILE_DEBUG
log_printf(dgettext(TEXT_DOMAIN,
"fill_device_array_from_id failure getting memory"
" for array\n"));
#endif
return (PICL_FAILURE);
}
entry = tbl_hdl;
for (i = 0; i < devs; i++) {
err = picl_get_next_by_row(entry, &entry);
if (err != 0) {
#ifdef WORKFILE_DEBUG
log_printf(dgettext(TEXT_DOMAIN,
"fill_device_array_from_id failure in "
"picl_get_next_by_row err is %s\n"),
picl_strerror(err));
#endif
return (err);
}
/* get node associated with reference property */
err = picl_get_propval(entry, &((*device_array)[i]),
sizeof (picl_nodehdl_t));
if (err != 0) {
#ifdef WORKFILE_DEBUG
log_printf(dgettext(TEXT_DOMAIN,
"fill_device_array_from_id failure in "
"picl_get_propval err is %s\n"), picl_strerror(err));
#endif
return (err);
}
}
*number_of_devices = devs;
return (err);
}
int32_t
find_child_device(picl_nodehdl_t parent, char *child_name,
picl_nodehdl_t *child)
{
int32_t err;
char name[PICL_PROPNAMELEN_MAX];
err = picl_get_propval_by_name(parent, PICL_PROP_CHILD, &(*child),
sizeof (picl_nodehdl_t));
switch (err) {
case PICL_SUCCESS:
break;
case PICL_PROPNOTFOUND:
err = PICL_INVALIDHANDLE;
return (err);
default:
#ifdef WORKFILE_DEBUG
log_printf(dgettext(TEXT_DOMAIN,
"Failed picl_get_propval_by_name with %s\n"),
picl_strerror(err));
#endif
return (err);
}
err = picl_get_propval_by_name(*child, PICL_PROP_NAME, name,
PICL_PROPNAMELEN_MAX);
#ifdef WORKFILE_DEBUG
if (err != PICL_SUCCESS) {
log_printf(dgettext(TEXT_DOMAIN,
"failed the get name for root\n"));
log_printf(dgettext(TEXT_DOMAIN, "%s\n"), picl_strerror(err));
}
#endif
if (strcmp(name, child_name) == 0)
return (err);
while (err != PICL_PROPNOTFOUND) {
#ifdef WORKFILE_DEBUG
log_printf(dgettext(TEXT_DOMAIN, "child name is %s\n"), name);
#endif
err = picl_get_propval_by_name(*child, PICL_PROP_PEER,
&(*child), sizeof (picl_nodehdl_t));
switch (err) {
case PICL_SUCCESS:
err = picl_get_propval_by_name(*child, PICL_PROP_NAME,
name, PICL_PROPNAMELEN_MAX);
if (strcmp(name, child_name) == 0)
return (err);
break;
case PICL_PROPNOTFOUND:
break;
default:
#ifdef WORKFILE_DEBUG
log_printf(dgettext(TEXT_DOMAIN,
"Failed picl_get_propval_by_name with %s\n"),
picl_strerror(err));
#endif
return (err);
}
}
err = PICL_INVALIDHANDLE;
return (err);
}
