usr/src/cmd/devctl/devctl.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25
  26 /*
  27  * devctl - device control utility
  28  *
  29  * to compile:
  30  * cc -o devctl -ldevice -ldevinfo devctl.c
  31  *
  32  * usage: devctl [-v] command [device/bus pathname]
  33  *
  34  * Commands:
  35  *      list            - list all controllers exporting the devctl interface
  36  *      online          - online a device
  37  *      offline         - offline a device
  38  *      remove          - remove a device from the device tree
  39  *      quiesce         - quiesce the bus
  40  *      unquiesce       - resume bus activity
  41  *      configure       - configure a bus's child devices
  42  *      unconfigure     - unconfigure a bus's child devices
  43  *      bus-reset       - reset a bus
  44  *      dev-reset       - reset a device
  45  *      bus-getstate    - return the current state of the bus
  46  *      dev-getstate    - return the current state of the device
  47  *      bus-devcreate   - create a new device, bus specific
  48  *      dev-raisepower          - power up a device via pm_raise_power() (pm)
  49  *      dev-idlecomp            - idle a device's component 0 (pm)
  50  *      dev-busycomp            - busy a device's component 0 (pm)
  51  *      dev-testbusy            - test a device's component 0's busy state (pm)
  52  *      dev-changepowerhigh     - power up a device via pm_power_has_changed()
  53  *                                (pm)
  54  *      dev-changepowerlow      - power off a device via pm_power_has_changed()
  55  *                                (pm)
  56  *      dev-failsuspend         - fail DDI_SUSPEND (pm)
  57  *      dev-changeonresume      - issue pm_power_has_changed() vs,
  58  *                                pm_raise_power() on device resume (pm)
  59  *      dev-nolowerpower        - don't call pm_lower_power() on detach (pm)
  60  *      dev-promprintf          - issue a prom_printf() call (pm)
  61  *      bus-raisepower          - power up a bus via pm_raise_power() (pm)
  62  *      bus-idlecomp            - idle a bus' component (pm)
  63  *      bus-busycomp            - busy a bus' component (pm)
  64  *      bus-testbusy            - test a bus' component busy state (pm)
  65  *      bus-changepowerhigh     - power up a bus via pm_power_has_changed() (pm)
  66  *      bus-changepowerlow      - power off a bus via pm_power_has_changed()
  67  *                                (pm)
  68  *      bus-failsuspend         - fail DDI_SUSPEND (pm)
  69  *      bus-teststrict          - test is bus driver is  strict or involved (pm)
  70  *      bus-noinvol             - mark idle twice when child detaches
  71  *
  72  *
  73  * Returns:
  74  *      - Success
  75  *      - Operation not supported by device
  76  *      - No Permission
  77  *      - No Such Device
  78  *
  79  * Examples:
  80  *      devctl list - list all controllers exporting a :devctl node
  81  *      devctl offline /dev/dsk/c0t3d0s0  - offline disk
  82  *      devctl dev-getstate  /devices/sbus@1f,0/espdma@e,8400000/esp@e,8800000\
  83  * sd@3,0
  84  *
  85  */
  86
  87 #include <stdio.h>
  88 #include <string.h>
  89 #include <unistd.h>
  90 #include <stdlib.h>
  91 #include <sys/types.h>
  92 #include <sys/errno.h>
  93 #include <sys/stat.h>
  94 #include <sys/param.h>
  95 #include <libdevice.h>
  96 #include <libdevinfo.h>
  97 #include <sys/sunddi.h>
  98
  99 typedef struct cmds {
 100         char *cmdname;
 101         int (*cmdf)(devctl_hdl_t);
 102 } cmds_t;
 103
 104 extern int errno;
 105
 106 static void setpname(char *name);
 107 static void print_bus_state(char *devname, uint_t state);
 108 static void print_dev_state(char *devname, uint_t state);
 109 static int dev_getstate(devctl_hdl_t);
 110 static int bus_getstate(devctl_hdl_t);
 111 static int bus_devcreate(devctl_hdl_t);
 112 static void run_list_ctlrs(void);
 113 static struct cmds *dc_cmd();
 114 static int nexif(di_node_t din, di_minor_t dim, void *arg);
 115 static void *s_malloc(size_t);
 116 static void *s_realloc(void *, size_t);
 117 static char *s_strdup(char *);
 118 static int dev_pm_testbusy(devctl_hdl_t);
 119 static int bus_pm_teststrict(devctl_hdl_t);
 120
 121 static char *devctl_device;
 122 static char *orig_path;
 123 static char *devctl_cmdname;
 124 static char *progname;
 125 static int  verbose;
 126 static int  debug;
 127 static char *dev_name;
 128 static char **dev_props;
 129
 130 static const char *usage = "%s [-v] list | online | offline | remove |\n"
 131         "\tquiesce | unquiesce | configure | unconfigure |\n"
 132         "\t{bus,dev}-reset {bus,dev}-getstate | {bus,dev}-raisepower |\n"
 133         "\t{bus,dev}-idlecomp | {bus,dev}-busycomp |\n"
 134         "\t{bus,dev}-changepowerhigh | {bus,dev}-changepowerlow |\n"
 135         "\t{bus,dev}-testbusy | {bus,dev}-failsuspend | dev-changeonresume |\n"
 136         "\tdev-promprintf | dev-nolowerpower | bus-teststrict |\n"
 137         "\tbus-noinvol [/dev/... | /devices/...]\n";
 138
 139 static struct cmds device_cmds[] = {
 140         {"online", devctl_device_online},
 141         {"offline", devctl_device_offline},
 142         {"remove", devctl_device_remove},
 143         {"dev-reset", devctl_device_reset},
 144         {"dev-getstate", dev_getstate},
 145         {"dev-raisepower", devctl_pm_raisepower},
 146         {"dev-busycomp", devctl_pm_busycomponent},
 147         {"dev-idlecomp", devctl_pm_idlecomponent},
 148         {"dev-testbusy", dev_pm_testbusy},
 149         {"dev-changepowerlow", devctl_pm_changepowerlow},
 150         {"dev-changepowerhigh", devctl_pm_changepowerhigh},
 151         {"dev-failsuspend", devctl_pm_failsuspend},
 152         {"dev-changeonresume", devctl_pm_device_changeonresume},
 153         {"dev-promprintf", devctl_pm_device_promprintf},
 154         {"dev-nolowerpower", devctl_pm_device_no_lower_power},
 155         {NULL, NULL},
 156 };
 157
 158 static struct cmds bus_cmds[] = {
 159         {"quiesce", devctl_bus_quiesce},
 160         {"unquiesce", devctl_bus_unquiesce},
 161         {"bus-reset", devctl_bus_reset},
 162         {"configure", devctl_bus_configure},
 163         {"unconfigure", devctl_bus_unconfigure},
 164         {"bus-getstate", bus_getstate},
 165         {"bus-devcreate", bus_devcreate},
 166         {"bus-raisepower", devctl_pm_raisepower},
 167         {"bus-busycomp", devctl_pm_busycomponent},
 168         {"bus-idlecomp", devctl_pm_idlecomponent},
 169         {"bus-changepowerlow", devctl_pm_changepowerlow},
 170         {"bus-changepowerhigh", devctl_pm_changepowerhigh},
 171         {"bus-testbusy", dev_pm_testbusy},
 172         {"bus-failsuspend", devctl_pm_failsuspend},
 173         {"bus-teststrict", bus_pm_teststrict},
 174         {"bus-noinvol", devctl_pm_bus_no_invol},
 175         {NULL, NULL},
 176 };
 177
 178
 179
 180 int
 181 main(int argc, char *argv[])
 182 {
 183         int     c;
 184         int     rv;
 185         int     pathlen;
 186         struct cmds *dcmd;
 187         devctl_hdl_t dcp;
 188         struct stat stat_buf;
 189
 190         setpname(argv[0]);
 191         while ((c = getopt(argc, argv, "vd")) != -1)  {
 192                 switch (c)  {
 193                 case 'v':
 194                         ++verbose;
 195                         break;
 196                 case 'd':
 197                         ++debug;
 198                         (void) putenv("LIBDEVICE_DEBUG");
 199                         break;
 200                 default:
 201                         (void) fprintf(stderr, usage, progname);
 202                         exit(1);
 203                         /*NOTREACHED*/
 204                 }
 205         }
 206
 207         if (optind == argc) {
 208                 (void) fprintf(stderr, usage, progname);
 209                 exit(-1);
 210         }
 211
 212         devctl_cmdname = argv[optind++];
 213
 214         if (strcmp(devctl_cmdname, "list") == 0) {
 215                 run_list_ctlrs();
 216                 exit(0);
 217         }
 218
 219         /*
 220          * any command other than "list" requires a device path
 221          */
 222         if (((optind + 1) > argc)) {
 223                 (void) fprintf(stderr, usage, progname);
 224                 exit(-1);
 225         }
 226
 227         orig_path = s_strdup(argv[optind]);
 228         devctl_device = s_malloc(MAXPATHLEN);
 229         (void) strcpy(devctl_device, orig_path);
 230
 231         /*
 232          * Additional properties follow for bus-devcreate
 233          */
 234         if ((optind + 1 < argc) &&
 235             strcmp(devctl_cmdname, "bus-devcreate") == 0) {
 236                 int i;
 237                 optind++;
 238                 dev_name = s_strdup(argv[optind]);
 239                 i = argc - optind;
 240                 dev_props = s_malloc(i * sizeof (char *));
 241                 while (--i) {
 242                         dev_props[i - 1] = s_strdup(argv[optind + i]);
 243                 }
 244         }
 245
 246         /*
 247          * if the device is a logical name, get the physical name
 248          */
 249         if (lstat(orig_path, &stat_buf) == 0) {
 250                 if (S_ISLNK(stat_buf.st_mode)) {
 251                         if ((pathlen = readlink(orig_path, devctl_device,
 252                             MAXPATHLEN)) == -1)  {
 253                                 (void) fprintf(stderr,
 254                                     "devctl: readlink(%s) - %s\n",
 255                                     orig_path, strerror(errno));
 256                                 exit(-1);
 257                         }
 258                         devctl_device[pathlen] = '\0';
 259                 }
 260         }
 261
 262         if ((dcmd = dc_cmd(device_cmds, devctl_cmdname)) == NULL) {
 263                 dcmd = dc_cmd(bus_cmds, devctl_cmdname);
 264                 if (dcmd == NULL) {
 265                         (void) fprintf(stderr, "unrecognized command (%s)\n",
 266                             devctl_cmdname);
 267                         (void) fprintf(stderr, usage, progname);
 268                         exit(1);
 269                 } else if (strcmp(devctl_cmdname, "bus-raisepower") == 0 ||
 270                     strcmp(devctl_cmdname, "bus-changepowerlow") == 0 ||
 271                     strcmp(devctl_cmdname, "bus-changepowerhigh") == 0 ||
 272                     strcmp(devctl_cmdname, "bus-idlecomp") == 0 ||
 273                     strcmp(devctl_cmdname, "bus-busycomp") == 0 ||
 274                     strcmp(devctl_cmdname, "bus-testbusy") == 0 ||
 275                     strcmp(devctl_cmdname, "bus-failsuspend") == 0 ||
 276                     strcmp(devctl_cmdname, "bus-teststrict") == 0 ||
 277                     strcmp(devctl_cmdname, "bus-noinvol") == 0) {
 278                         dcp = devctl_pm_bus_acquire(devctl_device, 0);
 279                         if (dcp == NULL) {
 280                                 (void) fprintf(stderr,
 281                                     "devctl: device_pm_bus_acquire %s - %s\n",
 282                                     devctl_device, strerror(errno));
 283                                 exit(-1);
 284                         }
 285                 } else {
 286                         dcp = devctl_bus_acquire(devctl_device, 0);
 287                         if (dcp == NULL) {
 288                                 (void) fprintf(stderr, "devctl: bus_acquire "
 289                                     "%s - %s\n",
 290                                     devctl_device, strerror(errno));
 291                                 exit(-1);
 292                         }
 293                 }
 294         } else if (strcmp(devctl_cmdname, "dev-raisepower") == 0 ||
 295             strcmp(devctl_cmdname, "dev-changepowerlow") == 0 ||
 296             strcmp(devctl_cmdname, "dev-changepowerhigh") == 0 ||
 297             strcmp(devctl_cmdname, "dev-idlecomp") == 0 ||
 298             strcmp(devctl_cmdname, "dev-busycomp") == 0 ||
 299             strcmp(devctl_cmdname, "dev-testbusy") == 0 ||
 300             strcmp(devctl_cmdname, "dev-failsuspend") == 0 ||
 301             strcmp(devctl_cmdname, "dev-changeonresume") == 0 ||
 302             strcmp(devctl_cmdname, "dev-promprintf") == 0 ||
 303             strcmp(devctl_cmdname, "dev-nolowerpower") == 0) {
 304                 dcp = devctl_pm_dev_acquire(devctl_device, 0);
 305                 if (dcp == NULL) {
 306                         (void) fprintf(stderr,
 307                             "devctl: device_pm_dev_acquire %s - %s\n",
 308                             devctl_device, strerror(errno));
 309                         exit(-1);
 310                 }
 311         } else {
 312                 dcp = devctl_device_acquire(devctl_device, 0);
 313                 if (dcp == NULL) {
 314                         (void) fprintf(stderr,
 315                             "devctl: device_acquire %s - %s\n",
 316                             devctl_device, strerror(errno));
 317                         exit(-1);
 318                 }
 319         }
 320
 321         if (verbose)
 322                 (void) printf("devctl: cmd (%s) device (%s)\n",
 323                     devctl_cmdname, orig_path);
 324
 325         (void) fflush(NULL);    /* get output out of the way */
 326
 327         rv = (dcmd->cmdf)(dcp);
 328
 329         if (rv == -1) {
 330                 perror("devctl");
 331                 exit(-1);
 332         }
 333         return (0);
 334 } /* main */
 335
 336 static int
 337 dev_pm_testbusy(devctl_hdl_t dcp)
 338 {
 339         int rv;
 340         uint_t *busyp;
 341
 342         busyp = s_malloc(sizeof (uint_t));
 343         rv = devctl_pm_testbusy(dcp, busyp);
 344         if (rv != -1)
 345                 (void) printf("%s: busy state %d\n", orig_path, *busyp);
 346
 347         return (0);
 348 }
 349
 350 static int
 351 bus_pm_teststrict(devctl_hdl_t dcp)
 352 {
 353         int rv;
 354         uint_t *strict;
 355
 356         strict = s_malloc(sizeof (uint_t));
 357
 358         rv = devctl_pm_bus_teststrict(dcp, strict);
 359         if (rv != -1)
 360                 (void) printf("%s: strict %d\n", orig_path, *strict);
 361
 362         return (0);
 363 }
 364
 365 static int
 366 dev_getstate(devctl_hdl_t dcp)
 367 {
 368         int rv;
 369         uint_t state;
 370
 371         rv = devctl_device_getstate(dcp, &state);
 372         if (rv != -1)
 373                 print_dev_state(orig_path, state);
 374
 375         return (0);
 376 }
 377
 378 static int
 379 bus_getstate(devctl_hdl_t dcp)
 380 {
 381         int rv;
 382         uint_t state;
 383
 384         rv = devctl_bus_getstate(dcp, &state);
 385         if (rv != -1)
 386                 print_bus_state(orig_path, state);
 387
 388         return (0);
 389 }
 390
 391 /*
 392  * Only string property is supported now.
 393  * Will add more later.
 394  */
 395 static void
 396 add_prop(devctl_ddef_t ddef_hdl, char *prop_str)
 397 {
 398         char *pname, *pval, *tmp;
 399         char **strs = NULL;
 400         int nstr;
 401
 402         tmp = strchr(prop_str, '=');
 403         if (tmp == NULL) {
 404                 (void) fprintf(stderr, "invalid property %s", prop_str);
 405                 exit(-1);
 406         }
 407
 408         (void) printf("prop string: %s\n", prop_str);
 409         pname = prop_str;
 410         *tmp++ = '\0';
 411         if (*tmp != '"') {
 412                 (void) devctl_ddef_string(ddef_hdl, pname, tmp);
 413                 return;
 414         }
 415
 416         nstr = 0;
 417         while (*tmp != '\0') {
 418                 pval = tmp + 1;
 419                 tmp = strchr(pval, '"');
 420                 if (tmp == NULL) {
 421                         (void) fprintf(stderr, "missing quote in %s", tmp);
 422                         exit(-1);
 423                 }
 424                 nstr++;
 425                 strs = (char **)s_realloc(strs, nstr * sizeof (char *));
 426                 strs[nstr - 1] = pval;
 427                 *tmp++ = '\0';
 428                 (void) printf("string[%d] = %s\n", nstr - 1, pval);
 429                 if (*tmp)
 430                         tmp = strchr(tmp, '"');
 431                 if (tmp == NULL) {
 432                         (void) fprintf(stderr, "string not ending with quote");
 433                         exit(-1);
 434                 }
 435         }
 436
 437         (void) devctl_ddef_string_array(ddef_hdl, pname, nstr, strs);
 438         free(strs);
 439 }
 440
 441 static int
 442 bus_devcreate(devctl_hdl_t bus_dcp)
 443 {
 444         int rv;
 445         char **propp = dev_props;
 446         devctl_ddef_t ddef_hdl = NULL;
 447         devctl_hdl_t dev_hdl = NULL;
 448
 449         ddef_hdl = devctl_ddef_alloc(dev_name, 0);
 450         if (dev_props == NULL) {
 451                 (void) fprintf(stderr, "dev-create: missing device props\n");
 452                 return (-1);
 453         }
 454
 455         while (*propp) {
 456                 add_prop(ddef_hdl, *propp);
 457                 propp++;
 458         }
 459
 460         if (devctl_bus_dev_create(bus_dcp, ddef_hdl, 0, &dev_hdl)) {
 461                 (void) fprintf(stderr,
 462                     "bus-devcreate: failed to create device node\n");
 463                 rv = -1;
 464         } else if (devctl_get_pathname(dev_hdl, devctl_device, MAXPATHLEN)
 465             == NULL) {
 466                 (void) fprintf(stderr,
 467                     "bus-devcreate: failed to get device path\n");
 468                 rv = -1;
 469         } else {
 470                 (void) printf("created device %s\n", devctl_device);
 471                 rv = 0;
 472         }
 473
 474         devctl_ddef_free(ddef_hdl);
 475         if (dev_hdl)
 476                 devctl_release(dev_hdl);
 477
 478         return (rv);
 479 }
 480
 481 static void
 482 print_bus_state(char *devname, uint_t state)
 483 {
 484         (void) printf("\t%s: ", devname);
 485         if (state == BUS_QUIESCED)
 486                 (void) printf("Quiesced");
 487         else if (state == BUS_ACTIVE)
 488                 (void) printf("Active");
 489         else if (state == BUS_SHUTDOWN)
 490                 (void) printf("Shutdown");
 491         (void) printf("\n");
 492 }
 493
 494 static void
 495 print_dev_state(char *devname, uint_t state)
 496 {
 497         (void) printf("\t%s: ", devname);
 498         if (state & DEVICE_ONLINE) {
 499                 (void) printf("Online");
 500                 if (state & DEVICE_BUSY)
 501                         (void) printf(" Busy");
 502                 if (state & DEVICE_DOWN)
 503                         (void) printf(" Down");
 504         } else {
 505                 if (state & DEVICE_OFFLINE) {
 506                         (void) printf("Offline");
 507                         if (state & DEVICE_DOWN)
 508                                 (void) printf(" Down");
 509                 }
 510         }
 511         (void) printf("\n");
 512 }
 513
 514 static void
 515 setpname(char *name)
 516 {
 517         register char *p;
 518
 519         if (p = strrchr(name, '/'))
 520                 progname = p + 1;
 521         else
 522                 progname = name;
 523 }
 524
 525 static struct cmds *
 526 dc_cmd(struct cmds *cmd_tbl, char *devctl_cmdname)
 527 {
 528         int i;
 529
 530         for (i = 0; cmd_tbl[i].cmdname != NULL; i++) {
 531                 if (strcasecmp(cmd_tbl[i].cmdname, devctl_cmdname) == 0)
 532                         return (&cmd_tbl[i]);
 533         }
 534
 535         return (NULL);
 536 }
 537
 538 /*
 539  * list all nexus drivers exporting the :devctl minor device
 540  */
 541 static void
 542 run_list_ctlrs(void)
 543 {
 544         di_node_t dinode;
 545
 546         if ((dinode = di_init("/", DINFOSUBTREE|DINFOMINOR)) == NULL) {
 547                 (void) fprintf(stderr, "%s: di_init() failed\n",
 548                     progname);
 549                 exit(-1);
 550         }
 551         (void) di_walk_minor(dinode, DDI_NT_NEXUS, NULL, 0, &nexif);
 552         di_fini(dinode);
 553         exit(0);
 554 }
 555
 556 /*ARGSUSED*/
 557 static int
 558 nexif(di_node_t din, di_minor_t dim, void *arg)
 559 {
 560         char *devname;
 561
 562         if ((devname = di_devfs_path(din)) != NULL) {
 563                 (void) printf("%s%d: /devices%s\n", di_driver_name(din),
 564                     di_instance(din), devname);
 565                 di_devfs_path_free(devname);
 566         }
 567
 568         return (DI_WALK_CONTINUE);
 569 }
 570
 571 void *
 572 s_malloc(size_t len)
 573 {
 574         void *buf = malloc(len);
 575
 576         if (buf == NULL) {
 577                 perror("s_malloc failed");
 578                 exit(-1);
 579         }
 580         return (buf);
 581 }
 582
 583 void *
 584 s_realloc(void *ptr, size_t len)
 585 {
 586         void *buf = realloc(ptr, len);
 587
 588         if (buf == NULL) {
 589                 perror("s_realloc failed");
 590                 exit(-1);
 591         }
 592         return (buf);
 593 }
 594
 595 char *
 596 s_strdup(char *str)
 597 {
 598         char *buf = strdup(str);
 599
 600         if (buf == NULL) {
 601                 perror("s_malloc failed");
 602                 exit(-1);
 603         }
 604         return (buf);
 605 }