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(struct ata_ioc_raid_config *config);
60 static int ata_raid_create(struct ata_ioc_raid_config *config);
61 static int ata_raid_delete(int array);
62 static int ata_raid_addspare(struct ata_ioc_raid_config *config);
63 static int ata_raid_rebuild(int array);
64 static int ata_raid_read_metadata(device_t subdisk);
65 static int ata_raid_write_metadata(struct ar_softc *rdp);
66 static int ata_raid_wipe_metadata(struct ar_softc *rdp);
67 static int ata_raid_adaptec_read_meta(device_t dev, struct ar_softc **raidp);
68 static int ata_raid_hptv2_read_meta(device_t dev, struct ar_softc **raidp);
69 static int ata_raid_hptv2_write_meta(struct ar_softc *rdp);
70 static int ata_raid_hptv3_read_meta(device_t dev, struct ar_softc **raidp);
71 static int ata_raid_intel_read_meta(device_t dev, struct ar_softc **raidp);
72 static int ata_raid_intel_write_meta(struct ar_softc *rdp);
73 static int ata_raid_ite_read_meta(device_t dev, struct ar_softc **raidp);
74 static int ata_raid_jmicron_read_meta(device_t dev, struct ar_softc **raidp);
75 static int ata_raid_jmicron_write_meta(struct ar_softc *rdp);
76 static int ata_raid_lsiv2_read_meta(device_t dev, struct ar_softc **raidp);
77 static int ata_raid_lsiv3_read_meta(device_t dev, struct ar_softc **raidp);
78 static int ata_raid_nvidia_read_meta(device_t dev, struct ar_softc **raidp);
79 static int ata_raid_promise_read_meta(device_t dev, struct ar_softc **raidp, int native);
80 static int ata_raid_promise_write_meta(struct ar_softc *rdp);
81 static int ata_raid_sii_read_meta(device_t dev, struct ar_softc **raidp);
82 static int ata_raid_sis_read_meta(device_t dev, struct ar_softc **raidp);
83 static int ata_raid_sis_write_meta(struct ar_softc *rdp);
84 static int ata_raid_via_read_meta(device_t dev, struct ar_softc **raidp);
85 static int ata_raid_via_write_meta(struct ar_softc *rdp);
86 static struct ata_request *ata_raid_init_request(struct ar_softc *rdp, struct bio *bio);
87 static int ata_raid_send_request(struct ata_request *request);
88 static int ata_raid_rw(device_t dev, u_int64_t lba, void *data, u_int bcount, int flags);
89 static char * ata_raid_format(struct ar_softc *rdp);
90 static char * ata_raid_type(struct ar_softc *rdp);
91 static char * ata_raid_flags(struct ar_softc *rdp);
94 static void ata_raid_print_meta(struct ar_softc *meta);
95 static void ata_raid_adaptec_print_meta(struct adaptec_raid_conf *meta);
96 static void ata_raid_hptv2_print_meta(struct hptv2_raid_conf *meta);
97 static void ata_raid_hptv3_print_meta(struct hptv3_raid_conf *meta);
98 static void ata_raid_intel_print_meta(struct intel_raid_conf *meta);
99 static void ata_raid_ite_print_meta(struct ite_raid_conf *meta);
100 static void ata_raid_jmicron_print_meta(struct jmicron_raid_conf *meta);
101 static void ata_raid_lsiv2_print_meta(struct lsiv2_raid_conf *meta);
102 static void ata_raid_lsiv3_print_meta(struct lsiv3_raid_conf *meta);
103 static void ata_raid_nvidia_print_meta(struct nvidia_raid_conf *meta);
104 static void ata_raid_promise_print_meta(struct promise_raid_conf *meta);
105 static void ata_raid_sii_print_meta(struct sii_raid_conf *meta);
106 static void ata_raid_sis_print_meta(struct sis_raid_conf *meta);
107 static void ata_raid_via_print_meta(struct via_raid_conf *meta);
110 static struct ar_softc *ata_raid_arrays[MAX_ARRAYS];
111 static MALLOC_DEFINE(M_AR, "ar_driver", "ATA PseudoRAID driver");
112 static devclass_t ata_raid_sub_devclass;
113 static int testing = 0;
115 /* device structures */
116 static disk_strategy_t ata_raid_strategy;
117 static dumper_t ata_raid_dump;
120 ata_raid_attach(struct ar_softc *rdp, int writeback)
125 mtx_init(&rdp->lock, "ATA PseudoRAID metadata lock", NULL, MTX_DEF);
126 ata_raid_config_changed(rdp, writeback);
128 /* sanitize arrays total_size % (width * interleave) == 0 */
129 if (rdp->type == AR_T_RAID0 || rdp->type == AR_T_RAID01 ||
130 rdp->type == AR_T_RAID5) {
131 rdp->total_sectors = (rdp->total_sectors/(rdp->interleave*rdp->width))*
132 (rdp->interleave * rdp->width);
133 sprintf(buffer, " (stripe %d KB)",
134 (rdp->interleave * DEV_BSIZE) / 1024);
138 rdp->disk = disk_alloc();
139 rdp->disk->d_strategy = ata_raid_strategy;
140 rdp->disk->d_dump = ata_raid_dump;
141 rdp->disk->d_name = "ar";
142 rdp->disk->d_sectorsize = DEV_BSIZE;
143 rdp->disk->d_mediasize = (off_t)rdp->total_sectors * DEV_BSIZE;
144 rdp->disk->d_fwsectors = rdp->sectors;
145 rdp->disk->d_fwheads = rdp->heads;
146 rdp->disk->d_maxsize = 128 * DEV_BSIZE;
147 rdp->disk->d_drv1 = rdp;
148 rdp->disk->d_unit = rdp->lun;
149 disk_create(rdp->disk, DISK_VERSION);
151 printf("ar%d: %lluMB <%s %s%s> status: %s\n", rdp->lun,
152 (unsigned long long)(rdp->total_sectors / ((1024L*1024L)/DEV_BSIZE)),
153 ata_raid_format(rdp), ata_raid_type(rdp),
154 buffer, ata_raid_flags(rdp));
156 if (testing || bootverbose)
157 printf("ar%d: %llu sectors [%dC/%dH/%dS] <%s> subdisks defined as:\n",
158 rdp->lun, (unsigned long long)rdp->total_sectors,
159 rdp->cylinders, rdp->heads, rdp->sectors, rdp->name);
161 for (disk = 0; disk < rdp->total_disks; disk++) {
162 printf("ar%d: disk%d ", rdp->lun, disk);
163 if (rdp->disks[disk].dev) {
164 if (rdp->disks[disk].flags & AR_DF_PRESENT) {
165 /* status of this disk in the array */
166 if (rdp->disks[disk].flags & AR_DF_ONLINE)
168 else if (rdp->disks[disk].flags & AR_DF_SPARE)
173 /* what type of disk is this in the array */
177 if (disk < rdp->width)
183 /* which physical disk is used */
184 printf("using %s at ata%d-%s\n",
185 device_get_nameunit(rdp->disks[disk].dev),
186 device_get_unit(device_get_parent(rdp->disks[disk].dev)),
187 (((struct ata_device *)
188 device_get_softc(rdp->disks[disk].dev))->unit ==
189 ATA_MASTER) ? "master" : "slave");
191 else if (rdp->disks[disk].flags & AR_DF_ASSIGNED)
194 printf("INVALID no RAID config on this subdisk\n");
197 printf("DOWN no device found for this subdisk\n");
202 ata_raid_ioctl(u_long cmd, caddr_t data)
204 struct ata_ioc_raid_config *config = (struct ata_ioc_raid_config *)data;
205 int *lun = (int *)data;
206 int error = EOPNOTSUPP;
209 case IOCATARAIDSTATUS:
210 error = ata_raid_status(config);
213 case IOCATARAIDCREATE:
214 error = ata_raid_create(config);
217 case IOCATARAIDDELETE:
218 error = ata_raid_delete(*lun);
221 case IOCATARAIDADDSPARE:
222 error = ata_raid_addspare(config);
225 case IOCATARAIDREBUILD:
226 error = ata_raid_rebuild(*lun);
233 ata_raid_strategy(struct bio *bp)
235 struct ar_softc *rdp = bp->bio_disk->d_drv1;
236 struct ata_request *request;
238 u_int64_t blkno, lba, blk = 0;
239 int count, chunk, drv, par = 0, change = 0;
241 if (!(rdp->status & AR_S_READY) ||
242 (bp->bio_cmd != BIO_READ && bp->bio_cmd != BIO_WRITE)) {
243 biofinish(bp, NULL, EIO);
247 bp->bio_resid = bp->bio_bcount;
248 for (count = howmany(bp->bio_bcount, DEV_BSIZE),
249 blkno = bp->bio_pblkno, data = bp->bio_data;
251 count -= chunk, blkno += chunk, data += (chunk * DEV_BSIZE)) {
264 while (lba >= rdp->disks[drv].sectors)
265 lba -= rdp->disks[drv++].sectors;
266 chunk = min(rdp->disks[drv].sectors - lba, count);
271 chunk = blkno % rdp->interleave;
272 drv = (blkno / rdp->interleave) % rdp->width;
273 lba = (((blkno/rdp->interleave)/rdp->width)*rdp->interleave)+chunk;
274 chunk = min(count, rdp->interleave - chunk);
278 drv = (blkno / rdp->interleave) % (rdp->width - 1);
279 par = rdp->width - 1 -
280 (blkno / (rdp->interleave * (rdp->width - 1))) % rdp->width;
283 lba = ((blkno/rdp->interleave)/(rdp->width-1))*(rdp->interleave) +
284 ((blkno%(rdp->interleave*(rdp->width-1)))%rdp->interleave);
285 chunk = min(count, rdp->interleave - (lba % rdp->interleave));
289 printf("ar%d: unknown array type in ata_raid_strategy\n", rdp->lun);
290 biofinish(bp, NULL, EIO);
294 /* offset on all but "first on HPTv2" */
295 if (!(drv == 0 && rdp->format == AR_F_HPTV2_RAID))
296 lba += rdp->offset_sectors;
298 if (!(request = ata_raid_init_request(rdp, bp))) {
299 biofinish(bp, NULL, EIO);
302 request->data = data;
303 request->bytecount = chunk * DEV_BSIZE;
304 request->u.ata.lba = lba;
305 request->u.ata.count = request->bytecount / DEV_BSIZE;
311 if (((rdp->disks[drv].flags & (AR_DF_PRESENT|AR_DF_ONLINE)) ==
312 (AR_DF_PRESENT|AR_DF_ONLINE) && !rdp->disks[drv].dev)) {
313 rdp->disks[drv].flags &= ~AR_DF_ONLINE;
314 ata_raid_config_changed(rdp, 1);
315 ata_free_request(request);
316 biofinish(bp, NULL, EIO);
320 request->dev = rdp->disks[request->this].dev;
321 ata_raid_send_request(request);
326 if ((rdp->disks[drv].flags &
327 (AR_DF_PRESENT|AR_DF_ONLINE))==(AR_DF_PRESENT|AR_DF_ONLINE) &&
328 !rdp->disks[drv].dev) {
329 rdp->disks[drv].flags &= ~AR_DF_ONLINE;
332 if ((rdp->disks[drv + rdp->width].flags &
333 (AR_DF_PRESENT|AR_DF_ONLINE))==(AR_DF_PRESENT|AR_DF_ONLINE) &&
334 !rdp->disks[drv + rdp->width].dev) {
335 rdp->disks[drv + rdp->width].flags &= ~AR_DF_ONLINE;
339 ata_raid_config_changed(rdp, 1);
340 if (!(rdp->status & AR_S_READY)) {
341 ata_free_request(request);
342 biofinish(bp, NULL, EIO);
346 if (rdp->status & AR_S_REBUILDING)
347 blk = ((lba / rdp->interleave) * rdp->width) * rdp->interleave +
348 (rdp->interleave * (drv % rdp->width)) +
349 lba % rdp->interleave;;
351 if (bp->bio_cmd == BIO_READ) {
353 (rdp->disks[drv].flags & AR_DF_ONLINE);
355 (rdp->disks[drv+rdp->width].flags & AR_DF_ONLINE);
357 /* if mirror gone or close to last access on source */
361 (rdp->disks[drv].last_lba - AR_PROXIMITY) &&
363 (rdp->disks[drv].last_lba + AR_PROXIMITY))) {
366 /* if source gone or close to last access on mirror */
367 else if (!src_online ||
370 (rdp->disks[drv+rdp->width].last_lba-AR_PROXIMITY) &&
372 (rdp->disks[drv+rdp->width].last_lba+AR_PROXIMITY))) {
376 /* not close to any previous access, toggle */
386 if ((rdp->status & AR_S_REBUILDING) &&
387 (blk <= rdp->rebuild_lba) &&
388 ((blk + chunk) > rdp->rebuild_lba)) {
389 struct ata_composite *composite;
390 struct ata_request *rebuild;
393 /* figure out what part to rebuild */
394 if (drv < rdp->width)
395 this = drv + rdp->width;
397 this = drv - rdp->width;
399 /* do we have a spare to rebuild on ? */
400 if (rdp->disks[this].flags & AR_DF_SPARE) {
401 if ((composite = ata_alloc_composite())) {
402 if ((rebuild = ata_alloc_request())) {
403 rdp->rebuild_lba = blk + chunk;
404 bcopy(request, rebuild,
405 sizeof(struct ata_request));
406 rebuild->this = this;
407 rebuild->dev = rdp->disks[this].dev;
408 rebuild->flags &= ~ATA_R_READ;
409 rebuild->flags |= ATA_R_WRITE;
410 mtx_init(&composite->lock,
411 "ATA PseudoRAID rebuild lock",
413 composite->residual = request->bytecount;
414 composite->rd_needed |= (1 << drv);
415 composite->wr_depend |= (1 << drv);
416 composite->wr_needed |= (1 << this);
417 composite->request[drv] = request;
418 composite->request[this] = rebuild;
419 request->composite = composite;
420 rebuild->composite = composite;
421 ata_raid_send_request(rebuild);
424 ata_free_composite(composite);
425 printf("DOH! ata_alloc_request failed!\n");
429 printf("DOH! ata_alloc_composite failed!\n");
432 else if (rdp->disks[this].flags & AR_DF_ONLINE) {
434 * if we got here we are a chunk of a RAID01 that
435 * does not need a rebuild, but we need to increment
436 * the rebuild_lba address to get the rebuild to
437 * move to the next chunk correctly
439 rdp->rebuild_lba = blk + chunk;
442 printf("DOH! we didn't find the rebuild part\n");
445 if (bp->bio_cmd == BIO_WRITE) {
446 if ((rdp->disks[drv+rdp->width].flags & AR_DF_ONLINE) ||
447 ((rdp->status & AR_S_REBUILDING) &&
448 (rdp->disks[drv+rdp->width].flags & AR_DF_SPARE) &&
449 ((blk < rdp->rebuild_lba) ||
450 ((blk <= rdp->rebuild_lba) &&
451 ((blk + chunk) > rdp->rebuild_lba))))) {
452 if ((rdp->disks[drv].flags & AR_DF_ONLINE) ||
453 ((rdp->status & AR_S_REBUILDING) &&
454 (rdp->disks[drv].flags & AR_DF_SPARE) &&
455 ((blk < rdp->rebuild_lba) ||
456 ((blk <= rdp->rebuild_lba) &&
457 ((blk + chunk) > rdp->rebuild_lba))))) {
458 struct ata_request *mirror;
459 struct ata_composite *composite;
460 int this = drv + rdp->width;
462 if ((composite = ata_alloc_composite())) {
463 if ((mirror = ata_alloc_request())) {
464 if ((blk <= rdp->rebuild_lba) &&
465 ((blk + chunk) > rdp->rebuild_lba))
466 rdp->rebuild_lba = blk + chunk;
467 bcopy(request, mirror,
468 sizeof(struct ata_request));
470 mirror->dev = rdp->disks[this].dev;
471 mtx_init(&composite->lock,
472 "ATA PseudoRAID mirror lock",
474 composite->residual = request->bytecount;
475 composite->wr_needed |= (1 << drv);
476 composite->wr_needed |= (1 << this);
477 composite->request[drv] = request;
478 composite->request[this] = mirror;
479 request->composite = composite;
480 mirror->composite = composite;
481 ata_raid_send_request(mirror);
482 rdp->disks[this].last_lba =
483 bp->bio_pblkno + chunk;
486 ata_free_composite(composite);
487 printf("DOH! ata_alloc_request failed!\n");
491 printf("DOH! ata_alloc_composite failed!\n");
499 request->dev = rdp->disks[request->this].dev;
500 ata_raid_send_request(request);
501 rdp->disks[request->this].last_lba = bp->bio_pblkno + chunk;
505 if (((rdp->disks[drv].flags & (AR_DF_PRESENT|AR_DF_ONLINE)) ==
506 (AR_DF_PRESENT|AR_DF_ONLINE) && !rdp->disks[drv].dev)) {
507 rdp->disks[drv].flags &= ~AR_DF_ONLINE;
510 if (((rdp->disks[par].flags & (AR_DF_PRESENT|AR_DF_ONLINE)) ==
511 (AR_DF_PRESENT|AR_DF_ONLINE) && !rdp->disks[par].dev)) {
512 rdp->disks[par].flags &= ~AR_DF_ONLINE;
516 ata_raid_config_changed(rdp, 1);
517 if (!(rdp->status & AR_S_READY)) {
518 ata_free_request(request);
519 biofinish(bp, NULL, EIO);
522 if (rdp->status & AR_S_DEGRADED) {
523 /* do the XOR game if possible */
527 request->dev = rdp->disks[request->this].dev;
528 if (bp->bio_cmd == BIO_READ) {
529 ata_raid_send_request(request);
531 if (bp->bio_cmd == BIO_WRITE) {
532 ata_raid_send_request(request);
533 // sikre at læs-modify-skriv til hver disk er atomarisk.
534 // par kopi af request
535 // læse orgdata fra drv
536 // skriv nydata til drv
537 // læse parorgdata fra par
538 // skriv orgdata xor parorgdata xor nydata til par
544 printf("ar%d: unknown array type in ata_raid_strategy\n", rdp->lun);
550 ata_raid_done(struct ata_request *request)
552 struct ar_softc *rdp = request->driver;
553 struct ata_composite *composite = NULL;
554 struct bio *bp = request->bio;
555 int i, mirror, finished = 0;
561 if (request->result) {
562 rdp->disks[request->this].flags &= ~AR_DF_ONLINE;
563 ata_raid_config_changed(rdp, 1);
564 bp->bio_error = request->result;
568 bp->bio_resid -= request->donecount;
576 if (request->this < rdp->width)
577 mirror = request->this + rdp->width;
579 mirror = request->this - rdp->width;
580 if (request->result) {
581 rdp->disks[request->this].flags &= ~AR_DF_ONLINE;
582 ata_raid_config_changed(rdp, 1);
584 if (rdp->status & AR_S_READY) {
587 if (rdp->status & AR_S_REBUILDING)
588 blk = ((request->u.ata.lba / rdp->interleave) * rdp->width) *
589 rdp->interleave + (rdp->interleave *
590 (request->this % rdp->width)) +
591 request->u.ata.lba % rdp->interleave;
593 if (bp->bio_cmd == BIO_READ) {
595 /* is this a rebuild composite */
596 if ((composite = request->composite)) {
597 mtx_lock(&composite->lock);
599 /* handle the read part of a rebuild composite */
600 if (request->flags & ATA_R_READ) {
602 /* if read failed array is now broken */
603 if (request->result) {
604 rdp->disks[request->this].flags &= ~AR_DF_ONLINE;
605 ata_raid_config_changed(rdp, 1);
606 bp->bio_error = request->result;
607 rdp->rebuild_lba = blk;
611 /* good data, update how far we've gotten */
613 bp->bio_resid -= request->donecount;
614 composite->residual -= request->donecount;
615 if (!composite->residual) {
616 if (composite->wr_done & (1 << mirror))
622 /* handle the write part of a rebuild composite */
623 else if (request->flags & ATA_R_WRITE) {
624 if (composite->rd_done & (1 << mirror)) {
625 if (request->result) {
626 printf("DOH! rebuild failed\n"); /* XXX SOS */
627 rdp->rebuild_lba = blk;
629 if (!composite->residual)
633 mtx_unlock(&composite->lock);
636 /* if read failed retry on the mirror */
637 else if (request->result) {
638 request->dev = rdp->disks[mirror].dev;
639 request->flags &= ~ATA_R_TIMEOUT;
640 ata_raid_send_request(request);
644 /* we have good data */
646 bp->bio_resid -= request->donecount;
651 else if (bp->bio_cmd == BIO_WRITE) {
652 /* do we have a mirror or rebuild to deal with ? */
653 if ((composite = request->composite)) {
654 mtx_lock(&composite->lock);
655 if (composite->wr_done & (1 << mirror)) {
656 if (request->result) {
657 if (composite->request[mirror]->result) {
658 printf("DOH! all disks failed and got here\n");
661 if (rdp->status & AR_S_REBUILDING) {
662 rdp->rebuild_lba = blk;
663 printf("DOH! rebuild failed\n"); /* XXX SOS */
666 composite->request[mirror]->donecount;
667 composite->residual -=
668 composite->request[mirror]->donecount;
671 bp->bio_resid -= request->donecount;
672 composite->residual -= request->donecount;
674 if (!composite->residual)
677 mtx_unlock(&composite->lock);
679 /* no mirror we are done */
681 bp->bio_resid -= request->donecount;
688 biofinish(bp, NULL, request->result);
692 if (request->result) {
693 rdp->disks[request->this].flags &= ~AR_DF_ONLINE;
694 ata_raid_config_changed(rdp, 1);
695 if (rdp->status & AR_S_READY) {
696 if (bp->bio_cmd == BIO_READ) {
697 /* do the XOR game to recover data */
699 if (bp->bio_cmd == BIO_WRITE) {
700 /* if the parity failed we're OK sortof */
701 /* otherwise wee need to do the XOR long dance */
706 biofinish(bp, NULL, request->result);
709 // did we have an XOR game going ??
710 bp->bio_resid -= request->donecount;
717 printf("ar%d: unknown array type in ata_raid_done\n", rdp->lun);
721 if ((rdp->status & AR_S_REBUILDING) &&
722 rdp->rebuild_lba >= rdp->total_sectors) {
725 for (disk = 0; disk < rdp->total_disks; disk++) {
726 if ((rdp->disks[disk].flags &
727 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_SPARE)) ==
728 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_SPARE)) {
729 rdp->disks[disk].flags &= ~AR_DF_SPARE;
730 rdp->disks[disk].flags |= AR_DF_ONLINE;
733 rdp->status &= ~AR_S_REBUILDING;
734 ata_raid_config_changed(rdp, 1);
742 /* we are done with this composite, free all resources */
743 for (i = 0; i < 32; i++) {
744 if (composite->rd_needed & (1 << i) ||
745 composite->wr_needed & (1 << i)) {
746 ata_free_request(composite->request[i]);
749 mtx_destroy(&composite->lock);
750 ata_free_composite(composite);
754 ata_free_request(request);
758 ata_raid_dump(void *arg, void *virtual, vm_offset_t physical,
759 off_t offset, size_t length)
761 struct disk *dp = arg;
762 struct ar_softc *rdp = dp->d_drv1;
765 /* length zero is special and really means flush buffers to media */
769 for (disk = 0, error = 0; disk < rdp->total_disks; disk++)
770 if (rdp->disks[disk].dev)
771 error |= ata_controlcmd(rdp->disks[disk].dev,
772 ATA_FLUSHCACHE, 0, 0, 0);
773 return (error ? EIO : 0);
776 bzero(&bp, sizeof(struct bio));
778 bp.bio_pblkno = offset / DEV_BSIZE;
779 bp.bio_bcount = length;
780 bp.bio_data = virtual;
781 bp.bio_cmd = BIO_WRITE;
782 ata_raid_strategy(&bp);
787 ata_raid_config_changed(struct ar_softc *rdp, int writeback)
789 int disk, count, status;
791 mtx_lock(&rdp->lock);
792 /* set default all working mode */
793 status = rdp->status;
794 rdp->status &= ~AR_S_DEGRADED;
795 rdp->status |= AR_S_READY;
797 /* make sure all lost drives are accounted for */
798 for (disk = 0; disk < rdp->total_disks; disk++) {
799 if (!(rdp->disks[disk].flags & AR_DF_PRESENT))
800 rdp->disks[disk].flags &= ~AR_DF_ONLINE;
803 /* depending on RAID type figure out our health status */
808 for (disk = 0; disk < rdp->total_disks; disk++)
809 if (!(rdp->disks[disk].flags & AR_DF_ONLINE))
810 rdp->status &= ~AR_S_READY;
815 for (disk = 0; disk < rdp->width; disk++) {
816 if (!(rdp->disks[disk].flags & AR_DF_ONLINE) &&
817 !(rdp->disks[disk + rdp->width].flags & AR_DF_ONLINE)) {
818 rdp->status &= ~AR_S_READY;
820 else if (((rdp->disks[disk].flags & AR_DF_ONLINE) &&
821 !(rdp->disks[disk + rdp->width].flags & AR_DF_ONLINE)) ||
822 (!(rdp->disks[disk].flags & AR_DF_ONLINE) &&
823 (rdp->disks [disk + rdp->width].flags & AR_DF_ONLINE))) {
824 rdp->status |= AR_S_DEGRADED;
830 for (count = 0, disk = 0; disk < rdp->total_disks; disk++) {
831 if (!(rdp->disks[disk].flags & AR_DF_ONLINE))
836 rdp->status &= ~AR_S_READY;
838 rdp->status |= AR_S_DEGRADED;
842 rdp->status &= ~AR_S_READY;
845 if (rdp->status != status) {
846 if (!(rdp->status & AR_S_READY)) {
847 printf("ar%d: FAILURE - %s array broken\n",
848 rdp->lun, ata_raid_type(rdp));
850 else if (rdp->status & AR_S_DEGRADED) {
851 if (rdp->type & (AR_T_RAID1 | AR_T_RAID01))
852 printf("ar%d: WARNING - mirror", rdp->lun);
854 printf("ar%d: WARNING - parity", rdp->lun);
855 printf(" protection lost. %s array in DEGRADED mode\n",
859 mtx_unlock(&rdp->lock);
861 ata_raid_write_metadata(rdp);
866 ata_raid_status(struct ata_ioc_raid_config *config)
868 struct ar_softc *rdp;
871 if (!(rdp = ata_raid_arrays[config->lun]))
874 config->type = rdp->type;
875 config->total_disks = rdp->total_disks;
876 for (i = 0; i < rdp->total_disks; i++ ) {
877 if ((rdp->disks[i].flags & AR_DF_PRESENT) && rdp->disks[i].dev)
878 config->disks[i] = device_get_unit(rdp->disks[i].dev);
880 config->disks[i] = -1;
882 config->interleave = rdp->interleave;
883 config->status = rdp->status;
884 config->progress = 100 * rdp->rebuild_lba / rdp->total_sectors;
889 ata_raid_create(struct ata_ioc_raid_config *config)
891 struct ar_softc *rdp;
894 int ctlr = 0, disk_size = 0, total_disks = 0;
896 for (array = 0; array < MAX_ARRAYS; array++) {
897 if (!ata_raid_arrays[array])
900 if (array >= MAX_ARRAYS)
903 if (!(rdp = (struct ar_softc*)malloc(sizeof(struct ar_softc), M_AR,
904 M_NOWAIT | M_ZERO))) {
905 printf("ar%d: no memory for metadata storage\n", array);
909 for (disk = 0; disk < config->total_disks; disk++) {
910 if ((subdisk = devclass_get_device(ata_raid_sub_devclass,
911 config->disks[disk]))) {
912 struct ata_raid_subdisk *ars = device_get_softc(subdisk);
914 /* is device already assigned to another array ? */
915 if (ars->raid[rdp->volume]) {
916 config->disks[disk] = -1;
920 rdp->disks[disk].dev = device_get_parent(subdisk);
922 switch (pci_get_vendor(GRANDPARENT(rdp->disks[disk].dev))) {
923 case ATA_HIGHPOINT_ID:
925 * we need some way to decide if it should be v2 or v3
926 * for now just use v2 since the v3 BIOS knows how to
927 * handle that as well.
929 ctlr = AR_F_HPTV2_RAID;
930 rdp->disks[disk].sectors = HPTV3_LBA(rdp->disks[disk].dev);
934 ctlr = AR_F_INTEL_RAID;
935 rdp->disks[disk].sectors = INTEL_LBA(rdp->disks[disk].dev);
939 ctlr = AR_F_ITE_RAID;
940 rdp->disks[disk].sectors = ITE_LBA(rdp->disks[disk].dev);
944 ctlr = AR_F_JMICRON_RAID;
945 rdp->disks[disk].sectors = JMICRON_LBA(rdp->disks[disk].dev);
948 case 0: /* XXX SOS cover up for bug in our PCI code */
950 ctlr = AR_F_PROMISE_RAID;
951 rdp->disks[disk].sectors = PROMISE_LBA(rdp->disks[disk].dev);
955 ctlr = AR_F_SIS_RAID;
956 rdp->disks[disk].sectors = SIS_LBA(rdp->disks[disk].dev);
961 ctlr = AR_F_VIA_RAID;
962 rdp->disks[disk].sectors = VIA_LBA(rdp->disks[disk].dev);
967 * right, so here we are, we have an ATA chip and we want
968 * to create a RAID and store the metadata.
969 * we need to find a way to tell what kind of metadata this
970 * hardware's BIOS might be using (good ideas are welcomed)
971 * for now we just use our own native FreeBSD format.
972 * the only way to get support for the BIOS format is to
973 * setup the RAID from there, in that case we pickup the
974 * metadata format from the disks (if we support it).
976 printf("WARNING!! - not able to determine metadata format\n"
977 "WARNING!! - Using FreeBSD PsuedoRAID metadata\n"
978 "If that is not what you want, use the BIOS to "
979 "create the array\n");
980 ctlr = AR_F_FREEBSD_RAID;
981 rdp->disks[disk].sectors = PROMISE_LBA(rdp->disks[disk].dev);
985 /* we need all disks to be of the same format */
986 if ((rdp->format & AR_F_FORMAT_MASK) &&
987 (rdp->format & AR_F_FORMAT_MASK) != (ctlr & AR_F_FORMAT_MASK)) {
994 /* use the smallest disk of the lots size */
995 /* gigabyte boundry ??? XXX SOS */
997 disk_size = min(rdp->disks[disk].sectors, disk_size);
999 disk_size = rdp->disks[disk].sectors;
1000 rdp->disks[disk].flags =
1001 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_ONLINE);
1006 config->disks[disk] = -1;
1012 if (total_disks != config->total_disks) {
1017 switch (config->type) {
1024 if (total_disks != 2) {
1031 if (total_disks % 2 != 0) {
1038 if (total_disks < 3) {
1048 rdp->type = config->type;
1050 if (rdp->type == AR_T_RAID0 || rdp->type == AR_T_RAID01 ||
1051 rdp->type == AR_T_RAID5) {
1054 while (config->interleave >>= 1)
1056 rdp->interleave = 1 << bit;
1058 rdp->offset_sectors = 0;
1060 /* values that depend on metadata format */
1061 switch (rdp->format) {
1062 case AR_F_ADAPTEC_RAID:
1063 rdp->interleave = min(max(32, rdp->interleave), 128); /*+*/
1066 case AR_F_HPTV2_RAID:
1067 rdp->interleave = min(max(8, rdp->interleave), 128); /*+*/
1068 rdp->offset_sectors = HPTV2_LBA(x) + 1;
1071 case AR_F_HPTV3_RAID:
1072 rdp->interleave = min(max(32, rdp->interleave), 4096); /*+*/
1075 case AR_F_INTEL_RAID:
1076 rdp->interleave = min(max(8, rdp->interleave), 256); /*+*/
1080 rdp->interleave = min(max(2, rdp->interleave), 128); /*+*/
1083 case AR_F_JMICRON_RAID:
1084 rdp->interleave = min(max(8, rdp->interleave), 256); /*+*/
1087 case AR_F_LSIV2_RAID:
1088 rdp->interleave = min(max(2, rdp->interleave), 4096);
1091 case AR_F_LSIV3_RAID:
1092 rdp->interleave = min(max(2, rdp->interleave), 256);
1095 case AR_F_PROMISE_RAID:
1096 rdp->interleave = min(max(2, rdp->interleave), 2048); /*+*/
1100 rdp->interleave = min(max(8, rdp->interleave), 256); /*+*/
1104 rdp->interleave = min(max(32, rdp->interleave), 512); /*+*/
1108 rdp->interleave = min(max(8, rdp->interleave), 128); /*+*/
1112 rdp->total_disks = total_disks;
1113 rdp->width = total_disks / (rdp->type & (AR_RAID1 | AR_T_RAID01) ? 2 : 1);
1114 rdp->total_sectors = disk_size * (rdp->width - (rdp->type == AR_RAID5));
1117 rdp->cylinders = rdp->total_sectors / (255 * 63);
1118 rdp->rebuild_lba = 0;
1119 rdp->status |= AR_S_READY;
1121 /* we are committed to this array, grap the subdisks */
1122 for (disk = 0; disk < config->total_disks; disk++) {
1123 if ((subdisk = devclass_get_device(ata_raid_sub_devclass,
1124 config->disks[disk]))) {
1125 struct ata_raid_subdisk *ars = device_get_softc(subdisk);
1127 ars->raid[rdp->volume] = rdp;
1128 ars->disk_number[rdp->volume] = disk;
1131 ata_raid_attach(rdp, 1);
1132 ata_raid_arrays[array] = rdp;
1133 config->lun = array;
1138 ata_raid_delete(int array)
1140 struct ar_softc *rdp;
1144 if (!(rdp = ata_raid_arrays[array]))
1147 rdp->status &= ~AR_S_READY;
1149 disk_destroy(rdp->disk);
1151 for (disk = 0; disk < rdp->total_disks; disk++) {
1152 if ((rdp->disks[disk].flags & AR_DF_PRESENT) && rdp->disks[disk].dev) {
1153 if ((subdisk = devclass_get_device(ata_raid_sub_devclass,
1154 device_get_unit(rdp->disks[disk].dev)))) {
1155 struct ata_raid_subdisk *ars = device_get_softc(subdisk);
1157 if (ars->raid[rdp->volume] != rdp) /* XXX SOS */
1158 device_printf(subdisk, "DOH! this disk doesn't belong\n");
1159 if (ars->disk_number[rdp->volume] != disk) /* XXX SOS */
1160 device_printf(subdisk, "DOH! this disk number is wrong\n");
1161 ars->raid[rdp->volume] = NULL;
1162 ars->disk_number[rdp->volume] = -1;
1164 rdp->disks[disk].flags = 0;
1167 ata_raid_wipe_metadata(rdp);
1168 ata_raid_arrays[array] = NULL;
1174 ata_raid_addspare(struct ata_ioc_raid_config *config)
1176 struct ar_softc *rdp;
1180 if (!(rdp = ata_raid_arrays[config->lun]))
1182 if (!(rdp->status & AR_S_DEGRADED) || !(rdp->status & AR_S_READY))
1184 if (rdp->status & AR_S_REBUILDING)
1186 switch (rdp->type) {
1190 for (disk = 0; disk < rdp->total_disks; disk++ ) {
1192 if (((rdp->disks[disk].flags & (AR_DF_PRESENT | AR_DF_ONLINE)) ==
1193 (AR_DF_PRESENT | AR_DF_ONLINE)) && rdp->disks[disk].dev)
1196 if ((subdisk = devclass_get_device(ata_raid_sub_devclass,
1197 config->disks[0] ))) {
1198 struct ata_raid_subdisk *ars = device_get_softc(subdisk);
1200 if (ars->raid[rdp->volume])
1203 /* XXX SOS validate size etc etc */
1204 ars->raid[rdp->volume] = rdp;
1205 ars->disk_number[rdp->volume] = disk;
1206 rdp->disks[disk].dev = device_get_parent(subdisk);
1207 rdp->disks[disk].flags =
1208 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_SPARE);
1210 device_printf(rdp->disks[disk].dev,
1211 "inserted into ar%d disk%d as spare\n",
1213 ata_raid_config_changed(rdp, 1);
1225 ata_raid_rebuild(int array)
1227 struct ar_softc *rdp;
1230 if (!(rdp = ata_raid_arrays[array]))
1232 /* XXX SOS we should lock the rdp softc here */
1233 if (!(rdp->status & AR_S_DEGRADED) || !(rdp->status & AR_S_READY))
1235 if (rdp->status & AR_S_REBUILDING)
1238 switch (rdp->type) {
1242 for (count = 0, disk = 0; disk < rdp->total_disks; disk++ ) {
1243 if (((rdp->disks[disk].flags &
1244 (AR_DF_PRESENT|AR_DF_ASSIGNED|AR_DF_ONLINE|AR_DF_SPARE)) ==
1245 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_SPARE)) &&
1246 rdp->disks[disk].dev) {
1252 rdp->rebuild_lba = 0;
1253 rdp->status |= AR_S_REBUILDING;
1264 ata_raid_read_metadata(device_t subdisk)
1266 devclass_t pci_devclass = devclass_find("pci");
1267 devclass_t devclass=device_get_devclass(GRANDPARENT(GRANDPARENT(subdisk)));
1269 /* prioritize vendor native metadata layout if possible */
1270 if (devclass == pci_devclass) {
1271 switch (pci_get_vendor(GRANDPARENT(device_get_parent(subdisk)))) {
1272 case ATA_HIGHPOINT_ID:
1273 if (ata_raid_hptv3_read_meta(subdisk, ata_raid_arrays))
1275 if (ata_raid_hptv2_read_meta(subdisk, ata_raid_arrays))
1280 if (ata_raid_intel_read_meta(subdisk, ata_raid_arrays))
1285 if (ata_raid_ite_read_meta(subdisk, ata_raid_arrays))
1289 case ATA_JMICRON_ID:
1290 if (ata_raid_jmicron_read_meta(subdisk, ata_raid_arrays))
1295 if (ata_raid_nvidia_read_meta(subdisk, ata_raid_arrays))
1299 case 0: /* XXX SOS cover up for bug in our PCI code */
1300 case ATA_PROMISE_ID:
1301 if (ata_raid_promise_read_meta(subdisk, ata_raid_arrays, 0))
1306 case ATA_SILICON_IMAGE_ID:
1307 if (ata_raid_sii_read_meta(subdisk, ata_raid_arrays))
1312 if (ata_raid_sis_read_meta(subdisk, ata_raid_arrays))
1317 if (ata_raid_via_read_meta(subdisk, ata_raid_arrays))
1323 /* handle controllers that have multiple layout possibilities */
1324 /* NOTE: the order of these are not insignificant */
1326 /* Adaptec HostRAID */
1327 if (ata_raid_adaptec_read_meta(subdisk, ata_raid_arrays))
1330 /* LSILogic v3 and v2 */
1331 if (ata_raid_lsiv3_read_meta(subdisk, ata_raid_arrays))
1333 if (ata_raid_lsiv2_read_meta(subdisk, ata_raid_arrays))
1336 /* if none of the above matched, try FreeBSD native format */
1337 return ata_raid_promise_read_meta(subdisk, ata_raid_arrays, 1);
1341 ata_raid_write_metadata(struct ar_softc *rdp)
1343 switch (rdp->format) {
1344 case AR_F_FREEBSD_RAID:
1345 case AR_F_PROMISE_RAID:
1346 return ata_raid_promise_write_meta(rdp);
1348 case AR_F_HPTV3_RAID:
1349 case AR_F_HPTV2_RAID:
1351 * always write HPT v2 metadata, the v3 BIOS knows it as well.
1352 * this is handy since we cannot know what version BIOS is on there
1354 return ata_raid_hptv2_write_meta(rdp);
1356 case AR_F_INTEL_RAID:
1357 return ata_raid_intel_write_meta(rdp);
1359 case AR_F_JMICRON_RAID:
1360 return ata_raid_jmicron_write_meta(rdp);
1363 return ata_raid_sis_write_meta(rdp);
1366 return ata_raid_via_write_meta(rdp);
1368 case AR_F_HPTV3_RAID:
1369 return ata_raid_hptv3_write_meta(rdp);
1371 case AR_F_ADAPTEC_RAID:
1372 return ata_raid_adaptec_write_meta(rdp);
1375 return ata_raid_ite_write_meta(rdp);
1377 case AR_F_LSIV2_RAID:
1378 return ata_raid_lsiv2_write_meta(rdp);
1380 case AR_F_LSIV3_RAID:
1381 return ata_raid_lsiv3_write_meta(rdp);
1383 case AR_F_NVIDIA_RAID:
1384 return ata_raid_nvidia_write_meta(rdp);
1387 return ata_raid_sii_write_meta(rdp);
1391 printf("ar%d: writing of %s metadata is NOT supported yet\n",
1392 rdp->lun, ata_raid_format(rdp));
1398 ata_raid_wipe_metadata(struct ar_softc *rdp)
1400 int disk, error = 0;
1405 for (disk = 0; disk < rdp->total_disks; disk++) {
1406 if (rdp->disks[disk].dev) {
1407 switch (rdp->format) {
1408 case AR_F_ADAPTEC_RAID:
1409 lba = ADP_LBA(rdp->disks[disk].dev);
1410 size = sizeof(struct adaptec_raid_conf);
1413 case AR_F_HPTV2_RAID:
1414 lba = HPTV2_LBA(rdp->disks[disk].dev);
1415 size = sizeof(struct hptv2_raid_conf);
1418 case AR_F_HPTV3_RAID:
1419 lba = HPTV3_LBA(rdp->disks[disk].dev);
1420 size = sizeof(struct hptv3_raid_conf);
1423 case AR_F_INTEL_RAID:
1424 lba = INTEL_LBA(rdp->disks[disk].dev);
1425 size = 3 * 512; /* XXX SOS */
1429 lba = ITE_LBA(rdp->disks[disk].dev);
1430 size = sizeof(struct ite_raid_conf);
1433 case AR_F_JMICRON_RAID:
1434 lba = JMICRON_LBA(rdp->disks[disk].dev);
1435 size = sizeof(struct jmicron_raid_conf);
1438 case AR_F_LSIV2_RAID:
1439 lba = LSIV2_LBA(rdp->disks[disk].dev);
1440 size = sizeof(struct lsiv2_raid_conf);
1443 case AR_F_LSIV3_RAID:
1444 lba = LSIV3_LBA(rdp->disks[disk].dev);
1445 size = sizeof(struct lsiv3_raid_conf);
1448 case AR_F_NVIDIA_RAID:
1449 lba = NVIDIA_LBA(rdp->disks[disk].dev);
1450 size = sizeof(struct nvidia_raid_conf);
1453 case AR_F_FREEBSD_RAID:
1454 case AR_F_PROMISE_RAID:
1455 lba = PROMISE_LBA(rdp->disks[disk].dev);
1456 size = sizeof(struct promise_raid_conf);
1460 lba = SII_LBA(rdp->disks[disk].dev);
1461 size = sizeof(struct sii_raid_conf);
1465 lba = SIS_LBA(rdp->disks[disk].dev);
1466 size = sizeof(struct sis_raid_conf);
1470 lba = VIA_LBA(rdp->disks[disk].dev);
1471 size = sizeof(struct via_raid_conf);
1475 printf("ar%d: wiping of %s metadata is NOT supported yet\n",
1476 rdp->lun, ata_raid_format(rdp));
1479 if (!(meta = malloc(size, M_AR, M_NOWAIT | M_ZERO)))
1481 if (ata_raid_rw(rdp->disks[disk].dev, lba, meta, size,
1482 ATA_R_WRITE | ATA_R_DIRECT)) {
1483 device_printf(rdp->disks[disk].dev, "wipe metadata failed\n");
1492 /* Adaptec HostRAID Metadata */
1494 ata_raid_adaptec_read_meta(device_t dev, struct ar_softc **raidp)
1496 struct ata_raid_subdisk *ars = device_get_softc(dev);
1497 device_t parent = device_get_parent(dev);
1498 struct adaptec_raid_conf *meta;
1499 struct ar_softc *raid;
1500 int array, disk, retval = 0;
1502 if (!(meta = (struct adaptec_raid_conf *)
1503 malloc(sizeof(struct adaptec_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
1506 if (ata_raid_rw(parent, ADP_LBA(parent),
1507 meta, sizeof(struct adaptec_raid_conf), ATA_R_READ)) {
1508 if (testing || bootverbose)
1509 device_printf(parent, "Adaptec read metadata failed\n");
1513 /* check if this is a Adaptec RAID struct */
1514 if (meta->magic_0 != ADP_MAGIC_0 || meta->magic_3 != ADP_MAGIC_3) {
1515 if (testing || bootverbose)
1516 device_printf(parent, "Adaptec check1 failed\n");
1520 if (testing || bootverbose)
1521 ata_raid_adaptec_print_meta(meta);
1523 /* now convert Adaptec metadata into our generic form */
1524 for (array = 0; array < MAX_ARRAYS; array++) {
1525 if (!raidp[array]) {
1527 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
1529 if (!raidp[array]) {
1530 device_printf(parent, "failed to allocate metadata storage\n");
1534 raid = raidp[array];
1535 if (raid->format && (raid->format != AR_F_ADAPTEC_RAID))
1538 if (raid->magic_0 && raid->magic_0 != meta->configs[0].magic_0)
1541 if (!meta->generation || be32toh(meta->generation) > raid->generation) {
1542 switch (meta->configs[0].type) {
1544 raid->magic_0 = meta->configs[0].magic_0;
1545 raid->type = AR_T_RAID0;
1546 raid->interleave = 1 << (meta->configs[0].stripe_shift >> 1);
1547 raid->width = be16toh(meta->configs[0].total_disks);
1551 raid->magic_0 = meta->configs[0].magic_0;
1552 raid->type = AR_T_RAID1;
1553 raid->width = be16toh(meta->configs[0].total_disks) / 2;
1557 device_printf(parent, "Adaptec unknown RAID type 0x%02x\n",
1558 meta->configs[0].type);
1559 free(raidp[array], M_AR);
1560 raidp[array] = NULL;
1564 raid->format = AR_F_ADAPTEC_RAID;
1565 raid->generation = be32toh(meta->generation);
1566 raid->total_disks = be16toh(meta->configs[0].total_disks);
1567 raid->total_sectors = be32toh(meta->configs[0].sectors);
1570 raid->cylinders = raid->total_sectors / (63 * 255);
1571 raid->offset_sectors = 0;
1572 raid->rebuild_lba = 0;
1574 strncpy(raid->name, meta->configs[0].name,
1575 min(sizeof(raid->name), sizeof(meta->configs[0].name)));
1577 /* clear out any old info */
1578 if (raid->generation) {
1579 for (disk = 0; disk < raid->total_disks; disk++) {
1580 raid->disks[disk].dev = NULL;
1581 raid->disks[disk].flags = 0;
1585 if (be32toh(meta->generation) >= raid->generation) {
1586 struct ata_device *atadev = device_get_softc(parent);
1587 struct ata_channel *ch = device_get_softc(GRANDPARENT(dev));
1588 int disk_number = (ch->unit << !(ch->flags & ATA_NO_SLAVE)) +
1589 ATA_DEV(atadev->unit);
1591 raid->disks[disk_number].dev = parent;
1592 raid->disks[disk_number].sectors =
1593 be32toh(meta->configs[disk_number + 1].sectors);
1594 raid->disks[disk_number].flags =
1595 (AR_DF_ONLINE | AR_DF_PRESENT | AR_DF_ASSIGNED);
1596 ars->raid[raid->volume] = raid;
1597 ars->disk_number[raid->volume] = disk_number;
1608 /* Highpoint V2 RocketRAID Metadata */
1610 ata_raid_hptv2_read_meta(device_t dev, struct ar_softc **raidp)
1612 struct ata_raid_subdisk *ars = device_get_softc(dev);
1613 device_t parent = device_get_parent(dev);
1614 struct hptv2_raid_conf *meta;
1615 struct ar_softc *raid = NULL;
1616 int array, disk_number = 0, retval = 0;
1618 if (!(meta = (struct hptv2_raid_conf *)
1619 malloc(sizeof(struct hptv2_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
1622 if (ata_raid_rw(parent, HPTV2_LBA(parent),
1623 meta, sizeof(struct hptv2_raid_conf), ATA_R_READ)) {
1624 if (testing || bootverbose)
1625 device_printf(parent, "HighPoint (v2) read metadata failed\n");
1629 /* check if this is a HighPoint v2 RAID struct */
1630 if (meta->magic != HPTV2_MAGIC_OK && meta->magic != HPTV2_MAGIC_BAD) {
1631 if (testing || bootverbose)
1632 device_printf(parent, "HighPoint (v2) check1 failed\n");
1636 /* is this disk defined, or an old leftover/spare ? */
1637 if (!meta->magic_0) {
1638 if (testing || bootverbose)
1639 device_printf(parent, "HighPoint (v2) check2 failed\n");
1643 if (testing || bootverbose)
1644 ata_raid_hptv2_print_meta(meta);
1646 /* now convert HighPoint (v2) metadata into our generic form */
1647 for (array = 0; array < MAX_ARRAYS; array++) {
1648 if (!raidp[array]) {
1650 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
1652 if (!raidp[array]) {
1653 device_printf(parent, "failed to allocate metadata storage\n");
1657 raid = raidp[array];
1658 if (raid->format && (raid->format != AR_F_HPTV2_RAID))
1661 switch (meta->type) {
1663 if ((meta->order & (HPTV2_O_RAID0|HPTV2_O_OK)) ==
1664 (HPTV2_O_RAID0|HPTV2_O_OK))
1665 goto highpoint_raid1;
1666 if (meta->order & (HPTV2_O_RAID0 | HPTV2_O_RAID1))
1667 goto highpoint_raid01;
1668 if (raid->magic_0 && raid->magic_0 != meta->magic_0)
1670 raid->magic_0 = meta->magic_0;
1671 raid->type = AR_T_RAID0;
1672 raid->interleave = 1 << meta->stripe_shift;
1673 disk_number = meta->disk_number;
1674 if (!(meta->order & HPTV2_O_OK))
1675 meta->magic = 0; /* mark bad */
1680 if (raid->magic_0 && raid->magic_0 != meta->magic_0)
1682 raid->magic_0 = meta->magic_0;
1683 raid->type = AR_T_RAID1;
1684 disk_number = (meta->disk_number > 0);
1687 case HPTV2_T_RAID01_RAID0:
1689 if (meta->order & HPTV2_O_RAID0) {
1690 if ((raid->magic_0 && raid->magic_0 != meta->magic_0) ||
1691 (raid->magic_1 && raid->magic_1 != meta->magic_1))
1693 raid->magic_0 = meta->magic_0;
1694 raid->magic_1 = meta->magic_1;
1695 raid->type = AR_T_RAID01;
1696 raid->interleave = 1 << meta->stripe_shift;
1697 disk_number = meta->disk_number;
1700 if (raid->magic_1 && raid->magic_1 != meta->magic_1)
1702 raid->magic_1 = meta->magic_1;
1703 raid->type = AR_T_RAID01;
1704 raid->interleave = 1 << meta->stripe_shift;
1705 disk_number = meta->disk_number + meta->array_width;
1706 if (!(meta->order & HPTV2_O_RAID1))
1707 meta->magic = 0; /* mark bad */
1712 if (raid->magic_0 && raid->magic_0 != meta->magic_0)
1714 raid->magic_0 = meta->magic_0;
1715 raid->type = AR_T_SPAN;
1716 disk_number = meta->disk_number;
1720 device_printf(parent, "Highpoint (v2) unknown RAID type 0x%02x\n",
1722 free(raidp[array], M_AR);
1723 raidp[array] = NULL;
1727 raid->format |= AR_F_HPTV2_RAID;
1728 raid->disks[disk_number].dev = parent;
1729 raid->disks[disk_number].flags = (AR_DF_PRESENT | AR_DF_ASSIGNED);
1731 strncpy(raid->name, meta->name_1,
1732 min(sizeof(raid->name), sizeof(meta->name_1)));
1733 if (meta->magic == HPTV2_MAGIC_OK) {
1734 raid->disks[disk_number].flags |= AR_DF_ONLINE;
1735 raid->width = meta->array_width;
1736 raid->total_sectors = meta->total_sectors;
1739 raid->cylinders = raid->total_sectors / (63 * 255);
1740 raid->offset_sectors = HPTV2_LBA(parent) + 1;
1741 raid->rebuild_lba = meta->rebuild_lba;
1742 raid->disks[disk_number].sectors =
1743 raid->total_sectors / raid->width;
1746 raid->disks[disk_number].flags &= ~AR_DF_ONLINE;
1748 if ((raid->type & AR_T_RAID0) && (raid->total_disks < raid->width))
1749 raid->total_disks = raid->width;
1750 if (disk_number >= raid->total_disks)
1751 raid->total_disks = disk_number + 1;
1752 ars->raid[raid->volume] = raid;
1753 ars->disk_number[raid->volume] = disk_number;
1764 ata_raid_hptv2_write_meta(struct ar_softc *rdp)
1766 struct hptv2_raid_conf *meta;
1767 struct timeval timestamp;
1768 int disk, error = 0;
1770 if (!(meta = (struct hptv2_raid_conf *)
1771 malloc(sizeof(struct hptv2_raid_conf), M_AR, M_NOWAIT | M_ZERO))) {
1772 printf("ar%d: failed to allocate metadata storage\n", rdp->lun);
1776 microtime(×tamp);
1777 rdp->magic_0 = timestamp.tv_sec + 2;
1778 rdp->magic_1 = timestamp.tv_sec;
1780 for (disk = 0; disk < rdp->total_disks; disk++) {
1781 if ((rdp->disks[disk].flags & (AR_DF_PRESENT | AR_DF_ONLINE)) ==
1782 (AR_DF_PRESENT | AR_DF_ONLINE))
1783 meta->magic = HPTV2_MAGIC_OK;
1784 if (rdp->disks[disk].flags & AR_DF_ASSIGNED) {
1785 meta->magic_0 = rdp->magic_0;
1786 if (strlen(rdp->name))
1787 strncpy(meta->name_1, rdp->name, sizeof(meta->name_1));
1789 strcpy(meta->name_1, "FreeBSD");
1791 meta->disk_number = disk;
1793 switch (rdp->type) {
1795 meta->type = HPTV2_T_RAID0;
1796 strcpy(meta->name_2, "RAID 0");
1797 if (rdp->disks[disk].flags & AR_DF_ONLINE)
1798 meta->order = HPTV2_O_OK;
1802 meta->type = HPTV2_T_RAID0;
1803 strcpy(meta->name_2, "RAID 1");
1804 meta->disk_number = (disk < rdp->width) ? disk : disk + 5;
1805 meta->order = HPTV2_O_RAID0 | HPTV2_O_OK;
1809 meta->type = HPTV2_T_RAID01_RAID0;
1810 strcpy(meta->name_2, "RAID 0+1");
1811 if (rdp->disks[disk].flags & AR_DF_ONLINE) {
1812 if (disk < rdp->width) {
1813 meta->order = (HPTV2_O_RAID0 | HPTV2_O_RAID1);
1814 meta->magic_0 = rdp->magic_0 - 1;
1817 meta->order = HPTV2_O_RAID1;
1818 meta->disk_number -= rdp->width;
1822 meta->magic_0 = rdp->magic_0 - 1;
1823 meta->magic_1 = rdp->magic_1;
1827 meta->type = HPTV2_T_SPAN;
1828 strcpy(meta->name_2, "SPAN");
1835 meta->array_width = rdp->width;
1836 meta->stripe_shift = (rdp->width > 1) ? (ffs(rdp->interleave)-1) : 0;
1837 meta->total_sectors = rdp->total_sectors;
1838 meta->rebuild_lba = rdp->rebuild_lba;
1839 if (testing || bootverbose)
1840 ata_raid_hptv2_print_meta(meta);
1841 if (rdp->disks[disk].dev) {
1842 if (ata_raid_rw(rdp->disks[disk].dev,
1843 HPTV2_LBA(rdp->disks[disk].dev), meta,
1844 sizeof(struct promise_raid_conf),
1845 ATA_R_WRITE | ATA_R_DIRECT)) {
1846 device_printf(rdp->disks[disk].dev, "write metadata failed\n");
1855 /* Highpoint V3 RocketRAID Metadata */
1857 ata_raid_hptv3_read_meta(device_t dev, struct ar_softc **raidp)
1859 struct ata_raid_subdisk *ars = device_get_softc(dev);
1860 device_t parent = device_get_parent(dev);
1861 struct hptv3_raid_conf *meta;
1862 struct ar_softc *raid = NULL;
1863 int array, disk_number, retval = 0;
1865 if (!(meta = (struct hptv3_raid_conf *)
1866 malloc(sizeof(struct hptv3_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
1869 if (ata_raid_rw(parent, HPTV3_LBA(parent),
1870 meta, sizeof(struct hptv3_raid_conf), ATA_R_READ)) {
1871 if (testing || bootverbose)
1872 device_printf(parent, "HighPoint (v3) read metadata failed\n");
1876 /* check if this is a HighPoint v3 RAID struct */
1877 if (meta->magic != HPTV3_MAGIC) {
1878 if (testing || bootverbose)
1879 device_printf(parent, "HighPoint (v3) check1 failed\n");
1883 /* check if there are any config_entries */
1884 if (meta->config_entries < 1) {
1885 if (testing || bootverbose)
1886 device_printf(parent, "HighPoint (v3) check2 failed\n");
1890 if (testing || bootverbose)
1891 ata_raid_hptv3_print_meta(meta);
1893 /* now convert HighPoint (v3) metadata into our generic form */
1894 for (array = 0; array < MAX_ARRAYS; array++) {
1895 if (!raidp[array]) {
1897 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
1899 if (!raidp[array]) {
1900 device_printf(parent, "failed to allocate metadata storage\n");
1904 raid = raidp[array];
1905 if (raid->format && (raid->format != AR_F_HPTV3_RAID))
1908 if ((raid->format & AR_F_HPTV3_RAID) && raid->magic_0 != meta->magic_0)
1911 switch (meta->configs[0].type) {
1913 raid->type = AR_T_RAID0;
1914 raid->width = meta->configs[0].total_disks;
1915 disk_number = meta->configs[0].disk_number;
1919 raid->type = AR_T_RAID1;
1920 raid->width = meta->configs[0].total_disks / 2;
1921 disk_number = meta->configs[0].disk_number;
1925 raid->type = AR_T_RAID5;
1926 raid->width = meta->configs[0].total_disks;
1927 disk_number = meta->configs[0].disk_number;
1931 raid->type = AR_T_SPAN;
1932 raid->width = meta->configs[0].total_disks;
1933 disk_number = meta->configs[0].disk_number;
1937 device_printf(parent, "Highpoint (v3) unknown RAID type 0x%02x\n",
1938 meta->configs[0].type);
1939 free(raidp[array], M_AR);
1940 raidp[array] = NULL;
1943 if (meta->config_entries == 2) {
1944 switch (meta->configs[1].type) {
1946 if (raid->type == AR_T_RAID0) {
1947 raid->type = AR_T_RAID01;
1948 disk_number = meta->configs[1].disk_number +
1949 (meta->configs[0].disk_number << 1);
1953 device_printf(parent, "Highpoint (v3) unknown level 2 0x%02x\n",
1954 meta->configs[1].type);
1955 free(raidp[array], M_AR);
1956 raidp[array] = NULL;
1961 raid->magic_0 = meta->magic_0;
1962 raid->format = AR_F_HPTV3_RAID;
1963 raid->generation = meta->timestamp;
1964 raid->interleave = 1 << meta->configs[0].stripe_shift;
1965 raid->total_disks = meta->configs[0].total_disks +
1966 meta->configs[1].total_disks;
1967 raid->total_sectors = meta->configs[0].total_sectors +
1968 ((u_int64_t)meta->configs_high[0].total_sectors << 32);
1971 raid->cylinders = raid->total_sectors / (63 * 255);
1972 raid->offset_sectors = 0;
1973 raid->rebuild_lba = meta->configs[0].rebuild_lba +
1974 ((u_int64_t)meta->configs_high[0].rebuild_lba << 32);
1976 strncpy(raid->name, meta->name,
1977 min(sizeof(raid->name), sizeof(meta->name)));
1978 raid->disks[disk_number].sectors = raid->total_sectors /
1979 (raid->type == AR_T_RAID5 ? raid->width - 1 : raid->width);
1980 raid->disks[disk_number].dev = parent;
1981 raid->disks[disk_number].flags =
1982 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_ONLINE);
1983 ars->raid[raid->volume] = raid;
1984 ars->disk_number[raid->volume] = disk_number;
1994 /* Intel MatrixRAID Metadata */
1996 ata_raid_intel_read_meta(device_t dev, struct ar_softc **raidp)
1998 struct ata_raid_subdisk *ars = device_get_softc(dev);
1999 device_t parent = device_get_parent(dev);
2000 struct intel_raid_conf *meta;
2001 struct intel_raid_mapping *map;
2002 struct ar_softc *raid = NULL;
2003 u_int32_t checksum, *ptr;
2004 int array, count, disk, volume = 1, retval = 0;
2007 if (!(meta = (struct intel_raid_conf *)
2008 malloc(1536, M_AR, M_NOWAIT | M_ZERO)))
2011 if (ata_raid_rw(parent, INTEL_LBA(parent), meta, 1024, ATA_R_READ)) {
2012 if (testing || bootverbose)
2013 device_printf(parent, "Intel read metadata failed\n");
2017 bcopy(tmp, tmp+1024, 512);
2018 bcopy(tmp+512, tmp, 1024);
2019 bzero(tmp+1024, 512);
2021 /* check if this is a Intel RAID struct */
2022 if (strncmp(meta->intel_id, INTEL_MAGIC, strlen(INTEL_MAGIC))) {
2023 if (testing || bootverbose)
2024 device_printf(parent, "Intel check1 failed\n");
2028 for (checksum = 0, ptr = (u_int32_t *)meta, count = 0;
2029 count < (meta->config_size / sizeof(u_int32_t)); count++) {
2032 checksum -= meta->checksum;
2033 if (checksum != meta->checksum) {
2034 if (testing || bootverbose)
2035 device_printf(parent, "Intel check2 failed\n");
2039 if (testing || bootverbose)
2040 ata_raid_intel_print_meta(meta);
2042 map = (struct intel_raid_mapping *)&meta->disk[meta->total_disks];
2044 /* now convert Intel metadata into our generic form */
2045 for (array = 0; array < MAX_ARRAYS; array++) {
2046 if (!raidp[array]) {
2048 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
2050 if (!raidp[array]) {
2051 device_printf(parent, "failed to allocate metadata storage\n");
2055 raid = raidp[array];
2056 if (raid->format && (raid->format != AR_F_INTEL_RAID))
2059 if ((raid->format & AR_F_INTEL_RAID) &&
2060 (raid->magic_0 != meta->config_id))
2064 * update our knowledge about the array config based on generation
2065 * NOTE: there can be multiple volumes on a disk set
2067 if (!meta->generation || meta->generation > raid->generation) {
2068 switch (map->type) {
2070 raid->type = AR_T_RAID0;
2071 raid->width = map->total_disks;
2075 if (map->total_disks == 4)
2076 raid->type = AR_T_RAID01;
2078 raid->type = AR_T_RAID1;
2079 raid->width = map->total_disks / 2;
2083 raid->type = AR_T_RAID5;
2084 raid->width = map->total_disks;
2088 device_printf(parent, "Intel unknown RAID type 0x%02x\n",
2090 free(raidp[array], M_AR);
2091 raidp[array] = NULL;
2095 switch (map->status) {
2097 raid->status = AR_S_READY;
2099 case INTEL_S_DEGRADED:
2100 raid->status |= AR_S_DEGRADED;
2102 case INTEL_S_DISABLED:
2103 case INTEL_S_FAILURE:
2107 raid->magic_0 = meta->config_id;
2108 raid->format = AR_F_INTEL_RAID;
2109 raid->generation = meta->generation;
2110 raid->interleave = map->stripe_sectors;
2111 raid->total_disks = map->total_disks;
2112 raid->total_sectors = map->total_sectors;
2115 raid->cylinders = raid->total_sectors / (63 * 255);
2116 raid->offset_sectors = map->offset;
2117 raid->rebuild_lba = 0;
2119 raid->volume = volume - 1;
2120 strncpy(raid->name, map->name,
2121 min(sizeof(raid->name), sizeof(map->name)));
2123 /* clear out any old info */
2124 for (disk = 0; disk < raid->total_disks; disk++) {
2125 raid->disks[disk].dev = NULL;
2126 bcopy(meta->disk[map->disk_idx[disk]].serial,
2127 raid->disks[disk].serial,
2128 sizeof(raid->disks[disk].serial));
2129 raid->disks[disk].sectors =
2130 meta->disk[map->disk_idx[disk]].sectors;
2131 raid->disks[disk].flags = 0;
2132 if (meta->disk[map->disk_idx[disk]].flags & INTEL_F_ONLINE)
2133 raid->disks[disk].flags |= AR_DF_ONLINE;
2134 if (meta->disk[map->disk_idx[disk]].flags & INTEL_F_ASSIGNED)
2135 raid->disks[disk].flags |= AR_DF_ASSIGNED;
2136 if (meta->disk[map->disk_idx[disk]].flags & INTEL_F_SPARE) {
2137 raid->disks[disk].flags &= ~(AR_DF_ONLINE | AR_DF_ASSIGNED);
2138 raid->disks[disk].flags |= AR_DF_SPARE;
2140 if (meta->disk[map->disk_idx[disk]].flags & INTEL_F_DOWN)
2141 raid->disks[disk].flags &= ~AR_DF_ONLINE;
2144 if (meta->generation >= raid->generation) {
2145 for (disk = 0; disk < raid->total_disks; disk++) {
2146 struct ata_device *atadev = device_get_softc(parent);
2148 if (!strncmp(raid->disks[disk].serial, atadev->param.serial,
2149 sizeof(raid->disks[disk].serial))) {
2150 raid->disks[disk].dev = parent;
2151 raid->disks[disk].flags |= (AR_DF_PRESENT | AR_DF_ONLINE);
2152 ars->raid[raid->volume] = raid;
2153 ars->disk_number[raid->volume] = disk;
2162 if (volume < meta->total_volumes) {
2163 map = (struct intel_raid_mapping *)
2164 &map->disk_idx[map->total_disks];
2172 free(raidp[array], M_AR);
2173 raidp[array] = NULL;
2185 ata_raid_intel_write_meta(struct ar_softc *rdp)
2187 struct intel_raid_conf *meta;
2188 struct intel_raid_mapping *map;
2189 struct timeval timestamp;
2190 u_int32_t checksum, *ptr;
2191 int count, disk, error = 0;
2194 if (!(meta = (struct intel_raid_conf *)
2195 malloc(1536, M_AR, M_NOWAIT | M_ZERO))) {
2196 printf("ar%d: failed to allocate metadata storage\n", rdp->lun);
2201 microtime(×tamp);
2203 bcopy(INTEL_MAGIC, meta->intel_id, sizeof(meta->intel_id));
2204 bcopy(INTEL_VERSION_1100, meta->version, sizeof(meta->version));
2205 meta->config_id = timestamp.tv_sec;
2206 meta->generation = rdp->generation;
2207 meta->total_disks = rdp->total_disks;
2208 meta->total_volumes = 1; /* XXX SOS */
2209 for (disk = 0; disk < rdp->total_disks; disk++) {
2210 if (rdp->disks[disk].dev) {
2211 struct ata_channel *ch =
2212 device_get_softc(device_get_parent(rdp->disks[disk].dev));
2213 struct ata_device *atadev =
2214 device_get_softc(rdp->disks[disk].dev);
2216 bcopy(atadev->param.serial, meta->disk[disk].serial,
2217 sizeof(rdp->disks[disk].serial));
2218 meta->disk[disk].sectors = rdp->disks[disk].sectors;
2219 meta->disk[disk].id = (ch->unit << 16) | ATA_DEV(atadev->unit);
2222 meta->disk[disk].sectors = rdp->total_sectors / rdp->width;
2223 meta->disk[disk].flags = 0;
2224 if (rdp->disks[disk].flags & AR_DF_SPARE)
2225 meta->disk[disk].flags |= INTEL_F_SPARE;
2227 if (rdp->disks[disk].flags & AR_DF_ONLINE)
2228 meta->disk[disk].flags |= INTEL_F_ONLINE;
2230 meta->disk[disk].flags |= INTEL_F_DOWN;
2231 if (rdp->disks[disk].flags & AR_DF_ASSIGNED)
2232 meta->disk[disk].flags |= INTEL_F_ASSIGNED;
2235 map = (struct intel_raid_mapping *)&meta->disk[meta->total_disks];
2237 bcopy(rdp->name, map->name, sizeof(rdp->name));
2238 map->total_sectors = rdp->total_sectors;
2239 map->state = 12; /* XXX SOS */
2240 map->offset = rdp->offset_sectors;
2241 map->stripe_count = rdp->total_sectors / (rdp->interleave*rdp->total_disks);
2242 map->stripe_sectors = rdp->interleave;
2243 map->disk_sectors = rdp->total_sectors / rdp->width;
2244 map->status = INTEL_S_READY; /* XXX SOS */
2245 switch (rdp->type) {
2247 map->type = INTEL_T_RAID0;
2250 map->type = INTEL_T_RAID1;
2253 map->type = INTEL_T_RAID1;
2256 map->type = INTEL_T_RAID5;
2262 map->total_disks = rdp->total_disks;
2263 map->magic[0] = 0x02;
2264 map->magic[1] = 0xff;
2265 map->magic[2] = 0x01;
2266 for (disk = 0; disk < rdp->total_disks; disk++)
2267 map->disk_idx[disk] = disk;
2269 meta->config_size = (char *)&map->disk_idx[disk] - (char *)meta;
2270 for (checksum = 0, ptr = (u_int32_t *)meta, count = 0;
2271 count < (meta->config_size / sizeof(u_int32_t)); count++) {
2274 meta->checksum = checksum;
2276 if (testing || bootverbose)
2277 ata_raid_intel_print_meta(meta);
2280 bcopy(tmp, tmp+1024, 512);
2281 bcopy(tmp+512, tmp, 1024);
2282 bzero(tmp+1024, 512);
2284 for (disk = 0; disk < rdp->total_disks; disk++) {
2285 if (rdp->disks[disk].dev) {
2286 if (ata_raid_rw(rdp->disks[disk].dev,
2287 INTEL_LBA(rdp->disks[disk].dev),
2288 meta, 1024, ATA_R_WRITE | ATA_R_DIRECT)) {
2289 device_printf(rdp->disks[disk].dev, "write metadata failed\n");
2299 /* Integrated Technology Express Metadata */
2301 ata_raid_ite_read_meta(device_t dev, struct ar_softc **raidp)
2303 struct ata_raid_subdisk *ars = device_get_softc(dev);
2304 device_t parent = device_get_parent(dev);
2305 struct ite_raid_conf *meta;
2306 struct ar_softc *raid = NULL;
2307 int array, disk_number, count, retval = 0;
2310 if (!(meta = (struct ite_raid_conf *)
2311 malloc(sizeof(struct ite_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
2314 if (ata_raid_rw(parent, ITE_LBA(parent),
2315 meta, sizeof(struct ite_raid_conf), ATA_R_READ)) {
2316 if (testing || bootverbose)
2317 device_printf(parent, "ITE read metadata failed\n");
2321 /* check if this is a ITE RAID struct */
2322 for (ptr = (u_int16_t *)meta->ite_id, count = 0;
2323 count < sizeof(meta->ite_id)/sizeof(uint16_t); count++)
2324 ptr[count] = be16toh(ptr[count]);
2326 if (strncmp(meta->ite_id, ITE_MAGIC, strlen(ITE_MAGIC))) {
2327 if (testing || bootverbose)
2328 device_printf(parent, "ITE check1 failed\n");
2332 if (testing || bootverbose)
2333 ata_raid_ite_print_meta(meta);
2335 /* now convert ITE metadata into our generic form */
2336 for (array = 0; array < MAX_ARRAYS; array++) {
2337 if ((raid = raidp[array])) {
2338 if (raid->format != AR_F_ITE_RAID)
2340 if (raid->magic_0 != *((u_int64_t *)meta->timestamp_0))
2344 /* if we dont have a disks timestamp the RAID is invalidated */
2345 if (*((u_int64_t *)meta->timestamp_1) == 0)
2349 raidp[array] = (struct ar_softc *)malloc(sizeof(struct ar_softc),
2350 M_AR, M_NOWAIT | M_ZERO);
2351 if (!(raid = raidp[array])) {
2352 device_printf(parent, "failed to allocate metadata storage\n");
2357 switch (meta->type) {
2359 raid->type = AR_T_RAID0;
2360 raid->width = meta->array_width;
2361 raid->total_disks = meta->array_width;
2362 disk_number = meta->disk_number;
2366 raid->type = AR_T_RAID1;
2368 raid->total_disks = 2;
2369 disk_number = meta->disk_number;
2373 raid->type = AR_T_RAID01;
2374 raid->width = meta->array_width;
2375 raid->total_disks = 4;
2376 disk_number = ((meta->disk_number & 0x02) >> 1) |
2377 ((meta->disk_number & 0x01) << 1);
2381 raid->type = AR_T_SPAN;
2383 raid->total_disks = meta->array_width;
2384 disk_number = meta->disk_number;
2388 device_printf(parent, "ITE unknown RAID type 0x%02x\n", meta->type);
2389 free(raidp[array], M_AR);
2390 raidp[array] = NULL;
2394 raid->magic_0 = *((u_int64_t *)meta->timestamp_0);
2395 raid->format = AR_F_ITE_RAID;
2396 raid->generation = 0;
2397 raid->interleave = meta->stripe_sectors;
2398 raid->total_sectors = meta->total_sectors;
2401 raid->cylinders = raid->total_sectors / (63 * 255);
2402 raid->offset_sectors = 0;
2403 raid->rebuild_lba = 0;
2406 raid->disks[disk_number].dev = parent;
2407 raid->disks[disk_number].sectors = raid->total_sectors / raid->width;
2408 raid->disks[disk_number].flags =
2409 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_ONLINE);
2410 ars->raid[raid->volume] = raid;
2411 ars->disk_number[raid->volume] = disk_number;
2420 /* JMicron Technology Corp Metadata */
2422 ata_raid_jmicron_read_meta(device_t dev, struct ar_softc **raidp)
2424 struct ata_raid_subdisk *ars = device_get_softc(dev);
2425 device_t parent = device_get_parent(dev);
2426 struct jmicron_raid_conf *meta;
2427 struct ar_softc *raid = NULL;
2428 u_int16_t checksum, *ptr;
2429 u_int64_t disk_size;
2430 int count, array, disk, total_disks, retval = 0;
2432 if (!(meta = (struct jmicron_raid_conf *)
2433 malloc(sizeof(struct jmicron_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
2436 if (ata_raid_rw(parent, JMICRON_LBA(parent),
2437 meta, sizeof(struct jmicron_raid_conf), ATA_R_READ)) {
2438 if (testing || bootverbose)
2439 device_printf(parent,
2440 "JMicron read metadata failed\n");
2443 /* check for JMicron signature */
2444 if (strncmp(meta->signature, JMICRON_MAGIC, 2)) {
2445 if (testing || bootverbose)
2446 device_printf(parent, "JMicron check1 failed\n");
2450 /* calculate checksum and compare for valid */
2451 for (checksum = 0, ptr = (u_int16_t *)meta, count = 0; count < 64; count++)
2454 if (testing || bootverbose)
2455 device_printf(parent, "JMicron check2 failed\n");
2459 if (testing || bootverbose)
2460 ata_raid_jmicron_print_meta(meta);
2462 /* now convert JMicron meta into our generic form */
2463 for (array = 0; array < MAX_ARRAYS; array++) {
2465 if (!raidp[array]) {
2467 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
2469 if (!raidp[array]) {
2470 device_printf(parent, "failed to allocate metadata storage\n");
2474 raid = raidp[array];
2475 if (raid->format && (raid->format != AR_F_JMICRON_RAID))
2478 for (total_disks = 0, disk = 0; disk < JM_MAX_DISKS; disk++) {
2479 if (meta->disks[disk]) {
2480 if (raid->format == AR_F_JMICRON_RAID) {
2481 if (bcmp(&meta->disks[disk],
2482 raid->disks[disk].serial, sizeof(u_int32_t))) {
2488 bcopy(&meta->disks[disk],
2489 raid->disks[disk].serial, sizeof(u_int32_t));
2493 /* handle spares XXX SOS */
2495 switch (meta->type) {
2497 raid->type = AR_T_RAID0;
2498 raid->width = total_disks;
2502 raid->type = AR_T_RAID1;
2507 raid->type = AR_T_RAID01;
2508 raid->width = total_disks / 2;
2512 raid->type = AR_T_RAID5;
2513 raid->width = total_disks;
2517 raid->type = AR_T_SPAN;
2522 device_printf(parent,
2523 "JMicron unknown RAID type 0x%02x\n", meta->type);
2524 free(raidp[array], M_AR);
2525 raidp[array] = NULL;
2528 disk_size = (meta->disk_sectors_high << 16) + meta->disk_sectors_low;
2529 raid->format = AR_F_JMICRON_RAID;
2530 strncpy(raid->name, meta->name, sizeof(meta->name));
2531 raid->generation = 0;
2532 raid->interleave = 2 << meta->stripe_shift;
2533 raid->total_disks = total_disks;
2534 raid->total_sectors = disk_size * (raid->width-(raid->type==AR_RAID5));
2537 raid->cylinders = raid->total_sectors / (63 * 255);
2538 raid->offset_sectors = meta->offset * 16;
2539 raid->rebuild_lba = 0;
2542 for (disk = 0; disk < raid->total_disks; disk++) {
2543 if (meta->disks[disk] == meta->disk_id) {
2544 raid->disks[disk].dev = parent;
2545 raid->disks[disk].sectors = disk_size;
2546 raid->disks[disk].flags =
2547 (AR_DF_ONLINE | AR_DF_PRESENT | AR_DF_ASSIGNED);
2548 ars->raid[raid->volume] = raid;
2549 ars->disk_number[raid->volume] = disk;
2562 ata_raid_jmicron_write_meta(struct ar_softc *rdp)
2564 struct jmicron_raid_conf *meta;
2565 u_int64_t disk_sectors;
2566 int disk, error = 0;
2568 if (!(meta = (struct jmicron_raid_conf *)
2569 malloc(sizeof(struct jmicron_raid_conf), M_AR, M_NOWAIT | M_ZERO))) {
2570 printf("ar%d: failed to allocate metadata storage\n", rdp->lun);
2575 switch (rdp->type) {
2577 meta->type = JM_T_JBOD;
2581 meta->type = JM_T_RAID0;
2585 meta->type = JM_T_RAID1;
2589 meta->type = JM_T_RAID5;
2593 meta->type = JM_T_RAID01;
2600 bcopy(JMICRON_MAGIC, meta->signature, sizeof(JMICRON_MAGIC));
2601 meta->version = JMICRON_VERSION;
2602 meta->offset = rdp->offset_sectors / 16;
2603 disk_sectors = rdp->total_sectors / (rdp->width - (rdp->type == AR_RAID5));
2604 meta->disk_sectors_low = disk_sectors & 0xffff;
2605 meta->disk_sectors_high = disk_sectors >> 16;
2606 strncpy(meta->name, rdp->name, sizeof(meta->name));
2607 meta->stripe_shift = ffs(rdp->interleave) - 2;
2609 for (disk = 0; disk < rdp->total_disks; disk++) {
2610 if (rdp->disks[disk].serial[0])
2611 bcopy(rdp->disks[disk].serial,&meta->disks[disk],sizeof(u_int32_t));
2613 meta->disks[disk] = (u_int32_t)(uintptr_t)rdp->disks[disk].dev;
2616 for (disk = 0; disk < rdp->total_disks; disk++) {
2617 if (rdp->disks[disk].dev) {
2618 u_int16_t checksum = 0, *ptr;
2621 meta->disk_id = meta->disks[disk];
2623 for (ptr = (u_int16_t *)meta, count = 0; count < 64; count++)
2625 meta->checksum -= checksum;
2627 if (testing || bootverbose)
2628 ata_raid_jmicron_print_meta(meta);
2630 if (ata_raid_rw(rdp->disks[disk].dev,
2631 JMICRON_LBA(rdp->disks[disk].dev),
2632 meta, sizeof(struct jmicron_raid_conf),
2633 ATA_R_WRITE | ATA_R_DIRECT)) {
2634 device_printf(rdp->disks[disk].dev, "write metadata failed\n");
2639 /* handle spares XXX SOS */
2645 /* LSILogic V2 MegaRAID Metadata */
2647 ata_raid_lsiv2_read_meta(device_t dev, struct ar_softc **raidp)
2649 struct ata_raid_subdisk *ars = device_get_softc(dev);
2650 device_t parent = device_get_parent(dev);
2651 struct lsiv2_raid_conf *meta;
2652 struct ar_softc *raid = NULL;
2653 int array, retval = 0;
2655 if (!(meta = (struct lsiv2_raid_conf *)
2656 malloc(sizeof(struct lsiv2_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
2659 if (ata_raid_rw(parent, LSIV2_LBA(parent),
2660 meta, sizeof(struct lsiv2_raid_conf), ATA_R_READ)) {
2661 if (testing || bootverbose)
2662 device_printf(parent, "LSI (v2) read metadata failed\n");
2666 /* check if this is a LSI RAID struct */
2667 if (strncmp(meta->lsi_id, LSIV2_MAGIC, strlen(LSIV2_MAGIC))) {
2668 if (testing || bootverbose)
2669 device_printf(parent, "LSI (v2) check1 failed\n");
2673 if (testing || bootverbose)
2674 ata_raid_lsiv2_print_meta(meta);
2676 /* now convert LSI (v2) config meta into our generic form */
2677 for (array = 0; array < MAX_ARRAYS; array++) {
2678 int raid_entry, conf_entry;
2680 if (!raidp[array + meta->raid_number]) {
2681 raidp[array + meta->raid_number] =
2682 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
2684 if (!raidp[array + meta->raid_number]) {
2685 device_printf(parent, "failed to allocate metadata storage\n");
2689 raid = raidp[array + meta->raid_number];
2690 if (raid->format && (raid->format != AR_F_LSIV2_RAID))
2693 if (raid->magic_0 &&
2694 ((raid->magic_0 != meta->timestamp) ||
2695 (raid->magic_1 != meta->raid_number)))
2698 array += meta->raid_number;
2700 raid_entry = meta->raid_number;
2701 conf_entry = (meta->configs[raid_entry].raid.config_offset >> 4) +
2702 meta->disk_number - 1;
2704 switch (meta->configs[raid_entry].raid.type) {
2706 raid->magic_0 = meta->timestamp;
2707 raid->magic_1 = meta->raid_number;
2708 raid->type = AR_T_RAID0;
2709 raid->interleave = meta->configs[raid_entry].raid.stripe_sectors;
2710 raid->width = meta->configs[raid_entry].raid.array_width;
2714 raid->magic_0 = meta->timestamp;
2715 raid->magic_1 = meta->raid_number;
2716 raid->type = AR_T_RAID1;
2717 raid->width = meta->configs[raid_entry].raid.array_width;
2720 case LSIV2_T_RAID0 | LSIV2_T_RAID1:
2721 raid->magic_0 = meta->timestamp;
2722 raid->magic_1 = meta->raid_number;
2723 raid->type = AR_T_RAID01;
2724 raid->interleave = meta->configs[raid_entry].raid.stripe_sectors;
2725 raid->width = meta->configs[raid_entry].raid.array_width;
2729 device_printf(parent, "LSI v2 unknown RAID type 0x%02x\n",
2730 meta->configs[raid_entry].raid.type);
2731 free(raidp[array], M_AR);
2732 raidp[array] = NULL;
2736 raid->format = AR_F_LSIV2_RAID;
2737 raid->generation = 0;
2738 raid->total_disks = meta->configs[raid_entry].raid.disk_count;
2739 raid->total_sectors = meta->configs[raid_entry].raid.total_sectors;
2742 raid->cylinders = raid->total_sectors / (63 * 255);
2743 raid->offset_sectors = 0;
2744 raid->rebuild_lba = 0;
2747 if (meta->configs[conf_entry].disk.device != LSIV2_D_NONE) {
2748 raid->disks[meta->disk_number].dev = parent;
2749 raid->disks[meta->disk_number].sectors =
2750 meta->configs[conf_entry].disk.disk_sectors;
2751 raid->disks[meta->disk_number].flags =
2752 (AR_DF_ONLINE | AR_DF_PRESENT | AR_DF_ASSIGNED);
2753 ars->raid[raid->volume] = raid;
2754 ars->disk_number[raid->volume] = meta->disk_number;
2758 raid->disks[meta->disk_number].flags &= ~AR_DF_ONLINE;
2768 /* LSILogic V3 MegaRAID Metadata */
2770 ata_raid_lsiv3_read_meta(device_t dev, struct ar_softc **raidp)
2772 struct ata_raid_subdisk *ars = device_get_softc(dev);
2773 device_t parent = device_get_parent(dev);
2774 struct lsiv3_raid_conf *meta;
2775 struct ar_softc *raid = NULL;
2776 u_int8_t checksum, *ptr;
2777 int array, entry, count, disk_number, retval = 0;
2779 if (!(meta = (struct lsiv3_raid_conf *)
2780 malloc(sizeof(struct lsiv3_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
2783 if (ata_raid_rw(parent, LSIV3_LBA(parent),
2784 meta, sizeof(struct lsiv3_raid_conf), ATA_R_READ)) {
2785 if (testing || bootverbose)
2786 device_printf(parent, "LSI (v3) read metadata failed\n");
2790 /* check if this is a LSI RAID struct */
2791 if (strncmp(meta->lsi_id, LSIV3_MAGIC, strlen(LSIV3_MAGIC))) {
2792 if (testing || bootverbose)
2793 device_printf(parent, "LSI (v3) check1 failed\n");
2797 /* check if the checksum is OK */
2798 for (checksum = 0, ptr = meta->lsi_id, count = 0; count < 512; count++)
2801 if (testing || bootverbose)
2802 device_printf(parent, "LSI (v3) check2 failed\n");
2806 if (testing || bootverbose)
2807 ata_raid_lsiv3_print_meta(meta);
2809 /* now convert LSI (v3) config meta into our generic form */
2810 for (array = 0, entry = 0; array < MAX_ARRAYS && entry < 8;) {
2811 if (!raidp[array]) {
2813 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
2815 if (!raidp[array]) {
2816 device_printf(parent, "failed to allocate metadata storage\n");
2820 raid = raidp[array];
2821 if (raid->format && (raid->format != AR_F_LSIV3_RAID)) {
2826 if ((raid->format == AR_F_LSIV3_RAID) &&
2827 (raid->magic_0 != meta->timestamp)) {
2832 switch (meta->raid[entry].total_disks) {
2837 if (meta->raid[entry].device == meta->device) {
2846 disk_number = (meta->device & (LSIV3_D_DEVICE|LSIV3_D_CHANNEL))?1:0;
2849 device_printf(parent, "lsiv3 > 2 disk support untested!!\n");
2850 disk_number = (meta->device & LSIV3_D_DEVICE ? 1 : 0) +
2851 (meta->device & LSIV3_D_CHANNEL ? 2 : 0);
2855 switch (meta->raid[entry].type) {
2857 raid->type = AR_T_RAID0;
2858 raid->width = meta->raid[entry].total_disks;
2862 raid->type = AR_T_RAID1;
2863 raid->width = meta->raid[entry].array_width;
2867 device_printf(parent, "LSI v3 unknown RAID type 0x%02x\n",
2868 meta->raid[entry].type);
2869 free(raidp[array], M_AR);
2870 raidp[array] = NULL;
2875 raid->magic_0 = meta->timestamp;
2876 raid->format = AR_F_LSIV3_RAID;
2877 raid->generation = 0;
2878 raid->interleave = meta->raid[entry].stripe_pages * 8;
2879 raid->total_disks = meta->raid[entry].total_disks;
2880 raid->total_sectors = raid->width * meta->raid[entry].sectors;
2883 raid->cylinders = raid->total_sectors / (63 * 255);
2884 raid->offset_sectors = meta->raid[entry].offset;
2885 raid->rebuild_lba = 0;
2888 raid->disks[disk_number].dev = parent;
2889 raid->disks[disk_number].sectors = raid->total_sectors / raid->width;
2890 raid->disks[disk_number].flags =
2891 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_ONLINE);
2892 ars->raid[raid->volume] = raid;
2893 ars->disk_number[raid->volume] = disk_number;
2904 /* nVidia MediaShield Metadata */
2906 ata_raid_nvidia_read_meta(device_t dev, struct ar_softc **raidp)
2908 struct ata_raid_subdisk *ars = device_get_softc(dev);
2909 device_t parent = device_get_parent(dev);
2910 struct nvidia_raid_conf *meta;
2911 struct ar_softc *raid = NULL;
2912 u_int32_t checksum, *ptr;
2913 int array, count, retval = 0;
2915 if (!(meta = (struct nvidia_raid_conf *)
2916 malloc(sizeof(struct nvidia_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
2919 if (ata_raid_rw(parent, NVIDIA_LBA(parent),
2920 meta, sizeof(struct nvidia_raid_conf), ATA_R_READ)) {
2921 if (testing || bootverbose)
2922 device_printf(parent, "nVidia read metadata failed\n");
2926 /* check if this is a nVidia RAID struct */
2927 if (strncmp(meta->nvidia_id, NV_MAGIC, strlen(NV_MAGIC))) {
2928 if (testing || bootverbose)
2929 device_printf(parent, "nVidia check1 failed\n");
2933 /* check if the checksum is OK */
2934 for (checksum = 0, ptr = (u_int32_t*)meta, count = 0;
2935 count < meta->config_size; count++)
2938 if (testing || bootverbose)
2939 device_printf(parent, "nVidia check2 failed\n");
2943 if (testing || bootverbose)
2944 ata_raid_nvidia_print_meta(meta);
2946 /* now convert nVidia meta into our generic form */
2947 for (array = 0; array < MAX_ARRAYS; array++) {
2948 if (!raidp[array]) {
2950 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
2952 if (!raidp[array]) {
2953 device_printf(parent, "failed to allocate metadata storage\n");
2957 raid = raidp[array];
2958 if (raid->format && (raid->format != AR_F_NVIDIA_RAID))
2961 if (raid->format == AR_F_NVIDIA_RAID &&
2962 ((raid->magic_0 != meta->magic_1) ||
2963 (raid->magic_1 != meta->magic_2))) {
2967 switch (meta->type) {
2969 raid->type = AR_T_SPAN;
2973 raid->type = AR_T_RAID0;
2977 raid->type = AR_T_RAID1;
2981 raid->type = AR_T_RAID5;
2985 raid->type = AR_T_RAID01;
2989 device_printf(parent, "nVidia unknown RAID type 0x%02x\n",
2991 free(raidp[array], M_AR);
2992 raidp[array] = NULL;
2995 raid->magic_0 = meta->magic_1;
2996 raid->magic_1 = meta->magic_2;
2997 raid->format = AR_F_NVIDIA_RAID;
2998 raid->generation = 0;
2999 raid->interleave = meta->stripe_sectors;
3000 raid->width = meta->array_width;
3001 raid->total_disks = meta->total_disks;
3002 raid->total_sectors = meta->total_sectors;
3005 raid->cylinders = raid->total_sectors / (63 * 255);
3006 raid->offset_sectors = 0;
3007 raid->rebuild_lba = meta->rebuild_lba;
3009 raid->status = AR_S_READY;
3010 if (meta->status & NV_S_DEGRADED)
3011 raid->status |= AR_S_DEGRADED;
3013 raid->disks[meta->disk_number].dev = parent;
3014 raid->disks[meta->disk_number].sectors =
3015 raid->total_sectors / raid->width;
3016 raid->disks[meta->disk_number].flags =
3017 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_ONLINE);
3018 ars->raid[raid->volume] = raid;
3019 ars->disk_number[raid->volume] = meta->disk_number;
3029 /* Promise FastTrak Metadata */
3031 ata_raid_promise_read_meta(device_t dev, struct ar_softc **raidp, int native)
3033 struct ata_raid_subdisk *ars = device_get_softc(dev);
3034 device_t parent = device_get_parent(dev);
3035 struct promise_raid_conf *meta;
3036 struct ar_softc *raid;
3037 u_int32_t checksum, *ptr;
3038 int array, count, disk, disksum = 0, retval = 0;
3040 if (!(meta = (struct promise_raid_conf *)
3041 malloc(sizeof(struct promise_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
3044 if (ata_raid_rw(parent, PROMISE_LBA(parent),
3045 meta, sizeof(struct promise_raid_conf), ATA_R_READ)) {
3046 if (testing || bootverbose)
3047 device_printf(parent, "%s read metadata failed\n",
3048 native ? "FreeBSD" : "Promise");
3052 /* check the signature */
3054 if (strncmp(meta->promise_id, ATA_MAGIC, strlen(ATA_MAGIC))) {
3055 if (testing || bootverbose)
3056 device_printf(parent, "FreeBSD check1 failed\n");
3061 if (strncmp(meta->promise_id, PR_MAGIC, strlen(PR_MAGIC))) {
3062 if (testing || bootverbose)
3063 device_printf(parent, "Promise check1 failed\n");
3068 /* check if the checksum is OK */
3069 for (checksum = 0, ptr = (u_int32_t *)meta, count = 0; count < 511; count++)
3071 if (checksum != *ptr) {
3072 if (testing || bootverbose)
3073 device_printf(parent, "%s check2 failed\n",
3074 native ? "FreeBSD" : "Promise");
3078 /* check on disk integrity status */
3079 if (meta->raid.integrity != PR_I_VALID) {
3080 if (testing || bootverbose)
3081 device_printf(parent, "%s check3 failed\n",
3082 native ? "FreeBSD" : "Promise");
3086 if (testing || bootverbose)
3087 ata_raid_promise_print_meta(meta);
3089 /* now convert Promise metadata into our generic form */
3090 for (array = 0; array < MAX_ARRAYS; array++) {
3091 if (!raidp[array]) {
3093 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
3095 if (!raidp[array]) {
3096 device_printf(parent, "failed to allocate metadata storage\n");
3100 raid = raidp[array];
3102 (raid->format != (native ? AR_F_FREEBSD_RAID : AR_F_PROMISE_RAID)))
3105 if ((raid->format == (native ? AR_F_FREEBSD_RAID : AR_F_PROMISE_RAID))&&
3106 !(meta->raid.magic_1 == (raid->magic_1)))
3109 /* update our knowledge about the array config based on generation */
3110 if (!meta->raid.generation || meta->raid.generation > raid->generation){
3111 switch (meta->raid.type) {
3113 raid->type = AR_T_SPAN;
3117 raid->type = AR_T_JBOD;
3121 raid->type = AR_T_RAID0;
3125 raid->type = AR_T_RAID1;
3126 if (meta->raid.array_width > 1)
3127 raid->type = AR_T_RAID01;
3131 raid->type = AR_T_RAID5;
3135 device_printf(parent, "%s unknown RAID type 0x%02x\n",
3136 native ? "FreeBSD" : "Promise", meta->raid.type);
3137 free(raidp[array], M_AR);
3138 raidp[array] = NULL;
3141 raid->magic_1 = meta->raid.magic_1;
3142 raid->format = (native ? AR_F_FREEBSD_RAID : AR_F_PROMISE_RAID);
3143 raid->generation = meta->raid.generation;
3144 raid->interleave = 1 << meta->raid.stripe_shift;
3145 raid->width = meta->raid.array_width;
3146 raid->total_disks = meta->raid.total_disks;
3147 raid->heads = meta->raid.heads + 1;
3148 raid->sectors = meta->raid.sectors;
3149 raid->cylinders = meta->raid.cylinders + 1;
3150 raid->total_sectors = meta->raid.total_sectors;
3151 raid->offset_sectors = 0;
3152 raid->rebuild_lba = meta->raid.rebuild_lba;
3154 if ((meta->raid.status &
3155 (PR_S_VALID | PR_S_ONLINE | PR_S_INITED | PR_S_READY)) ==
3156 (PR_S_VALID | PR_S_ONLINE | PR_S_INITED | PR_S_READY)) {
3157 raid->status |= AR_S_READY;
3158 if (meta->raid.status & PR_S_DEGRADED)
3159 raid->status |= AR_S_DEGRADED;
3162 raid->status &= ~AR_S_READY;
3164 /* convert disk flags to our internal types */
3165 for (disk = 0; disk < meta->raid.total_disks; disk++) {
3166 raid->disks[disk].dev = NULL;
3167 raid->disks[disk].flags = 0;
3168 *((u_int64_t *)(raid->disks[disk].serial)) =
3169 meta->raid.disk[disk].magic_0;
3170 disksum += meta->raid.disk[disk].flags;
3171 if (meta->raid.disk[disk].flags & PR_F_ONLINE)
3172 raid->disks[disk].flags |= AR_DF_ONLINE;
3173 if (meta->raid.disk[disk].flags & PR_F_ASSIGNED)
3174 raid->disks[disk].flags |= AR_DF_ASSIGNED;
3175 if (meta->raid.disk[disk].flags & PR_F_SPARE) {
3176 raid->disks[disk].flags &= ~(AR_DF_ONLINE | AR_DF_ASSIGNED);
3177 raid->disks[disk].flags |= AR_DF_SPARE;
3179 if (meta->raid.disk[disk].flags & (PR_F_REDIR | PR_F_DOWN))
3180 raid->disks[disk].flags &= ~AR_DF_ONLINE;
3183 device_printf(parent, "%s subdisks has no flags\n",
3184 native ? "FreeBSD" : "Promise");
3185 free(raidp[array], M_AR);
3186 raidp[array] = NULL;
3190 if (meta->raid.generation >= raid->generation) {
3191 int disk_number = meta->raid.disk_number;
3193 if (raid->disks[disk_number].flags && (meta->magic_0 ==
3194 *((u_int64_t *)(raid->disks[disk_number].serial)))) {
3195 raid->disks[disk_number].dev = parent;
3196 raid->disks[disk_number].flags |= AR_DF_PRESENT;
3197 raid->disks[disk_number].sectors = meta->raid.disk_sectors;
3198 if ((raid->disks[disk_number].flags &
3199 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_ONLINE)) ==
3200 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_ONLINE)) {
3201 ars->raid[raid->volume] = raid;
3202 ars->disk_number[raid->volume] = disk_number;
3216 ata_raid_promise_write_meta(struct ar_softc *rdp)
3218 struct promise_raid_conf *meta;
3219 struct timeval timestamp;
3221 int count, disk, drive, error = 0;
3223 if (!(meta = (struct promise_raid_conf *)
3224 malloc(sizeof(struct promise_raid_conf), M_AR, M_NOWAIT))) {
3225 printf("ar%d: failed to allocate metadata storage\n", rdp->lun);
3230 microtime(×tamp);
3232 for (disk = 0; disk < rdp->total_disks; disk++) {
3233 for (count = 0; count < sizeof(struct promise_raid_conf); count++)
3234 *(((u_int8_t *)meta) + count) = 255 - (count % 256);
3235 meta->dummy_0 = 0x00020000;
3236 meta->raid.disk_number = disk;
3238 if (rdp->disks[disk].dev) {
3239 struct ata_device *atadev = device_get_softc(rdp->disks[disk].dev);
3240 struct ata_channel *ch =
3241 device_get_softc(device_get_parent(rdp->disks[disk].dev));
3243 meta->raid.channel = ch->unit;
3244 meta->raid.device = ATA_DEV(atadev->unit);
3245 meta->raid.disk_sectors = rdp->disks[disk].sectors;
3246 meta->raid.disk_offset = rdp->offset_sectors;
3249 meta->raid.channel = 0;
3250 meta->raid.device = 0;
3251 meta->raid.disk_sectors = 0;
3252 meta->raid.disk_offset = 0;
3254 meta->magic_0 = PR_MAGIC0(meta->raid) | timestamp.tv_sec;
3255 meta->magic_1 = timestamp.tv_sec >> 16;
3256 meta->magic_2 = timestamp.tv_sec;
3257 meta->raid.integrity = PR_I_VALID;
3258 meta->raid.magic_0 = meta->magic_0;
3259 meta->raid.rebuild_lba = rdp->rebuild_lba;
3260 meta->raid.generation = rdp->generation;
3262 if (rdp->status & AR_S_READY) {
3263 meta->raid.flags = (PR_F_VALID | PR_F_ASSIGNED | PR_F_ONLINE);
3265 (PR_S_VALID | PR_S_ONLINE | PR_S_INITED | PR_S_READY);
3266 if (rdp->status & AR_S_DEGRADED)
3267 meta->raid.status |= PR_S_DEGRADED;
3269 meta->raid.status |= PR_S_FUNCTIONAL;
3272 meta->raid.flags = PR_F_DOWN;
3273 meta->raid.status = 0;
3276 switch (rdp->type) {
3278 meta->raid.type = PR_T_RAID0;
3281 meta->raid.type = PR_T_RAID1;
3284 meta->raid.type = PR_T_RAID1;
3287 meta->raid.type = PR_T_RAID5;
3290 meta->raid.type = PR_T_SPAN;
3293 meta->raid.type = PR_T_JBOD;
3300 meta->raid.total_disks = rdp->total_disks;
3301 meta->raid.stripe_shift = ffs(rdp->interleave) - 1;
3302 meta->raid.array_width = rdp->width;
3303 meta->raid.array_number = rdp->lun;
3304 meta->raid.total_sectors = rdp->total_sectors;
3305 meta->raid.cylinders = rdp->cylinders - 1;
3306 meta->raid.heads = rdp->heads - 1;
3307 meta->raid.sectors = rdp->sectors;
3308 meta->raid.magic_1 = (u_int64_t)meta->magic_2<<16 | meta->magic_1;
3310 bzero(&meta->raid.disk, 8 * 12);
3311 for (drive = 0; drive < rdp->total_disks; drive++) {
3312 meta->raid.disk[drive].flags = 0;
3313 if (rdp->disks[drive].flags & AR_DF_PRESENT)
3314 meta->raid.disk[drive].flags |= PR_F_VALID;
3315 if (rdp->disks[drive].flags & AR_DF_ASSIGNED)
3316 meta->raid.disk[drive].flags |= PR_F_ASSIGNED;
3317 if (rdp->disks[drive].flags & AR_DF_ONLINE)
3318 meta->raid.disk[drive].flags |= PR_F_ONLINE;
3320 if (rdp->disks[drive].flags & AR_DF_PRESENT)
3321 meta->raid.disk[drive].flags = (PR_F_REDIR | PR_F_DOWN);
3322 if (rdp->disks[drive].flags & AR_DF_SPARE)
3323 meta->raid.disk[drive].flags |= PR_F_SPARE;
3324 meta->raid.disk[drive].dummy_0 = 0x0;
3325 if (rdp->disks[drive].dev) {
3326 struct ata_channel *ch =
3327 device_get_softc(device_get_parent(rdp->disks[drive].dev));
3328 struct ata_device *atadev =
3329 device_get_softc(rdp->disks[drive].dev);
3331 meta->raid.disk[drive].channel = ch->unit;
3332 meta->raid.disk[drive].device = ATA_DEV(atadev->unit);
3334 meta->raid.disk[drive].magic_0 =
3335 PR_MAGIC0(meta->raid.disk[drive]) | timestamp.tv_sec;
3338 if (rdp->disks[disk].dev) {
3339 if ((rdp->disks[disk].flags & (AR_DF_PRESENT | AR_DF_ONLINE)) ==
3340 (AR_DF_PRESENT | AR_DF_ONLINE)) {
3341 if (rdp->format == AR_F_FREEBSD_RAID)
3342 bcopy(ATA_MAGIC, meta->promise_id, sizeof(ATA_MAGIC));
3344 bcopy(PR_MAGIC, meta->promise_id, sizeof(PR_MAGIC));
3347 bzero(meta->promise_id, sizeof(meta->promise_id));
3349 for (ckptr = (int32_t *)meta, count = 0; count < 511; count++)
3350 meta->checksum += *ckptr++;
3351 if (testing || bootverbose)
3352 ata_raid_promise_print_meta(meta);
3353 if (ata_raid_rw(rdp->disks[disk].dev,
3354 PROMISE_LBA(rdp->disks[disk].dev),
3355 meta, sizeof(struct promise_raid_conf),
3356 ATA_R_WRITE | ATA_R_DIRECT)) {
3357 device_printf(rdp->disks[disk].dev, "write metadata failed\n");
3366 /* Silicon Image Medley Metadata */
3368 ata_raid_sii_read_meta(device_t dev, struct ar_softc **raidp)
3370 struct ata_raid_subdisk *ars = device_get_softc(dev);
3371 device_t parent = device_get_parent(dev);
3372 struct sii_raid_conf *meta;
3373 struct ar_softc *raid = NULL;
3374 u_int16_t checksum, *ptr;
3375 int array, count, disk, retval = 0;
3377 if (!(meta = (struct sii_raid_conf *)
3378 malloc(sizeof(struct sii_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
3381 if (ata_raid_rw(parent, SII_LBA(parent),
3382 meta, sizeof(struct sii_raid_conf), ATA_R_READ)) {
3383 if (testing || bootverbose)
3384 device_printf(parent, "Silicon Image read metadata failed\n");
3388 /* check if this is a Silicon Image (Medley) RAID struct */
3389 for (checksum = 0, ptr = (u_int16_t *)meta, count = 0; count < 160; count++)
3392 if (testing || bootverbose)
3393 device_printf(parent, "Silicon Image check1 failed\n");
3397 for (checksum = 0, ptr = (u_int16_t *)meta, count = 0; count < 256; count++)
3399 if (checksum != meta->checksum_1) {
3400 if (testing || bootverbose)
3401 device_printf(parent, "Silicon Image check2 failed\n");
3406 if (meta->version_major != 0x0002 ||
3407 (meta->version_minor != 0x0000 && meta->version_minor != 0x0001)) {
3408 if (testing || bootverbose)
3409 device_printf(parent, "Silicon Image check3 failed\n");
3413 if (testing || bootverbose)
3414 ata_raid_sii_print_meta(meta);
3416 /* now convert Silicon Image meta into our generic form */
3417 for (array = 0; array < MAX_ARRAYS; array++) {
3418 if (!raidp[array]) {
3420 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
3422 if (!raidp[array]) {
3423 device_printf(parent, "failed to allocate metadata storage\n");
3427 raid = raidp[array];
3428 if (raid->format && (raid->format != AR_F_SII_RAID))
3431 if (raid->format == AR_F_SII_RAID &&
3432 (raid->magic_0 != *((u_int64_t *)meta->timestamp))) {
3436 /* update our knowledge about the array config based on generation */
3437 if (!meta->generation || meta->generation > raid->generation) {
3438 switch (meta->type) {
3440 raid->type = AR_T_RAID0;
3444 raid->type = AR_T_RAID1;
3448 raid->type = AR_T_RAID01;
3452 device_printf(parent, "Silicon Image SPARE disk\n");
3453 free(raidp[array], M_AR);
3454 raidp[array] = NULL;
3458 device_printf(parent,"Silicon Image unknown RAID type 0x%02x\n",
3460 free(raidp[array], M_AR);
3461 raidp[array] = NULL;
3464 raid->magic_0 = *((u_int64_t *)meta->timestamp);
3465 raid->format = AR_F_SII_RAID;
3466 raid->generation = meta->generation;
3467 raid->interleave = meta->stripe_sectors;
3468 raid->width = (meta->raid0_disks != 0xff) ? meta->raid0_disks : 1;
3470 ((meta->raid0_disks != 0xff) ? meta->raid0_disks : 0) +
3471 ((meta->raid1_disks != 0xff) ? meta->raid1_disks : 0);
3472 raid->total_sectors = meta->total_sectors;
3475 raid->cylinders = raid->total_sectors / (63 * 255);
3476 raid->offset_sectors = 0;
3477 raid->rebuild_lba = meta->rebuild_lba;
3479 strncpy(raid->name, meta->name,
3480 min(sizeof(raid->name), sizeof(meta->name)));
3482 /* clear out any old info */
3483 if (raid->generation) {
3484 for (disk = 0; disk < raid->total_disks; disk++) {
3485 raid->disks[disk].dev = NULL;
3486 raid->disks[disk].flags = 0;
3490 if (meta->generation >= raid->generation) {
3491 /* XXX SOS add check for the right physical disk by serial# */
3492 if (meta->status & SII_S_READY) {
3493 int disk_number = (raid->type == AR_T_RAID01) ?
3494 meta->raid1_ident + (meta->raid0_ident << 1) :
3497 raid->disks[disk_number].dev = parent;
3498 raid->disks[disk_number].sectors =
3499 raid->total_sectors / raid->width;
3500 raid->disks[disk_number].flags =
3501 (AR_DF_ONLINE | AR_DF_PRESENT | AR_DF_ASSIGNED);
3502 ars->raid[raid->volume] = raid;
3503 ars->disk_number[raid->volume] = disk_number;
3515 /* Silicon Integrated Systems Metadata */
3517 ata_raid_sis_read_meta(device_t dev, struct ar_softc **raidp)
3519 struct ata_raid_subdisk *ars = device_get_softc(dev);
3520 device_t parent = device_get_parent(dev);
3521 struct sis_raid_conf *meta;
3522 struct ar_softc *raid = NULL;
3523 int array, disk_number, drive, retval = 0;
3525 if (!(meta = (struct sis_raid_conf *)
3526 malloc(sizeof(struct sis_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
3529 if (ata_raid_rw(parent, SIS_LBA(parent),
3530 meta, sizeof(struct sis_raid_conf), ATA_R_READ)) {
3531 if (testing || bootverbose)
3532 device_printf(parent,
3533 "Silicon Integrated Systems read metadata failed\n");
3536 /* check for SiS magic */
3537 if (meta->magic != SIS_MAGIC) {
3538 if (testing || bootverbose)
3539 device_printf(parent,
3540 "Silicon Integrated Systems check1 failed\n");
3544 if (testing || bootverbose)
3545 ata_raid_sis_print_meta(meta);
3547 /* now convert SiS meta into our generic form */
3548 for (array = 0; array < MAX_ARRAYS; array++) {
3549 if (!raidp[array]) {
3551 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
3553 if (!raidp[array]) {
3554 device_printf(parent, "failed to allocate metadata storage\n");
3559 raid = raidp[array];
3560 if (raid->format && (raid->format != AR_F_SIS_RAID))
3563 if ((raid->format == AR_F_SIS_RAID) &&
3564 ((raid->magic_0 != meta->controller_pci_id) ||
3565 (raid->magic_1 != meta->timestamp))) {
3569 switch (meta->type_total_disks & SIS_T_MASK) {
3571 raid->type = AR_T_JBOD;
3572 raid->width = (meta->type_total_disks & SIS_D_MASK);
3573 raid->total_sectors += SIS_LBA(parent);
3577 raid->type = AR_T_RAID0;
3578 raid->width = (meta->type_total_disks & SIS_D_MASK);
3579 if (!raid->total_sectors ||
3580 (raid->total_sectors > (raid->width * SIS_LBA(parent))))
3581 raid->total_sectors = raid->width * SIS_LBA(parent);
3585 raid->type = AR_T_RAID1;
3587 if (!raid->total_sectors || (raid->total_sectors > SIS_LBA(parent)))
3588 raid->total_sectors = SIS_LBA(parent);
3592 device_printf(parent, "Silicon Integrated Systems "
3593 "unknown RAID type 0x%08x\n", meta->magic);
3594 free(raidp[array], M_AR);
3595 raidp[array] = NULL;
3598 raid->magic_0 = meta->controller_pci_id;
3599 raid->magic_1 = meta->timestamp;
3600 raid->format = AR_F_SIS_RAID;
3601 raid->generation = 0;
3602 raid->interleave = meta->stripe_sectors;
3603 raid->total_disks = (meta->type_total_disks & SIS_D_MASK);
3606 raid->cylinders = raid->total_sectors / (63 * 255);
3607 raid->offset_sectors = 0;
3608 raid->rebuild_lba = 0;
3610 /* XXX SOS if total_disks > 2 this doesn't float */
3611 if (((meta->disks & SIS_D_MASTER) >> 4) == meta->disk_number)
3616 for (drive = 0; drive < raid->total_disks; drive++) {
3617 raid->disks[drive].sectors = raid->total_sectors/raid->width;
3618 if (drive == disk_number) {
3619 raid->disks[disk_number].dev = parent;
3620 raid->disks[disk_number].flags =
3621 (AR_DF_ONLINE | AR_DF_PRESENT | AR_DF_ASSIGNED);
3622 ars->raid[raid->volume] = raid;
3623 ars->disk_number[raid->volume] = disk_number;
3636 ata_raid_sis_write_meta(struct ar_softc *rdp)
3638 struct sis_raid_conf *meta;
3639 struct timeval timestamp;
3640 int disk, error = 0;
3642 if (!(meta = (struct sis_raid_conf *)
3643 malloc(sizeof(struct sis_raid_conf), M_AR, M_NOWAIT | M_ZERO))) {
3644 printf("ar%d: failed to allocate metadata storage\n", rdp->lun);
3649 microtime(×tamp);
3651 meta->magic = SIS_MAGIC;
3652 /* XXX SOS if total_disks > 2 this doesn't float */
3653 for (disk = 0; disk < rdp->total_disks; disk++) {
3654 if (rdp->disks[disk].dev) {
3655 struct ata_channel *ch =
3656 device_get_softc(device_get_parent(rdp->disks[disk].dev));
3657 struct ata_device *atadev = device_get_softc(rdp->disks[disk].dev);
3658 int disk_number = 1 + ATA_DEV(atadev->unit) + (ch->unit << 1);
3660 meta->disks |= disk_number << ((1 - disk) << 2);
3663 switch (rdp->type) {
3665 meta->type_total_disks = SIS_T_JBOD;
3669 meta->type_total_disks = SIS_T_RAID0;
3673 meta->type_total_disks = SIS_T_RAID1;
3680 meta->type_total_disks |= (rdp->total_disks & SIS_D_MASK);
3681 meta->stripe_sectors = rdp->interleave;
3682 meta->timestamp = timestamp.tv_sec;
3684 for (disk = 0; disk < rdp->total_disks; disk++) {
3685 if (rdp->disks[disk].dev) {
3686 struct ata_channel *ch =
3687 device_get_softc(device_get_parent(rdp->disks[disk].dev));
3688 struct ata_device *atadev = device_get_softc(rdp->disks[disk].dev);
3690 meta->controller_pci_id =
3691 (pci_get_vendor(GRANDPARENT(rdp->disks[disk].dev)) << 16) |
3692 pci_get_device(GRANDPARENT(rdp->disks[disk].dev));
3693 bcopy(atadev->param.model, meta->model, sizeof(meta->model));
3695 /* XXX SOS if total_disks > 2 this may not float */
3696 meta->disk_number = 1 + ATA_DEV(atadev->unit) + (ch->unit << 1);
3698 if (testing || bootverbose)
3699 ata_raid_sis_print_meta(meta);
3701 if (ata_raid_rw(rdp->disks[disk].dev,
3702 SIS_LBA(rdp->disks[disk].dev),
3703 meta, sizeof(struct sis_raid_conf),
3704 ATA_R_WRITE | ATA_R_DIRECT)) {
3705 device_printf(rdp->disks[disk].dev, "write metadata failed\n");
3714 /* VIA Tech V-RAID Metadata */
3716 ata_raid_via_read_meta(device_t dev, struct ar_softc **raidp)
3718 struct ata_raid_subdisk *ars = device_get_softc(dev);
3719 device_t parent = device_get_parent(dev);
3720 struct via_raid_conf *meta;
3721 struct ar_softc *raid = NULL;
3722 u_int8_t checksum, *ptr;
3723 int array, count, disk, retval = 0;
3725 if (!(meta = (struct via_raid_conf *)
3726 malloc(sizeof(struct via_raid_conf), M_AR, M_NOWAIT | M_ZERO)))
3729 if (ata_raid_rw(parent, VIA_LBA(parent),
3730 meta, sizeof(struct via_raid_conf), ATA_R_READ)) {
3731 if (testing || bootverbose)
3732 device_printf(parent, "VIA read metadata failed\n");
3736 /* check if this is a VIA RAID struct */
3737 if (meta->magic != VIA_MAGIC) {
3738 if (testing || bootverbose)
3739 device_printf(parent, "VIA check1 failed\n");
3743 /* calculate checksum and compare for valid */
3744 for (checksum = 0, ptr = (u_int8_t *)meta, count = 0; count < 50; count++)
3746 if (checksum != meta->checksum) {
3747 if (testing || bootverbose)
3748 device_printf(parent, "VIA check2 failed\n");
3752 if (testing || bootverbose)
3753 ata_raid_via_print_meta(meta);
3755 /* now convert VIA meta into our generic form */
3756 for (array = 0; array < MAX_ARRAYS; array++) {
3757 if (!raidp[array]) {
3759 (struct ar_softc *)malloc(sizeof(struct ar_softc), M_AR,
3761 if (!raidp[array]) {
3762 device_printf(parent, "failed to allocate metadata storage\n");
3766 raid = raidp[array];
3767 if (raid->format && (raid->format != AR_F_VIA_RAID))
3770 if (raid->format == AR_F_VIA_RAID && (raid->magic_0 != meta->disks[0]))
3773 switch (meta->type & VIA_T_MASK) {
3775 raid->type = AR_T_RAID0;
3776 raid->width = meta->stripe_layout & VIA_L_DISKS;
3777 if (!raid->total_sectors ||
3778 (raid->total_sectors > (raid->width * meta->disk_sectors)))
3779 raid->total_sectors = raid->width * meta->disk_sectors;
3783 raid->type = AR_T_RAID1;
3785 raid->total_sectors = meta->disk_sectors;
3789 raid->type = AR_T_RAID01;
3790 raid->width = meta->stripe_layout & VIA_L_DISKS;
3791 if (!raid->total_sectors ||
3792 (raid->total_sectors > (raid->width * meta->disk_sectors)))
3793 raid->total_sectors = raid->width * meta->disk_sectors;
3797 raid->type = AR_T_RAID5;
3798 raid->width = meta->stripe_layout & VIA_L_DISKS;
3799 if (!raid->total_sectors ||
3800 (raid->total_sectors > ((raid->width - 1)*meta->disk_sectors)))
3801 raid->total_sectors = (raid->width - 1) * meta->disk_sectors;
3805 raid->type = AR_T_SPAN;
3807 raid->total_sectors += meta->disk_sectors;
3811 device_printf(parent,"VIA unknown RAID type 0x%02x\n", meta->type);
3812 free(raidp[array], M_AR);
3813 raidp[array] = NULL;
3816 raid->magic_0 = meta->disks[0];
3817 raid->format = AR_F_VIA_RAID;
3818 raid->generation = 0;
3820 0x08 << ((meta->stripe_layout & VIA_L_MASK) >> VIA_L_SHIFT);
3821 for (count = 0, disk = 0; disk < 8; disk++)
3822 if (meta->disks[disk])
3824 raid->total_disks = count;
3827 raid->cylinders = raid->total_sectors / (63 * 255);
3828 raid->offset_sectors = 0;
3829 raid->rebuild_lba = 0;
3832 for (disk = 0; disk < raid->total_disks; disk++) {
3833 if (meta->disks[disk] == meta->disk_id) {
3834 raid->disks[disk].dev = parent;
3835 bcopy(&meta->disk_id, raid->disks[disk].serial,
3837 raid->disks[disk].sectors = meta->disk_sectors;
3838 raid->disks[disk].flags =
3839 (AR_DF_ONLINE | AR_DF_PRESENT | AR_DF_ASSIGNED);
3840 ars->raid[raid->volume] = raid;
3841 ars->disk_number[raid->volume] = disk;
3855 ata_raid_via_write_meta(struct ar_softc *rdp)
3857 struct via_raid_conf *meta;
3858 int disk, error = 0;
3860 if (!(meta = (struct via_raid_conf *)
3861 malloc(sizeof(struct via_raid_conf), M_AR, M_NOWAIT | M_ZERO))) {
3862 printf("ar%d: failed to allocate metadata storage\n", rdp->lun);
3868 meta->magic = VIA_MAGIC;
3869 meta->dummy_0 = 0x02;
3870 switch (rdp->type) {
3872 meta->type = VIA_T_SPAN;
3873 meta->stripe_layout = (rdp->total_disks & VIA_L_DISKS);
3877 meta->type = VIA_T_RAID0;
3878 meta->stripe_layout = ((rdp->interleave >> 1) & VIA_L_MASK);
3879 meta->stripe_layout |= (rdp->total_disks & VIA_L_DISKS);
3883 meta->type = VIA_T_RAID1;
3884 meta->stripe_layout = (rdp->total_disks & VIA_L_DISKS);
3888 meta->type = VIA_T_RAID5;
3889 meta->stripe_layout = ((rdp->interleave >> 1) & VIA_L_MASK);
3890 meta->stripe_layout |= (rdp->total_disks & VIA_L_DISKS);
3894 meta->type = VIA_T_RAID01;
3895 meta->stripe_layout = ((rdp->interleave >> 1) & VIA_L_MASK);
3896 meta->stripe_layout |= (rdp->width & VIA_L_DISKS);
3903 meta->type |= VIA_T_BOOTABLE; /* XXX SOS */
3904 meta->disk_sectors =
3905 rdp->total_sectors / (rdp->width - (rdp->type == AR_RAID5));
3906 for (disk = 0; disk < rdp->total_disks; disk++)
3907 meta->disks[disk] = (u_int32_t)(uintptr_t)rdp->disks[disk].dev;
3909 for (disk = 0; disk < rdp->total_disks; disk++) {
3910 if (rdp->disks[disk].dev) {
3914 meta->disk_index = disk * sizeof(u_int32_t);
3915 if (rdp->type == AR_T_RAID01)
3916 meta->disk_index = ((meta->disk_index & 0x08) << 2) |
3917 (meta->disk_index & ~0x08);
3918 meta->disk_id = meta->disks[disk];
3920 for (ptr = (u_int8_t *)meta, count = 0; count < 50; count++)
3921 meta->checksum += *ptr++;
3923 if (testing || bootverbose)
3924 ata_raid_via_print_meta(meta);
3926 if (ata_raid_rw(rdp->disks[disk].dev,
3927 VIA_LBA(rdp->disks[disk].dev),
3928 meta, sizeof(struct via_raid_conf),
3929 ATA_R_WRITE | ATA_R_DIRECT)) {
3930 device_printf(rdp->disks[disk].dev, "write metadata failed\n");
3939 static struct ata_request *
3940 ata_raid_init_request(struct ar_softc *rdp, struct bio *bio)
3942 struct ata_request *request;
3944 if (!(request = ata_alloc_request())) {
3945 printf("FAILURE - out of memory in ata_raid_init_request\n");
3948 request->timeout = 5;
3949 request->retries = 2;
3950 request->callback = ata_raid_done;
3951 request->driver = rdp;
3953 switch (request->bio->bio_cmd) {
3955 request->flags = ATA_R_READ;
3958 request->flags = ATA_R_WRITE;
3965 ata_raid_send_request(struct ata_request *request)
3967 struct ata_device *atadev = device_get_softc(request->dev);
3969 request->transfersize = min(request->bytecount, atadev->max_iosize);
3970 if (request->flags & ATA_R_READ) {
3971 if (atadev->mode >= ATA_DMA) {
3972 request->flags |= ATA_R_DMA;
3973 request->u.ata.command = ATA_READ_DMA;
3975 else if (atadev->max_iosize > DEV_BSIZE)
3976 request->u.ata.command = ATA_READ_MUL;
3978 request->u.ata.command = ATA_READ;
3980 else if (request->flags & ATA_R_WRITE) {
3981 if (atadev->mode >= ATA_DMA) {
3982 request->flags |= ATA_R_DMA;
3983 request->u.ata.command = ATA_WRITE_DMA;
3985 else if (atadev->max_iosize > DEV_BSIZE)
3986 request->u.ata.command = ATA_WRITE_MUL;
3988 request->u.ata.command = ATA_WRITE;
3991 device_printf(request->dev, "FAILURE - unknown IO operation\n");
3992 ata_free_request(request);
3995 request->flags |= (ATA_R_ORDERED | ATA_R_THREAD);
3996 ata_queue_request(request);
4001 ata_raid_rw(device_t dev, u_int64_t lba, void *data, u_int bcount, int flags)
4003 struct ata_device *atadev = device_get_softc(dev);
4004 struct ata_request *request;
4007 if (bcount % DEV_BSIZE) {
4008 device_printf(dev, "FAILURE - transfers must be modulo sectorsize\n");
4012 if (!(request = ata_alloc_request())) {
4013 device_printf(dev, "FAILURE - out of memory in ata_raid_rw\n");
4019 request->timeout = 10;
4020 request->retries = 0;
4021 request->data = data;
4022 request->bytecount = bcount;
4023 request->transfersize = DEV_BSIZE;
4024 request->u.ata.lba = lba;
4025 request->u.ata.count = request->bytecount / DEV_BSIZE;
4026 request->flags = flags;
4028 if (flags & ATA_R_READ) {
4029 if (atadev->mode >= ATA_DMA) {
4030 request->u.ata.command = ATA_READ_DMA;
4031 request->flags |= ATA_R_DMA;
4034 request->u.ata.command = ATA_READ;
4035 ata_queue_request(request);
4037 else if (flags & ATA_R_WRITE) {
4038 if (atadev->mode >= ATA_DMA) {
4039 request->u.ata.command = ATA_WRITE_DMA;
4040 request->flags |= ATA_R_DMA;
4043 request->u.ata.command = ATA_WRITE;
4044 ata_queue_request(request);
4047 device_printf(dev, "FAILURE - unknown IO operation\n");
4048 request->result = EIO;
4050 error = request->result;
4051 ata_free_request(request);
4059 ata_raid_subdisk_probe(device_t dev)
4066 ata_raid_subdisk_attach(device_t dev)
4068 struct ata_raid_subdisk *ars = device_get_softc(dev);
4071 for (volume = 0; volume < MAX_VOLUMES; volume++) {
4072 ars->raid[volume] = NULL;
4073 ars->disk_number[volume] = -1;
4075 ata_raid_read_metadata(dev);
4080 ata_raid_subdisk_detach(device_t dev)
4082 struct ata_raid_subdisk *ars = device_get_softc(dev);
4085 for (volume = 0; volume < MAX_VOLUMES; volume++) {
4086 if (ars->raid[volume]) {
4087 ars->raid[volume]->disks[ars->disk_number[volume]].flags &=
4088 ~(AR_DF_PRESENT | AR_DF_ONLINE);
4089 ars->raid[volume]->disks[ars->disk_number[volume]].dev = NULL;
4090 ata_raid_config_changed(ars->raid[volume], 1);
4091 ars->raid[volume] = NULL;
4092 ars->disk_number[volume] = -1;
4098 static device_method_t ata_raid_sub_methods[] = {
4099 /* device interface */
4100 DEVMETHOD(device_probe, ata_raid_subdisk_probe),
4101 DEVMETHOD(device_attach, ata_raid_subdisk_attach),
4102 DEVMETHOD(device_detach, ata_raid_subdisk_detach),
4106 static driver_t ata_raid_sub_driver = {
4108 ata_raid_sub_methods,
4109 sizeof(struct ata_raid_subdisk)
4112 DRIVER_MODULE(subdisk, ad, ata_raid_sub_driver, ata_raid_sub_devclass, NULL, NULL);
4115 ata_raid_module_event_handler(module_t mod, int what, void *arg)
4121 if (testing || bootverbose)
4122 printf("ATA PseudoRAID loaded\n");
4124 /* setup table to hold metadata for all ATA PseudoRAID arrays */
4125 ata_raid_arrays = malloc(sizeof(struct ar_soft *) * MAX_ARRAYS,
4126 M_AR, M_NOWAIT | M_ZERO);
4127 if (!ata_raid_arrays) {
4128 printf("ataraid: no memory for metadata storage\n");
4132 /* attach found PseudoRAID arrays */
4133 for (i = 0; i < MAX_ARRAYS; i++) {
4134 struct ar_softc *rdp = ata_raid_arrays[i];
4136 if (!rdp || !rdp->format)
4138 if (testing || bootverbose)
4139 ata_raid_print_meta(rdp);
4140 ata_raid_attach(rdp, 0);
4142 ata_raid_ioctl_func = ata_raid_ioctl;
4146 /* detach found PseudoRAID arrays */
4147 for (i = 0; i < MAX_ARRAYS; i++) {
4148 struct ar_softc *rdp = ata_raid_arrays[i];
4150 if (!rdp || !rdp->status)
4153 disk_destroy(rdp->disk);
4155 if (testing || bootverbose)
4156 printf("ATA PseudoRAID unloaded\n");
4158 free(ata_raid_arrays, M_AR);
4160 ata_raid_ioctl_func = NULL;
4168 static moduledata_t ata_raid_moduledata =
4169 { "ataraid", ata_raid_module_event_handler, NULL };
4170 DECLARE_MODULE(ata, ata_raid_moduledata, SI_SUB_RAID, SI_ORDER_FIRST);
4171 MODULE_VERSION(ataraid, 1);
4172 MODULE_DEPEND(ataraid, ata, 1, 1, 1);
4173 MODULE_DEPEND(ataraid, ad, 1, 1, 1);
4176 ata_raid_format(struct ar_softc *rdp)
4178 switch (rdp->format) {
4179 case AR_F_FREEBSD_RAID: return "FreeBSD PseudoRAID";
4180 case AR_F_ADAPTEC_RAID: return "Adaptec HostRAID";
4181 case AR_F_HPTV2_RAID: return "HighPoint v2 RocketRAID";
4182 case AR_F_HPTV3_RAID: return "HighPoint v3 RocketRAID";
4183 case AR_F_INTEL_RAID: return "Intel MatrixRAID";
4184 case AR_F_ITE_RAID: return "Integrated Technology Express";
4185 case AR_F_JMICRON_RAID: return "JMicron Technology Corp";
4186 case AR_F_LSIV2_RAID: return "LSILogic v2 MegaRAID";
4187 case AR_F_LSIV3_RAID: return "LSILogic v3 MegaRAID";
4188 case AR_F_NVIDIA_RAID: return "nVidia MediaShield";
4189 case AR_F_PROMISE_RAID: return "Promise Fasttrak";
4190 case AR_F_SII_RAID: return "Silicon Image Medley";
4191 case AR_F_SIS_RAID: return "Silicon Integrated Systems";
4192 case AR_F_VIA_RAID: return "VIA Tech V-RAID";
4193 default: return "UNKNOWN";
4198 ata_raid_type(struct ar_softc *rdp)
4200 switch (rdp->type) {
4201 case AR_T_JBOD: return "JBOD";
4202 case AR_T_SPAN: return "SPAN";
4203 case AR_T_RAID0: return "RAID0";
4204 case AR_T_RAID1: return "RAID1";
4205 case AR_T_RAID3: return "RAID3";
4206 case AR_T_RAID4: return "RAID4";
4207 case AR_T_RAID5: return "RAID5";
4208 case AR_T_RAID01: return "RAID0+1";
4209 default: return "UNKNOWN";
4214 ata_raid_flags(struct ar_softc *rdp)
4216 switch (rdp->status & (AR_S_READY | AR_S_DEGRADED | AR_S_REBUILDING)) {
4217 case AR_S_READY: return "READY";
4218 case AR_S_READY | AR_S_DEGRADED: return "DEGRADED";
4219 case AR_S_READY | AR_S_REBUILDING:
4220 case AR_S_READY | AR_S_DEGRADED | AR_S_REBUILDING: return "REBUILDING";
4221 default: return "BROKEN";
4225 /* debugging gunk */
4227 ata_raid_print_meta(struct ar_softc *raid)
4231 printf("********** ATA PseudoRAID ar%d Metadata **********\n", raid->lun);
4232 printf("=================================================\n");
4233 printf("format %s\n", ata_raid_format(raid));
4234 printf("type %s\n", ata_raid_type(raid));
4235 printf("flags 0x%02x %b\n", raid->status, raid->status,
4236 "\20\3REBUILDING\2DEGRADED\1READY\n");
4237 printf("magic_0 0x%016llx\n",(unsigned long long)raid->magic_0);
4238 printf("magic_1 0x%016llx\n",(unsigned long long)raid->magic_1);
4239 printf("generation %u\n", raid->generation);
4240 printf("total_sectors %llu\n",
4241 (unsigned long long)raid->total_sectors);
4242 printf("offset_sectors %llu\n",
4243 (unsigned long long)raid->offset_sectors);
4244 printf("heads %u\n", raid->heads);
4245 printf("sectors %u\n", raid->sectors);
4246 printf("cylinders %u\n", raid->cylinders);
4247 printf("width %u\n", raid->width);
4248 printf("interleave %u\n", raid->interleave);
4249 printf("total_disks %u\n", raid->total_disks);
4250 for (i = 0; i < raid->total_disks; i++) {
4251 printf(" disk %d: flags = 0x%02x %b\n", i, raid->disks[i].flags,
4252 raid->disks[i].flags, "\20\4ONLINE\3SPARE\2ASSIGNED\1PRESENT\n");
4253 if (raid->disks[i].dev) {
4255 device_printf(raid->disks[i].dev, " sectors %lld\n",
4256 (long long)raid->disks[i].sectors);
4259 printf("=================================================\n");
4263 ata_raid_adaptec_type(int type)
4265 static char buffer[16];
4268 case ADP_T_RAID0: return "RAID0";
4269 case ADP_T_RAID1: return "RAID1";
4270 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4276 ata_raid_adaptec_print_meta(struct adaptec_raid_conf *meta)
4280 printf("********* ATA Adaptec HostRAID Metadata *********\n");
4281 printf("magic_0 <0x%08x>\n", be32toh(meta->magic_0));
4282 printf("generation 0x%08x\n", be32toh(meta->generation));
4283 printf("dummy_0 0x%04x\n", be16toh(meta->dummy_0));
4284 printf("total_configs %u\n", be16toh(meta->total_configs));
4285 printf("dummy_1 0x%04x\n", be16toh(meta->dummy_1));
4286 printf("checksum 0x%04x\n", be16toh(meta->checksum));
4287 printf("dummy_2 0x%08x\n", be32toh(meta->dummy_2));
4288 printf("dummy_3 0x%08x\n", be32toh(meta->dummy_3));
4289 printf("flags 0x%08x\n", be32toh(meta->flags));
4290 printf("timestamp 0x%08x\n", be32toh(meta->timestamp));
4291 printf("dummy_4 0x%08x 0x%08x 0x%08x 0x%08x\n",
4292 be32toh(meta->dummy_4[0]), be32toh(meta->dummy_4[1]),
4293 be32toh(meta->dummy_4[2]), be32toh(meta->dummy_4[3]));
4294 printf("dummy_5 0x%08x 0x%08x 0x%08x 0x%08x\n",
4295 be32toh(meta->dummy_5[0]), be32toh(meta->dummy_5[1]),
4296 be32toh(meta->dummy_5[2]), be32toh(meta->dummy_5[3]));
4298 for (i = 0; i < be16toh(meta->total_configs); i++) {
4299 printf(" %d total_disks %u\n", i,
4300 be16toh(meta->configs[i].disk_number));
4301 printf(" %d generation %u\n", i,
4302 be16toh(meta->configs[i].generation));
4303 printf(" %d magic_0 0x%08x\n", i,
4304 be32toh(meta->configs[i].magic_0));
4305 printf(" %d dummy_0 0x%02x\n", i, meta->configs[i].dummy_0);
4306 printf(" %d type %s\n", i,
4307 ata_raid_adaptec_type(meta->configs[i].type));
4308 printf(" %d dummy_1 0x%02x\n", i, meta->configs[i].dummy_1);
4309 printf(" %d flags %d\n", i,
4310 be32toh(meta->configs[i].flags));
4311 printf(" %d dummy_2 0x%02x\n", i, meta->configs[i].dummy_2);
4312 printf(" %d dummy_3 0x%02x\n", i, meta->configs[i].dummy_3);
4313 printf(" %d dummy_4 0x%02x\n", i, meta->configs[i].dummy_4);
4314 printf(" %d dummy_5 0x%02x\n", i, meta->configs[i].dummy_5);
4315 printf(" %d disk_number %u\n", i,
4316 be32toh(meta->configs[i].disk_number));
4317 printf(" %d dummy_6 0x%08x\n", i,
4318 be32toh(meta->configs[i].dummy_6));
4319 printf(" %d sectors %u\n", i,
4320 be32toh(meta->configs[i].sectors));
4321 printf(" %d stripe_shift %u\n", i,
4322 be16toh(meta->configs[i].stripe_shift));
4323 printf(" %d dummy_7 0x%08x\n", i,
4324 be32toh(meta->configs[i].dummy_7));
4325 printf(" %d dummy_8 0x%08x 0x%08x 0x%08x 0x%08x\n", i,
4326 be32toh(meta->configs[i].dummy_8[0]),
4327 be32toh(meta->configs[i].dummy_8[1]),
4328 be32toh(meta->configs[i].dummy_8[2]),
4329 be32toh(meta->configs[i].dummy_8[3]));
4330 printf(" %d name <%s>\n", i, meta->configs[i].name);
4332 printf("magic_1 <0x%08x>\n", be32toh(meta->magic_1));
4333 printf("magic_2 <0x%08x>\n", be32toh(meta->magic_2));
4334 printf("magic_3 <0x%08x>\n", be32toh(meta->magic_3));
4335 printf("magic_4 <0x%08x>\n", be32toh(meta->magic_4));
4336 printf("=================================================\n");
4340 ata_raid_hptv2_type(int type)
4342 static char buffer[16];
4345 case HPTV2_T_RAID0: return "RAID0";
4346 case HPTV2_T_RAID1: return "RAID1";
4347 case HPTV2_T_RAID01_RAID0: return "RAID01_RAID0";
4348 case HPTV2_T_SPAN: return "SPAN";
4349 case HPTV2_T_RAID_3: return "RAID3";
4350 case HPTV2_T_RAID_5: return "RAID5";
4351 case HPTV2_T_JBOD: return "JBOD";
4352 case HPTV2_T_RAID01_RAID1: return "RAID01_RAID1";
4353 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4359 ata_raid_hptv2_print_meta(struct hptv2_raid_conf *meta)
4363 printf("****** ATA Highpoint V2 RocketRAID Metadata *****\n");
4364 printf("magic 0x%08x\n", meta->magic);
4365 printf("magic_0 0x%08x\n", meta->magic_0);
4366 printf("magic_1 0x%08x\n", meta->magic_1);
4367 printf("order 0x%08x\n", meta->order);
4368 printf("array_width %u\n", meta->array_width);
4369 printf("stripe_shift %u\n", meta->stripe_shift);
4370 printf("type %s\n", ata_raid_hptv2_type(meta->type));
4371 printf("disk_number %u\n", meta->disk_number);
4372 printf("total_sectors %u\n", meta->total_sectors);
4373 printf("disk_mode 0x%08x\n", meta->disk_mode);
4374 printf("boot_mode 0x%08x\n", meta->boot_mode);
4375 printf("boot_disk 0x%02x\n", meta->boot_disk);
4376 printf("boot_protect 0x%02x\n", meta->boot_protect);
4377 printf("log_entries 0x%02x\n", meta->error_log_entries);
4378 printf("log_index 0x%02x\n", meta->error_log_index);
4379 if (meta->error_log_entries) {
4380 printf(" timestamp reason disk status sectors lba\n");
4381 for (i = meta->error_log_index;
4382 i < meta->error_log_index + meta->error_log_entries; i++)
4383 printf(" 0x%08x 0x%02x 0x%02x 0x%02x 0x%02x 0x%08x\n",
4384 meta->errorlog[i%32].timestamp,
4385 meta->errorlog[i%32].reason,
4386 meta->errorlog[i%32].disk, meta->errorlog[i%32].status,
4387 meta->errorlog[i%32].sectors, meta->errorlog[i%32].lba);
4389 printf("rebuild_lba 0x%08x\n", meta->rebuild_lba);
4390 printf("dummy_1 0x%02x\n", meta->dummy_1);
4391 printf("name_1 <%.15s>\n", meta->name_1);
4392 printf("dummy_2 0x%02x\n", meta->dummy_2);
4393 printf("name_2 <%.15s>\n", meta->name_2);
4394 printf("=================================================\n");
4398 ata_raid_hptv3_type(int type)
4400 static char buffer[16];
4403 case HPTV3_T_SPARE: return "SPARE";
4404 case HPTV3_T_JBOD: return "JBOD";
4405 case HPTV3_T_SPAN: return "SPAN";
4406 case HPTV3_T_RAID0: return "RAID0";
4407 case HPTV3_T_RAID1: return "RAID1";
4408 case HPTV3_T_RAID3: return "RAID3";
4409 case HPTV3_T_RAID5: return "RAID5";
4410 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4416 ata_raid_hptv3_print_meta(struct hptv3_raid_conf *meta)
4420 printf("****** ATA Highpoint V3 RocketRAID Metadata *****\n");
4421 printf("magic 0x%08x\n", meta->magic);
4422 printf("magic_0 0x%08x\n", meta->magic_0);
4423 printf("checksum_0 0x%02x\n", meta->checksum_0);
4424 printf("mode 0x%02x\n", meta->mode);
4425 printf("user_mode 0x%02x\n", meta->user_mode);
4426 printf("config_entries 0x%02x\n", meta->config_entries);
4427 for (i = 0; i < meta->config_entries; i++) {
4428 printf("config %d:\n", i);
4429 printf(" total_sectors %llu\n",
4430 (unsigned long long)(meta->configs[0].total_sectors +
4431 ((u_int64_t)meta->configs_high[0].total_sectors << 32)));
4432 printf(" type %s\n",
4433 ata_raid_hptv3_type(meta->configs[i].type));
4434 printf(" total_disks %u\n", meta->configs[i].total_disks);
4435 printf(" disk_number %u\n", meta->configs[i].disk_number);
4436 printf(" stripe_shift %u\n", meta->configs[i].stripe_shift);
4437 printf(" status %b\n", meta->configs[i].status,
4438 "\20\2RAID5\1NEED_REBUILD\n");
4439 printf(" critical_disks %u\n", meta->configs[i].critical_disks);
4440 printf(" rebuild_lba %llu\n",
4441 (unsigned long long)(meta->configs_high[0].rebuild_lba +
4442 ((u_int64_t)meta->configs_high[0].rebuild_lba << 32)));
4444 printf("name <%.16s>\n", meta->name);
4445 printf("timestamp 0x%08x\n", meta->timestamp);
4446 printf("description <%.16s>\n", meta->description);
4447 printf("creator <%.16s>\n", meta->creator);
4448 printf("checksum_1 0x%02x\n", meta->checksum_1);
4449 printf("dummy_0 0x%02x\n", meta->dummy_0);
4450 printf("dummy_1 0x%02x\n", meta->dummy_1);
4451 printf("flags %b\n", meta->flags,
4452 "\20\4RCACHE\3WCACHE\2NCQ\1TCQ\n");
4453 printf("=================================================\n");
4457 ata_raid_intel_type(int type)
4459 static char buffer[16];
4462 case INTEL_T_RAID0: return "RAID0";
4463 case INTEL_T_RAID1: return "RAID1";
4464 case INTEL_T_RAID5: return "RAID5";
4465 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4471 ata_raid_intel_print_meta(struct intel_raid_conf *meta)
4473 struct intel_raid_mapping *map;
4476 printf("********* ATA Intel MatrixRAID Metadata *********\n");
4477 printf("intel_id <%.24s>\n", meta->intel_id);
4478 printf("version <%.6s>\n", meta->version);
4479 printf("checksum 0x%08x\n", meta->checksum);
4480 printf("config_size 0x%08x\n", meta->config_size);
4481 printf("config_id 0x%08x\n", meta->config_id);
4482 printf("generation 0x%08x\n", meta->generation);
4483 printf("total_disks %u\n", meta->total_disks);
4484 printf("total_volumes %u\n", meta->total_volumes);
4485 printf("DISK# serial disk_sectors disk_id flags\n");
4486 for (i = 0; i < meta->total_disks; i++ ) {
4487 printf(" %d <%.16s> %u 0x%08x 0x%08x\n", i,
4488 meta->disk[i].serial, meta->disk[i].sectors,
4489 meta->disk[i].id, meta->disk[i].flags);
4491 map = (struct intel_raid_mapping *)&meta->disk[meta->total_disks];
4492 for (j = 0; j < meta->total_volumes; j++) {
4493 printf("name %.16s\n", map->name);
4494 printf("total_sectors %llu\n",
4495 (unsigned long long)map->total_sectors);
4496 printf("state %u\n", map->state);
4497 printf("reserved %u\n", map->reserved);
4498 printf("offset %u\n", map->offset);
4499 printf("disk_sectors %u\n", map->disk_sectors);
4500 printf("stripe_count %u\n", map->stripe_count);
4501 printf("stripe_sectors %u\n", map->stripe_sectors);
4502 printf("status %u\n", map->status);
4503 printf("type %s\n", ata_raid_intel_type(map->type));
4504 printf("total_disks %u\n", map->total_disks);
4505 printf("magic[0] 0x%02x\n", map->magic[0]);
4506 printf("magic[1] 0x%02x\n", map->magic[1]);
4507 printf("magic[2] 0x%02x\n", map->magic[2]);
4508 for (i = 0; i < map->total_disks; i++ ) {
4509 printf(" disk %d at disk_idx 0x%08x\n", i, map->disk_idx[i]);
4511 map = (struct intel_raid_mapping *)&map->disk_idx[map->total_disks];
4513 printf("=================================================\n");
4517 ata_raid_ite_type(int type)
4519 static char buffer[16];
4522 case ITE_T_RAID0: return "RAID0";
4523 case ITE_T_RAID1: return "RAID1";
4524 case ITE_T_RAID01: return "RAID0+1";
4525 case ITE_T_SPAN: return "SPAN";
4526 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4532 ata_raid_ite_print_meta(struct ite_raid_conf *meta)
4534 printf("*** ATA Integrated Technology Express Metadata **\n");
4535 printf("ite_id <%.40s>\n", meta->ite_id);
4536 printf("timestamp_0 %04x/%02x/%02x %02x:%02x:%02x.%02x\n",
4537 *((u_int16_t *)meta->timestamp_0), meta->timestamp_0[2],
4538 meta->timestamp_0[3], meta->timestamp_0[5], meta->timestamp_0[4],
4539 meta->timestamp_0[7], meta->timestamp_0[6]);
4540 printf("total_sectors %lld\n",
4541 (unsigned long long)meta->total_sectors);
4542 printf("type %s\n", ata_raid_ite_type(meta->type));
4543 printf("stripe_1kblocks %u\n", meta->stripe_1kblocks);
4544 printf("timestamp_1 %04x/%02x/%02x %02x:%02x:%02x.%02x\n",
4545 *((u_int16_t *)meta->timestamp_1), meta->timestamp_1[2],
4546 meta->timestamp_1[3], meta->timestamp_1[5], meta->timestamp_1[4],
4547 meta->timestamp_1[7], meta->timestamp_1[6]);
4548 printf("stripe_sectors %u\n", meta->stripe_sectors);
4549 printf("array_width %u\n", meta->array_width);
4550 printf("disk_number %u\n", meta->disk_number);
4551 printf("disk_sectors %u\n", meta->disk_sectors);
4552 printf("=================================================\n");
4556 ata_raid_jmicron_type(int type)
4558 static char buffer[16];
4561 case JM_T_RAID0: return "RAID0";
4562 case JM_T_RAID1: return "RAID1";
4563 case JM_T_RAID01: return "RAID0+1";
4564 case JM_T_JBOD: return "JBOD";
4565 case JM_T_RAID5: return "RAID5";
4566 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4572 ata_raid_jmicron_print_meta(struct jmicron_raid_conf *meta)
4576 printf("***** ATA JMicron Technology Corp Metadata ******\n");
4577 printf("signature %.2s\n", meta->signature);
4578 printf("version 0x%04x\n", meta->version);
4579 printf("checksum 0x%04x\n", meta->checksum);
4580 printf("disk_id 0x%08x\n", meta->disk_id);
4581 printf("offset 0x%08x\n", meta->offset);
4582 printf("disk_sectors_low 0x%08x\n", meta->disk_sectors_low);
4583 printf("disk_sectors_high 0x%08x\n", meta->disk_sectors_high);
4584 printf("name %.16s\n", meta->name);
4585 printf("type %s\n", ata_raid_jmicron_type(meta->type));
4586 printf("stripe_shift %d\n", meta->stripe_shift);
4587 printf("flags 0x%04x\n", meta->flags);
4589 for (i=0; i < 2 && meta->spare[i]; i++)
4590 printf(" %d 0x%08x\n", i, meta->spare[i]);
4592 for (i=0; i < 8 && meta->disks[i]; i++)
4593 printf(" %d 0x%08x\n", i, meta->disks[i]);
4594 printf("=================================================\n");
4598 ata_raid_lsiv2_type(int type)
4600 static char buffer[16];
4603 case LSIV2_T_RAID0: return "RAID0";
4604 case LSIV2_T_RAID1: return "RAID1";
4605 case LSIV2_T_SPARE: return "SPARE";
4606 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4612 ata_raid_lsiv2_print_meta(struct lsiv2_raid_conf *meta)
4616 printf("******* ATA LSILogic V2 MegaRAID Metadata *******\n");
4617 printf("lsi_id <%s>\n", meta->lsi_id);
4618 printf("dummy_0 0x%02x\n", meta->dummy_0);
4619 printf("flags 0x%02x\n", meta->flags);
4620 printf("version 0x%04x\n", meta->version);
4621 printf("config_entries 0x%02x\n", meta->config_entries);
4622 printf("raid_count 0x%02x\n", meta->raid_count);
4623 printf("total_disks 0x%02x\n", meta->total_disks);
4624 printf("dummy_1 0x%02x\n", meta->dummy_1);
4625 printf("dummy_2 0x%04x\n", meta->dummy_2);
4626 for (i = 0; i < meta->config_entries; i++) {
4627 printf(" type %s\n",
4628 ata_raid_lsiv2_type(meta->configs[i].raid.type));
4629 printf(" dummy_0 %02x\n", meta->configs[i].raid.dummy_0);
4630 printf(" stripe_sectors %u\n",
4631 meta->configs[i].raid.stripe_sectors);
4632 printf(" array_width %u\n",
4633 meta->configs[i].raid.array_width);
4634 printf(" disk_count %u\n", meta->configs[i].raid.disk_count);
4635 printf(" config_offset %u\n",
4636 meta->configs[i].raid.config_offset);
4637 printf(" dummy_1 %u\n", meta->configs[i].raid.dummy_1);
4638 printf(" flags %02x\n", meta->configs[i].raid.flags);
4639 printf(" total_sectors %u\n",
4640 meta->configs[i].raid.total_sectors);
4642 printf("disk_number 0x%02x\n", meta->disk_number);
4643 printf("raid_number 0x%02x\n", meta->raid_number);
4644 printf("timestamp 0x%08x\n", meta->timestamp);
4645 printf("=================================================\n");
4649 ata_raid_lsiv3_type(int type)
4651 static char buffer[16];
4654 case LSIV3_T_RAID0: return "RAID0";
4655 case LSIV3_T_RAID1: return "RAID1";
4656 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4662 ata_raid_lsiv3_print_meta(struct lsiv3_raid_conf *meta)
4666 printf("******* ATA LSILogic V3 MegaRAID Metadata *******\n");
4667 printf("lsi_id <%.6s>\n", meta->lsi_id);
4668 printf("dummy_0 0x%04x\n", meta->dummy_0);
4669 printf("version 0x%04x\n", meta->version);
4670 printf("dummy_0 0x%04x\n", meta->dummy_1);
4671 printf("RAID configs:\n");
4672 for (i = 0; i < 8; i++) {
4673 if (meta->raid[i].total_disks) {
4674 printf("%02d stripe_pages %u\n", i,
4675 meta->raid[i].stripe_pages);
4676 printf("%02d type %s\n", i,
4677 ata_raid_lsiv3_type(meta->raid[i].type));
4678 printf("%02d total_disks %u\n", i,
4679 meta->raid[i].total_disks);
4680 printf("%02d array_width %u\n", i,
4681 meta->raid[i].array_width);
4682 printf("%02d sectors %u\n", i, meta->raid[i].sectors);
4683 printf("%02d offset %u\n", i, meta->raid[i].offset);
4684 printf("%02d device 0x%02x\n", i,
4685 meta->raid[i].device);
4688 printf("DISK configs:\n");
4689 for (i = 0; i < 6; i++) {
4690 if (meta->disk[i].disk_sectors) {
4691 printf("%02d disk_sectors %u\n", i,
4692 meta->disk[i].disk_sectors);
4693 printf("%02d flags 0x%02x\n", i, meta->disk[i].flags);
4696 printf("device 0x%02x\n", meta->device);
4697 printf("timestamp 0x%08x\n", meta->timestamp);
4698 printf("checksum_1 0x%02x\n", meta->checksum_1);
4699 printf("=================================================\n");
4703 ata_raid_nvidia_type(int type)
4705 static char buffer[16];
4708 case NV_T_SPAN: return "SPAN";
4709 case NV_T_RAID0: return "RAID0";
4710 case NV_T_RAID1: return "RAID1";
4711 case NV_T_RAID3: return "RAID3";
4712 case NV_T_RAID5: return "RAID5";
4713 case NV_T_RAID01: return "RAID0+1";
4714 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4720 ata_raid_nvidia_print_meta(struct nvidia_raid_conf *meta)
4722 printf("******** ATA nVidia MediaShield Metadata ********\n");
4723 printf("nvidia_id <%.8s>\n", meta->nvidia_id);
4724 printf("config_size %d\n", meta->config_size);
4725 printf("checksum 0x%08x\n", meta->checksum);
4726 printf("version 0x%04x\n", meta->version);
4727 printf("disk_number %d\n", meta->disk_number);
4728 printf("dummy_0 0x%02x\n", meta->dummy_0);
4729 printf("total_sectors %d\n", meta->total_sectors);
4730 printf("sectors_size %d\n", meta->sector_size);
4731 printf("serial %.16s\n", meta->serial);
4732 printf("revision %.4s\n", meta->revision);
4733 printf("dummy_1 0x%08x\n", meta->dummy_1);
4734 printf("magic_0 0x%08x\n", meta->magic_0);
4735 printf("magic_1 0x%016llx\n",(unsigned long long)meta->magic_1);
4736 printf("magic_2 0x%016llx\n",(unsigned long long)meta->magic_2);
4737 printf("flags 0x%02x\n", meta->flags);
4738 printf("array_width %d\n", meta->array_width);
4739 printf("total_disks %d\n", meta->total_disks);
4740 printf("dummy_2 0x%02x\n", meta->dummy_2);
4741 printf("type %s\n", ata_raid_nvidia_type(meta->type));
4742 printf("dummy_3 0x%04x\n", meta->dummy_3);
4743 printf("stripe_sectors %d\n", meta->stripe_sectors);
4744 printf("stripe_bytes %d\n", meta->stripe_bytes);
4745 printf("stripe_shift %d\n", meta->stripe_shift);
4746 printf("stripe_mask 0x%08x\n", meta->stripe_mask);
4747 printf("stripe_sizesectors %d\n", meta->stripe_sizesectors);
4748 printf("stripe_sizebytes %d\n", meta->stripe_sizebytes);
4749 printf("rebuild_lba %d\n", meta->rebuild_lba);
4750 printf("dummy_4 0x%08x\n", meta->dummy_4);
4751 printf("dummy_5 0x%08x\n", meta->dummy_5);
4752 printf("status 0x%08x\n", meta->status);
4753 printf("=================================================\n");
4757 ata_raid_promise_type(int type)
4759 static char buffer[16];
4762 case PR_T_RAID0: return "RAID0";
4763 case PR_T_RAID1: return "RAID1";
4764 case PR_T_RAID3: return "RAID3";
4765 case PR_T_RAID5: return "RAID5";
4766 case PR_T_SPAN: return "SPAN";
4767 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4773 ata_raid_promise_print_meta(struct promise_raid_conf *meta)
4777 printf("********* ATA Promise FastTrak Metadata *********\n");
4778 printf("promise_id <%s>\n", meta->promise_id);
4779 printf("dummy_0 0x%08x\n", meta->dummy_0);
4780 printf("magic_0 0x%016llx\n",(unsigned long long)meta->magic_0);
4781 printf("magic_1 0x%04x\n", meta->magic_1);
4782 printf("magic_2 0x%08x\n", meta->magic_2);
4783 printf("integrity 0x%08x %b\n", meta->raid.integrity,
4784 meta->raid.integrity, "\20\10VALID\n" );
4785 printf("flags 0x%02x %b\n",
4786 meta->raid.flags, meta->raid.flags,
4787 "\20\10READY\7DOWN\6REDIR\5DUPLICATE\4SPARE"
4788 "\3ASSIGNED\2ONLINE\1VALID\n");
4789 printf("disk_number %d\n", meta->raid.disk_number);
4790 printf("channel 0x%02x\n", meta->raid.channel);
4791 printf("device 0x%02x\n", meta->raid.device);
4792 printf("magic_0 0x%016llx\n",
4793 (unsigned long long)meta->raid.magic_0);
4794 printf("disk_offset %u\n", meta->raid.disk_offset);
4795 printf("disk_sectors %u\n", meta->raid.disk_sectors);
4796 printf("rebuild_lba 0x%08x\n", meta->raid.rebuild_lba);
4797 printf("generation 0x%04x\n", meta->raid.generation);
4798 printf("status 0x%02x %b\n",
4799 meta->raid.status, meta->raid.status,
4800 "\20\6MARKED\5DEGRADED\4READY\3INITED\2ONLINE\1VALID\n");
4801 printf("type %s\n", ata_raid_promise_type(meta->raid.type));
4802 printf("total_disks %u\n", meta->raid.total_disks);
4803 printf("stripe_shift %u\n", meta->raid.stripe_shift);
4804 printf("array_width %u\n", meta->raid.array_width);
4805 printf("array_number %u\n", meta->raid.array_number);
4806 printf("total_sectors %u\n", meta->raid.total_sectors);
4807 printf("cylinders %u\n", meta->raid.cylinders);
4808 printf("heads %u\n", meta->raid.heads);
4809 printf("sectors %u\n", meta->raid.sectors);
4810 printf("magic_1 0x%016llx\n",
4811 (unsigned long long)meta->raid.magic_1);
4812 printf("DISK# flags dummy_0 channel device magic_0\n");
4813 for (i = 0; i < 8; i++) {
4814 printf(" %d %b 0x%02x 0x%02x 0x%02x ",
4815 i, meta->raid.disk[i].flags,
4816 "\20\10READY\7DOWN\6REDIR\5DUPLICATE\4SPARE"
4817 "\3ASSIGNED\2ONLINE\1VALID\n", meta->raid.disk[i].dummy_0,
4818 meta->raid.disk[i].channel, meta->raid.disk[i].device);
4819 printf("0x%016llx\n",
4820 (unsigned long long)meta->raid.disk[i].magic_0);
4822 printf("checksum 0x%08x\n", meta->checksum);
4823 printf("=================================================\n");
4827 ata_raid_sii_type(int type)
4829 static char buffer[16];
4832 case SII_T_RAID0: return "RAID0";
4833 case SII_T_RAID1: return "RAID1";
4834 case SII_T_RAID01: return "RAID0+1";
4835 case SII_T_SPARE: return "SPARE";
4836 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4842 ata_raid_sii_print_meta(struct sii_raid_conf *meta)
4844 printf("******* ATA Silicon Image Medley Metadata *******\n");
4845 printf("total_sectors %llu\n",
4846 (unsigned long long)meta->total_sectors);
4847 printf("dummy_0 0x%04x\n", meta->dummy_0);
4848 printf("dummy_1 0x%04x\n", meta->dummy_1);
4849 printf("controller_pci_id 0x%08x\n", meta->controller_pci_id);
4850 printf("version_minor 0x%04x\n", meta->version_minor);
4851 printf("version_major 0x%04x\n", meta->version_major);
4852 printf("timestamp 20%02x/%02x/%02x %02x:%02x:%02x\n",
4853 meta->timestamp[5], meta->timestamp[4], meta->timestamp[3],
4854 meta->timestamp[2], meta->timestamp[1], meta->timestamp[0]);
4855 printf("stripe_sectors %u\n", meta->stripe_sectors);
4856 printf("dummy_2 0x%04x\n", meta->dummy_2);
4857 printf("disk_number %u\n", meta->disk_number);
4858 printf("type %s\n", ata_raid_sii_type(meta->type));
4859 printf("raid0_disks %u\n", meta->raid0_disks);
4860 printf("raid0_ident %u\n", meta->raid0_ident);
4861 printf("raid1_disks %u\n", meta->raid1_disks);
4862 printf("raid1_ident %u\n", meta->raid1_ident);
4863 printf("rebuild_lba %llu\n", (unsigned long long)meta->rebuild_lba);
4864 printf("generation 0x%08x\n", meta->generation);
4865 printf("status 0x%02x %b\n",
4866 meta->status, meta->status,
4868 printf("base_raid1_position %02x\n", meta->base_raid1_position);
4869 printf("base_raid0_position %02x\n", meta->base_raid0_position);
4870 printf("position %02x\n", meta->position);
4871 printf("dummy_3 %04x\n", meta->dummy_3);
4872 printf("name <%.16s>\n", meta->name);
4873 printf("checksum_0 0x%04x\n", meta->checksum_0);
4874 printf("checksum_1 0x%04x\n", meta->checksum_1);
4875 printf("=================================================\n");
4879 ata_raid_sis_type(int type)
4881 static char buffer[16];
4884 case SIS_T_JBOD: return "JBOD";
4885 case SIS_T_RAID0: return "RAID0";
4886 case SIS_T_RAID1: return "RAID1";
4887 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4893 ata_raid_sis_print_meta(struct sis_raid_conf *meta)
4895 printf("**** ATA Silicon Integrated Systems Metadata ****\n");
4896 printf("magic 0x%04x\n", meta->magic);
4897 printf("disks 0x%02x\n", meta->disks);
4899 ata_raid_sis_type(meta->type_total_disks & SIS_T_MASK));
4900 printf("total_disks %u\n", meta->type_total_disks & SIS_D_MASK);
4901 printf("dummy_0 0x%08x\n", meta->dummy_0);
4902 printf("controller_pci_id 0x%08x\n", meta->controller_pci_id);
4903 printf("stripe_sectors %u\n", meta->stripe_sectors);
4904 printf("dummy_1 0x%04x\n", meta->dummy_1);
4905 printf("timestamp 0x%08x\n", meta->timestamp);
4906 printf("model %.40s\n", meta->model);
4907 printf("disk_number %u\n", meta->disk_number);
4908 printf("dummy_2 0x%02x 0x%02x 0x%02x\n",
4909 meta->dummy_2[0], meta->dummy_2[1], meta->dummy_2[2]);
4910 printf("=================================================\n");
4914 ata_raid_via_type(int type)
4916 static char buffer[16];
4919 case VIA_T_RAID0: return "RAID0";
4920 case VIA_T_RAID1: return "RAID1";
4921 case VIA_T_RAID5: return "RAID5";
4922 case VIA_T_RAID01: return "RAID0+1";
4923 case VIA_T_SPAN: return "SPAN";
4924 default: sprintf(buffer, "UNKNOWN 0x%02x", type);
4930 ata_raid_via_print_meta(struct via_raid_conf *meta)
4934 printf("*************** ATA VIA Metadata ****************\n");
4935 printf("magic 0x%02x\n", meta->magic);
4936 printf("dummy_0 0x%02x\n", meta->dummy_0);
4938 ata_raid_via_type(meta->type & VIA_T_MASK));
4939 printf("bootable %d\n", meta->type & VIA_T_BOOTABLE);
4940 printf("unknown %d\n", meta->type & VIA_T_UNKNOWN);
4941 printf("disk_index 0x%02x\n", meta->disk_index);
4942 printf("stripe_layout 0x%02x\n", meta->stripe_layout);
4943 printf(" stripe_disks %d\n", meta->stripe_layout & VIA_L_DISKS);
4944 printf(" stripe_sectors %d\n",
4945 0x08 << ((meta->stripe_layout & VIA_L_MASK) >> VIA_L_SHIFT));
4946 printf("disk_sectors %llu\n",
4947 (unsigned long long)meta->disk_sectors);
4948 printf("disk_id 0x%08x\n", meta->disk_id);
4949 printf("DISK# disk_id\n");
4950 for (i = 0; i < 8; i++) {
4952 printf(" %d 0x%08x\n", i, meta->disks[i]);
4954 printf("checksum 0x%02x\n", meta->checksum);
4955 printf("=================================================\n");