sesutil.c revision 306797 
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: stable/10/usr.sbin/sesutil/sesutil.c 306797 2016-10-07 01:33:03Z mav $");
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
55static int encstatus(int argc, char **argv);
56static int fault(int argc, char **argv);
57static int locate(int argc, char **argv);
58static int objmap(int argc, char **argv);
59static int sesled(int argc, char **argv, bool fault);
60
61static 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
81static const int nbcmds = nitems(cmds);
82static const char *uflag;
83
84static void
85usage(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
111static void
112do_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
140static bool
141disk_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
156static int
157sesled(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
293static int
294locate(int argc, char **argv)
295{
296
297	return (sesled(argc, argv, false));
298}
299
300static int
301fault(int argc, char **argv)
302{
303
304	return (sesled(argc, argv, true));
305}
306
307static int
308objmap(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
441static int
442encstatus(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
528int
529main(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}
567