usr.sbin/sesutil/sesutil.c

   1 /*-
   2  * Copyright (c) 2015 Baptiste Daroussin <bapt@FreeBSD.org>
   3  * Copyright (c) 2015 Allan Jude <allanjude@FreeBSD.org>
   4  * Copyright (c) 2000 by Matthew Jacob
   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  *    in this position and unchanged.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/ioctl.h>
  34 #include <sys/types.h>
  35 #include <sys/sbuf.h>
  36
  37 #include <err.h>
  38 #include <errno.h>
  39 #include <fcntl.h>
  40 #include <getopt.h>
  41 #include <glob.h>
  42 #include <stdbool.h>
  43 #include <stddef.h>
  44 #include <stdint.h>
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <string.h>
  48 #include <unistd.h>
  49
  50 #include <cam/scsi/scsi_all.h>
  51 #include <cam/scsi/scsi_enc.h>
  52
  53 #include "eltsub.h"
  54
  55 static int encstatus(int argc, char **argv);
  56 static int fault(int argc, char **argv);
  57 static int locate(int argc, char **argv);
  58 static int objmap(int argc, char **argv);
  59 static int sesled(int argc, char **argv, bool fault);
  60
  61 static struct command {
  62         const char *name;
  63         const char *param;
  64         const char *desc;
  65         int (*exec)(int argc, char **argv);
  66 } cmds[] = {
  67         { "fault",
  68             "(<disk>|<sesid>|all) (on|off)",
  69             "Change the state of the fault LED associated with a disk",
  70             fault },
  71         { "locate",
  72             "(<disk>|<sesid>|all) (on|off)",
  73             "Change the state of the locate LED associated with a disk",
  74             locate },
  75         { "map", "",
  76             "Print a map of the devices managed by the enclosure", objmap } ,
  77         { "status", "", "Print the status of the enclosure",
  78             encstatus },
  79 };
  80
  81 static const int nbcmds = nitems(cmds);
  82 static const char *uflag;
  83
  84 static void
  85 usage(FILE *out, const char *subcmd)
  86 {
  87         int i;
  88
  89         if (subcmd == NULL) {
  90                 fprintf(out, "Usage: %s [-u /dev/ses<N>] <command> [options]\n",
  91                     getprogname());
  92                 fprintf(out, "Commands supported:\n");
  93         }
  94         for (i = 0; i < nbcmds; i++) {
  95                 if (subcmd != NULL) {
  96                         if (strcmp(subcmd, cmds[i].name) == 0) {
  97                                 fprintf(out, "Usage: %s %s [-u /dev/ses<N>] "
  98                                     "%s\n\t%s\n", getprogname(), subcmd,
  99                                     cmds[i].param, cmds[i].desc);
 100                                 break;
 101                         }
 102                         continue;
 103                 }
 104                 fprintf(out, "    %-12s%s\n\t\t%s\n\n", cmds[i].name,
 105                     cmds[i].param, cmds[i].desc);
 106         }
 107
 108         exit(EXIT_FAILURE);
 109 }
 110
 111 static void
 112 do_led(int fd, unsigned int idx, bool onoff, bool setfault)
 113 {
 114         encioc_elm_status_t o;
 115
 116         o.elm_idx = idx;
 117         if (ioctl(fd, ENCIOC_GETELMSTAT, (caddr_t) &o) < 0) {
 118                 close(fd);
 119                 err(EXIT_FAILURE, "ENCIOC_GETELMSTAT");
 120         }
 121         o.cstat[0] |= 0x80;
 122         if (setfault) {
 123                 if (onoff)
 124                         o.cstat[3] |= 0x20;
 125                 else
 126                         o.cstat[3] &= 0xdf;
 127         } else {
 128                 if (onoff)
 129                         o.cstat[2] |= 0x02;
 130                 else
 131                         o.cstat[2] &= 0xfd;
 132         }
 133
 134         if (ioctl(fd, ENCIOC_SETELMSTAT, (caddr_t) &o) < 0) {
 135                 close(fd);
 136                 err(EXIT_FAILURE, "ENCIOC_SETELMSTAT");
 137         }
 138 }
 139
 140 static bool
 141 disk_match(const char *devnames, const char *disk, size_t len)
 142 {
 143         const char *dname;
 144
 145         dname = devnames;
 146         while ((dname = strstr(dname, disk)) != NULL) {
 147                 if (dname[len] == '\0' || dname[len] == ',') {
 148                         return (true);
 149                 }
 150                 dname++;
 151         }
 152
 153         return (false);
 154 }
 155
 156 static int
 157 sesled(int argc, char **argv, bool setfault)
 158 {
 159         encioc_elm_devnames_t objdn;
 160         encioc_element_t *objp;
 161         glob_t g;
 162         char *disk, *endptr;
 163         size_t len, i, ndisks;
 164         int fd;
 165         unsigned int nobj, j, sesid;
 166         bool all, isses, onoff;
 167
 168         isses = false;
 169         all = false;
 170         onoff = false;
 171
 172         if (argc != 3) {
 173                 usage(stderr, (setfault ? "fault" : "locate"));
 174         }
 175
 176         disk = argv[1];
 177
 178         sesid = strtoul(disk, &endptr, 10);
 179         if (*endptr == '\0') {
 180                 endptr = strrchr(uflag, '*');
 181                 if (endptr != NULL && *endptr == '*') {
 182                         warnx("Must specifying a SES device (-u) to use a SES "
 183                             "id# to identify a disk");
 184                         usage(stderr, (setfault ? "fault" : "locate"));
 185                 }
 186                 isses = true;
 187         }
 188
 189         if (strcmp(argv[2], "on") == 0) {
 190                 onoff = true;
 191         } else if (strcmp(argv[2], "off") == 0) {
 192                 onoff = false;
 193         } else {
 194                 usage(stderr, (setfault ? "fault" : "locate"));
 195         }
 196
 197         if (strcmp(disk, "all") == 0) {
 198                 all = true;
 199         }
 200         len = strlen(disk);
 201
 202         /* Get the list of ses devices */
 203         if (glob((uflag != NULL ? uflag : "/dev/ses[0-9]*"), 0, NULL, &g) ==
 204             GLOB_NOMATCH) {
 205                 globfree(&g);
 206                 errx(EXIT_FAILURE, "No SES devices found");
 207         }
 208
 209         ndisks = 0;
 210         for (i = 0; i < g.gl_pathc; i++) {
 211                 /* ensure we only got numbers after ses */
 212                 if (strspn(g.gl_pathv[i] + 8, "0123456789") !=
 213                     strlen(g.gl_pathv[i] + 8)) {
 214                         continue;
 215                 }
 216                 if ((fd = open(g.gl_pathv[i], O_RDWR)) < 0) {
 217                         /*
 218                          * Don't treat non-access errors as critical if we are
 219                          * accessing all devices
 220                          */
 221                         if (errno == EACCES && g.gl_pathc > 1) {
 222                                 err(EXIT_FAILURE, "unable to access SES device");
 223                         }
 224                         warn("unable to access SES device: %s", g.gl_pathv[i]);
 225                         continue;
 226                 }
 227
 228                 if (ioctl(fd, ENCIOC_GETNELM, (caddr_t) &nobj) < 0) {
 229                         close(fd);
 230                         err(EXIT_FAILURE, "ENCIOC_GETNELM");
 231                 }
 232
 233                 objp = calloc(nobj, sizeof(encioc_element_t));
 234                 if (objp == NULL) {
 235                         close(fd);
 236                         err(EXIT_FAILURE, "calloc()");
 237                 }
 238
 239                 if (ioctl(fd, ENCIOC_GETELMMAP, (caddr_t) objp) < 0) {
 240                         close(fd);
 241                         err(EXIT_FAILURE, "ENCIOC_GETELMMAP");
 242                 }
 243
 244                 if (isses) {
 245                         if (sesid > nobj) {
 246                                 close(fd);
 247                                 errx(EXIT_FAILURE,
 248                                      "Requested SES ID does not exist");
 249                         }
 250                         do_led(fd, sesid, onoff, setfault);
 251                         ndisks++;
 252                         close(fd);
 253                         break;
 254                 }
 255                 for (j = 0; j < nobj; j++) {
 256                         memset(&objdn, 0, sizeof(objdn));
 257                         objdn.elm_idx = objp[j].elm_idx;
 258                         objdn.elm_names_size = 128;
 259                         objdn.elm_devnames = calloc(128, sizeof(char));
 260                         if (objdn.elm_devnames == NULL) {
 261                                 close(fd);
 262                                 err(EXIT_FAILURE, "calloc()");
 263                         }
 264                         if (ioctl(fd, ENCIOC_GETELMDEVNAMES,
 265                             (caddr_t) &objdn) <0) {
 266                                 continue;
 267                         }
 268                         if (objdn.elm_names_len > 0) {
 269                                 if (all) {
 270                                         do_led(fd, objdn.elm_idx,
 271                                             onoff, setfault);
 272                                         continue;
 273                                 }
 274                                 if (disk_match(objdn.elm_devnames, disk, len)) {
 275                                         do_led(fd, objdn.elm_idx,
 276                                             onoff, setfault);
 277                                         ndisks++;
 278                                         break;
 279                                 }
 280                         }
 281                 }
 282                 close(fd);
 283         }
 284         globfree(&g);
 285         if (ndisks == 0 && all == false) {
 286                 errx(EXIT_FAILURE, "Count not find the SES id of device '%s'",
 287                     disk);
 288         }
 289
 290         return (EXIT_SUCCESS);
 291 }
 292
 293 static int
 294 locate(int argc, char **argv)
 295 {
 296
 297         return (sesled(argc, argv, false));
 298 }
 299
 300 static int
 301 fault(int argc, char **argv)
 302 {
 303
 304         return (sesled(argc, argv, true));
 305 }
 306
 307 static int
 308 objmap(int argc, char **argv __unused)
 309 {
 310         struct sbuf *extra;
 311         encioc_string_t stri;
 312         encioc_elm_devnames_t e_devname;
 313         encioc_elm_status_t e_status;
 314         encioc_elm_desc_t e_desc;
 315         encioc_element_t *e_ptr;
 316         glob_t g;
 317         int fd;
 318         unsigned int j, nobj;
 319         size_t i;
 320         char str[32];
 321
 322         if (argc != 1) {
 323                 usage(stderr, "map");
 324         }
 325
 326         /* Get the list of ses devices */
 327         if (glob(uflag, 0, NULL, &g) == GLOB_NOMATCH) {
 328                 globfree(&g);
 329                 errx(EXIT_FAILURE, "No SES devices found");
 330         }
 331         for (i = 0; i < g.gl_pathc; i++) {
 332                 /* ensure we only got numbers after ses */
 333                 if (strspn(g.gl_pathv[i] + 8, "0123456789") !=
 334                     strlen(g.gl_pathv[i] + 8)) {
 335                         continue;
 336                 }
 337                 if ((fd = open(g.gl_pathv[i], O_RDWR)) < 0) {
 338                         /*
 339                          * Don't treat non-access errors as critical if we are
 340                          * accessing all devices
 341                          */
 342                         if (errno == EACCES && g.gl_pathc > 1) {
 343                                 err(EXIT_FAILURE, "unable to access SES device");
 344                         }
 345                         warn("unable to access SES device: %s", g.gl_pathv[i]);
 346                         continue;
 347                 }
 348
 349                 if (ioctl(fd, ENCIOC_GETNELM, (caddr_t) &nobj) < 0) {
 350                         close(fd);
 351                         err(EXIT_FAILURE, "ENCIOC_GETNELM");
 352                 }
 353
 354                 e_ptr = calloc(nobj, sizeof(encioc_element_t));
 355                 if (e_ptr == NULL) {
 356                         close(fd);
 357                         err(EXIT_FAILURE, "calloc()");
 358                 }
 359
 360                 if (ioctl(fd, ENCIOC_GETELMMAP, (caddr_t) e_ptr) < 0) {
 361                         close(fd);
 362                         err(EXIT_FAILURE, "ENCIOC_GETELMMAP");
 363                 }
 364
 365                 printf("%s:\n", g.gl_pathv[i] + 5);
 366                 stri.bufsiz = sizeof(str);
 367                 stri.buf = &str[0];
 368                 if (ioctl(fd, ENCIOC_GETENCNAME, (caddr_t) &stri) == 0)
 369                         printf("\tEnclosure Name: %s\n", stri.buf);
 370                 stri.bufsiz = sizeof(str);
 371                 stri.buf = &str[0];
 372                 if (ioctl(fd, ENCIOC_GETENCID, (caddr_t) &stri) == 0)
 373                         printf("\tEnclosure ID: %s\n", stri.buf);
 374
 375                 for (j = 0; j < nobj; j++) {
 376                         /* Get the status of the element */
 377                         memset(&e_status, 0, sizeof(e_status));
 378                         e_status.elm_idx = e_ptr[j].elm_idx;
 379                         if (ioctl(fd, ENCIOC_GETELMSTAT,
 380                             (caddr_t) &e_status) < 0) {
 381                                 close(fd);
 382                                 err(EXIT_FAILURE, "ENCIOC_GETELMSTAT");
 383                         }
 384                         /* Get the description of the element */
 385                         memset(&e_desc, 0, sizeof(e_desc));
 386                         e_desc.elm_idx = e_ptr[j].elm_idx;
 387                         e_desc.elm_desc_len = UINT16_MAX;
 388                         e_desc.elm_desc_str = calloc(UINT16_MAX, sizeof(char));
 389                         if (e_desc.elm_desc_str == NULL) {
 390                                 close(fd);
 391                                 err(EXIT_FAILURE, "calloc()");
 392                         }
 393                         if (ioctl(fd, ENCIOC_GETELMDESC,
 394                             (caddr_t) &e_desc) < 0) {
 395                                 close(fd);
 396                                 err(EXIT_FAILURE, "ENCIOC_GETELMDESC");
 397                         }
 398                         /* Get the device name(s) of the element */
 399                         memset(&e_devname, 0, sizeof(e_devname));
 400                         e_devname.elm_idx = e_ptr[j].elm_idx;
 401                         e_devname.elm_names_size = 128;
 402                         e_devname.elm_devnames = calloc(128, sizeof(char));
 403                         if (e_devname.elm_devnames == NULL) {
 404                                 close(fd);
 405                                 err(EXIT_FAILURE, "calloc()");
 406                         }
 407                         if (ioctl(fd, ENCIOC_GETELMDEVNAMES,
 408                             (caddr_t) &e_devname) <0) {
 409                                 /* We don't care if this fails */
 410                                 e_devname.elm_devnames[0] = '\0';
 411                         }
 412                         printf("\tElement %u, Type: %s\n", e_ptr[j].elm_idx,
 413                             geteltnm(e_ptr[j].elm_type));
 414                         printf("\t\tStatus: %s (0x%02x 0x%02x 0x%02x 0x%02x)\n",
 415                             scode2ascii(e_status.cstat[0]), e_status.cstat[0],
 416                             e_status.cstat[1], e_status.cstat[2],
 417                             e_status.cstat[3]);
 418                         if (e_desc.elm_desc_len > 0) {
 419                                 printf("\t\tDescription: %s\n",
 420                                     e_desc.elm_desc_str);
 421                         }
 422                         if (e_devname.elm_names_len > 0) {
 423                                 printf("\t\tDevice Names: %s\n",
 424                                     e_devname.elm_devnames);
 425                         }
 426                         extra = stat2sbuf(e_ptr[j].elm_type, e_status.cstat);
 427                         if (sbuf_len(extra) > 0) {
 428                                 printf("\t\tExtra status:\n%s",
 429                                    sbuf_data(extra));
 430                         }
 431                         sbuf_delete(extra);
 432                         free(e_devname.elm_devnames);
 433                 }
 434                 close(fd);
 435         }
 436         globfree(&g);
 437
 438         return (EXIT_SUCCESS);
 439 }
 440
 441 static int
 442 encstatus(int argc, char **argv __unused)
 443 {
 444         glob_t g;
 445         int fd, status;
 446         size_t i, e;
 447         u_char estat;
 448
 449         status = 0;
 450         if (argc != 1) {
 451                 usage(stderr, "status");
 452         }
 453
 454         /* Get the list of ses devices */
 455         if (glob(uflag, 0, NULL, &g) == GLOB_NOMATCH) {
 456                 globfree(&g);
 457                 errx(EXIT_FAILURE, "No SES devices found");
 458         }
 459         for (i = 0; i < g.gl_pathc; i++) {
 460                 /* ensure we only got numbers after ses */
 461                 if (strspn(g.gl_pathv[i] + 8, "0123456789") !=
 462                     strlen(g.gl_pathv[i] + 8)) {
 463                         continue;
 464                 }
 465                 if ((fd = open(g.gl_pathv[i], O_RDWR)) < 0) {
 466                         /*
 467                          * Don't treat non-access errors as critical if we are
 468                          * accessing all devices
 469                          */
 470                         if (errno == EACCES && g.gl_pathc > 1) {
 471                                 err(EXIT_FAILURE, "unable to access SES device");
 472                         }
 473                         warn("unable to access SES device: %s", g.gl_pathv[i]);
 474                         continue;
 475                 }
 476
 477                 if (ioctl(fd, ENCIOC_GETENCSTAT, (caddr_t) &estat) < 0) {
 478                         close(fd);
 479                         err(EXIT_FAILURE, "ENCIOC_GETENCSTAT");
 480                 }
 481
 482                 printf("%s: ", g.gl_pathv[i] + 5);
 483                 e = 0;
 484                 if (estat == 0) {
 485                         if (status == 0) {
 486                                 status = 1;
 487                         }
 488                         printf("OK");
 489                 } else {
 490                         if (estat & SES_ENCSTAT_INFO) {
 491                                 printf("INFO");
 492                                 e++;
 493                         }
 494                         if (estat & SES_ENCSTAT_NONCRITICAL) {
 495                                 if (e)
 496                                         printf(",");
 497                                 printf("NONCRITICAL");
 498                                 e++;
 499                         }
 500                         if (estat & SES_ENCSTAT_CRITICAL) {
 501                                 if (e)
 502                                         printf(",");
 503                                 printf("CRITICAL");
 504                                 e++;
 505                                 status = -1;
 506                         }
 507                         if (estat & SES_ENCSTAT_UNRECOV) {
 508                                 if (e)
 509                                         printf(",");
 510                                 printf("UNRECOV");
 511                                 e++;
 512                                 status = -1;
 513                         }
 514                 }
 515                 printf("\n");
 516
 517                 close(fd);
 518         }
 519         globfree(&g);
 520
 521         if (status == 1) {
 522                 return (EXIT_SUCCESS);
 523         } else {
 524                 return (EXIT_FAILURE);
 525         }
 526 }
 527
 528 int
 529 main(int argc, char **argv)
 530 {
 531         int i, ch;
 532         struct command *cmd = NULL;
 533
 534         uflag = "/dev/ses[0-9]*";
 535         while ((ch = getopt_long(argc, argv, "u:", NULL, NULL)) != -1) {
 536                 switch (ch) {
 537                 case 'u':
 538                         uflag = optarg;
 539                         break;
 540                 case '?':
 541                 default:
 542                         usage(stderr, NULL);
 543                 }
 544         }
 545         argc -= optind;
 546         argv += optind;
 547
 548         if (argc < 1) {
 549                 warnx("Missing command");
 550                 usage(stderr, NULL);
 551         }
 552
 553         for (i = 0; i < nbcmds; i++) {
 554                 if (strcmp(argv[0], cmds[i].name) == 0) {
 555                         cmd = &cmds[i];
 556                         break;
 557                 }
 558         }
 559
 560         if (cmd == NULL) {
 561                 warnx("unknown command %s", argv[0]);
 562                 usage(stderr, NULL);
 563         }
 564
 565         return (cmd->exec(argc, argv));
 566 }