sbin/ccdconfig/ccdconfig.c

   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  * $FreeBSD: src/sbin/ccdconfig/ccdconfig.c,v 1.16.2.2 2000/12/11 01:03:25 obrien Exp $
  35  * $DragonFly: src/sbin/ccdconfig/ccdconfig.c,v 1.5 2004/12/18 21:43:38 swildner Exp $
  36  */
  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 <kvm.h>
  48 #include <limits.h>
  49 #include <paths.h>
  50 #include <stdio.h>
  51 #include <stdlib.h>
  52 #include <string.h>
  53 #include <unistd.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  char *ccdconf = _PATH_CCDCONF;
  63
  64 static  char *core = NULL;
  65 static  char *kernel = NULL;
  66
  67 struct  flagval {
  68         char    *fv_flag;
  69         int     fv_val;
  70 } flagvaltab[] = {
  71         { "CCDF_SWAP",          CCDF_SWAP },
  72         { "CCDF_UNIFORM",       CCDF_UNIFORM },
  73         { "CCDF_MIRROR",        CCDF_MIRROR },
  74         { "CCDF_PARITY",        CCDF_PARITY },
  75         { NULL,                 0 },
  76 };
  77
  78 static  struct nlist nl[] = {
  79         { "_ccd_softc" },
  80 #define SYM_CCDSOFTC            0
  81         { "_numccd" },
  82 #define SYM_NUMCCD              1
  83         { NULL },
  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 checkdev(char *);
  93 static  int do_io(char *, u_long, struct ccd_ioctl *);
  94 static  int do_single(int, char **, int);
  95 static  int do_all(int);
  96 static  int dump_ccd(int, char **);
  97 static  int getmaxpartitions(void);
  98 static  int getrawpartition(void);
  99 static  int flags_to_val(char *);
 100 static  void print_ccd_info(struct ccd_softc *, kvm_t *);
 101 static  char *resolve_ccdname(char *);
 102 static  void usage(void);
 103
 104 int
 105 main(int argc, char **argv)
 106 {
 107         int ch, options = 0, action = CCD_CONFIG;
 108
 109         while ((ch = getopt(argc, argv, "cCf:gM:N:uUv")) != -1) {
 110                 switch (ch) {
 111                 case 'c':
 112                         action = CCD_CONFIG;
 113                         ++options;
 114                         break;
 115
 116                 case 'C':
 117                         action = CCD_CONFIGALL;
 118                         ++options;
 119                         break;
 120
 121                 case 'f':
 122                         ccdconf = optarg;
 123                         break;
 124
 125                 case 'g':
 126                         action = CCD_DUMP;
 127                         break;
 128
 129                 case 'M':
 130                         core = optarg;
 131                         break;
 132
 133                 case 'N':
 134                         kernel = optarg;
 135                         break;
 136
 137                 case 'u':
 138                         action = CCD_UNCONFIG;
 139                         ++options;
 140                         break;
 141
 142                 case 'U':
 143                         action = CCD_UNCONFIGALL;
 144                         ++options;
 145                         break;
 146
 147                 case 'v':
 148                         verbose = 1;
 149                         break;
 150
 151                 default:
 152                         usage();
 153                 }
 154         }
 155         argc -= optind;
 156         argv += optind;
 157
 158         if (options > 1)
 159                 usage();
 160
 161         /*
 162          * Discard setgid privileges if not the running kernel so that bad
 163          * guys can't print interesting stuff from kernel memory.
 164          */
 165         if (core != NULL || kernel != NULL || action != CCD_DUMP) {
 166                 setegid(getgid());
 167                 setgid(getgid());
 168         }
 169
 170         if (modfind("ccd") < 0) {
 171                 /* Not present in kernel, try loading it */
 172                 if (kldload("ccd") < 0 || modfind("ccd") < 0)
 173                         warn("ccd module not available!");
 174         }
 175
 176         switch (action) {
 177                 case CCD_CONFIG:
 178                 case CCD_UNCONFIG:
 179                         exit(do_single(argc, argv, action));
 180                         /* NOTREACHED */
 181
 182                 case CCD_CONFIGALL:
 183                 case CCD_UNCONFIGALL:
 184                         exit(do_all(action));
 185                         /* NOTREACHED */
 186
 187                 case CCD_DUMP:
 188                         exit(dump_ccd(argc, argv));
 189                         /* NOTREACHED */
 190         }
 191         /* NOTREACHED */
 192         return (0);
 193 }
 194
 195 static int
 196 do_single(int argc, char **argv, int action)
 197 {
 198         struct ccd_ioctl ccio;
 199         char *ccd, *cp, *cp2, **disks;
 200         int noflags = 0, i, ileave, flags = 0, j;
 201
 202         bzero(&ccio, sizeof(ccio));
 203
 204         /*
 205          * If unconfiguring, all arguments are treated as ccds.
 206          */
 207         if (action == CCD_UNCONFIG || action == CCD_UNCONFIGALL) {
 208                 for (i = 0; argc != 0; ) {
 209                         cp = *argv++; --argc;
 210                         if ((ccd = resolve_ccdname(cp)) == NULL) {
 211                                 warnx("invalid ccd name: %s", cp);
 212                                 i = 1;
 213                                 continue;
 214                         }
 215                         if (do_io(ccd, CCDIOCCLR, &ccio))
 216                                 i = 1;
 217                         else
 218                                 if (verbose)
 219                                         printf("%s unconfigured\n", cp);
 220                 }
 221                 return (i);
 222         }
 223
 224         /* Make sure there are enough arguments. */
 225         if (argc < 4) {
 226                 if (argc == 3) {
 227                         /* Assume that no flags are specified. */
 228                         noflags = 1;
 229                 } else {
 230                         if (action == CCD_CONFIGALL) {
 231                                 warnx("%s: bad line: %d", ccdconf, lineno);
 232                                 return (1);
 233                         } else
 234                                 usage();
 235                 }
 236         }
 237
 238         /* First argument is the ccd to configure. */
 239         cp = *argv++; --argc;
 240         if ((ccd = resolve_ccdname(cp)) == NULL) {
 241                 warnx("invalid ccd name: %s", cp);
 242                 return (1);
 243         }
 244
 245         /* Next argument is the interleave factor. */
 246         cp = *argv++; --argc;
 247         errno = 0;      /* to check for ERANGE */
 248         ileave = (int)strtol(cp, &cp2, 10);
 249         if ((errno == ERANGE) || (ileave < 0) || (*cp2 != '\0')) {
 250                 warnx("invalid interleave factor: %s", cp);
 251                 return (1);
 252         }
 253
 254         if (noflags == 0) {
 255                 /* Next argument is the ccd configuration flags. */
 256                 cp = *argv++; --argc;
 257                 if ((flags = flags_to_val(cp)) < 0) {
 258                         warnx("invalid flags argument: %s", cp);
 259                         return (1);
 260                 }
 261         }
 262
 263         /* Next is the list of disks to make the ccd from. */
 264         disks = malloc(argc * sizeof(char *));
 265         if (disks == NULL) {
 266                 warnx("no memory to configure ccd");
 267                 return (1);
 268         }
 269         for (i = 0; argc != 0; ) {
 270                 cp = *argv++; --argc;
 271                 if ((j = checkdev(cp)) == 0)
 272                         disks[i++] = cp;
 273                 else {
 274                         warnx("%s: %s", cp, strerror(j));
 275                         return (1);
 276                 }
 277         }
 278
 279         /* Fill in the ccio. */
 280         ccio.ccio_disks = disks;
 281         ccio.ccio_ndisks = i;
 282         ccio.ccio_ileave = ileave;
 283         ccio.ccio_flags = flags;
 284
 285         if (do_io(ccd, CCDIOCSET, &ccio)) {
 286                 free(disks);
 287                 return (1);
 288         }
 289
 290         if (verbose) {
 291                 printf("ccd%d: %d components ", ccio.ccio_unit,
 292                     ccio.ccio_ndisks);
 293                 for (i = 0; i < ccio.ccio_ndisks; ++i) {
 294                         if ((cp2 = strrchr(disks[i], '/')) != NULL)
 295                                 ++cp2;
 296                         else
 297                                 cp2 = disks[i];
 298                         printf("%c%s%c",
 299                             i == 0 ? '(' : ' ', cp2,
 300                             i == ccio.ccio_ndisks - 1 ? ')' : ',');
 301                 }
 302                 printf(", %lu blocks ", (u_long)ccio.ccio_size);
 303                 if (ccio.ccio_ileave != 0)
 304                         printf("interleaved at %d blocks\n", ccio.ccio_ileave);
 305                 else
 306                         printf("concatenated\n");
 307         }
 308
 309         free(disks);
 310         return (0);
 311 }
 312
 313 static int
 314 do_all(int action)
 315 {
 316         FILE *f;
 317         char line[_POSIX2_LINE_MAX];
 318         char *cp, **argv;
 319         int argc, rval;
 320         gid_t egid;
 321
 322         rval = 0;
 323         egid = getegid();
 324         setegid(getgid());
 325         if ((f = fopen(ccdconf, "r")) == NULL) {
 326                 setegid(egid);
 327                 warn("fopen: %s", ccdconf);
 328                 return (1);
 329         }
 330         setegid(egid);
 331
 332         while (fgets(line, sizeof(line), f) != NULL) {
 333                 argc = 0;
 334                 argv = NULL;
 335                 ++lineno;
 336                 if ((cp = strrchr(line, '\n')) != NULL)
 337                         *cp = '\0';
 338
 339                 /* Break up the line and pass it's contents to do_single(). */
 340                 if (line[0] == '\0')
 341                         goto end_of_line;
 342                 for (cp = line; (cp = strtok(cp, " \t")) != NULL; cp = NULL) {
 343                         if (*cp == '#')
 344                                 break;
 345                         if ((argv = realloc(argv,
 346                             sizeof(char *) * ++argc)) == NULL) {
 347                                 warnx("no memory to configure ccds");
 348                                 return (1);
 349                         }
 350                         argv[argc - 1] = cp;
 351                         /*
 352                          * If our action is to unconfigure all, then pass
 353                          * just the first token to do_single() and ignore
 354                          * the rest.  Since this will be encountered on
 355                          * our first pass through the line, the Right
 356                          * Thing will happen.
 357                          */
 358                         if (action == CCD_UNCONFIGALL) {
 359                                 if (do_single(argc, argv, action))
 360                                         rval = 1;
 361                                 goto end_of_line;
 362                         }
 363                 }
 364                 if (argc != 0)
 365                         if (do_single(argc, argv, action))
 366                                 rval = 1;
 367
 368  end_of_line:
 369                 if (argv != NULL)
 370                         free(argv);
 371         }
 372
 373         fclose(f);
 374         return (rval);
 375 }
 376
 377 static int
 378 checkdev(char *path)
 379 {
 380         struct stat st;
 381
 382         if (stat(path, &st) != 0)
 383                 return (errno);
 384
 385         if (!S_ISBLK(st.st_mode) && !S_ISCHR(st.st_mode))
 386                 return (EINVAL);
 387
 388         return (0);
 389 }
 390
 391 static int
 392 pathtounit(char *path, int *unitp)
 393 {
 394         struct stat st;
 395         int maxpartitions;
 396
 397         if (stat(path, &st) != 0)
 398                 return (errno);
 399
 400         if (!S_ISBLK(st.st_mode) && !S_ISCHR(st.st_mode))
 401                 return (EINVAL);
 402
 403         if ((maxpartitions = getmaxpartitions()) < 0)
 404                 return (errno);
 405
 406         *unitp = minor(st.st_rdev) / maxpartitions;
 407
 408         return (0);
 409 }
 410
 411 static char *
 412 resolve_ccdname(char *name)
 413 {
 414         char c, *path;
 415         size_t len, newlen;
 416         int rawpart;
 417
 418         if (name[0] == '/' || name[0] == '.') {
 419                 /* Assume they gave the correct pathname. */
 420                 return (strdup(name));
 421         }
 422
 423         len = strlen(name);
 424         c = name[len - 1];
 425
 426         newlen = len + 8;
 427         if ((path = malloc(newlen)) == NULL)
 428                 return (NULL);
 429         bzero(path, newlen);
 430
 431         if (isdigit(c)) {
 432                 if ((rawpart = getrawpartition()) < 0) {
 433                         free(path);
 434                         return (NULL);
 435                 }
 436                 sprintf(path, "%s%s%c", _PATH_DEV, name, 'a' + rawpart);
 437         } else
 438                 sprintf(path, "%s%s", _PATH_DEV, name);
 439
 440         return (path);
 441 }
 442
 443 static int
 444 do_io(char *path, u_long cmd, struct ccd_ioctl *cciop)
 445 {
 446         int fd;
 447         char *cp;
 448
 449         if ((fd = open(path, O_RDWR, 0640)) < 0) {
 450                 warn("open: %s", path);
 451                 return (1);
 452         }
 453
 454         if (ioctl(fd, cmd, cciop) < 0) {
 455                 switch (cmd) {
 456                 case CCDIOCSET:
 457                         cp = "CCDIOCSET";
 458                         break;
 459
 460                 case CCDIOCCLR:
 461                         cp = "CCDIOCCLR";
 462                         break;
 463
 464                 default:
 465                         cp = "unknown";
 466                 }
 467                 warn("ioctl (%s): %s", cp, path);
 468                 return (1);
 469         }
 470
 471         return (0);
 472 }
 473
 474 #define KVM_ABORT(kd, str) {                                            \
 475         kvm_close((kd));                                                \
 476         warnx("%s", (str));                                                     \
 477         warnx("%s", kvm_geterr((kd)));                                  \
 478         return (1);                                                     \
 479 }
 480
 481 static int
 482 dump_ccd(int argc, char **argv)
 483 {
 484         char errbuf[_POSIX2_LINE_MAX], *ccd, *cp;
 485         struct ccd_softc *cs, *kcs;
 486         size_t readsize;
 487         int i, error, numccd, numconfiged = 0;
 488         kvm_t *kd;
 489
 490         bzero(errbuf, sizeof(errbuf));
 491
 492         if ((kd = kvm_openfiles(kernel, core, NULL, O_RDONLY,
 493             errbuf)) == NULL) {
 494                 warnx("can't open kvm: %s", errbuf);
 495                 return (1);
 496         }
 497
 498         if (kvm_nlist(kd, nl))
 499                 KVM_ABORT(kd, "ccd-related symbols not available");
 500
 501         /* Check to see how many ccds are currently configured. */
 502         if (kvm_read(kd, nl[SYM_NUMCCD].n_value, (char *)&numccd,
 503             sizeof(numccd)) != sizeof(numccd))
 504                 KVM_ABORT(kd, "can't determine number of configured ccds");
 505
 506         if (numccd == 0) {
 507                 printf("ccd driver in kernel, but is uninitialized\n");
 508                 goto done;
 509         }
 510
 511         /* Allocate space for the configuration data. */
 512         readsize = numccd * sizeof(struct ccd_softc);
 513         if ((cs = malloc(readsize)) == NULL) {
 514                 warnx("no memory for configuration data");
 515                 goto bad;
 516         }
 517         bzero(cs, readsize);
 518
 519         /*
 520          * Read the ccd configuration data from the kernel and dump
 521          * it to stdout.
 522          */
 523         if (kvm_read(kd, nl[SYM_CCDSOFTC].n_value, (char *)&kcs,
 524             sizeof(kcs)) != sizeof(kcs)) {
 525                 free(cs);
 526                 KVM_ABORT(kd, "can't find pointer to configuration data");
 527         }
 528         if (kvm_read(kd, (u_long)kcs, (char *)cs, readsize) != readsize) {
 529                 free(cs);
 530                 KVM_ABORT(kd, "can't read configuration data");
 531         }
 532
 533         if (argc == 0) {
 534                 for (i = 0; i < numccd; ++i)
 535                         if (cs[i].sc_flags & CCDF_INITED) {
 536                                 ++numconfiged;
 537                                 print_ccd_info(&cs[i], kd);
 538                         }
 539
 540                 if (numconfiged == 0)
 541                         printf("no concatenated disks configured\n");
 542         } else {
 543                 while (argc) {
 544                         cp = *argv++; --argc;
 545                         if ((ccd = resolve_ccdname(cp)) == NULL) {
 546                                 warnx("invalid ccd name: %s", cp);
 547                                 continue;
 548                         }
 549                         if ((error = pathtounit(ccd, &i)) != 0) {
 550                                 warnx("%s: %s", ccd, strerror(error));
 551                                 continue;
 552                         }
 553                         if (i >= numccd) {
 554                                 warnx("ccd%d not configured", i);
 555                                 continue;
 556                         }
 557                         if (cs[i].sc_flags & CCDF_INITED)
 558                                 print_ccd_info(&cs[i], kd);
 559                         else
 560                                 printf("ccd%d not configured\n", i);
 561                 }
 562         }
 563
 564         free(cs);
 565
 566  done:
 567         kvm_close(kd);
 568         return (0);
 569
 570  bad:
 571         kvm_close(kd);
 572         return (1);
 573 }
 574
 575 static void
 576 print_ccd_info(struct ccd_softc *cs, kvm_t *kd)
 577 {
 578         static int header_printed = 0;
 579         struct ccdcinfo *cip;
 580         size_t readsize;
 581         char path[MAXPATHLEN];
 582         int i;
 583
 584         if (header_printed == 0 && verbose) {
 585                 printf("# ccd\t\tileave\tflags\tcompnent devices\n");
 586                 header_printed = 1;
 587         }
 588
 589         readsize = cs->sc_nccdisks * sizeof(struct ccdcinfo);
 590         if ((cip = malloc(readsize)) == NULL) {
 591                 warn("ccd%d: can't allocate memory for component info",
 592                     cs->sc_unit);
 593                 return;
 594         }
 595         bzero(cip, readsize);
 596
 597         /* Dump out softc information. */
 598         printf("ccd%d\t\t%d\t%d\t", cs->sc_unit, cs->sc_ileave,
 599             cs->sc_cflags & CCDF_USERMASK);
 600         fflush(stdout);
 601
 602         /* Read in the component info. */
 603         if (kvm_read(kd, (u_long)cs->sc_cinfo, (char *)cip,
 604             readsize) != readsize) {
 605                 printf("\n");
 606                 warnx("can't read component info");
 607                 warnx("%s", kvm_geterr(kd));
 608                 goto done;
 609         }
 610
 611         /* Read component pathname and display component info. */
 612         for (i = 0; i < cs->sc_nccdisks; ++i) {
 613                 if (kvm_read(kd, (u_long)cip[i].ci_path, (char *)path,
 614                     cip[i].ci_pathlen) != cip[i].ci_pathlen) {
 615                         printf("\n");
 616                         warnx("can't read component pathname");
 617                         warnx("%s", kvm_geterr(kd));
 618                         goto done;
 619                 }
 620                 printf((i + 1 < cs->sc_nccdisks) ? "%s " : "%s\n", path);
 621                 fflush(stdout);
 622         }
 623
 624  done:
 625         free(cip);
 626 }
 627
 628 static int
 629 getmaxpartitions(void)
 630 {
 631     return (MAXPARTITIONS);
 632 }
 633
 634 static int
 635 getrawpartition(void)
 636 {
 637         return (RAW_PART);
 638 }
 639
 640 static int
 641 flags_to_val(char *flags)
 642 {
 643         char *cp, *tok;
 644         int i, tmp, val = ~CCDF_USERMASK;
 645         size_t flagslen;
 646
 647         /*
 648          * The most common case is that of NIL flags, so check for
 649          * those first.
 650          */
 651         if (strcmp("none", flags) == 0 || strcmp("0x0", flags) == 0 ||
 652             strcmp("0", flags) == 0)
 653                 return (0);
 654
 655         flagslen = strlen(flags);
 656
 657         /* Check for values represented by strings. */
 658         if ((cp = strdup(flags)) == NULL)
 659                 err(1, "no memory to parse flags");
 660         tmp = 0;
 661         for (tok = cp; (tok = strtok(tok, ",")) != NULL; tok = NULL) {
 662                 for (i = 0; flagvaltab[i].fv_flag != NULL; ++i)
 663                         if (strcmp(tok, flagvaltab[i].fv_flag) == 0)
 664                                 break;
 665                 if (flagvaltab[i].fv_flag == NULL) {
 666                         free(cp);
 667                         goto bad_string;
 668                 }
 669                 tmp |= flagvaltab[i].fv_val;
 670         }
 671
 672         /* If we get here, the string was ok. */
 673         free(cp);
 674         val = tmp;
 675         goto out;
 676
 677  bad_string:
 678
 679         /* Check for values represented in hex. */
 680         if (flagslen > 2 && flags[0] == '0' && flags[1] == 'x') {
 681                 errno = 0;      /* to check for ERANGE */
 682                 val = (int)strtol(&flags[2], &cp, 16);
 683                 if ((errno == ERANGE) || (*cp != '\0'))
 684                         return (-1);
 685                 goto out;
 686         }
 687
 688         /* Check for values represented in decimal. */
 689         errno = 0;      /* to check for ERANGE */
 690         val = (int)strtol(flags, &cp, 10);
 691         if ((errno == ERANGE) || (*cp != '\0'))
 692                 return (-1);
 693
 694  out:
 695         return (((val & ~CCDF_USERMASK) == 0) ? val : -1);
 696 }
 697
 698 static void
 699 usage(void)
 700 {
 701         fprintf(stderr, "%s\n%s\n%s\n%s\n%s\n",
 702                 "usage: ccdconfig [-cv] ccd ileave [flags] dev [...]",
 703                 "       ccdconfig -C [-v] [-f config_file]",
 704                 "       ccdconfig -u [-v] ccd [...]",
 705                 "       ccdconfig -U [-v] [-f config_file]",
 706                 "       ccdconfig -g [-M core] [-N system] [ccd [...]]");
 707         exit(1);
 708 }
 709
 710 /* Local Variables: */
 711 /* c-argdecl-indent: 8 */
 712 /* c-indent-level: 8 */
 713 /* End: */