sbin/vinum/v.c

   1 /* vinum.c: vinum interface program */
   2 /*-
   3  * Copyright (c) 1997, 1998
   4  *      Nan Yang Computer Services Limited.  All rights reserved.
   5  *
   6  *  Written by Greg Lehey
   7  *
   8  *  This software is distributed under the so-called ``Berkeley
   9  *  License'':
  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  * 3. All advertising materials mentioning features or use of this software
  20  *    must display the following acknowledgement:
  21  *      This product includes software developed by Nan Yang Computer
  22  *      Services Limited.
  23  * 4. Neither the name of the Company nor the names of its contributors
  24  *    may be used to endorse or promote products derived from this software
  25  *    without specific prior written permission.
  26  *
  27  * This software is provided ``as is'', and any express or implied
  28  * warranties, including, but not limited to, the implied warranties of
  29  * merchantability and fitness for a particular purpose are disclaimed.
  30  * In no event shall the company or contributors be liable for any
  31  * direct, indirect, incidental, special, exemplary, or consequential
  32  * damages (including, but not limited to, procurement of substitute
  33  * goods or services; loss of use, data, or profits; or business
  34  * interruption) however caused and on any theory of liability, whether
  35  * in contract, strict liability, or tort (including negligence or
  36  * otherwise) arising in any way out of the use of this software, even if
  37  * advised of the possibility of such damage.
  38  *
  39  * $Id: v.c,v 1.31 2000/09/03 01:29:26 grog Exp grog $
  40  * $FreeBSD: src/sbin/vinum/v.c,v 1.26.2.3 2001/03/13 03:04:06 grog Exp $
  41  * $DragonFly: src/sbin/vinum/v.c,v 1.2 2003/06/17 04:27:35 dillon Exp $
  42  */
  43
  44 #include <ctype.h>
  45 #include <errno.h>
  46 #include <fcntl.h>
  47 #include <sys/mman.h>
  48 #include <netdb.h>
  49 #include <setjmp.h>
  50 #include <signal.h>
  51 #include <stdio.h>
  52 #include <stdlib.h>
  53 #include <string.h>
  54 #include <syslog.h>
  55 #include <unistd.h>
  56 #include <sys/ioctl.h>
  57 #include <dev/vinum/vinumhdr.h>
  58 #include "vext.h"
  59 #include <sys/types.h>
  60 #include <sys/wait.h>
  61 #include <readline/history.h>
  62 #include <readline/readline.h>
  63 #include <sys/linker.h>
  64 #include <sys/module.h>
  65 #include <sys/resource.h>
  66
  67 FILE *cf;                                                   /* config file handle */
  68 FILE *history;                                              /* history file */
  69 char *historyfile;                                          /* and its name */
  70
  71 char *dateformat;                                           /* format in which to store date */
  72
  73 char buffer[BUFSIZE];                                       /* buffer to read in to */
  74
  75 int line = 0;                                               /* stdin line number for error messages */
  76 int file_line = 0;                                          /* and line in input file (yes, this is tacky) */
  77 int inerror;                                                /* set to 1 to exit after end of config file */
  78
  79 /* flags */
  80
  81 #if VINUMDEBUG
  82 int debug = 0;                                              /* debug flag, usage varies */
  83 #endif
  84 int force = 0;                                              /* set to 1 to force some dangerous ops */
  85 int interval = 0;                                           /* interval in ms between init/revive */
  86 int vflag = 0;                                              /* set verbose operation or verify */
  87 int Verbose = 0;                                            /* set very verbose operation */
  88 int recurse = 0;                                            /* set recursion */
  89 int sflag = 0;                                              /* show statistics */
  90 int SSize = 0;                                              /* sector size for revive */
  91 int dowait = 0;                                             /* wait for completion */
  92 char *objectname;                                           /* name to be passed for -n flag */
  93
  94 /* Structures to read kernel data into */
  95 struct _vinum_conf vinum_conf;                              /* configuration information */
  96
  97 struct volume vol;
  98 struct plex plex;
  99 struct sd sd;
 100 struct drive drive;
 101
 102 jmp_buf command_fail;                                       /* return on a failed command */
 103 int superdev;                                               /* vinum super device */
 104
 105 void start_daemon(void);
 106
 107 #define ofs(x) ((void *) (& ((struct confdata *) 0)->x))    /* offset of x in struct confdata */
 108
 109 char *token[MAXARGS];                                       /* pointers to individual tokens */
 110 int tokens;                                                 /* number of tokens */
 111
 112 int
 113 main(int argc, char *argv[], char *envp[])
 114 {
 115     struct stat histstat;
 116
 117     if (modfind(VINUMMOD) < 0) {
 118         /* need to load the vinum module */
 119         if (kldload(VINUMMOD) < 0 || modfind(VINUMMOD) < 0) {
 120             perror(VINUMMOD ": Kernel module not available");
 121             return 1;
 122         }
 123     }
 124     dateformat = getenv("VINUM_DATEFORMAT");
 125     if (dateformat == NULL)
 126         dateformat = "%e %b %Y %H:%M:%S";
 127     historyfile = getenv("VINUM_HISTORY");
 128     if (historyfile == NULL)
 129         historyfile = DEFAULT_HISTORYFILE;
 130     if (stat(historyfile, &histstat) == 0) {                /* history file exists */
 131         if ((histstat.st_mode & S_IFMT) != S_IFREG) {
 132             fprintf(stderr,
 133                 "Vinum history file %s must be a regular file\n",
 134                 historyfile);
 135             exit(1);
 136         }
 137     } else if ((errno != ENOENT)                            /* not "not there",  */
 138     &&(errno != EROFS)) {                                   /* and not read-only file system */
 139         fprintf(stderr,
 140             "Can't open %s: %s (%d)\n",
 141             historyfile,
 142             strerror(errno),
 143             errno);
 144         exit(1);
 145     }
 146     history = fopen(historyfile, "a+");
 147     if (history != NULL) {
 148         timestamp();
 149         fprintf(history, "*** " VINUMMOD " started ***\n");
 150         fflush(history);                                    /* before we start the daemon */
 151     }
 152     superdev = open(VINUM_SUPERDEV_NAME, O_RDWR);           /* open vinum superdevice */
 153     if (superdev < 0) {                                     /* no go */
 154         if (errno == ENODEV) {                              /* not configured, */
 155             superdev = open(VINUM_WRONGSUPERDEV_NAME, O_RDWR); /* do we have a debug mismatch? */
 156             if (superdev >= 0) {                            /* yup! */
 157 #if VINUMDEBUG
 158                 fprintf(stderr,
 159                     "This program is compiled with debug support, but the kernel module does\n"
 160                     "not have debug support.  This program must be matched with the kernel\n"
 161                     "module.  Please alter /usr/src/sbin/" VINUMMOD "/Makefile and remove\n"
 162                     "the option -DVINUMDEBUG from the CFLAGS definition, or alternatively\n"
 163                     "edit /usr/src/sys/modules/" VINUMMOD "/Makefile and add the option\n"
 164                     "-DVINUMDEBUG to the CFLAGS definition.  Then rebuild the component\n"
 165                     "of your choice with 'make clean all install'.  If you rebuild the kernel\n"
 166                     "module, you must stop " VINUMMOD " and restart it\n");
 167 #else
 168                 fprintf(stderr,
 169                     "This program is compiled without debug support, but the kernel module\n"
 170                     "includes debug support.  This program must be matched with the kernel\n"
 171                     "module.  Please alter /usr/src/sbin/" VINUMMOD "/Makefile and add\n"
 172                     "the option -DVINUMDEBUG to the CFLAGS definition, or alternatively\n"
 173                     "edit /usr/src/sys/modules/" VINUMMOD "/Makefile and remove the option\n"
 174                     "-DVINUMDEBUG from the CFLAGS definition.  Then rebuild the component\n"
 175                     "of your choice with 'make clean all install'.  If you rebuild the kernel\n"
 176                     "module, you must stop " VINUMMOD " and restart it\n");
 177 #endif
 178                 return 1;
 179             }
 180         } else if (errno == ENOENT)                         /* we don't have our node, */
 181             make_devices();                                 /* create them first */
 182         if (superdev < 0) {
 183             perror("Can't open " VINUM_SUPERDEV_NAME);
 184             return 1;
 185         }
 186     }
 187     /* Check if the dæmon is running.  If not, start it in the
 188      * background */
 189     start_daemon();
 190
 191     if (argc > 1) {                                         /* we have a command on the line */
 192         if (setjmp(command_fail) != 0)                      /* long jumped out */
 193             return -1;
 194         parseline(argc - 1, &argv[1]);                      /* do it */
 195     } else {
 196         /*
 197          * Catch a possible race condition which could cause us to
 198          * longjmp() into nowhere if we receive a SIGINT in the next few
 199          * lines.
 200          */
 201         if (setjmp(command_fail))                           /* come back here on catastrophic failure */
 202             return 1;
 203         setsigs();                                          /* set signal handler */
 204         for (;;) {                                          /* ugh */
 205             char *c;
 206             int childstatus;                                /* from wait4 */
 207
 208             if (setjmp(command_fail) == 2)                  /* come back here on catastrophic failure */
 209                 fprintf(stderr, "*** interrupted ***\n");   /* interrupted */
 210
 211             while (wait4(-1, &childstatus, WNOHANG, NULL) > 0); /* wait for all dead children */
 212             c = readline(VINUMMOD " -> ");                  /* get an input */
 213             if (c == NULL) {                                /* EOF or error */
 214                 if (ferror(stdin)) {
 215                     fprintf(stderr, "Can't read input: %s (%d)\n", strerror(errno), errno);
 216                     return 1;
 217                 } else {                                    /* EOF */
 218                     printf("\n");
 219                     return 0;
 220                 }
 221             } else if (*c) {                                /* got something there */
 222                 add_history(c);                             /* save it in the history */
 223                 strcpy(buffer, c);                          /* put it where we can munge it */
 224                 free(c);
 225                 line++;                                     /* count the lines */
 226                 tokens = tokenize(buffer, token);
 227                 /* got something potentially worth parsing */
 228                 if (tokens)
 229                     parseline(tokens, token);               /* and do what he says */
 230             }
 231             if (history)
 232                 fflush(history);
 233         }
 234     }
 235     return 0;                                               /* normal completion */
 236 }
 237
 238 /* stop the hard way */
 239 void
 240 vinum_quit(int argc, char *argv[], char *argv0[])
 241 {
 242     exit(0);
 243 }
 244
 245 /* Set action on receiving a SIGINT */
 246 void
 247 setsigs()
 248 {
 249     struct sigaction act;
 250
 251     act.sa_handler = catchsig;
 252     act.sa_flags = 0;
 253     sigemptyset(&act.sa_mask);
 254     sigaction(SIGINT, &act, NULL);
 255 }
 256
 257 void
 258 catchsig(int ignore)
 259 {
 260     longjmp(command_fail, 2);
 261 }
 262
 263 #define FUNKEY(x) { kw_##x, &vinum_##x }                    /* create pair "kw_foo", vinum_foo */
 264 #define vinum_move vinum_mv                                 /* synonym for 'mv' */
 265
 266 struct funkey {
 267     enum keyword kw;
 268     void (*fun) (int argc, char *argv[], char *arg0[]);
 269 } funkeys[] = {
 270
 271     FUNKEY(create),
 272         FUNKEY(read),
 273 #ifdef VINUMDEBUG
 274         FUNKEY(debug),
 275 #endif
 276         FUNKEY(modify),
 277         FUNKEY(list),
 278         FUNKEY(ld),
 279         FUNKEY(ls),
 280         FUNKEY(lp),
 281         FUNKEY(lv),
 282         FUNKEY(info),
 283         FUNKEY(set),
 284         FUNKEY(init),
 285         FUNKEY(label),
 286         FUNKEY(resetconfig),
 287         FUNKEY(rm),
 288         FUNKEY(mv),
 289         FUNKEY(move),
 290         FUNKEY(attach),
 291         FUNKEY(detach),
 292         FUNKEY(rename),
 293         FUNKEY(replace),
 294         FUNKEY(printconfig),
 295         FUNKEY(saveconfig),
 296         FUNKEY(start),
 297         FUNKEY(stop),
 298         FUNKEY(makedev),
 299         FUNKEY(help),
 300         FUNKEY(quit),
 301         FUNKEY(concat),
 302         FUNKEY(stripe),
 303         FUNKEY(raid4),
 304         FUNKEY(raid5),
 305         FUNKEY(mirror),
 306         FUNKEY(setdaemon),
 307         FUNKEY(readpol),
 308         FUNKEY(resetstats),
 309         FUNKEY(setstate),
 310         FUNKEY(checkparity),
 311         FUNKEY(rebuildparity),
 312         FUNKEY(dumpconfig)
 313 };
 314
 315 /* Take args arguments at argv and attempt to perform the operation specified */
 316 void
 317 parseline(int args, char *argv[])
 318 {
 319     int i;
 320     int j;
 321     enum keyword command;                                   /* command to execute */
 322
 323     if (history != NULL) {                                  /* save the command to history file */
 324         timestamp();
 325         for (i = 0; i < args; i++)                          /* all args */
 326             fprintf(history, "%s ", argv[i]);
 327         fputs("\n", history);
 328     }
 329     if ((args == 0)                                         /* empty line */
 330     ||(*argv[0] == '#'))                                    /* or a comment, */
 331         return;
 332     if (args == MAXARGS) {                                  /* too many arguments, */
 333         fprintf(stderr, "Too many arguments to %s, this can't be right\n", argv[0]);
 334         return;
 335     }
 336     command = get_keyword(argv[0], &keyword_set);
 337     dowait = 0;                                             /* initialize flags */
 338     force = 0;                                              /* initialize flags */
 339     vflag = 0;                                              /* initialize flags */
 340     Verbose = 0;                                            /* initialize flags */
 341     recurse = 0;                                            /* initialize flags */
 342     sflag = 0;                                              /* initialize flags */
 343     objectname = NULL;                                      /* no name yet */
 344
 345     /*
 346      * first handle generic options
 347      * We don't use getopt(3) because
 348      * getopt doesn't allow merging flags
 349      * (for example, -fr).
 350      */
 351     for (i = 1; (i < args) && (argv[i][0] == '-'); i++) {   /* while we have flags */
 352         for (j = 1; j < strlen(argv[i]); j++)
 353             switch (argv[i][j]) {
 354 #if VINUMDEBUG
 355             case 'd':                                       /* -d: debug */
 356                 debug = 1;
 357                 break;
 358 #endif
 359
 360             case 'f':                                       /* -f: force */
 361                 force = 1;
 362                 break;
 363
 364             case 'i':                                       /* interval */
 365                 interval = 0;
 366                 if (argv[i][j + 1] != '\0')                 /* operand follows, */
 367                     interval = atoi(&argv[i][j + 1]);       /* use it */
 368                 else if (args > (i + 1))                    /* another following, */
 369                     interval = atoi(argv[++i]);             /* use it */
 370                 if (interval == 0)                          /* nothing valid, */
 371                     fprintf(stderr, "-i: no interval specified\n");
 372                 break;
 373
 374             case 'n':                                       /* -n: get name */
 375                 if (i == args - 1) {                        /* last arg */
 376                     fprintf(stderr, "-n requires a name parameter\n");
 377                     return;
 378                 }
 379                 objectname = argv[++i];                     /* pick it up */
 380                 j = strlen(argv[i]);                        /* skip the next parm */
 381                 break;
 382
 383             case 'r':                                       /* -r: recurse */
 384                 recurse = 1;
 385                 break;
 386
 387             case 's':                                       /* -s: show statistics */
 388                 sflag = 1;
 389                 break;
 390
 391             case 'S':
 392                 SSize = 0;
 393                 if (argv[i][j + 1] != '\0')                 /* operand follows, */
 394                     SSize = atoi(&argv[i][j + 1]);          /* use it */
 395                 else if (args > (i + 1))                    /* another following, */
 396                     SSize = atoi(argv[++i]);                /* use it */
 397                 if (SSize == 0)                             /* nothing valid, */
 398                     fprintf(stderr, "-S: no size specified\n");
 399                 break;
 400
 401             case 'v':                                       /* -v: verbose */
 402                 vflag++;
 403                 break;
 404
 405             case 'V':                                       /* -V: Very verbose */
 406                 vflag++;
 407                 Verbose++;
 408                 break;
 409
 410             case 'w':                                       /* -w: wait for completion */
 411                 dowait = 1;
 412                 break;
 413
 414             default:
 415                 fprintf(stderr, "Invalid flag: %s\n", argv[i]);
 416             }
 417     }
 418
 419     /* Pass what we have left to the command to handle it */
 420     for (j = 0; j < (sizeof(funkeys) / sizeof(struct funkey)); j++) {
 421         if (funkeys[j].kw == command) {                     /* found the command */
 422             funkeys[j].fun(args - i, &argv[i], &argv[0]);
 423             return;
 424         }
 425     }
 426     fprintf(stderr, "Unknown command: %s\n", argv[0]);
 427 }
 428
 429 void
 430 get_drive_info(struct drive *drive, int index)
 431 {
 432     *(int *) drive = index;                                 /* put in drive to hand to driver */
 433     if (ioctl(superdev, VINUM_DRIVECONFIG, drive) < 0) {
 434         fprintf(stderr,
 435             "Can't get config for drive %d: %s\n",
 436             index,
 437             strerror(errno));
 438         longjmp(command_fail, -1);
 439     }
 440 }
 441
 442 void
 443 get_sd_info(struct sd *sd, int index)
 444 {
 445     *(int *) sd = index;                                    /* put in sd to hand to driver */
 446     if (ioctl(superdev, VINUM_SDCONFIG, sd) < 0) {
 447         fprintf(stderr,
 448             "Can't get config for subdisk %d: %s\n",
 449             index,
 450             strerror(errno));
 451         longjmp(command_fail, -1);
 452     }
 453 }
 454
 455 /* Get the contents of the sd entry for subdisk <sdno>
 456  * of the specified plex. */
 457 void
 458 get_plex_sd_info(struct sd *sd, int plexno, int sdno)
 459 {
 460     ((int *) sd)[0] = plexno;
 461     ((int *) sd)[1] = sdno;                                 /* pass parameters */
 462     if (ioctl(superdev, VINUM_PLEXSDCONFIG, sd) < 0) {
 463         fprintf(stderr,
 464             "Can't get config for subdisk %d (part of plex %d): %s\n",
 465             sdno,
 466             plexno,
 467             strerror(errno));
 468         longjmp(command_fail, -1);
 469     }
 470 }
 471
 472 void
 473 get_plex_info(struct plex *plex, int index)
 474 {
 475     *(int *) plex = index;                                  /* put in plex to hand to driver */
 476     if (ioctl(superdev, VINUM_PLEXCONFIG, plex) < 0) {
 477         fprintf(stderr,
 478             "Can't get config for plex %d: %s\n",
 479             index,
 480             strerror(errno));
 481         longjmp(command_fail, -1);
 482     }
 483 }
 484
 485 void
 486 get_volume_info(struct volume *volume, int index)
 487 {
 488     *(int *) volume = index;                                /* put in volume to hand to driver */
 489     if (ioctl(superdev, VINUM_VOLCONFIG, volume) < 0) {
 490         fprintf(stderr,
 491             "Can't get config for volume %d: %s\n",
 492             index,
 493             strerror(errno));
 494         longjmp(command_fail, -1);
 495     }
 496 }
 497
 498 struct drive *
 499 find_drive_by_devname(char *name)
 500 {
 501     int driveno;
 502
 503     if (ioctl(superdev, VINUM_GETCONFIG, &vinum_conf) < 0) {
 504         perror("Can't get vinum config");
 505         return NULL;
 506     }
 507     for (driveno = 0; driveno < vinum_conf.drives_allocated; driveno++) {
 508         get_drive_info(&drive, driveno);
 509         if ((drive.state != drive_unallocated)              /* real drive */
 510         &&(!strcmp(drive.devicename, name)))                /* and the name's right, */
 511             return &drive;                                  /* found it */
 512     }
 513     return NULL;                                            /* no drive of that name */
 514 }
 515
 516 /* Create the device nodes for vinum objects */
 517 void
 518 make_devices(void)
 519 {
 520     int volno;
 521     int plexno;
 522     int sdno;
 523     int driveno;
 524
 525     if (access("/dev", W_OK) < 0) {                         /* can't access /dev to write? */
 526         if (errno == EROFS)                                 /* because it's read-only, */
 527             fprintf(stderr, VINUMMOD ": /dev is mounted read-only, not rebuilding " VINUM_DIR "\n");
 528         else
 529             perror(VINUMMOD ": Can't write to /dev");
 530         return;
 531     }
 532     if (history) {
 533         timestamp();
 534         fprintf(history, "*** Created devices ***\n");
 535     }
 536     if (superdev >= 0)                                      /* super device open */
 537         close(superdev);
 538
 539     system("rm -rf " VINUM_DIR);                            /* remove the old directories */
 540     system("mkdir -p " VINUM_DIR "/drive "                  /* and make them again */
 541         VINUM_DIR "/plex "
 542         VINUM_DIR "/sd "
 543         VINUM_DIR "/vol");
 544
 545     if (mknod(VINUM_SUPERDEV_NAME,
 546             S_IRUSR | S_IWUSR | S_IFCHR,                    /* user only */
 547             makedev(VINUM_CDEV_MAJOR, VINUM_SUPERDEV)) < 0)
 548         fprintf(stderr, "Can't create %s: %s\n", VINUM_SUPERDEV_NAME, strerror(errno));
 549
 550     if (mknod(VINUM_WRONGSUPERDEV_NAME,
 551             S_IRUSR | S_IWUSR | S_IFCHR,                    /* user only */
 552             makedev(VINUM_CDEV_MAJOR, VINUM_WRONGSUPERDEV)) < 0)
 553         fprintf(stderr, "Can't create %s: %s\n", VINUM_WRONGSUPERDEV_NAME, strerror(errno));
 554
 555     superdev = open(VINUM_SUPERDEV_NAME, O_RDWR);           /* open the super device */
 556
 557     if (mknod(VINUM_DAEMON_DEV_NAME,                        /* daemon super device */
 558             S_IRUSR | S_IWUSR | S_IFCHR,                    /* user only */
 559             makedev(VINUM_CDEV_MAJOR, VINUM_DAEMON_DEV)) < 0)
 560         fprintf(stderr, "Can't create %s: %s\n", VINUM_DAEMON_DEV_NAME, strerror(errno));
 561
 562     if (ioctl(superdev, VINUM_GETCONFIG, &vinum_conf) < 0) {
 563         perror("Can't get vinum config");
 564         return;
 565     }
 566     for (volno = 0; volno < vinum_conf.volumes_allocated; volno++)
 567         make_vol_dev(volno, 0);
 568
 569     for (plexno = 0; plexno < vinum_conf.plexes_allocated; plexno++)
 570         make_plex_dev(plexno, 0);
 571
 572     for (sdno = 0; sdno < vinum_conf.subdisks_allocated; sdno++)
 573         make_sd_dev(sdno);
 574
 575     /* Drives.  Do this later (both logical and physical names) XXX */
 576     for (driveno = 0; driveno < vinum_conf.drives_allocated; driveno++) {
 577         char filename[PATH_MAX];                            /* for forming file names */
 578
 579         get_drive_info(&drive, driveno);
 580         if (drive.state > drive_referenced) {
 581             sprintf(filename, "ln -s %s " VINUM_DIR "/drive/%s", drive.devicename, drive.label.name);
 582             system(filename);
 583         }
 584     }
 585 }
 586
 587 /* make the devices for a volume */
 588 void
 589 make_vol_dev(int volno, int recurse)
 590 {
 591     dev_t voldev;
 592     char filename[PATH_MAX];                                /* for forming file names */
 593     int plexno;
 594
 595     get_volume_info(&vol, volno);
 596     if (vol.state != volume_unallocated) {                  /* we could have holes in our lists */
 597         voldev = VINUMDEV(volno, 0, 0, VINUM_VOLUME_TYPE);  /* create a device number */
 598
 599         /* Create /dev/vinum/<myvol> */
 600         sprintf(filename, VINUM_DIR "/%s", vol.name);
 601         if (mknod(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IFCHR, voldev) < 0)
 602             fprintf(stderr, "Can't create %s: %s\n", filename, strerror(errno));
 603
 604         /* Create /dev/vinum/vol/<myvol> */
 605         sprintf(filename, VINUM_DIR "/vol/%s", vol.name);
 606         if (mknod(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IFCHR, voldev) < 0)
 607             fprintf(stderr, "Can't create %s: %s\n", filename, strerror(errno));
 608
 609         if (vol.plexes > 0) {
 610             /* Create /dev/vinum/vol/<myvol>.plex/ */
 611             sprintf(filename, VINUM_DIR "/vol/%s.plex", vol.name);
 612             if (mkdir(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IXOTH) < 0)
 613                 fprintf(stderr, "Can't create %s: %s\n", filename, strerror(errno));
 614         }
 615         if (recurse)
 616             for (plexno = 0; plexno < vol.plexes; plexno++)
 617                 make_plex_dev(plex.plexno, recurse);
 618     }
 619 }
 620
 621 /*
 622  * Create device entries for the plexes in
 623  * /dev/vinum/<vol>.plex/ and /dev/vinum/plex.
 624  */
 625 void
 626 make_plex_dev(int plexno, int recurse)
 627 {
 628     dev_t plexdev;                                          /* device */
 629     char filename[PATH_MAX];                                /* for forming file names */
 630     int sdno;
 631
 632     get_plex_info(&plex, plexno);
 633     if (plex.state != plex_unallocated) {
 634         plexdev = VINUM_PLEX(plexno);
 635
 636         /* /dev/vinum/plex/<plex> */
 637         sprintf(filename, VINUM_DIR "/plex/%s", plex.name);
 638         if (mknod(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IFCHR, plexdev) < 0)
 639             fprintf(stderr, "Can't create %s: %s\n", filename, strerror(errno));
 640
 641         if (plex.volno >= 0) {
 642             get_volume_info(&vol, plex.volno);
 643             plexdev = VINUMDEV(plex.volno, plexno, 0, VINUM_PLEX_TYPE);
 644
 645             /* Create device /dev/vinum/vol/<vol>.plex/<plex> */
 646             sprintf(filename, VINUM_DIR "/vol/%s.plex/%s", vol.name, plex.name);
 647             if (mknod(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IFCHR, plexdev) < 0)
 648                 fprintf(stderr, "Can't create %s: %s\n", filename, strerror(errno));
 649
 650             /* Create directory /dev/vinum/vol/<vol>.plex/<plex>.sd */
 651             sprintf(filename, VINUM_DIR "/vol/%s.plex/%s.sd", vol.name, plex.name);
 652             if (mkdir(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IXOTH) < 0)
 653                 fprintf(stderr, "Can't create %s: %s\n", filename, strerror(errno));
 654         }
 655         if (recurse) {
 656             for (sdno = 0; sdno < plex.subdisks; sdno++) {
 657                 get_plex_sd_info(&sd, plex.plexno, sdno);
 658                 make_sd_dev(sd.sdno);
 659             }
 660         }
 661     }
 662 }
 663
 664 /* Create the contents of /dev/vinum/sd and /dev/vinum/rsd */
 665 void
 666 make_sd_dev(int sdno)
 667 {
 668     dev_t sddev;                                            /* device */
 669     char filename[PATH_MAX];                                /* for forming file names */
 670
 671     get_sd_info(&sd, sdno);
 672     if (sd.state != sd_unallocated) {
 673         sddev = VINUM_SD(sdno);
 674
 675         /* /dev/vinum/sd/<sd> */
 676         sprintf(filename, VINUM_DIR "/sd/%s", sd.name);
 677         if (mknod(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IFCHR, sddev) < 0)
 678             fprintf(stderr, "Can't create %s: %s\n", filename, strerror(errno));
 679     }
 680 }
 681
 682
 683 /* command line interface for the 'makedev' command */
 684 void
 685 vinum_makedev(int argc, char *argv[], char *arg0[])
 686 {
 687     make_devices();
 688 }
 689
 690 /*
 691  * Find the object "name".  Return object type at type,
 692  * and the index as the return value.
 693  * If not found, return -1 and invalid_object.
 694  */
 695 int
 696 find_object(const char *name, enum objecttype *type)
 697 {
 698     int object;
 699
 700     if (ioctl(superdev, VINUM_GETCONFIG, &vinum_conf) < 0) {
 701         perror("Can't get vinum config");
 702         *type = invalid_object;
 703         return -1;
 704     }
 705     /* Search the drive table */
 706     for (object = 0; object < vinum_conf.drives_allocated; object++) {
 707         get_drive_info(&drive, object);
 708         if (strcmp(name, drive.label.name) == 0) {
 709             *type = drive_object;
 710             return object;
 711         }
 712     }
 713
 714     /* Search the subdisk table */
 715     for (object = 0; object < vinum_conf.subdisks_allocated; object++) {
 716         get_sd_info(&sd, object);
 717         if (strcmp(name, sd.name) == 0) {
 718             *type = sd_object;
 719             return object;
 720         }
 721     }
 722
 723     /* Search the plex table */
 724     for (object = 0; object < vinum_conf.plexes_allocated; object++) {
 725         get_plex_info(&plex, object);
 726         if (strcmp(name, plex.name) == 0) {
 727             *type = plex_object;
 728             return object;
 729         }
 730     }
 731
 732     /* Search the volume table */
 733     for (object = 0; object < vinum_conf.volumes_allocated; object++) {
 734         get_volume_info(&vol, object);
 735         if (strcmp(name, vol.name) == 0) {
 736             *type = volume_object;
 737             return object;
 738         }
 739     }
 740
 741     /* Didn't find the name: invalid */
 742     *type = invalid_object;
 743     return -1;
 744 }
 745
 746 /* Continue reviving a subdisk in the background */
 747 void
 748 continue_revive(int sdno)
 749 {
 750     struct sd sd;
 751     pid_t pid;
 752     get_sd_info(&sd, sdno);
 753
 754     if (dowait == 0)
 755         pid = fork();                                       /* do this in the background */
 756     else
 757         pid = 0;
 758     if (pid == 0) {                                         /* we're the child */
 759         struct _ioctl_reply reply;
 760         struct vinum_ioctl_msg *message = (struct vinum_ioctl_msg *) &reply;
 761
 762         openlog(VINUMMOD, LOG_CONS | LOG_PERROR | LOG_PID, LOG_KERN);
 763         syslog(LOG_INFO | LOG_KERN, "reviving %s", sd.name);
 764         setproctitle("reviving %s", sd.name);
 765
 766         for (reply.error = EAGAIN; reply.error == EAGAIN;) { /* revive the subdisk */
 767             if (interval)
 768                 usleep(interval * 1000);                    /* pause between each copy */
 769             message->index = sdno;                          /* pass sd number */
 770             message->type = sd_object;                      /* and type of object */
 771             message->state = object_up;
 772             if (SSize != 0) {                               /* specified a size for init */
 773                 if (SSize < 512)
 774                     SSize <<= DEV_BSHIFT;
 775                 message->blocksize = SSize;
 776             } else
 777                 message->blocksize = DEFAULT_REVIVE_BLOCKSIZE;
 778             ioctl(superdev, VINUM_SETSTATE, message);
 779         }
 780         if (reply.error) {
 781             syslog(LOG_ERR | LOG_KERN,
 782                 "can't revive %s: %s",
 783                 sd.name,
 784                 reply.msg[0] ? reply.msg : strerror(reply.error));
 785             if (dowait == 0)
 786                 exit(1);
 787         } else {
 788             get_sd_info(&sd, sdno);                         /* update the info */
 789             syslog(LOG_INFO | LOG_KERN, "%s is %s", sd.name, sd_state(sd.state));
 790             if (dowait == 0)
 791                 exit(0);
 792         }
 793     } else if (pid < 0)                                     /* couldn't fork? */
 794         fprintf(stderr, "Can't continue reviving %s: %s\n", sd.name, strerror(errno));
 795     else                                                    /* parent */
 796         printf("Reviving %s in the background\n", sd.name);
 797 }
 798
 799 /*
 800  * Check if the daemon is running,
 801  * start it if it isn't.  The check itself
 802  * could take a while, so we do it as a separate
 803  * process, which will become the daemon if one isn't
 804  * running already
 805  */
 806 void
 807 start_daemon(void)
 808 {
 809     int pid;
 810     int status;
 811     int error;
 812
 813     pid = (int) fork();
 814
 815     if (pid == 0) {                                         /* We're the child, do the work */
 816         /*
 817          * We have a problem when stopping the subsystem:
 818          * The only way to know that we're idle is when
 819          * all open superdevs close.  But we want the
 820          * daemon to clean up for us, and since we can't
 821          * count the opens, we need to have the main device
 822          * closed when we stop.  We solve this conundrum
 823          * by getting the daemon to open a separate device.
 824          */
 825         close(superdev);                                    /* this is the wrong device */
 826         superdev = open(VINUM_DAEMON_DEV_NAME, O_RDWR);     /* open deamon superdevice */
 827         if (superdev < 0) {
 828             perror("Can't open " VINUM_DAEMON_DEV_NAME);
 829             exit(1);
 830         }
 831         error = daemon(0, 0);                               /* this will fork again, but who's counting? */
 832         if (error != 0) {
 833             fprintf(stderr, "Can't start daemon: %s (%d)\n", strerror(errno), errno);
 834             exit(1);
 835         }
 836         setproctitle(VINUMMOD " daemon");                   /* show what we're doing */
 837         status = ioctl(superdev, VINUM_FINDDAEMON, NULL);
 838         if (status != 0) {                                  /* no daemon, */
 839             ioctl(superdev, VINUM_DAEMON, &vflag);          /* we should hang here */
 840             syslog(LOG_ERR | LOG_KERN, "%s", strerror(errno));
 841             exit(1);
 842         }
 843         exit(0);                                            /* when told to die */
 844     } else if (pid < 0)                                     /* couldn't fork */
 845         printf("Can't fork to check daemon\n");
 846 }
 847
 848 void
 849 timestamp()
 850 {
 851     struct timeval now;
 852     struct tm *date;
 853     char datetext[MAXDATETEXT];
 854     time_t sec;
 855
 856     if (history != NULL) {
 857         if (gettimeofday(&now, NULL) != 0) {
 858             fprintf(stderr, "Can't get time: %s\n", strerror(errno));
 859             return;
 860         }
 861         sec = now.tv_sec;
 862         date = localtime(&sec);
 863         strftime(datetext, MAXDATETEXT, dateformat, date),
 864             fprintf(history,
 865             "%s.%06ld ",
 866             datetext,
 867             now.tv_usec);
 868     }
 869 }