2 * Copyright (c) 2000 - 2006 Søren Schmidt <sos@FreeBSD.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer,
10 * without modification, immediately at the beginning of the file.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
31 #include <sys/param.h>
32 #include <sys/systm.h>
34 #include <sys/kernel.h>
35 #include <sys/malloc.h>
36 #include <sys/module.h>
37 #include <sys/endian.h>
44 #include <sys/taskqueue.h>
46 #include <machine/bus.h>
48 #include <dev/pci/pcivar.h>
49 #include <geom/geom_disk.h>
50 #include <dev/ata/ata-all.h>
51 #include <dev/ata/ata-disk.h>
52 #include <dev/ata/ata-raid.h>
53 #include <dev/ata/ata-pci.h>
57 static void ata_raid_done(struct ata_request *request);
58 static void ata_raid_config_changed(struct ar_softc *rdp, int writeback);
59 static int ata_raid_status_old(struct ata_ioc_raid_config *config);
60 static int ata_raid_status(struct ata_ioc_raid_status *status);
61 static int ata_raid_create(struct ata_ioc_raid_config *config);
62 static int ata_raid_delete(int array);
63 static int ata_raid_addspare(struct ata_ioc_raid_config *config);
64 static int ata_raid_rebuild(int array);
65 static int ata_raid_read_metadata(device_t subdisk);
66 static int ata_raid_write_metadata(struct ar_softc *rdp);
67 static int ata_raid_wipe_metadata(struct ar_softc *rdp);
68 static int ata_raid_adaptec_read_meta(device_t dev, struct ar_softc **raidp);
69 static int ata_raid_hptv2_read_meta(device_t dev, struct ar_softc **raidp);
70 static int ata_raid_hptv2_write_meta(struct ar_softc *rdp);
71 static int ata_raid_hptv3_read_meta(device_t dev, struct ar_softc **raidp);
72 static int ata_raid_intel_read_meta(device_t dev, struct ar_softc **raidp);
73 static int ata_raid_intel_write_meta(struct ar_softc *rdp);
74 static int ata_raid_ite_read_meta(device_t dev, struct ar_softc **raidp);
75 static int ata_raid_jmicron_read_meta(device_t dev, struct ar_softc **raidp);
76 static int ata_raid_jmicron_write_meta(struct ar_softc *rdp);
77 static int ata_raid_lsiv2_read_meta(device_t dev, struct ar_softc **raidp);
78 static int ata_raid_lsiv3_read_meta(device_t dev, struct ar_softc **raidp);
79 static int ata_raid_nvidia_read_meta(device_t dev, struct ar_softc **raidp);
80 static int ata_raid_promise_read_meta(device_t dev, struct ar_softc **raidp, int native);
81 static int ata_raid_promise_write_meta(struct ar_softc *rdp);
82 static int ata_raid_sii_read_meta(device_t dev, struct ar_softc **raidp);
83 static int ata_raid_sis_read_meta(device_t dev, struct ar_softc **raidp);
84 static int ata_raid_sis_write_meta(struct ar_softc *rdp);
85 static int ata_raid_via_read_meta(device_t dev, struct ar_softc **raidp);
86 static int ata_raid_via_write_meta(struct ar_softc *rdp);
87 static struct ata_request *ata_raid_init_request(struct ar_softc *rdp, struct bio *bio);
88 static int ata_raid_send_request(struct ata_request *request);
89 static int ata_raid_rw(device_t dev, u_int64_t lba, void *data, u_int bcount, int flags);
90 static char * ata_raid_format(struct ar_softc *rdp);
91 static char * ata_raid_type(struct ar_softc *rdp);
92 static char * ata_raid_flags(struct ar_softc *rdp);
95 static void ata_raid_print_meta(struct ar_softc *meta);
96 static void ata_raid_adaptec_print_meta(struct adaptec_raid_conf *meta);
97 static void ata_raid_hptv2_print_meta(struct hptv2_raid_conf *meta);
98 static void ata_raid_hptv3_print_meta(struct hptv3_raid_conf *meta);
99 static void ata_raid_intel_print_meta(struct intel_raid_conf *meta);
100 static void ata_raid_ite_print_meta(struct ite_raid_conf *meta);
101 static void ata_raid_jmicron_print_meta(struct jmicron_raid_conf *meta);
102 static void ata_raid_lsiv2_print_meta(struct lsiv2_raid_conf *meta);
103 static void ata_raid_lsiv3_print_meta(struct lsiv3_raid_conf *meta);
104 static void ata_raid_nvidia_print_meta(struct nvidia_raid_conf *meta);
105 static void ata_raid_promise_print_meta(struct promise_raid_conf *meta);
106 static void ata_raid_sii_print_meta(struct sii_raid_conf *meta);
107 static void ata_raid_sis_print_meta(struct sis_raid_conf *meta);
108 static void ata_raid_via_print_meta(struct via_raid_conf *meta);
111 static struct ar_softc *ata_raid_arrays[MAX_ARRAYS];
112 static MALLOC_DEFINE(M_AR, "ar_driver", "ATA PseudoRAID driver");
113 static devclass_t ata_raid_sub_devclass;
114 static int testing = 0;
116 /* device structures */
117 static disk_strategy_t ata_raid_strategy;
118 static dumper_t ata_raid_dump;
121 ata_raid_attach(struct ar_softc *rdp, int writeback)
126 mtx_init(&rdp->lock, "ATA PseudoRAID metadata lock", NULL, MTX_DEF);
127 ata_raid_config_changed(rdp, writeback);
129 /* sanitize arrays total_size % (width * interleave) == 0 */
130 if (rdp->type == AR_T_RAID0 || rdp->type == AR_T_RAID01 ||
131 rdp->type == AR_T_RAID5) {
132 rdp->total_sectors = (rdp->total_sectors/(rdp->interleave*rdp->width))*
133 (rdp->interleave * rdp->width);
134 sprintf(buffer, " (stripe %d KB)",
135 (rdp->interleave * DEV_BSIZE) / 1024);
139 rdp->disk = disk_alloc();
140 rdp->disk->d_strategy = ata_raid_strategy;
141 rdp->disk->d_dump = ata_raid_dump;
142 rdp->disk->d_name = "ar";
143 rdp->disk->d_sectorsize = DEV_BSIZE;
144 rdp->disk->d_mediasize = (off_t)rdp->total_sectors * DEV_BSIZE;
145 rdp->disk->d_fwsectors = rdp->sectors;
146 rdp->disk->d_fwheads = rdp->heads;
147 rdp->disk->d_maxsize = 128 * DEV_BSIZE;
148 rdp->disk->d_drv1 = rdp;
149 rdp->disk->d_unit = rdp->lun;
150 disk_create(rdp->disk, DISK_VERSION);
152 printf("ar%d: %juMB <%s %s%s> status: %s\n", rdp->lun,
153 rdp->total_sectors / ((1024L * 1024L) / DEV_BSIZE),
154 ata_raid_format(rdp), ata_raid_type(rdp),
155 buffer, ata_raid_flags(rdp));
157 if (testing || bootverbose)
158 printf("ar%d: %ju sectors [%dC/%dH/%dS] <%s> subdisks defined as:\n",
159 rdp->lun, rdp->total_sectors,
160 rdp->cylinders, rdp->heads, rdp->sectors, rdp->name);
162 for (disk = 0; disk < rdp->total_disks; disk++) {
163 printf("ar%d: disk%d ", rdp->lun, disk);
164 if (rdp->disks[disk].dev) {
165 if (rdp->disks[disk].flags & AR_DF_PRESENT) {
166 /* status of this disk in the array */
167 if (rdp->disks[disk].flags & AR_DF_ONLINE)
169 else if (rdp->disks[disk].flags & AR_DF_SPARE)
174 /* what type of disk is this in the array */
178 if (disk < rdp->width)
184 /* which physical disk is used */
185 printf("using %s at ata%d-%s\n",
186 device_get_nameunit(rdp->disks[disk].dev),
187 device_get_unit(device_get_parent(rdp->disks[disk].dev)),
188 (((struct ata_device *)
189 device_get_softc(rdp->disks[disk].dev))->unit ==
190 ATA_MASTER) ? "master" : "slave");
192 else if (rdp->disks[disk].flags & AR_DF_ASSIGNED)
195 printf("INVALID no RAID config on this subdisk\n");
198 printf("DOWN no device found for this subdisk\n");
203 ata_raid_ioctl(u_long cmd, caddr_t data)
205 struct ata_ioc_raid_status *status = (struct ata_ioc_raid_status *)data;
206 struct ata_ioc_raid_config *config = (struct ata_ioc_raid_config *)data;
207 int *lun = (int *)data;
208 int error = EOPNOTSUPP;
211 case IOCATARAIDSTATUS_OLD:
212 error = ata_raid_status_old(config);
215 case IOCATARAIDSTATUS:
216 error = ata_raid_status(status);
219 case IOCATARAIDCREATE:
220 error = ata_raid_create(config);
223 case IOCATARAIDDELETE:
224 error = ata_raid_delete(*lun);
227 case IOCATARAIDADDSPARE:
228 error = ata_raid_addspare(config);
231 case IOCATARAIDREBUILD:
232 error = ata_raid_rebuild(*lun);
239 ata_raid_strategy(struct bio *bp)
241 struct ar_softc *rdp = bp->bio_disk->d_drv1;
242 struct ata_request *request;
244 u_int64_t blkno, lba, blk = 0;
245 int count, chunk, drv, par = 0, change = 0;
247 if (!(rdp->status & AR_S_READY) ||
248 (bp->bio_cmd != BIO_READ && bp->bio_cmd != BIO_WRITE)) {
249 biofinish(bp, NULL, EIO);
253 bp->bio_resid = bp->bio_bcount;
254 for (count = howmany(bp->bio_bcount, DEV_BSIZE),
255 blkno = bp->bio_pblkno, data = bp->bio_data;
257 count -= chunk, blkno += chunk, data += (chunk * DEV_BSIZE)) {
270 while (lba >= rdp->disks[drv].sectors)
271 lba -= rdp->disks[drv++].sectors;
272 chunk = min(rdp->disks[drv].sectors - lba, count);
277 chunk = blkno % rdp->interleave;
278 drv = (blkno / rdp->interleave) % rdp->width;
279 lba = (((blkno/rdp->interleave)/rdp->width)*rdp->interleave)+chunk;
280 chunk = min(count, rdp->interleave - chunk);
284 drv = (blkno / rdp->interleave) % (rdp->width - 1);
285 par = rdp->width - 1 -
286 (blkno / (rdp->interleave * (rdp->width - 1))) % rdp->width;
289 lba = ((blkno/rdp->interleave)/(rdp->width-1))*(rdp->interleave) +
290 ((blkno%(rdp->interleave*(rdp->width-1)))%rdp->interleave);
291 chunk = min(count, rdp->interleave - (lba % rdp->interleave));
295 printf("ar%d: unknown array type in ata_raid_strategy\n", rdp->lun);
296 biofinish(bp, NULL, EIO);
300 /* offset on all but "first on HPTv2" */
301 if (!(drv == 0 && rdp->format == AR_F_HPTV2_RAID))
302 lba += rdp->offset_sectors;
304 if (!(request = ata_raid_init_request(rdp, bp))) {
305 biofinish(bp, NULL, EIO);
308 request->data = data;
309 request->bytecount = chunk * DEV_BSIZE;
310 request->u.ata.lba = lba;
311 request->u.ata.count = request->bytecount / DEV_BSIZE;
317 if (((rdp->disks[drv].flags & (AR_DF_PRESENT|AR_DF_ONLINE)) ==
318 (AR_DF_PRESENT|AR_DF_ONLINE) && !rdp->disks[drv].dev)) {
319 rdp->disks[drv].flags &= ~AR_DF_ONLINE;
320 ata_raid_config_changed(rdp, 1);
321 ata_free_request(request);
322 biofinish(bp, NULL, EIO);
326 request->dev = rdp->disks[request->this].dev;
327 ata_raid_send_request(request);
332 if ((rdp->disks[drv].flags &
333 (AR_DF_PRESENT|AR_DF_ONLINE))==(AR_DF_PRESENT|AR_DF_ONLINE) &&
334 !rdp->disks[drv].dev) {
335 rdp->disks[drv].flags &= ~AR_DF_ONLINE;
338 if ((rdp->disks[drv + rdp->width].flags &
339 (AR_DF_PRESENT|AR_DF_ONLINE))==(AR_DF_PRESENT|AR_DF_ONLINE) &&
340 !rdp->disks[drv + rdp->width].dev) {
341 rdp->disks[drv + rdp->width].flags &= ~AR_DF_ONLINE;
345 ata_raid_config_changed(rdp, 1);
346 if (!(rdp->status & AR_S_READY)) {
347 ata_free_request(request);
348 biofinish(bp, NULL, EIO);
352 if (rdp->status & AR_S_REBUILDING)
353 blk = ((lba / rdp->interleave) * rdp->width) * rdp->interleave +
354 (rdp->interleave * (drv % rdp->width)) +
355 lba % rdp->interleave;;
357 if (bp->bio_cmd == BIO_READ) {
359 (rdp->disks[drv].flags & AR_DF_ONLINE);
361 (rdp->disks[drv+rdp->width].flags & AR_DF_ONLINE);
363 /* if mirror gone or close to last access on source */
367 (rdp->disks[drv].last_lba - AR_PROXIMITY) &&
369 (rdp->disks[drv].last_lba + AR_PROXIMITY))) {
372 /* if source gone or close to last access on mirror */
373 else if (!src_online ||
376 (rdp->disks[drv+rdp->width].last_lba-AR_PROXIMITY) &&
378 (rdp->disks[drv+rdp->width].last_lba+AR_PROXIMITY))) {
382 /* not close to any previous access, toggle */
392 if ((rdp->status & AR_S_REBUILDING) &&
393 (blk <= rdp->rebuild_lba) &&
394 ((blk + chunk) > rdp->rebuild_lba)) {
395 struct ata_composite *composite;
396 struct ata_request *rebuild;
399 /* figure out what part to rebuild */
400 if (drv < rdp->width)
401 this = drv + rdp->width;
403 this = drv - rdp->width;
405 /* do we have a spare to rebuild on ? */
406 if (rdp->disks[this].flags & AR_DF_SPARE) {
407 if ((composite = ata_alloc_composite())) {
408 if ((rebuild = ata_alloc_request())) {
409 rdp->rebuild_lba = blk + chunk;
410 bcopy(request, rebuild,
411 sizeof(struct ata_request));
412 rebuild->this = this;
413 rebuild->dev = rdp->disks[this].dev;
414 rebuild->flags &= ~ATA_R_READ;
415 rebuild->flags |= ATA_R_WRITE;
416 mtx_init(&composite->lock,
417 "ATA PseudoRAID rebuild lock",
419 composite->residual = request->bytecount;
420 composite->rd_needed |= (1 << drv);
421 composite->wr_depend |= (1 << drv);
422 composite->wr_needed |= (1 << this);
423 composite->request[drv] = request;
424 composite->request[this] = rebuild;
425 request->composite = composite;
426 rebuild->composite = composite;
427 ata_raid_send_request(rebuild);
430 ata_free_composite(composite);
431 printf("DOH! ata_alloc_request failed!\n");
435 printf("DOH! ata_alloc_composite failed!\n");
438 else if (rdp->disks[this].flags & AR_DF_ONLINE) {
440 * if we got here we are a chunk of a RAID01 that
441 * does not need a rebuild, but we need to increment
442 * the rebuild_lba address to get the rebuild to
443 * move to the next chunk correctly
445 rdp->rebuild_lba = blk + chunk;
448 printf("DOH! we didn't find the rebuild part\n");
451 if (bp->bio_cmd == BIO_WRITE) {
452 if ((rdp->disks[drv+rdp->width].flags & AR_DF_ONLINE) ||
453 ((rdp->status & AR_S_REBUILDING) &&
454 (rdp->disks[drv+rdp->width].flags & AR_DF_SPARE) &&
455 ((blk < rdp->rebuild_lba) ||
456 ((blk <= rdp->rebuild_lba) &&
457 ((blk + chunk) > rdp->rebuild_lba))))) {
458 if ((rdp->disks[drv].flags & AR_DF_ONLINE) ||
459 ((rdp->status & AR_S_REBUILDING) &&
460 (rdp->disks[drv].flags & AR_DF_SPARE) &&
461 ((blk < rdp->rebuild_lba) ||
462 ((blk <= rdp->rebuild_lba) &&
463 ((blk + chunk) > rdp->rebuild_lba))))) {
464 struct ata_request *mirror;
465 struct ata_composite *composite;
466 int this = drv + rdp->width;
468 if ((composite = ata_alloc_composite())) {
469 if ((mirror = ata_alloc_request())) {
470 if ((blk <= rdp->rebuild_lba) &&
471 ((blk + chunk) > rdp->rebuild_lba))
472 rdp->rebuild_lba = blk + chunk;
473 bcopy(request, mirror,
474 sizeof(struct ata_request));
476 mirror->dev = rdp->disks[this].dev;
477 mtx_init(&composite->lock,
478 "ATA PseudoRAID mirror lock",
480 composite->residual = request->bytecount;
481 composite->wr_needed |= (1 << drv);
482 composite->wr_needed |= (1 << this);
483 composite->request[drv] = request;
484 composite->request[this] = mirror;
485 request->composite = composite;
486 mirror->composite = composite;
487 ata_raid_send_request(mirror);
488 rdp->disks[this].last_lba =
489 bp->bio_pblkno + chunk;
492 ata_free_composite(composite);
493 printf("DOH! ata_alloc_request failed!\n");
497 printf("DOH! ata_alloc_composite failed!\n");
505 request->dev = rdp->disks[request->this].dev;
506 ata_raid_send_request(request);
507 rdp->disks[request->this].last_lba = bp->bio_pblkno + chunk;
511 if (((rdp->disks[drv].flags & (AR_DF_PRESENT|AR_DF_ONLINE)) ==
512 (AR_DF_PRESENT|AR_DF_ONLINE) && !rdp->disks[drv].dev)) {
513 rdp->disks[drv].flags &= ~AR_DF_ONLINE;
516 if (((rdp->disks[par].flags & (AR_DF_PRESENT|AR_DF_ONLINE)) ==
517 (AR_DF_PRESENT|AR_DF_ONLINE) && !rdp->disks[par].dev)) {
518 rdp->disks[par].flags &= ~AR_DF_ONLINE;
522 ata_raid_config_changed(rdp, 1);
523 if (!(rdp->status & AR_S_READY)) {
524 ata_free_request(request);
525 biofinish(bp, NULL, EIO);
528 if (rdp->status & AR_S_DEGRADED) {
529 /* do the XOR game if possible */
533 request->dev = rdp->disks[request->this].dev;
534 if (bp->bio_cmd == BIO_READ) {
535 ata_raid_send_request(request);
537 if (bp->bio_cmd == BIO_WRITE) {
538 ata_raid_send_request(request);
539 // sikre at læs-modify-skriv til hver disk er atomarisk.
540 // par kopi af request
541 // læse orgdata fra drv
542 // skriv nydata til drv
543 // læse parorgdata fra par
544 // skriv orgdata xor parorgdata xor nydata til par
550 printf("ar%d: unknown array type in ata_raid_strategy\n", rdp->lun);
556 ata_raid_done(struct ata_request *request)
558 struct ar_softc *rdp = request->driver;
559 struct ata_composite *composite = NULL;
560 struct bio *bp = request->bio;
561 int i, mirror, finished = 0;
567 if (request->result) {
568 rdp->disks[request->this].flags &= ~AR_DF_ONLINE;
569 ata_raid_config_changed(rdp, 1);
570 bp->bio_error = request->result;
574 bp->bio_resid -= request->donecount;
582 if (request->this < rdp->width)
583 mirror = request->this + rdp->width;
585 mirror = request->this - rdp->width;
586 if (request->result) {
587 rdp->disks[request->this].flags &= ~AR_DF_ONLINE;
588 ata_raid_config_changed(rdp, 1);
590 if (rdp->status & AR_S_READY) {
593 if (rdp->status & AR_S_REBUILDING)
594 blk = ((request->u.ata.lba / rdp->interleave) * rdp->width) *
595 rdp->interleave + (rdp->interleave *
596 (request->this % rdp->width)) +
597 request->u.ata.lba % rdp->interleave;
599 if (bp->bio_cmd == BIO_READ) {
601 /* is this a rebuild composite */
602 if ((composite = request->composite)) {
603 mtx_lock(&composite->lock);
605 /* handle the read part of a rebuild composite */
606 if (request->flags & ATA_R_READ) {
608 /* if read failed array is now broken */
609 if (request->result) {
610 rdp->disks[request->this].flags &= ~AR_DF_ONLINE;
611 ata_raid_config_changed(rdp, 1);
612 bp->bio_error = request->result;
613 rdp->rebuild_lba = blk;
617 /* good data, update how far we've gotten */
619 bp->bio_resid -= request->donecount;
620 composite->residual -= request->donecount;
621 if (!composite->residual) {
622 if (composite->wr_done & (1 << mirror))
628 /* handle the write part of a rebuild composite */
629 else if (request->flags & ATA_R_WRITE) {
630 if (composite->rd_done & (1 << mirror)) {
631 if (request->result) {
632 printf("DOH! rebuild failed\n"); /* XXX SOS */
633 rdp->rebuild_lba = blk;
635 if (!composite->residual)
639 mtx_unlock(&composite->lock);
642 /* if read failed retry on the mirror */
643 else if (request->result) {
644 request->dev = rdp->disks[mirror].dev;
645 request->flags &= ~ATA_R_TIMEOUT;
646 ata_raid_send_request(request);
650 /* we have good data */
652 bp->bio_resid -= request->donecount;
657 else if (bp->bio_cmd == BIO_WRITE) {
658 /* do we have a mirror or rebuild to deal with ? */
659 if ((composite = request->composite)) {
660 mtx_lock(&composite->lock);
661 if (composite->wr_done & (1 << mirror)) {
662 if (request->result) {
663 if (composite->request[mirror]->result) {
664 printf("DOH! all disks failed and got here\n");
667 if (rdp->status & AR_S_REBUILDING) {
668 rdp->rebuild_lba = blk;
669 printf("DOH! rebuild failed\n"); /* XXX SOS */
672 composite->request[mirror]->donecount;
673 composite->residual -=
674 composite->request[mirror]->donecount;
677 bp->bio_resid -= request->donecount;
678 composite->residual -= request->donecount;
680 if (!composite->residual)
683 mtx_unlock(&composite->lock);
685 /* no mirror we are done */
687 bp->bio_resid -= request->donecount;
694 biofinish(bp, NULL, request->result);
698 if (request->result) {
699 rdp->disks[request->this].flags &= ~AR_DF_ONLINE;
700 ata_raid_config_changed(rdp, 1);
701 if (rdp->status & AR_S_READY) {
702 if (bp->bio_cmd == BIO_READ) {
703 /* do the XOR game to recover data */
705 if (bp->bio_cmd == BIO_WRITE) {
706 /* if the parity failed we're OK sortof */
707 /* otherwise wee need to do the XOR long dance */
712 biofinish(bp, NULL, request->result);
715 // did we have an XOR game going ??
716 bp->bio_resid -= request->donecount;
723 printf("ar%d: unknown array type in ata_raid_done\n", rdp->lun);
727 if ((rdp->status & AR_S_REBUILDING) &&
728 rdp->rebuild_lba >= rdp->total_sectors) {
731 for (disk = 0; disk < rdp->total_disks; disk++) {
732 if ((rdp->disks[disk].flags &
733 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_SPARE)) ==
734 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_SPARE)) {
735 rdp->disks[disk].flags &= ~AR_DF_SPARE;
736 rdp->disks[disk].flags |= AR_DF_ONLINE;
739 rdp->status &= ~AR_S_REBUILDING;
740 ata_raid_config_changed(rdp, 1);
748 /* we are done with this composite, free all resources */
749 for (i = 0; i < 32; i++) {
750 if (composite->rd_needed & (1 << i) ||
751 composite->wr_needed & (1 << i)) {
752 ata_free_request(composite->request[i]);
755 mtx_destroy(&composite->lock);
756 ata_free_composite(composite);
760 ata_free_request(request);
764 ata_raid_dump(void *arg, void *virtual, vm_offset_t physical,
765 off_t offset, size_t length)
767 struct disk *dp = arg;
768 struct ar_softc *rdp = dp->d_drv1;
771 /* length zero is special and really means flush buffers to media */
775 for (disk = 0, error = 0; disk < rdp->total_disks; disk++)
776 if (rdp->disks[disk].dev)
777 error |= ata_controlcmd(rdp->disks[disk].dev,
778 ATA_FLUSHCACHE, 0, 0, 0);
779 return (error ? EIO : 0);
782 bzero(&bp, sizeof(struct bio));
784 bp.bio_pblkno = offset / DEV_BSIZE;
785 bp.bio_bcount = length;
786 bp.bio_data = virtual;
787 bp.bio_cmd = BIO_WRITE;
788 ata_raid_strategy(&bp);
793 ata_raid_config_changed(struct ar_softc *rdp, int writeback)
795 int disk, count, status;
797 mtx_lock(&rdp->lock);
798 /* set default all working mode */
799 status = rdp->status;
800 rdp->status &= ~AR_S_DEGRADED;
801 rdp->status |= AR_S_READY;
803 /* make sure all lost drives are accounted for */
804 for (disk = 0; disk < rdp->total_disks; disk++) {
805 if (!(rdp->disks[disk].flags & AR_DF_PRESENT))
806 rdp->disks[disk].flags &= ~AR_DF_ONLINE;
809 /* depending on RAID type figure out our health status */
814 for (disk = 0; disk < rdp->total_disks; disk++)
815 if (!(rdp->disks[disk].flags & AR_DF_ONLINE))
816 rdp->status &= ~AR_S_READY;
821 for (disk = 0; disk < rdp->width; disk++) {
822 if (!(rdp->disks[disk].flags & AR_DF_ONLINE) &&
823 !(rdp->disks[disk + rdp->width].flags & AR_DF_ONLINE)) {
824 rdp->status &= ~AR_S_READY;
826 else if (((rdp->disks[disk].flags & AR_DF_ONLINE) &&
827 !(rdp->disks[disk + rdp->width].flags & AR_DF_ONLINE)) ||
828 (!(rdp->disks[disk].flags & AR_DF_ONLINE) &&
829 (rdp->disks [disk + rdp->width].flags & AR_DF_ONLINE))) {
830 rdp->status |= AR_S_DEGRADED;
836 for (count = 0, disk = 0; disk < rdp->total_disks; disk++) {
837 if (!(rdp->disks[disk].flags & AR_DF_ONLINE))
842 rdp->status &= ~AR_S_READY;
844 rdp->status |= AR_S_DEGRADED;
848 rdp->status &= ~AR_S_READY;
851 if (rdp->status != status) {
852 if (!(rdp->status & AR_S_READY)) {
853 printf("ar%d: FAILURE - %s array broken\n",
854 rdp->lun, ata_raid_type(rdp));
856 else if (rdp->status & AR_S_DEGRADED) {
857 if (rdp->type & (AR_T_RAID1 | AR_T_RAID01))
858 printf("ar%d: WARNING - mirror", rdp->lun);
860 printf("ar%d: WARNING - parity", rdp->lun);
861 printf(" protection lost. %s array in DEGRADED mode\n",
865 mtx_unlock(&rdp->lock);
867 ata_raid_write_metadata(rdp);
872 ata_raid_status_old(struct ata_ioc_raid_config *config)
874 struct ata_ioc_raid_status status;
877 status.lun = config->lun;
878 error = ata_raid_status(&status);
882 config->type = status.type;
883 config->total_disks = status.total_disks;
884 config->interleave = status.interleave;
885 config->status = status.status;
886 config->progress = status.progress;
888 for (i = 0; i < config->total_disks; i++)
889 config->disks[i] = status.disks[i].lun;
894 ata_raid_status(struct ata_ioc_raid_status *status)
896 struct ar_softc *rdp;
899 if (!(rdp = ata_raid_arrays[status->lun]))
902 status->type = rdp->type;
903 status->total_disks = rdp->total_disks;
904 for (i = 0; i < rdp->total_disks; i++ ) {
905 status->disks[i].state = 0;
906 if ((rdp->disks[i].flags & AR_DF_PRESENT) && rdp->disks[i].dev) {
907 status->disks[i].lun = device_get_unit(rdp->disks[i].dev);
908 if (rdp->disks[i].flags & AR_DF_PRESENT)
909 status->disks[i].state |= AR_DISK_PRESENT;
910 if (rdp->disks[i].flags & AR_DF_ONLINE)
911 status->disks[i].state |= AR_DISK_ONLINE;
912 if (rdp->disks[i].flags & AR_DF_SPARE)
913 status->disks[i].state |= AR_DISK_SPARE;
915 status->disks[i].lun = -1;
917 status->interleave = rdp->interleave;
918 status->status = rdp->status;
919 status->progress = 100 * rdp->rebuild_lba / rdp->total_sectors;
924 ata_raid_create(struct ata_ioc_raid_config *config)
926 struct ar_softc *rdp;
929 int ctlr = 0, disk_size = 0, total_disks = 0;
931 for (array = 0; array < MAX_ARRAYS; array++) {
932 if (!ata_raid_arrays[array])
935 if (array >= MAX_ARRAYS)
938 if (!(rdp = (struct ar_softc*)malloc(sizeof(struct ar_softc), M_AR,
939 M_NOWAIT | M_ZERO))) {
940 printf("ar%d: no memory for metadata storage\n", array);
944 for (disk = 0; disk < config->total_disks; disk++) {
945 if ((subdisk = devclass_get_device(ata_raid_sub_devclass,
946 config->disks[disk]))) {
947 struct ata_raid_subdisk *ars = device_get_softc(subdisk);
949 /* is device already assigned to another array ? */
950 if (ars->raid[rdp->volume]) {
951 config->disks[disk] = -1;
955 rdp->disks[disk].dev = device_get_parent(subdisk);
957 switch (pci_get_vendor(GRANDPARENT(rdp->disks[disk].dev))) {
958 case ATA_HIGHPOINT_ID:
960 * we need some way to decide if it should be v2 or v3
961 * for now just use v2 since the v3 BIOS knows how to
962 * handle that as well.
964 ctlr = AR_F_HPTV2_RAID;
965 rdp->disks[disk].sectors = HPTV3_LBA(rdp->disks[disk].dev);
969 ctlr = AR_F_INTEL_RAID;
970 rdp->disks[disk].sectors = INTEL_LBA(rdp->disks[disk].dev);
974 ctlr = AR_F_ITE_RAID;
975 rdp->disks[disk].sectors = ITE_LBA(rdp->disks[disk].dev);
979 ctlr = AR_F_JMICRON_RAID;
980 rdp->disks[disk].sectors = JMICRON_LBA(rdp->disks[disk].dev);
983 case 0: /* XXX SOS cover up for bug in our PCI code */
985 ctlr = AR_F_PROMISE_RAID;
986 rdp->disks[disk].sectors = PROMISE_LBA(rdp->disks[disk].dev);
990 ctlr = AR_F_SIS_RAID;
991 rdp->disks[disk].sectors = SIS_LBA(rdp->disks[disk].dev);
996 ctlr = AR_F_VIA_RAID;
997 rdp->disks[disk].sectors = VIA_LBA(rdp->disks[disk].dev);
1002 * right, so here we are, we have an ATA chip and we want
1003 * to create a RAID and store the metadata.
1004 * we need to find a way to tell what kind of metadata this
1005 * hardware's BIOS might be using (good ideas are welcomed)
1006 * for now we just use our own native FreeBSD format.
1007 * the only way to get support for the BIOS format is to
1008 * setup the RAID from there, in that case we pickup the
1009 * metadata format from the disks (if we support it).
1011 printf("WARNING!! - not able to determine metadata format\n"
1012 "WARNING!! - Using FreeBSD PseudoRAID metadata\n"
1013 "If that is not what you want, use the BIOS to "
1014 "create the array\n");
1015 ctlr = AR_F_FREEBSD_RAID;
1016 rdp->disks[disk].sectors = PROMISE_LBA(rdp->disks[disk].dev);
1020 /* we need all disks to be of the same format */
1021 if ((rdp->format & AR_F_FORMAT_MASK) &&
1022 (rdp->format & AR_F_FORMAT_MASK) != (ctlr & AR_F_FORMAT_MASK)) {
1029 /* use the smallest disk of the lots size */
1030 /* gigabyte boundry ??? XXX SOS */
1032 disk_size = min(rdp->disks[disk].sectors, disk_size);
1034 disk_size = rdp->disks[disk].sectors;
1035 rdp->disks[disk].flags =
1036 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_ONLINE);
1041 config->disks[disk] = -1;
1047 if (total_disks != config->total_disks) {
1052 switch (config->type) {
1059 if (total_disks != 2) {
1066 if (total_disks % 2 != 0) {
1073 if (total_disks < 3) {
1083 rdp->type = config->type;
1085 if (rdp->type == AR_T_RAID0 || rdp->type == AR_T_RAID01 ||
1086 rdp->type == AR_T_RAID5) {
1089 while (config->interleave >>= 1)
1091 rdp->interleave = 1 << bit;
1093 rdp->offset_sectors = 0;
1095 /* values that depend on metadata format */
1096 switch (rdp->format) {
1097 case AR_F_ADAPTEC_RAID:
1098 rdp->interleave = min(max(32, rdp->interleave), 128); /*+*/
1101 case AR_F_HPTV2_RAID:
1102 rdp->interleave = min(max(8, rdp->interleave), 128); /*+*/
1103 rdp->offset_sectors = HPTV2_LBA(x) + 1;
1106 case AR_F_HPTV3_RAID:
1107 rdp->interleave = min(max(32, rdp->interleave), 4096); /*+*/
1110 case AR_F_INTEL_RAID:
1111 rdp->interleave = min(max(8, rdp->interleave), 256); /*+*/
1115 rdp->interleave = min(max(2, rdp->interleave), 128); /*+*/
1118 case AR_F_JMICRON_RAID:
1119 rdp->interleave = min(max(8, rdp->interleave), 256); /*+*/
1122 case AR_F_LSIV2_RAID:
1123 rdp->interleave = min(max(2, rdp->interleave), 4096);
1126 case AR_F_LSIV3_RAID:
1127 rdp->interleave = min(max(2, rdp->interleave), 256);
1130 case AR_F_PROMISE_RAID:
1131 rdp->interleave = min(max(2, rdp->interleave), 2048); /*+*/
1135 rdp->interleave = min(max(8, rdp->interleave), 256); /*+*/
1139 rdp->interleave = min(max(32, rdp->interleave), 512); /*+*/
1143 rdp->interleave = min(max(8, rdp->interleave), 128); /*+*/
1147 rdp->total_disks = total_disks;
1148 rdp->width = total_disks / (rdp->type & (AR_RAID1 | AR_T_RAID01) ? 2 : 1);
1149 rdp->total_sectors = disk_size * (rdp->width - (rdp->type == AR_RAID5));
1152 rdp->cylinders = rdp->total_sectors / (255 * 63);
1153 rdp->rebuild_lba = 0;
1154 rdp->status |= AR_S_READY;
1156 /* we are committed to this array, grap the subdisks */
1157 for (disk = 0; disk < config->total_disks; disk++) {
1158 if ((subdisk = devclass_get_device(ata_raid_sub_devclass,
1159 config->disks[disk]))) {
1160 struct ata_raid_subdisk *ars = device_get_softc(subdisk);
1162 ars->raid[rdp->volume] = rdp;
1163 ars->disk_number[rdp->volume] = disk;
1166 ata_raid_attach(rdp, 1);
1167 ata_raid_arrays[array] = rdp;
1168 config->lun = array;
1173 ata_raid_delete(int array)
1175 struct ar_softc *rdp;
1179 if (!(rdp = ata_raid_arrays[array]))
1182 rdp->status &= ~AR_S_READY;
1184 disk_destroy(rdp->disk);
1186 for (disk = 0; disk < rdp->total_disks; disk++) {
1187 if ((rdp->disks[disk].flags & AR_DF_PRESENT) && rdp->disks[disk].dev) {
1188 if ((subdisk = devclass_get_device(ata_raid_sub_devclass,
1189 device_get_unit(rdp->disks[disk].dev)))) {
1190 struct ata_raid_subdisk *ars = device_get_softc(subdisk);
1192 if (ars->raid[rdp->volume] != rdp) /* XXX SOS */
1193 device_printf(subdisk, "DOH! this disk doesn't belong\n");
1194 if (ars->disk_number[rdp->volume] != disk) /* XXX SOS */
1195 device_printf(subdisk, "DOH! this disk number is wrong\n");
1196 ars->raid[rdp->volume] = NULL;
1197 ars->disk_number[rdp->volume] = -1;
1199 rdp->disks[disk].flags = 0;
1202 ata_raid_wipe_metadata(rdp);
1203 ata_raid_arrays[array] = NULL;
1209 ata_raid_addspare(struct ata_ioc_raid_config *config)
1211 struct ar_softc *rdp;
1215 if (!(rdp = ata_raid_arrays[config->lun]))
1217 if (!(rdp->status & AR_S_DEGRADED) || !(rdp->status & AR_S_READY))
1219 if (rdp->status & AR_S_REBUILDING)
1221 switch (rdp->type) {
1225 for (disk = 0; disk < rdp->total_disks; disk++ ) {
1227 if (((rdp->disks[disk].flags & (AR_DF_PRESENT | AR_DF_ONLINE)) ==
1228 (AR_DF_PRESENT | AR_DF_ONLINE)) && rdp->disks[disk].dev)
1231 if ((subdisk = devclass_get_device(ata_raid_sub_devclass,
1232 config->disks[0] ))) {
1233 struct ata_raid_subdisk *ars = device_get_softc(subdisk);
1235 if (ars->raid[rdp->volume])
1238 /* XXX SOS validate size etc etc */
1239 ars->raid[rdp->volume] = rdp;
1240 ars->disk_number[rdp->volume] = disk;
1241 rdp->disks[disk].dev = device_get_parent(subdisk);
1242 rdp->disks[disk].flags =
1243 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_SPARE);
1245 device_printf(rdp->disks[disk].dev,
1246 "inserted into ar%d disk%d as spare\n",
1248 ata_raid_config_changed(rdp, 1);
1260 ata_raid_rebuild(int array)
1262 struct ar_softc *rdp;
1265 if (!(rdp = ata_raid_arrays[array]))
1267 /* XXX SOS we should lock the rdp softc here */
1268 if (!(rdp->status & AR_S_DEGRADED) || !(rdp->status & AR_S_READY))
1270 if (rdp->status & AR_S_REBUILDING)
1273 switch (rdp->type) {
1277 for (count = 0, disk = 0; disk < rdp->total_disks; disk++ ) {
1278 if (((rdp->disks[disk].flags &
1279 (AR_DF_PRESENT|AR_DF_ASSIGNED|AR_DF_ONLINE|AR_DF_SPARE)) ==
1280 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_SPARE)) &&
1281 rdp->disks[disk].dev) {
1287 rdp->rebuild_lba = 0;
1288 rdp->status |= AR_S_REBUILDING;
1299 ata_raid_read_metadata(device_t subdisk)
1301 devclass_t pci_devclass = devclass_find("pci");
1302 devclass_t devclass=device_get_devclass(GRANDPARENT(GRANDPARENT(subdisk)));
1304 /* prioritize vendor native metadata layout if possible */
1305 if (devclass == pci_devclass) {
1306 switch (pci_get_vendor(GRANDPARENT(device_get_parent(subdisk)))) {
1307 case ATA_HIGHPOINT_ID:
1308 if (ata_raid_hptv3_read_meta(subdisk, ata_raid_arrays))
1310 if (ata_raid_hptv2_read_meta(subdisk, ata_raid_arrays))
1315 if (ata_raid_intel_read_meta(subdisk, ata_raid_arrays))
1320 if (ata_raid_ite_read_meta(subdisk, ata_raid_arrays))
1324 case ATA_JMICRON_ID:
1325 if (ata_raid_jmicron_read_meta(subdisk, ata_raid_arrays))
1330 if (ata_raid_nvidia_read_meta(subdisk, ata_raid_arrays))
1334 case 0: /* XXX SOS cover up for bug in our PCI code */
1335 case ATA_PROMISE_ID:
1336 if (ata_raid_promise_read_meta(subdisk, ata_raid_arrays, 0))
1341 case ATA_SILICON_IMAGE_ID:
1342 if (ata_raid_sii_read_meta(subdisk, ata_raid_arrays))
1347 if (ata_raid_sis_read_meta(subdisk, ata_raid_arrays))
1352 if (ata_raid_via_read_meta(subdisk, ata_raid_arrays))
1358 /* handle controllers that have multiple layout possibilities */
1359 /* NOTE: the order of these are not insignificant */
1361 /* Adaptec HostRAID */
1362 if (ata_raid_adaptec_read_meta(subdisk, ata_raid_arrays))
1365 /* LSILogic v3 and v2 */
1366 if (ata_raid_lsiv3_read_meta(subdisk, ata_raid_arrays))
1368 if (ata_raid_lsiv2_read_meta(subdisk, ata_raid_arrays))
1371 /* if none of the above matched, try FreeBSD native format */
1372 return ata_raid_promise_read_meta(subdisk, ata_raid_arrays, 1);
1376 ata_raid_write_metadata(struct ar_softc *rdp)
1378 switch (rdp->format) {
1379 case AR_F_FREEBSD_RAID:
1380 case AR_F_PROMISE_RAID:
1381 return ata_raid_promise_write_meta(rdp);
1383 case AR_F_HPTV3_RAID:
1384 case AR_F_HPTV2_RAID:
1386 * always write HPT v2 metadata, the v3 BIOS knows it as well.
1387 * this is handy since we cannot know what version BIOS is on there
1389 return ata_raid_hptv2_write_meta(rdp);
1391 case AR_F_INTEL_RAID:
1392 return ata_raid_intel_write_meta(rdp);
1394 case AR_F_JMICRON_RAID:
1395 return ata_raid_jmicron_write_meta(rdp);
1398 return ata_raid_sis_write_meta(rdp);
1401 return ata_raid_via_write_meta(rdp);
1403 case AR_F_HPTV3_RAID:
1404 return ata_raid_hptv3_write_meta(rdp);
1406 case AR_F_ADAPTEC_RAID:
1407 return ata_raid_adaptec_write_meta(rdp);
1410 return ata_raid_ite_write_meta(rdp);
1412 case AR_F_LSIV2_RAID:
1413 return ata_raid_lsiv2_write_meta(rdp);
1415 case AR_F_LSIV3_RAID:
1416 return ata_raid_lsiv3_write_meta(rdp);
1418 case AR_F_NVIDIA_RAID:
1419 return ata_raid_nvidia_write_meta(rdp);
1422 return ata_raid_sii_write_meta(rdp);
1426 printf("ar%d: writing of %s metadata is NOT supported yet\n",
1427 rdp->lun, ata_raid_format(rdp));
1433 ata_raid_wipe_metadata(struct ar_softc *rdp)
1435 int disk, error = 0;
1440 for (disk = 0; disk < rdp->total_disks; disk++) {
1441 if (rdp->disks[disk].dev) {
1442 switch (rdp->format) {
1443 case AR_F_ADAPTEC_RAID:
1444 lba = ADP_LBA(rdp->disks[disk].dev);
1445 size = sizeof(struct adaptec_raid_conf);
1448 case AR_F_HPTV2_RAID:
1449 lba = HPTV2_LBA(rdp->disks[disk].dev);
1450 size = sizeof(struct hptv2_raid_conf);
1453 case AR_F_HPTV3_RAID:
1454 lba = HPTV3_LBA(rdp->disks[disk].dev);
1455 size = sizeof(struct hptv3_raid_conf);
1458 case AR_F_INTEL_RAID:
1459 lba = INTEL_LBA(rdp->disks[disk].dev);
1460 size = 3 * 512; /* XXX SOS */
1464 lba = ITE_LBA(rdp->disks[disk].dev);
1465 size = sizeof(struct ite_raid_conf);
1468 case AR_F_JMICRON_RAID:
1469 lba = JMICRON_LBA(rdp->disks[disk].dev);
1470 size = sizeof(struct jmicron_raid_conf);
1473 case AR_F_LSIV2_RAID:
1474 lba = LSIV2_LBA(rdp->disks[disk].dev);
1475 size = sizeof(struct lsiv2_raid_conf);
1478 case AR_F_LSIV3_RAID:
1479 lba = LSIV3_LBA(rdp->disks[disk].dev);
1480 size = sizeof(struct lsiv3_raid_conf);
1483 case AR_F_NVIDIA_RAID:
1484 lba = NVIDIA_LBA(rdp->disks[disk].dev);
1485 size = sizeof(struct nvidia_raid_conf);
1488 case AR_F_FREEBSD_RAID:
1489 case AR_F_PROMISE_RAID:
1490 lba = PROMISE_LBA(rdp->disks[disk].dev);
1491 size = sizeof(struct promise_raid_conf);
1495 lba = SII_LBA(rdp->disks[disk].dev);
1496 size = sizeof(struct sii_raid_conf);
1500 lba = SIS_LBA(rdp->disks[disk].dev);
1501 size = sizeof(struct sis_raid_conf);
1505 lba = VIA_LBA(rdp->disks[disk].dev);
1506 size = sizeof(struct via_raid_conf);
1510 printf("ar%d: wiping of %s metadata is NOT supported yet\n",
1511 rdp->lun, ata_raid_format(rdp));
1514 if (!(meta = malloc(size, M_AR, M_NOWAIT | M_ZERO)))
1516 if (ata_raid_rw(rdp->disks[disk].dev, lba, meta, size,
1517 ATA_R_WRITE | ATA_R_DIRECT)) {
1518 device_printf(rdp->disks[disk].dev, "wipe metadata failed\n");
1527 /* Adaptec HostRAID Metadata */
1529 ata_raid_adaptec_read_meta(device_t dev, struct ar_softc **raidp)
1531 struct ata_raid_subdisk *ars = device_get_softc(dev);
1532 device_t parent = device_get_parent(dev);
1533 struct adaptec_raid_conf *meta;
1534 struct ar_softc *raid;
1535 int array, disk, retval = 0;
1537 if (!(meta = (struct adaptec_raid_conf *)
1538 malloc(sizeof(struct adaptec_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
1541 if (ata_raid_rw(parent, ADP_LBA(parent),
1542 meta, sizeof(struct adaptec_raid_conf), ATA_R_READ)) {
1543 if (testing || bootverbose)
1544 device_printf(parent, "Adaptec read metadata failed\n");
1548 /* check if this is a Adaptec RAID struct */
1549 if (meta->magic_0 != ADP_MAGIC_0 || meta->magic_3 != ADP_MAGIC_3) {
1550 if (testing || bootverbose)
1551 device_printf(parent, "Adaptec check1 failed\n");
1555 if (testing || bootverbose)
1556 ata_raid_adaptec_print_meta(meta);
1558 /* now convert Adaptec metadata into our generic form */
1559 for (array = 0; array < MAX_ARRAYS; array++) {
1560 if (!raidp[array]) {
1562 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
1564 if (!raidp[array]) {
1565 device_printf(parent, "failed to allocate metadata storage\n");
1569 raid = raidp[array];
1570 if (raid->format && (raid->format != AR_F_ADAPTEC_RAID))
1573 if (raid->magic_0 && raid->magic_0 != meta->configs[0].magic_0)
1576 if (!meta->generation || be32toh(meta->generation) > raid->generation) {
1577 switch (meta->configs[0].type) {
1579 raid->magic_0 = meta->configs[0].magic_0;
1580 raid->type = AR_T_RAID0;
1581 raid->interleave = 1 << (meta->configs[0].stripe_shift >> 1);
1582 raid->width = be16toh(meta->configs[0].total_disks);
1586 raid->magic_0 = meta->configs[0].magic_0;
1587 raid->type = AR_T_RAID1;
1588 raid->width = be16toh(meta->configs[0].total_disks) / 2;
1592 device_printf(parent, "Adaptec unknown RAID type 0x%02x\n",
1593 meta->configs[0].type);
1594 free(raidp[array], M_AR);
1595 raidp[array] = NULL;
1599 raid->format = AR_F_ADAPTEC_RAID;
1600 raid->generation = be32toh(meta->generation);
1601 raid->total_disks = be16toh(meta->configs[0].total_disks);
1602 raid->total_sectors = be32toh(meta->configs[0].sectors);
1605 raid->cylinders = raid->total_sectors / (63 * 255);
1606 raid->offset_sectors = 0;
1607 raid->rebuild_lba = 0;
1609 strncpy(raid->name, meta->configs[0].name,
1610 min(sizeof(raid->name), sizeof(meta->configs[0].name)));
1612 /* clear out any old info */
1613 if (raid->generation) {
1614 for (disk = 0; disk < raid->total_disks; disk++) {
1615 raid->disks[disk].dev = NULL;
1616 raid->disks[disk].flags = 0;
1620 if (be32toh(meta->generation) >= raid->generation) {
1621 struct ata_device *atadev = device_get_softc(parent);
1622 struct ata_channel *ch = device_get_softc(GRANDPARENT(dev));
1623 int disk_number = (ch->unit << !(ch->flags & ATA_NO_SLAVE)) +
1624 ATA_DEV(atadev->unit);
1626 raid->disks[disk_number].dev = parent;
1627 raid->disks[disk_number].sectors =
1628 be32toh(meta->configs[disk_number + 1].sectors);
1629 raid->disks[disk_number].flags =
1630 (AR_DF_ONLINE | AR_DF_PRESENT | AR_DF_ASSIGNED);
1631 ars->raid[raid->volume] = raid;
1632 ars->disk_number[raid->volume] = disk_number;
1643 /* Highpoint V2 RocketRAID Metadata */
1645 ata_raid_hptv2_read_meta(device_t dev, struct ar_softc **raidp)
1647 struct ata_raid_subdisk *ars = device_get_softc(dev);
1648 device_t parent = device_get_parent(dev);
1649 struct hptv2_raid_conf *meta;
1650 struct ar_softc *raid = NULL;
1651 int array, disk_number = 0, retval = 0;
1653 if (!(meta = (struct hptv2_raid_conf *)
1654 malloc(sizeof(struct hptv2_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
1657 if (ata_raid_rw(parent, HPTV2_LBA(parent),
1658 meta, sizeof(struct hptv2_raid_conf), ATA_R_READ)) {
1659 if (testing || bootverbose)
1660 device_printf(parent, "HighPoint (v2) read metadata failed\n");
1664 /* check if this is a HighPoint v2 RAID struct */
1665 if (meta->magic != HPTV2_MAGIC_OK && meta->magic != HPTV2_MAGIC_BAD) {
1666 if (testing || bootverbose)
1667 device_printf(parent, "HighPoint (v2) check1 failed\n");
1671 /* is this disk defined, or an old leftover/spare ? */
1672 if (!meta->magic_0) {
1673 if (testing || bootverbose)
1674 device_printf(parent, "HighPoint (v2) check2 failed\n");
1678 if (testing || bootverbose)
1679 ata_raid_hptv2_print_meta(meta);
1681 /* now convert HighPoint (v2) metadata into our generic form */
1682 for (array = 0; array < MAX_ARRAYS; array++) {
1683 if (!raidp[array]) {
1685 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
1687 if (!raidp[array]) {
1688 device_printf(parent, "failed to allocate metadata storage\n");
1692 raid = raidp[array];
1693 if (raid->format && (raid->format != AR_F_HPTV2_RAID))
1696 switch (meta->type) {
1698 if ((meta->order & (HPTV2_O_RAID0|HPTV2_O_OK)) ==
1699 (HPTV2_O_RAID0|HPTV2_O_OK))
1700 goto highpoint_raid1;
1701 if (meta->order & (HPTV2_O_RAID0 | HPTV2_O_RAID1))
1702 goto highpoint_raid01;
1703 if (raid->magic_0 && raid->magic_0 != meta->magic_0)
1705 raid->magic_0 = meta->magic_0;
1706 raid->type = AR_T_RAID0;
1707 raid->interleave = 1 << meta->stripe_shift;
1708 disk_number = meta->disk_number;
1709 if (!(meta->order & HPTV2_O_OK))
1710 meta->magic = 0; /* mark bad */
1715 if (raid->magic_0 && raid->magic_0 != meta->magic_0)
1717 raid->magic_0 = meta->magic_0;
1718 raid->type = AR_T_RAID1;
1719 disk_number = (meta->disk_number > 0);
1722 case HPTV2_T_RAID01_RAID0:
1724 if (meta->order & HPTV2_O_RAID0) {
1725 if ((raid->magic_0 && raid->magic_0 != meta->magic_0) ||
1726 (raid->magic_1 && raid->magic_1 != meta->magic_1))
1728 raid->magic_0 = meta->magic_0;
1729 raid->magic_1 = meta->magic_1;
1730 raid->type = AR_T_RAID01;
1731 raid->interleave = 1 << meta->stripe_shift;
1732 disk_number = meta->disk_number;
1735 if (raid->magic_1 && raid->magic_1 != meta->magic_1)
1737 raid->magic_1 = meta->magic_1;
1738 raid->type = AR_T_RAID01;
1739 raid->interleave = 1 << meta->stripe_shift;
1740 disk_number = meta->disk_number + meta->array_width;
1741 if (!(meta->order & HPTV2_O_RAID1))
1742 meta->magic = 0; /* mark bad */
1747 if (raid->magic_0 && raid->magic_0 != meta->magic_0)
1749 raid->magic_0 = meta->magic_0;
1750 raid->type = AR_T_SPAN;
1751 disk_number = meta->disk_number;
1755 device_printf(parent, "Highpoint (v2) unknown RAID type 0x%02x\n",
1757 free(raidp[array], M_AR);
1758 raidp[array] = NULL;
1762 raid->format |= AR_F_HPTV2_RAID;
1763 raid->disks[disk_number].dev = parent;
1764 raid->disks[disk_number].flags = (AR_DF_PRESENT | AR_DF_ASSIGNED);
1766 strncpy(raid->name, meta->name_1,
1767 min(sizeof(raid->name), sizeof(meta->name_1)));
1768 if (meta->magic == HPTV2_MAGIC_OK) {
1769 raid->disks[disk_number].flags |= AR_DF_ONLINE;
1770 raid->width = meta->array_width;
1771 raid->total_sectors = meta->total_sectors;
1774 raid->cylinders = raid->total_sectors / (63 * 255);
1775 raid->offset_sectors = HPTV2_LBA(parent) + 1;
1776 raid->rebuild_lba = meta->rebuild_lba;
1777 raid->disks[disk_number].sectors =
1778 raid->total_sectors / raid->width;
1781 raid->disks[disk_number].flags &= ~AR_DF_ONLINE;
1783 if ((raid->type & AR_T_RAID0) && (raid->total_disks < raid->width))
1784 raid->total_disks = raid->width;
1785 if (disk_number >= raid->total_disks)
1786 raid->total_disks = disk_number + 1;
1787 ars->raid[raid->volume] = raid;
1788 ars->disk_number[raid->volume] = disk_number;
1799 ata_raid_hptv2_write_meta(struct ar_softc *rdp)
1801 struct hptv2_raid_conf *meta;
1802 struct timeval timestamp;
1803 int disk, error = 0;
1805 if (!(meta = (struct hptv2_raid_conf *)
1806 malloc(sizeof(struct hptv2_raid_conf), M_AR, M_NOWAIT | M_ZERO))) {
1807 printf("ar%d: failed to allocate metadata storage\n", rdp->lun);
1811 microtime(×tamp);
1812 rdp->magic_0 = timestamp.tv_sec + 2;
1813 rdp->magic_1 = timestamp.tv_sec;
1815 for (disk = 0; disk < rdp->total_disks; disk++) {
1816 if ((rdp->disks[disk].flags & (AR_DF_PRESENT | AR_DF_ONLINE)) ==
1817 (AR_DF_PRESENT | AR_DF_ONLINE))
1818 meta->magic = HPTV2_MAGIC_OK;
1819 if (rdp->disks[disk].flags & AR_DF_ASSIGNED) {
1820 meta->magic_0 = rdp->magic_0;
1821 if (strlen(rdp->name))
1822 strncpy(meta->name_1, rdp->name, sizeof(meta->name_1));
1824 strcpy(meta->name_1, "FreeBSD");
1826 meta->disk_number = disk;
1828 switch (rdp->type) {
1830 meta->type = HPTV2_T_RAID0;
1831 strcpy(meta->name_2, "RAID 0");
1832 if (rdp->disks[disk].flags & AR_DF_ONLINE)
1833 meta->order = HPTV2_O_OK;
1837 meta->type = HPTV2_T_RAID0;
1838 strcpy(meta->name_2, "RAID 1");
1839 meta->disk_number = (disk < rdp->width) ? disk : disk + 5;
1840 meta->order = HPTV2_O_RAID0 | HPTV2_O_OK;
1844 meta->type = HPTV2_T_RAID01_RAID0;
1845 strcpy(meta->name_2, "RAID 0+1");
1846 if (rdp->disks[disk].flags & AR_DF_ONLINE) {
1847 if (disk < rdp->width) {
1848 meta->order = (HPTV2_O_RAID0 | HPTV2_O_RAID1);
1849 meta->magic_0 = rdp->magic_0 - 1;
1852 meta->order = HPTV2_O_RAID1;
1853 meta->disk_number -= rdp->width;
1857 meta->magic_0 = rdp->magic_0 - 1;
1858 meta->magic_1 = rdp->magic_1;
1862 meta->type = HPTV2_T_SPAN;
1863 strcpy(meta->name_2, "SPAN");
1870 meta->array_width = rdp->width;
1871 meta->stripe_shift = (rdp->width > 1) ? (ffs(rdp->interleave)-1) : 0;
1872 meta->total_sectors = rdp->total_sectors;
1873 meta->rebuild_lba = rdp->rebuild_lba;
1874 if (testing || bootverbose)
1875 ata_raid_hptv2_print_meta(meta);
1876 if (rdp->disks[disk].dev) {
1877 if (ata_raid_rw(rdp->disks[disk].dev,
1878 HPTV2_LBA(rdp->disks[disk].dev), meta,
1879 sizeof(struct promise_raid_conf),
1880 ATA_R_WRITE | ATA_R_DIRECT)) {
1881 device_printf(rdp->disks[disk].dev, "write metadata failed\n");
1890 /* Highpoint V3 RocketRAID Metadata */
1892 ata_raid_hptv3_read_meta(device_t dev, struct ar_softc **raidp)
1894 struct ata_raid_subdisk *ars = device_get_softc(dev);
1895 device_t parent = device_get_parent(dev);
1896 struct hptv3_raid_conf *meta;
1897 struct ar_softc *raid = NULL;
1898 int array, disk_number, retval = 0;
1900 if (!(meta = (struct hptv3_raid_conf *)
1901 malloc(sizeof(struct hptv3_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
1904 if (ata_raid_rw(parent, HPTV3_LBA(parent),
1905 meta, sizeof(struct hptv3_raid_conf), ATA_R_READ)) {
1906 if (testing || bootverbose)
1907 device_printf(parent, "HighPoint (v3) read metadata failed\n");
1911 /* check if this is a HighPoint v3 RAID struct */
1912 if (meta->magic != HPTV3_MAGIC) {
1913 if (testing || bootverbose)
1914 device_printf(parent, "HighPoint (v3) check1 failed\n");
1918 /* check if there are any config_entries */
1919 if (meta->config_entries < 1) {
1920 if (testing || bootverbose)
1921 device_printf(parent, "HighPoint (v3) check2 failed\n");
1925 if (testing || bootverbose)
1926 ata_raid_hptv3_print_meta(meta);
1928 /* now convert HighPoint (v3) metadata into our generic form */
1929 for (array = 0; array < MAX_ARRAYS; array++) {
1930 if (!raidp[array]) {
1932 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
1934 if (!raidp[array]) {
1935 device_printf(parent, "failed to allocate metadata storage\n");
1939 raid = raidp[array];
1940 if (raid->format && (raid->format != AR_F_HPTV3_RAID))
1943 if ((raid->format & AR_F_HPTV3_RAID) && raid->magic_0 != meta->magic_0)
1946 switch (meta->configs[0].type) {
1948 raid->type = AR_T_RAID0;
1949 raid->width = meta->configs[0].total_disks;
1950 disk_number = meta->configs[0].disk_number;
1954 raid->type = AR_T_RAID1;
1955 raid->width = meta->configs[0].total_disks / 2;
1956 disk_number = meta->configs[0].disk_number;
1960 raid->type = AR_T_RAID5;
1961 raid->width = meta->configs[0].total_disks;
1962 disk_number = meta->configs[0].disk_number;
1966 raid->type = AR_T_SPAN;
1967 raid->width = meta->configs[0].total_disks;
1968 disk_number = meta->configs[0].disk_number;
1972 device_printf(parent, "Highpoint (v3) unknown RAID type 0x%02x\n",
1973 meta->configs[0].type);
1974 free(raidp[array], M_AR);
1975 raidp[array] = NULL;
1978 if (meta->config_entries == 2) {
1979 switch (meta->configs[1].type) {
1981 if (raid->type == AR_T_RAID0) {
1982 raid->type = AR_T_RAID01;
1983 disk_number = meta->configs[1].disk_number +
1984 (meta->configs[0].disk_number << 1);
1988 device_printf(parent, "Highpoint (v3) unknown level 2 0x%02x\n",
1989 meta->configs[1].type);
1990 free(raidp[array], M_AR);
1991 raidp[array] = NULL;
1996 raid->magic_0 = meta->magic_0;
1997 raid->format = AR_F_HPTV3_RAID;
1998 raid->generation = meta->timestamp;
1999 raid->interleave = 1 << meta->configs[0].stripe_shift;
2000 raid->total_disks = meta->configs[0].total_disks +
2001 meta->configs[1].total_disks;
2002 raid->total_sectors = meta->configs[0].total_sectors +
2003 ((u_int64_t)meta->configs_high[0].total_sectors << 32);
2006 raid->cylinders = raid->total_sectors / (63 * 255);
2007 raid->offset_sectors = 0;
2008 raid->rebuild_lba = meta->configs[0].rebuild_lba +
2009 ((u_int64_t)meta->configs_high[0].rebuild_lba << 32);
2011 strncpy(raid->name, meta->name,
2012 min(sizeof(raid->name), sizeof(meta->name)));
2013 raid->disks[disk_number].sectors = raid->total_sectors /
2014 (raid->type == AR_T_RAID5 ? raid->width - 1 : raid->width);
2015 raid->disks[disk_number].dev = parent;
2016 raid->disks[disk_number].flags =
2017 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_ONLINE);
2018 ars->raid[raid->volume] = raid;
2019 ars->disk_number[raid->volume] = disk_number;
2029 /* Intel MatrixRAID Metadata */
2031 ata_raid_intel_read_meta(device_t dev, struct ar_softc **raidp)
2033 struct ata_raid_subdisk *ars = device_get_softc(dev);
2034 device_t parent = device_get_parent(dev);
2035 struct intel_raid_conf *meta;
2036 struct intel_raid_mapping *map;
2037 struct ar_softc *raid = NULL;
2038 u_int32_t checksum, *ptr;
2039 int array, count, disk, volume = 1, retval = 0;
2042 if (!(meta = (struct intel_raid_conf *)
2043 malloc(1536, M_AR, M_NOWAIT | M_ZERO)))
2046 if (ata_raid_rw(parent, INTEL_LBA(parent), meta, 1024, ATA_R_READ)) {
2047 if (testing || bootverbose)
2048 device_printf(parent, "Intel read metadata failed\n");
2052 bcopy(tmp, tmp+1024, 512);
2053 bcopy(tmp+512, tmp, 1024);
2054 bzero(tmp+1024, 512);
2056 /* check if this is a Intel RAID struct */
2057 if (strncmp(meta->intel_id, INTEL_MAGIC, strlen(INTEL_MAGIC))) {
2058 if (testing || bootverbose)
2059 device_printf(parent, "Intel check1 failed\n");
2063 for (checksum = 0, ptr = (u_int32_t *)meta, count = 0;
2064 count < (meta->config_size / sizeof(u_int32_t)); count++) {
2067 checksum -= meta->checksum;
2068 if (checksum != meta->checksum) {
2069 if (testing || bootverbose)
2070 device_printf(parent, "Intel check2 failed\n");
2074 if (testing || bootverbose)
2075 ata_raid_intel_print_meta(meta);
2077 map = (struct intel_raid_mapping *)&meta->disk[meta->total_disks];
2079 /* now convert Intel metadata into our generic form */
2080 for (array = 0; array < MAX_ARRAYS; array++) {
2081 if (!raidp[array]) {
2083 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
2085 if (!raidp[array]) {
2086 device_printf(parent, "failed to allocate metadata storage\n");
2090 raid = raidp[array];
2091 if (raid->format && (raid->format != AR_F_INTEL_RAID))
2094 if ((raid->format & AR_F_INTEL_RAID) &&
2095 (raid->magic_0 != meta->config_id))
2099 * update our knowledge about the array config based on generation
2100 * NOTE: there can be multiple volumes on a disk set
2102 if (!meta->generation || meta->generation > raid->generation) {
2103 switch (map->type) {
2105 raid->type = AR_T_RAID0;
2106 raid->width = map->total_disks;
2110 if (map->total_disks == 4)
2111 raid->type = AR_T_RAID01;
2113 raid->type = AR_T_RAID1;
2114 raid->width = map->total_disks / 2;
2118 raid->type = AR_T_RAID5;
2119 raid->width = map->total_disks;
2123 device_printf(parent, "Intel unknown RAID type 0x%02x\n",
2125 free(raidp[array], M_AR);
2126 raidp[array] = NULL;
2130 switch (map->status) {
2132 raid->status = AR_S_READY;
2134 case INTEL_S_DEGRADED:
2135 raid->status |= AR_S_DEGRADED;
2137 case INTEL_S_DISABLED:
2138 case INTEL_S_FAILURE:
2142 raid->magic_0 = meta->config_id;
2143 raid->format = AR_F_INTEL_RAID;
2144 raid->generation = meta->generation;
2145 raid->interleave = map->stripe_sectors;
2146 raid->total_disks = map->total_disks;
2147 raid->total_sectors = map->total_sectors;
2150 raid->cylinders = raid->total_sectors / (63 * 255);
2151 raid->offset_sectors = map->offset;
2152 raid->rebuild_lba = 0;
2154 raid->volume = volume - 1;
2155 strncpy(raid->name, map->name,
2156 min(sizeof(raid->name), sizeof(map->name)));
2158 /* clear out any old info */
2159 for (disk = 0; disk < raid->total_disks; disk++) {
2160 raid->disks[disk].dev = NULL;
2161 bcopy(meta->disk[map->disk_idx[disk]].serial,
2162 raid->disks[disk].serial,
2163 sizeof(raid->disks[disk].serial));
2164 raid->disks[disk].sectors =
2165 meta->disk[map->disk_idx[disk]].sectors;
2166 raid->disks[disk].flags = 0;
2167 if (meta->disk[map->disk_idx[disk]].flags & INTEL_F_ONLINE)
2168 raid->disks[disk].flags |= AR_DF_ONLINE;
2169 if (meta->disk[map->disk_idx[disk]].flags & INTEL_F_ASSIGNED)
2170 raid->disks[disk].flags |= AR_DF_ASSIGNED;
2171 if (meta->disk[map->disk_idx[disk]].flags & INTEL_F_SPARE) {
2172 raid->disks[disk].flags &= ~(AR_DF_ONLINE | AR_DF_ASSIGNED);
2173 raid->disks[disk].flags |= AR_DF_SPARE;
2175 if (meta->disk[map->disk_idx[disk]].flags & INTEL_F_DOWN)
2176 raid->disks[disk].flags &= ~AR_DF_ONLINE;
2179 if (meta->generation >= raid->generation) {
2180 for (disk = 0; disk < raid->total_disks; disk++) {
2181 struct ata_device *atadev = device_get_softc(parent);
2183 if (!strncmp(raid->disks[disk].serial, atadev->param.serial,
2184 sizeof(raid->disks[disk].serial))) {
2185 raid->disks[disk].dev = parent;
2186 raid->disks[disk].flags |= (AR_DF_PRESENT | AR_DF_ONLINE);
2187 ars->raid[raid->volume] = raid;
2188 ars->disk_number[raid->volume] = disk;
2197 if (volume < meta->total_volumes) {
2198 map = (struct intel_raid_mapping *)
2199 &map->disk_idx[map->total_disks];
2207 free(raidp[array], M_AR);
2208 raidp[array] = NULL;
2220 ata_raid_intel_write_meta(struct ar_softc *rdp)
2222 struct intel_raid_conf *meta;
2223 struct intel_raid_mapping *map;
2224 struct timeval timestamp;
2225 u_int32_t checksum, *ptr;
2226 int count, disk, error = 0;
2229 if (!(meta = (struct intel_raid_conf *)
2230 malloc(1536, M_AR, M_NOWAIT | M_ZERO))) {
2231 printf("ar%d: failed to allocate metadata storage\n", rdp->lun);
2236 microtime(×tamp);
2238 bcopy(INTEL_MAGIC, meta->intel_id, sizeof(meta->intel_id));
2239 bcopy(INTEL_VERSION_1100, meta->version, sizeof(meta->version));
2240 meta->config_id = timestamp.tv_sec;
2241 meta->generation = rdp->generation;
2242 meta->total_disks = rdp->total_disks;
2243 meta->total_volumes = 1; /* XXX SOS */
2244 for (disk = 0; disk < rdp->total_disks; disk++) {
2245 if (rdp->disks[disk].dev) {
2246 struct ata_channel *ch =
2247 device_get_softc(device_get_parent(rdp->disks[disk].dev));
2248 struct ata_device *atadev =
2249 device_get_softc(rdp->disks[disk].dev);
2251 bcopy(atadev->param.serial, meta->disk[disk].serial,
2252 sizeof(rdp->disks[disk].serial));
2253 meta->disk[disk].sectors = rdp->disks[disk].sectors;
2254 meta->disk[disk].id = (ch->unit << 16) | ATA_DEV(atadev->unit);
2257 meta->disk[disk].sectors = rdp->total_sectors / rdp->width;
2258 meta->disk[disk].flags = 0;
2259 if (rdp->disks[disk].flags & AR_DF_SPARE)
2260 meta->disk[disk].flags |= INTEL_F_SPARE;
2262 if (rdp->disks[disk].flags & AR_DF_ONLINE)
2263 meta->disk[disk].flags |= INTEL_F_ONLINE;
2265 meta->disk[disk].flags |= INTEL_F_DOWN;
2266 if (rdp->disks[disk].flags & AR_DF_ASSIGNED)
2267 meta->disk[disk].flags |= INTEL_F_ASSIGNED;
2270 map = (struct intel_raid_mapping *)&meta->disk[meta->total_disks];
2272 bcopy(rdp->name, map->name, sizeof(rdp->name));
2273 map->total_sectors = rdp->total_sectors;
2274 map->state = 12; /* XXX SOS */
2275 map->offset = rdp->offset_sectors;
2276 map->stripe_count = rdp->total_sectors / (rdp->interleave*rdp->total_disks);
2277 map->stripe_sectors = rdp->interleave;
2278 map->disk_sectors = rdp->total_sectors / rdp->width;
2279 map->status = INTEL_S_READY; /* XXX SOS */
2280 switch (rdp->type) {
2282 map->type = INTEL_T_RAID0;
2285 map->type = INTEL_T_RAID1;
2288 map->type = INTEL_T_RAID1;
2291 map->type = INTEL_T_RAID5;
2297 map->total_disks = rdp->total_disks;
2298 map->magic[0] = 0x02;
2299 map->magic[1] = 0xff;
2300 map->magic[2] = 0x01;
2301 for (disk = 0; disk < rdp->total_disks; disk++)
2302 map->disk_idx[disk] = disk;
2304 meta->config_size = (char *)&map->disk_idx[disk] - (char *)meta;
2305 for (checksum = 0, ptr = (u_int32_t *)meta, count = 0;
2306 count < (meta->config_size / sizeof(u_int32_t)); count++) {
2309 meta->checksum = checksum;
2311 if (testing || bootverbose)
2312 ata_raid_intel_print_meta(meta);
2315 bcopy(tmp, tmp+1024, 512);
2316 bcopy(tmp+512, tmp, 1024);
2317 bzero(tmp+1024, 512);
2319 for (disk = 0; disk < rdp->total_disks; disk++) {
2320 if (rdp->disks[disk].dev) {
2321 if (ata_raid_rw(rdp->disks[disk].dev,
2322 INTEL_LBA(rdp->disks[disk].dev),
2323 meta, 1024, ATA_R_WRITE | ATA_R_DIRECT)) {
2324 device_printf(rdp->disks[disk].dev, "write metadata failed\n");
2334 /* Integrated Technology Express Metadata */
2336 ata_raid_ite_read_meta(device_t dev, struct ar_softc **raidp)
2338 struct ata_raid_subdisk *ars = device_get_softc(dev);
2339 device_t parent = device_get_parent(dev);
2340 struct ite_raid_conf *meta;
2341 struct ar_softc *raid = NULL;
2342 int array, disk_number, count, retval = 0;
2345 if (!(meta = (struct ite_raid_conf *)
2346 malloc(sizeof(struct ite_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
2349 if (ata_raid_rw(parent, ITE_LBA(parent),
2350 meta, sizeof(struct ite_raid_conf), ATA_R_READ)) {
2351 if (testing || bootverbose)
2352 device_printf(parent, "ITE read metadata failed\n");
2356 /* check if this is a ITE RAID struct */
2357 for (ptr = (u_int16_t *)meta->ite_id, count = 0;
2358 count < sizeof(meta->ite_id)/sizeof(uint16_t); count++)
2359 ptr[count] = be16toh(ptr[count]);
2361 if (strncmp(meta->ite_id, ITE_MAGIC, strlen(ITE_MAGIC))) {
2362 if (testing || bootverbose)
2363 device_printf(parent, "ITE check1 failed\n");
2367 if (testing || bootverbose)
2368 ata_raid_ite_print_meta(meta);
2370 /* now convert ITE metadata into our generic form */
2371 for (array = 0; array < MAX_ARRAYS; array++) {
2372 if ((raid = raidp[array])) {
2373 if (raid->format != AR_F_ITE_RAID)
2375 if (raid->magic_0 != *((u_int64_t *)meta->timestamp_0))
2379 /* if we dont have a disks timestamp the RAID is invalidated */
2380 if (*((u_int64_t *)meta->timestamp_1) == 0)
2384 raidp[array] = (struct ar_softc *)malloc(sizeof(struct ar_softc),
2385 M_AR, M_NOWAIT | M_ZERO);
2386 if (!(raid = raidp[array])) {
2387 device_printf(parent, "failed to allocate metadata storage\n");
2392 switch (meta->type) {
2394 raid->type = AR_T_RAID0;
2395 raid->width = meta->array_width;
2396 raid->total_disks = meta->array_width;
2397 disk_number = meta->disk_number;
2401 raid->type = AR_T_RAID1;
2403 raid->total_disks = 2;
2404 disk_number = meta->disk_number;
2408 raid->type = AR_T_RAID01;
2409 raid->width = meta->array_width;
2410 raid->total_disks = 4;
2411 disk_number = ((meta->disk_number & 0x02) >> 1) |
2412 ((meta->disk_number & 0x01) << 1);
2416 raid->type = AR_T_SPAN;
2418 raid->total_disks = meta->array_width;
2419 disk_number = meta->disk_number;
2423 device_printf(parent, "ITE unknown RAID type 0x%02x\n", meta->type);
2424 free(raidp[array], M_AR);
2425 raidp[array] = NULL;
2429 raid->magic_0 = *((u_int64_t *)meta->timestamp_0);
2430 raid->format = AR_F_ITE_RAID;
2431 raid->generation = 0;
2432 raid->interleave = meta->stripe_sectors;
2433 raid->total_sectors = meta->total_sectors;
2436 raid->cylinders = raid->total_sectors / (63 * 255);
2437 raid->offset_sectors = 0;
2438 raid->rebuild_lba = 0;
2441 raid->disks[disk_number].dev = parent;
2442 raid->disks[disk_number].sectors = raid->total_sectors / raid->width;
2443 raid->disks[disk_number].flags =
2444 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_ONLINE);
2445 ars->raid[raid->volume] = raid;
2446 ars->disk_number[raid->volume] = disk_number;
2455 /* JMicron Technology Corp Metadata */
2457 ata_raid_jmicron_read_meta(device_t dev, struct ar_softc **raidp)
2459 struct ata_raid_subdisk *ars = device_get_softc(dev);
2460 device_t parent = device_get_parent(dev);
2461 struct jmicron_raid_conf *meta;
2462 struct ar_softc *raid = NULL;
2463 u_int16_t checksum, *ptr;
2464 u_int64_t disk_size;
2465 int count, array, disk, total_disks, retval = 0;
2467 if (!(meta = (struct jmicron_raid_conf *)
2468 malloc(sizeof(struct jmicron_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
2471 if (ata_raid_rw(parent, JMICRON_LBA(parent),
2472 meta, sizeof(struct jmicron_raid_conf), ATA_R_READ)) {
2473 if (testing || bootverbose)
2474 device_printf(parent,
2475 "JMicron read metadata failed\n");
2478 /* check for JMicron signature */
2479 if (strncmp(meta->signature, JMICRON_MAGIC, 2)) {
2480 if (testing || bootverbose)
2481 device_printf(parent, "JMicron check1 failed\n");
2485 /* calculate checksum and compare for valid */
2486 for (checksum = 0, ptr = (u_int16_t *)meta, count = 0; count < 64; count++)
2489 if (testing || bootverbose)
2490 device_printf(parent, "JMicron check2 failed\n");
2494 if (testing || bootverbose)
2495 ata_raid_jmicron_print_meta(meta);
2497 /* now convert JMicron meta into our generic form */
2498 for (array = 0; array < MAX_ARRAYS; array++) {
2500 if (!raidp[array]) {
2502 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
2504 if (!raidp[array]) {
2505 device_printf(parent, "failed to allocate metadata storage\n");
2509 raid = raidp[array];
2510 if (raid->format && (raid->format != AR_F_JMICRON_RAID))
2513 for (total_disks = 0, disk = 0; disk < JM_MAX_DISKS; disk++) {
2514 if (meta->disks[disk]) {
2515 if (raid->format == AR_F_JMICRON_RAID) {
2516 if (bcmp(&meta->disks[disk],
2517 raid->disks[disk].serial, sizeof(u_int32_t))) {
2523 bcopy(&meta->disks[disk],
2524 raid->disks[disk].serial, sizeof(u_int32_t));
2528 /* handle spares XXX SOS */
2530 switch (meta->type) {
2532 raid->type = AR_T_RAID0;
2533 raid->width = total_disks;
2537 raid->type = AR_T_RAID1;
2542 raid->type = AR_T_RAID01;
2543 raid->width = total_disks / 2;
2547 raid->type = AR_T_RAID5;
2548 raid->width = total_disks;
2552 raid->type = AR_T_SPAN;
2557 device_printf(parent,
2558 "JMicron unknown RAID type 0x%02x\n", meta->type);
2559 free(raidp[array], M_AR);
2560 raidp[array] = NULL;
2563 disk_size = (meta->disk_sectors_high << 16) + meta->disk_sectors_low;
2564 raid->format = AR_F_JMICRON_RAID;
2565 strncpy(raid->name, meta->name, sizeof(meta->name));
2566 raid->generation = 0;
2567 raid->interleave = 2 << meta->stripe_shift;
2568 raid->total_disks = total_disks;
2569 raid->total_sectors = disk_size * (raid->width-(raid->type==AR_RAID5));
2572 raid->cylinders = raid->total_sectors / (63 * 255);
2573 raid->offset_sectors = meta->offset * 16;
2574 raid->rebuild_lba = 0;
2577 for (disk = 0; disk < raid->total_disks; disk++) {
2578 if (meta->disks[disk] == meta->disk_id) {
2579 raid->disks[disk].dev = parent;
2580 raid->disks[disk].sectors = disk_size;
2581 raid->disks[disk].flags =
2582 (AR_DF_ONLINE | AR_DF_PRESENT | AR_DF_ASSIGNED);
2583 ars->raid[raid->volume] = raid;
2584 ars->disk_number[raid->volume] = disk;
2597 ata_raid_jmicron_write_meta(struct ar_softc *rdp)
2599 struct jmicron_raid_conf *meta;
2600 u_int64_t disk_sectors;
2601 int disk, error = 0;
2603 if (!(meta = (struct jmicron_raid_conf *)
2604 malloc(sizeof(struct jmicron_raid_conf), M_AR, M_NOWAIT | M_ZERO))) {
2605 printf("ar%d: failed to allocate metadata storage\n", rdp->lun);
2610 switch (rdp->type) {
2612 meta->type = JM_T_JBOD;
2616 meta->type = JM_T_RAID0;
2620 meta->type = JM_T_RAID1;
2624 meta->type = JM_T_RAID5;
2628 meta->type = JM_T_RAID01;
2635 bcopy(JMICRON_MAGIC, meta->signature, sizeof(JMICRON_MAGIC));
2636 meta->version = JMICRON_VERSION;
2637 meta->offset = rdp->offset_sectors / 16;
2638 disk_sectors = rdp->total_sectors / (rdp->width - (rdp->type == AR_RAID5));
2639 meta->disk_sectors_low = disk_sectors & 0xffff;
2640 meta->disk_sectors_high = disk_sectors >> 16;
2641 strncpy(meta->name, rdp->name, sizeof(meta->name));
2642 meta->stripe_shift = ffs(rdp->interleave) - 2;
2644 for (disk = 0; disk < rdp->total_disks; disk++) {
2645 if (rdp->disks[disk].serial[0])
2646 bcopy(rdp->disks[disk].serial,&meta->disks[disk],sizeof(u_int32_t));
2648 meta->disks[disk] = (u_int32_t)(uintptr_t)rdp->disks[disk].dev;
2651 for (disk = 0; disk < rdp->total_disks; disk++) {
2652 if (rdp->disks[disk].dev) {
2653 u_int16_t checksum = 0, *ptr;
2656 meta->disk_id = meta->disks[disk];
2658 for (ptr = (u_int16_t *)meta, count = 0; count < 64; count++)
2660 meta->checksum -= checksum;
2662 if (testing || bootverbose)
2663 ata_raid_jmicron_print_meta(meta);
2665 if (ata_raid_rw(rdp->disks[disk].dev,
2666 JMICRON_LBA(rdp->disks[disk].dev),
2667 meta, sizeof(struct jmicron_raid_conf),
2668 ATA_R_WRITE | ATA_R_DIRECT)) {
2669 device_printf(rdp->disks[disk].dev, "write metadata failed\n");
2674 /* handle spares XXX SOS */
2680 /* LSILogic V2 MegaRAID Metadata */
2682 ata_raid_lsiv2_read_meta(device_t dev, struct ar_softc **raidp)
2684 struct ata_raid_subdisk *ars = device_get_softc(dev);
2685 device_t parent = device_get_parent(dev);
2686 struct lsiv2_raid_conf *meta;
2687 struct ar_softc *raid = NULL;
2688 int array, retval = 0;
2690 if (!(meta = (struct lsiv2_raid_conf *)
2691 malloc(sizeof(struct lsiv2_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
2694 if (ata_raid_rw(parent, LSIV2_LBA(parent),
2695 meta, sizeof(struct lsiv2_raid_conf), ATA_R_READ)) {
2696 if (testing || bootverbose)
2697 device_printf(parent, "LSI (v2) read metadata failed\n");
2701 /* check if this is a LSI RAID struct */
2702 if (strncmp(meta->lsi_id, LSIV2_MAGIC, strlen(LSIV2_MAGIC))) {
2703 if (testing || bootverbose)
2704 device_printf(parent, "LSI (v2) check1 failed\n");
2708 if (testing || bootverbose)
2709 ata_raid_lsiv2_print_meta(meta);
2711 /* now convert LSI (v2) config meta into our generic form */
2712 for (array = 0; array < MAX_ARRAYS; array++) {
2713 int raid_entry, conf_entry;
2715 if (!raidp[array + meta->raid_number]) {
2716 raidp[array + meta->raid_number] =
2717 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
2719 if (!raidp[array + meta->raid_number]) {
2720 device_printf(parent, "failed to allocate metadata storage\n");
2724 raid = raidp[array + meta->raid_number];
2725 if (raid->format && (raid->format != AR_F_LSIV2_RAID))
2728 if (raid->magic_0 &&
2729 ((raid->magic_0 != meta->timestamp) ||
2730 (raid->magic_1 != meta->raid_number)))
2733 array += meta->raid_number;
2735 raid_entry = meta->raid_number;
2736 conf_entry = (meta->configs[raid_entry].raid.config_offset >> 4) +
2737 meta->disk_number - 1;
2739 switch (meta->configs[raid_entry].raid.type) {
2741 raid->magic_0 = meta->timestamp;
2742 raid->magic_1 = meta->raid_number;
2743 raid->type = AR_T_RAID0;
2744 raid->interleave = meta->configs[raid_entry].raid.stripe_sectors;
2745 raid->width = meta->configs[raid_entry].raid.array_width;
2749 raid->magic_0 = meta->timestamp;
2750 raid->magic_1 = meta->raid_number;
2751 raid->type = AR_T_RAID1;
2752 raid->width = meta->configs[raid_entry].raid.array_width;
2755 case LSIV2_T_RAID0 | LSIV2_T_RAID1:
2756 raid->magic_0 = meta->timestamp;
2757 raid->magic_1 = meta->raid_number;
2758 raid->type = AR_T_RAID01;
2759 raid->interleave = meta->configs[raid_entry].raid.stripe_sectors;
2760 raid->width = meta->configs[raid_entry].raid.array_width;
2764 device_printf(parent, "LSI v2 unknown RAID type 0x%02x\n",
2765 meta->configs[raid_entry].raid.type);
2766 free(raidp[array], M_AR);
2767 raidp[array] = NULL;
2771 raid->format = AR_F_LSIV2_RAID;
2772 raid->generation = 0;
2773 raid->total_disks = meta->configs[raid_entry].raid.disk_count;
2774 raid->total_sectors = meta->configs[raid_entry].raid.total_sectors;
2777 raid->cylinders = raid->total_sectors / (63 * 255);
2778 raid->offset_sectors = 0;
2779 raid->rebuild_lba = 0;
2782 if (meta->configs[conf_entry].disk.device != LSIV2_D_NONE) {
2783 raid->disks[meta->disk_number].dev = parent;
2784 raid->disks[meta->disk_number].sectors =
2785 meta->configs[conf_entry].disk.disk_sectors;
2786 raid->disks[meta->disk_number].flags =
2787 (AR_DF_ONLINE | AR_DF_PRESENT | AR_DF_ASSIGNED);
2788 ars->raid[raid->volume] = raid;
2789 ars->disk_number[raid->volume] = meta->disk_number;
2793 raid->disks[meta->disk_number].flags &= ~AR_DF_ONLINE;
2803 /* LSILogic V3 MegaRAID Metadata */
2805 ata_raid_lsiv3_read_meta(device_t dev, struct ar_softc **raidp)
2807 struct ata_raid_subdisk *ars = device_get_softc(dev);
2808 device_t parent = device_get_parent(dev);
2809 struct lsiv3_raid_conf *meta;
2810 struct ar_softc *raid = NULL;
2811 u_int8_t checksum, *ptr;
2812 int array, entry, count, disk_number, retval = 0;
2814 if (!(meta = (struct lsiv3_raid_conf *)
2815 malloc(sizeof(struct lsiv3_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
2818 if (ata_raid_rw(parent, LSIV3_LBA(parent),
2819 meta, sizeof(struct lsiv3_raid_conf), ATA_R_READ)) {
2820 if (testing || bootverbose)
2821 device_printf(parent, "LSI (v3) read metadata failed\n");
2825 /* check if this is a LSI RAID struct */
2826 if (strncmp(meta->lsi_id, LSIV3_MAGIC, strlen(LSIV3_MAGIC))) {
2827 if (testing || bootverbose)
2828 device_printf(parent, "LSI (v3) check1 failed\n");
2832 /* check if the checksum is OK */
2833 for (checksum = 0, ptr = meta->lsi_id, count = 0; count < 512; count++)
2836 if (testing || bootverbose)
2837 device_printf(parent, "LSI (v3) check2 failed\n");
2841 if (testing || bootverbose)
2842 ata_raid_lsiv3_print_meta(meta);
2844 /* now convert LSI (v3) config meta into our generic form */
2845 for (array = 0, entry = 0; array < MAX_ARRAYS && entry < 8;) {
2846 if (!raidp[array]) {
2848 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
2850 if (!raidp[array]) {
2851 device_printf(parent, "failed to allocate metadata storage\n");
2855 raid = raidp[array];
2856 if (raid->format && (raid->format != AR_F_LSIV3_RAID)) {
2861 if ((raid->format == AR_F_LSIV3_RAID) &&
2862 (raid->magic_0 != meta->timestamp)) {
2867 switch (meta->raid[entry].total_disks) {
2872 if (meta->raid[entry].device == meta->device) {
2881 disk_number = (meta->device & (LSIV3_D_DEVICE|LSIV3_D_CHANNEL))?1:0;
2884 device_printf(parent, "lsiv3 > 2 disk support untested!!\n");
2885 disk_number = (meta->device & LSIV3_D_DEVICE ? 1 : 0) +
2886 (meta->device & LSIV3_D_CHANNEL ? 2 : 0);
2890 switch (meta->raid[entry].type) {
2892 raid->type = AR_T_RAID0;
2893 raid->width = meta->raid[entry].total_disks;
2897 raid->type = AR_T_RAID1;
2898 raid->width = meta->raid[entry].array_width;
2902 device_printf(parent, "LSI v3 unknown RAID type 0x%02x\n",
2903 meta->raid[entry].type);
2904 free(raidp[array], M_AR);
2905 raidp[array] = NULL;
2910 raid->magic_0 = meta->timestamp;
2911 raid->format = AR_F_LSIV3_RAID;
2912 raid->generation = 0;
2913 raid->interleave = meta->raid[entry].stripe_pages * 8;
2914 raid->total_disks = meta->raid[entry].total_disks;
2915 raid->total_sectors = raid->width * meta->raid[entry].sectors;
2918 raid->cylinders = raid->total_sectors / (63 * 255);
2919 raid->offset_sectors = meta->raid[entry].offset;
2920 raid->rebuild_lba = 0;
2923 raid->disks[disk_number].dev = parent;
2924 raid->disks[disk_number].sectors = raid->total_sectors / raid->width;
2925 raid->disks[disk_number].flags =
2926 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_ONLINE);
2927 ars->raid[raid->volume] = raid;
2928 ars->disk_number[raid->volume] = disk_number;
2939 /* nVidia MediaShield Metadata */
2941 ata_raid_nvidia_read_meta(device_t dev, struct ar_softc **raidp)
2943 struct ata_raid_subdisk *ars = device_get_softc(dev);
2944 device_t parent = device_get_parent(dev);
2945 struct nvidia_raid_conf *meta;
2946 struct ar_softc *raid = NULL;
2947 u_int32_t checksum, *ptr;
2948 int array, count, retval = 0;
2950 if (!(meta = (struct nvidia_raid_conf *)
2951 malloc(sizeof(struct nvidia_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
2954 if (ata_raid_rw(parent, NVIDIA_LBA(parent),
2955 meta, sizeof(struct nvidia_raid_conf), ATA_R_READ)) {
2956 if (testing || bootverbose)
2957 device_printf(parent, "nVidia read metadata failed\n");
2961 /* check if this is a nVidia RAID struct */
2962 if (strncmp(meta->nvidia_id, NV_MAGIC, strlen(NV_MAGIC))) {
2963 if (testing || bootverbose)
2964 device_printf(parent, "nVidia check1 failed\n");
2968 /* check if the checksum is OK */
2969 for (checksum = 0, ptr = (u_int32_t*)meta, count = 0;
2970 count < meta->config_size; count++)
2973 if (testing || bootverbose)
2974 device_printf(parent, "nVidia check2 failed\n");
2978 if (testing || bootverbose)
2979 ata_raid_nvidia_print_meta(meta);
2981 /* now convert nVidia meta into our generic form */
2982 for (array = 0; array < MAX_ARRAYS; array++) {
2983 if (!raidp[array]) {
2985 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
2987 if (!raidp[array]) {
2988 device_printf(parent, "failed to allocate metadata storage\n");
2992 raid = raidp[array];
2993 if (raid->format && (raid->format != AR_F_NVIDIA_RAID))
2996 if (raid->format == AR_F_NVIDIA_RAID &&
2997 ((raid->magic_0 != meta->magic_1) ||
2998 (raid->magic_1 != meta->magic_2))) {
3002 switch (meta->type) {
3004 raid->type = AR_T_SPAN;
3008 raid->type = AR_T_RAID0;
3012 raid->type = AR_T_RAID1;
3016 raid->type = AR_T_RAID5;
3020 raid->type = AR_T_RAID01;
3024 device_printf(parent, "nVidia unknown RAID type 0x%02x\n",
3026 free(raidp[array], M_AR);
3027 raidp[array] = NULL;
3030 raid->magic_0 = meta->magic_1;
3031 raid->magic_1 = meta->magic_2;
3032 raid->format = AR_F_NVIDIA_RAID;
3033 raid->generation = 0;
3034 raid->interleave = meta->stripe_sectors;
3035 raid->width = meta->array_width;
3036 raid->total_disks = meta->total_disks;
3037 raid->total_sectors = meta->total_sectors;
3040 raid->cylinders = raid->total_sectors / (63 * 255);
3041 raid->offset_sectors = 0;
3042 raid->rebuild_lba = meta->rebuild_lba;
3044 raid->status = AR_S_READY;
3045 if (meta->status & NV_S_DEGRADED)
3046 raid->status |= AR_S_DEGRADED;
3048 raid->disks[meta->disk_number].dev = parent;
3049 raid->disks[meta->disk_number].sectors =
3050 raid->total_sectors / raid->width;
3051 raid->disks[meta->disk_number].flags =
3052 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_ONLINE);
3053 ars->raid[raid->volume] = raid;
3054 ars->disk_number[raid->volume] = meta->disk_number;
3064 /* Promise FastTrak Metadata */
3066 ata_raid_promise_read_meta(device_t dev, struct ar_softc **raidp, int native)
3068 struct ata_raid_subdisk *ars = device_get_softc(dev);
3069 device_t parent = device_get_parent(dev);
3070 struct promise_raid_conf *meta;
3071 struct ar_softc *raid;
3072 u_int32_t checksum, *ptr;
3073 int array, count, disk, disksum = 0, retval = 0;
3075 if (!(meta = (struct promise_raid_conf *)
3076 malloc(sizeof(struct promise_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
3079 if (ata_raid_rw(parent, PROMISE_LBA(parent),
3080 meta, sizeof(struct promise_raid_conf), ATA_R_READ)) {
3081 if (testing || bootverbose)
3082 device_printf(parent, "%s read metadata failed\n",
3083 native ? "FreeBSD" : "Promise");
3087 /* check the signature */
3089 if (strncmp(meta->promise_id, ATA_MAGIC, strlen(ATA_MAGIC))) {
3090 if (testing || bootverbose)
3091 device_printf(parent, "FreeBSD check1 failed\n");
3096 if (strncmp(meta->promise_id, PR_MAGIC, strlen(PR_MAGIC))) {
3097 if (testing || bootverbose)
3098 device_printf(parent, "Promise check1 failed\n");
3103 /* check if the checksum is OK */
3104 for (checksum = 0, ptr = (u_int32_t *)meta, count = 0; count < 511; count++)
3106 if (checksum != *ptr) {
3107 if (testing || bootverbose)
3108 device_printf(parent, "%s check2 failed\n",
3109 native ? "FreeBSD" : "Promise");
3113 /* check on disk integrity status */
3114 if (meta->raid.integrity != PR_I_VALID) {
3115 if (testing || bootverbose)
3116 device_printf(parent, "%s check3 failed\n",
3117 native ? "FreeBSD" : "Promise");
3121 if (testing || bootverbose)
3122 ata_raid_promise_print_meta(meta);
3124 /* now convert Promise metadata into our generic form */
3125 for (array = 0; array < MAX_ARRAYS; array++) {
3126 if (!raidp[array]) {
3128 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
3130 if (!raidp[array]) {
3131 device_printf(parent, "failed to allocate metadata storage\n");
3135 raid = raidp[array];
3137 (raid->format != (native ? AR_F_FREEBSD_RAID : AR_F_PROMISE_RAID)))
3140 if ((raid->format == (native ? AR_F_FREEBSD_RAID : AR_F_PROMISE_RAID))&&
3141 !(meta->raid.magic_1 == (raid->magic_1)))
3144 /* update our knowledge about the array config based on generation */
3145 if (!meta->raid.generation || meta->raid.generation > raid->generation){
3146 switch (meta->raid.type) {
3148 raid->type = AR_T_SPAN;
3152 raid->type = AR_T_JBOD;
3156 raid->type = AR_T_RAID0;
3160 raid->type = AR_T_RAID1;
3161 if (meta->raid.array_width > 1)
3162 raid->type = AR_T_RAID01;
3166 raid->type = AR_T_RAID5;
3170 device_printf(parent, "%s unknown RAID type 0x%02x\n",
3171 native ? "FreeBSD" : "Promise", meta->raid.type);
3172 free(raidp[array], M_AR);
3173 raidp[array] = NULL;
3176 raid->magic_1 = meta->raid.magic_1;
3177 raid->format = (native ? AR_F_FREEBSD_RAID : AR_F_PROMISE_RAID);
3178 raid->generation = meta->raid.generation;
3179 raid->interleave = 1 << meta->raid.stripe_shift;
3180 raid->width = meta->raid.array_width;
3181 raid->total_disks = meta->raid.total_disks;
3182 raid->heads = meta->raid.heads + 1;
3183 raid->sectors = meta->raid.sectors;
3184 raid->cylinders = meta->raid.cylinders + 1;
3185 raid->total_sectors = meta->raid.total_sectors;
3186 raid->offset_sectors = 0;
3187 raid->rebuild_lba = meta->raid.rebuild_lba;
3189 if ((meta->raid.status &
3190 (PR_S_VALID | PR_S_ONLINE | PR_S_INITED | PR_S_READY)) ==
3191 (PR_S_VALID | PR_S_ONLINE | PR_S_INITED | PR_S_READY)) {
3192 raid->status |= AR_S_READY;
3193 if (meta->raid.status & PR_S_DEGRADED)
3194 raid->status |= AR_S_DEGRADED;
3197 raid->status &= ~AR_S_READY;
3199 /* convert disk flags to our internal types */
3200 for (disk = 0; disk < meta->raid.total_disks; disk++) {
3201 raid->disks[disk].dev = NULL;
3202 raid->disks[disk].flags = 0;
3203 *((u_int64_t *)(raid->disks[disk].serial)) =
3204 meta->raid.disk[disk].magic_0;
3205 disksum += meta->raid.disk[disk].flags;
3206 if (meta->raid.disk[disk].flags & PR_F_ONLINE)
3207 raid->disks[disk].flags |= AR_DF_ONLINE;
3208 if (meta->raid.disk[disk].flags & PR_F_ASSIGNED)
3209 raid->disks[disk].flags |= AR_DF_ASSIGNED;
3210 if (meta->raid.disk[disk].flags & PR_F_SPARE) {
3211 raid->disks[disk].flags &= ~(AR_DF_ONLINE | AR_DF_ASSIGNED);
3212 raid->disks[disk].flags |= AR_DF_SPARE;
3214 if (meta->raid.disk[disk].flags & (PR_F_REDIR | PR_F_DOWN))
3215 raid->disks[disk].flags &= ~AR_DF_ONLINE;
3218 device_printf(parent, "%s subdisks has no flags\n",
3219 native ? "FreeBSD" : "Promise");
3220 free(raidp[array], M_AR);
3221 raidp[array] = NULL;
3225 if (meta->raid.generation >= raid->generation) {
3226 int disk_number = meta->raid.disk_number;
3228 if (raid->disks[disk_number].flags && (meta->magic_0 ==
3229 *((u_int64_t *)(raid->disks[disk_number].serial)))) {
3230 raid->disks[disk_number].dev = parent;
3231 raid->disks[disk_number].flags |= AR_DF_PRESENT;
3232 raid->disks[disk_number].sectors = meta->raid.disk_sectors;
3233 if ((raid->disks[disk_number].flags &
3234 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_ONLINE)) ==
3235 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_ONLINE)) {
3236 ars->raid[raid->volume] = raid;
3237 ars->disk_number[raid->volume] = disk_number;
3251 ata_raid_promise_write_meta(struct ar_softc *rdp)
3253 struct promise_raid_conf *meta;
3254 struct timeval timestamp;
3256 int count, disk, drive, error = 0;
3258 if (!(meta = (struct promise_raid_conf *)
3259 malloc(sizeof(struct promise_raid_conf), M_AR, M_NOWAIT))) {
3260 printf("ar%d: failed to allocate metadata storage\n", rdp->lun);
3265 microtime(×tamp);
3267 for (disk = 0; disk < rdp->total_disks; disk++) {
3268 for (count = 0; count < sizeof(struct promise_raid_conf); count++)
3269 *(((u_int8_t *)meta) + count) = 255 - (count % 256);
3270 meta->dummy_0 = 0x00020000;
3271 meta->raid.disk_number = disk;
3273 if (rdp->disks[disk].dev) {
3274 struct ata_device *atadev = device_get_softc(rdp->disks[disk].dev);
3275 struct ata_channel *ch =
3276 device_get_softc(device_get_parent(rdp->disks[disk].dev));
3278 meta->raid.channel = ch->unit;
3279 meta->raid.device = ATA_DEV(atadev->unit);
3280 meta->raid.disk_sectors = rdp->disks[disk].sectors;
3281 meta->raid.disk_offset = rdp->offset_sectors;
3284 meta->raid.channel = 0;
3285 meta->raid.device = 0;
3286 meta->raid.disk_sectors = 0;
3287 meta->raid.disk_offset = 0;
3289 meta->magic_0 = PR_MAGIC0(meta->raid) | timestamp.tv_sec;
3290 meta->magic_1 = timestamp.tv_sec >> 16;
3291 meta->magic_2 = timestamp.tv_sec;
3292 meta->raid.integrity = PR_I_VALID;
3293 meta->raid.magic_0 = meta->magic_0;
3294 meta->raid.rebuild_lba = rdp->rebuild_lba;
3295 meta->raid.generation = rdp->generation;
3297 if (rdp->status & AR_S_READY) {
3298 meta->raid.flags = (PR_F_VALID | PR_F_ASSIGNED | PR_F_ONLINE);
3300 (PR_S_VALID | PR_S_ONLINE | PR_S_INITED | PR_S_READY);
3301 if (rdp->status & AR_S_DEGRADED)
3302 meta->raid.status |= PR_S_DEGRADED;
3304 meta->raid.status |= PR_S_FUNCTIONAL;
3307 meta->raid.flags = PR_F_DOWN;
3308 meta->raid.status = 0;
3311 switch (rdp->type) {
3313 meta->raid.type = PR_T_RAID0;
3316 meta->raid.type = PR_T_RAID1;
3319 meta->raid.type = PR_T_RAID1;
3322 meta->raid.type = PR_T_RAID5;
3325 meta->raid.type = PR_T_SPAN;
3328 meta->raid.type = PR_T_JBOD;
3335 meta->raid.total_disks = rdp->total_disks;
3336 meta->raid.stripe_shift = ffs(rdp->interleave) - 1;
3337 meta->raid.array_width = rdp->width;
3338 meta->raid.array_number = rdp->lun;
3339 meta->raid.total_sectors = rdp->total_sectors;
3340 meta->raid.cylinders = rdp->cylinders - 1;
3341 meta->raid.heads = rdp->heads - 1;
3342 meta->raid.sectors = rdp->sectors;
3343 meta->raid.magic_1 = (u_int64_t)meta->magic_2<<16 | meta->magic_1;
3345 bzero(&meta->raid.disk, 8 * 12);
3346 for (drive = 0; drive < rdp->total_disks; drive++) {
3347 meta->raid.disk[drive].flags = 0;
3348 if (rdp->disks[drive].flags & AR_DF_PRESENT)
3349 meta->raid.disk[drive].flags |= PR_F_VALID;
3350 if (rdp->disks[drive].flags & AR_DF_ASSIGNED)
3351 meta->raid.disk[drive].flags |= PR_F_ASSIGNED;
3352 if (rdp->disks[drive].flags & AR_DF_ONLINE)
3353 meta->raid.disk[drive].flags |= PR_F_ONLINE;
3355 if (rdp->disks[drive].flags & AR_DF_PRESENT)
3356 meta->raid.disk[drive].flags = (PR_F_REDIR | PR_F_DOWN);
3357 if (rdp->disks[drive].flags & AR_DF_SPARE)
3358 meta->raid.disk[drive].flags |= PR_F_SPARE;
3359 meta->raid.disk[drive].dummy_0 = 0x0;
3360 if (rdp->disks[drive].dev) {
3361 struct ata_channel *ch =
3362 device_get_softc(device_get_parent(rdp->disks[drive].dev));
3363 struct ata_device *atadev =
3364 device_get_softc(rdp->disks[drive].dev);
3366 meta->raid.disk[drive].channel = ch->unit;
3367 meta->raid.disk[drive].device = ATA_DEV(atadev->unit);
3369 meta->raid.disk[drive].magic_0 =
3370 PR_MAGIC0(meta->raid.disk[drive]) | timestamp.tv_sec;
3373 if (rdp->disks[disk].dev) {
3374 if ((rdp->disks[disk].flags & (AR_DF_PRESENT | AR_DF_ONLINE)) ==
3375 (AR_DF_PRESENT | AR_DF_ONLINE)) {
3376 if (rdp->format == AR_F_FREEBSD_RAID)
3377 bcopy(ATA_MAGIC, meta->promise_id, sizeof(ATA_MAGIC));
3379 bcopy(PR_MAGIC, meta->promise_id, sizeof(PR_MAGIC));
3382 bzero(meta->promise_id, sizeof(meta->promise_id));
3384 for (ckptr = (int32_t *)meta, count = 0; count < 511; count++)
3385 meta->checksum += *ckptr++;
3386 if (testing || bootverbose)
3387 ata_raid_promise_print_meta(meta);
3388 if (ata_raid_rw(rdp->disks[disk].dev,
3389 PROMISE_LBA(rdp->disks[disk].dev),
3390 meta, sizeof(struct promise_raid_conf),
3391 ATA_R_WRITE | ATA_R_DIRECT)) {
3392 device_printf(rdp->disks[disk].dev, "write metadata failed\n");
3401 /* Silicon Image Medley Metadata */
3403 ata_raid_sii_read_meta(device_t dev, struct ar_softc **raidp)
3405 struct ata_raid_subdisk *ars = device_get_softc(dev);
3406 device_t parent = device_get_parent(dev);
3407 struct sii_raid_conf *meta;
3408 struct ar_softc *raid = NULL;
3409 u_int16_t checksum, *ptr;
3410 int array, count, disk, retval = 0;
3412 if (!(meta = (struct sii_raid_conf *)
3413 malloc(sizeof(struct sii_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
3416 if (ata_raid_rw(parent, SII_LBA(parent),
3417 meta, sizeof(struct sii_raid_conf), ATA_R_READ)) {
3418 if (testing || bootverbose)
3419 device_printf(parent, "Silicon Image read metadata failed\n");
3423 /* check if this is a Silicon Image (Medley) RAID struct */
3424 for (checksum = 0, ptr = (u_int16_t *)meta, count = 0; count < 160; count++)
3427 if (testing || bootverbose)
3428 device_printf(parent, "Silicon Image check1 failed\n");
3432 for (checksum = 0, ptr = (u_int16_t *)meta, count = 0; count < 256; count++)
3434 if (checksum != meta->checksum_1) {
3435 if (testing || bootverbose)
3436 device_printf(parent, "Silicon Image check2 failed\n");
3441 if (meta->version_major != 0x0002 ||
3442 (meta->version_minor != 0x0000 && meta->version_minor != 0x0001)) {
3443 if (testing || bootverbose)
3444 device_printf(parent, "Silicon Image check3 failed\n");
3448 if (testing || bootverbose)
3449 ata_raid_sii_print_meta(meta);
3451 /* now convert Silicon Image meta into our generic form */
3452 for (array = 0; array < MAX_ARRAYS; array++) {
3453 if (!raidp[array]) {
3455 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
3457 if (!raidp[array]) {
3458 device_printf(parent, "failed to allocate metadata storage\n");
3462 raid = raidp[array];
3463 if (raid->format && (raid->format != AR_F_SII_RAID))
3466 if (raid->format == AR_F_SII_RAID &&
3467 (raid->magic_0 != *((u_int64_t *)meta->timestamp))) {
3471 /* update our knowledge about the array config based on generation */
3472 if (!meta->generation || meta->generation > raid->generation) {
3473 switch (meta->type) {
3475 raid->type = AR_T_RAID0;
3479 raid->type = AR_T_RAID1;
3483 raid->type = AR_T_RAID01;
3487 device_printf(parent, "Silicon Image SPARE disk\n");
3488 free(raidp[array], M_AR);
3489 raidp[array] = NULL;
3493 device_printf(parent,"Silicon Image unknown RAID type 0x%02x\n",
3495 free(raidp[array], M_AR);
3496 raidp[array] = NULL;
3499 raid->magic_0 = *((u_int64_t *)meta->timestamp);
3500 raid->format = AR_F_SII_RAID;
3501 raid->generation = meta->generation;
3502 raid->interleave = meta->stripe_sectors;
3503 raid->width = (meta->raid0_disks != 0xff) ? meta->raid0_disks : 1;
3505 ((meta->raid0_disks != 0xff) ? meta->raid0_disks : 0) +
3506 ((meta->raid1_disks != 0xff) ? meta->raid1_disks : 0);
3507 raid->total_sectors = meta->total_sectors;
3510 raid->cylinders = raid->total_sectors / (63 * 255);
3511 raid->offset_sectors = 0;
3512 raid->rebuild_lba = meta->rebuild_lba;
3514 strncpy(raid->name, meta->name,
3515 min(sizeof(raid->name), sizeof(meta->name)));
3517 /* clear out any old info */
3518 if (raid->generation) {
3519 for (disk = 0; disk < raid->total_disks; disk++) {
3520 raid->disks[disk].dev = NULL;
3521 raid->disks[disk].flags = 0;
3525 if (meta->generation >= raid->generation) {
3526 /* XXX SOS add check for the right physical disk by serial# */
3527 if (meta->status & SII_S_READY) {
3528 int disk_number = (raid->type == AR_T_RAID01) ?
3529 meta->raid1_ident + (meta->raid0_ident << 1) :
3532 raid->disks[disk_number].dev = parent;
3533 raid->disks[disk_number].sectors =
3534 raid->total_sectors / raid->width;
3535 raid->disks[disk_number].flags =
3536 (AR_DF_ONLINE | AR_DF_PRESENT | AR_DF_ASSIGNED);
3537 ars->raid[raid->volume] = raid;
3538 ars->disk_number[raid->volume] = disk_number;
3550 /* Silicon Integrated Systems Metadata */
3552 ata_raid_sis_read_meta(device_t dev, struct ar_softc **raidp)
3554 struct ata_raid_subdisk *ars = device_get_softc(dev);
3555 device_t parent = device_get_parent(dev);
3556 struct sis_raid_conf *meta;
3557 struct ar_softc *raid = NULL;
3558 int array, disk_number, drive, retval = 0;
3560 if (!(meta = (struct sis_raid_conf *)
3561 malloc(sizeof(struct sis_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
3564 if (ata_raid_rw(parent, SIS_LBA(parent),
3565 meta, sizeof(struct sis_raid_conf), ATA_R_READ)) {
3566 if (testing || bootverbose)
3567 device_printf(parent,
3568 "Silicon Integrated Systems read metadata failed\n");
3571 /* check for SiS magic */
3572 if (meta->magic != SIS_MAGIC) {
3573 if (testing || bootverbose)
3574 device_printf(parent,
3575 "Silicon Integrated Systems check1 failed\n");
3579 if (testing || bootverbose)
3580 ata_raid_sis_print_meta(meta);
3582 /* now convert SiS meta into our generic form */
3583 for (array = 0; array < MAX_ARRAYS; array++) {
3584 if (!raidp[array]) {
3586 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
3588 if (!raidp[array]) {
3589 device_printf(parent, "failed to allocate metadata storage\n");
3594 raid = raidp[array];
3595 if (raid->format && (raid->format != AR_F_SIS_RAID))
3598 if ((raid->format == AR_F_SIS_RAID) &&
3599 ((raid->magic_0 != meta->controller_pci_id) ||
3600 (raid->magic_1 != meta->timestamp))) {
3604 switch (meta->type_total_disks & SIS_T_MASK) {
3606 raid->type = AR_T_JBOD;
3607 raid->width = (meta->type_total_disks & SIS_D_MASK);
3608 raid->total_sectors += SIS_LBA(parent);
3612 raid->type = AR_T_RAID0;
3613 raid->width = (meta->type_total_disks & SIS_D_MASK);
3614 if (!raid->total_sectors ||
3615 (raid->total_sectors > (raid->width * SIS_LBA(parent))))
3616 raid->total_sectors = raid->width * SIS_LBA(parent);
3620 raid->type = AR_T_RAID1;
3622 if (!raid->total_sectors || (raid->total_sectors > SIS_LBA(parent)))
3623 raid->total_sectors = SIS_LBA(parent);
3627 device_printf(parent, "Silicon Integrated Systems "
3628 "unknown RAID type 0x%08x\n", meta->magic);
3629 free(raidp[array], M_AR);
3630 raidp[array] = NULL;
3633 raid->magic_0 = meta->controller_pci_id;
3634 raid->magic_1 = meta->timestamp;
3635 raid->format = AR_F_SIS_RAID;
3636 raid->generation = 0;
3637 raid->interleave = meta->stripe_sectors;
3638 raid->total_disks = (meta->type_total_disks & SIS_D_MASK);
3641 raid->cylinders = raid->total_sectors / (63 * 255);
3642 raid->offset_sectors = 0;
3643 raid->rebuild_lba = 0;
3645 /* XXX SOS if total_disks > 2 this doesn't float */
3646 if (((meta->disks & SIS_D_MASTER) >> 4) == meta->disk_number)
3651 for (drive = 0; drive < raid->total_disks; drive++) {
3652 raid->disks[drive].sectors = raid->total_sectors/raid->width;
3653 if (drive == disk_number) {
3654 raid->disks[disk_number].dev = parent;
3655 raid->disks[disk_number].flags =
3656 (AR_DF_ONLINE | AR_DF_PRESENT | AR_DF_ASSIGNED);
3657 ars->raid[raid->volume] = raid;
3658 ars->disk_number[raid->volume] = disk_number;
3671 ata_raid_sis_write_meta(struct ar_softc *rdp)
3673 struct sis_raid_conf *meta;
3674 struct timeval timestamp;
3675 int disk, error = 0;
3677 if (!(meta = (struct sis_raid_conf *)
3678 malloc(sizeof(struct sis_raid_conf), M_AR, M_NOWAIT | M_ZERO))) {
3679 printf("ar%d: failed to allocate metadata storage\n", rdp->lun);
3684 microtime(×tamp);
3686 meta->magic = SIS_MAGIC;
3687 /* XXX SOS if total_disks > 2 this doesn't float */
3688 for (disk = 0; disk < rdp->total_disks; disk++) {
3689 if (rdp->disks[disk].dev) {
3690 struct ata_channel *ch =
3691 device_get_softc(device_get_parent(rdp->disks[disk].dev));
3692 struct ata_device *atadev = device_get_softc(rdp->disks[disk].dev);
3693 int disk_number = 1 + ATA_DEV(atadev->unit) + (ch->unit << 1);
3695 meta->disks |= disk_number << ((1 - disk) << 2);
3698 switch (rdp->type) {
3700 meta->type_total_disks = SIS_T_JBOD;
3704 meta->type_total_disks = SIS_T_RAID0;
3708 meta->type_total_disks = SIS_T_RAID1;
3715 meta->type_total_disks |= (rdp->total_disks & SIS_D_MASK);
3716 meta->stripe_sectors = rdp->interleave;
3717 meta->timestamp = timestamp.tv_sec;
3719 for (disk = 0; disk < rdp->total_disks; disk++) {
3720 if (rdp->disks[disk].dev) {
3721 struct ata_channel *ch =
3722 device_get_softc(device_get_parent(rdp->disks[disk].dev));
3723 struct ata_device *atadev = device_get_softc(rdp->disks[disk].dev);
3725 meta->controller_pci_id =
3726 (pci_get_vendor(GRANDPARENT(rdp->disks[disk].dev)) << 16) |
3727 pci_get_device(GRANDPARENT(rdp->disks[disk].dev));
3728 bcopy(atadev->param.model, meta->model, sizeof(meta->model));
3730 /* XXX SOS if total_disks > 2 this may not float */
3731 meta->disk_number = 1 + ATA_DEV(atadev->unit) + (ch->unit << 1);
3733 if (testing || bootverbose)
3734 ata_raid_sis_print_meta(meta);
3736 if (ata_raid_rw(rdp->disks[disk].dev,
3737 SIS_LBA(rdp->disks[disk].dev),
3738 meta, sizeof(struct sis_raid_conf),
3739 ATA_R_WRITE | ATA_R_DIRECT)) {
3740 device_printf(rdp->disks[disk].dev, "write metadata failed\n");
3749 /* VIA Tech V-RAID Metadata */
3751 ata_raid_via_read_meta(device_t dev, struct ar_softc **raidp)
3753 struct ata_raid_subdisk *ars = device_get_softc(dev);
3754 device_t parent = device_get_parent(dev);
3755 struct via_raid_conf *meta;
3756 struct ar_softc *raid = NULL;
3757 u_int8_t checksum, *ptr;
3758 int array, count, disk, retval = 0;
3760 if (!(meta = (struct via_raid_conf *)
3761 malloc(sizeof(struct via_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
3764 if (ata_raid_rw(parent, VIA_LBA(parent),
3765 meta, sizeof(struct via_raid_conf), ATA_R_READ)) {
3766 if (testing || bootverbose)
3767 device_printf(parent, "VIA read metadata failed\n");
3771 /* check if this is a VIA RAID struct */
3772 if (meta->magic != VIA_MAGIC) {
3773 if (testing || bootverbose)
3774 device_printf(parent, "VIA check1 failed\n");
3778 /* calculate checksum and compare for valid */
3779 for (checksum = 0, ptr = (u_int8_t *)meta, count = 0; count < 50; count++)
3781 if (checksum != meta->checksum) {
3782 if (testing || bootverbose)
3783 device_printf(parent, "VIA check2 failed\n");
3787 if (testing || bootverbose)
3788 ata_raid_via_print_meta(meta);
3790 /* now convert VIA meta into our generic form */
3791 for (array = 0; array < MAX_ARRAYS; array++) {
3792 if (!raidp[array]) {
3794 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
3796 if (!raidp[array]) {
3797 device_printf(parent, "failed to allocate metadata storage\n");
3801 raid = raidp[array];
3802 if (raid->format && (raid->format != AR_F_VIA_RAID))
3805 if (raid->format == AR_F_VIA_RAID && (raid->magic_0 != meta->disks[0]))
3808 switch (meta->type & VIA_T_MASK) {
3810 raid->type = AR_T_RAID0;
3811 raid->width = meta->stripe_layout & VIA_L_DISKS;
3812 if (!raid->total_sectors ||
3813 (raid->total_sectors > (raid->width * meta->disk_sectors)))
3814 raid->total_sectors = raid->width * meta->disk_sectors;
3818 raid->type = AR_T_RAID1;
3820 raid->total_sectors = meta->disk_sectors;
3824 raid->type = AR_T_RAID01;
3825 raid->width = meta->stripe_layout & VIA_L_DISKS;
3826 if (!raid->total_sectors ||
3827 (raid->total_sectors > (raid->width * meta->disk_sectors)))
3828 raid->total_sectors = raid->width * meta->disk_sectors;
3832 raid->type = AR_T_RAID5;
3833 raid->width = meta->stripe_layout & VIA_L_DISKS;
3834 if (!raid->total_sectors ||
3835 (raid->total_sectors > ((raid->width - 1)*meta->disk_sectors)))
3836 raid->total_sectors = (raid->width - 1) * meta->disk_sectors;
3840 raid->type = AR_T_SPAN;
3842 raid->total_sectors += meta->disk_sectors;
3846 device_printf(parent,"VIA unknown RAID type 0x%02x\n", meta->type);
3847 free(raidp[array], M_AR);
3848 raidp[array] = NULL;
3851 raid->magic_0 = meta->disks[0];
3852 raid->format = AR_F_VIA_RAID;
3853 raid->generation = 0;
3855 0x08 << ((meta->stripe_layout & VIA_L_MASK) >> VIA_L_SHIFT);
3856 for (count = 0, disk = 0; disk < 8; disk++)
3857 if (meta->disks[disk])
3859 raid->total_disks = count;
3862 raid->cylinders = raid->total_sectors / (63 * 255);
3863 raid->offset_sectors = 0;
3864 raid->rebuild_lba = 0;
3867 for (disk = 0; disk < raid->total_disks; disk++) {
3868 if (meta->disks[disk] == meta->disk_id) {
3869 raid->disks[disk].dev = parent;
3870 bcopy(&meta->disk_id, raid->disks[disk].serial,
3872 raid->disks[disk].sectors = meta->disk_sectors;
3873 raid->disks[disk].flags =
3874 (AR_DF_ONLINE | AR_DF_PRESENT | AR_DF_ASSIGNED);
3875 ars->raid[raid->volume] = raid;
3876 ars->disk_number[raid->volume] = disk;
3890 ata_raid_via_write_meta(struct ar_softc *rdp)
3892 struct via_raid_conf *meta;
3893 int disk, error = 0;
3895 if (!(meta = (struct via_raid_conf *)
3896 malloc(sizeof(struct via_raid_conf), M_AR, M_NOWAIT | M_ZERO))) {
3897 printf("ar%d: failed to allocate metadata storage\n", rdp->lun);
3903 meta->magic = VIA_MAGIC;
3904 meta->dummy_0 = 0x02;
3905 switch (rdp->type) {
3907 meta->type = VIA_T_SPAN;
3908 meta->stripe_layout = (rdp->total_disks & VIA_L_DISKS);
3912 meta->type = VIA_T_RAID0;
3913 meta->stripe_layout = ((rdp->interleave >> 1) & VIA_L_MASK);
3914 meta->stripe_layout |= (rdp->total_disks & VIA_L_DISKS);
3918 meta->type = VIA_T_RAID1;
3919 meta->stripe_layout = (rdp->total_disks & VIA_L_DISKS);
3923 meta->type = VIA_T_RAID5;
3924 meta->stripe_layout = ((rdp->interleave >> 1) & VIA_L_MASK);
3925 meta->stripe_layout |= (rdp->total_disks & VIA_L_DISKS);
3929 meta->type = VIA_T_RAID01;
3930 meta->stripe_layout = ((rdp->interleave >> 1) & VIA_L_MASK);
3931 meta->stripe_layout |= (rdp->width & VIA_L_DISKS);
3938 meta->type |= VIA_T_BOOTABLE; /* XXX SOS */
3939 meta->disk_sectors =
3940 rdp->total_sectors / (rdp->width - (rdp->type == AR_RAID5));
3941 for (disk = 0; disk < rdp->total_disks; disk++)
3942 meta->disks[disk] = (u_int32_t)(uintptr_t)rdp->disks[disk].dev;
3944 for (disk = 0; disk < rdp->total_disks; disk++) {
3945 if (rdp->disks[disk].dev) {
3949 meta->disk_index = disk * sizeof(u_int32_t);
3950 if (rdp->type == AR_T_RAID01)
3951 meta->disk_index = ((meta->disk_index & 0x08) << 2) |
3952 (meta->disk_index & ~0x08);
3953 meta->disk_id = meta->disks[disk];
3955 for (ptr = (u_int8_t *)meta, count = 0; count < 50; count++)
3956 meta->checksum += *ptr++;
3958 if (testing || bootverbose)
3959 ata_raid_via_print_meta(meta);
3961 if (ata_raid_rw(rdp->disks[disk].dev,
3962 VIA_LBA(rdp->disks[disk].dev),
3963 meta, sizeof(struct via_raid_conf),
3964 ATA_R_WRITE | ATA_R_DIRECT)) {
3965 device_printf(rdp->disks[disk].dev, "write metadata failed\n");
3974 static struct ata_request *
3975 ata_raid_init_request(struct ar_softc *rdp, struct bio *bio)
3977 struct ata_request *request;
3979 if (!(request = ata_alloc_request())) {
3980 printf("FAILURE - out of memory in ata_raid_init_request\n");
3983 request->timeout = 5;
3984 request->retries = 2;
3985 request->callback = ata_raid_done;
3986 request->driver = rdp;
3988 switch (request->bio->bio_cmd) {
3990 request->flags = ATA_R_READ;
3993 request->flags = ATA_R_WRITE;
4000 ata_raid_send_request(struct ata_request *request)
4002 struct ata_device *atadev = device_get_softc(request->dev);
4004 request->transfersize = min(request->bytecount, atadev->max_iosize);
4005 if (request->flags & ATA_R_READ) {
4006 if (atadev->mode >= ATA_DMA) {
4007 request->flags |= ATA_R_DMA;
4008 request->u.ata.command = ATA_READ_DMA;
4010 else if (atadev->max_iosize > DEV_BSIZE)
4011 request->u.ata.command = ATA_READ_MUL;
4013 request->u.ata.command = ATA_READ;
4015 else if (request->flags & ATA_R_WRITE) {
4016 if (atadev->mode >= ATA_DMA) {
4017 request->flags |= ATA_R_DMA;
4018 request->u.ata.command = ATA_WRITE_DMA;
4020 else if (atadev->max_iosize > DEV_BSIZE)
4021 request->u.ata.command = ATA_WRITE_MUL;
4023 request->u.ata.command = ATA_WRITE;
4026 device_printf(request->dev, "FAILURE - unknown IO operation\n");
4027 ata_free_request(request);
4030 request->flags |= (ATA_R_ORDERED | ATA_R_THREAD);
4031 ata_queue_request(request);
4036 ata_raid_rw(device_t dev, u_int64_t lba, void *data, u_int bcount, int flags)
4038 struct ata_device *atadev = device_get_softc(dev);
4039 struct ata_request *request;
4042 if (bcount % DEV_BSIZE) {
4043 device_printf(dev, "FAILURE - transfers must be modulo sectorsize\n");
4047 if (!(request = ata_alloc_request())) {
4048 device_printf(dev, "FAILURE - out of memory in ata_raid_rw\n");
4054 request->timeout = 10;
4055 request->retries = 0;
4056 request->data = data;
4057 request->bytecount = bcount;
4058 request->transfersize = DEV_BSIZE;
4059 request->u.ata.lba = lba;
4060 request->u.ata.count = request->bytecount / DEV_BSIZE;
4061 request->flags = flags;
4063 if (flags & ATA_R_READ) {
4064 if (atadev->mode >= ATA_DMA) {
4065 request->u.ata.command = ATA_READ_DMA;
4066 request->flags |= ATA_R_DMA;
4069 request->u.ata.command = ATA_READ;
4070 ata_queue_request(request);
4072 else if (flags & ATA_R_WRITE) {
4073 if (atadev->mode >= ATA_DMA) {
4074 request->u.ata.command = ATA_WRITE_DMA;
4075 request->flags |= ATA_R_DMA;
4078 request->u.ata.command = ATA_WRITE;
4079 ata_queue_request(request);
4082 device_printf(dev, "FAILURE - unknown IO operation\n");
4083 request->result = EIO;
4085 error = request->result;
4086 ata_free_request(request);
4094 ata_raid_subdisk_probe(device_t dev)
4101 ata_raid_subdisk_attach(device_t dev)
4103 struct ata_raid_subdisk *ars = device_get_softc(dev);
4106 for (volume = 0; volume < MAX_VOLUMES; volume++) {
4107 ars->raid[volume] = NULL;
4108 ars->disk_number[volume] = -1;
4110 ata_raid_read_metadata(dev);
4115 ata_raid_subdisk_detach(device_t dev)
4117 struct ata_raid_subdisk *ars = device_get_softc(dev);
4120 for (volume = 0; volume < MAX_VOLUMES; volume++) {
4121 if (ars->raid[volume]) {
4122 ars->raid[volume]->disks[ars->disk_number[volume]].flags &=
4123 ~(AR_DF_PRESENT | AR_DF_ONLINE);
4124 ars->raid[volume]->disks[ars->disk_number[volume]].dev = NULL;
4125 if (mtx_initialized(&ars->raid[volume]->lock))
4126 ata_raid_config_changed(ars->raid[volume], 1);
4127 ars->raid[volume] = NULL;
4128 ars->disk_number[volume] = -1;
4134 static device_method_t ata_raid_sub_methods[] = {
4135 /* device interface */
4136 DEVMETHOD(device_probe, ata_raid_subdisk_probe),
4137 DEVMETHOD(device_attach, ata_raid_subdisk_attach),
4138 DEVMETHOD(device_detach, ata_raid_subdisk_detach),
4142 static driver_t ata_raid_sub_driver = {
4144 ata_raid_sub_methods,
4145 sizeof(struct ata_raid_subdisk)
4148 DRIVER_MODULE(subdisk, ad, ata_raid_sub_driver, ata_raid_sub_devclass, NULL, NULL);
4151 ata_raid_module_event_handler(module_t mod, int what, void *arg)
4157 if (testing || bootverbose)
4158 printf("ATA PseudoRAID loaded\n");
4160 /* setup table to hold metadata for all ATA PseudoRAID arrays */
4161 ata_raid_arrays = malloc(sizeof(struct ar_soft *) * MAX_ARRAYS,
4162 M_AR, M_NOWAIT | M_ZERO);
4163 if (!ata_raid_arrays) {
4164 printf("ataraid: no memory for metadata storage\n");
4168 /* attach found PseudoRAID arrays */
4169 for (i = 0; i < MAX_ARRAYS; i++) {
4170 struct ar_softc *rdp = ata_raid_arrays[i];
4172 if (!rdp || !rdp->format)
4174 if (testing || bootverbose)
4175 ata_raid_print_meta(rdp);
4176 ata_raid_attach(rdp, 0);
4178 ata_raid_ioctl_func = ata_raid_ioctl;
4182 /* detach found PseudoRAID arrays */
4183 for (i = 0; i < MAX_ARRAYS; i++) {
4184 struct ar_softc *rdp = ata_raid_arrays[i];
4186 if (!rdp || !rdp->status)
4188 if (mtx_initialized(&rdp->lock))
4189 mtx_destroy(&rdp->lock);
4191 disk_destroy(rdp->disk);
4193 if (testing || bootverbose)
4194 printf("ATA PseudoRAID unloaded\n");
4196 free(ata_raid_arrays, M_AR);
4198 ata_raid_ioctl_func = NULL;
4206 static moduledata_t ata_raid_moduledata =
4207 { "ataraid", ata_raid_module_event_handler, NULL };
4208 DECLARE_MODULE(ata, ata_raid_moduledata, SI_SUB_RAID, SI_ORDER_FIRST);
4209 MODULE_VERSION(ataraid, 1);
4210 MODULE_DEPEND(ataraid, ata, 1, 1, 1);
4211 MODULE_DEPEND(ataraid, ad, 1, 1, 1);
4214 ata_raid_format(struct ar_softc *rdp)
4216 switch (rdp->format) {
4217 case AR_F_FREEBSD_RAID: return "FreeBSD PseudoRAID";
4218 case AR_F_ADAPTEC_RAID: return "Adaptec HostRAID";
4219 case AR_F_HPTV2_RAID: return "HighPoint v2 RocketRAID";
4220 case AR_F_HPTV3_RAID: return "HighPoint v3 RocketRAID";
4221 case AR_F_INTEL_RAID: return "Intel MatrixRAID";
4222 case AR_F_ITE_RAID: return "Integrated Technology Express";
4223 case AR_F_JMICRON_RAID: return "JMicron Technology Corp";
4224 case AR_F_LSIV2_RAID: return "LSILogic v2 MegaRAID";
4225 case AR_F_LSIV3_RAID: return "LSILogic v3 MegaRAID";
4226 case AR_F_NVIDIA_RAID: return "nVidia MediaShield";
4227 case AR_F_PROMISE_RAID: return "Promise Fasttrak";
4228 case AR_F_SII_RAID: return "Silicon Image Medley";
4229 case AR_F_SIS_RAID: return "Silicon Integrated Systems";
4230 case AR_F_VIA_RAID: return "VIA Tech V-RAID";
4231 default: return "UNKNOWN";
4236 ata_raid_type(struct ar_softc *rdp)
4238 switch (rdp->type) {
4239 case AR_T_JBOD: return "JBOD";
4240 case AR_T_SPAN: return "SPAN";
4241 case AR_T_RAID0: return "RAID0";
4242 case AR_T_RAID1: return "RAID1";
4243 case AR_T_RAID3: return "RAID3";
4244 case AR_T_RAID4: return "RAID4";
4245 case AR_T_RAID5: return "RAID5";
4246 case AR_T_RAID01: return "RAID0+1";
4247 default: return "UNKNOWN";
4252 ata_raid_flags(struct ar_softc *rdp)
4254 switch (rdp->status & (AR_S_READY | AR_S_DEGRADED | AR_S_REBUILDING)) {
4255 case AR_S_READY: return "READY";
4256 case AR_S_READY | AR_S_DEGRADED: return "DEGRADED";
4257 case AR_S_READY | AR_S_REBUILDING:
4258 case AR_S_READY | AR_S_DEGRADED | AR_S_REBUILDING: return "REBUILDING";
4259 default: return "BROKEN";
4263 /* debugging gunk */
4265 ata_raid_print_meta(struct ar_softc *raid)
4269 printf("********** ATA PseudoRAID ar%d Metadata **********\n", raid->lun);
4270 printf("=================================================\n");
4271 printf("format %s\n", ata_raid_format(raid));
4272 printf("type %s\n", ata_raid_type(raid));
4273 printf("flags 0x%02x %b\n", raid->status, raid->status,
4274 "\20\3REBUILDING\2DEGRADED\1READY\n");
4275 printf("magic_0 0x%016jx\n", raid->magic_0);
4276 printf("magic_1 0x%016jx\n",raid->magic_1);
4277 printf("generation %u\n", raid->generation);
4278 printf("total_sectors %ju\n", raid->total_sectors);
4279 printf("offset_sectors %ju\n", raid->offset_sectors);
4280 printf("heads %u\n", raid->heads);
4281 printf("sectors %u\n", raid->sectors);
4282 printf("cylinders %u\n", raid->cylinders);
4283 printf("width %u\n", raid->width);
4284 printf("interleave %u\n", raid->interleave);
4285 printf("total_disks %u\n", raid->total_disks);
4286 for (i = 0; i < raid->total_disks; i++) {
4287 printf(" disk %d: flags = 0x%02x %b\n", i, raid->disks[i].flags,
4288 raid->disks[i].flags, "\20\4ONLINE\3SPARE\2ASSIGNED\1PRESENT\n");
4289 if (raid->disks[i].dev) {
4291 device_printf(raid->disks[i].dev, " sectors %jd\n",
4292 raid->disks[i].sectors);
4295 printf("=================================================\n");
4299 ata_raid_adaptec_type(int type)
4301 static char buffer[16];
4304 case ADP_T_RAID0: return "RAID0";
4305 case ADP_T_RAID1: return "RAID1";
4306 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4312 ata_raid_adaptec_print_meta(struct adaptec_raid_conf *meta)
4316 printf("********* ATA Adaptec HostRAID Metadata *********\n");
4317 printf("magic_0 <0x%08x>\n", be32toh(meta->magic_0));
4318 printf("generation 0x%08x\n", be32toh(meta->generation));
4319 printf("dummy_0 0x%04x\n", be16toh(meta->dummy_0));
4320 printf("total_configs %u\n", be16toh(meta->total_configs));
4321 printf("dummy_1 0x%04x\n", be16toh(meta->dummy_1));
4322 printf("checksum 0x%04x\n", be16toh(meta->checksum));
4323 printf("dummy_2 0x%08x\n", be32toh(meta->dummy_2));
4324 printf("dummy_3 0x%08x\n", be32toh(meta->dummy_3));
4325 printf("flags 0x%08x\n", be32toh(meta->flags));
4326 printf("timestamp 0x%08x\n", be32toh(meta->timestamp));
4327 printf("dummy_4 0x%08x 0x%08x 0x%08x 0x%08x\n",
4328 be32toh(meta->dummy_4[0]), be32toh(meta->dummy_4[1]),
4329 be32toh(meta->dummy_4[2]), be32toh(meta->dummy_4[3]));
4330 printf("dummy_5 0x%08x 0x%08x 0x%08x 0x%08x\n",
4331 be32toh(meta->dummy_5[0]), be32toh(meta->dummy_5[1]),
4332 be32toh(meta->dummy_5[2]), be32toh(meta->dummy_5[3]));
4334 for (i = 0; i < be16toh(meta->total_configs); i++) {
4335 printf(" %d total_disks %u\n", i,
4336 be16toh(meta->configs[i].disk_number));
4337 printf(" %d generation %u\n", i,
4338 be16toh(meta->configs[i].generation));
4339 printf(" %d magic_0 0x%08x\n", i,
4340 be32toh(meta->configs[i].magic_0));
4341 printf(" %d dummy_0 0x%02x\n", i, meta->configs[i].dummy_0);
4342 printf(" %d type %s\n", i,
4343 ata_raid_adaptec_type(meta->configs[i].type));
4344 printf(" %d dummy_1 0x%02x\n", i, meta->configs[i].dummy_1);
4345 printf(" %d flags %d\n", i,
4346 be32toh(meta->configs[i].flags));
4347 printf(" %d dummy_2 0x%02x\n", i, meta->configs[i].dummy_2);
4348 printf(" %d dummy_3 0x%02x\n", i, meta->configs[i].dummy_3);
4349 printf(" %d dummy_4 0x%02x\n", i, meta->configs[i].dummy_4);
4350 printf(" %d dummy_5 0x%02x\n", i, meta->configs[i].dummy_5);
4351 printf(" %d disk_number %u\n", i,
4352 be32toh(meta->configs[i].disk_number));
4353 printf(" %d dummy_6 0x%08x\n", i,
4354 be32toh(meta->configs[i].dummy_6));
4355 printf(" %d sectors %u\n", i,
4356 be32toh(meta->configs[i].sectors));
4357 printf(" %d stripe_shift %u\n", i,
4358 be16toh(meta->configs[i].stripe_shift));
4359 printf(" %d dummy_7 0x%08x\n", i,
4360 be32toh(meta->configs[i].dummy_7));
4361 printf(" %d dummy_8 0x%08x 0x%08x 0x%08x 0x%08x\n", i,
4362 be32toh(meta->configs[i].dummy_8[0]),
4363 be32toh(meta->configs[i].dummy_8[1]),
4364 be32toh(meta->configs[i].dummy_8[2]),
4365 be32toh(meta->configs[i].dummy_8[3]));
4366 printf(" %d name <%s>\n", i, meta->configs[i].name);
4368 printf("magic_1 <0x%08x>\n", be32toh(meta->magic_1));
4369 printf("magic_2 <0x%08x>\n", be32toh(meta->magic_2));
4370 printf("magic_3 <0x%08x>\n", be32toh(meta->magic_3));
4371 printf("magic_4 <0x%08x>\n", be32toh(meta->magic_4));
4372 printf("=================================================\n");
4376 ata_raid_hptv2_type(int type)
4378 static char buffer[16];
4381 case HPTV2_T_RAID0: return "RAID0";
4382 case HPTV2_T_RAID1: return "RAID1";
4383 case HPTV2_T_RAID01_RAID0: return "RAID01_RAID0";
4384 case HPTV2_T_SPAN: return "SPAN";
4385 case HPTV2_T_RAID_3: return "RAID3";
4386 case HPTV2_T_RAID_5: return "RAID5";
4387 case HPTV2_T_JBOD: return "JBOD";
4388 case HPTV2_T_RAID01_RAID1: return "RAID01_RAID1";
4389 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4395 ata_raid_hptv2_print_meta(struct hptv2_raid_conf *meta)
4399 printf("****** ATA Highpoint V2 RocketRAID Metadata *****\n");
4400 printf("magic 0x%08x\n", meta->magic);
4401 printf("magic_0 0x%08x\n", meta->magic_0);
4402 printf("magic_1 0x%08x\n", meta->magic_1);
4403 printf("order 0x%08x\n", meta->order);
4404 printf("array_width %u\n", meta->array_width);
4405 printf("stripe_shift %u\n", meta->stripe_shift);
4406 printf("type %s\n", ata_raid_hptv2_type(meta->type));
4407 printf("disk_number %u\n", meta->disk_number);
4408 printf("total_sectors %u\n", meta->total_sectors);
4409 printf("disk_mode 0x%08x\n", meta->disk_mode);
4410 printf("boot_mode 0x%08x\n", meta->boot_mode);
4411 printf("boot_disk 0x%02x\n", meta->boot_disk);
4412 printf("boot_protect 0x%02x\n", meta->boot_protect);
4413 printf("log_entries 0x%02x\n", meta->error_log_entries);
4414 printf("log_index 0x%02x\n", meta->error_log_index);
4415 if (meta->error_log_entries) {
4416 printf(" timestamp reason disk status sectors lba\n");
4417 for (i = meta->error_log_index;
4418 i < meta->error_log_index + meta->error_log_entries; i++)
4419 printf(" 0x%08x 0x%02x 0x%02x 0x%02x 0x%02x 0x%08x\n",
4420 meta->errorlog[i%32].timestamp,
4421 meta->errorlog[i%32].reason,
4422 meta->errorlog[i%32].disk, meta->errorlog[i%32].status,
4423 meta->errorlog[i%32].sectors, meta->errorlog[i%32].lba);
4425 printf("rebuild_lba 0x%08x\n", meta->rebuild_lba);
4426 printf("dummy_1 0x%02x\n", meta->dummy_1);
4427 printf("name_1 <%.15s>\n", meta->name_1);
4428 printf("dummy_2 0x%02x\n", meta->dummy_2);
4429 printf("name_2 <%.15s>\n", meta->name_2);
4430 printf("=================================================\n");
4434 ata_raid_hptv3_type(int type)
4436 static char buffer[16];
4439 case HPTV3_T_SPARE: return "SPARE";
4440 case HPTV3_T_JBOD: return "JBOD";
4441 case HPTV3_T_SPAN: return "SPAN";
4442 case HPTV3_T_RAID0: return "RAID0";
4443 case HPTV3_T_RAID1: return "RAID1";
4444 case HPTV3_T_RAID3: return "RAID3";
4445 case HPTV3_T_RAID5: return "RAID5";
4446 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4452 ata_raid_hptv3_print_meta(struct hptv3_raid_conf *meta)
4456 printf("****** ATA Highpoint V3 RocketRAID Metadata *****\n");
4457 printf("magic 0x%08x\n", meta->magic);
4458 printf("magic_0 0x%08x\n", meta->magic_0);
4459 printf("checksum_0 0x%02x\n", meta->checksum_0);
4460 printf("mode 0x%02x\n", meta->mode);
4461 printf("user_mode 0x%02x\n", meta->user_mode);
4462 printf("config_entries 0x%02x\n", meta->config_entries);
4463 for (i = 0; i < meta->config_entries; i++) {
4464 printf("config %d:\n", i);
4465 printf(" total_sectors %ju\n",
4466 meta->configs[0].total_sectors +
4467 ((u_int64_t)meta->configs_high[0].total_sectors << 32));
4468 printf(" type %s\n",
4469 ata_raid_hptv3_type(meta->configs[i].type));
4470 printf(" total_disks %u\n", meta->configs[i].total_disks);
4471 printf(" disk_number %u\n", meta->configs[i].disk_number);
4472 printf(" stripe_shift %u\n", meta->configs[i].stripe_shift);
4473 printf(" status %b\n", meta->configs[i].status,
4474 "\20\2RAID5\1NEED_REBUILD\n");
4475 printf(" critical_disks %u\n", meta->configs[i].critical_disks);
4476 printf(" rebuild_lba %ju\n",
4477 meta->configs_high[0].rebuild_lba +
4478 ((u_int64_t)meta->configs_high[0].rebuild_lba << 32));
4480 printf("name <%.16s>\n", meta->name);
4481 printf("timestamp 0x%08x\n", meta->timestamp);
4482 printf("description <%.16s>\n", meta->description);
4483 printf("creator <%.16s>\n", meta->creator);
4484 printf("checksum_1 0x%02x\n", meta->checksum_1);
4485 printf("dummy_0 0x%02x\n", meta->dummy_0);
4486 printf("dummy_1 0x%02x\n", meta->dummy_1);
4487 printf("flags %b\n", meta->flags,
4488 "\20\4RCACHE\3WCACHE\2NCQ\1TCQ\n");
4489 printf("=================================================\n");
4493 ata_raid_intel_type(int type)
4495 static char buffer[16];
4498 case INTEL_T_RAID0: return "RAID0";
4499 case INTEL_T_RAID1: return "RAID1";
4500 case INTEL_T_RAID5: return "RAID5";
4501 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4507 ata_raid_intel_print_meta(struct intel_raid_conf *meta)
4509 struct intel_raid_mapping *map;
4512 printf("********* ATA Intel MatrixRAID Metadata *********\n");
4513 printf("intel_id <%.24s>\n", meta->intel_id);
4514 printf("version <%.6s>\n", meta->version);
4515 printf("checksum 0x%08x\n", meta->checksum);
4516 printf("config_size 0x%08x\n", meta->config_size);
4517 printf("config_id 0x%08x\n", meta->config_id);
4518 printf("generation 0x%08x\n", meta->generation);
4519 printf("total_disks %u\n", meta->total_disks);
4520 printf("total_volumes %u\n", meta->total_volumes);
4521 printf("DISK# serial disk_sectors disk_id flags\n");
4522 for (i = 0; i < meta->total_disks; i++ ) {
4523 printf(" %d <%.16s> %u 0x%08x 0x%08x\n", i,
4524 meta->disk[i].serial, meta->disk[i].sectors,
4525 meta->disk[i].id, meta->disk[i].flags);
4527 map = (struct intel_raid_mapping *)&meta->disk[meta->total_disks];
4528 for (j = 0; j < meta->total_volumes; j++) {
4529 printf("name %.16s\n", map->name);
4530 printf("total_sectors %ju\n", map->total_sectors);
4531 printf("state %u\n", map->state);
4532 printf("reserved %u\n", map->reserved);
4533 printf("offset %u\n", map->offset);
4534 printf("disk_sectors %u\n", map->disk_sectors);
4535 printf("stripe_count %u\n", map->stripe_count);
4536 printf("stripe_sectors %u\n", map->stripe_sectors);
4537 printf("status %u\n", map->status);
4538 printf("type %s\n", ata_raid_intel_type(map->type));
4539 printf("total_disks %u\n", map->total_disks);
4540 printf("magic[0] 0x%02x\n", map->magic[0]);
4541 printf("magic[1] 0x%02x\n", map->magic[1]);
4542 printf("magic[2] 0x%02x\n", map->magic[2]);
4543 for (i = 0; i < map->total_disks; i++ ) {
4544 printf(" disk %d at disk_idx 0x%08x\n", i, map->disk_idx[i]);
4546 map = (struct intel_raid_mapping *)&map->disk_idx[map->total_disks];
4548 printf("=================================================\n");
4552 ata_raid_ite_type(int type)
4554 static char buffer[16];
4557 case ITE_T_RAID0: return "RAID0";
4558 case ITE_T_RAID1: return "RAID1";
4559 case ITE_T_RAID01: return "RAID0+1";
4560 case ITE_T_SPAN: return "SPAN";
4561 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4567 ata_raid_ite_print_meta(struct ite_raid_conf *meta)
4569 printf("*** ATA Integrated Technology Express Metadata **\n");
4570 printf("ite_id <%.40s>\n", meta->ite_id);
4571 printf("timestamp_0 %04x/%02x/%02x %02x:%02x:%02x.%02x\n",
4572 *((u_int16_t *)meta->timestamp_0), meta->timestamp_0[2],
4573 meta->timestamp_0[3], meta->timestamp_0[5], meta->timestamp_0[4],
4574 meta->timestamp_0[7], meta->timestamp_0[6]);
4575 printf("total_sectors %jd\n", meta->total_sectors);
4576 printf("type %s\n", ata_raid_ite_type(meta->type));
4577 printf("stripe_1kblocks %u\n", meta->stripe_1kblocks);
4578 printf("timestamp_1 %04x/%02x/%02x %02x:%02x:%02x.%02x\n",
4579 *((u_int16_t *)meta->timestamp_1), meta->timestamp_1[2],
4580 meta->timestamp_1[3], meta->timestamp_1[5], meta->timestamp_1[4],
4581 meta->timestamp_1[7], meta->timestamp_1[6]);
4582 printf("stripe_sectors %u\n", meta->stripe_sectors);
4583 printf("array_width %u\n", meta->array_width);
4584 printf("disk_number %u\n", meta->disk_number);
4585 printf("disk_sectors %u\n", meta->disk_sectors);
4586 printf("=================================================\n");
4590 ata_raid_jmicron_type(int type)
4592 static char buffer[16];
4595 case JM_T_RAID0: return "RAID0";
4596 case JM_T_RAID1: return "RAID1";
4597 case JM_T_RAID01: return "RAID0+1";
4598 case JM_T_JBOD: return "JBOD";
4599 case JM_T_RAID5: return "RAID5";
4600 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4606 ata_raid_jmicron_print_meta(struct jmicron_raid_conf *meta)
4610 printf("***** ATA JMicron Technology Corp Metadata ******\n");
4611 printf("signature %.2s\n", meta->signature);
4612 printf("version 0x%04x\n", meta->version);
4613 printf("checksum 0x%04x\n", meta->checksum);
4614 printf("disk_id 0x%08x\n", meta->disk_id);
4615 printf("offset 0x%08x\n", meta->offset);
4616 printf("disk_sectors_low 0x%08x\n", meta->disk_sectors_low);
4617 printf("disk_sectors_high 0x%08x\n", meta->disk_sectors_high);
4618 printf("name %.16s\n", meta->name);
4619 printf("type %s\n", ata_raid_jmicron_type(meta->type));
4620 printf("stripe_shift %d\n", meta->stripe_shift);
4621 printf("flags 0x%04x\n", meta->flags);
4623 for (i=0; i < 2 && meta->spare[i]; i++)
4624 printf(" %d 0x%08x\n", i, meta->spare[i]);
4626 for (i=0; i < 8 && meta->disks[i]; i++)
4627 printf(" %d 0x%08x\n", i, meta->disks[i]);
4628 printf("=================================================\n");
4632 ata_raid_lsiv2_type(int type)
4634 static char buffer[16];
4637 case LSIV2_T_RAID0: return "RAID0";
4638 case LSIV2_T_RAID1: return "RAID1";
4639 case LSIV2_T_SPARE: return "SPARE";
4640 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4646 ata_raid_lsiv2_print_meta(struct lsiv2_raid_conf *meta)
4650 printf("******* ATA LSILogic V2 MegaRAID Metadata *******\n");
4651 printf("lsi_id <%s>\n", meta->lsi_id);
4652 printf("dummy_0 0x%02x\n", meta->dummy_0);
4653 printf("flags 0x%02x\n", meta->flags);
4654 printf("version 0x%04x\n", meta->version);
4655 printf("config_entries 0x%02x\n", meta->config_entries);
4656 printf("raid_count 0x%02x\n", meta->raid_count);
4657 printf("total_disks 0x%02x\n", meta->total_disks);
4658 printf("dummy_1 0x%02x\n", meta->dummy_1);
4659 printf("dummy_2 0x%04x\n", meta->dummy_2);
4660 for (i = 0; i < meta->config_entries; i++) {
4661 printf(" type %s\n",
4662 ata_raid_lsiv2_type(meta->configs[i].raid.type));
4663 printf(" dummy_0 %02x\n", meta->configs[i].raid.dummy_0);
4664 printf(" stripe_sectors %u\n",
4665 meta->configs[i].raid.stripe_sectors);
4666 printf(" array_width %u\n",
4667 meta->configs[i].raid.array_width);
4668 printf(" disk_count %u\n", meta->configs[i].raid.disk_count);
4669 printf(" config_offset %u\n",
4670 meta->configs[i].raid.config_offset);
4671 printf(" dummy_1 %u\n", meta->configs[i].raid.dummy_1);
4672 printf(" flags %02x\n", meta->configs[i].raid.flags);
4673 printf(" total_sectors %u\n",
4674 meta->configs[i].raid.total_sectors);
4676 printf("disk_number 0x%02x\n", meta->disk_number);
4677 printf("raid_number 0x%02x\n", meta->raid_number);
4678 printf("timestamp 0x%08x\n", meta->timestamp);
4679 printf("=================================================\n");
4683 ata_raid_lsiv3_type(int type)
4685 static char buffer[16];
4688 case LSIV3_T_RAID0: return "RAID0";
4689 case LSIV3_T_RAID1: return "RAID1";
4690 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4696 ata_raid_lsiv3_print_meta(struct lsiv3_raid_conf *meta)
4700 printf("******* ATA LSILogic V3 MegaRAID Metadata *******\n");
4701 printf("lsi_id <%.6s>\n", meta->lsi_id);
4702 printf("dummy_0 0x%04x\n", meta->dummy_0);
4703 printf("version 0x%04x\n", meta->version);
4704 printf("dummy_0 0x%04x\n", meta->dummy_1);
4705 printf("RAID configs:\n");
4706 for (i = 0; i < 8; i++) {
4707 if (meta->raid[i].total_disks) {
4708 printf("%02d stripe_pages %u\n", i,
4709 meta->raid[i].stripe_pages);
4710 printf("%02d type %s\n", i,
4711 ata_raid_lsiv3_type(meta->raid[i].type));
4712 printf("%02d total_disks %u\n", i,
4713 meta->raid[i].total_disks);
4714 printf("%02d array_width %u\n", i,
4715 meta->raid[i].array_width);
4716 printf("%02d sectors %u\n", i, meta->raid[i].sectors);
4717 printf("%02d offset %u\n", i, meta->raid[i].offset);
4718 printf("%02d device 0x%02x\n", i,
4719 meta->raid[i].device);
4722 printf("DISK configs:\n");
4723 for (i = 0; i < 6; i++) {
4724 if (meta->disk[i].disk_sectors) {
4725 printf("%02d disk_sectors %u\n", i,
4726 meta->disk[i].disk_sectors);
4727 printf("%02d flags 0x%02x\n", i, meta->disk[i].flags);
4730 printf("device 0x%02x\n", meta->device);
4731 printf("timestamp 0x%08x\n", meta->timestamp);
4732 printf("checksum_1 0x%02x\n", meta->checksum_1);
4733 printf("=================================================\n");
4737 ata_raid_nvidia_type(int type)
4739 static char buffer[16];
4742 case NV_T_SPAN: return "SPAN";
4743 case NV_T_RAID0: return "RAID0";
4744 case NV_T_RAID1: return "RAID1";
4745 case NV_T_RAID3: return "RAID3";
4746 case NV_T_RAID5: return "RAID5";
4747 case NV_T_RAID01: return "RAID0+1";
4748 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4754 ata_raid_nvidia_print_meta(struct nvidia_raid_conf *meta)
4756 printf("******** ATA nVidia MediaShield Metadata ********\n");
4757 printf("nvidia_id <%.8s>\n", meta->nvidia_id);
4758 printf("config_size %d\n", meta->config_size);
4759 printf("checksum 0x%08x\n", meta->checksum);
4760 printf("version 0x%04x\n", meta->version);
4761 printf("disk_number %d\n", meta->disk_number);
4762 printf("dummy_0 0x%02x\n", meta->dummy_0);
4763 printf("total_sectors %d\n", meta->total_sectors);
4764 printf("sectors_size %d\n", meta->sector_size);
4765 printf("serial %.16s\n", meta->serial);
4766 printf("revision %.4s\n", meta->revision);
4767 printf("dummy_1 0x%08x\n", meta->dummy_1);
4768 printf("magic_0 0x%08x\n", meta->magic_0);
4769 printf("magic_1 0x%016jx\n", meta->magic_1);
4770 printf("magic_2 0x%016jx\n", meta->magic_2);
4771 printf("flags 0x%02x\n", meta->flags);
4772 printf("array_width %d\n", meta->array_width);
4773 printf("total_disks %d\n", meta->total_disks);
4774 printf("dummy_2 0x%02x\n", meta->dummy_2);
4775 printf("type %s\n", ata_raid_nvidia_type(meta->type));
4776 printf("dummy_3 0x%04x\n", meta->dummy_3);
4777 printf("stripe_sectors %d\n", meta->stripe_sectors);
4778 printf("stripe_bytes %d\n", meta->stripe_bytes);
4779 printf("stripe_shift %d\n", meta->stripe_shift);
4780 printf("stripe_mask 0x%08x\n", meta->stripe_mask);
4781 printf("stripe_sizesectors %d\n", meta->stripe_sizesectors);
4782 printf("stripe_sizebytes %d\n", meta->stripe_sizebytes);
4783 printf("rebuild_lba %d\n", meta->rebuild_lba);
4784 printf("dummy_4 0x%08x\n", meta->dummy_4);
4785 printf("dummy_5 0x%08x\n", meta->dummy_5);
4786 printf("status 0x%08x\n", meta->status);
4787 printf("=================================================\n");
4791 ata_raid_promise_type(int type)
4793 static char buffer[16];
4796 case PR_T_RAID0: return "RAID0";
4797 case PR_T_RAID1: return "RAID1";
4798 case PR_T_RAID3: return "RAID3";
4799 case PR_T_RAID5: return "RAID5";
4800 case PR_T_SPAN: return "SPAN";
4801 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4807 ata_raid_promise_print_meta(struct promise_raid_conf *meta)
4811 printf("********* ATA Promise FastTrak Metadata *********\n");
4812 printf("promise_id <%s>\n", meta->promise_id);
4813 printf("dummy_0 0x%08x\n", meta->dummy_0);
4814 printf("magic_0 0x%016jx\n", meta->magic_0);
4815 printf("magic_1 0x%04x\n", meta->magic_1);
4816 printf("magic_2 0x%08x\n", meta->magic_2);
4817 printf("integrity 0x%08x %b\n", meta->raid.integrity,
4818 meta->raid.integrity, "\20\10VALID\n" );
4819 printf("flags 0x%02x %b\n",
4820 meta->raid.flags, meta->raid.flags,
4821 "\20\10READY\7DOWN\6REDIR\5DUPLICATE\4SPARE"
4822 "\3ASSIGNED\2ONLINE\1VALID\n");
4823 printf("disk_number %d\n", meta->raid.disk_number);
4824 printf("channel 0x%02x\n", meta->raid.channel);
4825 printf("device 0x%02x\n", meta->raid.device);
4826 printf("magic_0 0x%016jx\n", meta->raid.magic_0);
4827 printf("disk_offset %u\n", meta->raid.disk_offset);
4828 printf("disk_sectors %u\n", meta->raid.disk_sectors);
4829 printf("rebuild_lba 0x%08x\n", meta->raid.rebuild_lba);
4830 printf("generation 0x%04x\n", meta->raid.generation);
4831 printf("status 0x%02x %b\n",
4832 meta->raid.status, meta->raid.status,
4833 "\20\6MARKED\5DEGRADED\4READY\3INITED\2ONLINE\1VALID\n");
4834 printf("type %s\n", ata_raid_promise_type(meta->raid.type));
4835 printf("total_disks %u\n", meta->raid.total_disks);
4836 printf("stripe_shift %u\n", meta->raid.stripe_shift);
4837 printf("array_width %u\n", meta->raid.array_width);
4838 printf("array_number %u\n", meta->raid.array_number);
4839 printf("total_sectors %u\n", meta->raid.total_sectors);
4840 printf("cylinders %u\n", meta->raid.cylinders);
4841 printf("heads %u\n", meta->raid.heads);
4842 printf("sectors %u\n", meta->raid.sectors);
4843 printf("magic_1 0x%016jx\n", meta->raid.magic_1);
4844 printf("DISK# flags dummy_0 channel device magic_0\n");
4845 for (i = 0; i < 8; i++) {
4846 printf(" %d %b 0x%02x 0x%02x 0x%02x ",
4847 i, meta->raid.disk[i].flags,
4848 "\20\10READY\7DOWN\6REDIR\5DUPLICATE\4SPARE"
4849 "\3ASSIGNED\2ONLINE\1VALID\n", meta->raid.disk[i].dummy_0,
4850 meta->raid.disk[i].channel, meta->raid.disk[i].device);
4851 printf("0x%016jx\n", meta->raid.disk[i].magic_0);
4853 printf("checksum 0x%08x\n", meta->checksum);
4854 printf("=================================================\n");
4858 ata_raid_sii_type(int type)
4860 static char buffer[16];
4863 case SII_T_RAID0: return "RAID0";
4864 case SII_T_RAID1: return "RAID1";
4865 case SII_T_RAID01: return "RAID0+1";
4866 case SII_T_SPARE: return "SPARE";
4867 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4873 ata_raid_sii_print_meta(struct sii_raid_conf *meta)
4875 printf("******* ATA Silicon Image Medley Metadata *******\n");
4876 printf("total_sectors %ju\n", meta->total_sectors);
4877 printf("dummy_0 0x%04x\n", meta->dummy_0);
4878 printf("dummy_1 0x%04x\n", meta->dummy_1);
4879 printf("controller_pci_id 0x%08x\n", meta->controller_pci_id);
4880 printf("version_minor 0x%04x\n", meta->version_minor);
4881 printf("version_major 0x%04x\n", meta->version_major);
4882 printf("timestamp 20%02x/%02x/%02x %02x:%02x:%02x\n",
4883 meta->timestamp[5], meta->timestamp[4], meta->timestamp[3],
4884 meta->timestamp[2], meta->timestamp[1], meta->timestamp[0]);
4885 printf("stripe_sectors %u\n", meta->stripe_sectors);
4886 printf("dummy_2 0x%04x\n", meta->dummy_2);
4887 printf("disk_number %u\n", meta->disk_number);
4888 printf("type %s\n", ata_raid_sii_type(meta->type));
4889 printf("raid0_disks %u\n", meta->raid0_disks);
4890 printf("raid0_ident %u\n", meta->raid0_ident);
4891 printf("raid1_disks %u\n", meta->raid1_disks);
4892 printf("raid1_ident %u\n", meta->raid1_ident);
4893 printf("rebuild_lba %ju\n", meta->rebuild_lba);
4894 printf("generation 0x%08x\n", meta->generation);
4895 printf("status 0x%02x %b\n",
4896 meta->status, meta->status,
4898 printf("base_raid1_position %02x\n", meta->base_raid1_position);
4899 printf("base_raid0_position %02x\n", meta->base_raid0_position);
4900 printf("position %02x\n", meta->position);
4901 printf("dummy_3 %04x\n", meta->dummy_3);
4902 printf("name <%.16s>\n", meta->name);
4903 printf("checksum_0 0x%04x\n", meta->checksum_0);
4904 printf("checksum_1 0x%04x\n", meta->checksum_1);
4905 printf("=================================================\n");
4909 ata_raid_sis_type(int type)
4911 static char buffer[16];
4914 case SIS_T_JBOD: return "JBOD";
4915 case SIS_T_RAID0: return "RAID0";
4916 case SIS_T_RAID1: return "RAID1";
4917 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4923 ata_raid_sis_print_meta(struct sis_raid_conf *meta)
4925 printf("**** ATA Silicon Integrated Systems Metadata ****\n");
4926 printf("magic 0x%04x\n", meta->magic);
4927 printf("disks 0x%02x\n", meta->disks);
4929 ata_raid_sis_type(meta->type_total_disks & SIS_T_MASK));
4930 printf("total_disks %u\n", meta->type_total_disks & SIS_D_MASK);
4931 printf("dummy_0 0x%08x\n", meta->dummy_0);
4932 printf("controller_pci_id 0x%08x\n", meta->controller_pci_id);
4933 printf("stripe_sectors %u\n", meta->stripe_sectors);
4934 printf("dummy_1 0x%04x\n", meta->dummy_1);
4935 printf("timestamp 0x%08x\n", meta->timestamp);
4936 printf("model %.40s\n", meta->model);
4937 printf("disk_number %u\n", meta->disk_number);
4938 printf("dummy_2 0x%02x 0x%02x 0x%02x\n",
4939 meta->dummy_2[0], meta->dummy_2[1], meta->dummy_2[2]);
4940 printf("=================================================\n");
4944 ata_raid_via_type(int type)
4946 static char buffer[16];
4949 case VIA_T_RAID0: return "RAID0";
4950 case VIA_T_RAID1: return "RAID1";
4951 case VIA_T_RAID5: return "RAID5";
4952 case VIA_T_RAID01: return "RAID0+1";
4953 case VIA_T_SPAN: return "SPAN";
4954 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4960 ata_raid_via_print_meta(struct via_raid_conf *meta)
4964 printf("*************** ATA VIA Metadata ****************\n");
4965 printf("magic 0x%02x\n", meta->magic);
4966 printf("dummy_0 0x%02x\n", meta->dummy_0);
4968 ata_raid_via_type(meta->type & VIA_T_MASK));
4969 printf("bootable %d\n", meta->type & VIA_T_BOOTABLE);
4970 printf("unknown %d\n", meta->type & VIA_T_UNKNOWN);
4971 printf("disk_index 0x%02x\n", meta->disk_index);
4972 printf("stripe_layout 0x%02x\n", meta->stripe_layout);
4973 printf(" stripe_disks %d\n", meta->stripe_layout & VIA_L_DISKS);
4974 printf(" stripe_sectors %d\n",
4975 0x08 << ((meta->stripe_layout & VIA_L_MASK) >> VIA_L_SHIFT));
4976 printf("disk_sectors %ju\n", meta->disk_sectors);
4977 printf("disk_id 0x%08x\n", meta->disk_id);
4978 printf("DISK# disk_id\n");
4979 for (i = 0; i < 8; i++) {
4981 printf(" %d 0x%08x\n", i, meta->disks[i]);
4983 printf("checksum 0x%02x\n", meta->checksum);
4984 printf("=================================================\n");