1 /* $NetBSD: ccdconfig.c,v 1.2.2.1 1995/11/11 02:43:35 thorpej Exp $ */ 2 3 /* 4 * Copyright (c) 1995 Jason R. Thorpe. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed for the NetBSD Project 18 * by Jason R. Thorpe. 19 * 4. The name of the author may not be used to endorse or promote products 20 * derived from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 35 #include <sys/cdefs.h> 36 __FBSDID("$FreeBSD$"); 37 38 #include <sys/param.h> 39 #include <sys/linker.h> 40 #include <sys/disklabel.h> 41 #include <sys/stat.h> 42 #include <sys/module.h> 43 #include <ctype.h> 44 #include <err.h> 45 #include <errno.h> 46 #include <fcntl.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 #include <libgeom.h> 54 55 #include <sys/devicestat.h> 56 #include <sys/ccdvar.h> 57 58 #include "pathnames.h" 59 60 static int lineno = 0; 61 static int verbose = 0; 62 static const char *ccdconf = _PATH_CCDCONF; 63 64 struct flagval { 65 const char *fv_flag; 66 int fv_val; 67 } flagvaltab[] = { 68 { "CCDF_UNIFORM", CCDF_UNIFORM }, 69 { "CCDF_MIRROR", CCDF_MIRROR }, 70 { NULL, 0 }, 71 }; 72 73 #define CCD_CONFIG 0 /* configure a device */ 74 #define CCD_CONFIGALL 1 /* configure all devices */ 75 #define CCD_UNCONFIG 2 /* unconfigure a device */ 76 #define CCD_UNCONFIGALL 3 /* unconfigure all devices */ 77 #define CCD_DUMP 4 /* dump a ccd's configuration */ 78 79 static int checkdev(char *); 80 static int do_io(int, u_long, struct ccd_ioctl *); 81 static int do_single(int, char **, int); 82 static int do_all(int); 83 static int dump_ccd(int, char **); 84 static int flags_to_val(char *); 85 static int resolve_ccdname(char *); 86 static void usage(void); 87 88 int 89 main(int argc, char *argv[]) 90 { 91 int ch, options = 0, action = CCD_CONFIG; 92 93 while ((ch = getopt(argc, argv, "cCf:guUv")) != -1) { 94 switch (ch) { 95 case 'c': 96 action = CCD_CONFIG; 97 ++options; 98 break; 99 100 case 'C': 101 action = CCD_CONFIGALL; 102 ++options; 103 break; 104 105 case 'f': 106 ccdconf = optarg; 107 break; 108 109 case 'g': 110 action = CCD_DUMP; 111 break; 112 113 case 'u': 114 action = CCD_UNCONFIG; 115 ++options; 116 break; 117 118 case 'U': 119 action = CCD_UNCONFIGALL; 120 ++options; 121 break; 122 123 case 'v': 124 verbose = 1; 125 break; 126 127 default: 128 usage(); 129 } 130 } 131 argc -= optind; 132 argv += optind; 133 134 if (options > 1) 135 usage(); 136 137 if (modfind("ccd") < 0) { 138 /* Not present in kernel, try loading it */ 139 if (kldload("ccd") < 0 || modfind("ccd") < 0) 140 warn("ccd module not available!"); 141 } 142 143 switch (action) { 144 case CCD_CONFIG: 145 case CCD_UNCONFIG: 146 exit(do_single(argc, argv, action)); 147 /* NOTREACHED */ 148 149 case CCD_CONFIGALL: 150 case CCD_UNCONFIGALL: 151 exit(do_all(action)); 152 /* NOTREACHED */ 153 154 case CCD_DUMP: 155 exit(dump_ccd(argc, argv)); 156 /* NOTREACHED */ 157 } 158 /* NOTREACHED */ 159 return (0); 160 } 161 162 static int 163 do_single(int argc, char **argv, int action) 164 { 165 struct ccd_ioctl ccio; 166 char *cp, *cp2, **disks; 167 int ccd, noflags = 0, i, ileave, flags = 0, j; 168 u_int u; 169 170 bzero(&ccio, sizeof(ccio)); 171 172 /* 173 * If unconfiguring, all arguments are treated as ccds. 174 */ 175 if (action == CCD_UNCONFIG || action == CCD_UNCONFIGALL) { 176 for (i = 0; argc != 0; ) { 177 cp = *argv++; --argc; 178 if ((ccd = resolve_ccdname(cp)) < 0) { 179 warnx("invalid ccd name: %s", cp); 180 i = 1; 181 continue; 182 } 183 ccio.ccio_size = ccd; 184 if (do_io(ccd, CCDIOCCLR, &ccio)) 185 i = 1; 186 else 187 if (verbose) 188 printf("%s unconfigured\n", cp); 189 } 190 return (i); 191 } 192 193 /* Make sure there are enough arguments. */ 194 if (argc < 4) { 195 if (argc == 3) { 196 /* Assume that no flags are specified. */ 197 noflags = 1; 198 } else { 199 if (action == CCD_CONFIGALL) { 200 warnx("%s: bad line: %d", ccdconf, lineno); 201 return (1); 202 } else 203 usage(); 204 } 205 } 206 207 /* First argument is the ccd to configure. */ 208 cp = *argv++; --argc; 209 if ((ccd = resolve_ccdname(cp)) < 0) { 210 warnx("invalid ccd name: %s", cp); 211 return (1); 212 } 213 214 /* Next argument is the interleave factor. */ 215 cp = *argv++; --argc; 216 errno = 0; /* to check for ERANGE */ 217 ileave = (int)strtol(cp, &cp2, 10); 218 if ((errno == ERANGE) || (ileave < 0) || (*cp2 != '\0')) { 219 warnx("invalid interleave factor: %s", cp); 220 return (1); 221 } 222 223 if (noflags == 0) { 224 /* Next argument is the ccd configuration flags. */ 225 cp = *argv++; --argc; 226 if ((flags = flags_to_val(cp)) < 0) { 227 warnx("invalid flags argument: %s", cp); 228 return (1); 229 } 230 } 231 232 /* Next is the list of disks to make the ccd from. */ 233 disks = malloc(argc * sizeof(char *)); 234 if (disks == NULL) { 235 warnx("no memory to configure ccd"); 236 return (1); 237 } 238 for (i = 0; argc != 0; ) { 239 cp = *argv++; --argc; 240 if ((j = checkdev(cp)) == 0) 241 disks[i++] = cp; 242 else { 243 warnx("%s: %s", cp, strerror(j)); 244 return (1); 245 } 246 } 247 248 /* Fill in the ccio. */ 249 ccio.ccio_disks = disks; 250 ccio.ccio_ndisks = i; 251 ccio.ccio_ileave = ileave; 252 ccio.ccio_flags = flags; 253 ccio.ccio_size = ccd; 254 255 if (do_io(ccd, CCDIOCSET, &ccio)) { 256 free(disks); 257 return (1); 258 } 259 260 if (verbose) { 261 printf("ccd%d: %d components ", ccio.ccio_unit, 262 ccio.ccio_ndisks); 263 for (u = 0; u < ccio.ccio_ndisks; ++u) { 264 if ((cp2 = strrchr(disks[u], '/')) != NULL) 265 ++cp2; 266 else 267 cp2 = disks[u]; 268 printf("%c%s%c", 269 u == 0 ? '(' : ' ', cp2, 270 u == ccio.ccio_ndisks - 1 ? ')' : ','); 271 } 272 printf(", %lu blocks ", (u_long)ccio.ccio_size); 273 if (ccio.ccio_ileave != 0) 274 printf("interleaved at %d blocks\n", ccio.ccio_ileave); 275 else 276 printf("concatenated\n"); 277 } 278 279 free(disks); 280 return (0); 281 } 282 283 static int 284 do_all(int action) 285 { 286 FILE *f; 287 char line[_POSIX2_LINE_MAX]; 288 char *cp, **argv; 289 int argc, rval; 290 gid_t egid; 291 292 rval = 0; 293 egid = getegid(); 294 setegid(getgid()); 295 if ((f = fopen(ccdconf, "r")) == NULL) { 296 setegid(egid); 297 warn("fopen: %s", ccdconf); 298 return (1); 299 } 300 setegid(egid); 301 302 while (fgets(line, sizeof(line), f) != NULL) { 303 argc = 0; 304 argv = NULL; 305 ++lineno; 306 if ((cp = strrchr(line, '\n')) != NULL) 307 *cp = '\0'; 308 309 /* Break up the line and pass it's contents to do_single(). */ 310 if (line[0] == '\0') 311 goto end_of_line; 312 for (cp = line; (cp = strtok(cp, " \t")) != NULL; cp = NULL) { 313 if (*cp == '#') 314 break; 315 if ((argv = realloc(argv, 316 sizeof(char *) * ++argc)) == NULL) { 317 warnx("no memory to configure ccds"); 318 return (1); 319 } 320 argv[argc - 1] = cp; 321 /* 322 * If our action is to unconfigure all, then pass 323 * just the first token to do_single() and ignore 324 * the rest. Since this will be encountered on 325 * our first pass through the line, the Right 326 * Thing will happen. 327 */ 328 if (action == CCD_UNCONFIGALL) { 329 if (do_single(argc, argv, action)) 330 rval = 1; 331 goto end_of_line; 332 } 333 } 334 if (argc != 0) 335 if (do_single(argc, argv, action)) 336 rval = 1; 337 338 end_of_line: 339 if (argv != NULL) 340 free(argv); 341 } 342 343 (void)fclose(f); 344 return (rval); 345 } 346 347 static int 348 checkdev(char *path) 349 { 350 struct stat st; 351 352 if (stat(path, &st) != 0) 353 return (errno); 354 355 if (!S_ISBLK(st.st_mode) && !S_ISCHR(st.st_mode)) 356 return (EINVAL); 357 358 return (0); 359 } 360 361 static int 362 resolve_ccdname(char *name) 363 { 364 365 if (!strncmp(name, _PATH_DEV, strlen(_PATH_DEV))) 366 name += strlen(_PATH_DEV); 367 if (strncmp(name, "ccd", 3)) 368 return -1; 369 name += 3; 370 if (!isdigit(*name)) 371 return -1; 372 return (strtoul(name, NULL, 10)); 373 } 374 375 static int 376 do_io(int unit, u_long cmd, struct ccd_ioctl *cciop) 377 { 378 int fd; 379 char *cp; 380 char *path; 381 382 asprintf(&path, "%s%s", _PATH_DEV, _PATH_CCDCTL); 383 384 if ((fd = open(path, O_RDWR, 0640)) < 0) { 385 asprintf(&path, "%sccd%dc", _PATH_DEV, unit); 386 if ((fd = open(path, O_RDWR, 0640)) < 0) { 387 warn("open: %s", path); 388 return (1); 389 } 390 fprintf(stderr, 391 "***WARNING***: Kernel older than ccdconfig(8), please upgrade it.\n"); 392 fprintf(stderr, 393 "***WARNING***: Continuing in 30 seconds\n"); 394 sleep(30); 395 } 396 397 if (ioctl(fd, cmd, cciop) < 0) { 398 switch (cmd) { 399 case CCDIOCSET: 400 cp = "CCDIOCSET"; 401 break; 402 403 case CCDIOCCLR: 404 cp = "CCDIOCCLR"; 405 break; 406 407 default: 408 cp = "unknown"; 409 } 410 warn("ioctl (%s): %s", cp, path); 411 return (1); 412 } 413 414 return (0); 415 } 416 417 static int 418 dumpout(int unit) 419 { 420 static int v; 421 struct gctl_req *grq; 422 int ncp; 423 char *cp; 424 char const *errstr; 425 426 427 grq = gctl_get_handle(); 428 ncp = 65536; 429 cp = malloc(ncp); 430 gctl_ro_param(grq, "verb", -1, "list"); 431 gctl_ro_param(grq, "class", -1, "CCD"); 432 gctl_ro_param(grq, "unit", sizeof(unit), &unit); 433 gctl_rw_param(grq, "output", ncp, cp); 434 errstr = gctl_issue(grq); 435 if (errstr != NULL) 436 errx(1, "%s\nor possibly kernel and ccdconfig out of sync", 437 errstr); 438 if (strlen(cp) == 0) 439 errx(1, "ccd%d not configured", unit); 440 if (verbose && !v) { 441 printf("# ccd\t\tileave\tflags\tcomponent devices\n"); 442 v = 1; 443 } 444 printf("%s", cp); 445 free(cp); 446 return (0); 447 } 448 449 static int 450 dump_ccd(int argc, char **argv) 451 { 452 int i, err; 453 454 if (argc == 0) { 455 err = dumpout(-1); 456 } else { 457 err = 0; 458 for (i = 0; err == 0 && i < argc; i++) 459 err = dumpout(resolve_ccdname(argv[i])); 460 } 461 return (err); 462 } 463 464 static int 465 flags_to_val(char *flags) 466 { 467 char *cp, *tok; 468 int i, tmp, val = ~CCDF_USERMASK; 469 size_t flagslen; 470 471 /* 472 * The most common case is that of NIL flags, so check for 473 * those first. 474 */ 475 if (strcmp("none", flags) == 0 || strcmp("0x0", flags) == 0 || 476 strcmp("0", flags) == 0) 477 return (0); 478 479 flagslen = strlen(flags); 480 481 /* Check for values represented by strings. */ 482 if ((cp = strdup(flags)) == NULL) 483 err(1, "no memory to parse flags"); 484 tmp = 0; 485 for (tok = cp; (tok = strtok(tok, ",")) != NULL; tok = NULL) { 486 for (i = 0; flagvaltab[i].fv_flag != NULL; ++i) 487 if (strcmp(tok, flagvaltab[i].fv_flag) == 0) 488 break; 489 if (flagvaltab[i].fv_flag == NULL) { 490 free(cp); 491 goto bad_string; 492 } 493 tmp |= flagvaltab[i].fv_val; 494 } 495 496 /* If we get here, the string was ok. */ 497 free(cp); 498 val = tmp; 499 goto out; 500 501 bad_string: 502 503 /* Check for values represented in hex. */ 504 if (flagslen > 2 && flags[0] == '0' && flags[1] == 'x') { 505 errno = 0; /* to check for ERANGE */ 506 val = (int)strtol(&flags[2], &cp, 16); 507 if ((errno == ERANGE) || (*cp != '\0')) 508 return (-1); 509 goto out; 510 } 511 512 /* Check for values represented in decimal. */ 513 errno = 0; /* to check for ERANGE */ 514 val = (int)strtol(flags, &cp, 10); 515 if ((errno == ERANGE) || (*cp != '\0')) 516 return (-1); 517 518 out: 519 return (((val & ~CCDF_USERMASK) == 0) ? val : -1); 520 } 521 522 static void 523 usage(void) 524 { 525 fprintf(stderr, "%s\n%s\n%s\n%s\n%s\n", 526 "usage: ccdconfig [-cv] ccd ileave [flags] dev [...]", 527 " ccdconfig -C [-v] [-f config_file]", 528 " ccdconfig -u [-v] ccd [...]", 529 " ccdconfig -U [-v] [-f config_file]", 530 " ccdconfig -g [ccd [...]]"); 531 exit(1); 532 } 533 534 /* Local Variables: */ 535 /* c-argdecl-indent: 8 */ 536 /* c-indent-level: 8 */ 537 /* End: */ 538