sbin/ccdconfig/ccdconfig.c

   1 /*      $NetBSD: ccdconfig.c,v 1.6 1996/05/16 07:11:18 thorpej Exp $    */
   2
   3 /*-
   4  * SPDX-License-Identifier: BSD-4-Clause
   5  *
   6  * Copyright (c) 2003 Poul-Henning Kamp
   7  * Copyright (c) 1996 The NetBSD Foundation, Inc.
   8  * All rights reserved.
   9  *
  10  * This code is derived from software contributed to The NetBSD Foundation
  11  * by Jason R. Thorpe.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  * 3. All advertising materials mentioning features or use of this software
  22  *    must display the following acknowledgement:
  23  *        This product includes software developed by the NetBSD
  24  *        Foundation, Inc. and its contributors.
  25  * 4. Neither the name of The NetBSD Foundation nor the names of its
  26  *    contributors may be used to endorse or promote products derived
  27  *    from this software without specific prior written permission.
  28  *
  29  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  30  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  31  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  32  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
  33  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  34  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  35  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  36  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  37  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  38  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  39  * POSSIBILITY OF SUCH DAMAGE.
  40  */
  41
  42 #include <sys/cdefs.h>
  43 __FBSDID("$FreeBSD$");
  44
  45 #include <sys/param.h>
  46 #include <sys/linker.h>
  47 #include <sys/module.h>
  48 #include <ctype.h>
  49 #include <err.h>
  50 #include <errno.h>
  51 #include <limits.h>
  52 #include <paths.h>
  53 #include <stdio.h>
  54 #include <stdlib.h>
  55 #include <string.h>
  56 #include <unistd.h>
  57 #include <libgeom.h>
  58
  59 #define CCDF_UNIFORM    0x02    /* use LCCD of sizes for uniform interleave */
  60 #define CCDF_MIRROR     0x04    /* use mirroring */
  61 #define CCDF_NO_OFFSET  0x08    /* do not leave space in front */
  62 #define CCDF_LINUX      0x10    /* use Linux compatibility mode */
  63
  64 #include "pathnames.h"
  65
  66 static  int lineno = 0;
  67 static  int verbose = 0;
  68 static  const char *ccdconf = _PATH_CCDCONF;
  69
  70 static struct flagval {
  71         const char      *fv_flag;
  72         int             fv_val;
  73 } flagvaltab[] = {
  74         { "CCDF_UNIFORM",       CCDF_UNIFORM },
  75         { "uniform",            CCDF_UNIFORM },
  76         { "CCDF_MIRROR",        CCDF_MIRROR },
  77         { "mirror",             CCDF_MIRROR },
  78         { "CCDF_NO_OFFSET",     CCDF_NO_OFFSET },
  79         { "no_offset",          CCDF_NO_OFFSET },
  80         { "CCDF_LINUX",         CCDF_LINUX },
  81         { "linux",              CCDF_LINUX },
  82         { "none",               0 },
  83         { NULL,                 0 },
  84 };
  85
  86 #define CCD_CONFIG              0       /* configure a device */
  87 #define CCD_CONFIGALL           1       /* configure all devices */
  88 #define CCD_UNCONFIG            2       /* unconfigure a device */
  89 #define CCD_UNCONFIGALL         3       /* unconfigure all devices */
  90 #define CCD_DUMP                4       /* dump a ccd's configuration */
  91
  92 static  int do_single(int, char **, int);
  93 static  int do_all(int);
  94 static  int dump_ccd(int, char **);
  95 static  int flags_to_val(char *);
  96 static  int resolve_ccdname(char *);
  97 static  void usage(void);
  98
  99 int
 100 main(int argc, char *argv[])
 101 {
 102         int ch, options = 0, action = CCD_CONFIG;
 103
 104         while ((ch = getopt(argc, argv, "cCf:guUv")) != -1) {
 105                 switch (ch) {
 106                 case 'c':
 107                         action = CCD_CONFIG;
 108                         ++options;
 109                         break;
 110
 111                 case 'C':
 112                         action = CCD_CONFIGALL;
 113                         ++options;
 114                         break;
 115
 116                 case 'f':
 117                         ccdconf = optarg;
 118                         break;
 119
 120                 case 'g':
 121                         action = CCD_DUMP;
 122                         break;
 123
 124                 case 'u':
 125                         action = CCD_UNCONFIG;
 126                         ++options;
 127                         break;
 128
 129                 case 'U':
 130                         action = CCD_UNCONFIGALL;
 131                         ++options;
 132                         break;
 133
 134                 case 'v':
 135                         verbose = 1;
 136                         break;
 137
 138                 default:
 139                         usage();
 140                 }
 141         }
 142         argc -= optind;
 143         argv += optind;
 144
 145         if (options > 1)
 146                 usage();
 147
 148         if (modfind("g_ccd") < 0) {
 149                 /* Not present in kernel, try loading it */
 150                 if (kldload("geom_ccd") < 0 || modfind("g_ccd") < 0)
 151                         warn("geom_ccd module not available!");
 152         }
 153
 154         switch (action) {
 155                 case CCD_CONFIG:
 156                 case CCD_UNCONFIG:
 157                         exit(do_single(argc, argv, action));
 158                         /* NOTREACHED */
 159
 160                 case CCD_CONFIGALL:
 161                 case CCD_UNCONFIGALL:
 162                         exit(do_all(action));
 163                         /* NOTREACHED */
 164
 165                 case CCD_DUMP:
 166                         exit(dump_ccd(argc, argv));
 167                         /* NOTREACHED */
 168         }
 169         /* NOTREACHED */
 170         return (0);
 171 }
 172
 173 static int
 174 do_single(int argc, char **argv, int action)
 175 {
 176         char *cp, *cp2;
 177         int ccd, noflags = 0, i, ileave, flags = 0;
 178         struct gctl_req *grq;
 179         char const *errstr;
 180         char buf1[BUFSIZ];
 181         int ex;
 182
 183         /*
 184          * If unconfiguring, all arguments are treated as ccds.
 185          */
 186         if (action == CCD_UNCONFIG || action == CCD_UNCONFIGALL) {
 187                 ex = 0;
 188                 for (; argc != 0;) {
 189                         cp = *argv++; --argc;
 190                         if ((ccd = resolve_ccdname(cp)) < 0) {
 191                                 warnx("invalid ccd name: %s", cp);
 192                                 continue;
 193                         }
 194                         grq = gctl_get_handle();
 195                         gctl_ro_param(grq, "verb", -1, "destroy geom");
 196                         gctl_ro_param(grq, "class", -1, "CCD");
 197                         sprintf(buf1, "ccd%d", ccd);
 198                         gctl_ro_param(grq, "geom", -1, buf1);
 199                         errstr = gctl_issue(grq);
 200                         if (errstr == NULL) {
 201                                 if (verbose)
 202                                         printf("%s unconfigured\n", cp);
 203                                 gctl_free(grq);
 204                                 continue;
 205                         }
 206                         warnx(
 207                             "%s\nor possibly kernel and ccdconfig out of sync",
 208                             errstr);
 209                         ex = 1;
 210                 }
 211                 return (ex);
 212         }
 213
 214         /* Make sure there are enough arguments. */
 215         if (argc < 4) {
 216                 if (argc == 3) {
 217                         /* Assume that no flags are specified. */
 218                         noflags = 1;
 219                 } else {
 220                         if (action == CCD_CONFIGALL) {
 221                                 warnx("%s: bad line: %d", ccdconf, lineno);
 222                                 return (1);
 223                         } else
 224                                 usage();
 225                 }
 226         }
 227
 228         /* First argument is the ccd to configure. */
 229         cp = *argv++; --argc;
 230         if ((ccd = resolve_ccdname(cp)) < 0) {
 231                 warnx("invalid ccd name: %s", cp);
 232                 return (1);
 233         }
 234
 235         /* Next argument is the interleave factor. */
 236         cp = *argv++; --argc;
 237         errno = 0;      /* to check for ERANGE */
 238         ileave = (int)strtol(cp, &cp2, 10);
 239         if ((errno == ERANGE) || (ileave < 0) || (*cp2 != '\0')) {
 240                 warnx("invalid interleave factor: %s", cp);
 241                 return (1);
 242         }
 243
 244         if (noflags == 0) {
 245                 /* Next argument is the ccd configuration flags. */
 246                 cp = *argv++; --argc;
 247                 if ((flags = flags_to_val(cp)) < 0) {
 248                         warnx("invalid flags argument: %s", cp);
 249                         return (1);
 250                 }
 251         }
 252         grq = gctl_get_handle();
 253         gctl_ro_param(grq, "verb", -1, "create geom");
 254         gctl_ro_param(grq, "class", -1, "CCD");
 255         gctl_ro_param(grq, "unit", sizeof(ccd), &ccd);
 256         gctl_ro_param(grq, "ileave", sizeof(ileave), &ileave);
 257         if (flags & CCDF_UNIFORM)
 258                 gctl_ro_param(grq, "uniform", -1, "");
 259         if (flags & CCDF_MIRROR)
 260                 gctl_ro_param(grq, "mirror", -1, "");
 261         if (flags & CCDF_NO_OFFSET)
 262                 gctl_ro_param(grq, "no_offset", -1, "");
 263         if (flags & CCDF_LINUX)
 264                 gctl_ro_param(grq, "linux", -1, "");
 265         gctl_ro_param(grq, "nprovider", sizeof(argc), &argc);
 266         for (i = 0; i < argc; i++) {
 267                 sprintf(buf1, "provider%d", i);
 268                 cp = argv[i];
 269                 if (!strncmp(cp, _PATH_DEV, strlen(_PATH_DEV)))
 270                         cp += strlen(_PATH_DEV);
 271                 gctl_ro_param(grq, buf1, -1, cp);
 272         }
 273         gctl_rw_param(grq, "output", sizeof(buf1), buf1);
 274         errstr = gctl_issue(grq);
 275         if (errstr == NULL) {
 276                 if (verbose) {
 277                         printf("%s", buf1);
 278                 }
 279                 gctl_free(grq);
 280                 return (0);
 281         }
 282         warnx(
 283             "%s\nor possibly kernel and ccdconfig out of sync",
 284             errstr);
 285         return (1);
 286 }
 287
 288 static int
 289 do_all(int action)
 290 {
 291         FILE *f;
 292         char line[_POSIX2_LINE_MAX];
 293         char *cp, **argv;
 294         int argc, rval;
 295         gid_t egid;
 296
 297         rval = 0;
 298         egid = getegid();
 299         if (setegid(getgid()) != 0)
 300                 err(1, "setegid failed");
 301         if ((f = fopen(ccdconf, "r")) == NULL) {
 302                 if (setegid(egid) != 0)
 303                         err(1, "setegid failed");
 304                 warn("fopen: %s", ccdconf);
 305                 return (1);
 306         }
 307         if (setegid(egid) != 0)
 308                 err(1, "setegid failed");
 309
 310         while (fgets(line, sizeof(line), f) != NULL) {
 311                 argc = 0;
 312                 argv = NULL;
 313                 ++lineno;
 314                 if ((cp = strrchr(line, '\n')) != NULL)
 315                         *cp = '\0';
 316
 317                 /* Break up the line and pass it's contents to do_single(). */
 318                 if (line[0] == '\0')
 319                         goto end_of_line;
 320                 for (cp = line; (cp = strtok(cp, " \t")) != NULL; cp = NULL) {
 321                         if (*cp == '#')
 322                                 break;
 323                         if ((argv = realloc(argv,
 324                             sizeof(char *) * ++argc)) == NULL) {
 325                                 warnx("no memory to configure ccds");
 326                                 return (1);
 327                         }
 328                         argv[argc - 1] = cp;
 329                         /*
 330                          * If our action is to unconfigure all, then pass
 331                          * just the first token to do_single() and ignore
 332                          * the rest.  Since this will be encountered on
 333                          * our first pass through the line, the Right
 334                          * Thing will happen.
 335                          */
 336                         if (action == CCD_UNCONFIGALL) {
 337                                 if (do_single(argc, argv, action))
 338                                         rval = 1;
 339                                 goto end_of_line;
 340                         }
 341                 }
 342                 if (argc != 0)
 343                         if (do_single(argc, argv, action))
 344                                 rval = 1;
 345
 346  end_of_line:
 347                 if (argv != NULL)
 348                         free(argv);
 349         }
 350
 351         (void)fclose(f);
 352         return (rval);
 353 }
 354
 355 static int
 356 resolve_ccdname(char *name)
 357 {
 358
 359         if (!strncmp(name, _PATH_DEV, strlen(_PATH_DEV)))
 360                 name += strlen(_PATH_DEV);
 361         if (strncmp(name, "ccd", 3))
 362                 return -1;
 363         name += 3;
 364         if (!isdigit(*name))
 365                 return -1;
 366         return (strtoul(name, NULL, 10));
 367 }
 368
 369 static int
 370 dumpout(int unit)
 371 {
 372         static int v;
 373         struct gctl_req *grq;
 374         int ncp;
 375         char *cp;
 376         char const *errstr;
 377
 378         grq = gctl_get_handle();
 379         ncp = 65536;
 380         cp = malloc(ncp);
 381         gctl_ro_param(grq, "verb", -1, "list");
 382         gctl_ro_param(grq, "class", -1, "CCD");
 383         gctl_ro_param(grq, "unit", sizeof(unit), &unit);
 384         gctl_rw_param(grq, "output", ncp, cp);
 385         errstr = gctl_issue(grq);
 386         if (errstr != NULL)
 387                 errx(1, "%s\nor possibly kernel and ccdconfig out of sync",
 388                         errstr);
 389         if (strlen(cp) == 0)
 390                 errx(1, "ccd%d not configured", unit);
 391         if (verbose && !v) {
 392                 printf("# ccd\t\tileave\tflags\tcomponent devices\n");
 393                 v = 1;
 394         }
 395         printf("%s", cp);
 396         free(cp);
 397         return (0);
 398 }
 399
 400 static int
 401 dump_ccd(int argc, char **argv)
 402 {
 403         int i, error;
 404
 405         if (argc == 0) {
 406                 error = dumpout(-1);
 407         } else {
 408                 error = 0;
 409                 for (i = 0; error == 0 && i < argc; i++)
 410                         error = dumpout(resolve_ccdname(argv[i]));
 411         }
 412         return (error);
 413 }
 414
 415 static int
 416 flags_to_val(char *flags)
 417 {
 418         char *cp, *tok;
 419         int i, tmp, val;
 420
 421         errno = 0;      /* to check for ERANGE */
 422         val = (int)strtol(flags, &cp, 0);
 423         if ((errno != ERANGE) && (*cp == '\0')) {
 424                 if (val & ~(CCDF_UNIFORM|CCDF_MIRROR))
 425                         return (-1);
 426                 return (val);
 427         }
 428
 429         /* Check for values represented by strings. */
 430         if ((cp = strdup(flags)) == NULL)
 431                 err(1, "no memory to parse flags");
 432         tmp = 0;
 433         for (tok = cp; (tok = strtok(tok, ",")) != NULL; tok = NULL) {
 434                 for (i = 0; flagvaltab[i].fv_flag != NULL; ++i)
 435                         if (strcmp(tok, flagvaltab[i].fv_flag) == 0)
 436                                 break;
 437                 if (flagvaltab[i].fv_flag == NULL) {
 438                         free(cp);
 439                         return (-1);
 440                 }
 441                 tmp |= flagvaltab[i].fv_val;
 442         }
 443
 444         /* If we get here, the string was ok. */
 445         free(cp);
 446         return (tmp);
 447 }
 448
 449 static void
 450 usage(void)
 451 {
 452         fprintf(stderr, "%s\n%s\n%s\n%s\n%s\n",
 453                 "usage: ccdconfig [-cv] ccd ileave [flags] dev ...",
 454                 "       ccdconfig -C [-v] [-f config_file]",
 455                 "       ccdconfig -u [-v] ccd ...",
 456                 "       ccdconfig -U [-v] [-f config_file]",
 457                 "       ccdconfig -g [ccd ...]");
 458         exit(1);
 459 }