kernel - Fix mprace in kern_objcache
[dragonfly.git] / sbin / ccdconfig / ccdconfig.c
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  * $DragonFly: src/sbin/ccdconfig/ccdconfig.c,v 1.9 2007/05/20 23:21:33 dillon Exp $
35  */
36
37 #define _KERNEL_STRUCTURES
38 #include <sys/param.h>
39 #include <sys/linker.h>
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
59 static  int lineno = 0;
60 static  int verbose = 0;
61 static  const char *ccdconf = _PATH_CCDCONF;
62
63 static  char *core = NULL;
64 static  char *kernel = NULL;
65
66 struct  flagval {
67         const char      *fv_flag;
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
77 static  struct nlist nl[] = {
78         { "_ccd_softc", 0, 0, 0, 0 },
79 #define SYM_CCDSOFTC            0
80         { "_numccd", 0, 0, 0, 0 },
81 #define SYM_NUMCCD              1
82         { NULL , 0, 0, 0, 0 },
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
91 static  int checkdev(char *);
92 static  int do_io(char *, u_long, struct ccd_ioctl *);
93 static  int do_single(int, char **, int);
94 static  int do_all(int);
95 static  int dump_ccd(int, char **);
96 static  int getmaxpartitions(void);
97 static  int flags_to_val(char *);
98 static  void print_ccd_info(struct ccd_softc *, kvm_t *);
99 static  char *resolve_ccdname(char *);
100 static  void usage(void);
101
102 int
103 main(int argc, char **argv)
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
193 static int
194 do_single(int argc, char **argv, int action)
195 {
196         struct ccd_ioctl ccio;
197         char *ccd, *cp, *cp2, **disks;
198         int noflags = 0, ileave, flags = 0, j;
199         unsigned int i;
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                 }
301                 printf(", %ju blocks ", (uintmax_t)ccio.ccio_size);
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
312 static int
313 do_all(int action)
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
372         fclose(f);
373         return (rval);
374 }
375
376 static int
377 checkdev(char *path)
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
390 static int
391 pathtounit(char *path, int *unitp)
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
410 static char *
411 resolve_ccdname(char *name)
412 {
413         char c, *path;
414         size_t len;
415
416         if (name[0] == '/' || name[0] == '.') {
417                 /* Assume they gave the correct pathname. */
418                 return (strdup(name));
419         }
420
421         len = strlen(name);
422         if (len > 0)
423                 c = name[len - 1];
424         else
425                 c = '\0';
426
427         asprintf(&path, "%s%s", _PATH_DEV, name);
428
429         return (path);
430 }
431
432 static int
433 do_io(char *path, u_long cmd, struct ccd_ioctl *cciop)
434 {
435         int fd;
436         const char *cp;
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) {                                            \
464         kvm_close((kd));                                                \
465         warnx("%s", (str));                                                     \
466         warnx("%s", kvm_geterr((kd)));                                  \
467         return (1);                                                     \
468 }
469
470 static int
471 dump_ccd(int argc, char **argv)
472 {
473         char errbuf[_POSIX2_LINE_MAX], *ccd, *cp;
474         struct ccd_softc *cs, *kcs;
475         ssize_t readsize;
476         int i = 0, error, numccd, numconfiged = 0;
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:
556         kvm_close(kd);
557         return (0);
558
559  bad:
560         kvm_close(kd);
561         return (1);
562 }
563
564 static void
565 print_ccd_info(struct ccd_softc *cs, kvm_t *kd)
566 {
567         static int header_printed = 0;
568         struct ccdcinfo *cip;
569         ssize_t readsize;
570         char path[MAXPATHLEN];
571         unsigned int i;
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) {
602                 if ((unsigned)kvm_read(kd, (u_long)cip[i].ci_path, (char *)path,
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
617 static int
618 getmaxpartitions(void)
619 {
620     return (MAXPARTITIONS);
621 }
622
623 static int
624 flags_to_val(char *flags)
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
681 static void
682 usage(void)
683 {
684         fprintf(stderr, "%s\n%s\n%s\n%s\n%s\n",
685                 "usage: ccdconfig [-cv] ccd ileave [flags] dev ...",
686                 "       ccdconfig -C [-v] [-f config_file]",
687                 "       ccdconfig -u [-v] ccd ...",
688                 "       ccdconfig -U [-v] [-f config_file]",
689                 "       ccdconfig -g [-M core] [-N system] [ccd ...]");
690         exit(1);
691 }
692
693 /* Local Variables: */
694 /* c-argdecl-indent: 8 */
695 /* c-indent-level: 8 */
696 /* End: */