#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/errno.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <libdevice.h>
#include <libdevinfo.h>
#include <sys/sunddi.h>
typedef struct cmds {
char *cmdname;
int (*cmdf)(devctl_hdl_t);
} cmds_t;
extern int errno;
static void setpname(char *name);
static void print_bus_state(char *devname, uint_t state);
static void print_dev_state(char *devname, uint_t state);
static int dev_getstate(devctl_hdl_t);
static int bus_getstate(devctl_hdl_t);
static int bus_devcreate(devctl_hdl_t);
static void run_list_ctlrs(void);
static struct cmds *dc_cmd();
static int nexif(di_node_t din, di_minor_t dim, void *arg);
static void *s_malloc(size_t);
static void *s_realloc(void *, size_t);
static char *s_strdup(char *);
static int dev_pm_testbusy(devctl_hdl_t);
static int bus_pm_teststrict(devctl_hdl_t);
static char *devctl_device;
static char *orig_path;
static char *devctl_cmdname;
static char *progname;
static int verbose;
static int debug;
static char *dev_name;
static char **dev_props;
static const char *usage = "%s [-v] list | online | offline | remove |\n"
"\tquiesce | unquiesce | configure | unconfigure |\n"
"\t{bus,dev}-reset {bus,dev}-getstate | {bus,dev}-raisepower |\n"
"\t{bus,dev}-idlecomp | {bus,dev}-busycomp |\n"
"\t{bus,dev}-changepowerhigh | {bus,dev}-changepowerlow |\n"
"\t{bus,dev}-testbusy | {bus,dev}-failsuspend | dev-changeonresume |\n"
"\tdev-promprintf | dev-nolowerpower | bus-teststrict |\n"
"\tbus-noinvol [/dev/... | /devices/...]\n";
static struct cmds device_cmds[] = {
{"online", devctl_device_online},
{"offline", devctl_device_offline},
{"remove", devctl_device_remove},
{"dev-reset", devctl_device_reset},
{"dev-getstate", dev_getstate},
{"dev-raisepower", devctl_pm_raisepower},
{"dev-busycomp", devctl_pm_busycomponent},
{"dev-idlecomp", devctl_pm_idlecomponent},
{"dev-testbusy", dev_pm_testbusy},
{"dev-changepowerlow", devctl_pm_changepowerlow},
{"dev-changepowerhigh", devctl_pm_changepowerhigh},
{"dev-failsuspend", devctl_pm_failsuspend},
{"dev-changeonresume", devctl_pm_device_changeonresume},
{"dev-promprintf", devctl_pm_device_promprintf},
{"dev-nolowerpower", devctl_pm_device_no_lower_power},
{NULL, NULL},
};
static struct cmds bus_cmds[] = {
{"quiesce", devctl_bus_quiesce},
{"unquiesce", devctl_bus_unquiesce},
{"bus-reset", devctl_bus_reset},
{"configure", devctl_bus_configure},
{"unconfigure", devctl_bus_unconfigure},
{"bus-getstate", bus_getstate},
{"bus-devcreate", bus_devcreate},
{"bus-raisepower", devctl_pm_raisepower},
{"bus-busycomp", devctl_pm_busycomponent},
{"bus-idlecomp", devctl_pm_idlecomponent},
{"bus-changepowerlow", devctl_pm_changepowerlow},
{"bus-changepowerhigh", devctl_pm_changepowerhigh},
{"bus-testbusy", dev_pm_testbusy},
{"bus-failsuspend", devctl_pm_failsuspend},
{"bus-teststrict", bus_pm_teststrict},
{"bus-noinvol", devctl_pm_bus_no_invol},
{NULL, NULL},
};
int
main(int argc, char *argv[])
{
int c;
int rv;
int pathlen;
struct cmds *dcmd;
devctl_hdl_t dcp;
struct stat stat_buf;
setpname(argv[0]);
while ((c = getopt(argc, argv, "vd")) != -1) {
switch (c) {
case 'v':
++verbose;
break;
case 'd':
++debug;
(void) putenv("LIBDEVICE_DEBUG");
break;
default:
(void) fprintf(stderr, usage, progname);
exit(1);
}
}
if (optind == argc) {
(void) fprintf(stderr, usage, progname);
exit(-1);
}
devctl_cmdname = argv[optind++];
if (strcmp(devctl_cmdname, "list") == 0) {
run_list_ctlrs();
exit(0);
}
if (((optind + 1) > argc)) {
(void) fprintf(stderr, usage, progname);
exit(-1);
}
orig_path = s_strdup(argv[optind]);
devctl_device = s_malloc(MAXPATHLEN);
(void) strcpy(devctl_device, orig_path);
if ((optind + 1 < argc) &&
strcmp(devctl_cmdname, "bus-devcreate") == 0) {
int i;
optind++;
dev_name = s_strdup(argv[optind]);
i = argc - optind;
dev_props = s_malloc(i * sizeof (char *));
while (--i) {
dev_props[i - 1] = s_strdup(argv[optind + i]);
}
}
if (lstat(orig_path, &stat_buf) == 0) {
if (S_ISLNK(stat_buf.st_mode)) {
if ((pathlen = readlink(orig_path, devctl_device,
MAXPATHLEN)) == -1) {
(void) fprintf(stderr,
"devctl: readlink(%s) - %s\n",
orig_path, strerror(errno));
exit(-1);
}
devctl_device[pathlen] = '\0';
}
}
if ((dcmd = dc_cmd(device_cmds, devctl_cmdname)) == NULL) {
dcmd = dc_cmd(bus_cmds, devctl_cmdname);
if (dcmd == NULL) {
(void) fprintf(stderr, "unrecognized command (%s)\n",
devctl_cmdname);
(void) fprintf(stderr, usage, progname);
exit(1);
} else if (strcmp(devctl_cmdname, "bus-raisepower") == 0 ||
strcmp(devctl_cmdname, "bus-changepowerlow") == 0 ||
strcmp(devctl_cmdname, "bus-changepowerhigh") == 0 ||
strcmp(devctl_cmdname, "bus-idlecomp") == 0 ||
strcmp(devctl_cmdname, "bus-busycomp") == 0 ||
strcmp(devctl_cmdname, "bus-testbusy") == 0 ||
strcmp(devctl_cmdname, "bus-failsuspend") == 0 ||
strcmp(devctl_cmdname, "bus-teststrict") == 0 ||
strcmp(devctl_cmdname, "bus-noinvol") == 0) {
dcp = devctl_pm_bus_acquire(devctl_device, 0);
if (dcp == NULL) {
(void) fprintf(stderr,
"devctl: device_pm_bus_acquire %s - %s\n",
devctl_device, strerror(errno));
exit(-1);
}
} else {
dcp = devctl_bus_acquire(devctl_device, 0);
if (dcp == NULL) {
(void) fprintf(stderr, "devctl: bus_acquire "
"%s - %s\n",
devctl_device, strerror(errno));
exit(-1);
}
}
} else if (strcmp(devctl_cmdname, "dev-raisepower") == 0 ||
strcmp(devctl_cmdname, "dev-changepowerlow") == 0 ||
strcmp(devctl_cmdname, "dev-changepowerhigh") == 0 ||
strcmp(devctl_cmdname, "dev-idlecomp") == 0 ||
strcmp(devctl_cmdname, "dev-busycomp") == 0 ||
strcmp(devctl_cmdname, "dev-testbusy") == 0 ||
strcmp(devctl_cmdname, "dev-failsuspend") == 0 ||
strcmp(devctl_cmdname, "dev-changeonresume") == 0 ||
strcmp(devctl_cmdname, "dev-promprintf") == 0 ||
strcmp(devctl_cmdname, "dev-nolowerpower") == 0) {
dcp = devctl_pm_dev_acquire(devctl_device, 0);
if (dcp == NULL) {
(void) fprintf(stderr,
"devctl: device_pm_dev_acquire %s - %s\n",
devctl_device, strerror(errno));
exit(-1);
}
} else {
dcp = devctl_device_acquire(devctl_device, 0);
if (dcp == NULL) {
(void) fprintf(stderr,
"devctl: device_acquire %s - %s\n",
devctl_device, strerror(errno));
exit(-1);
}
}
if (verbose)
(void) printf("devctl: cmd (%s) device (%s)\n",
devctl_cmdname, orig_path);
(void) fflush(NULL);
rv = (dcmd->cmdf)(dcp);
if (rv == -1) {
perror("devctl");
exit(-1);
}
return (0);
}
static int
dev_pm_testbusy(devctl_hdl_t dcp)
{
int rv;
uint_t *busyp;
busyp = s_malloc(sizeof (uint_t));
rv = devctl_pm_testbusy(dcp, busyp);
if (rv != -1)
(void) printf("%s: busy state %d\n", orig_path, *busyp);
return (0);
}
static int
bus_pm_teststrict(devctl_hdl_t dcp)
{
int rv;
uint_t *strict;
strict = s_malloc(sizeof (uint_t));
rv = devctl_pm_bus_teststrict(dcp, strict);
if (rv != -1)
(void) printf("%s: strict %d\n", orig_path, *strict);
return (0);
}
static int
dev_getstate(devctl_hdl_t dcp)
{
int rv;
uint_t state;
rv = devctl_device_getstate(dcp, &state);
if (rv != -1)
print_dev_state(orig_path, state);
return (0);
}
static int
bus_getstate(devctl_hdl_t dcp)
{
int rv;
uint_t state;
rv = devctl_bus_getstate(dcp, &state);
if (rv != -1)
print_bus_state(orig_path, state);
return (0);
}
static void
add_prop(devctl_ddef_t ddef_hdl, char *prop_str)
{
char *pname, *pval, *tmp;
char **strs = NULL;
int nstr;
tmp = strchr(prop_str, '=');
if (tmp == NULL) {
(void) fprintf(stderr, "invalid property %s", prop_str);
exit(-1);
}
(void) printf("prop string: %s\n", prop_str);
pname = prop_str;
*tmp++ = '\0';
if (*tmp != '"') {
(void) devctl_ddef_string(ddef_hdl, pname, tmp);
return;
}
nstr = 0;
while (*tmp != '\0') {
pval = tmp + 1;
tmp = strchr(pval, '"');
if (tmp == NULL) {
(void) fprintf(stderr, "missing quote in %s", tmp);
exit(-1);
}
nstr++;
strs = (char **)s_realloc(strs, nstr * sizeof (char *));
strs[nstr - 1] = pval;
*tmp++ = '\0';
(void) printf("string[%d] = %s\n", nstr - 1, pval);
if (*tmp)
tmp = strchr(tmp, '"');
if (tmp == NULL) {
(void) fprintf(stderr, "string not ending with quote");
exit(-1);
}
}
(void) devctl_ddef_string_array(ddef_hdl, pname, nstr, strs);
free(strs);
}
static int
bus_devcreate(devctl_hdl_t bus_dcp)
{
int rv;
char **propp = dev_props;
devctl_ddef_t ddef_hdl = NULL;
devctl_hdl_t dev_hdl = NULL;
ddef_hdl = devctl_ddef_alloc(dev_name, 0);
if (dev_props == NULL) {
(void) fprintf(stderr, "dev-create: missing device props\n");
return (-1);
}
while (*propp) {
add_prop(ddef_hdl, *propp);
propp++;
}
if (devctl_bus_dev_create(bus_dcp, ddef_hdl, 0, &dev_hdl)) {
(void) fprintf(stderr,
"bus-devcreate: failed to create device node\n");
rv = -1;
} else if (devctl_get_pathname(dev_hdl, devctl_device, MAXPATHLEN)
== NULL) {
(void) fprintf(stderr,
"bus-devcreate: failed to get device path\n");
rv = -1;
} else {
(void) printf("created device %s\n", devctl_device);
rv = 0;
}
devctl_ddef_free(ddef_hdl);
if (dev_hdl)
devctl_release(dev_hdl);
return (rv);
}
static void
print_bus_state(char *devname, uint_t state)
{
(void) printf("\t%s: ", devname);
if (state == BUS_QUIESCED)
(void) printf("Quiesced");
else if (state == BUS_ACTIVE)
(void) printf("Active");
else if (state == BUS_SHUTDOWN)
(void) printf("Shutdown");
(void) printf("\n");
}
static void
print_dev_state(char *devname, uint_t state)
{
(void) printf("\t%s: ", devname);
if (state & DEVICE_ONLINE) {
(void) printf("Online");
if (state & DEVICE_BUSY)
(void) printf(" Busy");
if (state & DEVICE_DOWN)
(void) printf(" Down");
} else {
if (state & DEVICE_OFFLINE) {
(void) printf("Offline");
if (state & DEVICE_DOWN)
(void) printf(" Down");
}
}
(void) printf("\n");
}
static void
setpname(char *name)
{
register char *p;
if (p = strrchr(name, '/'))
progname = p + 1;
else
progname = name;
}
static struct cmds *
dc_cmd(struct cmds *cmd_tbl, char *devctl_cmdname)
{
int i;
for (i = 0; cmd_tbl[i].cmdname != NULL; i++) {
if (strcasecmp(cmd_tbl[i].cmdname, devctl_cmdname) == 0)
return (&cmd_tbl[i]);
}
return (NULL);
}
static void
run_list_ctlrs(void)
{
di_node_t dinode;
if ((dinode = di_init("/", DINFOSUBTREE|DINFOMINOR)) == NULL) {
(void) fprintf(stderr, "%s: di_init() failed\n",
progname);
exit(-1);
}
(void) di_walk_minor(dinode, DDI_NT_NEXUS, 0, NULL, &nexif);
di_fini(dinode);
exit(0);
}
static int
nexif(di_node_t din, di_minor_t dim, void *arg)
{
char *devname;
if ((devname = di_devfs_path(din)) != NULL) {
(void) printf("%s%d: /devices%s\n", di_driver_name(din),
di_instance(din), devname);
di_devfs_path_free(devname);
}
return (DI_WALK_CONTINUE);
}
void *
s_malloc(size_t len)
{
void *buf = malloc(len);
if (buf == NULL) {
perror("s_malloc failed");
exit(-1);
}
return (buf);
}
void *
s_realloc(void *ptr, size_t len)
{
void *buf = realloc(ptr, len);
if (buf == NULL) {
perror("s_realloc failed");
exit(-1);
}
return (buf);
}
char *
s_strdup(char *str)
{
char *buf = strdup(str);
if (buf == NULL) {
perror("s_malloc failed");
exit(-1);
}
return (buf);
}
