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