Change the kernel dev_t, representing a pointer to a specinfo structure,
[dragonfly.git] / sys / dev / raid / vinum / vinumrequest.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: vinumrequest.c,v 1.30 2001/01/09 04:20:55 grog Exp grog $
41 * $FreeBSD: src/sys/dev/vinum/vinumrequest.c,v 1.44.2.5 2002/08/28 04:30:56 grog Exp $
b13267a5 42 * $DragonFly: src/sys/dev/raid/vinum/vinumrequest.c,v 1.17 2006/09/10 01:26:36 dillon Exp $
984263bc
MD
43 */
44
1f2de5d4
MD
45#include "vinumhdr.h"
46#include "request.h"
984263bc
MD
47#include <sys/resourcevar.h>
48
49enum requeststatus bre(struct request *rq,
50 int plexno,
51 daddr_t * diskstart,
52 daddr_t diskend);
53enum requeststatus bre5(struct request *rq,
54 int plexno,
55 daddr_t * diskstart,
56 daddr_t diskend);
57enum requeststatus build_read_request(struct request *rq, int volplexno);
58enum requeststatus build_write_request(struct request *rq);
59enum requeststatus build_rq_buffer(struct rqelement *rqe, struct plex *plex);
60int find_alternate_sd(struct request *rq);
61int check_range_covered(struct request *);
81b5c339 62void complete_rqe(struct bio *bio);
984263bc
MD
63void complete_raid5_write(struct rqelement *);
64int abortrequest(struct request *rq, int error);
81b5c339
MD
65void sdio_done(struct bio *bio);
66struct bio *vinum_bounds_check(struct bio *bio, struct volume *vol);
984263bc
MD
67caddr_t allocdatabuf(struct rqelement *rqe);
68void freedatabuf(struct rqelement *rqe);
69
70#ifdef VINUMDEBUG
71struct rqinfo rqinfo[RQINFO_SIZE];
72struct rqinfo *rqip = rqinfo;
73
74void
81b5c339 75logrq(enum rqinfo_type type, union rqinfou info, struct bio *ubio)
984263bc 76{
b13267a5 77 cdev_t dev;
81b5c339 78
407c6ab2 79 crit_enter();
984263bc
MD
80
81 microtime(&rqip->timestamp); /* when did this happen? */
82 rqip->type = type;
81b5c339
MD
83 rqip->bio = ubio; /* user buffer */
84
984263bc
MD
85 switch (type) {
86 case loginfo_user_bp:
87 case loginfo_user_bpl:
88 case loginfo_sdio: /* subdisk I/O */
89 case loginfo_sdiol: /* subdisk I/O launch */
90 case loginfo_sdiodone: /* subdisk I/O complete */
81b5c339
MD
91 bcopy(info.bio, &rqip->info.bio, sizeof(struct bio));
92 dev = info.bio->bio_driver_info;
93 rqip->devmajor = major(dev);
94 rqip->devminor = minor(dev);
984263bc
MD
95 break;
96
97 case loginfo_iodone:
98 case loginfo_rqe:
99 case loginfo_raid5_data:
100 case loginfo_raid5_parity:
101 bcopy(info.rqe, &rqip->info.rqe, sizeof(struct rqelement));
81b5c339
MD
102 dev = info.rqe->b.b_bio1.bio_driver_info;
103 rqip->devmajor = major(dev);
104 rqip->devminor = minor(dev);
984263bc
MD
105 break;
106
107 case loginfo_lockwait:
108 case loginfo_lock:
109 case loginfo_unlock:
110 bcopy(info.lockinfo, &rqip->info.lockinfo, sizeof(struct rangelock));
111
112 break;
113
114 case loginfo_unused:
115 break;
116 }
117 rqip++;
118 if (rqip >= &rqinfo[RQINFO_SIZE]) /* wrap around */
119 rqip = rqinfo;
407c6ab2 120 crit_exit();
984263bc
MD
121}
122
123#endif
124
fef8985e
MD
125int
126vinumstrategy(struct dev_strategy_args *ap)
984263bc 127{
b13267a5 128 cdev_t dev = ap->a_head.a_dev;
fef8985e 129 struct bio *bio = ap->a_bio;
81b5c339
MD
130 struct buf *bp = bio->bio_buf;
131 struct bio *nbio = bio;
984263bc 132 struct volume *vol = NULL;
81b5c339 133 int volno;
984263bc 134
81b5c339 135 switch (DEVTYPE(dev)) {
984263bc
MD
136 case VINUM_SD_TYPE:
137 case VINUM_RAWSD_TYPE:
81b5c339
MD
138 bio->bio_driver_info = dev;
139 sdio(bio);
fef8985e
MD
140 break;
141 case VINUM_DRIVE_TYPE:
142 default:
984263bc
MD
143 /*
144 * In fact, vinum doesn't handle drives: they're
145 * handled directly by the disk drivers
146 */
984263bc
MD
147 bp->b_error = EIO; /* I/O error */
148 bp->b_flags |= B_ERROR;
81b5c339 149 biodone(bio);
fef8985e 150 break;
984263bc
MD
151
152 case VINUM_VOLUME_TYPE: /* volume I/O */
81b5c339 153 volno = Volno(dev);
984263bc
MD
154 vol = &VOL[volno];
155 if (vol->state != volume_up) { /* can't access this volume */
156 bp->b_error = EIO; /* I/O error */
157 bp->b_flags |= B_ERROR;
81b5c339 158 biodone(bio);
fef8985e 159 break;
984263bc 160 }
81b5c339
MD
161 nbio = vinum_bounds_check(bio, vol);
162 if (nbio == NULL) {
163 biodone(bio);
fef8985e 164 break;
984263bc
MD
165 }
166 /* FALLTHROUGH */
fef8985e
MD
167 case VINUM_PLEX_TYPE:
168 case VINUM_RAWPLEX_TYPE:
984263bc
MD
169 /*
170 * Plex I/O is pretty much the same as volume I/O
171 * for a single plex. Indicate this by passing a NULL
172 * pointer (set above) for the volume
173 */
984263bc 174 bp->b_resid = bp->b_bcount; /* transfer everything */
81b5c339 175 vinumstart(dev, nbio, 0);
fef8985e 176 break;
984263bc 177 }
fef8985e 178 return(0);
984263bc
MD
179}
180
181/*
182 * Start a transfer. Return -1 on error,
183 * 0 if OK, 1 if we need to retry.
184 * Parameter reviveok is set when doing
185 * transfers for revives: it allows transfers to
186 * be started immediately when a revive is in
187 * progress. During revive, normal transfers
188 * are queued if they share address space with
189 * a currently active revive operation.
190 */
191int
b13267a5 192vinumstart(cdev_t dev, struct bio *bio, int reviveok)
984263bc 193{
81b5c339 194 struct buf *bp = bio->bio_buf;
984263bc
MD
195 int plexno;
196 int maxplex; /* maximum number of plexes to handle */
197 struct volume *vol;
198 struct request *rq; /* build up our request here */
199 enum requeststatus status;
200
81b5c339
MD
201 bio->bio_driver_info = dev;
202
984263bc
MD
203#if VINUMDEBUG
204 if (debug & DEBUG_LASTREQS)
81b5c339 205 logrq(loginfo_user_bp, (union rqinfou) bio, bio);
984263bc
MD
206#endif
207
208 if ((bp->b_bcount % DEV_BSIZE) != 0) { /* bad length */
209 bp->b_error = EINVAL; /* invalid size */
210 bp->b_flags |= B_ERROR;
81b5c339 211 biodone(bio);
984263bc
MD
212 return -1;
213 }
214 rq = (struct request *) Malloc(sizeof(struct request)); /* allocate a request struct */
215 if (rq == NULL) { /* can't do it */
216 bp->b_error = ENOMEM; /* can't get memory */
217 bp->b_flags |= B_ERROR;
81b5c339 218 biodone(bio);
984263bc
MD
219 return -1;
220 }
221 bzero(rq, sizeof(struct request));
222
223 /*
224 * Note the volume ID. This can be NULL, which
225 * the request building functions use as an
226 * indication for single plex I/O
227 */
81b5c339 228 rq->bio = bio; /* and the user buffer struct */
984263bc 229
81b5c339
MD
230 if (DEVTYPE(dev) == VINUM_VOLUME_TYPE) { /* it's a volume, */
231 rq->volplex.volno = Volno(dev); /* get the volume number */
984263bc
MD
232 vol = &VOL[rq->volplex.volno]; /* and point to it */
233 vol->active++; /* one more active request */
234 maxplex = vol->plexes; /* consider all its plexes */
235 } else {
236 vol = NULL; /* no volume */
81b5c339 237 rq->volplex.plexno = Plexno(dev); /* point to the plex */
984263bc
MD
238 rq->isplex = 1; /* note that it's a plex */
239 maxplex = 1; /* just the one plex */
240 }
241
10f3fee5 242 if (bp->b_cmd == BUF_CMD_READ) {
984263bc
MD
243 /*
244 * This is a read request. Decide
245 * which plex to read from.
246 *
247 * There's a potential race condition here,
248 * since we're not locked, and we could end
249 * up multiply incrementing the round-robin
250 * counter. This doesn't have any serious
251 * effects, however.
252 */
253 if (vol != NULL) {
254 plexno = vol->preferred_plex; /* get the plex to use */
255 if (plexno < 0) { /* round robin */
256 plexno = vol->last_plex_read;
257 vol->last_plex_read++;
258 if (vol->last_plex_read >= vol->plexes) /* got the the end? */
259 vol->last_plex_read = 0; /* wrap around */
260 }
261 status = build_read_request(rq, plexno); /* build a request */
262 } else {
54078292
MD
263 daddr_t diskaddr = (daddr_t)(bio->bio_offset >> DEV_BSHIFT);
264 /* start offset of transfer */
984263bc
MD
265 status = bre(rq, /* build a request list */
266 rq->volplex.plexno,
267 &diskaddr,
268 diskaddr + (bp->b_bcount / DEV_BSIZE));
269 }
270
271 if (status > REQUEST_RECOVERED) { /* can't satisfy it */
272 if (status == REQUEST_DOWN) { /* not enough subdisks */
273 bp->b_error = EIO; /* I/O error */
274 bp->b_flags |= B_ERROR;
275 }
81b5c339 276 biodone(bio);
984263bc
MD
277 freerq(rq);
278 return -1;
279 }
280 return launch_requests(rq, reviveok); /* now start the requests if we can */
281 } else
282 /*
283 * This is a write operation. We write to all plexes. If this is
284 * a RAID-4 or RAID-5 plex, we must also update the parity stripe.
285 */
286 {
287 if (vol != NULL)
288 status = build_write_request(rq); /* Not all the subdisks are up */
289 else { /* plex I/O */
290 daddr_t diskstart;
54078292 291 daddr_t diskend;
984263bc 292
54078292
MD
293 diskstart = (daddr_t)(bio->bio_offset >> DEV_BSHIFT); /* start offset of transfer */
294 diskend = diskstart + bp->b_bcount / DEV_BSIZE;
295 status = bre(rq, Plexno(dev),
296 &diskstart, diskend); /* build requests for the plex */
984263bc
MD
297 }
298 if (status > REQUEST_RECOVERED) { /* can't satisfy it */
299 if (status == REQUEST_DOWN) { /* not enough subdisks */
300 bp->b_error = EIO; /* I/O error */
301 bp->b_flags |= B_ERROR;
302 }
81b5c339 303 biodone(bio);
984263bc
MD
304 freerq(rq);
305 return -1;
306 }
307 return launch_requests(rq, reviveok); /* now start the requests if we can */
308 }
309}
310
311/*
312 * Call the low-level strategy routines to
313 * perform the requests in a struct request
314 */
315int
316launch_requests(struct request *rq, int reviveok)
317{
318 struct rqgroup *rqg;
319 int rqno; /* loop index */
320 struct rqelement *rqe; /* current element */
321 struct drive *drive;
322 int rcount; /* request count */
984263bc
MD
323
324 /*
325 * First find out whether we're reviving, and the
326 * request contains a conflict. If so, we hang
327 * the request off plex->waitlist of the first
328 * plex we find which is reviving
329 */
330
331 if ((rq->flags & XFR_REVIVECONFLICT) /* possible revive conflict */
332 &&(!reviveok)) { /* and we don't want to do it now, */
333 struct sd *sd;
334 struct request *waitlist; /* point to the waitlist */
335
336 sd = &SD[rq->sdno];
337 if (sd->waitlist != NULL) { /* something there already, */
338 waitlist = sd->waitlist;
339 while (waitlist->next != NULL) /* find the end */
340 waitlist = waitlist->next;
341 waitlist->next = rq; /* hook our request there */
342 } else
343 sd->waitlist = rq; /* hook our request at the front */
344
345#if VINUMDEBUG
81b5c339 346 if (debug & DEBUG_REVIVECONFLICT) {
984263bc 347 log(LOG_DEBUG,
591bdbe9 348 "Revive conflict sd %d: %p\n%s dev %d.%d, offset 0x%llx, length %d\n",
984263bc
MD
349 rq->sdno,
350 rq,
10f3fee5 351 (rq->bio->bio_buf->b_cmd & BUF_CMD_READ) ? "Read" : "Write",
b13267a5
MD
352 major(((cdev_t)rq->bio->bio_driver_info)),
353 minor(((cdev_t)rq->bio->bio_driver_info)),
54078292 354 rq->bio->bio_offset,
81b5c339
MD
355 rq->bio->bio_buf->b_bcount);
356 }
984263bc
MD
357#endif
358 return 0; /* and get out of here */
359 }
360 rq->active = 0; /* nothing yet */
361#if VINUMDEBUG
362 if (debug & DEBUG_ADDRESSES)
363 log(LOG_DEBUG,
591bdbe9 364 "Request: %p\n%s dev %d.%d, offset 0x%llx, length %d\n",
984263bc 365 rq,
10f3fee5 366 (rq->bio->bio_buf->b_cmd == BUF_CMD_READ) ? "Read" : "Write",
b13267a5
MD
367 major(((cdev_t)rq->bio->bio_driver_info)),
368 minor(((cdev_t)rq->bio->bio_driver_info)),
54078292 369 rq->bio->bio_offset,
81b5c339 370 rq->bio->bio_buf->b_bcount);
984263bc 371 vinum_conf.lastrq = rq;
81b5c339 372 vinum_conf.lastbio = rq->bio;
984263bc 373 if (debug & DEBUG_LASTREQS)
81b5c339 374 logrq(loginfo_user_bpl, (union rqinfou) rq->bio, rq->bio);
984263bc
MD
375#endif
376
984263bc
MD
377 /*
378 * This loop happens without any participation
379 * of the bottom half, so it requires no
380 * protection.
381 */
382 for (rqg = rq->rqg; rqg != NULL; rqg = rqg->next) { /* through the whole request chain */
383 rqg->active = rqg->count; /* they're all active */
384 for (rqno = 0; rqno < rqg->count; rqno++) {
385 rqe = &rqg->rqe[rqno];
386 if (rqe->flags & XFR_BAD_SUBDISK) /* this subdisk is bad, */
387 rqg->active--; /* one less active request */
388 }
389 if (rqg->active) /* we have at least one active request, */
390 rq->active++; /* one more active request group */
391 }
392
393 /*
394 * Now fire off the requests. In this loop the
395 * bottom half could be completing requests
407c6ab2 396 * before we finish, so we need critical section protection.
984263bc 397 */
407c6ab2 398 crit_enter();
984263bc
MD
399 for (rqg = rq->rqg; rqg != NULL;) { /* through the whole request chain */
400 if (rqg->lockbase >= 0) /* this rqg needs a lock first */
81b5c339 401 rqg->lock = lockrange(rqg->lockbase, rqg->rq->bio->bio_buf, &PLEX[rqg->plexno]);
984263bc
MD
402 rcount = rqg->count;
403 for (rqno = 0; rqno < rcount;) {
b13267a5 404 cdev_t dev;
81b5c339 405
984263bc
MD
406 rqe = &rqg->rqe[rqno];
407
408 /*
409 * Point to next rqg before the bottom end
410 * changes the structures.
411 */
412 if (++rqno >= rcount)
413 rqg = rqg->next;
414 if ((rqe->flags & XFR_BAD_SUBDISK) == 0) { /* this subdisk is good, */
415 drive = &DRIVE[rqe->driveno]; /* look at drive */
416 drive->active++;
417 if (drive->active >= drive->maxactive)
418 drive->maxactive = drive->active;
419 vinum_conf.active++;
420 if (vinum_conf.active >= vinum_conf.maxactive)
421 vinum_conf.maxactive = vinum_conf.active;
422
81b5c339 423 dev = rqe->b.b_bio1.bio_driver_info;
984263bc
MD
424#ifdef VINUMDEBUG
425 if (debug & DEBUG_ADDRESSES)
426 log(LOG_DEBUG,
591bdbe9 427 " %s dev %d.%d, sd %d, offset 0x%llx, devoffset 0x%llx, length %d\n",
10f3fee5 428 (rqe->b.b_cmd == BUF_CMD_READ) ? "Read" : "Write",
81b5c339
MD
429 major(dev),
430 minor(dev),
984263bc 431 rqe->sdno,
54078292
MD
432 rqe->b.b_bio1.bio_offset - ((off_t)SD[rqe->sdno].driveoffset << DEV_BSHIFT),
433 rqe->b.b_bio1.bio_offset,
984263bc
MD
434 rqe->b.b_bcount);
435 if (debug & DEBUG_LASTREQS)
81b5c339 436 logrq(loginfo_rqe, (union rqinfou) rqe, rq->bio);
984263bc
MD
437#endif
438 /* fire off the request */
81b5c339 439 dev_dstrategy(dev, &rqe->b.b_bio1);
984263bc
MD
440 }
441 }
442 }
407c6ab2 443 crit_exit();
984263bc
MD
444 return 0;
445}
446
447/*
448 * define the low-level requests needed to perform a
449 * high-level I/O operation for a specific plex 'plexno'.
450 *
451 * Return REQUEST_OK if all subdisks involved in the request are up,
452 * REQUEST_DOWN if some subdisks are not up, and REQUEST_EOF if the
453 * request is at least partially outside the bounds of the subdisks.
454 *
455 * Modify the pointer *diskstart to point to the end address. On
456 * read, return on the first bad subdisk, so that the caller
457 * (build_read_request) can try alternatives.
458 *
459 * On entry to this routine, the rqg structures are not assigned. The
460 * assignment is performed by expandrq(). Strictly speaking, the
461 * elements rqe->sdno of all entries should be set to -1, since 0
462 * (from bzero) is a valid subdisk number. We avoid this problem by
463 * initializing the ones we use, and not looking at the others (index
464 * >= rqg->requests).
465 */
466enum requeststatus
467bre(struct request *rq,
468 int plexno,
469 daddr_t * diskaddr,
470 daddr_t diskend)
471{
472 int sdno;
473 struct sd *sd;
474 struct rqgroup *rqg;
81b5c339 475 struct bio *bio;
984263bc
MD
476 struct buf *bp; /* user's bp */
477 struct plex *plex;
478 enum requeststatus status; /* return value */
479 daddr_t plexoffset; /* offset of transfer in plex */
480 daddr_t stripebase; /* base address of stripe (1st subdisk) */
481 daddr_t stripeoffset; /* offset in stripe */
482 daddr_t blockoffset; /* offset in stripe on subdisk */
483 struct rqelement *rqe; /* point to this request information */
484 daddr_t diskstart = *diskaddr; /* remember where this transfer starts */
485 enum requeststatus s; /* temp return value */
486
81b5c339
MD
487 bio = rq->bio; /* buffer pointer */
488 bp = bio->bio_buf;
984263bc
MD
489 status = REQUEST_OK; /* return value: OK until proven otherwise */
490 plex = &PLEX[plexno]; /* point to the plex */
491
492 switch (plex->organization) {
493 case plex_concat:
494 sd = NULL; /* (keep compiler quiet) */
495 for (sdno = 0; sdno < plex->subdisks; sdno++) {
496 sd = &SD[plex->sdnos[sdno]];
497 if (*diskaddr < sd->plexoffset) /* we must have a hole, */
498 status = REQUEST_DEGRADED; /* note the fact */
499 if (*diskaddr < (sd->plexoffset + sd->sectors)) { /* the request starts in this subdisk */
500 rqg = allocrqg(rq, 1); /* space for the request */
501 if (rqg == NULL) { /* malloc failed */
502 bp->b_error = ENOMEM;
503 bp->b_flags |= B_ERROR;
504 return REQUEST_ENOMEM;
505 }
506 rqg->plexno = plexno;
507
508 rqe = &rqg->rqe[0]; /* point to the element */
509 rqe->rqg = rqg; /* group */
510 rqe->sdno = sd->sdno; /* put in the subdisk number */
511 plexoffset = *diskaddr; /* start offset in plex */
512 rqe->sdoffset = plexoffset - sd->plexoffset; /* start offset in subdisk */
513 rqe->useroffset = plexoffset - diskstart; /* start offset in user buffer */
514 rqe->dataoffset = 0;
515 rqe->datalen = min(diskend - *diskaddr, /* number of sectors to transfer in this sd */
516 sd->sectors - rqe->sdoffset);
517 rqe->groupoffset = 0; /* no groups for concatenated plexes */
518 rqe->grouplen = 0;
519 rqe->buflen = rqe->datalen; /* buffer length is data buffer length */
520 rqe->flags = 0;
521 rqe->driveno = sd->driveno;
522 if (sd->state != sd_up) { /* *now* we find the sd is down */
523 s = checksdstate(sd, rq, *diskaddr, diskend); /* do we need to change state? */
524 if (s == REQUEST_DOWN) { /* down? */
525 rqe->flags = XFR_BAD_SUBDISK; /* yup */
10f3fee5 526 if (rq->bio->bio_buf->b_cmd == BUF_CMD_READ) /* read request, */
984263bc
MD
527 return REQUEST_DEGRADED; /* give up here */
528 /*
529 * If we're writing, don't give up
530 * because of a bad subdisk. Go
531 * through to the bitter end, but note
532 * which ones we can't access.
533 */
534 status = REQUEST_DEGRADED; /* can't do it all */
535 }
536 }
537 *diskaddr += rqe->datalen; /* bump the address */
538 if (build_rq_buffer(rqe, plex)) { /* build the buffer */
539 deallocrqg(rqg);
540 bp->b_error = ENOMEM;
541 bp->b_flags |= B_ERROR;
542 return REQUEST_ENOMEM; /* can't do it */
543 }
544 }
545 if (*diskaddr == diskend) /* we're finished, */
546 break; /* get out of here */
547 }
548 /*
549 * We've got to the end of the plex. Have we got to the end of
550 * the transfer? It would seem that having an offset beyond the
551 * end of the subdisk is an error, but in fact it can happen if
552 * the volume has another plex of different size. There's a valid
553 * question as to why you would want to do this, but currently
554 * it's allowed.
555 *
556 * In a previous version, I returned REQUEST_DOWN here. I think
557 * REQUEST_EOF is more appropriate now.
558 */
559 if (diskend > sd->sectors + sd->plexoffset) /* pointing beyond EOF? */
560 status = REQUEST_EOF;
561 break;
562
563 case plex_striped:
564 {
565 while (*diskaddr < diskend) { /* until we get it all sorted out */
566 if (*diskaddr >= plex->length) /* beyond the end of the plex */
567 return REQUEST_EOF; /* can't continue */
568
569 /* The offset of the start address from the start of the stripe. */
570 stripeoffset = *diskaddr % (plex->stripesize * plex->subdisks);
571
572 /* The plex-relative address of the start of the stripe. */
573 stripebase = *diskaddr - stripeoffset;
574
575 /* The number of the subdisk in which the start is located. */
576 sdno = stripeoffset / plex->stripesize;
577
578 /* The offset from the beginning of the stripe on this subdisk. */
579 blockoffset = stripeoffset % plex->stripesize;
580
581 sd = &SD[plex->sdnos[sdno]]; /* the subdisk in question */
582 rqg = allocrqg(rq, 1); /* space for the request */
583 if (rqg == NULL) { /* malloc failed */
584 bp->b_error = ENOMEM;
585 bp->b_flags |= B_ERROR;
586 return REQUEST_ENOMEM;
587 }
588 rqg->plexno = plexno;
589
590 rqe = &rqg->rqe[0]; /* point to the element */
591 rqe->rqg = rqg;
592 rqe->sdoffset = stripebase / plex->subdisks + blockoffset; /* start offset in this subdisk */
593 rqe->useroffset = *diskaddr - diskstart; /* The offset of the start in the user buffer */
594 rqe->dataoffset = 0;
595 rqe->datalen = min(diskend - *diskaddr, /* the amount remaining to transfer */
596 plex->stripesize - blockoffset); /* and the amount left in this stripe */
597 rqe->groupoffset = 0; /* no groups for striped plexes */
598 rqe->grouplen = 0;
599 rqe->buflen = rqe->datalen; /* buffer length is data buffer length */
600 rqe->flags = 0;
601 rqe->sdno = sd->sdno; /* put in the subdisk number */
602 rqe->driveno = sd->driveno;
603
604 if (sd->state != sd_up) { /* *now* we find the sd is down */
605 s = checksdstate(sd, rq, *diskaddr, diskend); /* do we need to change state? */
606 if (s == REQUEST_DOWN) { /* down? */
607 rqe->flags = XFR_BAD_SUBDISK; /* yup */
10f3fee5 608 if (rq->bio->bio_buf->b_cmd == BUF_CMD_READ) /* read request, */
984263bc
MD
609 return REQUEST_DEGRADED; /* give up here */
610 /*
611 * If we're writing, don't give up
612 * because of a bad subdisk. Go through
613 * to the bitter end, but note which
614 * ones we can't access.
615 */
616 status = REQUEST_DEGRADED; /* can't do it all */
617 }
618 }
619 /*
620 * It would seem that having an offset
621 * beyond the end of the subdisk is an
622 * error, but in fact it can happen if the
623 * volume has another plex of different
624 * size. There's a valid question as to why
625 * you would want to do this, but currently
626 * it's allowed.
627 */
628 if (rqe->sdoffset + rqe->datalen > sd->sectors) { /* ends beyond the end of the subdisk? */
629 rqe->datalen = sd->sectors - rqe->sdoffset; /* truncate */
630#if VINUMDEBUG
631 if (debug & DEBUG_EOFINFO) { /* tell on the request */
632 log(LOG_DEBUG,
54078292 633 "vinum: EOF on plex %s, sd %s offset %llx (user offset %x)\n",
984263bc
MD
634 plex->name,
635 sd->name,
636 (u_int) sd->sectors,
54078292 637 bp->b_bio1.bio_offset);
984263bc
MD
638 log(LOG_DEBUG,
639 "vinum: stripebase %x, stripeoffset %x, blockoffset %x\n",
640 stripebase,
641 stripeoffset,
642 blockoffset);
643 }
644#endif
645 }
646 if (build_rq_buffer(rqe, plex)) { /* build the buffer */
647 deallocrqg(rqg);
648 bp->b_error = ENOMEM;
649 bp->b_flags |= B_ERROR;
650 return REQUEST_ENOMEM; /* can't do it */
651 }
652 *diskaddr += rqe->datalen; /* look at the remainder */
653 if ((*diskaddr < diskend) /* didn't finish the request on this stripe */
654 &&(*diskaddr < plex->length)) { /* and there's more to come */
655 plex->multiblock++; /* count another one */
656 if (sdno == plex->subdisks - 1) /* last subdisk, */
657 plex->multistripe++; /* another stripe as well */
658 }
659 }
660 }
661 break;
662
663 /*
664 * RAID-4 and RAID-5 are complicated enough to have their own
665 * function.
666 */
667 case plex_raid4:
668 case plex_raid5:
669 status = bre5(rq, plexno, diskaddr, diskend);
670 break;
671
672 default:
673 log(LOG_ERR, "vinum: invalid plex type %d in bre\n", plex->organization);
674 status = REQUEST_DOWN; /* can't access it */
675 }
676
677 return status;
678}
679
680/*
681 * Build up a request structure for reading volumes.
682 * This function is not needed for plex reads, since there's
683 * no recovery if a plex read can't be satisified.
684 */
685enum requeststatus
686build_read_request(struct request *rq, /* request */
687 int plexindex)
688{ /* index in the volume's plex table */
81b5c339 689 struct bio *bio;
984263bc
MD
690 struct buf *bp;
691 daddr_t startaddr; /* offset of previous part of transfer */
692 daddr_t diskaddr; /* offset of current part of transfer */
693 daddr_t diskend; /* and end offset of transfer */
694 int plexno; /* plex index in vinum_conf */
695 struct rqgroup *rqg; /* point to the request we're working on */
696 struct volume *vol; /* volume in question */
697 int recovered = 0; /* set if we recover a read */
698 enum requeststatus status = REQUEST_OK;
699 int plexmask; /* bit mask of plexes, for recovery */
700
81b5c339
MD
701 bio = rq->bio; /* buffer pointer */
702 bp = bio->bio_buf;
54078292 703 diskaddr = bio->bio_offset >> DEV_BSHIFT; /* start offset of transfer */
984263bc
MD
704 diskend = diskaddr + (bp->b_bcount / DEV_BSIZE); /* and end offset of transfer */
705 rqg = &rq->rqg[plexindex]; /* plex request */
706 vol = &VOL[rq->volplex.volno]; /* point to volume */
707
708 while (diskaddr < diskend) { /* build up request components */
709 startaddr = diskaddr;
710 status = bre(rq, vol->plex[plexindex], &diskaddr, diskend); /* build up a request */
711 switch (status) {
712 case REQUEST_OK:
713 continue;
714
715 case REQUEST_RECOVERED:
716 /*
717 * XXX FIXME if we have more than one plex, and we can
718 * satisfy the request from another, don't use the
719 * recovered request, since it's more expensive.
720 */
721 recovered = 1;
722 break;
723
724 case REQUEST_ENOMEM:
725 return status;
726 /*
727 * If we get here, our request is not complete. Try
728 * to fill in the missing parts from another plex.
729 * This can happen multiple times in this function,
730 * and we reinitialize the plex mask each time, since
731 * we could have a hole in our plexes.
732 */
733 case REQUEST_EOF:
734 case REQUEST_DOWN: /* can't access the plex */
735 case REQUEST_DEGRADED: /* can't access the plex */
736 plexmask = ((1 << vol->plexes) - 1) /* all plexes in the volume */
737 &~(1 << plexindex); /* except for the one we were looking at */
738 for (plexno = 0; plexno < vol->plexes; plexno++) {
739 if (plexmask == 0) /* no plexes left to try */
740 return REQUEST_DOWN; /* failed */
741 diskaddr = startaddr; /* start at the beginning again */
742 if (plexmask & (1 << plexno)) { /* we haven't tried this plex yet */
743 bre(rq, vol->plex[plexno], &diskaddr, diskend); /* try a request */
744 if (diskaddr > startaddr) { /* we satisfied another part */
745 recovered = 1; /* we recovered from the problem */
746 status = REQUEST_OK; /* don't complain about it */
747 break;
748 }
749 }
750 }
751 if (diskaddr == startaddr) /* didn't get any further, */
752 return status;
753 }
754 if (recovered)
755 vol->recovered_reads += recovered; /* adjust our recovery count */
756 }
757 return status;
758}
759
760/*
761 * Build up a request structure for writes.
762 * Return 0 if all subdisks involved in the request are up, 1 if some
763 * subdisks are not up, and -1 if the request is at least partially
764 * outside the bounds of the subdisks.
765 */
766enum requeststatus
767build_write_request(struct request *rq)
768{ /* request */
81b5c339 769 struct bio *bio;
984263bc
MD
770 struct buf *bp;
771 daddr_t diskstart; /* offset of current part of transfer */
772 daddr_t diskend; /* and end offset of transfer */
773 int plexno; /* plex index in vinum_conf */
774 struct volume *vol; /* volume in question */
775 enum requeststatus status;
776
81b5c339
MD
777 bio = rq->bio; /* buffer pointer */
778 bp = bio->bio_buf;
984263bc 779 vol = &VOL[rq->volplex.volno]; /* point to volume */
54078292 780 diskend = (daddr_t)(bio->bio_offset >> DEV_BSHIFT) + (bp->b_bcount / DEV_BSIZE); /* end offset of transfer */
984263bc
MD
781 status = REQUEST_DOWN; /* assume the worst */
782 for (plexno = 0; plexno < vol->plexes; plexno++) {
54078292 783 diskstart = (daddr_t)(bio->bio_offset >> DEV_BSHIFT); /* start offset of transfer */
984263bc
MD
784 /*
785 * Build requests for the plex.
786 * We take the best possible result here (min,
787 * not max): we're happy if we can write at all
788 */
789 status = min(status, bre(rq,
790 vol->plex[plexno],
791 &diskstart,
792 diskend));
793 }
794 return status;
795}
796
797/* Fill in the struct buf part of a request element. */
798enum requeststatus
799build_rq_buffer(struct rqelement *rqe, struct plex *plex)
800{
801 struct sd *sd; /* point to subdisk */
802 struct volume *vol;
803 struct buf *bp;
804 struct buf *ubp; /* user (high level) buffer header */
81b5c339 805 struct bio *ubio;
984263bc
MD
806
807 vol = &VOL[rqe->rqg->rq->volplex.volno];
808 sd = &SD[rqe->sdno]; /* point to subdisk */
809 bp = &rqe->b;
81b5c339
MD
810 ubio = rqe->rqg->rq->bio; /* pointer to user buffer header */
811 ubp = ubio->bio_buf;
984263bc
MD
812
813 /* Initialize the buf struct */
814 /* copy these flags from user bp */
10f3fee5
MD
815 bp->b_flags = ubp->b_flags & (B_ORDERED | B_NOCACHE | B_ASYNC);
816 bp->b_cmd = ubp->b_cmd;
984263bc
MD
817#ifdef VINUMDEBUG
818 if (rqe->flags & XFR_BUFLOCKED) /* paranoia */
819 panic("build_rq_buffer: rqe already locked"); /* XXX remove this when we're sure */
820#endif
821 BUF_LOCKINIT(bp); /* get a lock for the buffer */
822 BUF_LOCK(bp, LK_EXCLUSIVE); /* and lock it */
823 BUF_KERNPROC(bp);
61ebc48c 824 initbufbio(bp);
984263bc 825 rqe->flags |= XFR_BUFLOCKED;
81b5c339 826 bp->b_bio1.bio_done = complete_rqe;
984263bc
MD
827 /*
828 * You'd think that we wouldn't need to even
829 * build the request buffer for a dead subdisk,
830 * but in some cases we need information like
831 * the user buffer address. Err on the side of
832 * generosity and supply what we can. That
833 * obviously doesn't include drive information
834 * when the drive is dead.
835 */
836 if ((rqe->flags & XFR_BAD_SUBDISK) == 0) /* subdisk is accessible, */
81b5c339 837 bp->b_bio1.bio_driver_info = DRIVE[rqe->driveno].dev; /* drive device */
54078292 838 bp->b_bio1.bio_offset = (off_t)(rqe->sdoffset + sd->driveoffset) << DEV_BSHIFT; /* start address */
984263bc
MD
839 bp->b_bcount = rqe->buflen << DEV_BSHIFT; /* number of bytes to transfer */
840 bp->b_resid = bp->b_bcount; /* and it's still all waiting */
984263bc
MD
841
842 if (rqe->flags & XFR_MALLOCED) { /* this operation requires a malloced buffer */
843 bp->b_data = Malloc(bp->b_bcount); /* get a buffer to put it in */
844 if (bp->b_data == NULL) { /* failed */
845 abortrequest(rqe->rqg->rq, ENOMEM);
846 return REQUEST_ENOMEM; /* no memory */
847 }
848 } else
849 /*
850 * Point directly to user buffer data. This means
851 * that we don't need to do anything when we have
852 * finished the transfer
853 */
854 bp->b_data = ubp->b_data + rqe->useroffset * DEV_BSIZE;
855 /*
856 * On a recovery read, we perform an XOR of
857 * all blocks to the user buffer. To make
858 * this work, we first clean out the buffer
859 */
860 if ((rqe->flags & (XFR_RECOVERY_READ | XFR_BAD_SUBDISK))
861 == (XFR_RECOVERY_READ | XFR_BAD_SUBDISK)) { /* bad subdisk of a recovery read */
862 int length = rqe->grouplen << DEV_BSHIFT; /* and count involved */
863 char *data = (char *) &rqe->b.b_data[rqe->groupoffset << DEV_BSHIFT]; /* destination */
864
865 bzero(data, length); /* clean it out */
866 }
867 return 0;
868}
869
870/*
871 * Abort a request: free resources and complete the
872 * user request with the specified error
873 */
874int
875abortrequest(struct request *rq, int error)
876{
81b5c339 877 struct buf *bp = rq->bio->bio_buf; /* user buffer */
984263bc
MD
878
879 bp->b_error = error;
880 freerq(rq); /* free everything we're doing */
881 bp->b_flags |= B_ERROR;
882 return error; /* and give up */
883}
884
885/*
886 * Check that our transfer will cover the
887 * complete address space of the user request.
888 *
889 * Return 1 if it can, otherwise 0
890 */
891int
892check_range_covered(struct request *rq)
893{
894 return 1;
895}
896
897/* Perform I/O on a subdisk */
898void
81b5c339 899sdio(struct bio *bio)
984263bc 900{
b13267a5
MD
901 cdev_t dev;
902 cdev_t sddev;
984263bc
MD
903 struct sd *sd;
904 struct sdbuf *sbp;
905 daddr_t endoffset;
906 struct drive *drive;
81b5c339
MD
907 struct buf *bp = bio->bio_buf;
908
909 dev = bio->bio_driver_info;
984263bc
MD
910
911#if VINUMDEBUG
912 if (debug & DEBUG_LASTREQS)
81b5c339 913 logrq(loginfo_sdio, (union rqinfou) bio, bio);
984263bc 914#endif
81b5c339 915 sd = &SD[Sdno(dev)]; /* point to the subdisk */
984263bc
MD
916 drive = &DRIVE[sd->driveno];
917
918 if (drive->state != drive_up) {
919 if (sd->state >= sd_crashed) {
10f3fee5 920 if (bp->b_cmd != BUF_CMD_READ) /* writing, */
984263bc
MD
921 set_sd_state(sd->sdno, sd_stale, setstate_force);
922 else
923 set_sd_state(sd->sdno, sd_crashed, setstate_force);
924 }
925 bp->b_error = EIO;
926 bp->b_flags |= B_ERROR;
81b5c339 927 biodone(bio);
984263bc
MD
928 return;
929 }
930 /*
931 * We allow access to any kind of subdisk as long as we can expect
932 * to get the I/O performed.
933 */
934 if (sd->state < sd_empty) { /* nothing to talk to, */
935 bp->b_error = EIO;
936 bp->b_flags |= B_ERROR;
81b5c339 937 biodone(bio);
984263bc
MD
938 return;
939 }
940 /* Get a buffer */
941 sbp = (struct sdbuf *) Malloc(sizeof(struct sdbuf));
942 if (sbp == NULL) {
943 bp->b_error = ENOMEM;
944 bp->b_flags |= B_ERROR;
81b5c339 945 biodone(bio);
984263bc
MD
946 return;
947 }
81b5c339 948 sddev = DRIVE[sd->driveno].dev; /* device */
984263bc 949 bzero(sbp, sizeof(struct sdbuf)); /* start with nothing */
4ef09ff8 950 sbp->b.b_cmd = bp->b_cmd;
984263bc
MD
951 sbp->b.b_bcount = bp->b_bcount; /* number of bytes to transfer */
952 sbp->b.b_resid = bp->b_resid; /* and amount waiting */
984263bc 953 sbp->b.b_data = bp->b_data; /* data buffer */
984263bc
MD
954 BUF_LOCKINIT(&sbp->b); /* get a lock for the buffer */
955 BUF_LOCK(&sbp->b, LK_EXCLUSIVE); /* and lock it */
956 BUF_KERNPROC(&sbp->b);
81b5c339 957 initbufbio(&sbp->b);
54078292 958 sbp->b.b_bio1.bio_offset = bio->bio_offset + ((off_t)sd->driveoffset << DEV_BSHIFT);
81b5c339
MD
959 sbp->b.b_bio1.bio_done = sdio_done; /* come here on completion */
960 sbp->bio = bio; /* note the address of the original header */
984263bc
MD
961 sbp->sdno = sd->sdno; /* note for statistics */
962 sbp->driveno = sd->driveno;
54078292 963 endoffset = (daddr_t)(bio->bio_offset >> DEV_BSHIFT) + sbp->b.b_bcount / DEV_BSIZE; /* final sector offset */
984263bc
MD
964 if (endoffset > sd->sectors) { /* beyond the end */
965 sbp->b.b_bcount -= (endoffset - sd->sectors) * DEV_BSIZE; /* trim */
966 if (sbp->b.b_bcount <= 0) { /* nothing to transfer */
967 bp->b_resid = bp->b_bcount; /* nothing transferred */
81b5c339 968 biodone(bio);
984263bc
MD
969 BUF_UNLOCK(&sbp->b);
970 BUF_LOCKFREE(&sbp->b);
971 Free(sbp);
972 return;
973 }
974 }
975#if VINUMDEBUG
976 if (debug & DEBUG_ADDRESSES)
977 log(LOG_DEBUG,
591bdbe9 978 " %s dev %d.%d, sd %d, offset 0x%llx, devoffset 0x%llx, length %d\n",
10f3fee5 979 (sbp->b.b_cmd == BUF_CMD_READ) ? "Read" : "Write",
81b5c339
MD
980 major(sddev),
981 minor(sddev),
984263bc 982 sbp->sdno,
54078292
MD
983 sbp->b.b_bio1.bio_offset - ((off_t)SD[sbp->sdno].driveoffset << DEV_BSHIFT),
984 sbp->b.b_bio1.bio_offset,
984263bc
MD
985 sbp->b.b_bcount);
986#endif
407c6ab2 987 crit_enter();
984263bc
MD
988#if VINUMDEBUG
989 if (debug & DEBUG_LASTREQS)
81b5c339 990 logrq(loginfo_sdiol, (union rqinfou) &sbp->b.b_bio1, &sbp->b.b_bio1);
984263bc 991#endif
81b5c339 992 dev_dstrategy(sddev, &sbp->b.b_bio1);
407c6ab2 993 crit_exit();
984263bc
MD
994}
995
996/*
997 * Simplified version of bounds_check_with_label
998 * Determine the size of the transfer, and make sure it is
999 * within the boundaries of the partition. Adjust transfer
1000 * if needed, and signal errors or early completion.
1001 *
1002 * Volumes are simpler than disk slices: they only contain
1003 * one component (though we call them a, b and c to make
1004 * system utilities happy), and they always take up the
1005 * complete space of the "partition".
1006 *
1007 * I'm still not happy with this: why should the label be
1008 * protected? If it weren't so damned difficult to write
1009 * one in the first pleace (because it's protected), it wouldn't
1010 * be a problem.
1011 */
81b5c339
MD
1012struct bio *
1013vinum_bounds_check(struct bio *bio, struct volume *vol)
984263bc 1014{
81b5c339
MD
1015 struct buf *bp = bio->bio_buf;
1016 struct bio *nbio;
984263bc
MD
1017 int maxsize = vol->size; /* size of the partition (sectors) */
1018 int size = (bp->b_bcount + DEV_BSIZE - 1) >> DEV_BSHIFT; /* size of this request (sectors) */
54078292 1019 daddr_t blkno = (daddr_t)(bio->bio_offset >> DEV_BSHIFT);
984263bc
MD
1020
1021 /* Would this transfer overwrite the disk label? */
54078292 1022 if (blkno <= LABELSECTOR /* starts before or at the label */
984263bc 1023#if LABELSECTOR != 0
54078292 1024 && blkno + size > LABELSECTOR /* and finishes after */
984263bc
MD
1025#endif
1026 && (!(vol->flags & VF_RAW)) /* and it's not raw */
10f3fee5 1027 && (bp->b_cmd != BUF_CMD_READ) /* and it's a write */
984263bc
MD
1028 &&(!vol->flags & (VF_WLABEL | VF_LABELLING))) { /* and we're not allowed to write the label */
1029 bp->b_error = EROFS; /* read-only */
1030 bp->b_flags |= B_ERROR;
81b5c339 1031 return (NULL);
984263bc
MD
1032 }
1033 if (size == 0) /* no transfer specified, */
1034 return 0; /* treat as EOF */
1035 /* beyond partition? */
54078292
MD
1036 if (bio->bio_offset < 0 /* negative start */
1037 || blkno + size > maxsize) { /* or goes beyond the end of the partition */
984263bc 1038 /* if exactly at end of disk, return an EOF */
54078292 1039 if (blkno == maxsize) {
984263bc 1040 bp->b_resid = bp->b_bcount;
81b5c339 1041 return (NULL);
984263bc
MD
1042 }
1043 /* or truncate if part of it fits */
54078292 1044 size = maxsize - blkno;
984263bc
MD
1045 if (size <= 0) { /* nothing to transfer */
1046 bp->b_error = EINVAL;
1047 bp->b_flags |= B_ERROR;
81b5c339 1048 return (NULL);
984263bc
MD
1049 }
1050 bp->b_bcount = size << DEV_BSHIFT;
1051 }
81b5c339 1052 nbio = push_bio(bio);
54078292 1053 nbio->bio_offset = bio->bio_offset;
81b5c339 1054 return (nbio);
984263bc
MD
1055}
1056
1057/*
1058 * Allocate a request group and hook
1059 * it in in the list for rq
1060 */
1061struct rqgroup *
1062allocrqg(struct request *rq, int elements)
1063{
1064 struct rqgroup *rqg; /* the one we're going to allocate */
1065 int size = sizeof(struct rqgroup) + elements * sizeof(struct rqelement);
1066
1067 rqg = (struct rqgroup *) Malloc(size);
1068 if (rqg != NULL) { /* malloc OK, */
1069 if (rq->rqg) /* we already have requests */
1070 rq->lrqg->next = rqg; /* hang it off the end */
1071 else /* first request */
1072 rq->rqg = rqg; /* at the start */
1073 rq->lrqg = rqg; /* this one is the last in the list */
1074
1075 bzero(rqg, size); /* no old junk */
1076 rqg->rq = rq; /* point back to the parent request */
1077 rqg->count = elements; /* number of requests in the group */
1078 rqg->lockbase = -1; /* no lock required yet */
1079 }
1080 return rqg;
1081}
1082
1083/*
1084 * Deallocate a request group out of a chain. We do
1085 * this by linear search: the chain is short, this
1086 * almost never happens, and currently it can only
1087 * happen to the first member of the chain.
1088 */
1089void
1090deallocrqg(struct rqgroup *rqg)
1091{
1092 struct rqgroup *rqgc = rqg->rq->rqg; /* point to the request chain */
1093
1094 if (rqg->lock) /* got a lock? */
1095 unlockrange(rqg->plexno, rqg->lock); /* yes, free it */
1096 if (rqgc == rqg) /* we're first in line */
1097 rqg->rq->rqg = rqg->next; /* unhook ourselves */
1098 else {
1099 while ((rqgc->next != NULL) /* find the group */
1100 &&(rqgc->next != rqg))
1101 rqgc = rqgc->next;
1102 if (rqgc->next == NULL)
1103 log(LOG_ERR,
1104 "vinum deallocrqg: rqg %p not found in request %p\n",
1105 rqg->rq,
1106 rqg);
1107 else
1108 rqgc->next = rqg->next; /* make the chain jump over us */
1109 }
1110 Free(rqg);
1111}
1112
1113/* Local Variables: */
1114/* fill-column: 50 */
1115/* End: */