sys/dev/raid/vinum/vinumrevive.c

   1 /*-
   2  * Copyright (c) 1997, 1998, 1999
   3  *      Nan Yang Computer Services Limited.  All rights reserved.
   4  *
   5  *  Parts copyright (c) 1997, 1998 Cybernet Corporation, NetMAX project.
   6  *
   7  *  Written by Greg Lehey
   8  *
   9  *  This software is distributed under the so-called ``Berkeley
  10  *  License'':
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  * 3. All advertising materials mentioning features or use of this software
  21  *    must display the following acknowledgement:
  22  *      This product includes software developed by Nan Yang Computer
  23  *      Services Limited.
  24  * 4. Neither the name of the Company nor the names of its contributors
  25  *    may be used to endorse or promote products derived from this software
  26  *    without specific prior written permission.
  27  *
  28  * This software is provided ``as is'', and any express or implied
  29  * warranties, including, but not limited to, the implied warranties of
  30  * merchantability and fitness for a particular purpose are disclaimed.
  31  * In no event shall the company or contributors be liable for any
  32  * direct, indirect, incidental, special, exemplary, or consequential
  33  * damages (including, but not limited to, procurement of substitute
  34  * goods or services; loss of use, data, or profits; or business
  35  * interruption) however caused and on any theory of liability, whether
  36  * in contract, strict liability, or tort (including negligence or
  37  * otherwise) arising in any way out of the use of this software, even if
  38  * advised of the possibility of such damage.
  39  *
  40  * $Id: vinumrevive.c,v 1.14 2000/12/21 01:55:11 grog Exp grog $
  41  * $FreeBSD: src/sys/dev/vinum/vinumrevive.c,v 1.22.2.5 2001/03/13 02:59:43 grog Exp $
  42  */
  43
  44 #include "vinumhdr.h"
  45 #include "request.h"
  46
  47 /*
  48  * Revive a block of a subdisk.  Return an error
  49  * indication.  EAGAIN means successful copy, but
  50  * that more blocks remain to be copied.  EINVAL
  51  * means that the subdisk isn't associated with a
  52  * plex (which means a programming error if we get
  53  * here at all; FIXME).
  54  */
  55
  56 int
  57 revive_block(int sdno)
  58 {
  59     struct sd *sd;
  60     struct plex *plex;
  61     struct volume *vol;
  62     struct buf *bp;
  63     cdev_t dev;
  64     int error = EAGAIN;
  65     int size;                                               /* size of revive block, bytes */
  66     vinum_off_t plexblkno;                                          /* lblkno in plex */
  67     int psd;                                                /* parity subdisk number */
  68     u_int64_t stripe;                                       /* stripe number */
  69     int paritysd = 0;                                       /* set if this is the parity stripe */
  70     struct rangelock *lock;                                 /* for locking */
  71     vinum_off_t stripeoffset;                               /* offset in stripe */
  72
  73     plexblkno = 0;                                          /* to keep the compiler happy */
  74     sd = &SD[sdno];
  75     lock = NULL;
  76     if (sd->plexno < 0)                                     /* no plex? */
  77         return EINVAL;
  78     plex = &PLEX[sd->plexno];                               /* point to plex */
  79     if (plex->volno >= 0)
  80         vol = &VOL[plex->volno];
  81     else
  82         vol = NULL;
  83
  84     if ((sd->revive_blocksize == 0)                         /* no block size */
  85     ||(sd->revive_blocksize & ((1 << DEV_BSHIFT) - 1)))     /* or invalid block size */
  86         sd->revive_blocksize = DEFAULT_REVIVE_BLOCKSIZE;
  87     else if (sd->revive_blocksize > MAX_REVIVE_BLOCKSIZE)
  88         sd->revive_blocksize = MAX_REVIVE_BLOCKSIZE;
  89     size = u64min(sd->revive_blocksize >> DEV_BSHIFT, sd->sectors - sd->revived) << DEV_BSHIFT;
  90     sd->reviver = curproc->p_pid;                           /* note who last had a bash at it */
  91
  92     /* Now decide where to read from */
  93     switch (plex->organization) {
  94     case plex_concat:
  95         plexblkno = sd->revived + sd->plexoffset;           /* corresponding address in plex */
  96         break;
  97
  98     case plex_striped:
  99         stripeoffset = sd->revived % plex->stripesize;      /* offset from beginning of stripe */
 100         if (stripeoffset + (size >> DEV_BSHIFT) > plex->stripesize)
 101             size = (plex->stripesize - stripeoffset) << DEV_BSHIFT;
 102         plexblkno = sd->plexoffset                          /* base */
 103             + (sd->revived - stripeoffset) * plex->subdisks /* offset to beginning of stripe */
 104             + stripeoffset;                                 /* offset from beginning of stripe */
 105         break;
 106
 107     case plex_raid4:
 108     case plex_raid5:
 109         stripeoffset = sd->revived % plex->stripesize;      /* offset from beginning of stripe */
 110         plexblkno = sd->plexoffset                          /* base */
 111             + (sd->revived - stripeoffset) * (plex->subdisks - 1) /* offset to beginning of stripe */
 112             +stripeoffset;                                  /* offset from beginning of stripe */
 113         stripe = (sd->revived / plex->stripesize);          /* stripe number */
 114
 115         /* Make sure we don't go beyond the end of the band. */
 116         size = u64min(size, (plex->stripesize - stripeoffset) << DEV_BSHIFT);
 117         if (plex->organization == plex_raid4)
 118             psd = plex->subdisks - 1;                       /* parity subdisk for this stripe */
 119         else
 120             psd = plex->subdisks - 1 - stripe % plex->subdisks; /* parity subdisk for this stripe */
 121         paritysd = plex->sdnos[psd] == sdno;                /* note if it's the parity subdisk */
 122
 123         /*
 124          * Now adjust for the strangenesses
 125          * in RAID-4 and RAID-5 striping.
 126          */
 127         if (sd->plexsdno > psd)                             /* beyond the parity stripe, */
 128             plexblkno -= plex->stripesize;                  /* one stripe less */
 129         else if (paritysd)
 130             plexblkno -= plex->stripesize * sd->plexsdno;   /* go back to the beginning of the band */
 131         break;
 132
 133     case plex_disorg:                                       /* to keep the compiler happy */
 134         break;
 135     }
 136
 137     if (paritysd) {                                         /* we're reviving a parity block, */
 138         bp = parityrebuild(plex, sd->revived, size, rebuildparity, &lock, NULL); /* do the grunt work */
 139         if (bp == NULL)                                     /* no buffer space */
 140             return ENOMEM;                                  /* chicken out */
 141     } else {                                                /* data block */
 142         bp = getpbuf(&vinum_conf.physbufs);                 /* Get a buffer */
 143         bp->b_data = Malloc(size);
 144
 145         /*
 146          * Amount to transfer: block size, unless it
 147          * would overlap the end.
 148          */
 149         bp->b_bcount = size;
 150         bp->b_resid = bp->b_bcount;
 151         bp->b_bio1.bio_offset = (off_t)plexblkno << DEV_BSHIFT;             /* start here */
 152         bp->b_bio1.bio_done = biodone_sync;
 153         bp->b_bio1.bio_flags |= BIO_SYNC;
 154         if (isstriped(plex))                                /* we need to lock striped plexes */
 155             lock = lockrange(plexblkno << DEV_BSHIFT, bp, plex); /* lock it */
 156         if (vol != NULL)                                    /* it's part of a volume, */
 157             /*
 158                * First, read the data from the volume.  We
 159                * don't care which plex, that's bre's job.
 160              */
 161             dev = vol->vol_dev;
 162         else                                                /* it's an unattached plex */
 163             dev = PLEX[sd->plexno].plex_dev;
 164
 165         bp->b_cmd = BUF_CMD_READ;
 166         vinumstart(dev, &bp->b_bio1, 1);
 167         biowait(&bp->b_bio1, "drvrd");
 168     }
 169
 170     if (bp->b_flags & B_ERROR)
 171         error = bp->b_error;
 172     else
 173         /* Now write to the subdisk */
 174     {
 175         dev = SD[sdno].sd_dev;
 176         KKASSERT(dev != NULL);
 177         bp->b_flags |= B_ORDERED;                   /* and make this an ordered write */
 178         bp->b_cmd = BUF_CMD_WRITE;
 179         bp->b_resid = bp->b_bcount;
 180         bp->b_bio1.bio_offset = (off_t)sd->revived << DEV_BSHIFT;                   /* write it to here */
 181         bp->b_bio1.bio_driver_info = dev;
 182         bp->b_bio1.bio_done = biodone_sync;
 183         sdio(&bp->b_bio1);                                  /* perform the I/O */
 184         biowait(&bp->b_bio1, "drvwr");
 185         if (bp->b_flags & B_ERROR)
 186             error = bp->b_error;
 187         else {
 188             sd->revived += bp->b_bcount >> DEV_BSHIFT;      /* moved this much further down */
 189             if (sd->revived >= sd->sectors) {               /* finished */
 190                 sd->revived = 0;
 191                 set_sd_state(sdno, sd_up, setstate_force);  /* bring the sd up */
 192                 log(LOG_INFO, "vinum: %s is %s\n", sd->name, sd_state(sd->state));
 193                 save_config();                              /* and save the updated configuration */
 194                 error = 0;                                  /* we're done */
 195             }
 196         }
 197         if (lock)                                           /* we took a lock, */
 198             unlockrange(sd->plexno, lock);                  /* give it back */
 199         while (sd->waitlist) {                              /* we have waiting requests */
 200 #if VINUMDEBUG
 201             struct request *rq = sd->waitlist;
 202             cdev_t dev;
 203
 204             if (debug & DEBUG_REVIVECONFLICT) {
 205                 dev = rq->bio->bio_driver_info;
 206                 log(LOG_DEBUG,
 207                     "Relaunch revive conflict sd %d: %p\n%s dev %d.%d, offset 0x%llx, length %d\n",
 208                     rq->sdno,
 209                     rq,
 210                     (rq->bio->bio_buf->b_cmd == BUF_CMD_READ) ? "Read" : "Write",
 211                     major(dev),
 212                     minor(dev),
 213                     rq->bio->bio_offset,
 214                     rq->bio->bio_buf->b_bcount);
 215             }
 216 #endif
 217             launch_requests(sd->waitlist, 1);               /* do them now */
 218             sd->waitlist = sd->waitlist->next;              /* and move on to the next */
 219         }
 220     }
 221     Free(bp->b_data);
 222     relpbuf(bp, &vinum_conf.physbufs);
 223     return error;
 224 }
 225
 226 /*
 227  * Check or rebuild the parity blocks of a RAID-4
 228  * or RAID-5 plex.
 229  *
 230  * The variables plex->checkblock and
 231  * plex->rebuildblock represent the
 232  * subdisk-relative address of the stripe we're
 233  * looking at, not the plex-relative address.  We
 234  * store it in the plex and not as a local
 235  * variable because this function could be
 236  * stopped, and we don't want to repeat the part
 237  * we've already done.  This is also the reason
 238  * why we don't initialize it here except at the
 239  * end.  It gets initialized with the plex on
 240  * creation.
 241  *
 242  * Each call to this function processes at most
 243  * one stripe.  We can't loop in this function,
 244  * because we're unstoppable, so we have to be
 245  * called repeatedly from userland.
 246  */
 247 void
 248 parityops(struct vinum_ioctl_msg *data)
 249 {
 250     int plexno;
 251     struct plex *plex;
 252     int size;                                               /* I/O transfer size, bytes */
 253     vinum_off_t stripe;                                             /* stripe number in plex */
 254     int psd;                                                /* parity subdisk number */
 255     struct rangelock *lock;                                 /* lock on stripe */
 256     struct _ioctl_reply *reply;
 257     off_t pstripe;                                          /* pointer to our stripe counter */
 258     struct buf *pbp;
 259     off_t errorloc;                                         /* offset of parity error */
 260     enum parityop op;                                       /* operation to perform */
 261
 262     plexno = data->index;
 263     op = data->op;
 264     pbp = NULL;
 265     reply = (struct _ioctl_reply *) data;
 266     reply->error = EAGAIN;                                  /* expect to repeat this call */
 267     plex = &PLEX[plexno];
 268     if (!isparity(plex)) {                                  /* not RAID-4 or RAID-5 */
 269         reply->error = EINVAL;
 270         return;
 271     } else if (plex->state < plex_flaky) {
 272         reply->error = EIO;
 273         strcpy(reply->msg, "Plex is not completely accessible\n");
 274         return;
 275     }
 276     pstripe = data->offset;
 277     stripe = pstripe / plex->stripesize;                    /* stripe number */
 278     psd = plex->subdisks - 1 - stripe % plex->subdisks;     /* parity subdisk for this stripe */
 279     size = imin(DEFAULT_REVIVE_BLOCKSIZE,                   /* one block at a time */
 280         plex->stripesize << DEV_BSHIFT);
 281
 282     pbp = parityrebuild(plex, pstripe, size, op, &lock, &errorloc); /* do the grunt work */
 283     if (pbp == NULL) {                                      /* no buffer space */
 284         reply->error = ENOMEM;
 285         return;                                             /* chicken out */
 286     }
 287     /*
 288      * Now we have a result in the data buffer of
 289      * the parity buffer header, which we have kept.
 290      * Decide what to do with it.
 291      */
 292     reply->msg[0] = '\0';                                   /* until shown otherwise */
 293     if ((pbp->b_flags & B_ERROR) == 0) {                    /* no error */
 294         if ((op == rebuildparity)
 295             || (op == rebuildandcheckparity)) {
 296             pbp->b_cmd = BUF_CMD_WRITE;
 297             pbp->b_resid = pbp->b_bcount;
 298             pbp->b_bio1.bio_done = biodone_sync;
 299             sdio(&pbp->b_bio1);                             /* write the parity block */
 300             biowait(&pbp->b_bio1, "drvwr");
 301         }
 302         if (((op == checkparity)
 303                 || (op == rebuildandcheckparity))
 304             && (errorloc != -1)) {
 305             if (op == checkparity)
 306                 reply->error = EIO;
 307             ksprintf(reply->msg,
 308                 "Parity incorrect at offset 0x%llx\n",
 309                 (long long)errorloc);
 310         }
 311         if (reply->error == EAGAIN) {                       /* still OK, */
 312             plex->checkblock = pstripe + (pbp->b_bcount >> DEV_BSHIFT); /* moved this much further down */
 313             if (plex->checkblock >= SD[plex->sdnos[0]].sectors) { /* finished */
 314                 plex->checkblock = 0;
 315                 reply->error = 0;
 316             }
 317         }
 318     }
 319     if (pbp->b_flags & B_ERROR)
 320         reply->error = pbp->b_error;
 321     Free(pbp->b_data);
 322     relpbuf(pbp, &vinum_conf.physbufs);
 323     unlockrange(plexno, lock);
 324 }
 325
 326 /*
 327  * Rebuild a parity stripe.  Return pointer to
 328  * parity bp.  On return,
 329  *
 330  * 1.  The band is locked.  The caller must unlock
 331  *     the band and release the buffer header.
 332  *
 333  * 2.  All buffer headers except php have been
 334  *     released.  The caller must release pbp.
 335  *
 336  * 3.  For checkparity and rebuildandcheckparity,
 337  *     the parity is compared with the current
 338  *     parity block.  If it's different, the
 339  *     offset of the error is returned to
 340  *     errorloc.  The caller can set the value of
 341  *     the pointer to NULL if this is called for
 342  *     rebuilding parity.
 343  *
 344  * pstripe is the subdisk-relative base address of
 345  * the data to be reconstructed, size is the size
 346  * of the transfer in bytes.
 347  */
 348 struct buf *
 349 parityrebuild(struct plex *plex,
 350     vinum_off_t pstripe,
 351     int size,
 352     enum parityop op,
 353     struct rangelock **lockp,
 354     off_t * errorloc)
 355 {
 356     int error;
 357     int sdno;
 358     u_int64_t stripe;                                       /* stripe number */
 359     int *parity_buf;                                        /* buffer address for current parity block */
 360     int *newparity_buf;                                     /* and for new parity block */
 361     int mysize;                                             /* I/O transfer size for this transfer */
 362     int isize;                                              /* mysize in ints */
 363     int i;
 364     int psd;                                                /* parity subdisk number */
 365     int newpsd;                                             /* and "subdisk number" of new parity */
 366     struct buf **bpp;                                       /* pointers to our bps */
 367     struct buf *pbp;                                        /* buffer header for parity stripe */
 368     int *sbuf;
 369     int bufcount;                                           /* number of buffers we need */
 370
 371     stripe = pstripe / plex->stripesize;                    /* stripe number */
 372     psd = plex->subdisks - 1 - stripe % plex->subdisks;     /* parity subdisk for this stripe */
 373     parity_buf = NULL;                                      /* to keep the compiler happy */
 374     error = 0;
 375
 376     /*
 377      * It's possible that the default transfer size
 378      * we chose is not a factor of the stripe size.
 379      * We *must* limit this operation to a single
 380      * stripe, at least for RAID-5 rebuild, since
 381      * the parity subdisk changes between stripes,
 382      * so in this case we need to perform a short
 383      * transfer.  Set variable mysize to reflect
 384      * this.
 385      */
 386     mysize = u64min(size, (plex->stripesize * (stripe + 1) - pstripe) << DEV_BSHIFT);
 387     isize = mysize / (sizeof(int));                         /* number of ints in the buffer */
 388     bufcount = plex->subdisks + 1;                          /* sd buffers plus result buffer */
 389     newpsd = plex->subdisks;
 390     bpp = (struct buf **) Malloc(bufcount * sizeof(struct buf *)); /* array of pointers to bps */
 391
 392     /* First, build requests for all subdisks */
 393     for (sdno = 0; sdno < bufcount; sdno++) {               /* for each subdisk */
 394         if ((sdno != psd) || (op != rebuildparity)) {
 395             /* Get a buffer header and initialize it. */
 396             bpp[sdno] = getpbuf(&vinum_conf.physbufs);      /* Get a buffer */
 397             bpp[sdno]->b_data = Malloc(mysize);
 398             if (sdno == psd)
 399                 parity_buf = (int *) bpp[sdno]->b_data;
 400             if (sdno == newpsd)                             /* the new one? */
 401                 bpp[sdno]->b_bio1.bio_driver_info = SD[plex->sdnos[psd]].sd_dev; /* write back to the parity SD */
 402             else
 403                 bpp[sdno]->b_bio1.bio_driver_info = SD[plex->sdnos[sdno]].sd_dev;       /* device number */
 404             KKASSERT(bpp[sdno]->b_bio1.bio_driver_info);
 405             bpp[sdno]->b_cmd = BUF_CMD_READ;        /* either way, read it */
 406             bpp[sdno]->b_bcount = mysize;
 407             bpp[sdno]->b_resid = bpp[sdno]->b_bcount;
 408             bpp[sdno]->b_bio1.bio_offset = (off_t)pstripe << DEV_BSHIFT;            /* transfer from here */
 409             bpp[sdno]->b_bio1.bio_done = biodone_sync;
 410         }
 411     }
 412
 413     /* Initialize result buffer */
 414     pbp = bpp[newpsd];
 415     newparity_buf = (int *) bpp[newpsd]->b_data;
 416     bzero(newparity_buf, mysize);
 417
 418     /*
 419      * Now lock the stripe with the first non-parity
 420      * bp as locking bp.
 421      */
 422     *lockp = lockrange(pstripe * plex->stripesize * (plex->subdisks - 1),
 423         bpp[psd ? 0 : 1],
 424         plex);
 425
 426     /*
 427      * Then issue requests for all subdisks in
 428      * parallel.  Don't transfer the parity stripe
 429      * if we're rebuilding parity, unless we also
 430      * want to check it.
 431      */
 432     for (sdno = 0; sdno < plex->subdisks; sdno++) {         /* for each real subdisk */
 433         if ((sdno != psd) || (op != rebuildparity)) {
 434             sdio(&bpp[sdno]->b_bio1);
 435         }
 436     }
 437
 438     /*
 439      * Next, wait for the requests to complete.
 440      * We wait in the order in which they were
 441      * issued, which isn't necessarily the order in
 442      * which they complete, but we don't have a
 443      * convenient way of doing the latter, and the
 444      * delay is minimal.
 445      */
 446     for (sdno = 0; sdno < plex->subdisks; sdno++) {         /* for each subdisk */
 447         if ((sdno != psd) || (op != rebuildparity)) {
 448             biowait(&bpp[sdno]->b_bio1, "drvio");
 449             if (bpp[sdno]->b_flags & B_ERROR)               /* can't read, */
 450                 error = bpp[sdno]->b_error;
 451             else if (sdno != psd) {                         /* update parity */
 452                 sbuf = (int *) bpp[sdno]->b_data;
 453                 for (i = 0; i < isize; i++)
 454                     newparity_buf[i] ^= sbuf[i];            /* xor in the buffer */
 455             }
 456         }
 457         if (sdno != psd) {                                  /* release all bps except parity */
 458             Free(bpp[sdno]->b_data);
 459             relpbuf(bpp[sdno], &vinum_conf.physbufs);       /* give back our resources */
 460         }
 461     }
 462
 463     /*
 464      * If we're checking, compare the calculated
 465      * and the read parity block.  If they're
 466      * different, return the plex-relative offset;
 467      * otherwise return -1.
 468      */
 469     if ((op == checkparity)
 470         || (op == rebuildandcheckparity)) {
 471         *errorloc = -1;                                     /* no error yet */
 472         for (i = 0; i < isize; i++) {
 473             if (parity_buf[i] != newparity_buf[i]) {
 474                 *errorloc = (off_t) (pstripe << DEV_BSHIFT) * (plex->subdisks - 1)
 475                     + i * sizeof(int);
 476                 break;
 477             }
 478         }
 479         Free(bpp[psd]->b_data);
 480         relpbuf(bpp[psd], &vinum_conf.physbufs);            /* give back our resources */
 481     }
 482     /* release our resources */
 483     Free(bpp);
 484     if (error) {
 485         pbp->b_flags |= B_ERROR;
 486         pbp->b_error = error;
 487     }
 488     return pbp;
 489 }
 490
 491 /*
 492  * Initialize a subdisk by writing zeroes to the
 493  * complete address space.  If verify is set,
 494  * check each transfer for correctness.
 495  *
 496  * Each call to this function writes (and maybe
 497  * checks) a single block.
 498  */
 499 int
 500 initsd(int sdno, int verify)
 501 {
 502     struct sd *sd;
 503     struct plex *plex;
 504     struct volume *vol;
 505     struct buf *bp;
 506     int error;
 507     int size;                                               /* size of init block, bytes */
 508     vinum_off_t plexblkno;                                          /* lblkno in plex */
 509     int verified;                                           /* set when we're happy with what we wrote */
 510
 511     error = 0;
 512     plexblkno = 0;                                          /* to keep the compiler happy */
 513     sd = &SD[sdno];
 514     if (sd->plexno < 0)                                     /* no plex? */
 515         return EINVAL;
 516     plex = &PLEX[sd->plexno];                               /* point to plex */
 517     if (plex->volno >= 0)
 518         vol = &VOL[plex->volno];
 519     else
 520         vol = NULL;
 521
 522     if (sd->init_blocksize == 0) {
 523         if (plex->stripesize != 0)                          /* we're striped, don't init more than */
 524             sd->init_blocksize = u64min(DEFAULT_REVIVE_BLOCKSIZE, /* one block at a time */
 525                 plex->stripesize << DEV_BSHIFT);
 526         else
 527             sd->init_blocksize = DEFAULT_REVIVE_BLOCKSIZE;
 528     } else if (sd->init_blocksize > MAX_REVIVE_BLOCKSIZE)
 529         sd->init_blocksize = MAX_REVIVE_BLOCKSIZE;
 530
 531     size = u64min(sd->init_blocksize >> DEV_BSHIFT, sd->sectors - sd->initialized) << DEV_BSHIFT;
 532
 533     bp = getpbuf(&vinum_conf.physbufs);             /* Get a buffer */
 534     bp->b_data = Malloc(size);
 535
 536     verified = 0;
 537     while (!verified) {                                     /* until we're happy with it, */
 538         bp->b_bcount = size;
 539         bp->b_resid = bp->b_bcount;
 540         bp->b_bio1.bio_offset = (off_t)sd->initialized << DEV_BSHIFT;               /* write it to here */
 541         bp->b_bio1.bio_driver_info = SD[sdno].sd_dev;
 542         bp->b_bio1.bio_done = biodone_sync;
 543         KKASSERT(bp->b_bio1.bio_driver_info);
 544         bzero(bp->b_data, bp->b_bcount);
 545         bp->b_cmd = BUF_CMD_WRITE;
 546         sdio(&bp->b_bio1);                  /* perform the I/O */
 547         biowait(&bp->b_bio1, "drvwr");
 548         if (bp->b_flags & B_ERROR)
 549             error = bp->b_error;
 550         if ((error == 0) && verify) {                       /* check that it got there */
 551             bp->b_bcount = size;
 552             bp->b_resid = bp->b_bcount;
 553             bp->b_bio1.bio_offset = (off_t)sd->initialized << DEV_BSHIFT;           /* read from here */
 554             bp->b_bio1.bio_driver_info = SD[sdno].sd_dev;
 555             bp->b_bio1.bio_done = biodone_sync;
 556             KKASSERT(bp->b_bio1.bio_driver_info);
 557             bp->b_cmd = BUF_CMD_READ;               /* read it back */
 558             sdio(&bp->b_bio1);
 559             biowait(&bp->b_bio1, "drvrd");
 560             /*
 561              * XXX Bug fix code.  This is hopefully no
 562              * longer needed (21 February 2000).
 563              */
 564             if (bp->b_flags & B_ERROR)
 565                 error = bp->b_error;
 566             else if ((*bp->b_data != 0)             /* first word spammed */
 567             ||(bcmp(bp->b_data, &bp->b_data[1], bp->b_bcount - 1))) { /* or one of the others */
 568                 kprintf("vinum: init error on %s, offset 0x%llx sectors\n",
 569                     sd->name,
 570                     (long long) sd->initialized);
 571                 verified = 0;
 572             } else
 573                 verified = 1;
 574         } else
 575             verified = 1;
 576     }
 577     Free(bp->b_data);
 578     relpbuf(bp, &vinum_conf.physbufs);
 579     if (error == 0) {                                       /* did it, */
 580         sd->initialized += size >> DEV_BSHIFT;              /* moved this much further down */
 581         if (sd->initialized >= sd->sectors) {               /* finished */
 582             sd->initialized = 0;
 583             set_sd_state(sdno, sd_initialized, setstate_force); /* bring the sd up */
 584             log(LOG_INFO, "vinum: %s is %s\n", sd->name, sd_state(sd->state));
 585             save_config();                                  /* and save the updated configuration */
 586         } else                                              /* more to go, */
 587             error = EAGAIN;                                 /* ya'll come back, see? */
 588     }
 589     return error;
 590 }