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  */
  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!\n"
 171                             "NOTE: Systems which don't have /boot as part of"
 172                             " the root partition\n"
 173                             "      (as is the case with the default HAMMER"
 174                             " install) need to load ccd(4)\n"
 175                             "      via /boot/loader.conf or compile it into"
 176                             " the kernel.");
 177                 }
 178         }
 179
 180         switch (action) {
 181                 case CCD_CONFIG:
 182                 case CCD_UNCONFIG:
 183                         exit(do_single(argc, argv, action));
 184                         /* NOTREACHED */
 185
 186                 case CCD_CONFIGALL:
 187                 case CCD_UNCONFIGALL:
 188                         exit(do_all(action));
 189                         /* NOTREACHED */
 190
 191                 case CCD_DUMP:
 192                         exit(dump_ccd(argc, argv));
 193                         /* NOTREACHED */
 194         }
 195         /* NOTREACHED */
 196         return (0);
 197 }
 198
 199 static int
 200 do_single(int argc, char **argv, int action)
 201 {
 202         struct ccd_ioctl ccio;
 203         char *ccd, *cp, *cp2, **disks;
 204         int noflags = 0, ileave, flags = 0, j;
 205         unsigned int i;
 206
 207         bzero(&ccio, sizeof(ccio));
 208
 209         /*
 210          * If unconfiguring, all arguments are treated as ccds.
 211          */
 212         if (action == CCD_UNCONFIG || action == CCD_UNCONFIGALL) {
 213                 for (i = 0; argc != 0; ) {
 214                         cp = *argv++; --argc;
 215                         if ((ccd = resolve_ccdname(cp)) == NULL) {
 216                                 warnx("invalid ccd name: %s", cp);
 217                                 i = 1;
 218                                 continue;
 219                         }
 220                         if (do_io(ccd, CCDIOCCLR, &ccio))
 221                                 i = 1;
 222                         else
 223                                 if (verbose)
 224                                         printf("%s unconfigured\n", cp);
 225                 }
 226                 return (i);
 227         }
 228
 229         /* Make sure there are enough arguments. */
 230         if (argc < 4) {
 231                 if (argc == 3) {
 232                         /* Assume that no flags are specified. */
 233                         noflags = 1;
 234                 } else {
 235                         if (action == CCD_CONFIGALL) {
 236                                 warnx("%s: bad line: %d", ccdconf, lineno);
 237                                 return (1);
 238                         } else
 239                                 usage();
 240                 }
 241         }
 242
 243         /* First argument is the ccd to configure. */
 244         cp = *argv++; --argc;
 245         if ((ccd = resolve_ccdname(cp)) == NULL) {
 246                 warnx("invalid ccd name: %s", cp);
 247                 return (1);
 248         }
 249
 250         /* Next argument is the interleave factor. */
 251         cp = *argv++; --argc;
 252         errno = 0;      /* to check for ERANGE */
 253         ileave = (int)strtol(cp, &cp2, 10);
 254         if ((errno == ERANGE) || (ileave < 0) || (*cp2 != '\0')) {
 255                 warnx("invalid interleave factor: %s", cp);
 256                 return (1);
 257         }
 258
 259         if (noflags == 0) {
 260                 /* Next argument is the ccd configuration flags. */
 261                 cp = *argv++; --argc;
 262                 if ((flags = flags_to_val(cp)) < 0) {
 263                         warnx("invalid flags argument: %s", cp);
 264                         return (1);
 265                 }
 266         }
 267
 268         /* Next is the list of disks to make the ccd from. */
 269         disks = malloc(argc * sizeof(char *));
 270         if (disks == NULL) {
 271                 warnx("no memory to configure ccd");
 272                 return (1);
 273         }
 274         for (i = 0; argc != 0; ) {
 275                 cp = *argv++; --argc;
 276                 if ((j = checkdev(cp)) == 0)
 277                         disks[i++] = cp;
 278                 else {
 279                         warnx("%s: %s", cp, strerror(j));
 280                         free(disks);
 281                         return (1);
 282                 }
 283         }
 284
 285         /* Fill in the ccio. */
 286         ccio.ccio_disks = disks;
 287         ccio.ccio_ndisks = i;
 288         ccio.ccio_ileave = ileave;
 289         ccio.ccio_flags = flags;
 290
 291         if (do_io(ccd, CCDIOCSET, &ccio)) {
 292                 free(disks);
 293                 return (1);
 294         }
 295
 296         if (verbose) {
 297                 printf("ccd%d: %d components ", ccio.ccio_unit,
 298                     ccio.ccio_ndisks);
 299                 for (i = 0; i < ccio.ccio_ndisks; ++i) {
 300                         if ((cp2 = strrchr(disks[i], '/')) != NULL)
 301                                 ++cp2;
 302                         else
 303                                 cp2 = disks[i];
 304                         printf("%c%s%c",
 305                             i == 0 ? '(' : ' ', cp2,
 306                             i == ccio.ccio_ndisks - 1 ? ')' : ',');
 307                 }
 308                 printf(", %ju blocks ", (uintmax_t)ccio.ccio_size);
 309                 if (ccio.ccio_ileave != 0)
 310                         printf("interleaved at %d blocks\n", ccio.ccio_ileave);
 311                 else
 312                         printf("concatenated\n");
 313         }
 314
 315         free(disks);
 316         return (0);
 317 }
 318
 319 static int
 320 do_all(int action)
 321 {
 322         FILE *f;
 323         char line[_POSIX2_LINE_MAX];
 324         char *cp, **argv;
 325         int argc, rval;
 326         gid_t egid;
 327
 328         rval = 0;
 329         egid = getegid();
 330         setegid(getgid());
 331         if ((f = fopen(ccdconf, "r")) == NULL) {
 332                 setegid(egid);
 333                 warn("fopen: %s", ccdconf);
 334                 return (1);
 335         }
 336         setegid(egid);
 337
 338         while (fgets(line, sizeof(line), f) != NULL) {
 339                 argc = 0;
 340                 argv = NULL;
 341                 ++lineno;
 342                 if ((cp = strrchr(line, '\n')) != NULL)
 343                         *cp = '\0';
 344
 345                 /* Break up the line and pass it's contents to do_single(). */
 346                 if (line[0] == '\0')
 347                         goto end_of_line;
 348                 for (cp = line; (cp = strtok(cp, " \t")) != NULL; cp = NULL) {
 349                         if (*cp == '#')
 350                                 break;
 351                         if ((argv = realloc(argv,
 352                             sizeof(char *) * ++argc)) == NULL) {
 353                                 warnx("no memory to configure ccds");
 354                                 return (1);
 355                         }
 356                         argv[argc - 1] = cp;
 357                         /*
 358                          * If our action is to unconfigure all, then pass
 359                          * just the first token to do_single() and ignore
 360                          * the rest.  Since this will be encountered on
 361                          * our first pass through the line, the Right
 362                          * Thing will happen.
 363                          */
 364                         if (action == CCD_UNCONFIGALL) {
 365                                 if (do_single(argc, argv, action))
 366                                         rval = 1;
 367                                 goto end_of_line;
 368                         }
 369                 }
 370                 if (argc != 0)
 371                         if (do_single(argc, argv, action))
 372                                 rval = 1;
 373
 374  end_of_line:
 375                 if (argv != NULL)
 376                         free(argv);
 377         }
 378
 379         fclose(f);
 380         return (rval);
 381 }
 382
 383 static int
 384 checkdev(char *path)
 385 {
 386         struct stat st;
 387
 388         if (stat(path, &st) != 0)
 389                 return (errno);
 390
 391         if (!S_ISBLK(st.st_mode) && !S_ISCHR(st.st_mode))
 392                 return (EINVAL);
 393
 394         return (0);
 395 }
 396
 397 static int
 398 pathtounit(char *path, int *unitp)
 399 {
 400         struct stat st;
 401         int maxpartitions;
 402
 403         if (stat(path, &st) != 0)
 404                 return (errno);
 405
 406         if (!S_ISBLK(st.st_mode) && !S_ISCHR(st.st_mode))
 407                 return (EINVAL);
 408
 409         if ((maxpartitions = getmaxpartitions()) < 0)
 410                 return (errno);
 411
 412         *unitp = minor(st.st_rdev) / maxpartitions;
 413
 414         return (0);
 415 }
 416
 417 static char *
 418 resolve_ccdname(char *name)
 419 {
 420         char *path;
 421
 422         if (name[0] == '/' || name[0] == '.') {
 423                 /* Assume they gave the correct pathname. */
 424                 return (strdup(name));
 425         }
 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 }