Merge from vendor branch READLINE:
[dragonfly.git] / sys / dev / raid / vinum / vinuminterrupt.c
1 /* vinuminterrupt.c: bottom half of the driver */
2
3 /*-
4  * Copyright (c) 1997, 1998, 1999
5  *      Nan Yang Computer Services Limited.  All rights reserved.
6  *
7  *  Parts copyright (c) 1997, 1998 Cybernet Corporation, NetMAX project.
8  *
9  *  Written by Greg Lehey
10  *
11  *  This software is distributed under the so-called ``Berkeley
12  *  License'':
13  *
14  * Redistribution and use in source and binary forms, with or without
15  * modification, are permitted provided that the following conditions
16  * are met:
17  * 1. Redistributions of source code must retain the above copyright
18  *    notice, this list of conditions and the following disclaimer.
19  * 2. Redistributions in binary form must reproduce the above copyright
20  *    notice, this list of conditions and the following disclaimer in the
21  *    documentation and/or other materials provided with the distribution.
22  * 3. All advertising materials mentioning features or use of this software
23  *    must display the following acknowledgement:
24  *      This product includes software developed by Nan Yang Computer
25  *      Services Limited.
26  * 4. Neither the name of the Company nor the names of its contributors
27  *    may be used to endorse or promote products derived from this software
28  *    without specific prior written permission.
29  *
30  * This software is provided ``as is'', and any express or implied
31  * warranties, including, but not limited to, the implied warranties of
32  * merchantability and fitness for a particular purpose are disclaimed.
33  * In no event shall the company or contributors be liable for any
34  * direct, indirect, incidental, special, exemplary, or consequential
35  * damages (including, but not limited to, procurement of substitute
36  * goods or services; loss of use, data, or profits; or business
37  * interruption) however caused and on any theory of liability, whether
38  * in contract, strict liability, or tort (including negligence or
39  * otherwise) arising in any way out of the use of this software, even if
40  * advised of the possibility of such damage.
41  *
42  * $Id: vinuminterrupt.c,v 1.12 2000/11/24 03:41:42 grog Exp grog $
43  * $FreeBSD: src/sys/dev/vinum/vinuminterrupt.c,v 1.25.2.3 2001/05/28 05:56:27 grog Exp $
44  * $DragonFly: src/sys/dev/raid/vinum/vinuminterrupt.c,v 1.3 2003/08/07 21:17:09 dillon Exp $
45  */
46
47 #include "vinumhdr.h"
48 #include "request.h"
49 #include <sys/resourcevar.h>
50
51 void complete_raid5_write(struct rqelement *);
52 void complete_rqe(struct buf *bp);
53 void sdio_done(struct buf *bp);
54
55 /*
56  * Take a completed buffer, transfer the data back if
57  * it's a read, and complete the high-level request
58  * if this is the last subrequest.
59  *
60  * The bp parameter is in fact a struct rqelement, which
61  * includes a couple of extras at the end.
62  */
63 void
64 complete_rqe(struct buf *bp)
65 {
66     struct rqelement *rqe;
67     struct request *rq;
68     struct rqgroup *rqg;
69     struct buf *ubp;                                        /* user buffer */
70     struct drive *drive;
71     struct sd *sd;
72     char *gravity;                                          /* for error messages */
73
74     rqe = (struct rqelement *) bp;                          /* point to the element that completed */
75     rqg = rqe->rqg;                                         /* and the request group */
76     rq = rqg->rq;                                           /* and the complete request */
77     ubp = rq->bp;                                           /* user buffer */
78
79 #ifdef VINUMDEBUG
80     if (debug & DEBUG_LASTREQS)
81         logrq(loginfo_iodone, (union rqinfou) rqe, ubp);
82 #endif
83     drive = &DRIVE[rqe->driveno];
84     drive->active--;                                        /* one less outstanding I/O on this drive */
85     vinum_conf.active--;                                    /* one less outstanding I/O globally */
86     if ((drive->active == (DRIVE_MAXACTIVE - 1))            /* we were at the drive limit */
87     ||(vinum_conf.active == VINUM_MAXACTIVE))               /* or the global limit */
88         wakeup(&launch_requests);                           /* let another one at it */
89     if ((bp->b_flags & B_ERROR) != 0) {                     /* transfer in error */
90         gravity = "";
91         sd = &SD[rqe->sdno];
92
93         if (bp->b_error != 0)                               /* did it return a number? */
94             rq->error = bp->b_error;                        /* yes, put it in. */
95         else if (rq->error == 0)                            /* no: do we have one already? */
96             rq->error = EIO;                                /* no: catchall "I/O error" */
97         sd->lasterror = rq->error;
98         if (bp->b_flags & B_READ) {
99             if ((rq->error == ENXIO) || (sd->flags & VF_RETRYERRORS) == 0) {
100                 gravity = " fatal";
101                 set_sd_state(rqe->sdno, sd_crashed, setstate_force); /* subdisk is crashed */
102             }
103             log(LOG_ERR,
104                 "%s:%s read error, block %d for %ld bytes\n",
105                 gravity,
106                 sd->name,
107                 bp->b_blkno,
108                 bp->b_bcount);
109         } else {                                            /* write operation */
110             if ((rq->error == ENXIO) || (sd->flags & VF_RETRYERRORS) == 0) {
111                 gravity = "fatal ";
112                 set_sd_state(rqe->sdno, sd_stale, setstate_force); /* subdisk is stale */
113             }
114             log(LOG_ERR,
115                 "%s:%s write error, block %d for %ld bytes\n",
116                 gravity,
117                 sd->name,
118                 bp->b_blkno,
119                 bp->b_bcount);
120         }
121         log(LOG_ERR,
122             "%s: user buffer block %d for %ld bytes\n",
123             sd->name,
124             ubp->b_blkno,
125             ubp->b_bcount);
126         if (rq->error == ENXIO) {                           /* the drive's down too */
127             log(LOG_ERR,
128                 "%s: fatal drive I/O error, block %d for %ld bytes\n",
129                 DRIVE[rqe->driveno].label.name,
130                 bp->b_blkno,
131                 bp->b_bcount);
132             DRIVE[rqe->driveno].lasterror = rq->error;
133             set_drive_state(rqe->driveno,                   /* take the drive down */
134                 drive_down,
135                 setstate_force);
136         }
137     }
138     /* Now update the statistics */
139     if (bp->b_flags & B_READ) {                             /* read operation */
140         DRIVE[rqe->driveno].reads++;
141         DRIVE[rqe->driveno].bytes_read += bp->b_bcount;
142         SD[rqe->sdno].reads++;
143         SD[rqe->sdno].bytes_read += bp->b_bcount;
144         PLEX[rqe->rqg->plexno].reads++;
145         PLEX[rqe->rqg->plexno].bytes_read += bp->b_bcount;
146         if (PLEX[rqe->rqg->plexno].volno >= 0) {            /* volume I/O, not plex */
147             VOL[PLEX[rqe->rqg->plexno].volno].reads++;
148             VOL[PLEX[rqe->rqg->plexno].volno].bytes_read += bp->b_bcount;
149         }
150     } else {                                                /* write operation */
151         DRIVE[rqe->driveno].writes++;
152         DRIVE[rqe->driveno].bytes_written += bp->b_bcount;
153         SD[rqe->sdno].writes++;
154         SD[rqe->sdno].bytes_written += bp->b_bcount;
155         PLEX[rqe->rqg->plexno].writes++;
156         PLEX[rqe->rqg->plexno].bytes_written += bp->b_bcount;
157         if (PLEX[rqe->rqg->plexno].volno >= 0) {            /* volume I/O, not plex */
158             VOL[PLEX[rqe->rqg->plexno].volno].writes++;
159             VOL[PLEX[rqe->rqg->plexno].volno].bytes_written += bp->b_bcount;
160         }
161     }
162     if (rqg->flags & XFR_RECOVERY_READ) {                   /* recovery read, */
163         int *sdata;                                         /* source */
164         int *data;                                          /* and group data */
165         int length;                                         /* and count involved */
166         int count;                                          /* loop counter */
167         struct rqelement *urqe = &rqg->rqe[rqg->badsdno];   /* rqe of the bad subdisk */
168
169         /* XOR destination is the user data */
170         sdata = (int *) &rqe->b.b_data[rqe->groupoffset << DEV_BSHIFT]; /* old data contents */
171         data = (int *) &urqe->b.b_data[urqe->groupoffset << DEV_BSHIFT]; /* destination */
172         length = urqe->grouplen * (DEV_BSIZE / sizeof(int)); /* and number of ints */
173
174         for (count = 0; count < length; count++)
175             data[count] ^= sdata[count];
176
177         /*
178          * In a normal read, we will normally read directly
179          * into the user buffer.  This doesn't work if
180          * we're also doing a recovery, so we have to
181          * copy it
182          */
183         if (rqe->flags & XFR_NORMAL_READ) {                 /* normal read as well, */
184             char *src = &rqe->b.b_data[rqe->dataoffset << DEV_BSHIFT]; /* read data is here */
185             char *dst;
186
187             dst = (char *) ubp->b_data + (rqe->useroffset << DEV_BSHIFT); /* where to put it in user buffer */
188             length = rqe->datalen << DEV_BSHIFT;            /* and count involved */
189             bcopy(src, dst, length);                        /* move it */
190         }
191     } else if ((rqg->flags & (XFR_NORMAL_WRITE | XFR_DEGRADED_WRITE)) /* RAID 4/5 group write operation  */
192     &&(rqg->active == 1))                                   /* and this is the last active request */
193         complete_raid5_write(rqe);
194     /*
195      * This is the earliest place where we can be
196      * sure that the request has really finished,
197      * since complete_raid5_write can issue new
198      * requests.
199      */
200     rqg->active--;                                          /* this request now finished */
201     if (rqg->active == 0) {                                 /* request group finished, */
202         rq->active--;                                       /* one less */
203         if (rqg->lock) {                                    /* got a lock? */
204             unlockrange(rqg->plexno, rqg->lock);            /* yes, free it */
205             rqg->lock = 0;
206         }
207     }
208     if (rq->active == 0) {                                  /* request finished, */
209 #ifdef VINUMDEBUG
210         if (debug & DEBUG_RESID) {
211             if (ubp->b_resid != 0)                          /* still something to transfer? */
212                 Debugger("resid");
213         }
214 #endif
215
216         if (rq->error) {                                    /* did we have an error? */
217             if (rq->isplex) {                               /* plex operation, */
218                 ubp->b_flags |= B_ERROR;                    /* yes, propagate to user */
219                 ubp->b_error = rq->error;
220             } else                                          /* try to recover */
221                 queue_daemon_request(daemonrq_ioerror, (union daemoninfo) rq); /* let the daemon complete */
222         } else {
223             ubp->b_resid = 0;                               /* completed our transfer */
224             if (rq->isplex == 0)                            /* volume request, */
225                 VOL[rq->volplex.volno].active--;            /* another request finished */
226             biodone(ubp);                                   /* top level buffer completed */
227             freerq(rq);                                     /* return the request storage */
228         }
229     }
230 }
231
232 /* Free a request block and anything hanging off it */
233 void
234 freerq(struct request *rq)
235 {
236     struct rqgroup *rqg;
237     struct rqgroup *nrqg;                                   /* next in chain */
238     int rqno;
239
240     for (rqg = rq->rqg; rqg != NULL; rqg = nrqg) {          /* through the whole request chain */
241         if (rqg->lock)                                      /* got a lock? */
242             unlockrange(rqg->plexno, rqg->lock);            /* yes, free it */
243         for (rqno = 0; rqno < rqg->count; rqno++) {
244             if ((rqg->rqe[rqno].flags & XFR_MALLOCED)       /* data buffer was malloced, */
245             &&rqg->rqe[rqno].b.b_data)                      /* and the allocation succeeded */
246                 Free(rqg->rqe[rqno].b.b_data);              /* free it */
247             if (rqg->rqe[rqno].flags & XFR_BUFLOCKED) {     /* locked this buffer, */
248                 BUF_UNLOCK(&rqg->rqe[rqno].b);              /* unlock it again */
249                 BUF_LOCKFREE(&rqg->rqe[rqno].b);
250             }
251         }
252         nrqg = rqg->next;                                   /* note the next one */
253         Free(rqg);                                          /* and free this one */
254     }
255     Free(rq);                                               /* free the request itself */
256 }
257
258 /* I/O on subdisk completed */
259 void
260 sdio_done(struct buf *bp)
261 {
262     struct sdbuf *sbp;
263
264     sbp = (struct sdbuf *) bp;
265     if (sbp->b.b_flags & B_ERROR) {                         /* had an error */
266         sbp->bp->b_flags |= B_ERROR;                        /* propagate upwards */
267         sbp->bp->b_error = sbp->b.b_error;
268     }
269 #ifdef VINUMDEBUG
270     if (debug & DEBUG_LASTREQS)
271         logrq(loginfo_sdiodone, (union rqinfou) bp, bp);
272 #endif
273     sbp->bp->b_resid = sbp->b.b_resid;                      /* copy the resid field */
274     /* Now update the statistics */
275     if (bp->b_flags & B_READ) {                             /* read operation */
276         DRIVE[sbp->driveno].reads++;
277         DRIVE[sbp->driveno].bytes_read += sbp->b.b_bcount;
278         SD[sbp->sdno].reads++;
279         SD[sbp->sdno].bytes_read += sbp->b.b_bcount;
280     } else {                                                /* write operation */
281         DRIVE[sbp->driveno].writes++;
282         DRIVE[sbp->driveno].bytes_written += sbp->b.b_bcount;
283         SD[sbp->sdno].writes++;
284         SD[sbp->sdno].bytes_written += sbp->b.b_bcount;
285     }
286     biodone(sbp->bp);                                       /* complete the caller's I/O */
287     BUF_UNLOCK(&sbp->b);
288     BUF_LOCKFREE(&sbp->b);
289     Free(sbp);
290 }
291
292 /* Start the second phase of a RAID-4 or RAID-5 group write operation. */
293 void
294 complete_raid5_write(struct rqelement *rqe)
295 {
296     int *sdata;                                             /* source */
297     int *pdata;                                             /* and parity block data */
298     int length;                                             /* and count involved */
299     int count;                                              /* loop counter */
300     int rqno;                                               /* request index */
301     int rqoffset;                                           /* offset of request data from parity data */
302     struct buf *ubp;                                        /* user buffer header */
303     struct request *rq;                                     /* pointer to our request */
304     struct rqgroup *rqg;                                    /* and to the request group */
305     struct rqelement *prqe;                                 /* point to the parity block */
306     struct drive *drive;                                    /* drive to access */
307
308     rqg = rqe->rqg;                                         /* and to our request group */
309     rq = rqg->rq;                                           /* point to our request */
310     ubp = rq->bp;                                           /* user's buffer header */
311     prqe = &rqg->rqe[0];                                    /* point to the parity block */
312
313     /*
314      * If we get to this function, we have normal or
315      * degraded writes, or a combination of both.  We do
316      * the same thing in each case: we perform an
317      * exclusive or to the parity block.  The only
318      * difference is the origin of the data and the
319      * address range.
320      */
321     if (rqe->flags & XFR_DEGRADED_WRITE) {                  /* do the degraded write stuff */
322         pdata = (int *) (&prqe->b.b_data[(prqe->groupoffset) << DEV_BSHIFT]); /* parity data pointer */
323         bzero(pdata, prqe->grouplen << DEV_BSHIFT);         /* start with nothing in the parity block */
324
325         /* Now get what data we need from each block */
326         for (rqno = 1; rqno < rqg->count; rqno++) {         /* for all the data blocks */
327             rqe = &rqg->rqe[rqno];                          /* this request */
328             sdata = (int *) (&rqe->b.b_data[rqe->groupoffset << DEV_BSHIFT]); /* old data */
329             length = rqe->grouplen << (DEV_BSHIFT - 2);     /* and count involved */
330
331             /*
332              * Add the data block to the parity block.  Before
333              * we started the request, we zeroed the parity
334              * block, so the result of adding all the other
335              * blocks and the block we want to write will be
336              * the correct parity block.
337              */
338             for (count = 0; count < length; count++)
339                 pdata[count] ^= sdata[count];
340             if ((rqe->flags & XFR_MALLOCED)                 /* the buffer was malloced, */
341             &&((rqg->flags & XFR_NORMAL_WRITE) == 0)) {     /* and we have no normal write, */
342                 Free(rqe->b.b_data);                        /* free it now */
343                 rqe->flags &= ~XFR_MALLOCED;
344             }
345         }
346     }
347     if (rqg->flags & XFR_NORMAL_WRITE) {                    /* do normal write stuff */
348         /* Get what data we need from each block */
349         for (rqno = 1; rqno < rqg->count; rqno++) {         /* for all the data blocks */
350             rqe = &rqg->rqe[rqno];                          /* this request */
351             if ((rqe->flags & (XFR_DATA_BLOCK | XFR_BAD_SUBDISK | XFR_NORMAL_WRITE))
352                 == (XFR_DATA_BLOCK | XFR_NORMAL_WRITE)) {   /* good data block to write */
353                 sdata = (int *) &rqe->b.b_data[rqe->dataoffset << DEV_BSHIFT]; /* old data contents */
354                 rqoffset = rqe->dataoffset + rqe->sdoffset - prqe->sdoffset; /* corresponding parity block offset */
355                 pdata = (int *) (&prqe->b.b_data[rqoffset << DEV_BSHIFT]); /* parity data pointer */
356                 length = rqe->datalen * (DEV_BSIZE / sizeof(int)); /* and number of ints */
357
358                 /*
359                  * "remove" the old data block
360                  * from the parity block
361                  */
362                 if ((pdata < ((int *) prqe->b.b_data))
363                     || (&pdata[length] > ((int *) (prqe->b.b_data + prqe->b.b_bcount)))
364                     || (sdata < ((int *) rqe->b.b_data))
365                     || (&sdata[length] > ((int *) (rqe->b.b_data + rqe->b.b_bcount))))
366                     panic("complete_raid5_write: bounds overflow");
367                 for (count = 0; count < length; count++)
368                     pdata[count] ^= sdata[count];
369
370                 /* "add" the new data block */
371                 sdata = (int *) (&ubp->b_data[rqe->useroffset << DEV_BSHIFT]); /* new data */
372                 if ((sdata < ((int *) ubp->b_data))
373                     || (&sdata[length] > ((int *) (ubp->b_data + ubp->b_bcount))))
374                     panic("complete_raid5_write: bounds overflow");
375                 for (count = 0; count < length; count++)
376                     pdata[count] ^= sdata[count];
377
378                 /* Free the malloced buffer */
379                 if (rqe->flags & XFR_MALLOCED) {            /* the buffer was malloced, */
380                     Free(rqe->b.b_data);                    /* free it */
381                     rqe->flags &= ~XFR_MALLOCED;
382                 } else
383                     panic("complete_raid5_write: malloc conflict");
384
385                 if ((rqe->b.b_flags & B_READ)               /* this was a read */
386                 &&((rqe->flags & XFR_BAD_SUBDISK) == 0)) {  /* and we can write this block */
387                     rqe->b.b_flags &= ~(B_READ | B_DONE);   /* we're writing now */
388                     rqe->b.b_flags |= B_CALL;               /* call us when you're done */
389                     rqe->b.b_iodone = complete_rqe;         /* by calling us here */
390                     rqe->flags &= ~XFR_PARITYOP;            /* reset flags that brought us here */
391                     rqe->b.b_data = &ubp->b_data[rqe->useroffset << DEV_BSHIFT]; /* point to the user data */
392                     rqe->b.b_bcount = rqe->datalen << DEV_BSHIFT; /* length to write */
393                     rqe->b.b_bufsize = rqe->b.b_bcount;     /* don't claim more */
394                     rqe->b.b_resid = rqe->b.b_bcount;       /* nothing transferred */
395                     rqe->b.b_blkno += rqe->dataoffset;      /* point to the correct block */
396                     rqg->active++;                          /* another active request */
397                     drive = &DRIVE[rqe->driveno];           /* drive to access */
398
399                                                             /* We can't sleep here, so we just increment the counters. */
400                     drive->active++;
401                     if (drive->active >= drive->maxactive)
402                         drive->maxactive = drive->active;
403                     vinum_conf.active++;
404                     if (vinum_conf.active >= vinum_conf.maxactive)
405                         vinum_conf.maxactive = vinum_conf.active;
406 #if VINUMDEBUG
407                     if (debug & DEBUG_ADDRESSES)
408                         log(LOG_DEBUG,
409                             "  %s dev %d.%d, sd %d, offset 0x%x, devoffset 0x%x, length %ld\n",
410                             rqe->b.b_flags & B_READ ? "Read" : "Write",
411                             major(rqe->b.b_dev),
412                             minor(rqe->b.b_dev),
413                             rqe->sdno,
414                             (u_int) (rqe->b.b_blkno - SD[rqe->sdno].driveoffset),
415                             rqe->b.b_blkno,
416                             rqe->b.b_bcount);
417                     if (debug & DEBUG_LASTREQS)
418                         logrq(loginfo_raid5_data, (union rqinfou) rqe, ubp);
419 #endif
420                     BUF_STRATEGY(&rqe->b, 0);
421                 }
422             }
423         }
424     }
425     /* Finally, write the parity block */
426     rqe = &rqg->rqe[0];
427     rqe->b.b_flags &= ~(B_READ | B_DONE);                   /* we're writing now */
428     rqe->b.b_flags |= B_CALL;                               /* tell us when you're done */
429     rqe->b.b_iodone = complete_rqe;                         /* by calling us here */
430     rqg->flags &= ~XFR_PARITYOP;                            /* reset flags that brought us here */
431     rqe->b.b_bcount = rqe->buflen << DEV_BSHIFT;            /* length to write */
432     rqe->b.b_bufsize = rqe->b.b_bcount;                     /* don't claim we have more */
433     rqe->b.b_resid = rqe->b.b_bcount;                       /* nothing transferred */
434     rqg->active++;                                          /* another active request */
435     drive = &DRIVE[rqe->driveno];                           /* drive to access */
436
437     /* We can't sleep here, so we just increment the counters. */
438     drive->active++;
439     if (drive->active >= drive->maxactive)
440         drive->maxactive = drive->active;
441     vinum_conf.active++;
442     if (vinum_conf.active >= vinum_conf.maxactive)
443         vinum_conf.maxactive = vinum_conf.active;
444
445 #if VINUMDEBUG
446     if (debug & DEBUG_ADDRESSES)
447         log(LOG_DEBUG,
448             "  %s dev %d.%d, sd %d, offset 0x%x, devoffset 0x%x, length %ld\n",
449             rqe->b.b_flags & B_READ ? "Read" : "Write",
450             major(rqe->b.b_dev),
451             minor(rqe->b.b_dev),
452             rqe->sdno,
453             (u_int) (rqe->b.b_blkno - SD[rqe->sdno].driveoffset),
454             rqe->b.b_blkno,
455             rqe->b.b_bcount);
456     if (debug & DEBUG_LASTREQS)
457         logrq(loginfo_raid5_parity, (union rqinfou) rqe, ubp);
458 #endif
459     BUF_STRATEGY(&rqe->b, 0);
460 }
461
462 /* Local Variables: */
463 /* fill-column: 50 */
464 /* End: */