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.2 2003/11/25 20:11:59 jdolecek Exp $
41 * $FreeBSD$
42 */
43
44 #include <dev/vinum/vinumhdr.h>
45 #include <dev/vinum/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 int s; /* priority level */
60 struct sd *sd;
61 struct plex *plex;
62 struct volume *vol;
63 struct buf *bp;
64 int error = EAGAIN;
65 int size; /* size of revive block, bytes */
66 daddr_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 daddr_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 = min(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 = min(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 s = splbio();
143 bp = geteblk(size); /* Get a buffer */
144 splx(s);
145 if (bp == NULL)
146 return ENOMEM;
147
148 /*
149 * Amount to transfer: block size, unless it
150 * would overlap the end.
151 */
152 bp->b_bcount = size;
153 bp->b_resid = bp->b_bcount;
154 bp->b_blkno = plexblkno; /* start here */
155 if (isstriped(plex)) /* we need to lock striped plexes */
156 lock = lockrange(plexblkno << DEV_BSHIFT, bp, plex); /* lock it */
157 if (vol != NULL) /* it's part of a volume, */
158 /*
159 * First, read the data from the volume. We
160 * don't care which plex, that's bre's job.
161 */
162 bp->b_dev = VINUM_VOL(plex->volno); /* create the device number */
163 else /* it's an unattached plex */
164 bp->b_dev = VINUM_PLEX(sd->plexno); /* create the device number */
165
166 bp->b_flags = B_BUSY | B_READ; /* either way, read it */
167 vinumstart(bp, 1);
168 biowait(bp);
169 }
170
171 if (bp->b_flags & B_ERROR) {
172 error = bp->b_error;
173 if (lock) /* we took a lock, */
174 unlockrange(sd->plexno, lock); /* give it back */
175 } else
176 /* Now write to the subdisk */
177 {
178 bp->b_dev = VINUM_SD(sdno); /* create the device number */
179 bp->b_flags = B_BUSY | B_WRITE; /* and make this a write */
180 bp->b_resid = bp->b_bcount;
181 bp->b_blkno = sd->revived; /* write it to here */
182 sdio(bp); /* perform the I/O */
183 biowait(bp);
184 if (bp->b_flags & B_ERROR)
185 error = bp->b_error;
186 else {
187 sd->revived += bp->b_bcount >> DEV_BSHIFT; /* moved this much further down */
188 if (sd->revived >= sd->sectors) { /* finished */
189 sd->revived = 0;
190 set_sd_state(sdno, sd_up, setstate_force); /* bring the sd up */
191 log(LOG_INFO, "vinum: %s is %s\n", sd->name, sd_state(sd->state));
192 save_config(); /* and save the updated configuration */
193 error = 0; /* we're done */
194 }
195 }
196 if (lock) /* we took a lock, */
197 unlockrange(sd->plexno, lock); /* give it back */
198 while (sd->waitlist) { /* we have waiting requests */
199 #ifdef VINUMDEBUG
200 struct request *rq = sd->waitlist;
201
202 if (debug & DEBUG_REVIVECONFLICT)
203 log(LOG_DEBUG,
204 "Relaunch revive conflict sd %d: %p\n%s dev %d.%d, offset 0x%llx, length %ld\n",
205 rq->sdno,
206 rq,
207 rq->bp->b_flags & B_READ ? "Read" : "Write",
208 major(rq->bp->b_dev),
209 minor(rq->bp->b_dev),
210 rq->bp->b_blkno,
211 rq->bp->b_bcount);
212 #endif
213 launch_requests(sd->waitlist, 1); /* do them now */
214 sd->waitlist = sd->waitlist->next; /* and move on to the next */
215 }
216 }
217 bp->b_flags &= ~B_ERROR;
218 bp->b_flags |= B_INVAL;
219 brelse(bp); /* is this kosher? */
220 return error;
221 }
222
223 /*
224 * Check or rebuild the parity blocks of a RAID-4
225 * or RAID-5 plex.
226 *
227 * The variables plex->checkblock and
228 * plex->rebuildblock represent the
229 * subdisk-relative address of the stripe we're
230 * looking at, not the plex-relative address. We
231 * store it in the plex and not as a local
232 * variable because this function could be
233 * stopped, and we don't want to repeat the part
234 * we've already done. This is also the reason
235 * why we don't initialize it here except at the
236 * end. It gets initialized with the plex on
237 * creation.
238 *
239 * Each call to this function processes at most
240 * one stripe. We can't loop in this function,
241 * because we're unstoppable, so we have to be
242 * called repeatedly from userland.
243 */
244 void
245 parityops(struct vinum_ioctl_msg *data)
246 {
247 int plexno;
248 struct plex *plex;
249 int size; /* I/O transfer size, bytes */
250 int stripe; /* stripe number in plex */
251 int psd; /* parity subdisk number */
252 struct rangelock *lock; /* lock on stripe */
253 struct _ioctl_reply *reply;
254 off_t pstripe; /* pointer to our stripe counter */
255 struct buf *pbp;
256 off_t errorloc; /* offset of parity error */
257 enum parityop op; /* operation to perform */
258
259 plexno = data->index;
260 op = data->op;
261 pbp = NULL;
262 reply = (struct _ioctl_reply *) data;
263 reply->error = EAGAIN; /* expect to repeat this call */
264 plex = &PLEX[plexno];
265 if (!isparity(plex)) { /* not RAID-4 or RAID-5 */
266 reply->error = EINVAL;
267 return;
268 } else if (plex->state < plex_flaky) {
269 reply->error = EIO;
270 strcpy(reply->msg, "Plex is not completely accessible\n");
271 return;
272 }
273 pstripe = data->offset;
274 stripe = pstripe / plex->stripesize; /* stripe number */
275 psd = plex->subdisks - 1 - stripe % plex->subdisks; /* parity subdisk for this stripe */
276 size = min(DEFAULT_REVIVE_BLOCKSIZE, /* one block at a time */
277 plex->stripesize << DEV_BSHIFT);
278
279 pbp = parityrebuild(plex, pstripe, size, op, &lock, &errorloc); /* do the grunt work */
280 if (pbp == NULL) { /* no buffer space */
281 reply->error = ENOMEM;
282 return; /* chicken out */
283 }
284 /*
285 * Now we have a result in the data buffer of
286 * the parity buffer header, which we have kept.
287 * Decide what to do with it.
288 */
289 reply->msg[0] = '\0'; /* until shown otherwise */
290 if ((pbp->b_flags & B_ERROR) == 0) { /* no error */
291 if ((op == rebuildparity)
292 || (op == rebuildandcheckparity)) {
293 pbp->b_flags &= ~B_READ;
294 pbp->b_resid = pbp->b_bcount;
295 sdio(pbp); /* write the parity block */
296 biowait(pbp);
297 }
298 if (((op == checkparity)
299 || (op == rebuildandcheckparity))
300 && (errorloc != -1)) {
301 if (op == checkparity)
302 reply->error = EIO;
303 sprintf(reply->msg,
304 "Parity incorrect at offset 0x%llx\n",
305 (long long int) errorloc);
306 }
307 if (reply->error == EAGAIN) { /* still OK, */
308 plex->checkblock = pstripe + (pbp->b_bcount >> DEV_BSHIFT); /* moved this much further down */
309 if (plex->checkblock >= SD[plex->sdnos[0]].sectors) { /* finished */
310 plex->checkblock = 0;
311 reply->error = 0;
312 }
313 }
314 }
315 if (pbp->b_flags & B_ERROR)
316 reply->error = pbp->b_error;
317 pbp->b_flags |= B_INVAL;
318 pbp->b_flags &= ~B_ERROR;
319 brelse(pbp);
320 unlockrange(plexno, lock);
321 }
322
323 /*
324 * Rebuild a parity stripe. Return pointer to
325 * parity bp. On return,
326 *
327 * 1. The band is locked. The caller must unlock
328 * the band and release the buffer header.
329 *
330 * 2. All buffer headers except php have been
331 * released. The caller must release pbp.
332 *
333 * 3. For checkparity and rebuildandcheckparity,
334 * the parity is compared with the current
335 * parity block. If it's different, the
336 * offset of the error is returned to
337 * errorloc. The caller can set the value of
338 * the pointer to NULL if this is called for
339 * rebuilding parity.
340 *
341 * pstripe is the subdisk-relative base address of
342 * the data to be reconstructed, size is the size
343 * of the transfer in bytes.
344 */
345 struct buf *
346 parityrebuild(struct plex *plex,
347 u_int64_t pstripe,
348 int size,
349 enum parityop op,
350 struct rangelock **lockp,
351 off_t * errorloc)
352 {
353 int error;
354 int s;
355 int sdno;
356 u_int64_t stripe; /* stripe number */
357 int *parity_buf; /* buffer address for current parity block */
358 int *newparity_buf; /* and for new parity block */
359 int mysize; /* I/O transfer size for this transfer */
360 int isize; /* mysize in ints */
361 int i;
362 int psd; /* parity subdisk number */
363 int newpsd; /* and "subdisk number" of new parity */
364 struct buf **bpp; /* pointers to our bps */
365 struct buf *pbp; /* buffer header for parity stripe */
366 int *sbuf;
367 int bufcount; /* number of buffers we need */
368
369 stripe = pstripe / plex->stripesize; /* stripe number */
370 psd = plex->subdisks - 1 - stripe % plex->subdisks; /* parity subdisk for this stripe */
371 parity_buf = NULL; /* to keep the compiler happy */
372 error = 0;
373
374 /*
375 * It's possible that the default transfer size
376 * we chose is not a factor of the stripe size.
377 * We *must* limit this operation to a single
378 * stripe, at least for RAID-5 rebuild, since
379 * the parity subdisk changes between stripes,
380 * so in this case we need to perform a short
381 * transfer. Set variable mysize to reflect
382 * this.
383 */
384 mysize = min(size, (plex->stripesize * (stripe + 1) - pstripe) << DEV_BSHIFT);
385 isize = mysize / (sizeof(int)); /* number of ints in the buffer */
386 bufcount = plex->subdisks + 1; /* sd buffers plus result buffer */
387 newpsd = plex->subdisks;
388 bpp = (struct buf **) Malloc(bufcount * sizeof(struct buf *)); /* array of pointers to bps */
389
390 /* First, build requests for all subdisks */
391 for (sdno = 0; sdno < bufcount; sdno++) { /* for each subdisk */
392 if ((sdno != psd) || (op != rebuildparity)) {
393 /* Get a buffer header and initialize it. */
394 s = splbio();
395 bpp[sdno] = geteblk(mysize); /* Get a buffer */
396 if (bpp[sdno] == NULL) {
397 while (sdno-- > 0) { /* release the ones we got */
398 bpp[sdno]->b_flags |= B_INVAL;
399 brelse(bpp[sdno]); /* give back our resources */
400 }
401 splx(s);
402 printf("vinum: can't allocate buffer space for parity op.\n");
403 return NULL; /* no bpps */
404 }
405 splx(s);
406 if (sdno == psd)
407 parity_buf = (int *) bpp[sdno]->b_data;
408 if (sdno == newpsd) /* the new one? */
409 bpp[sdno]->b_dev = VINUM_SD(plex->sdnos[psd]); /* write back to the parity SD */
410 else
411 bpp[sdno]->b_dev = VINUM_SD(plex->sdnos[sdno]); /* device number */
412 bpp[sdno]->b_flags = B_READ; /* either way, read it */
413 bpp[sdno]->b_bcount = mysize;
414 bpp[sdno]->b_resid = bpp[sdno]->b_bcount;
415 bpp[sdno]->b_blkno = pstripe; /* transfer from here */
416 }
417 }
418
419 /* Initialize result buffer */
420 pbp = bpp[newpsd];
421 newparity_buf = (int *) bpp[newpsd]->b_data;
422 bzero(newparity_buf, mysize);
423
424 /*
425 * Now lock the stripe with the first non-parity
426 * bp as locking bp.
427 */
428 *lockp = lockrange(pstripe * plex->stripesize * (plex->subdisks - 1),
429 bpp[psd ? 0 : 1],
430 plex);
431
432 /*
433 * Then issue requests for all subdisks in
434 * parallel. Don't transfer the parity stripe
435 * if we're rebuilding parity, unless we also
436 * want to check it.
437 */
438 for (sdno = 0; sdno < plex->subdisks; sdno++) { /* for each real subdisk */
439 if ((sdno != psd) || (op != rebuildparity)) {
440 bpp[sdno]->b_flags |= B_BUSY;
441 sdio(bpp[sdno]);
442 }
443 }
444
445 /*
446 * Next, wait for the requests to complete.
447 * We wait in the order in which they were
448 * issued, which isn't necessarily the order in
449 * which they complete, but we don't have a
450 * convenient way of doing the latter, and the
451 * delay is minimal.
452 */
453 for (sdno = 0; sdno < plex->subdisks; sdno++) { /* for each subdisk */
454 if ((sdno != psd) || (op != rebuildparity)) {
455 biowait(bpp[sdno]);
456 if (bpp[sdno]->b_flags & B_ERROR) /* can't read, */
457 error = bpp[sdno]->b_error;
458 else if (sdno != psd) { /* update parity */
459 sbuf = (int *) bpp[sdno]->b_data;
460 for (i = 0; i < isize; i++)
461 ((int *) newparity_buf)[i] ^= sbuf[i]; /* xor in the buffer */
462 }
463 }
464 if (sdno != psd) { /* release all bps except parity */
465 bpp[sdno]->b_flags |= B_INVAL;
466 brelse(bpp[sdno]); /* give back our resources */
467 }
468 }
469
470 /*
471 * If we're checking, compare the calculated
472 * and the read parity block. If they're
473 * different, return the plex-relative offset;
474 * otherwise return -1.
475 */
476 if ((op == checkparity)
477 || (op == rebuildandcheckparity)) {
478 *errorloc = -1; /* no error yet */
479 for (i = 0; i < isize; i++) {
480 if (parity_buf[i] != newparity_buf[i]) {
481 *errorloc = (off_t) (pstripe << DEV_BSHIFT) * (plex->subdisks - 1)
482 + i * sizeof(int);
483 break;
484 }
485 }
486 bpp[psd]->b_flags |= B_INVAL;
487 brelse(bpp[psd]); /* give back our resources */
488 }
489 /* release our resources */
490 Free(bpp);
491 if (error) {
492 pbp->b_flags |= B_ERROR;
493 pbp->b_error = error;
494 }
495 pbp->b_flags |= B_BUSY; /* return busy bp */
496 return pbp;
497 }
498
499 /*
500 * Initialize a subdisk by writing zeroes to the
501 * complete address space. If verify is set,
502 * check each transfer for correctness.
503 *
504 * Each call to this function writes (and maybe
505 * checks) a single block.
506 */
507 int
508 initsd(int sdno, int verify)
509 {
510 int s; /* priority level */
511 struct sd *sd;
512 struct plex *plex;
513 struct volume *vol;
514 struct buf *bp;
515 int error;
516 int size; /* size of init block, bytes */
517 daddr_t plexblkno; /* lblkno in plex */
518 int verified; /* set when we're happy with what we wrote */
519
520 error = 0;
521 plexblkno = 0; /* to keep the compiler happy */
522 sd = &SD[sdno];
523 if (sd->plexno < 0) /* no plex? */
524 return EINVAL;
525 plex = &PLEX[sd->plexno]; /* point to plex */
526 if (plex->volno >= 0)
527 vol = &VOL[plex->volno];
528 else
529 vol = NULL;
530
531 if (sd->init_blocksize == 0) {
532 if (plex->stripesize != 0) /* we're striped, don't init more than */
533 sd->init_blocksize = min(DEFAULT_REVIVE_BLOCKSIZE, /* one block at a time */
534 plex->stripesize << DEV_BSHIFT);
535 else
536 sd->init_blocksize = DEFAULT_REVIVE_BLOCKSIZE;
537 } else if (sd->init_blocksize > MAX_REVIVE_BLOCKSIZE)
538 sd->init_blocksize = MAX_REVIVE_BLOCKSIZE;
539
540 size = min(sd->init_blocksize >> DEV_BSHIFT, sd->sectors - sd->initialized) << DEV_BSHIFT;
541
542 verified = 0;
543 while (!verified) { /* until we're happy with it, */
544 s = splbio();
545 bp = geteblk(size); /* Get a buffer */
546 splx(s);
547 if (bp == NULL)
548 return ENOMEM;
549
550 bp->b_bcount = size;
551 bp->b_resid = bp->b_bcount;
552 bp->b_blkno = sd->initialized; /* write it to here */
553 bzero(bp->b_data, bp->b_bcount);
554 bp->b_dev = VINUM_SD(sdno); /* create the device number */
555 bp->b_flags |= B_BUSY;
556 bp->b_flags &= ~B_READ;
557 sdio(bp); /* perform the I/O */
558 biowait(bp);
559 if (bp->b_flags & B_ERROR)
560 error = bp->b_error;
561 bp->b_flags |= B_INVAL;
562 bp->b_flags &= ~B_ERROR;
563 brelse(bp); /* is this kosher? */
564 if ((error == 0) && verify) { /* check that it got there */
565 s = splbio();
566 bp = geteblk(size); /* get a buffer */
567 if (bp == NULL) {
568 splx(s);
569 error = ENOMEM;
570 } else {
571 bp->b_bcount = size;
572 bp->b_resid = bp->b_bcount;
573 bp->b_blkno = sd->initialized; /* read from here */
574 bp->b_dev = VINUM_SD(sdno); /* create the device number */
575 bp->b_flags |= B_READ; /* read it back */
576 splx(s);
577 bp->b_flags |= B_BUSY;
578 sdio(bp);
579 biowait(bp);
580 /*
581 * XXX Bug fix code. This is hopefully no
582 * longer needed (21 February 2000).
583 */
584 if (bp->b_flags & B_ERROR)
585 error = bp->b_error;
586 else if ((*bp->b_data != 0) /* first word spammed */
587 ||(bcmp(bp->b_data, &bp->b_data[1], bp->b_bcount - 1))) { /* or one of the others */
588 printf("vinum: init error on %s, offset 0x%llx sectors\n",
589 sd->name,
590 (long long) sd->initialized);
591 verified = 0;
592 } else
593 verified = 1;
594 bp->b_flags |= B_INVAL;
595 bp->b_flags &= ~B_ERROR;
596 brelse(bp);
597 }
598 } else
599 verified = 1;
600 }
601 if (error == 0) { /* did it, */
602 sd->initialized += size >> DEV_BSHIFT; /* moved this much further down */
603 if (sd->initialized >= sd->sectors) { /* finished */
604 sd->initialized = 0;
605 set_sd_state(sdno, sd_initialized, setstate_force); /* bring the sd up */
606 log(LOG_INFO, "vinum: %s is %s\n", sd->name, sd_state(sd->state));
607 save_config(); /* and save the updated configuration */
608 } else /* more to go, */
609 error = EAGAIN; /* ya'll come back, see? */
610 }
611 return error;
612 }
613
614 /* Local Variables: */
615 /* fill-column: 50 */
616 /* End: */
Cache object: 5b5dbc3618d0f584ed9a8ed36c007057
|