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