sys/dev/raid/vinum/vinumio.c

   1 /*-
   2  * Copyright (c) 1997, 1998
   3  *      Nan Yang Computer Services Limited.  All rights reserved.
   4  *
   5  *  This software is distributed under the so-called ``Berkeley
   6  *  License'':
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by Nan Yang Computer
  19  *      Services Limited.
  20  * 4. Neither the name of the Company nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * This software is provided ``as is'', and any express or implied
  25  * warranties, including, but not limited to, the implied warranties of
  26  * merchantability and fitness for a particular purpose are disclaimed.
  27  * In no event shall the company or contributors be liable for any
  28  * direct, indirect, incidental, special, exemplary, or consequential
  29  * damages (including, but not limited to, procurement of substitute
  30  * goods or services; loss of use, data, or profits; or business
  31  * interruption) however caused and on any theory of liability, whether
  32  * in contract, strict liability, or tort (including negligence or
  33  * otherwise) arising in any way out of the use of this software, even if
  34  * advised of the possibility of such damage.
  35  *
  36  * $Id: vinumio.c,v 1.30 2000/05/10 23:23:30 grog Exp grog $
  37  * $FreeBSD: src/sys/dev/vinum/vinumio.c,v 1.52.2.6 2002/05/02 08:43:44 grog Exp $
  38  */
  39
  40 #include "vinumhdr.h"
  41 #include "request.h"
  42 #include <vm/vm_zone.h>
  43 #include <sys/nlookup.h>
  44
  45 static char *sappend(char *txt, char *s);
  46 static int drivecmp(const void *va, const void *vb);
  47
  48 /*
  49  * Open the device associated with the drive, and set drive's vp.
  50  * Return an error number
  51  */
  52 int
  53 open_drive(struct drive *drive, struct proc *p, int verbose)
  54 {
  55     struct nlookupdata nd;
  56     int error;
  57
  58     /*
  59      * Fail if already open
  60      */
  61     if (drive->flags & VF_OPEN)
  62         return EBUSY;
  63
  64     if (rootdev) {
  65         /*
  66          * Open via filesystem (future)
  67          */
  68         error = nlookup_init(&nd, drive->devicename, UIO_SYSSPACE, NLC_FOLLOW);
  69         if (error)
  70             return error;
  71         error = vn_open(&nd, NULL, FREAD|FWRITE, 0);
  72         drive->vp = nd.nl_open_vp;
  73         nd.nl_open_vp = NULL;
  74         nlookup_done(&nd);
  75     } else {
  76         /*
  77          * Open via synthesized vnode backed by disk device
  78          */
  79         error = vn_opendisk(drive->devicename, FREAD|FWRITE, &drive->vp);
  80         if (error)
  81             return error;
  82     }
  83
  84     if (error == 0 && drive->vp == NULL)
  85         error = ENODEV;
  86
  87     /*
  88      * A huge amount of pollution all over vinum requires that our low
  89      * level drive be a device.
  90      */
  91     if (error == 0 && drive->vp->v_type != VCHR) {
  92         vn_close(drive->vp, FREAD|FWRITE, NULL);
  93         drive->vp = NULL;
  94         error = ENODEV;
  95     }
  96     if (error) {
  97         drive->state = drive_down;
  98         if (verbose) {
  99             log(LOG_WARNING,
 100                 "vinum open_drive %s: failed with error %d\n",
 101                 drive->devicename, error);
 102         }
 103     } else {
 104         drive->dev = drive->vp->v_rdev;
 105         drive->flags |= VF_OPEN;
 106     }
 107     drive->lasterror = error;
 108     return error;
 109 }
 110
 111 /*
 112  * Set some variables in the drive struct
 113  * in more convenient form.  Return error indication
 114  */
 115 int
 116 set_drive_parms(struct drive *drive)
 117 {
 118     drive->blocksize = BLKDEV_IOSIZE;                       /* do we need this? */
 119     drive->secsperblock = drive->blocksize                  /* number of sectors per block */
 120         / drive->partinfo.media_blksize;
 121
 122     /* Now update the label part */
 123     bcopy(hostname, drive->label.sysname, VINUMHOSTNAMELEN); /* put in host name */
 124     getmicrotime(&drive->label.date_of_birth);              /* and current time */
 125     drive->label.drive_size = drive->partinfo.media_size;
 126 #if VINUMDEBUG
 127     if (debug & DEBUG_BIGDRIVE)                             /* pretend we're 100 times as big */
 128         drive->label.drive_size *= 100;
 129 #endif
 130
 131     /* number of sectors available for subdisks */
 132     drive->sectors_available = drive->label.drive_size / DEV_BSIZE - DATASTART;
 133
 134     /*
 135      * Bug in 3.0 as of January 1998: you can open
 136      * non-existent slices.  They have a length of 0.
 137      */
 138     if (drive->label.drive_size < MINVINUMSLICE) {          /* too small to worry about */
 139         set_drive_state(drive->driveno, drive_down, setstate_force);
 140         drive->lasterror = ENOSPC;
 141         return ENOSPC;
 142     }
 143     drive->freelist_size = INITIAL_DRIVE_FREELIST;          /* initial number of entries */
 144     drive->freelist = (struct drive_freelist *)
 145         Malloc(INITIAL_DRIVE_FREELIST * sizeof(struct drive_freelist));
 146     if (drive->freelist == NULL)                            /* can't malloc, dammit */
 147         return ENOSPC;
 148     drive->freelist_entries = 1;                            /* just (almost) the complete drive */
 149     drive->freelist[0].offset = DATASTART;                  /* starts here */
 150     drive->freelist[0].sectors = (drive->label.drive_size >> DEV_BSHIFT) - DATASTART; /* and it's this long */
 151     if (drive->label.name[0] != '\0')                       /* got a name */
 152         set_drive_state(drive->driveno, drive_up, setstate_force); /* our drive is accessible */
 153     else                                                    /* we know about it, but that's all */
 154         drive->state = drive_referenced;
 155     return 0;
 156 }
 157
 158 /*
 159  * Initialize a drive: open the device and add device
 160  * information
 161  */
 162 int
 163 init_drive(struct drive *drive, int verbose)
 164 {
 165     if (drive->devicename[0] != '/') {
 166         drive->lasterror = EINVAL;
 167         log(LOG_ERR, "vinum: Can't open drive without drive name (%s)\n",
 168             drive->devicename);
 169         return EINVAL;
 170     }
 171     drive->lasterror = open_drive(drive, curproc, verbose); /* open the drive */
 172     if (drive->lasterror)
 173         return drive->lasterror;
 174
 175     drive->lasterror = VOP_IOCTL(drive->vp, DIOCGPART,
 176                                  (caddr_t)&drive->partinfo, FREAD|FWRITE,
 177                                  proc0.p_ucred, NULL);
 178     if (drive->lasterror) {
 179         if (verbose)
 180             log(LOG_WARNING,
 181                 "vinum open_drive %s: Can't get partition information, drive->lasterror %d\n",
 182                 drive->devicename,
 183                 drive->lasterror);
 184         close_drive(drive);
 185         return drive->lasterror;
 186     }
 187     if (drive->partinfo.fstype != FS_VINUM &&
 188         !kuuid_is_vinum(&drive->partinfo.fstype_uuid)
 189     ) {
 190         drive->lasterror = EFTYPE;
 191         if (verbose)
 192             log(LOG_WARNING,
 193                 "vinum open_drive %s: Wrong partition type for vinum\n",
 194                 drive->devicename);
 195         close_drive(drive);
 196         return EFTYPE;
 197     }
 198     return set_drive_parms(drive);                          /* set various odds and ends */
 199 }
 200
 201 /* Close a drive if it's open. */
 202 void
 203 close_drive(struct drive *drive)
 204 {
 205     LOCKDRIVE(drive);                                       /* keep the daemon out */
 206     if (drive->flags & VF_OPEN)
 207         close_locked_drive(drive);                          /* and close it */
 208     if (drive->state > drive_down)                          /* if it's up */
 209         drive->state = drive_down;                          /* make sure it's down */
 210     unlockdrive(drive);
 211 }
 212
 213 /*
 214  * Real drive close code, called with drive already locked.
 215  * We have also checked that the drive is open.  No errors.
 216  */
 217 void
 218 close_locked_drive(struct drive *drive)
 219 {
 220     /*
 221      * If we can't access the drive, we can't flush
 222      * the queues, which spec_close() will try to
 223      * do.  Get rid of them here first.
 224      */
 225     if (drive->vp) {
 226         drive->lasterror = vn_close(drive->vp, FREAD|FWRITE, NULL);
 227         drive->vp = NULL;
 228     }
 229     drive->flags &= ~VF_OPEN;
 230 }
 231
 232 /*
 233  * Remove drive from the configuration.
 234  * Caller must ensure that it isn't active.
 235  */
 236 void
 237 remove_drive(int driveno)
 238 {
 239     struct drive *drive = &vinum_conf.drive[driveno];
 240     struct vinum_hdr *vhdr;                                 /* buffer for header */
 241     int error;
 242
 243     if (drive->state > drive_referenced) {                  /* real drive */
 244         if (drive->state == drive_up) {
 245             vhdr = (struct vinum_hdr *) Malloc(VINUMHEADERLEN); /* allocate buffer */
 246             CHECKALLOC(vhdr, "Can't allocate memory");
 247             error = read_drive(drive, (void *) vhdr, VINUMHEADERLEN, VINUM_LABEL_OFFSET);
 248             if (error)
 249                 drive->lasterror = error;
 250             else {
 251                 vhdr->magic = VINUM_NOMAGIC;                /* obliterate the magic, but leave the rest */
 252                 write_drive(drive, (void *) vhdr, VINUMHEADERLEN, VINUM_LABEL_OFFSET);
 253             }
 254             Free(vhdr);
 255         }
 256         free_drive(drive);                                  /* close it and free resources */
 257         save_config();                                      /* and save the updated configuration */
 258     }
 259 }
 260
 261 /*
 262  * Transfer drive data.  Usually called from one of these defines;
 263  * #define read_drive(a, b, c, d) driveio (a, b, c, d, BUF_CMD_READ)
 264  * #define write_drive(a, b, c, d) driveio (a, b, c, d, BUF_CMD_WRITE)
 265  *
 266  * length and offset are in bytes, but must be multiples of sector
 267  * size.  The function *does not check* for this condition, and
 268  * truncates ruthlessly.
 269  * Return error number
 270  */
 271 int
 272 driveio(struct drive *drive, char *buf, size_t length, off_t offset, buf_cmd_t cmd)
 273 {
 274     int error;
 275     struct buf *bp;
 276     caddr_t saveaddr;
 277
 278     error = 0;                                              /* to keep the compiler happy */
 279     while (length) {                                        /* divide into small enough blocks */
 280         int len = umin(length, MAXBSIZE);                   /* maximum block device transfer is MAXBSIZE */
 281
 282         bp = geteblk(len);                                  /* get a buffer header */
 283         bp->b_cmd = cmd;
 284         bp->b_bio1.bio_offset = offset;                     /* disk offset */
 285         bp->b_bio1.bio_done = biodone_sync;
 286         bp->b_bio1.bio_flags |= BIO_SYNC;
 287         saveaddr = bp->b_data;
 288         bp->b_data = buf;
 289         bp->b_bcount = len;
 290         vn_strategy(drive->vp, &bp->b_bio1);
 291         error = biowait(&bp->b_bio1, (cmd == BUF_CMD_READ ? "drvrd" : "drvwr"));
 292         bp->b_data = saveaddr;
 293         bp->b_flags |= B_INVAL | B_AGE;
 294         bp->b_flags &= ~B_ERROR;
 295         brelse(bp);
 296         if (error)
 297             break;
 298         length -= len;                                      /* update pointers */
 299         buf += len;
 300         offset += len;
 301     }
 302     return error;
 303 }
 304
 305 /*
 306  * Check a drive for a vinum header.  If found,
 307  * update the drive information.  We come here
 308  * with a partially populated drive structure
 309  * which includes the device name.
 310  *
 311  * Return information on what we found.
 312  *
 313  * This function is called from two places: check_drive,
 314  * which wants to find out whether the drive is a
 315  * Vinum drive, and config_drive, which asserts that
 316  * it is a vinum drive.  In the first case, we don't
 317  * print error messages (verbose==0), in the second
 318  * we do (verbose==1).
 319  */
 320 enum drive_label_info
 321 read_drive_label(struct drive *drive, int verbose)
 322 {
 323     int error;
 324     int result;
 325     struct vinum_hdr *vhdr;
 326
 327     error = init_drive(drive, verbose);                     /* find the drive */
 328     if (error)                                              /* find the drive */
 329         return DL_CANT_OPEN;                                /* not ours */
 330
 331     vhdr = (struct vinum_hdr *) Malloc(VINUMHEADERLEN);     /* allocate buffers */
 332     CHECKALLOC(vhdr, "Can't allocate memory");
 333
 334     drive->state = drive_up;                                /* be optimistic */
 335     error = read_drive(drive, (void *) vhdr, VINUMHEADERLEN, VINUM_LABEL_OFFSET);
 336     if (vhdr->magic == VINUM_MAGIC) {                       /* ours! */
 337         if (drive->label.name[0]                            /* we have a name for this drive */
 338         &&(strcmp(drive->label.name, vhdr->label.name))) {  /* but it doesn't match the real name */
 339             drive->lasterror = EINVAL;
 340             result = DL_WRONG_DRIVE;                        /* it's the wrong drive */
 341             drive->state = drive_unallocated;               /* put it back, it's not ours */
 342         } else
 343             result = DL_OURS;
 344         /*
 345          * We copy the drive anyway so that we have
 346          * the correct name in the drive info.  This
 347          * may not be the name specified
 348          */
 349         drive->label = vhdr->label;                         /* put in the label information */
 350     } else if (vhdr->magic == VINUM_NOMAGIC)                /* was ours, but we gave it away */
 351         result = DL_DELETED_LABEL;                          /* and return the info */
 352     else
 353         result = DL_NOT_OURS;                               /* we could have it, but we don't yet */
 354     Free(vhdr);                                             /* that's all. */
 355     return result;
 356 }
 357
 358 /*
 359  * Check a drive for a vinum header.  If found,
 360  * read configuration information from the drive and
 361  * incorporate the data into the configuration.
 362  *
 363  * Return drive number.
 364  */
 365 struct drive *
 366 check_drive(char *devicename)
 367 {
 368     int driveno;
 369     int i;
 370     struct drive *drive;
 371
 372     driveno = find_drive_by_dev(devicename, 1);             /* if entry doesn't exist, create it */
 373     drive = &vinum_conf.drive[driveno];                     /* and get a pointer */
 374
 375     if (read_drive_label(drive, 0) == DL_OURS) {            /* one of ours */
 376         for (i = 0; i < vinum_conf.drives_allocated; i++) { /* see if the name already exists */
 377             if ((i != driveno)                              /* not this drive */
 378             &&(DRIVE[i].state != drive_unallocated)         /* and it's allocated */
 379             &&(strcmp(DRIVE[i].label.name,
 380                         DRIVE[driveno].label.name) == 0)) { /* and it has the same name */
 381                 struct drive *mydrive = &DRIVE[i];
 382
 383                 if (mydrive->devicename[0] == '/') {        /* we know a device name for it */
 384                     /*
 385                      * set an error, but don't take the
 386                      * drive down: that would cause unneeded
 387                      * error messages.
 388                      */
 389                     drive->lasterror = EEXIST;
 390                     break;
 391                 } else {                                    /* it's just a place holder, */
 392                     int sdno;
 393
 394                     for (sdno = 0; sdno < vinum_conf.subdisks_allocated; sdno++) { /* look at each subdisk */
 395                         if ((SD[sdno].driveno == i)         /* it's pointing to this one, */
 396                         &&(SD[sdno].state != sd_unallocated)) { /* and it's a real subdisk */
 397                             SD[sdno].driveno = drive->driveno; /* point to the one we found */
 398                             update_sd_state(sdno);          /* and update its state */
 399                         }
 400                     }
 401                     bzero(mydrive, sizeof(struct drive));   /* don't deallocate it, just remove it */
 402                 }
 403             }
 404         }
 405     } else {
 406         if (drive->lasterror == 0)
 407             drive->lasterror = ENODEV;
 408         close_drive(drive);
 409         drive->state = drive_down;
 410     }
 411     return drive;
 412 }
 413
 414 static char *
 415 sappend(char *txt, char *s)
 416 {
 417     while ((*s++ = *txt++) != 0);
 418     return s - 1;
 419 }
 420
 421 void
 422 format_config(char *config, int len)
 423 {
 424     int i;
 425     int j;
 426     char *s = config;
 427     char *configend = &config[len];
 428
 429     bzero(config, len);
 430
 431     /* First write the volume configuration */
 432     for (i = 0; i < vinum_conf.volumes_allocated; i++) {
 433         struct volume *vol;
 434
 435         vol = &vinum_conf.volume[i];
 436         if ((vol->state > volume_uninit)
 437             && (vol->name[0] != '\0')) {                    /* paranoia */
 438             ksnprintf(s,
 439                 configend - s,
 440                 "volume %s state %s",
 441                 vol->name,
 442                 volume_state(vol->state));
 443             while (*s)
 444                 s++;                                        /* find the end */
 445             if (vol->preferred_plex >= 0)                   /* preferences, */
 446                 ksnprintf(s,
 447                     configend - s,
 448                     " readpol prefer %s",
 449                     vinum_conf.plex[vol->preferred_plex].name);
 450             while (*s)
 451                 s++;                                        /* find the end */
 452             s = sappend("\n", s);
 453         }
 454     }
 455
 456     /* Then the plex configuration */
 457     for (i = 0; i < vinum_conf.plexes_allocated; i++) {
 458         struct plex *plex;
 459
 460         plex = &vinum_conf.plex[i];
 461         if ((plex->state > plex_referenced)
 462             && (plex->name[0] != '\0')) {                   /* paranoia */
 463             ksnprintf(s,
 464                 configend - s,
 465                 "plex name %s state %s org %s ",
 466                 plex->name,
 467                 plex_state(plex->state),
 468                 plex_org(plex->organization));
 469             while (*s)
 470                 s++;                                        /* find the end */
 471             if (isstriped(plex)) {
 472                 ksnprintf(s,
 473                     configend - s,
 474                     "%ds ",
 475                     (int) plex->stripesize);
 476                 while (*s)
 477                     s++;                                    /* find the end */
 478             }
 479             if (plex->volno >= 0)                           /* we have a volume */
 480                 ksnprintf(s,
 481                     configend - s,
 482                     "vol %s ",
 483                     vinum_conf.volume[plex->volno].name);
 484             while (*s)
 485                 s++;                                        /* find the end */
 486             for (j = 0; j < plex->subdisks; j++) {
 487                 ksnprintf(s,
 488                     configend - s,
 489                     " sd %s",
 490                     vinum_conf.sd[plex->sdnos[j]].name);
 491             }
 492             s = sappend("\n", s);
 493         }
 494     }
 495
 496     /* And finally the subdisk configuration */
 497     for (i = 0; i < vinum_conf.subdisks_allocated; i++) {
 498         struct sd *sd;
 499         char *drivename;
 500
 501         sd = &SD[i];
 502         if ((sd->state != sd_referenced)
 503             && (sd->state != sd_unallocated)
 504             && (sd->name[0] != '\0')) {                     /* paranoia */
 505             drivename = vinum_conf.drive[sd->driveno].label.name;
 506             /*
 507              * XXX We've seen cases of dead subdisks
 508              * which don't have a drive.  If we let them
 509              * through here, the drive name is null, so
 510              * they get the drive named 'plex'.
 511              *
 512              * This is a breakage limiter, not a fix.
 513              */
 514             if (drivename[0] == '\0')
 515                 drivename = "*invalid*";
 516             ksnprintf(s,
 517                 configend - s,
 518                 "sd name %s drive %s plex %s len %llus driveoffset %llus state %s",
 519                 sd->name,
 520                 drivename,
 521                 vinum_conf.plex[sd->plexno].name,
 522                 (unsigned long long) sd->sectors,
 523                 (unsigned long long) sd->driveoffset,
 524                 sd_state(sd->state));
 525             while (*s)
 526                 s++;                                        /* find the end */
 527             if (sd->plexno >= 0)
 528                 ksnprintf(s,
 529                     configend - s,
 530                     " plexoffset %llds",
 531                     (long long) sd->plexoffset);
 532             else
 533                 ksnprintf(s, configend - s, " detached");
 534             while (*s)
 535                 s++;                                        /* find the end */
 536             if (sd->flags & VF_RETRYERRORS) {
 537                 ksnprintf(s, configend - s, " retryerrors");
 538                 while (*s)
 539                     s++;                                    /* find the end */
 540             }
 541             ksnprintf(s, configend - s, " \n");
 542             while (*s)
 543                 s++;                                        /* find the end */
 544         }
 545     }
 546     if (s > &config[len - 2])
 547         panic("vinum: configuration data overflow");
 548 }
 549
 550 /*
 551  * issue a save config request to the dæmon.  The actual work
 552  * is done in process context by daemon_save_config
 553  */
 554 void
 555 save_config(void)
 556 {
 557     union daemoninfo di = { .nothing = 0 };
 558
 559     queue_daemon_request(daemonrq_saveconfig, di);
 560 }
 561
 562 /*
 563  * Write the configuration to all vinum slices.  This
 564  * is performed by the dæmon only
 565  */
 566 void
 567 daemon_save_config(void)
 568 {
 569     int error;
 570     int driveno;
 571     struct drive *drive;                                    /* point to current drive info */
 572     struct vinum_hdr *vhdr;                                 /* and as header */
 573     char *config;                                           /* point to config data */
 574     int wlabel_on;                                          /* to set writing label on/off */
 575
 576     /* don't save the configuration while we're still working on it */
 577     if (vinum_conf.flags & VF_CONFIGURING)
 578         return;
 579     /* Build a volume header */
 580     vhdr = (struct vinum_hdr *) Malloc(VINUMHEADERLEN);     /* get space for the config data */
 581     CHECKALLOC(vhdr, "Can't allocate config data");
 582     vhdr->magic = VINUM_MAGIC;                              /* magic number */
 583     vhdr->config_length = MAXCONFIG;                        /* length of following config info */
 584
 585     config = Malloc(MAXCONFIG);                             /* get space for the config data */
 586     CHECKALLOC(config, "Can't allocate config data");
 587
 588     format_config(config, MAXCONFIG);
 589     error = 0;                                              /* no errors yet */
 590     for (driveno = 0; driveno < vinum_conf.drives_allocated; driveno++) {
 591         drive = &vinum_conf.drive[driveno];                 /* point to drive */
 592         if (drive->state > drive_referenced) {
 593             LOCKDRIVE(drive);                               /* don't let it change */
 594
 595             /*
 596              * First, do some drive consistency checks.  Some
 597              * of these are kludges, others require a process
 598              * context and couldn't be done before
 599              */
 600             if ((drive->devicename[0] == '\0')
 601                 || (drive->label.name[0] == '\0')) {
 602                 unlockdrive(drive);
 603                 free_drive(drive);                          /* get rid of it */
 604                 break;
 605             }
 606             if (((drive->flags & VF_OPEN) == 0)             /* drive not open */
 607             &&(drive->state > drive_down)) {                /* and it thinks it's not down */
 608                 unlockdrive(drive);
 609                 set_drive_state(driveno, drive_down, setstate_force); /* tell it what's what */
 610                 continue;
 611             }
 612             if ((drive->state == drive_down)                /* it's down */
 613             &&(drive->flags & VF_OPEN)) {                   /* but open, */
 614                 unlockdrive(drive);
 615                 close_drive(drive);                         /* close it */
 616             } else if (drive->state > drive_down) {
 617                 getmicrotime(&drive->label.last_update);    /* time of last update is now */
 618                 bcopy((char *) &drive->label,               /* and the label info from the drive structure */
 619                     (char *) &vhdr->label,
 620                     sizeof(vhdr->label));
 621                 if ((drive->state != drive_unallocated)
 622                     && (drive->state != drive_referenced)) { /* and it's a real drive */
 623                     wlabel_on = 1;                          /* enable writing the label */
 624                     error = 0;
 625 #if 1
 626                     error = VOP_IOCTL(drive->vp, DIOCWLABEL,
 627                                       (caddr_t)&wlabel_on, FREAD|FWRITE,
 628                                       proc0.p_ucred, NULL);
 629 #endif
 630                     if (error == 0)
 631                         error = write_drive(drive, (char *) vhdr, VINUMHEADERLEN, VINUM_LABEL_OFFSET);
 632                     if (error == 0)
 633                         error = write_drive(drive, config, MAXCONFIG, VINUM_CONFIG_OFFSET); /* first config copy */
 634                     if (error == 0)
 635                         error = write_drive(drive, config, MAXCONFIG, VINUM_CONFIG_OFFSET + MAXCONFIG); /* second copy */
 636                     wlabel_on = 0;                          /* enable writing the label */
 637 #if 1
 638                     if (error == 0) {
 639                         error = VOP_IOCTL(drive->vp, DIOCWLABEL,
 640                                           (caddr_t)&wlabel_on, FREAD|FWRITE,
 641                                           proc0.p_ucred, NULL);
 642                     }
 643 #endif
 644                     unlockdrive(drive);
 645                     if (error) {
 646                         log(LOG_ERR,
 647                             "vinum: Can't write config to %s, error %d\n",
 648                             drive->devicename,
 649                             error);
 650                         set_drive_state(drive->driveno, drive_down, setstate_force);
 651                     }
 652                 }
 653             } else                                          /* not worth looking at, */
 654                 unlockdrive(drive);                         /* just unlock it again */
 655         }
 656     }
 657     Free(vhdr);
 658     Free(config);
 659 }
 660
 661 /* Look at all disks on the system for vinum slices */
 662 int
 663 vinum_scandisk(char *devicename[], int drives)
 664 {
 665     struct drive *volatile drive;
 666     volatile int driveno;
 667     volatile int gooddrives;                                /* number of usable drives found */
 668     int firsttime;                                          /* set if we have never configured before */
 669     int error;
 670     char *config_text;                                      /* read the config info from disk into here */
 671     char *volatile cptr;                                    /* pointer into config information */
 672     char *eptr;                                             /* end pointer into config information */
 673     char *config_line;                                      /* copy the config line to */
 674     volatile int status;
 675     int *volatile drivelist;                                /* list of drive indices */
 676 #define DRIVENAMELEN 64
 677 #define DRIVEPARTS   35                                     /* max partitions per drive, excluding c */
 678     char partname[DRIVENAMELEN];                            /* for creating partition names */
 679
 680     status = 0;                                             /* success indication */
 681     vinum_conf.flags |= VF_READING_CONFIG;                  /* reading config from disk */
 682
 683     gooddrives = 0;                                         /* number of usable drives found */
 684     firsttime = vinum_conf.drives_used == 0;                /* are we a virgin? */
 685
 686     /* allocate a drive pointer list */
 687     drivelist = (int *) Malloc(drives * DRIVEPARTS * sizeof(int));
 688     CHECKALLOC(drivelist, "Can't allocate memory");
 689     error = setjmp(command_fail);                           /* come back here on error */
 690     if (error) {                                            /* longjmped out */
 691         return error;
 692     }
 693
 694     /* Open all drives and find which was modified most recently */
 695     for (driveno = 0; driveno < drives; driveno++) {
 696         char part, has_part = 0;                            /* UNIX partition */
 697         int slice;
 698         int founddrive;                                     /* flag when we find a vinum drive */
 699         int has_slice = -1;
 700         char *tmp;
 701
 702         founddrive = 0;                                     /* no vinum drive found yet on this spindle */
 703
 704         /*
 705          * If the device path contains a slice we do not try to tack on
 706          * another slice.  If the device path has a partition we only check
 707          * that partition.
 708          */
 709         if ((tmp = rindex(devicename[driveno], '/')) == NULL)
 710             tmp = devicename[driveno];
 711         else
 712                 tmp++;
 713         ksscanf(tmp, "%*[a-z]%*d%*[s]%d%c", &has_slice, &has_part);
 714
 715         for (slice = 0; slice < MAX_SLICES; slice++) {
 716             if (has_slice >= 0 && slice != has_slice)
 717                 continue;
 718
 719             for (part = 'a'; part < 'a' + MAXPARTITIONS; part++) {
 720                 if (part == 'c')
 721                     continue;
 722                 if (has_part && part != has_part)
 723                     continue;
 724                 if (has_slice >= 0 && has_part)
 725                         strncpy(partname, devicename[driveno], DRIVENAMELEN);
 726                 else if (has_slice >= 0)
 727                         ksnprintf(partname, DRIVENAMELEN,
 728                                 "%s%c", devicename[driveno], part);
 729                 else
 730                         ksnprintf(partname, DRIVENAMELEN,
 731                                 "%ss%d%c", devicename[driveno], slice, part);
 732                 drive = check_drive(partname);      /* try to open it */
 733                 if ((drive->lasterror != 0)                 /* didn't work, */
 734                     ||(drive->state != drive_up))
 735                     free_drive(drive);              /* get rid of it */
 736                 else if (drive->flags & VF_CONFIGURED)  /* already read this config, */
 737                     log(LOG_WARNING,
 738                         "vinum: already read config from %s\n", /* say so */
 739                         drive->label.name);
 740                 else {
 741                     drivelist[gooddrives] = drive->driveno;     /* keep the drive index */
 742                     drive->flags &= ~VF_NEWBORN;            /* which is no longer newly born */
 743                     gooddrives++;
 744                     founddrive++;
 745                 }
 746             }
 747         }
 748     }
 749
 750     if (gooddrives == 0) {
 751         if (firsttime)
 752             log(LOG_WARNING, "vinum: no drives found\n");
 753         else
 754             log(LOG_INFO, "vinum: no additional drives found\n");
 755         return ENOENT;
 756     }
 757     /*
 758      * We now have at least one drive
 759      * open.  Sort them in order of config time
 760      * and merge the config info with what we
 761      * have already.
 762      */
 763     kqsort(drivelist, gooddrives, sizeof(int), drivecmp);
 764     config_text = (char *) Malloc(MAXCONFIG * 2);           /* allocate buffers */
 765     CHECKALLOC(config_text, "Can't allocate memory");
 766     config_line = (char *) Malloc(MAXCONFIGLINE * 2);       /* allocate buffers */
 767     CHECKALLOC(config_line, "Can't allocate memory");
 768     for (driveno = 0; driveno < gooddrives; driveno++) {    /* now include the config */
 769         drive = &DRIVE[drivelist[driveno]];                 /* point to the drive */
 770
 771         if (firsttime && (driveno == 0))                    /* we've never configured before, */
 772             log(LOG_INFO, "vinum: reading configuration from %s\n", drive->devicename);
 773         else
 774             log(LOG_INFO, "vinum: updating configuration from %s\n", drive->devicename);
 775
 776         if (drive->state == drive_up)
 777             /* Read in both copies of the configuration information */
 778             error = read_drive(drive, config_text, MAXCONFIG * 2, VINUM_CONFIG_OFFSET);
 779         else {
 780             error = EIO;
 781             kprintf("vinum_scandisk: %s is %s\n", drive->devicename, drive_state(drive->state));
 782         }
 783
 784         if (error != 0) {
 785             log(LOG_ERR, "vinum: Can't read device %s, error %d\n", drive->devicename, error);
 786             free_drive(drive);                              /* give it back */
 787             status = error;
 788         }
 789         /*
 790          * At this point, check that the two copies
 791          * are the same, and do something useful if
 792          * not.  In particular, consider which is
 793          * newer, and what this means for the
 794          * integrity of the data on the drive.
 795          */
 796         else {
 797             vinum_conf.drives_used++;                       /* another drive in use */
 798             /* Parse the configuration, and add it to the global configuration */
 799             for (cptr = config_text; *cptr != '\0';) {      /* love this style(9) */
 800                 volatile int parse_status;                  /* return value from parse_config */
 801
 802                 for (eptr = config_line; (*cptr != '\n') && (*cptr != '\0');) /* until the end of the line */
 803                     *eptr++ = *cptr++;
 804                 *eptr = '\0';                               /* and delimit */
 805                 if (setjmp(command_fail) == 0) {            /* come back here on error and continue */
 806                     parse_status = parse_config(config_line, &keyword_set, 1); /* parse the config line */
 807                     if (parse_status < 0) {                 /* error in config */
 808                         /*
 809                            * This config should have been parsed in user
 810                            * space.  If we run into problems here, something
 811                            * serious is afoot.  Complain and let the user
 812                            * snarf the config to see what's wrong.
 813                          */
 814                         log(LOG_ERR,
 815                             "vinum: Config error on %s, aborting integration\n",
 816                             drive->devicename);
 817                         free_drive(drive);                  /* give it back */
 818                         status = EINVAL;
 819                     }
 820                 }
 821                 while (*cptr == '\n')
 822                     cptr++;                                 /* skip to next line */
 823             }
 824         }
 825         drive->flags |= VF_CONFIGURED;                      /* read this drive's configuration */
 826     }
 827
 828     Free(config_line);
 829     Free(config_text);
 830     Free(drivelist);
 831     vinum_conf.flags &= ~VF_READING_CONFIG;                 /* no longer reading from disk */
 832     if (status != 0)
 833         kprintf("vinum: couldn't read configuration");
 834     else
 835         updateconfig(VF_READING_CONFIG);                    /* update from disk config */
 836     return status;
 837 }
 838
 839 /*
 840  * Compare the modification dates of the drives, for qsort.
 841  * Return 1 if a < b, 0 if a == b, 01 if a > b: in other
 842  * words, sort backwards.
 843  */
 844 static int
 845 drivecmp(const void *va, const void *vb)
 846 {
 847     const struct drive *a = &DRIVE[*(const int *) va];
 848     const struct drive *b = &DRIVE[*(const int *) vb];
 849
 850     if ((a->label.last_update.tv_sec == b->label.last_update.tv_sec)
 851         && (a->label.last_update.tv_usec == b->label.last_update.tv_usec))
 852         return 0;
 853     else if ((a->label.last_update.tv_sec > b->label.last_update.tv_sec)
 854             || ((a->label.last_update.tv_sec == b->label.last_update.tv_sec)
 855             && (a->label.last_update.tv_usec > b->label.last_update.tv_usec)))
 856         return -1;
 857     else
 858         return 1;
 859 }