kernel: Remove some bogus casts to the own type.
[dragonfly.git] / sys / dev / raid / vinum / vinumrevive.c
CommitLineData
984263bc
MD
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
1f2de5d4
MD
44#include "vinumhdr.h"
45#include "request.h"
984263bc
MD
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
56int
57revive_block(int sdno)
58{
984263bc
MD
59 struct sd *sd;
60 struct plex *plex;
61 struct volume *vol;
62 struct buf *bp;
b13267a5 63 cdev_t dev;
984263bc
MD
64 int error = EAGAIN;
65 int size; /* size of revive block, bytes */
c2fcd54e 66 vinum_off_t plexblkno; /* lblkno in plex */
984263bc
MD
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 */
c2fcd54e 71 vinum_off_t stripeoffset; /* offset in stripe */
984263bc
MD
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;
0d0607d0 89 size = u64min(sd->revive_blocksize >> DEV_BSHIFT, sd->sectors - sd->revived) << DEV_BSHIFT;
984263bc
MD
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. */
0d0607d0 116 size = u64min(size, (plex->stripesize - stripeoffset) << DEV_BSHIFT);
984263bc
MD
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 */
6b08710e 134 break;
984263bc
MD
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 */
e1c944c6
MD
142 bp = getpbuf(&vinum_conf.physbufs); /* Get a buffer */
143 bp->b_data = Malloc(size);
984263bc
MD
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;
54078292 151 bp->b_bio1.bio_offset = (off_t)plexblkno << DEV_BSHIFT; /* start here */
ae8e83e6
MD
152 bp->b_bio1.bio_done = biodone_sync;
153 bp->b_bio1.bio_flags |= BIO_SYNC;
984263bc
MD
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 */
d736a600 161 dev = vol->vol_dev;
984263bc 162 else /* it's an unattached plex */
d736a600 163 dev = PLEX[sd->plexno].plex_dev;
984263bc 164
10f3fee5 165 bp->b_cmd = BUF_CMD_READ;
81b5c339 166 vinumstart(dev, &bp->b_bio1, 1);
ae8e83e6 167 biowait(&bp->b_bio1, "drvrd");
984263bc
MD
168 }
169
170 if (bp->b_flags & B_ERROR)
171 error = bp->b_error;
172 else
173 /* Now write to the subdisk */
174 {
d736a600
MD
175 dev = SD[sdno].sd_dev;
176 KKASSERT(dev != NULL);
e1c944c6 177 bp->b_flags |= B_ORDERED; /* and make this an ordered write */
10f3fee5 178 bp->b_cmd = BUF_CMD_WRITE;
984263bc 179 bp->b_resid = bp->b_bcount;
54078292 180 bp->b_bio1.bio_offset = (off_t)sd->revived << DEV_BSHIFT; /* write it to here */
81b5c339 181 bp->b_bio1.bio_driver_info = dev;
5ad175c9 182 bp->b_bio1.bio_done = biodone_sync;
81b5c339 183 sdio(&bp->b_bio1); /* perform the I/O */
ae8e83e6 184 biowait(&bp->b_bio1, "drvwr");
984263bc
MD
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;
b13267a5 202 cdev_t dev;
984263bc 203
81b5c339
MD
204 if (debug & DEBUG_REVIVECONFLICT) {
205 dev = rq->bio->bio_driver_info;
984263bc 206 log(LOG_DEBUG,
591bdbe9 207 "Relaunch revive conflict sd %d: %p\n%s dev %d.%d, offset 0x%llx, length %d\n",
984263bc
MD
208 rq->sdno,
209 rq,
10f3fee5 210 (rq->bio->bio_buf->b_cmd == BUF_CMD_READ) ? "Read" : "Write",
81b5c339
MD
211 major(dev),
212 minor(dev),
54078292 213 rq->bio->bio_offset,
81b5c339
MD
214 rq->bio->bio_buf->b_bcount);
215 }
984263bc
MD
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 }
e1c944c6
MD
221 Free(bp->b_data);
222 relpbuf(bp, &vinum_conf.physbufs);
984263bc
MD
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 */
247void
248parityops(struct vinum_ioctl_msg *data)
249{
250 int plexno;
251 struct plex *plex;
252 int size; /* I/O transfer size, bytes */
c2fcd54e 253 vinum_off_t stripe; /* stripe number in plex */
984263bc
MD
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 */
0d0607d0 279 size = imin(DEFAULT_REVIVE_BLOCKSIZE, /* one block at a time */
984263bc
MD
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)) {
10f3fee5 296 pbp->b_cmd = BUF_CMD_WRITE;
984263bc 297 pbp->b_resid = pbp->b_bcount;
5ad175c9 298 pbp->b_bio1.bio_done = biodone_sync;
81b5c339 299 sdio(&pbp->b_bio1); /* write the parity block */
ae8e83e6 300 biowait(&pbp->b_bio1, "drvwr");
984263bc
MD
301 }
302 if (((op == checkparity)
303 || (op == rebuildandcheckparity))
304 && (errorloc != -1)) {
305 if (op == checkparity)
306 reply->error = EIO;
f8c7a42d 307 ksprintf(reply->msg,
984263bc 308 "Parity incorrect at offset 0x%llx\n",
5bcacc1c 309 (long long)errorloc);
984263bc
MD
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;
e1c944c6
MD
321 Free(pbp->b_data);
322 relpbuf(pbp, &vinum_conf.physbufs);
984263bc
MD
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 */
348struct buf *
349parityrebuild(struct plex *plex,
c2fcd54e 350 vinum_off_t pstripe,
984263bc
MD
351 int size,
352 enum parityop op,
353 struct rangelock **lockp,
354 off_t * errorloc)
355{
356 int error;
984263bc
MD
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 */
0d0607d0 386 mysize = u64min(size, (plex->stripesize * (stripe + 1) - pstripe) << DEV_BSHIFT);
984263bc
MD
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. */
e1c944c6
MD
396 bpp[sdno] = getpbuf(&vinum_conf.physbufs); /* Get a buffer */
397 bpp[sdno]->b_data = Malloc(mysize);
984263bc
MD
398 if (sdno == psd)
399 parity_buf = (int *) bpp[sdno]->b_data;
400 if (sdno == newpsd) /* the new one? */
d736a600 401 bpp[sdno]->b_bio1.bio_driver_info = SD[plex->sdnos[psd]].sd_dev; /* write back to the parity SD */
984263bc 402 else
d736a600
MD
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);
10f3fee5 405 bpp[sdno]->b_cmd = BUF_CMD_READ; /* either way, read it */
984263bc
MD
406 bpp[sdno]->b_bcount = mysize;
407 bpp[sdno]->b_resid = bpp[sdno]->b_bcount;
54078292 408 bpp[sdno]->b_bio1.bio_offset = (off_t)pstripe << DEV_BSHIFT; /* transfer from here */
5ad175c9 409 bpp[sdno]->b_bio1.bio_done = biodone_sync;
984263bc
MD
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)) {
81b5c339 434 sdio(&bpp[sdno]->b_bio1);
984263bc
MD
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)) {
ae8e83e6 448 biowait(&bpp[sdno]->b_bio1, "drvio");
984263bc
MD
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++)
362298e4 454 newparity_buf[i] ^= sbuf[i]; /* xor in the buffer */
984263bc
MD
455 }
456 }
457 if (sdno != psd) { /* release all bps except parity */
e1c944c6
MD
458 Free(bpp[sdno]->b_data);
459 relpbuf(bpp[sdno], &vinum_conf.physbufs); /* give back our resources */
984263bc
MD
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 }
e1c944c6
MD
479 Free(bpp[psd]->b_data);
480 relpbuf(bpp[psd], &vinum_conf.physbufs); /* give back our resources */
984263bc
MD
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 */
499int
500initsd(int sdno, int verify)
501{
984263bc
MD
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 */
c2fcd54e 508 vinum_off_t plexblkno; /* lblkno in plex */
984263bc
MD
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 */
0d0607d0 524 sd->init_blocksize = u64min(DEFAULT_REVIVE_BLOCKSIZE, /* one block at a time */
984263bc
MD
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
0d0607d0 531 size = u64min(sd->init_blocksize >> DEV_BSHIFT, sd->sectors - sd->initialized) << DEV_BSHIFT;
984263bc 532
e1c944c6
MD
533 bp = getpbuf(&vinum_conf.physbufs); /* Get a buffer */
534 bp->b_data = Malloc(size);
535
984263bc
MD
536 verified = 0;
537 while (!verified) { /* until we're happy with it, */
984263bc
MD
538 bp->b_bcount = size;
539 bp->b_resid = bp->b_bcount;
54078292 540 bp->b_bio1.bio_offset = (off_t)sd->initialized << DEV_BSHIFT; /* write it to here */
d736a600 541 bp->b_bio1.bio_driver_info = SD[sdno].sd_dev;
5ad175c9 542 bp->b_bio1.bio_done = biodone_sync;
d736a600 543 KKASSERT(bp->b_bio1.bio_driver_info);
984263bc 544 bzero(bp->b_data, bp->b_bcount);
10f3fee5 545 bp->b_cmd = BUF_CMD_WRITE;
81b5c339 546 sdio(&bp->b_bio1); /* perform the I/O */
ae8e83e6 547 biowait(&bp->b_bio1, "drvwr");
984263bc
MD
548 if (bp->b_flags & B_ERROR)
549 error = bp->b_error;
984263bc 550 if ((error == 0) && verify) { /* check that it got there */
e1c944c6
MD
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 */
d736a600 554 bp->b_bio1.bio_driver_info = SD[sdno].sd_dev;
5ad175c9 555 bp->b_bio1.bio_done = biodone_sync;
d736a600 556 KKASSERT(bp->b_bio1.bio_driver_info);
e1c944c6
MD
557 bp->b_cmd = BUF_CMD_READ; /* read it back */
558 sdio(&bp->b_bio1);
ae8e83e6 559 biowait(&bp->b_bio1, "drvrd");
e1c944c6
MD
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 */
e3869ec7 568 kprintf("vinum: init error on %s, offset 0x%llx sectors\n",
e1c944c6
MD
569 sd->name,
570 (long long) sd->initialized);
571 verified = 0;
572 } else
573 verified = 1;
984263bc
MD
574 } else
575 verified = 1;
576 }
e1c944c6
MD
577 Free(bp->b_data);
578 relpbuf(bp, &vinum_conf.physbufs);
984263bc
MD
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}
591
592/* Local Variables: */
593/* fill-column: 50 */
594/* End: */