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