usr.sbin/mlxcontrol/command.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 1999 Michael Smith
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  *      $FreeBSD$
  29  */
  30
  31 #include <fcntl.h>
  32 #include <paths.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <unistd.h>
  37 #include <err.h>
  38
  39 #include <dev/mlx/mlxio.h>
  40 #include <dev/mlx/mlxreg.h>
  41
  42 #include "mlxcontrol.h"
  43
  44 static int      cmd_status(int argc, char *argv[]);
  45 static int      cmd_rescan(int argc, char *argv[]);
  46 static int      cmd_detach(int argc, char *argv[]);
  47 static int      cmd_check(int argc, char *argv[]);
  48 static int      cmd_rebuild(int argc, char *argv[]);
  49 #ifdef SUPPORT_PAUSE
  50 static int      cmd_pause(int argc, char *argv[]);
  51 #endif
  52 static int      cmd_help(int argc, char *argv[]);
  53
  54 extern int      cmd_config(int argc, char *argv[]);
  55
  56
  57 struct
  58 {
  59     char        *cmd;
  60     int         (*func)(int argc, char *argv[]);
  61     char        *desc;
  62     char        *text;
  63 } commands[] = {
  64     {"status",  cmd_status,
  65      "displays device status",
  66      "  status [-qv] [<drive>...]\n"
  67      "      Display status for <drive> or all drives if none is listed\n"
  68      "  -q    Suppress output.\n"
  69      "  -v    Display verbose information.\n"
  70      "  Returns 0 if all drives tested are online, 1 if one or more are\n"
  71      "  critical, and 2 if one or more are offline."},
  72     {"rescan",  cmd_rescan,
  73      "scan for new system drives",
  74      "  rescan <controller> [<controller>...]\n"
  75      "      Rescan <controller> for system drives.\n"
  76      "  rescan -a\n"
  77      "      Rescan all controllers for system drives."},
  78     {"detach",  cmd_detach,
  79      "detach system drives",
  80      "  detach <drive> [<drive>...]\n"
  81      "      Detaches <drive> from the controller.\n"
  82      "  detach -a <controller>\n"
  83      "      Detaches all drives on <controller>."},
  84     {"check",   cmd_check,
  85      "consistency-check a system drive",
  86      "  check <drive>\n"
  87      "      Requests a check and rebuild of the parity information on <drive>.\n"
  88      "      Note that each controller can only check one system drive at a time."},
  89     {"rebuild", cmd_rebuild,
  90      "initiate a rebuild of a dead physical drive",
  91      "  rebuild <controller> <physdrive>\n"
  92      "      All system drives using space on the physical drive <physdrive>\n"
  93      "      are rebuilt, reconstructing all data on the drive.\n"
  94      "      Note that each controller can only perform one rebuild at a time."},
  95 #ifdef SUPPORT_PAUSE
  96     {"pause",   cmd_pause,
  97      "pauses controller channels",
  98      "  pause [-t <howlong>] [-d <delay>] <controller> [<channel>...]\n"
  99      "      Pauses SCSI I/O on <channel> and <controller>.  If no channel is specified,\n"
 100      "      all channels are paused.\n"
 101      "  <howlong>   How long (seconds) to pause for (default 30).\n"
 102      "  <delay>     How long (seconds) to wait before pausing (default 30).\n"
 103      "  pause <controller> -c\n"
 104      "      Cancels any pending pause operation on <controller>."},
 105 #endif
 106     {"config",  cmd_config,
 107      "examine and update controller configuration",
 108      "  config <controller>\n"
 109      "      Print configuration for <controller>."},
 110     {"help",    cmd_help,
 111      "give help on usage",
 112      ""},
 113     {NULL, NULL, NULL, NULL}
 114 };
 115
 116 /********************************************************************************
 117  * Command dispatch and global options parsing.
 118  */
 119
 120 int
 121 main(int argc, char *argv[])
 122 {
 123     int         ch, i, oargc;
 124     char        **oargv;
 125
 126     oargc = argc;
 127     oargv = argv;
 128     while ((ch = getopt(argc, argv, "")) != -1)
 129         switch(ch) {
 130         default:
 131             return(cmd_help(0, NULL));
 132         }
 133
 134     argc -= optind;
 135     argv += optind;
 136
 137     if (argc > 0)
 138         for (i = 0; commands[i].cmd != NULL; i++)
 139             if (!strcmp(argv[0], commands[i].cmd))
 140                 return(commands[i].func(argc, argv));
 141
 142     return(cmd_help(oargc, oargv));
 143 }
 144
 145 /********************************************************************************
 146  * Helptext output
 147  */
 148 static int
 149 cmd_help(int argc, char *argv[])
 150 {
 151     int         i;
 152
 153     if (argc > 1)
 154         for (i = 0; commands[i].cmd != NULL; i++)
 155             if (!strcmp(argv[1], commands[i].cmd)) {
 156                 fprintf(stderr, "%s\n", commands[i].text);
 157                 fflush(stderr);
 158                 return(0);
 159             }
 160
 161     if (argv != NULL)
 162         fprintf(stderr, "Unknown command '%s'.\n", argv[1]);
 163     fprintf(stderr, "Valid commands are:\n");
 164     for (i = 0; commands[i].cmd != NULL; i++)
 165         fprintf(stderr, "  %-20s %s\n", commands[i].cmd, commands[i].desc);
 166     fflush(stderr);
 167     return(0);
 168 }
 169
 170 /********************************************************************************
 171  * Status output
 172  *
 173  * status [-qv] [<device> ...]
 174  *              Prints status for <device>, or all if none listed.
 175  *
 176  * -q   Suppresses output, command returns 0 if devices are OK, 1 if one or
 177  *      more devices are critical, 2 if one or more devices are offline.
 178  */
 179 static struct mlx_rebuild_status        rs;
 180 static int                              rs_ctrlr = -1;
 181 static int                              status_result = 0;
 182
 183 /* XXX more verbosity! */
 184 static void
 185 status_print(int unit, void *arg)
 186 {
 187     int                         verbosity = *(int *)arg;
 188     int                         fd, result, ctrlr, sysdrive, statvalid;
 189
 190     /* Find which controller and what system drive we are */
 191     statvalid = 0;
 192     if (mlxd_find_ctrlr(unit, &ctrlr, &sysdrive)) {
 193         warnx("couldn't get controller/drive for %s", drivepath(unit));
 194     } else {
 195         /* If we don't have rebuild stats for this controller, get them */
 196         if (rs_ctrlr == ctrlr) {
 197             statvalid = 1;
 198         } else {
 199             if ((fd = open(ctrlrpath(ctrlr), 0)) < 0) {
 200                 warn("can't open %s", ctrlrpath(ctrlr));
 201             } else {
 202                 if (ioctl(fd, MLX_REBUILDSTAT, &rs) < 0) {
 203                     warn("ioctl MLX_REBUILDSTAT");
 204                 } else {
 205                     rs_ctrlr = ctrlr;
 206                     statvalid = 1;
 207                 }
 208                 close(fd);
 209             }
 210         }
 211     }
 212
 213     /* Get the device */
 214     if ((fd = open(drivepath(unit), 0)) < 0) {
 215         warn("can't open %s", drivepath(unit));
 216         return;
 217     }
 218
 219     /* Get its status */
 220     if (ioctl(fd, MLXD_STATUS, &result) < 0) {
 221         warn("ioctl MLXD_STATUS");
 222     } else {
 223         switch(result) {
 224         case MLX_SYSD_ONLINE:
 225             if (verbosity > 0)
 226                 printf("%s: online", drivename(unit));
 227             break;
 228         case MLX_SYSD_CRITICAL:
 229             if (verbosity > 0)
 230                 printf("%s: critical", drivename(unit));
 231             if (status_result < 1)
 232                 status_result = 1;
 233             break;
 234         case MLX_SYSD_OFFLINE:
 235             if (verbosity > 0)
 236                 printf("%s: offline", drivename(unit));
 237             if (status_result < 2)
 238                 status_result = 2;
 239             break;
 240         default:
 241             if (verbosity > 0) {
 242                 printf("%s: unknown status 0x%x", drivename(unit), result);
 243             }
 244         }
 245         if (verbosity > 0) {
 246             /* rebuild/check in progress on this drive? */
 247             if (statvalid && (rs_ctrlr == ctrlr) &&
 248                 (rs.rs_drive == sysdrive) && (rs.rs_code != MLX_REBUILDSTAT_IDLE)) {
 249                 switch(rs.rs_code) {
 250                 case MLX_REBUILDSTAT_REBUILDCHECK:
 251                     printf(" [consistency check");
 252                     break;
 253                 case MLX_REBUILDSTAT_ADDCAPACITY:
 254                     printf(" [add capacity");
 255                     break;
 256                 case MLX_REBUILDSTAT_ADDCAPACITYINIT:
 257                     printf(" [add capacity init");
 258                     break;
 259                 default:
 260                     printf(" [unknown operation");
 261                 }
 262                 printf(": %d/%d, %d%% complete]",
 263                        rs.rs_remaining, rs.rs_size,
 264                        ((rs.rs_size - rs.rs_remaining) / (rs.rs_size / 100)));
 265             }
 266             printf("\n");
 267         }
 268     }
 269     close(fd);
 270 }
 271
 272 static struct
 273 {
 274     int         hwid;
 275     char        *name;
 276 } mlx_controller_names[] = {
 277     {0x01,      "960P/PD"},
 278     {0x02,      "960PL"},
 279     {0x10,      "960PG"},
 280     {0x11,      "960PJ"},
 281     {0x12,      "960PR"},
 282     {0x13,      "960PT"},
 283     {0x14,      "960PTL0"},
 284     {0x15,      "960PRL"},
 285     {0x16,      "960PTL1"},
 286     {0x20,      "1100PVX"},
 287     {-1, NULL}
 288 };
 289
 290 static void
 291 controller_print(int unit, void *arg)
 292 {
 293     struct mlx_enquiry2 enq;
 294     struct mlx_phys_drv pd;
 295     int                 verbosity = *(int *)arg;
 296     static char         buf[80];
 297     char                *model;
 298     int                 i, channel, target;
 299
 300     if (verbosity == 0)
 301         return;
 302
 303     /* fetch and print controller data */
 304     if (mlx_enquiry(unit, &enq)) {
 305         printf("mlx%d: error submitting ENQUIRY2\n", unit);
 306     } else {
 307
 308         for (i = 0, model = NULL; mlx_controller_names[i].name != NULL; i++) {
 309             if ((enq.me_hardware_id & 0xff) == mlx_controller_names[i].hwid) {
 310                 model = mlx_controller_names[i].name;
 311                 break;
 312             }
 313         }
 314         if (model == NULL) {
 315             sprintf(buf, " model 0x%x", enq.me_hardware_id & 0xff);
 316             model = buf;
 317         }
 318
 319         printf("mlx%d: DAC%s, %d channel%s, firmware %d.%02d-%c-%02d, %dMB RAM\n",
 320                unit, model,
 321                enq.me_actual_channels,
 322                enq.me_actual_channels > 1 ? "s" : "",
 323                enq.me_firmware_id & 0xff,
 324                (enq.me_firmware_id >> 8) & 0xff,
 325                (enq.me_firmware_id >> 16),
 326                (enq.me_firmware_id >> 24) & 0xff,
 327                enq.me_mem_size / (1024 * 1024));
 328
 329         if (verbosity > 1) {
 330             printf("  Hardware ID                 0x%08x\n", enq.me_hardware_id);
 331             printf("  Firmware ID                 0x%08x\n", enq.me_firmware_id);
 332             printf("  Configured/Actual channels  %d/%d\n", enq.me_configured_channels,
 333                       enq.me_actual_channels);
 334             printf("  Max Targets                 %d\n", enq.me_max_targets);
 335             printf("  Max Tags                    %d\n", enq.me_max_tags);
 336             printf("  Max System Drives           %d\n", enq.me_max_sys_drives);
 337             printf("  Max Arms                    %d\n", enq.me_max_arms);
 338             printf("  Max Spans                   %d\n", enq.me_max_spans);
 339             printf("  DRAM/cache/flash/NVRAM size %d/%d/%d/%d\n", enq.me_mem_size,
 340                       enq.me_cache_size, enq.me_flash_size, enq.me_nvram_size);
 341             printf("  DRAM type                   %d\n", enq.me_mem_type);
 342             printf("  Clock Speed                 %dns\n", enq.me_clock_speed);
 343             printf("  Hardware Speed              %dns\n", enq.me_hardware_speed);
 344             printf("  Max Commands                %d\n", enq.me_max_commands);
 345             printf("  Max SG Entries              %d\n", enq.me_max_sg);
 346             printf("  Max DP                      %d\n", enq.me_max_dp);
 347             printf("  Max IOD                     %d\n", enq.me_max_iod);
 348             printf("  Max Comb                    %d\n", enq.me_max_comb);
 349             printf("  Latency                     %ds\n", enq.me_latency);
 350             printf("  SCSI Timeout                %ds\n", enq.me_scsi_timeout);
 351             printf("  Min Free Lines              %d\n", enq.me_min_freelines);
 352             printf("  Rate Constant               %d\n", enq.me_rate_const);
 353             printf("  MAXBLK                      %d\n", enq.me_maxblk);
 354             printf("  Blocking Factor             %d sectors\n", enq.me_blocking_factor);
 355             printf("  Cache Line Size             %d blocks\n", enq.me_cacheline);
 356             printf("  SCSI Capability             %s%dMHz, %d bit\n",
 357                       enq.me_scsi_cap & (1<<4) ? "differential " : "",
 358                       (1 << ((enq.me_scsi_cap >> 2) & 3)) * 10,
 359                       8 << (enq.me_scsi_cap & 0x3));
 360             printf("  Firmware Build Number       %d\n", enq.me_firmware_build);
 361             printf("  Fault Management Type       %d\n", enq.me_fault_mgmt_type);
 362 #if 0
 363             printf("  Features                    %b\n", enq.me_firmware_features,
 364                       "\20\4Background Init\3Read Ahead\2MORE\1Cluster\n");
 365 #endif
 366         }
 367
 368         /* fetch and print physical drive data */
 369         for (channel = 0; channel < enq.me_configured_channels; channel++) {
 370             for (target = 0; target < enq.me_max_targets; target++) {
 371                 if ((mlx_get_device_state(unit, channel, target, &pd) == 0) &&
 372                     (pd.pd_flags1 & MLX_PHYS_DRV_PRESENT)) {
 373                     mlx_print_phys_drv(&pd, channel, target, "  ", verbosity - 1);
 374                     if (verbosity > 1) {
 375                         /* XXX print device statistics? */
 376                     }
 377                 }
 378             }
 379         }
 380     }
 381 }
 382
 383 static int
 384 cmd_status(int argc, char *argv[])
 385 {
 386     int         ch, verbosity = 1, i, unit;
 387
 388     optreset = 1;
 389     optind = 1;
 390     while ((ch = getopt(argc, argv, "qv")) != -1)
 391         switch(ch) {
 392         case 'q':
 393             verbosity = 0;
 394             break;
 395         case 'v':
 396             verbosity = 2;
 397             break;
 398         default:
 399             return(cmd_help(argc, argv));
 400         }
 401     argc -= optind;
 402     argv += optind;
 403
 404     if (argc < 1) {
 405         mlx_foreach(controller_print, &verbosity);
 406         mlxd_foreach(status_print, &verbosity);
 407     } else {
 408         for (i = 0; i < argc; i++) {
 409             if ((unit = driveunit(argv[i])) == -1) {
 410                 warnx("'%s' is not a valid drive", argv[i]);
 411             } else {
 412                 status_print(unit, &verbosity);
 413             }
 414         }
 415     }
 416     return(status_result);
 417 }
 418
 419 /********************************************************************************
 420  * Recscan for system drives on one or more controllers.
 421  *
 422  * rescan <controller> [<controller>...]
 423  * rescan -a
 424  */
 425 static void
 426 rescan_ctrlr(int unit, void *junk)
 427 {
 428     int         fd;
 429
 430     /* Get the device */
 431     if ((fd = open(ctrlrpath(unit), 0)) < 0) {
 432         warn("can't open %s", ctrlrpath(unit));
 433         return;
 434     }
 435
 436     if (ioctl(fd, MLX_RESCAN_DRIVES) < 0)
 437         warn("can't rescan %s", ctrlrname(unit));
 438     close(fd);
 439 }
 440
 441 static int
 442 cmd_rescan(int argc, char *argv[])
 443 {
 444     int         all = 0, i, ch, unit;
 445
 446     optreset = 1;
 447     optind = 1;
 448     while ((ch = getopt(argc, argv, "a")) != -1)
 449         switch(ch) {
 450         case 'a':
 451             all = 1;
 452             break;
 453         default:
 454             return(cmd_help(argc, argv));
 455         }
 456     argc -= optind;
 457     argv += optind;
 458
 459     if (all) {
 460         mlx_foreach(rescan_ctrlr, NULL);
 461     } else {
 462         for (i = 0; i < argc; i++) {
 463             if ((unit = ctrlrunit(argv[i])) == -1) {
 464                 warnx("'%s' is not a valid controller", argv[i]);
 465             } else {
 466                 rescan_ctrlr(unit, NULL);
 467             }
 468         }
 469     }
 470     return(0);
 471 }
 472
 473 /********************************************************************************
 474  * Detach one or more system drives from a controller.
 475  *
 476  * detach <drive> [<drive>...]
 477  *              Detach <drive>.
 478  *
 479  * detach -a <controller> [<controller>...]
 480  *              Detach all drives on <controller>.
 481  *
 482  */
 483 static void
 484 detach_drive(int unit, void *arg)
 485 {
 486     int         fd;
 487
 488     /* Get the device */
 489     if ((fd = open(ctrlrpath(unit), 0)) < 0) {
 490         warn("can't open %s", ctrlrpath(unit));
 491         return;
 492     }
 493
 494     if (ioctl(fd, MLX_DETACH_DRIVE, &unit) < 0)
 495         warn("can't detach %s", drivename(unit));
 496     close(fd);
 497 }
 498
 499 static int
 500 cmd_detach(int argc, char *argv[])
 501 {
 502     struct mlxd_foreach_action  ma;
 503     int                         all = 0, i, ch, unit;
 504
 505     optreset = 1;
 506     optind = 1;
 507     while ((ch = getopt(argc, argv, "a")) != -1)
 508         switch(ch) {
 509         case 'a':
 510             all = 1;
 511             break;
 512         default:
 513             return(cmd_help(argc, argv));
 514         }
 515     argc -= optind;
 516     argv += optind;
 517
 518     if (all) {
 519         ma.func = detach_drive;
 520         ma.arg = &unit;
 521         for (i = 0; i < argc; i++) {
 522             if ((unit = ctrlrunit(argv[i])) == -1) {
 523                 warnx("'%s' is not a valid controller", argv[i]);
 524             } else {
 525                 mlxd_foreach_ctrlr(unit, &ma);
 526             }
 527         }
 528     } else {
 529         for (i = 0; i < argc; i++) {
 530             if ((unit = driveunit(argv[i])) == -1) {
 531                 warnx("'%s' is not a valid drive", argv[i]);
 532             } else {
 533                 /* run across all controllers to find this drive */
 534                 mlx_foreach(detach_drive, &unit);
 535             }
 536         }
 537     }
 538     return(0);
 539 }
 540
 541 /********************************************************************************
 542  * Initiate a consistency check on a system drive.
 543  *
 544  * check [<drive>]
 545  *      Start a check of <drive>
 546  *
 547  */
 548 static int
 549 cmd_check(int argc, char *argv[])
 550 {
 551     int         unit, fd, result;
 552
 553     if (argc != 2)
 554         return(cmd_help(argc, argv));
 555
 556     if ((unit = driveunit(argv[1])) == -1) {
 557         warnx("'%s' is not a valid drive", argv[1]);
 558     } else {
 559
 560         /* Get the device */
 561         if ((fd = open(drivepath(unit), 0)) < 0) {
 562             warn("can't open %s", drivepath(unit));
 563         } else {
 564             /* Try to start the check */
 565             if ((ioctl(fd, MLXD_CHECKASYNC, &result)) < 0) {
 566                 switch(result) {
 567                 case 0x0002:
 568                     warnx("one or more of the SCSI disks on which the drive '%s' depends is DEAD", argv[1]);
 569                     break;
 570                 case 0x0105:
 571                     warnx("drive %s is invalid, or not a drive which can be checked", argv[1]);
 572                     break;
 573                 case 0x0106:
 574                     warnx("drive rebuild or consistency check is already in progress on this controller");
 575                     break;
 576                 default:
 577                     warn("ioctl MLXD_CHECKASYNC");
 578                 }
 579             }
 580         }
 581     }
 582     return(0);
 583 }
 584
 585 /********************************************************************************
 586  * Initiate a physical drive rebuild
 587  *
 588  * rebuild <controller> <channel>:<target>
 589  *      Start a rebuild of <controller>:<channel>:<target>
 590  *
 591  */
 592 static int
 593 cmd_rebuild(int argc, char *argv[])
 594 {
 595     struct mlx_rebuild_request  rb;
 596     int                         unit, fd;
 597
 598     if (argc != 3)
 599         return(cmd_help(argc, argv));
 600
 601     /* parse arguments */
 602     if ((unit = ctrlrunit(argv[1])) == -1) {
 603         warnx("'%s' is not a valid controller", argv[1]);
 604         return(1);
 605     }
 606     /* try diskXXXX and unknownXXXX as we report the latter for a dead drive ... */
 607     if ((sscanf(argv[2], "disk%2d%2d", &rb.rr_channel, &rb.rr_target) != 2) &&
 608         (sscanf(argv[2], "unknown%2d%2d", &rb.rr_channel, &rb.rr_target) != 2)) {
 609         warnx("'%s' is not a valid physical drive", argv[2]);
 610         return(1);
 611     }
 612     /* get the device */
 613     if ((fd = open(ctrlrpath(unit), 0)) < 0) {
 614         warn("can't open %s", ctrlrpath(unit));
 615         return(1);
 616     }
 617     /* try to start the rebuild */
 618     if ((ioctl(fd, MLX_REBUILDASYNC, &rb)) < 0) {
 619         switch(rb.rr_status) {
 620         case 0x0002:
 621             warnx("the drive at %d:%d is already ONLINE", rb.rr_channel, rb.rr_target);
 622             break;
 623         case 0x0004:
 624             warnx("drive failed during rebuild");
 625             break;
 626         case 0x0105:
 627             warnx("there is no drive at channel %d, target %d", rb.rr_channel, rb.rr_target);
 628             break;
 629         case 0x0106:
 630             warnx("drive rebuild or consistency check is already in progress on this controller");
 631             break;
 632         default:
 633             warn("ioctl MLXD_REBUILDASYNC");
 634         }
 635     }
 636     return(0);
 637 }
 638
 639 #ifdef SUPPORT_PAUSE
 640 /********************************************************************************
 641  * Pause one or more channels on a controller
 642  *
 643  * pause [-d <delay>] [-t <time>] <controller> [<channel>...]
 644  *              Pauses <channel> (or all channels) for <time> seconds after a
 645  *              delay of <delay> seconds.
 646  * pause <controller> -c
 647  *              Cancels pending pause
 648  */
 649 static int
 650 cmd_pause(int argc, char *argv[])
 651 {
 652     struct mlx_pause    mp;
 653     int                 unit, i, ch, fd, cancel = 0;
 654     char                *cp;
 655     int                 oargc = argc;
 656     char                **oargv = argv;
 657
 658     mp.mp_which = 0;
 659     mp.mp_when = 30;
 660     mp.mp_howlong = 30;
 661     optreset = 1;
 662     optind = 1;
 663     while ((ch = getopt(argc, argv, "cd:t:")) != -1)
 664         switch(ch) {
 665         case 'c':
 666             cancel = 1;
 667             break;
 668         case 'd':
 669             mp.mp_when = strtol(optarg, &cp, 0);
 670             if (*cp != 0)
 671                 return(cmd_help(argc, argv));
 672             break;
 673         case 't':
 674             mp.mp_howlong = strtol(optarg, &cp, 0);
 675             if (*cp != 0)
 676                 return(cmd_help(argc, argv));
 677             break;
 678         default:
 679             return(cmd_help(argc, argv));
 680         }
 681     argc -= optind;
 682     argv += optind;
 683
 684     /* get controller unit number that we're working on */
 685     if ((argc < 1) || ((unit = ctrlrunit(argv[0])) == -1))
 686         return(cmd_help(oargc, oargv));
 687
 688     /* Get the device */
 689     if ((fd = open(ctrlrpath(unit), 0)) < 0) {
 690         warn("can't open %s", ctrlrpath(unit));
 691         return(1);
 692     }
 693
 694     if (argc == 1) {
 695         /* controller-wide pause/cancel */
 696         mp.mp_which = cancel ? MLX_PAUSE_CANCEL : MLX_PAUSE_ALL;
 697     } else {
 698         for (i = 1; i < argc; i++) {
 699             ch = strtol(argv[i], &cp, 0);
 700             if (*cp != 0) {
 701                 warnx("bad channel number '%s'", argv[i]);
 702                 continue;
 703             } else {
 704                 mp.mp_which |= (1 << ch);
 705             }
 706         }
 707     }
 708     if ((ioctl(fd, MLX_PAUSE_CHANNEL, &mp)) < 0)
 709         warn("couldn't %s %s", cancel ? "cancel pause on" : "pause", ctrlrname(unit));
 710     close(fd);
 711     return(0);
 712 }
 713 #endif  /* SUPPORT_PAUSE */
 714