xref: /dragonfly/sbin/ccdconfig/ccdconfig.c (revision 4d0c54c1) 
1 /*
2  * Copyright (c) 1995 Jason R. Thorpe.
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *	This product includes software developed for the NetBSD Project
16  *	by Jason R. Thorpe.
17  * 4. The name of the author may not be used to endorse or promote products
18  *    derived from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
24  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
25  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
27  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
28  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  *
32  * $NetBSD: ccdconfig.c,v 1.2.2.1 1995/11/11 02:43:35 thorpej Exp $
33  * $FreeBSD: src/sbin/ccdconfig/ccdconfig.c,v 1.16.2.2 2000/12/11 01:03:25 obrien Exp $
34  */
35 
36 #define _KERNEL_STRUCTURES
37 #include <sys/param.h>
38 #include <sys/linker.h>
39 #include <sys/stat.h>
40 #include <sys/module.h>
41 #include <ctype.h>
42 #include <err.h>
43 #include <errno.h>
44 #include <fcntl.h>
45 #include <kvm.h>
46 #include <limits.h>
47 #include <paths.h>
48 #include <stdio.h>
49 #include <stdlib.h>
50 #include <string.h>
51 #include <unistd.h>
52 
53 #include <sys/devicestat.h>
54 #include <sys/ccdvar.h>
55 
56 #include "pathnames.h"
57 
58 static	int lineno = 0;
59 static	int verbose = 0;
60 static	const char *ccdconf = _PATH_CCDCONF;
61 
62 static	char *core = NULL;
63 static	char *kernel = NULL;
64 
65 struct	flagval {
66 	const char	*fv_flag;
67 	int	fv_val;
68 } flagvaltab[] = {
69 	{ "CCDF_SWAP",		CCDF_SWAP },
70 	{ "CCDF_UNIFORM",	CCDF_UNIFORM },
71 	{ "CCDF_MIRROR",	CCDF_MIRROR },
72 	{ "CCDF_PARITY",	CCDF_PARITY },
73 	{ NULL,			0 },
74 };
75 
76 static	struct nlist nl[] = {
77 	{ "_ccd_softc", 0, 0, 0, 0 },
78 #define SYM_CCDSOFTC		0
79 	{ "_numccd", 0, 0, 0, 0 },
80 #define SYM_NUMCCD		1
81 	{ NULL , 0, 0, 0, 0 },
82 };
83 
84 #define CCD_CONFIG		0	/* configure a device */
85 #define CCD_CONFIGALL		1	/* configure all devices */
86 #define CCD_UNCONFIG		2	/* unconfigure a device */
87 #define CCD_UNCONFIGALL		3	/* unconfigure all devices */
88 #define CCD_DUMP		4	/* dump a ccd's configuration */
89 
90 static	int checkdev(char *);
91 static	int do_io(char *, u_long, struct ccd_ioctl *);
92 static	int do_single(int, char **, int);
93 static	int do_all(int);
94 static	int dump_ccd(int, char **);
95 static	int getmaxpartitions(void);
96 static	int flags_to_val(char *);
97 static	void print_ccd_info(struct ccd_softc *, kvm_t *);
98 static	char *resolve_ccdname(char *);
99 static	void usage(void);
100 
101 int
102 main(int argc, char **argv)
103 {
104 	int ch, options = 0, action = CCD_CONFIG;
105 
106 	while ((ch = getopt(argc, argv, "cCf:gM:N:uUv")) != -1) {
107 		switch (ch) {
108 		case 'c':
109 			action = CCD_CONFIG;
110 			++options;
111 			break;
112 
113 		case 'C':
114 			action = CCD_CONFIGALL;
115 			++options;
116 			break;
117 
118 		case 'f':
119 			ccdconf = optarg;
120 			break;
121 
122 		case 'g':
123 			action = CCD_DUMP;
124 			break;
125 
126 		case 'M':
127 			core = optarg;
128 			break;
129 
130 		case 'N':
131 			kernel = optarg;
132 			break;
133 
134 		case 'u':
135 			action = CCD_UNCONFIG;
136 			++options;
137 			break;
138 
139 		case 'U':
140 			action = CCD_UNCONFIGALL;
141 			++options;
142 			break;
143 
144 		case 'v':
145 			verbose = 1;
146 			break;
147 
148 		default:
149 			usage();
150 		}
151 	}
152 	argc -= optind;
153 	argv += optind;
154 
155 	if (options > 1)
156 		usage();
157 
158 	/*
159 	 * Discard setgid privileges if not the running kernel so that bad
160 	 * guys can't print interesting stuff from kernel memory.
161 	 */
162 	if (core != NULL || kernel != NULL || action != CCD_DUMP) {
163 		setegid(getgid());
164 		setgid(getgid());
165 	}
166 
167 	if (modfind("ccd") < 0) {
168 		/* Not present in kernel, try loading it */
169 		if (kldload("ccd") < 0 || modfind("ccd") < 0)
170 			warn("ccd module not available!");
171 	}
172 
173 	switch (action) {
174 		case CCD_CONFIG:
175 		case CCD_UNCONFIG:
176 			exit(do_single(argc, argv, action));
177 			/* NOTREACHED */
178 
179 		case CCD_CONFIGALL:
180 		case CCD_UNCONFIGALL:
181 			exit(do_all(action));
182 			/* NOTREACHED */
183 
184 		case CCD_DUMP:
185 			exit(dump_ccd(argc, argv));
186 			/* NOTREACHED */
187 	}
188 	/* NOTREACHED */
189 	return (0);
190 }
191 
192 static int
193 do_single(int argc, char **argv, int action)
194 {
195 	struct ccd_ioctl ccio;
196 	char *ccd, *cp, *cp2, **disks;
197 	int noflags = 0, ileave, flags = 0, j;
198 	unsigned int i;
199 
200 	bzero(&ccio, sizeof(ccio));
201 
202 	/*
203 	 * If unconfiguring, all arguments are treated as ccds.
204 	 */
205 	if (action == CCD_UNCONFIG || action == CCD_UNCONFIGALL) {
206 		for (i = 0; argc != 0; ) {
207 			cp = *argv++; --argc;
208 			if ((ccd = resolve_ccdname(cp)) == NULL) {
209 				warnx("invalid ccd name: %s", cp);
210 				i = 1;
211 				continue;
212 			}
213 			if (do_io(ccd, CCDIOCCLR, &ccio))
214 				i = 1;
215 			else
216 				if (verbose)
217 					printf("%s unconfigured\n", cp);
218 		}
219 		return (i);
220 	}
221 
222 	/* Make sure there are enough arguments. */
223 	if (argc < 4) {
224 		if (argc == 3) {
225 			/* Assume that no flags are specified. */
226 			noflags = 1;
227 		} else {
228 			if (action == CCD_CONFIGALL) {
229 				warnx("%s: bad line: %d", ccdconf, lineno);
230 				return (1);
231 			} else
232 				usage();
233 		}
234 	}
235 
236 	/* First argument is the ccd to configure. */
237 	cp = *argv++; --argc;
238 	if ((ccd = resolve_ccdname(cp)) == NULL) {
239 		warnx("invalid ccd name: %s", cp);
240 		return (1);
241 	}
242 
243 	/* Next argument is the interleave factor. */
244 	cp = *argv++; --argc;
245 	errno = 0;	/* to check for ERANGE */
246 	ileave = (int)strtol(cp, &cp2, 10);
247 	if ((errno == ERANGE) || (ileave < 0) || (*cp2 != '\0')) {
248 		warnx("invalid interleave factor: %s", cp);
249 		return (1);
250 	}
251 
252 	if (noflags == 0) {
253 		/* Next argument is the ccd configuration flags. */
254 		cp = *argv++; --argc;
255 		if ((flags = flags_to_val(cp)) < 0) {
256 			warnx("invalid flags argument: %s", cp);
257 			return (1);
258 		}
259 	}
260 
261 	/* Next is the list of disks to make the ccd from. */
262 	disks = malloc(argc * sizeof(char *));
263 	if (disks == NULL) {
264 		warnx("no memory to configure ccd");
265 		return (1);
266 	}
267 	for (i = 0; argc != 0; ) {
268 		cp = *argv++; --argc;
269 		if ((j = checkdev(cp)) == 0)
270 			disks[i++] = cp;
271 		else {
272 			warnx("%s: %s", cp, strerror(j));
273 			return (1);
274 		}
275 	}
276 
277 	/* Fill in the ccio. */
278 	ccio.ccio_disks = disks;
279 	ccio.ccio_ndisks = i;
280 	ccio.ccio_ileave = ileave;
281 	ccio.ccio_flags = flags;
282 
283 	if (do_io(ccd, CCDIOCSET, &ccio)) {
284 		free(disks);
285 		return (1);
286 	}
287 
288 	if (verbose) {
289 		printf("ccd%d: %d components ", ccio.ccio_unit,
290 		    ccio.ccio_ndisks);
291 		for (i = 0; i < ccio.ccio_ndisks; ++i) {
292 			if ((cp2 = strrchr(disks[i], '/')) != NULL)
293 				++cp2;
294 			else
295 				cp2 = disks[i];
296 			printf("%c%s%c",
297 			    i == 0 ? '(' : ' ', cp2,
298 			    i == ccio.ccio_ndisks - 1 ? ')' : ',');
299 		}
300 		printf(", %ju blocks ", (uintmax_t)ccio.ccio_size);
301 		if (ccio.ccio_ileave != 0)
302 			printf("interleaved at %d blocks\n", ccio.ccio_ileave);
303 		else
304 			printf("concatenated\n");
305 	}
306 
307 	free(disks);
308 	return (0);
309 }
310 
311 static int
312 do_all(int action)
313 {
314 	FILE *f;
315 	char line[_POSIX2_LINE_MAX];
316 	char *cp, **argv;
317 	int argc, rval;
318 	gid_t egid;
319 
320 	rval = 0;
321 	egid = getegid();
322 	setegid(getgid());
323 	if ((f = fopen(ccdconf, "r")) == NULL) {
324 		setegid(egid);
325 		warn("fopen: %s", ccdconf);
326 		return (1);
327 	}
328 	setegid(egid);
329 
330 	while (fgets(line, sizeof(line), f) != NULL) {
331 		argc = 0;
332 		argv = NULL;
333 		++lineno;
334 		if ((cp = strrchr(line, '\n')) != NULL)
335 			*cp = '\0';
336 
337 		/* Break up the line and pass it's contents to do_single(). */
338 		if (line[0] == '\0')
339 			goto end_of_line;
340 		for (cp = line; (cp = strtok(cp, " \t")) != NULL; cp = NULL) {
341 			if (*cp == '#')
342 				break;
343 			if ((argv = realloc(argv,
344 			    sizeof(char *) * ++argc)) == NULL) {
345 				warnx("no memory to configure ccds");
346 				return (1);
347 			}
348 			argv[argc - 1] = cp;
349 			/*
350 			 * If our action is to unconfigure all, then pass
351 			 * just the first token to do_single() and ignore
352 			 * the rest.  Since this will be encountered on
353 			 * our first pass through the line, the Right
354 			 * Thing will happen.
355 			 */
356 			if (action == CCD_UNCONFIGALL) {
357 				if (do_single(argc, argv, action))
358 					rval = 1;
359 				goto end_of_line;
360 			}
361 		}
362 		if (argc != 0)
363 			if (do_single(argc, argv, action))
364 				rval = 1;
365 
366  end_of_line:
367 		if (argv != NULL)
368 			free(argv);
369 	}
370 
371 	fclose(f);
372 	return (rval);
373 }
374 
375 static int
376 checkdev(char *path)
377 {
378 	struct stat st;
379 
380 	if (stat(path, &st) != 0)
381 		return (errno);
382 
383 	if (!S_ISBLK(st.st_mode) && !S_ISCHR(st.st_mode))
384 		return (EINVAL);
385 
386 	return (0);
387 }
388 
389 static int
390 pathtounit(char *path, int *unitp)
391 {
392 	struct stat st;
393 	int maxpartitions;
394 
395 	if (stat(path, &st) != 0)
396 		return (errno);
397 
398 	if (!S_ISBLK(st.st_mode) && !S_ISCHR(st.st_mode))
399 		return (EINVAL);
400 
401 	if ((maxpartitions = getmaxpartitions()) < 0)
402 		return (errno);
403 
404 	*unitp = minor(st.st_rdev) / maxpartitions;
405 
406 	return (0);
407 }
408 
409 static char *
410 resolve_ccdname(char *name)
411 {
412 	char *path;
413 
414 	if (name[0] == '/' || name[0] == '.') {
415 		/* Assume they gave the correct pathname. */
416 		return (strdup(name));
417 	}
418 
419 	asprintf(&path, "%s%s", _PATH_DEV, name);
420 
421 	return (path);
422 }
423 
424 static int
425 do_io(char *path, u_long cmd, struct ccd_ioctl *cciop)
426 {
427 	int fd;
428 	const char *cp;
429 
430 	if ((fd = open(path, O_RDWR, 0640)) < 0) {
431 		warn("open: %s", path);
432 		return (1);
433 	}
434 
435 	if (ioctl(fd, cmd, cciop) < 0) {
436 		switch (cmd) {
437 		case CCDIOCSET:
438 			cp = "CCDIOCSET";
439 			break;
440 
441 		case CCDIOCCLR:
442 			cp = "CCDIOCCLR";
443 			break;
444 
445 		default:
446 			cp = "unknown";
447 		}
448 		warn("ioctl (%s): %s", cp, path);
449 		return (1);
450 	}
451 
452 	return (0);
453 }
454 
455 #define KVM_ABORT(kd, str) {						\
456 	kvm_close((kd));						\
457 	warnx("%s", (str));							\
458 	warnx("%s", kvm_geterr((kd)));					\
459 	return (1);							\
460 }
461 
462 static int
463 dump_ccd(int argc, char **argv)
464 {
465 	char errbuf[_POSIX2_LINE_MAX], *ccd, *cp;
466 	struct ccd_softc *cs, *kcs;
467 	ssize_t readsize;
468 	int i = 0, error, numccd, numconfiged = 0;
469 	kvm_t *kd;
470 
471 	bzero(errbuf, sizeof(errbuf));
472 
473 	if ((kd = kvm_openfiles(kernel, core, NULL, O_RDONLY,
474 	    errbuf)) == NULL) {
475 		warnx("can't open kvm: %s", errbuf);
476 		return (1);
477 	}
478 
479 	if (kvm_nlist(kd, nl))
480 		KVM_ABORT(kd, "ccd-related symbols not available");
481 
482 	/* Check to see how many ccds are currently configured. */
483 	if (kvm_read(kd, nl[SYM_NUMCCD].n_value, (char *)&numccd,
484 	    sizeof(numccd)) != sizeof(numccd))
485 		KVM_ABORT(kd, "can't determine number of configured ccds");
486 
487 	if (numccd == 0) {
488 		printf("ccd driver in kernel, but is uninitialized\n");
489 		goto done;
490 	}
491 
492 	/* Allocate space for the configuration data. */
493 	readsize = numccd * sizeof(struct ccd_softc);
494 	if ((cs = malloc(readsize)) == NULL) {
495 		warnx("no memory for configuration data");
496 		goto bad;
497 	}
498 	bzero(cs, readsize);
499 
500 	/*
501 	 * Read the ccd configuration data from the kernel and dump
502 	 * it to stdout.
503 	 */
504 	if (kvm_read(kd, nl[SYM_CCDSOFTC].n_value, (char *)&kcs,
505 	    sizeof(kcs)) != sizeof(kcs)) {
506 		free(cs);
507 		KVM_ABORT(kd, "can't find pointer to configuration data");
508 	}
509 	if (kvm_read(kd, (u_long)kcs, (char *)cs, readsize) != readsize) {
510 		free(cs);
511 		KVM_ABORT(kd, "can't read configuration data");
512 	}
513 
514 	if (argc == 0) {
515 		for (i = 0; i < numccd; ++i)
516 			if (cs[i].sc_flags & CCDF_INITED) {
517 				++numconfiged;
518 				print_ccd_info(&cs[i], kd);
519 			}
520 
521 		if (numconfiged == 0)
522 			printf("no concatenated disks configured\n");
523 	} else {
524 		while (argc) {
525 			cp = *argv++; --argc;
526 			if ((ccd = resolve_ccdname(cp)) == NULL) {
527 				warnx("invalid ccd name: %s", cp);
528 				continue;
529 			}
530 			if ((error = pathtounit(ccd, &i)) != 0) {
531 				warnx("%s: %s", ccd, strerror(error));
532 				continue;
533 			}
534 			if (i >= numccd) {
535 				warnx("ccd%d not configured", i);
536 				continue;
537 			}
538 			if (cs[i].sc_flags & CCDF_INITED)
539 				print_ccd_info(&cs[i], kd);
540 			else
541 				printf("ccd%d not configured\n", i);
542 		}
543 	}
544 
545 	free(cs);
546 
547  done:
548 	kvm_close(kd);
549 	return (0);
550 
551  bad:
552 	kvm_close(kd);
553 	return (1);
554 }
555 
556 static void
557 print_ccd_info(struct ccd_softc *cs, kvm_t *kd)
558 {
559 	static int header_printed = 0;
560 	struct ccdcinfo *cip;
561 	ssize_t readsize;
562 	char path[MAXPATHLEN];
563 	unsigned int i;
564 
565 	if (header_printed == 0 && verbose) {
566 		printf("# ccd\t\tileave\tflags\tcompnent devices\n");
567 		header_printed = 1;
568 	}
569 
570 	readsize = cs->sc_nccdisks * sizeof(struct ccdcinfo);
571 	if ((cip = malloc(readsize)) == NULL) {
572 		warn("ccd%d: can't allocate memory for component info",
573 		    cs->sc_unit);
574 		return;
575 	}
576 	bzero(cip, readsize);
577 
578 	/* Dump out softc information. */
579 	printf("ccd%d\t\t%d\t%d\t", cs->sc_unit, cs->sc_ileave,
580 	    cs->sc_cflags & CCDF_USERMASK);
581 	fflush(stdout);
582 
583 	/* Read in the component info. */
584 	if (kvm_read(kd, (u_long)cs->sc_cinfo, (char *)cip,
585 	    readsize) != readsize) {
586 		printf("\n");
587 		warnx("can't read component info");
588 		warnx("%s", kvm_geterr(kd));
589 		goto done;
590 	}
591 
592 	/* Read component pathname and display component info. */
593 	for (i = 0; i < cs->sc_nccdisks; ++i) {
594 		if ((unsigned)kvm_read(kd, (u_long)cip[i].ci_path, (char *)path,
595 		    cip[i].ci_pathlen) != cip[i].ci_pathlen) {
596 			printf("\n");
597 			warnx("can't read component pathname");
598 			warnx("%s", kvm_geterr(kd));
599 			goto done;
600 		}
601 		printf((i + 1 < cs->sc_nccdisks) ? "%s " : "%s\n", path);
602 		fflush(stdout);
603 	}
604 
605  done:
606 	free(cip);
607 }
608 
609 static int
610 getmaxpartitions(void)
611 {
612     return (MAXPARTITIONS);
613 }
614 
615 static int
616 flags_to_val(char *flags)
617 {
618 	char *cp, *tok;
619 	int i, tmp, val = ~CCDF_USERMASK;
620 	size_t flagslen;
621 
622 	/*
623 	 * The most common case is that of NIL flags, so check for
624 	 * those first.
625 	 */
626 	if (strcmp("none", flags) == 0 || strcmp("0x0", flags) == 0 ||
627 	    strcmp("0", flags) == 0)
628 		return (0);
629 
630 	flagslen = strlen(flags);
631 
632 	/* Check for values represented by strings. */
633 	if ((cp = strdup(flags)) == NULL)
634 		err(1, "no memory to parse flags");
635 	tmp = 0;
636 	for (tok = cp; (tok = strtok(tok, ",")) != NULL; tok = NULL) {
637 		for (i = 0; flagvaltab[i].fv_flag != NULL; ++i)
638 			if (strcmp(tok, flagvaltab[i].fv_flag) == 0)
639 				break;
640 		if (flagvaltab[i].fv_flag == NULL) {
641 			free(cp);
642 			goto bad_string;
643 		}
644 		tmp |= flagvaltab[i].fv_val;
645 	}
646 
647 	/* If we get here, the string was ok. */
648 	free(cp);
649 	val = tmp;
650 	goto out;
651 
652  bad_string:
653 
654 	/* Check for values represented in hex. */
655 	if (flagslen > 2 && flags[0] == '0' && flags[1] == 'x') {
656 		errno = 0;	/* to check for ERANGE */
657 		val = (int)strtol(&flags[2], &cp, 16);
658 		if ((errno == ERANGE) || (*cp != '\0'))
659 			return (-1);
660 		goto out;
661 	}
662 
663 	/* Check for values represented in decimal. */
664 	errno = 0;	/* to check for ERANGE */
665 	val = (int)strtol(flags, &cp, 10);
666 	if ((errno == ERANGE) || (*cp != '\0'))
667 		return (-1);
668 
669  out:
670 	return (((val & ~CCDF_USERMASK) == 0) ? val : -1);
671 }
672 
673 static void
674 usage(void)
675 {
676 	fprintf(stderr, "%s\n%s\n%s\n%s\n%s\n",
677 		"usage: ccdconfig [-cv] ccd ileave [flags] dev ...",
678 		"       ccdconfig -C [-v] [-f config_file]",
679 		"       ccdconfig -u [-v] ccd ...",
680 		"       ccdconfig -U [-v] [-f config_file]",
681 		"       ccdconfig -g [-M core] [-N system] [ccd ...]");
682 	exit(1);
683 }
684 
685 /* Local Variables: */
686 /* c-argdecl-indent: 8 */
687 /* c-indent-level: 8 */
688 /* End: */
689