1 /*- 2 * Copyright (c) 2019 Klara Inc. 3 * Copyright (c) 2015 Baptiste Daroussin <bapt@FreeBSD.org> 4 * Copyright (c) 2015 Allan Jude <allanjude@FreeBSD.org> 5 * Copyright (c) 2000 by Matthew Jacob 6 * All rights reserved. 7 * 8 * Portions of this software were developed by Edward Tomasz Napierala 9 * under sponsorship from Klara Inc. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer 16 * in this position and unchanged. 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR 22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 24 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 #include <sys/cdefs.h> 34 __FBSDID("$FreeBSD$"); 35 36 #include <sys/endian.h> 37 #include <sys/param.h> 38 #include <sys/disk.h> 39 #include <sys/ioctl.h> 40 #include <sys/types.h> 41 42 #include <err.h> 43 #include <errno.h> 44 #include <fcntl.h> 45 #include <getopt.h> 46 #include <glob.h> 47 #include <stdbool.h> 48 #include <stddef.h> 49 #include <stdint.h> 50 #include <stdio.h> 51 #include <stdlib.h> 52 #include <string.h> 53 #include <unistd.h> 54 #include <libxo/xo.h> 55 56 #include <cam/scsi/scsi_enc.h> 57 58 #include "eltsub.h" 59 60 #define SESUTIL_XO_VERSION "1" 61 62 #define TEMPERATURE_OFFSET 20 63 64 #define PRINT_STYLE_DASHED 0 65 #define PRINT_STYLE_DASHED_2 1 66 #define PRINT_STYLE_CSV 2 67 #define PRINT_STYLE_CSV_2 3 68 69 static int encstatus(int argc, char **argv); 70 static int fault(int argc, char **argv); 71 static int locate(int argc, char **argv); 72 static int objmap(int argc, char **argv); 73 static int sesled(int argc, char **argv, bool fault); 74 static int show(int argc, char **argv); 75 static void sesutil_print(int *style, const char *fmt, ...) __printflike(2,3); 76 77 static struct command { 78 const char *name; 79 const char *param; 80 const char *desc; 81 int (*exec)(int argc, char **argv); 82 } cmds[] = { 83 { "fault", 84 "(<disk>|<sesid>|all) (on|off)", 85 "Change the state of the fault LED associated with a disk", 86 fault }, 87 { "locate", 88 "(<disk>|<sesid>|all) (on|off)", 89 "Change the state of the locate LED associated with a disk", 90 locate }, 91 { "map", "", 92 "Print a map of the devices managed by the enclosure", objmap } , 93 { "show", "", 94 "Print a human-friendly summary of the enclosure", show } , 95 { "status", "", "Print the status of the enclosure", 96 encstatus }, 97 }; 98 99 static const int nbcmds = nitems(cmds); 100 static const char *uflag; 101 102 static void 103 usage(FILE *out, const char *subcmd) 104 { 105 int i; 106 107 if (subcmd == NULL) { 108 fprintf(out, "Usage: %s [-u /dev/ses<N>] <command> [options]\n", 109 getprogname()); 110 fprintf(out, "Commands supported:\n"); 111 } 112 for (i = 0; i < nbcmds; i++) { 113 if (subcmd != NULL) { 114 if (strcmp(subcmd, cmds[i].name) == 0) { 115 fprintf(out, "Usage: %s %s [-u /dev/ses<N>] " 116 "%s\n\t%s\n", getprogname(), subcmd, 117 cmds[i].param, cmds[i].desc); 118 break; 119 } 120 continue; 121 } 122 fprintf(out, " %-12s%s\n\t\t%s\n\n", cmds[i].name, 123 cmds[i].param, cmds[i].desc); 124 } 125 126 exit(EXIT_FAILURE); 127 } 128 129 static void 130 do_led(int fd, unsigned int idx, elm_type_t type, bool onoff, bool setfault) 131 { 132 int state = onoff ? 1 : 0; 133 encioc_elm_status_t o; 134 struct ses_ctrl_dev_slot *slot; 135 136 o.elm_idx = idx; 137 if (ioctl(fd, ENCIOC_GETELMSTAT, (caddr_t) &o) < 0) { 138 close(fd); 139 xo_err(EXIT_FAILURE, "ENCIOC_GETELMSTAT"); 140 } 141 slot = (struct ses_ctrl_dev_slot *) &o.cstat[0]; 142 switch (type) { 143 case ELMTYP_DEVICE: 144 case ELMTYP_ARRAY_DEV: 145 ses_ctrl_common_set_select(&slot->common, 1); 146 if (setfault) 147 ses_ctrl_dev_slot_set_rqst_fault(slot, state); 148 else 149 ses_ctrl_dev_slot_set_rqst_ident(slot, state); 150 break; 151 default: 152 return; 153 } 154 if (ioctl(fd, ENCIOC_SETELMSTAT, (caddr_t) &o) < 0) { 155 close(fd); 156 xo_err(EXIT_FAILURE, "ENCIOC_SETELMSTAT"); 157 } 158 } 159 160 static bool 161 disk_match(const char *devnames, const char *disk, size_t len) 162 { 163 const char *dname; 164 165 dname = devnames; 166 while ((dname = strstr(dname, disk)) != NULL) { 167 if (dname[len] == '\0' || dname[len] == ',') { 168 return (true); 169 } 170 dname++; 171 } 172 173 return (false); 174 } 175 176 static int 177 sesled(int argc, char **argv, bool setfault) 178 { 179 encioc_elm_devnames_t objdn; 180 encioc_element_t *objp; 181 glob_t g; 182 char *disk, *endptr; 183 size_t len, i, ndisks; 184 int fd; 185 unsigned int nobj, j, sesid; 186 bool all, isses, onoff; 187 188 isses = false; 189 all = false; 190 onoff = false; 191 192 if (argc != 3) { 193 usage(stderr, (setfault ? "fault" : "locate")); 194 } 195 196 disk = argv[1]; 197 198 sesid = strtoul(disk, &endptr, 10); 199 if (*endptr == '\0') { 200 endptr = strrchr(uflag, '*'); 201 if (endptr != NULL && *endptr == '*') { 202 xo_warnx("Must specifying a SES device (-u) to use a SES " 203 "id# to identify a disk"); 204 usage(stderr, (setfault ? "fault" : "locate")); 205 } 206 isses = true; 207 } 208 209 if (strcmp(argv[2], "on") == 0) { 210 onoff = true; 211 } else if (strcmp(argv[2], "off") == 0) { 212 onoff = false; 213 } else { 214 usage(stderr, (setfault ? "fault" : "locate")); 215 } 216 217 if (strcmp(disk, "all") == 0) { 218 all = true; 219 } 220 len = strlen(disk); 221 222 /* Get the list of ses devices */ 223 if (glob((uflag != NULL ? uflag : "/dev/ses[0-9]*"), 0, NULL, &g) == 224 GLOB_NOMATCH) { 225 globfree(&g); 226 xo_errx(EXIT_FAILURE, "No SES devices found"); 227 } 228 229 ndisks = 0; 230 for (i = 0; i < g.gl_pathc; i++) { 231 /* ensure we only got numbers after ses */ 232 if (strspn(g.gl_pathv[i] + 8, "0123456789") != 233 strlen(g.gl_pathv[i] + 8)) { 234 continue; 235 } 236 if ((fd = open(g.gl_pathv[i], O_RDWR)) < 0) { 237 /* 238 * Don't treat non-access errors as critical if we are 239 * accessing all devices 240 */ 241 if (errno == EACCES && g.gl_pathc > 1) { 242 xo_err(EXIT_FAILURE, "unable to access SES device"); 243 } 244 xo_warn("unable to access SES device: %s", g.gl_pathv[i]); 245 continue; 246 } 247 248 if (ioctl(fd, ENCIOC_GETNELM, (caddr_t) &nobj) < 0) { 249 close(fd); 250 xo_err(EXIT_FAILURE, "ENCIOC_GETNELM"); 251 } 252 253 objp = calloc(nobj, sizeof(encioc_element_t)); 254 if (objp == NULL) { 255 close(fd); 256 xo_err(EXIT_FAILURE, "calloc()"); 257 } 258 259 if (ioctl(fd, ENCIOC_GETELMMAP, (caddr_t) objp) < 0) { 260 free(objp); 261 close(fd); 262 xo_err(EXIT_FAILURE, "ENCIOC_GETELMMAP"); 263 } 264 265 if (isses) { 266 if (sesid >= nobj) { 267 free(objp); 268 close(fd); 269 xo_errx(EXIT_FAILURE, 270 "Requested SES ID does not exist"); 271 } 272 do_led(fd, sesid, objp[sesid].elm_type, onoff, setfault); 273 ndisks++; 274 free(objp); 275 close(fd); 276 break; 277 } 278 for (j = 0; j < nobj; j++) { 279 const int devnames_size = 128; 280 char devnames[devnames_size]; 281 282 if (all) { 283 do_led(fd, objp[j].elm_idx, objp[j].elm_type, 284 onoff, setfault); 285 continue; 286 } 287 memset(&objdn, 0, sizeof(objdn)); 288 memset(devnames, 0, devnames_size); 289 objdn.elm_idx = objp[j].elm_idx; 290 objdn.elm_names_size = devnames_size; 291 objdn.elm_devnames = devnames; 292 if (ioctl(fd, ENCIOC_GETELMDEVNAMES, 293 (caddr_t) &objdn) <0) { 294 continue; 295 } 296 if (objdn.elm_names_len > 0) { 297 if (disk_match(objdn.elm_devnames, disk, len)) { 298 do_led(fd, objdn.elm_idx, objp[j].elm_type, 299 onoff, setfault); 300 ndisks++; 301 break; 302 } 303 } 304 } 305 free(objp); 306 close(fd); 307 } 308 globfree(&g); 309 if (ndisks == 0 && all == false) { 310 xo_errx(EXIT_FAILURE, "Count not find the SES id of device '%s'", 311 disk); 312 } 313 314 return (EXIT_SUCCESS); 315 } 316 317 static int 318 locate(int argc, char **argv) 319 { 320 321 return (sesled(argc, argv, false)); 322 } 323 324 static int 325 fault(int argc, char **argv) 326 { 327 328 return (sesled(argc, argv, true)); 329 } 330 331 static void 332 sesutil_print(int *style, const char *fmt, ...) 333 { 334 va_list args; 335 336 if (*style == PRINT_STYLE_DASHED) { 337 xo_open_container("extra_status"); 338 xo_emit("\t\tExtra status:\n"); 339 *style = PRINT_STYLE_DASHED_2; 340 } else if (*style == PRINT_STYLE_CSV) { 341 xo_open_container("extra_status"); 342 *style = PRINT_STYLE_CSV_2; 343 } 344 345 if (*style == PRINT_STYLE_DASHED_2) 346 xo_emit("\t\t- "); 347 else if (*style == PRINT_STYLE_CSV_2) 348 xo_emit(", "); 349 va_start(args, fmt); 350 xo_emit_hv(NULL, fmt, args); 351 va_end(args); 352 if (*style == PRINT_STYLE_DASHED_2) 353 xo_emit("\n"); 354 } 355 356 static void 357 print_extra_status(int eletype, u_char *cstat, int style) 358 { 359 360 if (cstat[0] & 0x40) { 361 sesutil_print(&style, "{e:predicted_failure/true} Predicted Failure"); 362 } 363 if (cstat[0] & 0x20) { 364 sesutil_print(&style, "{e:disabled/true} Disabled"); 365 } 366 if (cstat[0] & 0x10) { 367 sesutil_print(&style, "{e:swapped/true} Swapped"); 368 } 369 switch (eletype) { 370 case ELMTYP_DEVICE: 371 case ELMTYP_ARRAY_DEV: 372 if (cstat[2] & 0x02) { 373 sesutil_print(&style, "LED={q:led/locate}"); 374 } 375 if (cstat[2] & 0x20) { 376 sesutil_print(&style, "LED={q:led/fault}"); 377 } 378 break; 379 case ELMTYP_FAN: 380 sesutil_print(&style, "Speed: {:speed/%d}{Uw:rpm}", 381 (((0x7 & cstat[1]) << 8) + cstat[2]) * 10); 382 break; 383 case ELMTYP_THERM: 384 if (cstat[2]) { 385 sesutil_print(&style, "Temperature: {:temperature/%d}{Uw:C}", 386 cstat[2] - TEMPERATURE_OFFSET); 387 } else { 388 sesutil_print(&style, "Temperature: -{q:temperature/reserved}"); 389 } 390 break; 391 case ELMTYP_VOM: 392 sesutil_print(&style, "Voltage: {:voltage/%.2f}{Uw:V}", 393 be16dec(cstat + 2) / 100.0); 394 break; 395 } 396 if (style) { 397 xo_close_container("extra_status"); 398 } 399 } 400 401 static int 402 objmap(int argc, char **argv __unused) 403 { 404 encioc_string_t stri; 405 encioc_elm_devnames_t e_devname; 406 encioc_elm_status_t e_status; 407 encioc_elm_desc_t e_desc; 408 encioc_element_t *e_ptr; 409 glob_t g; 410 int fd; 411 unsigned int j, nobj; 412 size_t i; 413 char str[32]; 414 415 if (argc != 1) { 416 usage(stderr, "map"); 417 } 418 419 /* Get the list of ses devices */ 420 if (glob(uflag, 0, NULL, &g) == GLOB_NOMATCH) { 421 globfree(&g); 422 xo_errx(EXIT_FAILURE, "No SES devices found"); 423 } 424 xo_set_version(SESUTIL_XO_VERSION); 425 xo_open_container("sesutil"); 426 xo_open_list("enclosures"); 427 for (i = 0; i < g.gl_pathc; i++) { 428 /* ensure we only got numbers after ses */ 429 if (strspn(g.gl_pathv[i] + 8, "0123456789") != 430 strlen(g.gl_pathv[i] + 8)) { 431 continue; 432 } 433 if ((fd = open(g.gl_pathv[i], O_RDWR)) < 0) { 434 /* 435 * Don't treat non-access errors as critical if we are 436 * accessing all devices 437 */ 438 if (errno == EACCES && g.gl_pathc > 1) { 439 xo_err(EXIT_FAILURE, "unable to access SES device"); 440 } 441 xo_warn("unable to access SES device: %s", g.gl_pathv[i]); 442 continue; 443 } 444 445 if (ioctl(fd, ENCIOC_GETNELM, (caddr_t) &nobj) < 0) { 446 close(fd); 447 xo_err(EXIT_FAILURE, "ENCIOC_GETNELM"); 448 } 449 450 e_ptr = calloc(nobj, sizeof(encioc_element_t)); 451 if (e_ptr == NULL) { 452 close(fd); 453 xo_err(EXIT_FAILURE, "calloc()"); 454 } 455 456 if (ioctl(fd, ENCIOC_GETELMMAP, (caddr_t) e_ptr) < 0) { 457 close(fd); 458 xo_err(EXIT_FAILURE, "ENCIOC_GETELMMAP"); 459 } 460 461 xo_open_instance("enclosures"); 462 xo_emit("{t:enc/%s}:\n", g.gl_pathv[i] + 5); 463 stri.bufsiz = sizeof(str); 464 stri.buf = &str[0]; 465 if (ioctl(fd, ENCIOC_GETENCNAME, (caddr_t) &stri) == 0) 466 xo_emit("\tEnclosure Name: {t:name/%s}\n", stri.buf); 467 stri.bufsiz = sizeof(str); 468 stri.buf = &str[0]; 469 if (ioctl(fd, ENCIOC_GETENCID, (caddr_t) &stri) == 0) 470 xo_emit("\tEnclosure ID: {t:id/%s}\n", stri.buf); 471 472 xo_open_list("elements"); 473 for (j = 0; j < nobj; j++) { 474 /* Get the status of the element */ 475 memset(&e_status, 0, sizeof(e_status)); 476 e_status.elm_idx = e_ptr[j].elm_idx; 477 if (ioctl(fd, ENCIOC_GETELMSTAT, 478 (caddr_t) &e_status) < 0) { 479 close(fd); 480 xo_err(EXIT_FAILURE, "ENCIOC_GETELMSTAT"); 481 } 482 /* Get the description of the element */ 483 memset(&e_desc, 0, sizeof(e_desc)); 484 e_desc.elm_idx = e_ptr[j].elm_idx; 485 e_desc.elm_desc_len = UINT16_MAX; 486 e_desc.elm_desc_str = calloc(UINT16_MAX, sizeof(char)); 487 if (e_desc.elm_desc_str == NULL) { 488 close(fd); 489 xo_err(EXIT_FAILURE, "calloc()"); 490 } 491 if (ioctl(fd, ENCIOC_GETELMDESC, 492 (caddr_t) &e_desc) < 0) { 493 close(fd); 494 xo_err(EXIT_FAILURE, "ENCIOC_GETELMDESC"); 495 } 496 /* Get the device name(s) of the element */ 497 memset(&e_devname, 0, sizeof(e_devname)); 498 e_devname.elm_idx = e_ptr[j].elm_idx; 499 e_devname.elm_names_size = 128; 500 e_devname.elm_devnames = calloc(128, sizeof(char)); 501 if (e_devname.elm_devnames == NULL) { 502 close(fd); 503 xo_err(EXIT_FAILURE, "calloc()"); 504 } 505 if (ioctl(fd, ENCIOC_GETELMDEVNAMES, 506 (caddr_t) &e_devname) <0) { 507 /* We don't care if this fails */ 508 e_devname.elm_devnames[0] = '\0'; 509 } 510 xo_open_instance("elements"); 511 xo_emit("\tElement {:id/%u}, Type: {:type/%s}\n", e_ptr[j].elm_idx, 512 geteltnm(e_ptr[j].elm_type)); 513 xo_emit("\t\tStatus: {:status/%s} ({q:status_code/0x%02x 0x%02x 0x%02x 0x%02x})\n", 514 scode2ascii(e_status.cstat[0]), e_status.cstat[0], 515 e_status.cstat[1], e_status.cstat[2], 516 e_status.cstat[3]); 517 if (e_desc.elm_desc_len > 0) { 518 xo_emit("\t\tDescription: {:description/%s}\n", 519 e_desc.elm_desc_str); 520 } 521 if (e_devname.elm_names_len > 0) { 522 xo_emit("\t\tDevice Names: {:device_names/%s}\n", 523 e_devname.elm_devnames); 524 } 525 print_extra_status(e_ptr[j].elm_type, e_status.cstat, PRINT_STYLE_DASHED); 526 xo_close_instance("elements"); 527 free(e_devname.elm_devnames); 528 } 529 xo_close_list("elements"); 530 free(e_ptr); 531 close(fd); 532 } 533 globfree(&g); 534 xo_close_list("enclosures"); 535 xo_close_container("sesutil"); 536 xo_finish(); 537 538 return (EXIT_SUCCESS); 539 } 540 541 /* 542 * Get rid of the 'passN' devices, unless there's nothing else to show. 543 */ 544 static void 545 skip_pass_devices(char *devnames, size_t devnameslen) 546 { 547 char *dev, devs[128], passes[128], *tmp; 548 549 devs[0] = passes[0] = '\0'; 550 tmp = devnames; 551 552 while ((dev = strsep(&tmp, ",")) != NULL) { 553 if (strncmp(dev, "pass", 4) == 0) { 554 if (passes[0] != '\0') 555 strlcat(passes, ",", sizeof(passes)); 556 strlcat(passes, dev, sizeof(passes)); 557 } else { 558 if (devs[0] != '\0') 559 strlcat(devs, ",", sizeof(devs)); 560 strlcat(devs, dev, sizeof(devs)); 561 } 562 } 563 strlcpy(devnames, devs, devnameslen); 564 if (devnames[0] == '\0') 565 strlcpy(devnames, passes, devnameslen); 566 } 567 568 static void 569 fetch_device_details(char *devnames, char **model, char **serial, off_t *size) 570 { 571 char ident[DISK_IDENT_SIZE]; 572 struct diocgattr_arg arg; 573 char *tmp; 574 off_t mediasize; 575 int comma; 576 int fd; 577 578 comma = (int)strcspn(devnames, ","); 579 asprintf(&tmp, "/dev/%.*s", comma, devnames); 580 if (tmp == NULL) 581 err(1, "asprintf"); 582 fd = open(tmp, O_RDONLY); 583 free(tmp); 584 if (fd < 0) { 585 /* 586 * This can happen with a disk so broken it cannot 587 * be probed by GEOM. 588 */ 589 *model = strdup("?"); 590 *serial = strdup("?"); 591 *size = -1; 592 close(fd); 593 return; 594 } 595 596 strlcpy(arg.name, "GEOM::descr", sizeof(arg.name)); 597 arg.len = sizeof(arg.value.str); 598 if (ioctl(fd, DIOCGATTR, &arg) == 0) 599 *model = strdup(arg.value.str); 600 else 601 *model = NULL; 602 603 if (ioctl(fd, DIOCGIDENT, ident) == 0) 604 *serial = strdup(ident); 605 else 606 *serial = NULL; 607 608 if (ioctl(fd, DIOCGMEDIASIZE, &mediasize) == 0) 609 *size = mediasize; 610 else 611 *size = -1; 612 close(fd); 613 } 614 615 static void 616 show_device(int fd, int elm_idx, encioc_elm_status_t e_status, encioc_elm_desc_t e_desc) 617 { 618 encioc_elm_devnames_t e_devname; 619 char *model, *serial; 620 off_t size; 621 622 /* Get the device name(s) of the element */ 623 memset(&e_devname, 0, sizeof(e_devname)); 624 e_devname.elm_idx = elm_idx; 625 e_devname.elm_names_size = 128; 626 e_devname.elm_devnames = calloc(128, sizeof(char)); 627 if (e_devname.elm_devnames == NULL) { 628 close(fd); 629 xo_err(EXIT_FAILURE, "calloc()"); 630 } 631 632 if (ioctl(fd, ENCIOC_GETELMDEVNAMES, 633 (caddr_t) &e_devname) < 0) { 634 /* We don't care if this fails */ 635 e_devname.elm_devnames[0] = '\0'; 636 model = NULL; 637 serial = NULL; 638 size = -1; 639 } else { 640 skip_pass_devices(e_devname.elm_devnames, 128); 641 fetch_device_details(e_devname.elm_devnames, &model, &serial, &size); 642 } 643 xo_open_instance("elements"); 644 xo_emit("{e:type/device_slot}"); 645 xo_emit("{d:description/%-8s} ", e_desc.elm_desc_len > 0 ? e_desc.elm_desc_str : "-"); 646 xo_emit("{e:description/%-8s}", e_desc.elm_desc_len > 0 ? e_desc.elm_desc_str : ""); 647 xo_emit("{d:device_names/%-7s} ", e_devname.elm_names_len > 0 ? e_devname.elm_devnames : "-"); 648 xo_emit("{e:device_names/%s}", e_devname.elm_names_len > 0 ? e_devname.elm_devnames : ""); 649 xo_emit("{d:model/%-25s} ", model ? model : "-"); 650 xo_emit("{e:model/%s}", model ? model : ""); 651 xo_emit("{d:serial/%-20s} ", serial != NULL ? serial : "-"); 652 xo_emit("{e:serial/%s}", serial != NULL ? serial : ""); 653 if ((e_status.cstat[0] & 0xf) == SES_OBJSTAT_OK && size >= 0) { 654 xo_emit("{h,hn-1000:size/%ld}{e:status/%s}", 655 size, scode2ascii(e_status.cstat[0])); 656 } else { 657 xo_emit("{:status/%s}", scode2ascii(e_status.cstat[0])); 658 } 659 print_extra_status(ELMTYP_ARRAY_DEV, e_status.cstat, PRINT_STYLE_CSV); 660 xo_emit("\n"); 661 xo_close_instance("elements"); 662 free(e_devname.elm_devnames); 663 } 664 665 static void 666 show_therm(encioc_elm_status_t e_status, encioc_elm_desc_t e_desc) 667 { 668 669 if (e_desc.elm_desc_len <= 0) { 670 /* We don't have a label to display; might as well skip it. */ 671 return; 672 } 673 674 if (e_status.cstat[2] == 0) { 675 /* No temperature to show. */ 676 return; 677 } 678 679 xo_open_instance("elements"); 680 xo_emit("{e:type/temperature_sensor}"); 681 xo_emit("{:description/%s}: {:temperature/%d}{Uw:C}", 682 e_desc.elm_desc_str, e_status.cstat[2] - TEMPERATURE_OFFSET); 683 xo_close_instance("elements"); 684 } 685 686 static void 687 show_vom(encioc_elm_status_t e_status, encioc_elm_desc_t e_desc) 688 { 689 690 if (e_desc.elm_desc_len <= 0) { 691 /* We don't have a label to display; might as well skip it. */ 692 return; 693 } 694 695 if (e_status.cstat[2] == 0) { 696 /* No voltage to show. */ 697 return; 698 } 699 700 xo_open_instance("elements"); 701 xo_emit("{e:type/voltage_sensor}"); 702 xo_emit("{:description/%s}: {:voltage/%.2f}{Uw:V}", 703 e_desc.elm_desc_str, be16dec(e_status.cstat + 2) / 100.0); 704 xo_close_instance("elements"); 705 } 706 707 static int 708 show(int argc, char **argv __unused) 709 { 710 encioc_string_t stri; 711 encioc_elm_status_t e_status; 712 encioc_elm_desc_t e_desc; 713 encioc_element_t *e_ptr; 714 glob_t g; 715 elm_type_t prev_type; 716 int fd; 717 unsigned int j, nobj; 718 size_t i; 719 bool first_ses; 720 char str[32]; 721 722 if (argc != 1) { 723 usage(stderr, "map"); 724 } 725 726 first_ses = true; 727 728 /* Get the list of ses devices */ 729 if (glob(uflag, 0, NULL, &g) == GLOB_NOMATCH) { 730 globfree(&g); 731 xo_errx(EXIT_FAILURE, "No SES devices found"); 732 } 733 xo_set_version(SESUTIL_XO_VERSION); 734 xo_open_container("sesutil"); 735 xo_open_list("enclosures"); 736 for (i = 0; i < g.gl_pathc; i++) { 737 /* ensure we only got numbers after ses */ 738 if (strspn(g.gl_pathv[i] + 8, "0123456789") != 739 strlen(g.gl_pathv[i] + 8)) { 740 continue; 741 } 742 if ((fd = open(g.gl_pathv[i], O_RDWR)) < 0) { 743 /* 744 * Don't treat non-access errors as critical if we are 745 * accessing all devices 746 */ 747 if (errno == EACCES && g.gl_pathc > 1) { 748 xo_err(EXIT_FAILURE, "unable to access SES device"); 749 } 750 xo_warn("unable to access SES device: %s", g.gl_pathv[i]); 751 continue; 752 } 753 754 if (ioctl(fd, ENCIOC_GETNELM, (caddr_t) &nobj) < 0) { 755 close(fd); 756 xo_err(EXIT_FAILURE, "ENCIOC_GETNELM"); 757 } 758 759 e_ptr = calloc(nobj, sizeof(encioc_element_t)); 760 if (e_ptr == NULL) { 761 close(fd); 762 xo_err(EXIT_FAILURE, "calloc()"); 763 } 764 765 if (ioctl(fd, ENCIOC_GETELMMAP, (caddr_t) e_ptr) < 0) { 766 close(fd); 767 xo_err(EXIT_FAILURE, "ENCIOC_GETELMMAP"); 768 } 769 770 xo_open_instance("enclosures"); 771 772 if (first_ses) 773 first_ses = false; 774 else 775 xo_emit("\n"); 776 777 xo_emit("{t:enc/%s}: ", g.gl_pathv[i] + 5); 778 stri.bufsiz = sizeof(str); 779 stri.buf = &str[0]; 780 if (ioctl(fd, ENCIOC_GETENCNAME, (caddr_t) &stri) == 0) 781 xo_emit("<{t:name/%s}>; ", stri.buf); 782 stri.bufsiz = sizeof(str); 783 stri.buf = &str[0]; 784 if (ioctl(fd, ENCIOC_GETENCID, (caddr_t) &stri) == 0) 785 xo_emit("ID: {t:id/%s}", stri.buf); 786 xo_emit("\n"); 787 788 xo_open_list("elements"); 789 prev_type = -1; 790 for (j = 0; j < nobj; j++) { 791 /* Get the status of the element */ 792 memset(&e_status, 0, sizeof(e_status)); 793 e_status.elm_idx = e_ptr[j].elm_idx; 794 if (ioctl(fd, ENCIOC_GETELMSTAT, 795 (caddr_t) &e_status) < 0) { 796 close(fd); 797 xo_err(EXIT_FAILURE, "ENCIOC_GETELMSTAT"); 798 } 799 800 /* 801 * Skip "Unsupported" elements; those usually precede 802 * the actual device entries and are not particularly 803 * interesting. 804 */ 805 if (e_status.cstat[0] == SES_OBJSTAT_UNSUPPORTED) 806 continue; 807 808 /* Get the description of the element */ 809 memset(&e_desc, 0, sizeof(e_desc)); 810 e_desc.elm_idx = e_ptr[j].elm_idx; 811 e_desc.elm_desc_len = UINT16_MAX; 812 e_desc.elm_desc_str = calloc(UINT16_MAX, sizeof(char)); 813 if (e_desc.elm_desc_str == NULL) { 814 close(fd); 815 xo_err(EXIT_FAILURE, "calloc()"); 816 } 817 if (ioctl(fd, ENCIOC_GETELMDESC, 818 (caddr_t) &e_desc) < 0) { 819 close(fd); 820 xo_err(EXIT_FAILURE, "ENCIOC_GETELMDESC"); 821 } 822 823 switch (e_ptr[j].elm_type) { 824 case ELMTYP_DEVICE: 825 case ELMTYP_ARRAY_DEV: 826 if (e_ptr[j].elm_type != prev_type) 827 xo_emit("Desc Dev Model Ident Size/Status\n"); 828 829 show_device(fd, e_ptr[j].elm_idx, e_status, e_desc); 830 prev_type = e_ptr[j].elm_type; 831 break; 832 case ELMTYP_THERM: 833 if (e_ptr[j].elm_type != prev_type) 834 xo_emit("\nTemperatures: "); 835 else 836 xo_emit(", "); 837 prev_type = e_ptr[j].elm_type; 838 show_therm(e_status, e_desc); 839 break; 840 case ELMTYP_VOM: 841 if (e_ptr[j].elm_type != prev_type) 842 xo_emit("\nVoltages: "); 843 else 844 xo_emit(", "); 845 prev_type = e_ptr[j].elm_type; 846 show_vom(e_status, e_desc); 847 break; 848 default: 849 /* 850 * Ignore stuff not interesting to the user. 851 */ 852 break; 853 } 854 } 855 if (prev_type != (elm_type_t)-1 && 856 prev_type != ELMTYP_DEVICE && prev_type != ELMTYP_ARRAY_DEV) 857 xo_emit("\n"); 858 xo_close_list("elements"); 859 free(e_ptr); 860 close(fd); 861 } 862 globfree(&g); 863 xo_close_list("enclosures"); 864 xo_close_container("sesutil"); 865 xo_finish(); 866 867 return (EXIT_SUCCESS); 868 } 869 870 static int 871 encstatus(int argc, char **argv __unused) 872 { 873 glob_t g; 874 int fd, status; 875 size_t i, e; 876 u_char estat; 877 878 status = 0; 879 if (argc != 1) { 880 usage(stderr, "status"); 881 } 882 883 /* Get the list of ses devices */ 884 if (glob(uflag, 0, NULL, &g) == GLOB_NOMATCH) { 885 globfree(&g); 886 xo_errx(EXIT_FAILURE, "No SES devices found"); 887 } 888 889 xo_set_version(SESUTIL_XO_VERSION); 890 xo_open_container("sesutil"); 891 xo_open_list("enclosures"); 892 for (i = 0; i < g.gl_pathc; i++) { 893 /* ensure we only got numbers after ses */ 894 if (strspn(g.gl_pathv[i] + 8, "0123456789") != 895 strlen(g.gl_pathv[i] + 8)) { 896 continue; 897 } 898 if ((fd = open(g.gl_pathv[i], O_RDWR)) < 0) { 899 /* 900 * Don't treat non-access errors as critical if we are 901 * accessing all devices 902 */ 903 if (errno == EACCES && g.gl_pathc > 1) { 904 xo_err(EXIT_FAILURE, "unable to access SES device"); 905 } 906 xo_warn("unable to access SES device: %s", g.gl_pathv[i]); 907 continue; 908 } 909 910 if (ioctl(fd, ENCIOC_GETENCSTAT, (caddr_t) &estat) < 0) { 911 xo_err(EXIT_FAILURE, "ENCIOC_GETENCSTAT"); 912 close(fd); 913 } 914 915 xo_open_instance("enclosures"); 916 xo_emit("{:enc/%s}: ", g.gl_pathv[i] + 5); 917 e = 0; 918 if (estat == 0) { 919 if (status == 0) { 920 status = 1; 921 } 922 xo_emit("{q:status/OK}"); 923 } else { 924 if (estat & SES_ENCSTAT_INFO) { 925 xo_emit("{lq:status/INFO}"); 926 e++; 927 } 928 if (estat & SES_ENCSTAT_NONCRITICAL) { 929 if (e) 930 xo_emit(","); 931 xo_emit("{lq:status/NONCRITICAL}"); 932 e++; 933 } 934 if (estat & SES_ENCSTAT_CRITICAL) { 935 if (e) 936 xo_emit(","); 937 xo_emit("{lq:status/CRITICAL}"); 938 e++; 939 status = -1; 940 } 941 if (estat & SES_ENCSTAT_UNRECOV) { 942 if (e) 943 xo_emit(","); 944 xo_emit("{lq:status/UNRECOV}"); 945 e++; 946 status = -1; 947 } 948 } 949 xo_close_instance("enclosures"); 950 xo_emit("\n"); 951 close(fd); 952 } 953 globfree(&g); 954 955 xo_close_list("enclosures"); 956 xo_close_container("sesutil"); 957 xo_finish(); 958 959 if (status == 1) { 960 return (EXIT_SUCCESS); 961 } else { 962 return (EXIT_FAILURE); 963 } 964 } 965 966 int 967 main(int argc, char **argv) 968 { 969 int i, ch; 970 struct command *cmd = NULL; 971 972 argc = xo_parse_args(argc, argv); 973 if (argc < 0) 974 exit(1); 975 976 uflag = "/dev/ses[0-9]*"; 977 while ((ch = getopt_long(argc, argv, "u:", NULL, NULL)) != -1) { 978 switch (ch) { 979 case 'u': 980 uflag = optarg; 981 break; 982 case '?': 983 default: 984 usage(stderr, NULL); 985 } 986 } 987 argc -= optind; 988 argv += optind; 989 990 if (argc < 1) { 991 warnx("Missing command"); 992 usage(stderr, NULL); 993 } 994 995 for (i = 0; i < nbcmds; i++) { 996 if (strcmp(argv[0], cmds[i].name) == 0) { 997 cmd = &cmds[i]; 998 break; 999 } 1000 } 1001 1002 if (cmd == NULL) { 1003 warnx("unknown command %s", argv[0]); 1004 usage(stderr, NULL); 1005 } 1006 1007 return (cmd->exec(argc, argv)); 1008 } 1009