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.
26 * $FreeBSD: src/sys/dev/ata/ata-raid.c,v 1.120 2006/04/15 10:27:41 maxim Exp $
31 #include <sys/param.h>
37 #include <sys/device.h>
39 #include <sys/endian.h>
40 #include <sys/libkern.h>
41 #include <sys/malloc.h>
42 #include <sys/module.h>
44 #include <sys/spinlock2.h>
45 #include <sys/systm.h>
49 #include <machine/md_var.h>
51 #include <bus/pci/pcivar.h>
60 /* device structure */
61 static d_strategy_t ata_raid_strategy
;
62 static d_dump_t ata_raid_dump
;
63 static struct dev_ops ar_ops
= {
69 .d_strategy
= ata_raid_strategy
,
70 .d_dump
= ata_raid_dump
,
74 static void ata_raid_done(struct ata_request
*request
);
75 static void ata_raid_config_changed(struct ar_softc
*rdp
, int writeback
);
76 static int ata_raid_status(struct ata_ioc_raid_config
*config
);
77 static int ata_raid_create(struct ata_ioc_raid_config
*config
);
78 static int ata_raid_delete(int array
);
79 static int ata_raid_addspare(struct ata_ioc_raid_config
*config
);
80 static int ata_raid_rebuild(int array
);
81 static int ata_raid_read_metadata(device_t subdisk
);
82 static int ata_raid_write_metadata(struct ar_softc
*rdp
);
83 static int ata_raid_wipe_metadata(struct ar_softc
*rdp
);
84 static int ata_raid_adaptec_read_meta(device_t dev
, struct ar_softc
**raidp
);
85 static int ata_raid_hptv2_read_meta(device_t dev
, struct ar_softc
**raidp
);
86 static int ata_raid_hptv2_write_meta(struct ar_softc
*rdp
);
87 static int ata_raid_hptv3_read_meta(device_t dev
, struct ar_softc
**raidp
);
88 static int ata_raid_intel_read_meta(device_t dev
, struct ar_softc
**raidp
);
89 static int ata_raid_intel_write_meta(struct ar_softc
*rdp
);
90 static int ata_raid_ite_read_meta(device_t dev
, struct ar_softc
**raidp
);
91 static int ata_raid_jmicron_read_meta(device_t dev
, struct ar_softc
**raidp
);
92 static int ata_raid_jmicron_write_meta(struct ar_softc
*rdp
);
93 static int ata_raid_lsiv2_read_meta(device_t dev
, struct ar_softc
**raidp
);
94 static int ata_raid_lsiv3_read_meta(device_t dev
, struct ar_softc
**raidp
);
95 static int ata_raid_nvidia_read_meta(device_t dev
, struct ar_softc
**raidp
);
96 static int ata_raid_promise_read_meta(device_t dev
, struct ar_softc
**raidp
, int native
);
97 static int ata_raid_promise_write_meta(struct ar_softc
*rdp
);
98 static int ata_raid_sii_read_meta(device_t dev
, struct ar_softc
**raidp
);
99 static int ata_raid_sis_read_meta(device_t dev
, struct ar_softc
**raidp
);
100 static int ata_raid_sis_write_meta(struct ar_softc
*rdp
);
101 static int ata_raid_via_read_meta(device_t dev
, struct ar_softc
**raidp
);
102 static int ata_raid_via_write_meta(struct ar_softc
*rdp
);
103 static struct ata_request
*ata_raid_init_request(struct ar_softc
*rdp
, struct bio
*bio
);
104 static int ata_raid_send_request(struct ata_request
*request
);
105 static int ata_raid_rw(device_t dev
, u_int64_t lba
, void *data
, u_int bcount
, int flags
);
106 static char * ata_raid_format(struct ar_softc
*rdp
);
107 static char * ata_raid_type(struct ar_softc
*rdp
);
108 static char * ata_raid_flags(struct ar_softc
*rdp
);
111 static void ata_raid_print_meta(struct ar_softc
*meta
);
112 static void ata_raid_adaptec_print_meta(struct adaptec_raid_conf
*meta
);
113 static void ata_raid_hptv2_print_meta(struct hptv2_raid_conf
*meta
);
114 static void ata_raid_hptv3_print_meta(struct hptv3_raid_conf
*meta
);
115 static void ata_raid_intel_print_meta(struct intel_raid_conf
*meta
);
116 static void ata_raid_ite_print_meta(struct ite_raid_conf
*meta
);
117 static void ata_raid_jmicron_print_meta(struct jmicron_raid_conf
*meta
);
118 static void ata_raid_lsiv2_print_meta(struct lsiv2_raid_conf
*meta
);
119 static void ata_raid_lsiv3_print_meta(struct lsiv3_raid_conf
*meta
);
120 static void ata_raid_nvidia_print_meta(struct nvidia_raid_conf
*meta
);
121 static void ata_raid_promise_print_meta(struct promise_raid_conf
*meta
);
122 static void ata_raid_sii_print_meta(struct sii_raid_conf
*meta
);
123 static void ata_raid_sis_print_meta(struct sis_raid_conf
*meta
);
124 static void ata_raid_via_print_meta(struct via_raid_conf
*meta
);
127 static struct ar_softc
*ata_raid_arrays
[MAX_ARRAYS
];
128 static MALLOC_DEFINE(M_AR
, "ar_driver", "ATA PseudoRAID driver");
129 static devclass_t ata_raid_sub_devclass
;
130 static int testing
= 0;
133 ata_raid_attach(struct ar_softc
*rdp
, int writeback
)
135 struct disk_info info
;
140 spin_init(&rdp
->lock
);
141 ata_raid_config_changed(rdp
, writeback
);
143 /* sanitize arrays total_size % (width * interleave) == 0 */
144 if (rdp
->type
== AR_T_RAID0
|| rdp
->type
== AR_T_RAID01
||
145 rdp
->type
== AR_T_RAID5
) {
146 rdp
->total_sectors
= (rdp
->total_sectors
/(rdp
->interleave
*rdp
->width
))*
147 (rdp
->interleave
* rdp
->width
);
148 ksprintf(buffer
, " (stripe %d KB)",
149 (rdp
->interleave
* DEV_BSIZE
) / 1024);
153 /* XXX TGEN add devstats? */
154 cdev
= disk_create(rdp
->lun
, &rdp
->disk
, &ar_ops
);
156 cdev
->si_iosize_max
= 128 * DEV_BSIZE
;
159 bzero(&info
, sizeof(info
));
160 info
.d_media_blksize
= DEV_BSIZE
; /* mandatory */
161 info
.d_media_blocks
= rdp
->total_sectors
;
163 info
.d_secpertrack
= rdp
->sectors
; /* optional */
164 info
.d_nheads
= rdp
->heads
;
165 info
.d_ncylinders
= rdp
->total_sectors
/(rdp
->heads
*rdp
->sectors
);
166 info
.d_secpercyl
= rdp
->sectors
* rdp
->heads
;
168 kprintf("ar%d: %juMB <%s %s%s> status: %s\n", rdp
->lun
,
169 rdp
->total_sectors
/ ((1024L * 1024L) / DEV_BSIZE
),
170 ata_raid_format(rdp
), ata_raid_type(rdp
),
171 buffer
, ata_raid_flags(rdp
));
173 if (testing
|| bootverbose
)
174 kprintf("ar%d: %ju sectors [%dC/%dH/%dS] <%s> subdisks defined as:\n",
175 rdp
->lun
, rdp
->total_sectors
,
176 rdp
->cylinders
, rdp
->heads
, rdp
->sectors
, rdp
->name
);
178 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
179 kprintf("ar%d: disk%d ", rdp
->lun
, disk
);
180 if (rdp
->disks
[disk
].dev
) {
181 if (rdp
->disks
[disk
].flags
& AR_DF_PRESENT
) {
182 /* status of this disk in the array */
183 if (rdp
->disks
[disk
].flags
& AR_DF_ONLINE
)
185 else if (rdp
->disks
[disk
].flags
& AR_DF_SPARE
)
190 /* what type of disk is this in the array */
194 if (disk
< rdp
->width
)
195 kprintf("(master) ");
197 kprintf("(mirror) ");
200 /* which physical disk is used */
201 kprintf("using %s at ata%d-%s\n",
202 device_get_nameunit(rdp
->disks
[disk
].dev
),
203 device_get_unit(device_get_parent(rdp
->disks
[disk
].dev
)),
204 (((struct ata_device
*)
205 device_get_softc(rdp
->disks
[disk
].dev
))->unit
==
206 ATA_MASTER
) ? "master" : "slave");
208 else if (rdp
->disks
[disk
].flags
& AR_DF_ASSIGNED
)
211 kprintf("INVALID no RAID config on this subdisk\n");
214 kprintf("DOWN no device found for this subdisk\n");
217 disk_setdiskinfo(&rdp
->disk
, &info
);
221 * ATA PseudoRAID ioctl function. Note that this does not need to be adjusted
222 * to the dev_ops way, because it's just chained from the generic ata ioctl.
225 ata_raid_ioctl(u_long cmd
, caddr_t data
)
227 struct ata_ioc_raid_config
*config
= (struct ata_ioc_raid_config
*)data
;
228 int *lun
= (int *)data
;
229 int error
= EOPNOTSUPP
;
232 case IOCATARAIDSTATUS
:
233 error
= ata_raid_status(config
);
236 case IOCATARAIDCREATE
:
237 error
= ata_raid_create(config
);
240 case IOCATARAIDDELETE
:
241 error
= ata_raid_delete(*lun
);
244 case IOCATARAIDADDSPARE
:
245 error
= ata_raid_addspare(config
);
248 case IOCATARAIDREBUILD
:
249 error
= ata_raid_rebuild(*lun
);
256 ata_raid_flush(struct ar_softc
*rdp
, struct bio
*bp
)
258 struct ata_request
*request
;
263 bp
->bio_driver_info
= NULL
;
265 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
266 if ((dev
= rdp
->disks
[disk
].dev
) != NULL
)
267 bp
->bio_driver_info
= (void *)((intptr_t)bp
->bio_driver_info
+ 1);
269 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
270 if ((dev
= rdp
->disks
[disk
].dev
) == NULL
)
272 if (!(request
= ata_raid_init_request(rdp
, bp
)))
275 request
->u
.ata
.command
= ATA_FLUSHCACHE
;
276 request
->u
.ata
.lba
= 0;
277 request
->u
.ata
.count
= 0;
278 request
->u
.ata
.feature
= 0;
279 request
->timeout
= 1;
280 request
->retries
= 0;
281 request
->flags
|= ATA_R_ORDERED
| ATA_R_DIRECT
;
282 ata_queue_request(request
);
288 * XXX TGEN there are a lot of offset -> block number conversions going on
289 * here, which is suboptimal.
292 ata_raid_strategy(struct dev_strategy_args
*ap
)
294 struct ar_softc
*rdp
= ap
->a_head
.a_dev
->si_drv1
;
295 struct bio
*bp
= ap
->a_bio
;
296 struct buf
*bbp
= bp
->bio_buf
;
297 struct ata_request
*request
;
299 u_int64_t blkno
, lba
, blk
= 0;
300 int count
, chunk
, drv
, par
= 0, change
= 0;
302 if (bbp
->b_cmd
== BUF_CMD_FLUSH
) {
305 error
= ata_raid_flush(rdp
, bp
);
307 bbp
->b_flags
|= B_ERROR
;
308 bbp
->b_error
= error
;
314 if (!(rdp
->status
& AR_S_READY
) ||
315 (bbp
->b_cmd
!= BUF_CMD_READ
&& bbp
->b_cmd
!= BUF_CMD_WRITE
)) {
316 bbp
->b_flags
|= B_ERROR
;
322 bbp
->b_resid
= bbp
->b_bcount
;
323 for (count
= howmany(bbp
->b_bcount
, DEV_BSIZE
),
324 /* bio_offset is byte granularity, convert */
325 blkno
= (u_int64_t
)(bp
->bio_offset
>> DEV_BSHIFT
),
328 count
-= chunk
, blkno
+= chunk
, data
+= (chunk
* DEV_BSIZE
)) {
341 while (lba
>= rdp
->disks
[drv
].sectors
)
342 lba
-= rdp
->disks
[drv
++].sectors
;
343 chunk
= min(rdp
->disks
[drv
].sectors
- lba
, count
);
348 chunk
= blkno
% rdp
->interleave
;
349 drv
= (blkno
/ rdp
->interleave
) % rdp
->width
;
350 lba
= (((blkno
/rdp
->interleave
)/rdp
->width
)*rdp
->interleave
)+chunk
;
351 chunk
= min(count
, rdp
->interleave
- chunk
);
355 drv
= (blkno
/ rdp
->interleave
) % (rdp
->width
- 1);
356 par
= rdp
->width
- 1 -
357 (blkno
/ (rdp
->interleave
* (rdp
->width
- 1))) % rdp
->width
;
360 lba
= ((blkno
/rdp
->interleave
)/(rdp
->width
-1))*(rdp
->interleave
) +
361 ((blkno
%(rdp
->interleave
*(rdp
->width
-1)))%rdp
->interleave
);
362 chunk
= min(count
, rdp
->interleave
- (lba
% rdp
->interleave
));
366 kprintf("ar%d: unknown array type in ata_raid_strategy\n", rdp
->lun
);
367 bbp
->b_flags
|= B_ERROR
;
373 /* offset on all but "first on HPTv2" */
374 if (!(drv
== 0 && rdp
->format
== AR_F_HPTV2_RAID
))
375 lba
+= rdp
->offset_sectors
;
377 if (!(request
= ata_raid_init_request(rdp
, bp
))) {
378 bbp
->b_flags
|= B_ERROR
;
383 request
->data
= data
;
384 request
->bytecount
= chunk
* DEV_BSIZE
;
385 request
->u
.ata
.lba
= lba
;
386 request
->u
.ata
.count
= request
->bytecount
/ DEV_BSIZE
;
392 if (((rdp
->disks
[drv
].flags
& (AR_DF_PRESENT
|AR_DF_ONLINE
)) ==
393 (AR_DF_PRESENT
|AR_DF_ONLINE
) && !rdp
->disks
[drv
].dev
)) {
394 rdp
->disks
[drv
].flags
&= ~AR_DF_ONLINE
;
395 ata_raid_config_changed(rdp
, 1);
396 ata_free_request(request
);
397 bbp
->b_flags
|= B_ERROR
;
403 request
->dev
= rdp
->disks
[request
->this].dev
;
404 ata_raid_send_request(request
);
409 if ((rdp
->disks
[drv
].flags
&
410 (AR_DF_PRESENT
|AR_DF_ONLINE
))==(AR_DF_PRESENT
|AR_DF_ONLINE
) &&
411 !rdp
->disks
[drv
].dev
) {
412 rdp
->disks
[drv
].flags
&= ~AR_DF_ONLINE
;
415 if ((rdp
->disks
[drv
+ rdp
->width
].flags
&
416 (AR_DF_PRESENT
|AR_DF_ONLINE
))==(AR_DF_PRESENT
|AR_DF_ONLINE
) &&
417 !rdp
->disks
[drv
+ rdp
->width
].dev
) {
418 rdp
->disks
[drv
+ rdp
->width
].flags
&= ~AR_DF_ONLINE
;
422 ata_raid_config_changed(rdp
, 1);
423 if (!(rdp
->status
& AR_S_READY
)) {
424 ata_free_request(request
);
425 bbp
->b_flags
|= B_ERROR
;
431 if (rdp
->status
& AR_S_REBUILDING
)
432 blk
= ((lba
/ rdp
->interleave
) * rdp
->width
) * rdp
->interleave
+
433 (rdp
->interleave
* (drv
% rdp
->width
)) +
434 lba
% rdp
->interleave
;;
436 if (bbp
->b_cmd
== BUF_CMD_READ
) {
438 (rdp
->disks
[drv
].flags
& AR_DF_ONLINE
);
440 (rdp
->disks
[drv
+rdp
->width
].flags
& AR_DF_ONLINE
);
442 /* if mirror gone or close to last access on source */
445 ((u_int64_t
)(bp
->bio_offset
>> DEV_BSHIFT
)) >=
446 (rdp
->disks
[drv
].last_lba
- AR_PROXIMITY
) &&
447 ((u_int64_t
)(bp
->bio_offset
>> DEV_BSHIFT
)) <=
448 (rdp
->disks
[drv
].last_lba
+ AR_PROXIMITY
))) {
451 /* if source gone or close to last access on mirror */
452 else if (!src_online
||
454 ((u_int64_t
)(bp
->bio_offset
>> DEV_BSHIFT
)) >=
455 (rdp
->disks
[drv
+rdp
->width
].last_lba
-AR_PROXIMITY
) &&
456 ((u_int64_t
)(bp
->bio_offset
>> DEV_BSHIFT
)) <=
457 (rdp
->disks
[drv
+rdp
->width
].last_lba
+AR_PROXIMITY
))) {
461 /* not close to any previous access, toggle */
471 if ((rdp
->status
& AR_S_REBUILDING
) &&
472 (blk
<= rdp
->rebuild_lba
) &&
473 ((blk
+ chunk
) > rdp
->rebuild_lba
)) {
474 struct ata_composite
*composite
;
475 struct ata_request
*rebuild
;
478 /* figure out what part to rebuild */
479 if (drv
< rdp
->width
)
480 this = drv
+ rdp
->width
;
482 this = drv
- rdp
->width
;
484 /* do we have a spare to rebuild on ? */
485 if (rdp
->disks
[this].flags
& AR_DF_SPARE
) {
486 if ((composite
= ata_alloc_composite())) {
487 if ((rebuild
= ata_alloc_request())) {
488 rdp
->rebuild_lba
= blk
+ chunk
;
489 bcopy(request
, rebuild
,
490 sizeof(struct ata_request
));
491 rebuild
->this = this;
492 rebuild
->dev
= rdp
->disks
[this].dev
;
493 rebuild
->flags
&= ~ATA_R_READ
;
494 rebuild
->flags
|= ATA_R_WRITE
;
495 spin_init(&composite
->lock
);
496 composite
->residual
= request
->bytecount
;
497 composite
->rd_needed
|= (1 << drv
);
498 composite
->wr_depend
|= (1 << drv
);
499 composite
->wr_needed
|= (1 << this);
500 composite
->request
[drv
] = request
;
501 composite
->request
[this] = rebuild
;
502 request
->composite
= composite
;
503 rebuild
->composite
= composite
;
504 ata_raid_send_request(rebuild
);
507 ata_free_composite(composite
);
508 kprintf("DOH! ata_alloc_request failed!\n");
512 kprintf("DOH! ata_alloc_composite failed!\n");
515 else if (rdp
->disks
[this].flags
& AR_DF_ONLINE
) {
517 * if we got here we are a chunk of a RAID01 that
518 * does not need a rebuild, but we need to increment
519 * the rebuild_lba address to get the rebuild to
520 * move to the next chunk correctly
522 rdp
->rebuild_lba
= blk
+ chunk
;
525 kprintf("DOH! we didn't find the rebuild part\n");
528 if (bbp
->b_cmd
== BUF_CMD_WRITE
) {
529 if ((rdp
->disks
[drv
+rdp
->width
].flags
& AR_DF_ONLINE
) ||
530 ((rdp
->status
& AR_S_REBUILDING
) &&
531 (rdp
->disks
[drv
+rdp
->width
].flags
& AR_DF_SPARE
) &&
532 ((blk
< rdp
->rebuild_lba
) ||
533 ((blk
<= rdp
->rebuild_lba
) &&
534 ((blk
+ chunk
) > rdp
->rebuild_lba
))))) {
535 if ((rdp
->disks
[drv
].flags
& AR_DF_ONLINE
) ||
536 ((rdp
->status
& AR_S_REBUILDING
) &&
537 (rdp
->disks
[drv
].flags
& AR_DF_SPARE
) &&
538 ((blk
< rdp
->rebuild_lba
) ||
539 ((blk
<= rdp
->rebuild_lba
) &&
540 ((blk
+ chunk
) > rdp
->rebuild_lba
))))) {
541 struct ata_request
*mirror
;
542 struct ata_composite
*composite
;
543 int this = drv
+ rdp
->width
;
545 if ((composite
= ata_alloc_composite())) {
546 if ((mirror
= ata_alloc_request())) {
547 if ((blk
<= rdp
->rebuild_lba
) &&
548 ((blk
+ chunk
) > rdp
->rebuild_lba
))
549 rdp
->rebuild_lba
= blk
+ chunk
;
550 bcopy(request
, mirror
,
551 sizeof(struct ata_request
));
553 mirror
->dev
= rdp
->disks
[this].dev
;
554 spin_init(&composite
->lock
);
555 composite
->residual
= request
->bytecount
;
556 composite
->wr_needed
|= (1 << drv
);
557 composite
->wr_needed
|= (1 << this);
558 composite
->request
[drv
] = request
;
559 composite
->request
[this] = mirror
;
560 request
->composite
= composite
;
561 mirror
->composite
= composite
;
562 ata_raid_send_request(mirror
);
563 rdp
->disks
[this].last_lba
=
564 (u_int64_t
)(bp
->bio_offset
>> DEV_BSHIFT
) +
568 ata_free_composite(composite
);
569 kprintf("DOH! ata_alloc_request failed!\n");
573 kprintf("DOH! ata_alloc_composite failed!\n");
581 request
->dev
= rdp
->disks
[request
->this].dev
;
582 ata_raid_send_request(request
);
583 rdp
->disks
[request
->this].last_lba
=
584 ((u_int64_t
)(bp
->bio_offset
) >> DEV_BSHIFT
) + chunk
;
588 if (((rdp
->disks
[drv
].flags
& (AR_DF_PRESENT
|AR_DF_ONLINE
)) ==
589 (AR_DF_PRESENT
|AR_DF_ONLINE
) && !rdp
->disks
[drv
].dev
)) {
590 rdp
->disks
[drv
].flags
&= ~AR_DF_ONLINE
;
593 if (((rdp
->disks
[par
].flags
& (AR_DF_PRESENT
|AR_DF_ONLINE
)) ==
594 (AR_DF_PRESENT
|AR_DF_ONLINE
) && !rdp
->disks
[par
].dev
)) {
595 rdp
->disks
[par
].flags
&= ~AR_DF_ONLINE
;
599 ata_raid_config_changed(rdp
, 1);
600 if (!(rdp
->status
& AR_S_READY
)) {
601 ata_free_request(request
);
602 bbp
->b_flags
|= B_ERROR
;
607 if (rdp
->status
& AR_S_DEGRADED
) {
608 /* do the XOR game if possible */
612 request
->dev
= rdp
->disks
[request
->this].dev
;
613 if (bbp
->b_cmd
== BUF_CMD_READ
) {
614 ata_raid_send_request(request
);
616 if (bbp
->b_cmd
== BUF_CMD_WRITE
) {
617 ata_raid_send_request(request
);
618 /* XXX TGEN no, I don't speak Danish either */
620 * sikre at læs-modify-skriv til hver disk er atomarisk.
621 * par kopi af request
622 * læse orgdata fra drv
623 * skriv nydata til drv
624 * læse parorgdata fra par
625 * skriv orgdata xor parorgdata xor nydata til par
632 kprintf("ar%d: unknown array type in ata_raid_strategy\n", rdp
->lun
);
640 ata_raid_done(struct ata_request
*request
)
642 struct ar_softc
*rdp
= request
->driver
;
643 struct ata_composite
*composite
= NULL
;
644 struct bio
*bp
= request
->bio
;
645 struct buf
*bbp
= bp
->bio_buf
;
646 int i
, mirror
, finished
= 0;
648 if (bbp
->b_cmd
== BUF_CMD_FLUSH
) {
649 if (bbp
->b_error
== 0)
650 bbp
->b_error
= request
->result
;
651 ata_free_request(request
);
652 bp
->bio_driver_info
= (void *)((intptr_t)bp
->bio_driver_info
- 1);
653 if ((intptr_t)bp
->bio_driver_info
== 0) {
655 bbp
->b_flags
|= B_ERROR
;
665 if (request
->result
) {
666 rdp
->disks
[request
->this].flags
&= ~AR_DF_ONLINE
;
667 ata_raid_config_changed(rdp
, 1);
668 bbp
->b_error
= request
->result
;
672 bbp
->b_resid
-= request
->donecount
;
680 if (request
->this < rdp
->width
)
681 mirror
= request
->this + rdp
->width
;
683 mirror
= request
->this - rdp
->width
;
684 if (request
->result
) {
685 rdp
->disks
[request
->this].flags
&= ~AR_DF_ONLINE
;
686 ata_raid_config_changed(rdp
, 1);
688 if (rdp
->status
& AR_S_READY
) {
691 if (rdp
->status
& AR_S_REBUILDING
)
692 blk
= ((request
->u
.ata
.lba
/ rdp
->interleave
) * rdp
->width
) *
693 rdp
->interleave
+ (rdp
->interleave
*
694 (request
->this % rdp
->width
)) +
695 request
->u
.ata
.lba
% rdp
->interleave
;
697 if (bbp
->b_cmd
== BUF_CMD_READ
) {
699 /* is this a rebuild composite */
700 if ((composite
= request
->composite
)) {
701 spin_lock(&composite
->lock
);
703 /* handle the read part of a rebuild composite */
704 if (request
->flags
& ATA_R_READ
) {
706 /* if read failed array is now broken */
707 if (request
->result
) {
708 rdp
->disks
[request
->this].flags
&= ~AR_DF_ONLINE
;
709 ata_raid_config_changed(rdp
, 1);
710 bbp
->b_error
= request
->result
;
711 rdp
->rebuild_lba
= blk
;
715 /* good data, update how far we've gotten */
717 bbp
->b_resid
-= request
->donecount
;
718 composite
->residual
-= request
->donecount
;
719 if (!composite
->residual
) {
720 if (composite
->wr_done
& (1 << mirror
))
726 /* handle the write part of a rebuild composite */
727 else if (request
->flags
& ATA_R_WRITE
) {
728 if (composite
->rd_done
& (1 << mirror
)) {
729 if (request
->result
) {
730 kprintf("DOH! rebuild failed\n"); /* XXX SOS */
731 rdp
->rebuild_lba
= blk
;
733 if (!composite
->residual
)
737 spin_unlock(&composite
->lock
);
740 /* if read failed retry on the mirror */
741 else if (request
->result
) {
742 request
->dev
= rdp
->disks
[mirror
].dev
;
743 request
->flags
&= ~ATA_R_TIMEOUT
;
744 ata_raid_send_request(request
);
748 /* we have good data */
750 bbp
->b_resid
-= request
->donecount
;
755 else if (bbp
->b_cmd
== BUF_CMD_WRITE
) {
756 /* do we have a mirror or rebuild to deal with ? */
757 if ((composite
= request
->composite
)) {
758 spin_lock(&composite
->lock
);
759 if (composite
->wr_done
& (1 << mirror
)) {
760 if (request
->result
) {
761 if (composite
->request
[mirror
]->result
) {
762 kprintf("DOH! all disks failed and got here\n");
765 if (rdp
->status
& AR_S_REBUILDING
) {
766 rdp
->rebuild_lba
= blk
;
767 kprintf("DOH! rebuild failed\n"); /* XXX SOS */
770 composite
->request
[mirror
]->donecount
;
771 composite
->residual
-=
772 composite
->request
[mirror
]->donecount
;
775 bbp
->b_resid
-= request
->donecount
;
776 composite
->residual
-= request
->donecount
;
778 if (!composite
->residual
)
781 spin_unlock(&composite
->lock
);
783 /* no mirror we are done */
785 bbp
->b_resid
-= request
->donecount
;
792 /* XXX TGEN bbp->b_flags |= B_ERROR; */
793 bbp
->b_error
= request
->result
;
799 if (request
->result
) {
800 rdp
->disks
[request
->this].flags
&= ~AR_DF_ONLINE
;
801 ata_raid_config_changed(rdp
, 1);
802 if (rdp
->status
& AR_S_READY
) {
803 if (bbp
->b_cmd
== BUF_CMD_READ
) {
804 /* do the XOR game to recover data */
806 if (bbp
->b_cmd
== BUF_CMD_WRITE
) {
807 /* if the parity failed we're OK sortof */
808 /* otherwise wee need to do the XOR long dance */
813 /* XXX TGEN bbp->b_flags |= B_ERROR; */
814 bbp
->b_error
= request
->result
;
819 /* did we have an XOR game going ?? */
820 bbp
->b_resid
-= request
->donecount
;
827 kprintf("ar%d: unknown array type in ata_raid_done\n", rdp
->lun
);
831 if ((rdp
->status
& AR_S_REBUILDING
) &&
832 rdp
->rebuild_lba
>= rdp
->total_sectors
) {
835 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
836 if ((rdp
->disks
[disk
].flags
&
837 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_SPARE
)) ==
838 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_SPARE
)) {
839 rdp
->disks
[disk
].flags
&= ~AR_DF_SPARE
;
840 rdp
->disks
[disk
].flags
|= AR_DF_ONLINE
;
843 rdp
->status
&= ~AR_S_REBUILDING
;
844 ata_raid_config_changed(rdp
, 1);
852 /* we are done with this composite, free all resources */
853 for (i
= 0; i
< 32; i
++) {
854 if (composite
->rd_needed
& (1 << i
) ||
855 composite
->wr_needed
& (1 << i
)) {
856 ata_free_request(composite
->request
[i
]);
859 spin_uninit(&composite
->lock
);
860 ata_free_composite(composite
);
864 ata_free_request(request
);
868 ata_raid_dump(struct dev_dump_args
*ap
)
870 struct ar_softc
*rdp
= ap
->a_head
.a_dev
->si_drv1
;
875 if (ap
->a_length
== 0) {
876 /* flush subdisk buffers to media */
877 for (disk
= 0, error
= 0; disk
< rdp
->total_disks
; disk
++) {
878 if (rdp
->disks
[disk
].dev
) {
879 error
|= ata_controlcmd(rdp
->disks
[disk
].dev
,
880 ATA_FLUSHCACHE
, 0, 0, 0);
883 return (error
? EIO
: 0);
886 bzero(&dbuf
, sizeof(struct buf
));
888 BUF_LOCK(&dbuf
, LK_EXCLUSIVE
);
889 /* bio_offset is byte granularity, convert block granularity a_blkno */
890 dbuf
.b_bio1
.bio_offset
= ap
->a_offset
;
891 dbuf
.b_bio1
.bio_caller_info1
.ptr
= (void *)rdp
;
892 dbuf
.b_bio1
.bio_flags
|= BIO_SYNC
;
893 dbuf
.b_bio1
.bio_done
= biodone_sync
;
894 dbuf
.b_bcount
= ap
->a_length
;
895 dbuf
.b_data
= ap
->a_virtual
;
896 dbuf
.b_cmd
= BUF_CMD_WRITE
;
897 dev_dstrategy(rdp
->cdev
, &dbuf
.b_bio1
);
898 /* wait for completion, unlock the buffer, check status */
899 if (biowait(&dbuf
.b_bio1
, "dumpw")) {
901 return(dbuf
.b_error
? dbuf
.b_error
: EIO
);
910 ata_raid_config_changed(struct ar_softc
*rdp
, int writeback
)
912 int disk
, count
, status
;
914 spin_lock(&rdp
->lock
);
915 /* set default all working mode */
916 status
= rdp
->status
;
917 rdp
->status
&= ~AR_S_DEGRADED
;
918 rdp
->status
|= AR_S_READY
;
920 /* make sure all lost drives are accounted for */
921 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
922 if (!(rdp
->disks
[disk
].flags
& AR_DF_PRESENT
))
923 rdp
->disks
[disk
].flags
&= ~AR_DF_ONLINE
;
926 /* depending on RAID type figure out our health status */
931 for (disk
= 0; disk
< rdp
->total_disks
; disk
++)
932 if (!(rdp
->disks
[disk
].flags
& AR_DF_ONLINE
))
933 rdp
->status
&= ~AR_S_READY
;
938 for (disk
= 0; disk
< rdp
->width
; disk
++) {
939 if (!(rdp
->disks
[disk
].flags
& AR_DF_ONLINE
) &&
940 !(rdp
->disks
[disk
+ rdp
->width
].flags
& AR_DF_ONLINE
)) {
941 rdp
->status
&= ~AR_S_READY
;
943 else if (((rdp
->disks
[disk
].flags
& AR_DF_ONLINE
) &&
944 !(rdp
->disks
[disk
+ rdp
->width
].flags
& AR_DF_ONLINE
)) ||
945 (!(rdp
->disks
[disk
].flags
& AR_DF_ONLINE
) &&
946 (rdp
->disks
[disk
+ rdp
->width
].flags
& AR_DF_ONLINE
))) {
947 rdp
->status
|= AR_S_DEGRADED
;
953 for (count
= 0, disk
= 0; disk
< rdp
->total_disks
; disk
++) {
954 if (!(rdp
->disks
[disk
].flags
& AR_DF_ONLINE
))
959 rdp
->status
&= ~AR_S_READY
;
961 rdp
->status
|= AR_S_DEGRADED
;
965 rdp
->status
&= ~AR_S_READY
;
969 * Note that when the array breaks so comes up broken we
970 * force a write of the array config to the remaining
971 * drives so that the generation will be incremented past
972 * those of the missing or failed drives (in all cases).
974 if (rdp
->status
!= status
) {
975 if (!(rdp
->status
& AR_S_READY
)) {
976 kprintf("ar%d: FAILURE - %s array broken\n",
977 rdp
->lun
, ata_raid_type(rdp
));
980 else if (rdp
->status
& AR_S_DEGRADED
) {
981 if (rdp
->type
& (AR_T_RAID1
| AR_T_RAID01
))
982 kprintf("ar%d: WARNING - mirror", rdp
->lun
);
984 kprintf("ar%d: WARNING - parity", rdp
->lun
);
985 kprintf(" protection lost. %s array in DEGRADED mode\n",
990 spin_unlock(&rdp
->lock
);
992 ata_raid_write_metadata(rdp
);
997 ata_raid_status(struct ata_ioc_raid_config
*config
)
999 struct ar_softc
*rdp
;
1002 if (!(rdp
= ata_raid_arrays
[config
->lun
]))
1005 config
->type
= rdp
->type
;
1006 config
->total_disks
= rdp
->total_disks
;
1007 for (i
= 0; i
< rdp
->total_disks
; i
++ ) {
1008 if ((rdp
->disks
[i
].flags
& AR_DF_PRESENT
) && rdp
->disks
[i
].dev
)
1009 config
->disks
[i
] = device_get_unit(rdp
->disks
[i
].dev
);
1011 config
->disks
[i
] = -1;
1013 config
->interleave
= rdp
->interleave
;
1014 config
->status
= rdp
->status
;
1015 config
->progress
= 100 * rdp
->rebuild_lba
/ rdp
->total_sectors
;
1020 ata_raid_create(struct ata_ioc_raid_config
*config
)
1022 struct ar_softc
*rdp
;
1025 int ctlr
= 0, disk_size
= 0, total_disks
= 0;
1028 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
1029 if (!ata_raid_arrays
[array
])
1032 if (array
>= MAX_ARRAYS
)
1035 rdp
= (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
1038 for (disk
= 0; disk
< config
->total_disks
; disk
++) {
1039 if ((subdisk
= devclass_get_device(ata_raid_sub_devclass
,
1040 config
->disks
[disk
]))) {
1041 struct ata_raid_subdisk
*ars
= device_get_softc(subdisk
);
1043 /* is device already assigned to another array ? */
1044 if (ars
->raid
[rdp
->volume
]) {
1045 config
->disks
[disk
] = -1;
1049 rdp
->disks
[disk
].dev
= device_get_parent(subdisk
);
1051 gpdev
= GRANDPARENT(rdp
->disks
[disk
].dev
);
1053 switch (pci_get_vendor(gpdev
)) {
1054 case ATA_HIGHPOINT_ID
:
1056 * we need some way to decide if it should be v2 or v3
1057 * for now just use v2 since the v3 BIOS knows how to
1058 * handle that as well.
1060 ctlr
= AR_F_HPTV2_RAID
;
1061 rdp
->disks
[disk
].sectors
= HPTV3_LBA(rdp
->disks
[disk
].dev
);
1065 ctlr
= AR_F_INTEL_RAID
;
1066 rdp
->disks
[disk
].sectors
= INTEL_LBA(rdp
->disks
[disk
].dev
);
1070 ctlr
= AR_F_ITE_RAID
;
1071 rdp
->disks
[disk
].sectors
= ITE_LBA(rdp
->disks
[disk
].dev
);
1074 case ATA_JMICRON_ID
:
1075 ctlr
= AR_F_JMICRON_RAID
;
1076 rdp
->disks
[disk
].sectors
= JMICRON_LBA(rdp
->disks
[disk
].dev
);
1079 case 0: /* XXX SOS cover up for bug in our PCI code */
1080 case ATA_PROMISE_ID
:
1081 ctlr
= AR_F_PROMISE_RAID
;
1082 rdp
->disks
[disk
].sectors
= PROMISE_LBA(rdp
->disks
[disk
].dev
);
1086 ctlr
= AR_F_SIS_RAID
;
1087 rdp
->disks
[disk
].sectors
= SIS_LBA(rdp
->disks
[disk
].dev
);
1092 ctlr
= AR_F_VIA_RAID
;
1093 rdp
->disks
[disk
].sectors
= VIA_LBA(rdp
->disks
[disk
].dev
);
1098 * right, so here we are, we have an ATA chip and we want
1099 * to create a RAID and store the metadata.
1100 * we need to find a way to tell what kind of metadata this
1101 * hardware's BIOS might be using (good ideas are welcomed)
1102 * for now we just use our own native FreeBSD format.
1103 * the only way to get support for the BIOS format is to
1104 * setup the RAID from there, in that case we pickup the
1105 * metadata format from the disks (if we support it).
1107 kprintf("WARNING!! - not able to determine metadata format\n"
1108 "WARNING!! - Using FreeBSD PseudoRAID metadata\n"
1109 "If that is not what you want, use the BIOS to "
1110 "create the array\n");
1111 ctlr
= AR_F_FREEBSD_RAID
;
1112 rdp
->disks
[disk
].sectors
= PROMISE_LBA(rdp
->disks
[disk
].dev
);
1116 /* we need all disks to be of the same format */
1117 if ((rdp
->format
& AR_F_FORMAT_MASK
) &&
1118 (rdp
->format
& AR_F_FORMAT_MASK
) != (ctlr
& AR_F_FORMAT_MASK
)) {
1125 /* use the smallest disk of the lots size */
1126 /* gigabyte boundry ??? XXX SOS */
1128 disk_size
= min(rdp
->disks
[disk
].sectors
, disk_size
);
1130 disk_size
= rdp
->disks
[disk
].sectors
;
1131 rdp
->disks
[disk
].flags
=
1132 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_ONLINE
);
1137 config
->disks
[disk
] = -1;
1143 if (total_disks
!= config
->total_disks
) {
1148 switch (config
->type
) {
1155 if (total_disks
!= 2) {
1162 if (total_disks
% 2 != 0) {
1169 if (total_disks
< 3) {
1179 rdp
->type
= config
->type
;
1181 if (rdp
->type
== AR_T_RAID0
|| rdp
->type
== AR_T_RAID01
||
1182 rdp
->type
== AR_T_RAID5
) {
1185 while (config
->interleave
>>= 1)
1187 rdp
->interleave
= 1 << bit
;
1189 rdp
->offset_sectors
= 0;
1191 /* values that depend on metadata format */
1192 switch (rdp
->format
) {
1193 case AR_F_ADAPTEC_RAID
:
1194 rdp
->interleave
= min(max(32, rdp
->interleave
), 128); /*+*/
1197 case AR_F_HPTV2_RAID
:
1198 rdp
->interleave
= min(max(8, rdp
->interleave
), 128); /*+*/
1199 rdp
->offset_sectors
= HPTV2_LBA(x
) + 1;
1202 case AR_F_HPTV3_RAID
:
1203 rdp
->interleave
= min(max(32, rdp
->interleave
), 4096); /*+*/
1206 case AR_F_INTEL_RAID
:
1207 rdp
->interleave
= min(max(8, rdp
->interleave
), 256); /*+*/
1211 rdp
->interleave
= min(max(2, rdp
->interleave
), 128); /*+*/
1214 case AR_F_JMICRON_RAID
:
1215 rdp
->interleave
= min(max(8, rdp
->interleave
), 256); /*+*/
1218 case AR_F_LSIV2_RAID
:
1219 rdp
->interleave
= min(max(2, rdp
->interleave
), 4096);
1222 case AR_F_LSIV3_RAID
:
1223 rdp
->interleave
= min(max(2, rdp
->interleave
), 256);
1226 case AR_F_PROMISE_RAID
:
1227 rdp
->interleave
= min(max(2, rdp
->interleave
), 2048); /*+*/
1231 rdp
->interleave
= min(max(8, rdp
->interleave
), 256); /*+*/
1235 rdp
->interleave
= min(max(32, rdp
->interleave
), 512); /*+*/
1239 rdp
->interleave
= min(max(8, rdp
->interleave
), 128); /*+*/
1243 rdp
->total_disks
= total_disks
;
1244 rdp
->width
= total_disks
/ (rdp
->type
& (AR_RAID1
| AR_T_RAID01
) ? 2 : 1);
1245 rdp
->total_sectors
= disk_size
* (rdp
->width
- (rdp
->type
== AR_RAID5
));
1248 rdp
->cylinders
= rdp
->total_sectors
/ (255 * 63);
1249 rdp
->rebuild_lba
= 0;
1250 rdp
->status
|= AR_S_READY
;
1252 /* we are committed to this array, grap the subdisks */
1253 for (disk
= 0; disk
< config
->total_disks
; disk
++) {
1254 if ((subdisk
= devclass_get_device(ata_raid_sub_devclass
,
1255 config
->disks
[disk
]))) {
1256 struct ata_raid_subdisk
*ars
= device_get_softc(subdisk
);
1258 ars
->raid
[rdp
->volume
] = rdp
;
1259 ars
->disk_number
[rdp
->volume
] = disk
;
1262 ata_raid_attach(rdp
, 1);
1263 ata_raid_arrays
[array
] = rdp
;
1264 config
->lun
= array
;
1269 ata_raid_delete(int array
)
1271 struct ar_softc
*rdp
;
1275 if (!(rdp
= ata_raid_arrays
[array
]))
1278 rdp
->status
&= ~AR_S_READY
;
1279 disk_destroy(&rdp
->disk
);
1281 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
1282 if ((rdp
->disks
[disk
].flags
& AR_DF_PRESENT
) && rdp
->disks
[disk
].dev
) {
1283 if ((subdisk
= devclass_get_device(ata_raid_sub_devclass
,
1284 device_get_unit(rdp
->disks
[disk
].dev
)))) {
1285 struct ata_raid_subdisk
*ars
= device_get_softc(subdisk
);
1287 if (ars
->raid
[rdp
->volume
] != rdp
) /* XXX SOS */
1288 device_printf(subdisk
, "DOH! this disk doesn't belong\n");
1289 if (ars
->disk_number
[rdp
->volume
] != disk
) /* XXX SOS */
1290 device_printf(subdisk
, "DOH! this disk number is wrong\n");
1291 ars
->raid
[rdp
->volume
] = NULL
;
1292 ars
->disk_number
[rdp
->volume
] = -1;
1294 rdp
->disks
[disk
].flags
= 0;
1297 ata_raid_wipe_metadata(rdp
);
1298 ata_raid_arrays
[array
] = NULL
;
1304 ata_raid_addspare(struct ata_ioc_raid_config
*config
)
1306 struct ar_softc
*rdp
;
1310 if (!(rdp
= ata_raid_arrays
[config
->lun
]))
1312 if (!(rdp
->status
& AR_S_DEGRADED
) || !(rdp
->status
& AR_S_READY
))
1314 if (rdp
->status
& AR_S_REBUILDING
)
1316 switch (rdp
->type
) {
1320 for (disk
= 0; disk
< rdp
->total_disks
; disk
++ ) {
1322 if (((rdp
->disks
[disk
].flags
& (AR_DF_PRESENT
| AR_DF_ONLINE
)) ==
1323 (AR_DF_PRESENT
| AR_DF_ONLINE
)) && rdp
->disks
[disk
].dev
)
1326 if ((subdisk
= devclass_get_device(ata_raid_sub_devclass
,
1327 config
->disks
[0] ))) {
1328 struct ata_raid_subdisk
*ars
= device_get_softc(subdisk
);
1330 if (ars
->raid
[rdp
->volume
])
1333 /* XXX SOS validate size etc etc */
1334 ars
->raid
[rdp
->volume
] = rdp
;
1335 ars
->disk_number
[rdp
->volume
] = disk
;
1336 rdp
->disks
[disk
].dev
= device_get_parent(subdisk
);
1337 rdp
->disks
[disk
].flags
=
1338 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_SPARE
);
1340 device_printf(rdp
->disks
[disk
].dev
,
1341 "inserted into ar%d disk%d as spare\n",
1343 ata_raid_config_changed(rdp
, 1);
1355 ata_raid_rebuild(int array
)
1357 struct ar_softc
*rdp
;
1360 if (!(rdp
= ata_raid_arrays
[array
]))
1362 /* XXX SOS we should lock the rdp softc here */
1363 if (!(rdp
->status
& AR_S_DEGRADED
) || !(rdp
->status
& AR_S_READY
))
1365 if (rdp
->status
& AR_S_REBUILDING
)
1368 switch (rdp
->type
) {
1372 for (count
= 0, disk
= 0; disk
< rdp
->total_disks
; disk
++ ) {
1373 if (((rdp
->disks
[disk
].flags
&
1374 (AR_DF_PRESENT
|AR_DF_ASSIGNED
|AR_DF_ONLINE
|AR_DF_SPARE
)) ==
1375 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_SPARE
)) &&
1376 rdp
->disks
[disk
].dev
) {
1382 rdp
->rebuild_lba
= 0;
1383 rdp
->status
|= AR_S_REBUILDING
;
1394 ata_raid_read_metadata(device_t subdisk
)
1396 devclass_t pci_devclass
= devclass_find("pci");
1397 devclass_t devclass
=device_get_devclass(GRANDPARENT(GRANDPARENT(subdisk
)));
1401 /* prioritize vendor native metadata layout if possible */
1402 if (devclass
== pci_devclass
) {
1403 gpdev
= device_get_parent(subdisk
);
1404 gpdev
= GRANDPARENT(gpdev
);
1405 vendor
= pci_get_vendor(gpdev
);
1408 case ATA_HIGHPOINT_ID
:
1409 if (ata_raid_hptv3_read_meta(subdisk
, ata_raid_arrays
))
1411 if (ata_raid_hptv2_read_meta(subdisk
, ata_raid_arrays
))
1416 if (ata_raid_intel_read_meta(subdisk
, ata_raid_arrays
))
1421 if (ata_raid_ite_read_meta(subdisk
, ata_raid_arrays
))
1425 case ATA_JMICRON_ID
:
1426 if (ata_raid_jmicron_read_meta(subdisk
, ata_raid_arrays
))
1431 if (ata_raid_nvidia_read_meta(subdisk
, ata_raid_arrays
))
1435 case 0: /* XXX SOS cover up for bug in our PCI code */
1436 case ATA_PROMISE_ID
:
1437 if (ata_raid_promise_read_meta(subdisk
, ata_raid_arrays
, 0))
1442 case ATA_SILICON_IMAGE_ID
:
1443 if (ata_raid_sii_read_meta(subdisk
, ata_raid_arrays
))
1448 if (ata_raid_sis_read_meta(subdisk
, ata_raid_arrays
))
1453 if (ata_raid_via_read_meta(subdisk
, ata_raid_arrays
))
1459 /* handle controllers that have multiple layout possibilities */
1460 /* NOTE: the order of these are not insignificant */
1462 /* Adaptec HostRAID */
1463 if (ata_raid_adaptec_read_meta(subdisk
, ata_raid_arrays
))
1466 /* LSILogic v3 and v2 */
1467 if (ata_raid_lsiv3_read_meta(subdisk
, ata_raid_arrays
))
1469 if (ata_raid_lsiv2_read_meta(subdisk
, ata_raid_arrays
))
1472 /* if none of the above matched, try FreeBSD native format */
1473 return ata_raid_promise_read_meta(subdisk
, ata_raid_arrays
, 1);
1477 ata_raid_write_metadata(struct ar_softc
*rdp
)
1479 switch (rdp
->format
) {
1480 case AR_F_FREEBSD_RAID
:
1481 case AR_F_PROMISE_RAID
:
1482 return ata_raid_promise_write_meta(rdp
);
1484 case AR_F_HPTV3_RAID
:
1485 case AR_F_HPTV2_RAID
:
1487 * always write HPT v2 metadata, the v3 BIOS knows it as well.
1488 * this is handy since we cannot know what version BIOS is on there
1490 return ata_raid_hptv2_write_meta(rdp
);
1492 case AR_F_INTEL_RAID
:
1493 return ata_raid_intel_write_meta(rdp
);
1495 case AR_F_JMICRON_RAID
:
1496 return ata_raid_jmicron_write_meta(rdp
);
1499 return ata_raid_sis_write_meta(rdp
);
1502 return ata_raid_via_write_meta(rdp
);
1504 case AR_F_HPTV3_RAID
:
1505 return ata_raid_hptv3_write_meta(rdp
);
1507 case AR_F_ADAPTEC_RAID
:
1508 return ata_raid_adaptec_write_meta(rdp
);
1511 return ata_raid_ite_write_meta(rdp
);
1513 case AR_F_LSIV2_RAID
:
1514 return ata_raid_lsiv2_write_meta(rdp
);
1516 case AR_F_LSIV3_RAID
:
1517 return ata_raid_lsiv3_write_meta(rdp
);
1519 case AR_F_NVIDIA_RAID
:
1520 return ata_raid_nvidia_write_meta(rdp
);
1523 return ata_raid_sii_write_meta(rdp
);
1527 kprintf("ar%d: writing of %s metadata is NOT supported yet\n",
1528 rdp
->lun
, ata_raid_format(rdp
));
1534 ata_raid_wipe_metadata(struct ar_softc
*rdp
)
1536 int disk
, error
= 0;
1541 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
1542 if (rdp
->disks
[disk
].dev
) {
1543 switch (rdp
->format
) {
1544 case AR_F_ADAPTEC_RAID
:
1545 lba
= ADP_LBA(rdp
->disks
[disk
].dev
);
1546 size
= sizeof(struct adaptec_raid_conf
);
1549 case AR_F_HPTV2_RAID
:
1550 lba
= HPTV2_LBA(rdp
->disks
[disk
].dev
);
1551 size
= sizeof(struct hptv2_raid_conf
);
1554 case AR_F_HPTV3_RAID
:
1555 lba
= HPTV3_LBA(rdp
->disks
[disk
].dev
);
1556 size
= sizeof(struct hptv3_raid_conf
);
1559 case AR_F_INTEL_RAID
:
1560 lba
= INTEL_LBA(rdp
->disks
[disk
].dev
);
1561 size
= 3 * 512; /* XXX SOS */
1565 lba
= ITE_LBA(rdp
->disks
[disk
].dev
);
1566 size
= sizeof(struct ite_raid_conf
);
1569 case AR_F_JMICRON_RAID
:
1570 lba
= JMICRON_LBA(rdp
->disks
[disk
].dev
);
1571 size
= sizeof(struct jmicron_raid_conf
);
1574 case AR_F_LSIV2_RAID
:
1575 lba
= LSIV2_LBA(rdp
->disks
[disk
].dev
);
1576 size
= sizeof(struct lsiv2_raid_conf
);
1579 case AR_F_LSIV3_RAID
:
1580 lba
= LSIV3_LBA(rdp
->disks
[disk
].dev
);
1581 size
= sizeof(struct lsiv3_raid_conf
);
1584 case AR_F_NVIDIA_RAID
:
1585 lba
= NVIDIA_LBA(rdp
->disks
[disk
].dev
);
1586 size
= sizeof(struct nvidia_raid_conf
);
1589 case AR_F_FREEBSD_RAID
:
1590 case AR_F_PROMISE_RAID
:
1591 lba
= PROMISE_LBA(rdp
->disks
[disk
].dev
);
1592 size
= sizeof(struct promise_raid_conf
);
1596 lba
= SII_LBA(rdp
->disks
[disk
].dev
);
1597 size
= sizeof(struct sii_raid_conf
);
1601 lba
= SIS_LBA(rdp
->disks
[disk
].dev
);
1602 size
= sizeof(struct sis_raid_conf
);
1606 lba
= VIA_LBA(rdp
->disks
[disk
].dev
);
1607 size
= sizeof(struct via_raid_conf
);
1611 kprintf("ar%d: wiping of %s metadata is NOT supported yet\n",
1612 rdp
->lun
, ata_raid_format(rdp
));
1615 meta
= kmalloc(size
, M_AR
, M_WAITOK
| M_ZERO
);
1616 if (ata_raid_rw(rdp
->disks
[disk
].dev
, lba
, meta
, size
,
1617 ATA_R_WRITE
| ATA_R_DIRECT
)) {
1618 device_printf(rdp
->disks
[disk
].dev
, "wipe metadata failed\n");
1627 /* Adaptec HostRAID Metadata */
1629 ata_raid_adaptec_read_meta(device_t dev
, struct ar_softc
**raidp
)
1631 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
1632 device_t parent
= device_get_parent(dev
);
1633 struct adaptec_raid_conf
*meta
;
1634 struct ar_softc
*raid
;
1635 int array
, disk
, retval
= 0;
1637 meta
= (struct adaptec_raid_conf
*)
1638 kmalloc(sizeof(struct adaptec_raid_conf
), M_AR
, M_WAITOK
| M_ZERO
);
1640 if (ata_raid_rw(parent
, ADP_LBA(parent
),
1641 meta
, sizeof(struct adaptec_raid_conf
), ATA_R_READ
)) {
1642 if (testing
|| bootverbose
)
1643 device_printf(parent
, "Adaptec read metadata failed\n");
1647 /* check if this is a Adaptec RAID struct */
1648 if (meta
->magic_0
!= ADP_MAGIC_0
|| meta
->magic_3
!= ADP_MAGIC_3
) {
1649 if (testing
|| bootverbose
)
1650 device_printf(parent
, "Adaptec check1 failed\n");
1654 if (testing
|| bootverbose
)
1655 ata_raid_adaptec_print_meta(meta
);
1657 /* now convert Adaptec metadata into our generic form */
1658 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
1659 if (!raidp
[array
]) {
1661 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
1664 raid
= raidp
[array
];
1665 if (raid
->format
&& (raid
->format
!= AR_F_ADAPTEC_RAID
))
1668 if (raid
->magic_0
&& raid
->magic_0
!= meta
->configs
[0].magic_0
)
1671 if (!meta
->generation
|| be32toh(meta
->generation
) > raid
->generation
) {
1672 switch (meta
->configs
[0].type
) {
1674 raid
->magic_0
= meta
->configs
[0].magic_0
;
1675 raid
->type
= AR_T_RAID0
;
1676 raid
->interleave
= 1 << (meta
->configs
[0].stripe_shift
>> 1);
1677 raid
->width
= be16toh(meta
->configs
[0].total_disks
);
1681 raid
->magic_0
= meta
->configs
[0].magic_0
;
1682 raid
->type
= AR_T_RAID1
;
1683 raid
->width
= be16toh(meta
->configs
[0].total_disks
) / 2;
1687 device_printf(parent
, "Adaptec unknown RAID type 0x%02x\n",
1688 meta
->configs
[0].type
);
1689 kfree(raidp
[array
], M_AR
);
1690 raidp
[array
] = NULL
;
1694 raid
->format
= AR_F_ADAPTEC_RAID
;
1695 raid
->generation
= be32toh(meta
->generation
);
1696 raid
->total_disks
= be16toh(meta
->configs
[0].total_disks
);
1697 raid
->total_sectors
= be32toh(meta
->configs
[0].sectors
);
1700 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
1701 raid
->offset_sectors
= 0;
1702 raid
->rebuild_lba
= 0;
1704 strncpy(raid
->name
, meta
->configs
[0].name
,
1705 min(sizeof(raid
->name
), sizeof(meta
->configs
[0].name
)));
1707 /* clear out any old info */
1708 if (raid
->generation
) {
1709 for (disk
= 0; disk
< raid
->total_disks
; disk
++) {
1710 raid
->disks
[disk
].dev
= NULL
;
1711 raid
->disks
[disk
].flags
= 0;
1715 if (be32toh(meta
->generation
) >= raid
->generation
) {
1716 struct ata_device
*atadev
= device_get_softc(parent
);
1717 struct ata_channel
*ch
= device_get_softc(GRANDPARENT(dev
));
1718 int disk_number
= (ch
->unit
<< !(ch
->flags
& ATA_NO_SLAVE
)) +
1719 ATA_DEV(atadev
->unit
);
1721 raid
->disks
[disk_number
].dev
= parent
;
1722 raid
->disks
[disk_number
].sectors
=
1723 be32toh(meta
->configs
[disk_number
+ 1].sectors
);
1724 raid
->disks
[disk_number
].flags
=
1725 (AR_DF_ONLINE
| AR_DF_PRESENT
| AR_DF_ASSIGNED
);
1726 ars
->raid
[raid
->volume
] = raid
;
1727 ars
->disk_number
[raid
->volume
] = disk_number
;
1738 /* Highpoint V2 RocketRAID Metadata */
1740 ata_raid_hptv2_read_meta(device_t dev
, struct ar_softc
**raidp
)
1742 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
1743 device_t parent
= device_get_parent(dev
);
1744 struct hptv2_raid_conf
*meta
;
1745 struct ar_softc
*raid
= NULL
;
1746 int array
, disk_number
= 0, retval
= 0;
1748 meta
= (struct hptv2_raid_conf
*)kmalloc(sizeof(struct hptv2_raid_conf
),
1749 M_AR
, M_WAITOK
| M_ZERO
);
1751 if (ata_raid_rw(parent
, HPTV2_LBA(parent
),
1752 meta
, sizeof(struct hptv2_raid_conf
), ATA_R_READ
)) {
1753 if (testing
|| bootverbose
)
1754 device_printf(parent
, "HighPoint (v2) read metadata failed\n");
1758 /* check if this is a HighPoint v2 RAID struct */
1759 if (meta
->magic
!= HPTV2_MAGIC_OK
&& meta
->magic
!= HPTV2_MAGIC_BAD
) {
1760 if (testing
|| bootverbose
)
1761 device_printf(parent
, "HighPoint (v2) check1 failed\n");
1765 /* is this disk defined, or an old leftover/spare ? */
1766 if (!meta
->magic_0
) {
1767 if (testing
|| bootverbose
)
1768 device_printf(parent
, "HighPoint (v2) check2 failed\n");
1772 if (testing
|| bootverbose
)
1773 ata_raid_hptv2_print_meta(meta
);
1775 /* now convert HighPoint (v2) metadata into our generic form */
1776 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
1777 if (!raidp
[array
]) {
1779 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
1782 raid
= raidp
[array
];
1783 if (raid
->format
&& (raid
->format
!= AR_F_HPTV2_RAID
))
1786 switch (meta
->type
) {
1788 if ((meta
->order
& (HPTV2_O_RAID0
|HPTV2_O_OK
)) ==
1789 (HPTV2_O_RAID0
|HPTV2_O_OK
))
1790 goto highpoint_raid1
;
1791 if (meta
->order
& (HPTV2_O_RAID0
| HPTV2_O_RAID1
))
1792 goto highpoint_raid01
;
1793 if (raid
->magic_0
&& raid
->magic_0
!= meta
->magic_0
)
1795 raid
->magic_0
= meta
->magic_0
;
1796 raid
->type
= AR_T_RAID0
;
1797 raid
->interleave
= 1 << meta
->stripe_shift
;
1798 disk_number
= meta
->disk_number
;
1799 if (!(meta
->order
& HPTV2_O_OK
))
1800 meta
->magic
= 0; /* mark bad */
1805 if (raid
->magic_0
&& raid
->magic_0
!= meta
->magic_0
)
1807 raid
->magic_0
= meta
->magic_0
;
1808 raid
->type
= AR_T_RAID1
;
1809 disk_number
= (meta
->disk_number
> 0);
1812 case HPTV2_T_RAID01_RAID0
:
1814 if (meta
->order
& HPTV2_O_RAID0
) {
1815 if ((raid
->magic_0
&& raid
->magic_0
!= meta
->magic_0
) ||
1816 (raid
->magic_1
&& raid
->magic_1
!= meta
->magic_1
))
1818 raid
->magic_0
= meta
->magic_0
;
1819 raid
->magic_1
= meta
->magic_1
;
1820 raid
->type
= AR_T_RAID01
;
1821 raid
->interleave
= 1 << meta
->stripe_shift
;
1822 disk_number
= meta
->disk_number
;
1825 if (raid
->magic_1
&& raid
->magic_1
!= meta
->magic_1
)
1827 raid
->magic_1
= meta
->magic_1
;
1828 raid
->type
= AR_T_RAID01
;
1829 raid
->interleave
= 1 << meta
->stripe_shift
;
1830 disk_number
= meta
->disk_number
+ meta
->array_width
;
1831 if (!(meta
->order
& HPTV2_O_RAID1
))
1832 meta
->magic
= 0; /* mark bad */
1837 if (raid
->magic_0
&& raid
->magic_0
!= meta
->magic_0
)
1839 raid
->magic_0
= meta
->magic_0
;
1840 raid
->type
= AR_T_SPAN
;
1841 disk_number
= meta
->disk_number
;
1845 device_printf(parent
, "Highpoint (v2) unknown RAID type 0x%02x\n",
1847 kfree(raidp
[array
], M_AR
);
1848 raidp
[array
] = NULL
;
1852 raid
->format
|= AR_F_HPTV2_RAID
;
1853 raid
->disks
[disk_number
].dev
= parent
;
1854 raid
->disks
[disk_number
].flags
= (AR_DF_PRESENT
| AR_DF_ASSIGNED
);
1856 strncpy(raid
->name
, meta
->name_1
,
1857 min(sizeof(raid
->name
), sizeof(meta
->name_1
)));
1858 if (meta
->magic
== HPTV2_MAGIC_OK
) {
1859 raid
->disks
[disk_number
].flags
|= AR_DF_ONLINE
;
1860 raid
->width
= meta
->array_width
;
1861 raid
->total_sectors
= meta
->total_sectors
;
1864 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
1865 raid
->offset_sectors
= HPTV2_LBA(parent
) + 1;
1866 raid
->rebuild_lba
= meta
->rebuild_lba
;
1867 raid
->disks
[disk_number
].sectors
=
1868 raid
->total_sectors
/ raid
->width
;
1871 raid
->disks
[disk_number
].flags
&= ~AR_DF_ONLINE
;
1873 if ((raid
->type
& AR_T_RAID0
) && (raid
->total_disks
< raid
->width
))
1874 raid
->total_disks
= raid
->width
;
1875 if (disk_number
>= raid
->total_disks
)
1876 raid
->total_disks
= disk_number
+ 1;
1877 ars
->raid
[raid
->volume
] = raid
;
1878 ars
->disk_number
[raid
->volume
] = disk_number
;
1889 ata_raid_hptv2_write_meta(struct ar_softc
*rdp
)
1891 struct hptv2_raid_conf
*meta
;
1892 struct timeval timestamp
;
1893 int disk
, error
= 0;
1895 meta
= (struct hptv2_raid_conf
*)kmalloc(sizeof(struct hptv2_raid_conf
),
1896 M_AR
, M_WAITOK
| M_ZERO
);
1898 microtime(×tamp
);
1899 rdp
->magic_0
= timestamp
.tv_sec
+ 2;
1900 rdp
->magic_1
= timestamp
.tv_sec
;
1902 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
1903 if ((rdp
->disks
[disk
].flags
& (AR_DF_PRESENT
| AR_DF_ONLINE
)) ==
1904 (AR_DF_PRESENT
| AR_DF_ONLINE
))
1905 meta
->magic
= HPTV2_MAGIC_OK
;
1906 if (rdp
->disks
[disk
].flags
& AR_DF_ASSIGNED
) {
1907 meta
->magic_0
= rdp
->magic_0
;
1908 if (strlen(rdp
->name
))
1909 strncpy(meta
->name_1
, rdp
->name
, sizeof(meta
->name_1
));
1911 strcpy(meta
->name_1
, "FreeBSD");
1913 meta
->disk_number
= disk
;
1915 switch (rdp
->type
) {
1917 meta
->type
= HPTV2_T_RAID0
;
1918 strcpy(meta
->name_2
, "RAID 0");
1919 if (rdp
->disks
[disk
].flags
& AR_DF_ONLINE
)
1920 meta
->order
= HPTV2_O_OK
;
1924 meta
->type
= HPTV2_T_RAID0
;
1925 strcpy(meta
->name_2
, "RAID 1");
1926 meta
->disk_number
= (disk
< rdp
->width
) ? disk
: disk
+ 5;
1927 meta
->order
= HPTV2_O_RAID0
| HPTV2_O_OK
;
1931 meta
->type
= HPTV2_T_RAID01_RAID0
;
1932 strcpy(meta
->name_2
, "RAID 0+1");
1933 if (rdp
->disks
[disk
].flags
& AR_DF_ONLINE
) {
1934 if (disk
< rdp
->width
) {
1935 meta
->order
= (HPTV2_O_RAID0
| HPTV2_O_RAID1
);
1936 meta
->magic_0
= rdp
->magic_0
- 1;
1939 meta
->order
= HPTV2_O_RAID1
;
1940 meta
->disk_number
-= rdp
->width
;
1944 meta
->magic_0
= rdp
->magic_0
- 1;
1945 meta
->magic_1
= rdp
->magic_1
;
1949 meta
->type
= HPTV2_T_SPAN
;
1950 strcpy(meta
->name_2
, "SPAN");
1957 meta
->array_width
= rdp
->width
;
1958 meta
->stripe_shift
= (rdp
->width
> 1) ? (ffs(rdp
->interleave
)-1) : 0;
1959 meta
->total_sectors
= rdp
->total_sectors
;
1960 meta
->rebuild_lba
= rdp
->rebuild_lba
;
1961 if (testing
|| bootverbose
)
1962 ata_raid_hptv2_print_meta(meta
);
1963 if (rdp
->disks
[disk
].dev
) {
1964 if (ata_raid_rw(rdp
->disks
[disk
].dev
,
1965 HPTV2_LBA(rdp
->disks
[disk
].dev
), meta
,
1966 sizeof(struct promise_raid_conf
),
1967 ATA_R_WRITE
| ATA_R_DIRECT
)) {
1968 device_printf(rdp
->disks
[disk
].dev
, "write metadata failed\n");
1977 /* Highpoint V3 RocketRAID Metadata */
1979 ata_raid_hptv3_read_meta(device_t dev
, struct ar_softc
**raidp
)
1981 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
1982 device_t parent
= device_get_parent(dev
);
1983 struct hptv3_raid_conf
*meta
;
1984 struct ar_softc
*raid
= NULL
;
1985 int array
, disk_number
, retval
= 0;
1987 meta
= (struct hptv3_raid_conf
*)kmalloc(sizeof(struct hptv3_raid_conf
),
1988 M_AR
, M_WAITOK
| M_ZERO
);
1990 if (ata_raid_rw(parent
, HPTV3_LBA(parent
),
1991 meta
, sizeof(struct hptv3_raid_conf
), ATA_R_READ
)) {
1992 if (testing
|| bootverbose
)
1993 device_printf(parent
, "HighPoint (v3) read metadata failed\n");
1997 /* check if this is a HighPoint v3 RAID struct */
1998 if (meta
->magic
!= HPTV3_MAGIC
) {
1999 if (testing
|| bootverbose
)
2000 device_printf(parent
, "HighPoint (v3) check1 failed\n");
2004 /* check if there are any config_entries */
2005 if (meta
->config_entries
< 1) {
2006 if (testing
|| bootverbose
)
2007 device_printf(parent
, "HighPoint (v3) check2 failed\n");
2011 if (testing
|| bootverbose
)
2012 ata_raid_hptv3_print_meta(meta
);
2014 /* now convert HighPoint (v3) metadata into our generic form */
2015 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
2016 if (!raidp
[array
]) {
2018 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
2021 raid
= raidp
[array
];
2022 if (raid
->format
&& (raid
->format
!= AR_F_HPTV3_RAID
))
2025 if ((raid
->format
& AR_F_HPTV3_RAID
) && raid
->magic_0
!= meta
->magic_0
)
2028 switch (meta
->configs
[0].type
) {
2030 raid
->type
= AR_T_RAID0
;
2031 raid
->width
= meta
->configs
[0].total_disks
;
2032 disk_number
= meta
->configs
[0].disk_number
;
2036 raid
->type
= AR_T_RAID1
;
2037 raid
->width
= meta
->configs
[0].total_disks
/ 2;
2038 disk_number
= meta
->configs
[0].disk_number
;
2042 raid
->type
= AR_T_RAID5
;
2043 raid
->width
= meta
->configs
[0].total_disks
;
2044 disk_number
= meta
->configs
[0].disk_number
;
2048 raid
->type
= AR_T_SPAN
;
2049 raid
->width
= meta
->configs
[0].total_disks
;
2050 disk_number
= meta
->configs
[0].disk_number
;
2054 device_printf(parent
, "Highpoint (v3) unknown RAID type 0x%02x\n",
2055 meta
->configs
[0].type
);
2056 kfree(raidp
[array
], M_AR
);
2057 raidp
[array
] = NULL
;
2060 if (meta
->config_entries
== 2) {
2061 switch (meta
->configs
[1].type
) {
2063 if (raid
->type
== AR_T_RAID0
) {
2064 raid
->type
= AR_T_RAID01
;
2065 disk_number
= meta
->configs
[1].disk_number
+
2066 (meta
->configs
[0].disk_number
<< 1);
2070 device_printf(parent
, "Highpoint (v3) unknown level 2 0x%02x\n",
2071 meta
->configs
[1].type
);
2072 kfree(raidp
[array
], M_AR
);
2073 raidp
[array
] = NULL
;
2078 raid
->magic_0
= meta
->magic_0
;
2079 raid
->format
= AR_F_HPTV3_RAID
;
2080 raid
->generation
= meta
->timestamp
;
2081 raid
->interleave
= 1 << meta
->configs
[0].stripe_shift
;
2082 raid
->total_disks
= meta
->configs
[0].total_disks
+
2083 meta
->configs
[1].total_disks
;
2084 raid
->total_sectors
= meta
->configs
[0].total_sectors
+
2085 ((u_int64_t
)meta
->configs_high
[0].total_sectors
<< 32);
2088 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
2089 raid
->offset_sectors
= 0;
2090 raid
->rebuild_lba
= meta
->configs
[0].rebuild_lba
+
2091 ((u_int64_t
)meta
->configs_high
[0].rebuild_lba
<< 32);
2093 strncpy(raid
->name
, meta
->name
,
2094 min(sizeof(raid
->name
), sizeof(meta
->name
)));
2095 raid
->disks
[disk_number
].sectors
= raid
->total_sectors
/
2096 (raid
->type
== AR_T_RAID5
? raid
->width
- 1 : raid
->width
);
2097 raid
->disks
[disk_number
].dev
= parent
;
2098 raid
->disks
[disk_number
].flags
=
2099 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_ONLINE
);
2100 ars
->raid
[raid
->volume
] = raid
;
2101 ars
->disk_number
[raid
->volume
] = disk_number
;
2111 /* Intel MatrixRAID Metadata */
2113 ata_raid_intel_read_meta(device_t dev
, struct ar_softc
**raidp
)
2115 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
2116 device_t parent
= device_get_parent(dev
);
2117 struct intel_raid_conf
*meta
;
2118 struct intel_raid_mapping
*map
;
2119 struct ar_softc
*raid
= NULL
;
2120 u_int32_t checksum
, *ptr
;
2121 int array
, count
, disk
, volume
= 1, retval
= 0;
2124 meta
= (struct intel_raid_conf
*)kmalloc(1536, M_AR
, M_WAITOK
| M_ZERO
);
2126 if (ata_raid_rw(parent
, INTEL_LBA(parent
), meta
, 1024, ATA_R_READ
)) {
2127 if (testing
|| bootverbose
)
2128 device_printf(parent
, "Intel read metadata failed\n");
2132 bcopy(tmp
, tmp
+1024, 512);
2133 bcopy(tmp
+512, tmp
, 1024);
2134 bzero(tmp
+1024, 512);
2136 /* check if this is a Intel RAID struct */
2137 if (strncmp(meta
->intel_id
, INTEL_MAGIC
, strlen(INTEL_MAGIC
))) {
2138 if (testing
|| bootverbose
)
2139 device_printf(parent
, "Intel check1 failed\n");
2143 for (checksum
= 0, ptr
= (u_int32_t
*)meta
, count
= 0;
2144 count
< (meta
->config_size
/ sizeof(u_int32_t
)); count
++) {
2147 checksum
-= meta
->checksum
;
2148 if (checksum
!= meta
->checksum
) {
2149 if (testing
|| bootverbose
)
2150 device_printf(parent
, "Intel check2 failed\n");
2154 if (testing
|| bootverbose
)
2155 ata_raid_intel_print_meta(meta
);
2157 map
= (struct intel_raid_mapping
*)&meta
->disk
[meta
->total_disks
];
2159 /* now convert Intel metadata into our generic form */
2160 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
2161 if (!raidp
[array
]) {
2163 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
2166 raid
= raidp
[array
];
2167 if (raid
->format
&& (raid
->format
!= AR_F_INTEL_RAID
))
2170 if ((raid
->format
& AR_F_INTEL_RAID
) &&
2171 (raid
->magic_0
!= meta
->config_id
))
2175 * update our knowledge about the array config based on generation
2176 * NOTE: there can be multiple volumes on a disk set
2178 if (!meta
->generation
|| meta
->generation
> raid
->generation
) {
2179 switch (map
->type
) {
2181 raid
->type
= AR_T_RAID0
;
2182 raid
->width
= map
->total_disks
;
2186 if (map
->total_disks
== 4)
2187 raid
->type
= AR_T_RAID01
;
2189 raid
->type
= AR_T_RAID1
;
2190 raid
->width
= map
->total_disks
/ 2;
2194 raid
->type
= AR_T_RAID5
;
2195 raid
->width
= map
->total_disks
;
2199 device_printf(parent
, "Intel unknown RAID type 0x%02x\n",
2201 kfree(raidp
[array
], M_AR
);
2202 raidp
[array
] = NULL
;
2206 switch (map
->status
) {
2208 raid
->status
= AR_S_READY
;
2210 case INTEL_S_DEGRADED
:
2211 raid
->status
|= AR_S_DEGRADED
;
2213 case INTEL_S_DISABLED
:
2214 case INTEL_S_FAILURE
:
2218 raid
->magic_0
= meta
->config_id
;
2219 raid
->format
= AR_F_INTEL_RAID
;
2220 raid
->generation
= meta
->generation
;
2221 raid
->interleave
= map
->stripe_sectors
;
2222 raid
->total_disks
= map
->total_disks
;
2223 raid
->total_sectors
= map
->total_sectors
;
2226 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
2227 raid
->offset_sectors
= map
->offset
;
2228 raid
->rebuild_lba
= 0;
2230 raid
->volume
= volume
- 1;
2231 strncpy(raid
->name
, map
->name
,
2232 min(sizeof(raid
->name
), sizeof(map
->name
)));
2234 /* clear out any old info */
2235 for (disk
= 0; disk
< raid
->total_disks
; disk
++) {
2236 raid
->disks
[disk
].dev
= NULL
;
2237 bcopy(meta
->disk
[map
->disk_idx
[disk
]].serial
,
2238 raid
->disks
[disk
].serial
,
2239 sizeof(raid
->disks
[disk
].serial
));
2240 raid
->disks
[disk
].sectors
=
2241 meta
->disk
[map
->disk_idx
[disk
]].sectors
;
2242 raid
->disks
[disk
].flags
= 0;
2243 if (meta
->disk
[map
->disk_idx
[disk
]].flags
& INTEL_F_ONLINE
)
2244 raid
->disks
[disk
].flags
|= AR_DF_ONLINE
;
2245 if (meta
->disk
[map
->disk_idx
[disk
]].flags
& INTEL_F_ASSIGNED
)
2246 raid
->disks
[disk
].flags
|= AR_DF_ASSIGNED
;
2247 if (meta
->disk
[map
->disk_idx
[disk
]].flags
& INTEL_F_SPARE
) {
2248 raid
->disks
[disk
].flags
&= ~(AR_DF_ONLINE
| AR_DF_ASSIGNED
);
2249 raid
->disks
[disk
].flags
|= AR_DF_SPARE
;
2251 if (meta
->disk
[map
->disk_idx
[disk
]].flags
& INTEL_F_DOWN
)
2252 raid
->disks
[disk
].flags
&= ~AR_DF_ONLINE
;
2255 if (meta
->generation
>= raid
->generation
) {
2256 for (disk
= 0; disk
< raid
->total_disks
; disk
++) {
2257 struct ata_device
*atadev
= device_get_softc(parent
);
2259 if (!strncmp(raid
->disks
[disk
].serial
, atadev
->param
.serial
,
2260 sizeof(raid
->disks
[disk
].serial
))) {
2261 raid
->disks
[disk
].dev
= parent
;
2262 raid
->disks
[disk
].flags
|= (AR_DF_PRESENT
| AR_DF_ONLINE
);
2263 ars
->raid
[raid
->volume
] = raid
;
2264 ars
->disk_number
[raid
->volume
] = disk
;
2273 if (volume
< meta
->total_volumes
) {
2274 map
= (struct intel_raid_mapping
*)
2275 &map
->disk_idx
[map
->total_disks
];
2283 kfree(raidp
[array
], M_AR
);
2284 raidp
[array
] = NULL
;
2296 ata_raid_intel_write_meta(struct ar_softc
*rdp
)
2298 struct intel_raid_conf
*meta
;
2299 struct intel_raid_mapping
*map
;
2300 struct timeval timestamp
;
2301 u_int32_t checksum
, *ptr
;
2302 int count
, disk
, error
= 0;
2305 meta
= (struct intel_raid_conf
*)kmalloc(1536, M_AR
, M_WAITOK
| M_ZERO
);
2309 /* Generate a new config_id if none exists */
2310 if (!rdp
->magic_0
) {
2311 microtime(×tamp
);
2312 rdp
->magic_0
= timestamp
.tv_sec
^ timestamp
.tv_usec
;
2315 bcopy(INTEL_MAGIC
, meta
->intel_id
, sizeof(meta
->intel_id
));
2316 bcopy(INTEL_VERSION_1100
, meta
->version
, sizeof(meta
->version
));
2317 meta
->config_id
= rdp
->magic_0
;
2318 meta
->generation
= rdp
->generation
;
2319 meta
->total_disks
= rdp
->total_disks
;
2320 meta
->total_volumes
= 1; /* XXX SOS */
2321 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
2322 if (rdp
->disks
[disk
].dev
) {
2323 struct ata_channel
*ch
=
2324 device_get_softc(device_get_parent(rdp
->disks
[disk
].dev
));
2325 struct ata_device
*atadev
=
2326 device_get_softc(rdp
->disks
[disk
].dev
);
2328 bcopy(atadev
->param
.serial
, meta
->disk
[disk
].serial
,
2329 sizeof(rdp
->disks
[disk
].serial
));
2330 meta
->disk
[disk
].sectors
= rdp
->disks
[disk
].sectors
;
2331 meta
->disk
[disk
].id
= (ch
->unit
<< 16) | ATA_DEV(atadev
->unit
);
2334 meta
->disk
[disk
].sectors
= rdp
->total_sectors
/ rdp
->width
;
2335 meta
->disk
[disk
].flags
= 0;
2336 if (rdp
->disks
[disk
].flags
& AR_DF_SPARE
)
2337 meta
->disk
[disk
].flags
|= INTEL_F_SPARE
;
2339 if (rdp
->disks
[disk
].flags
& AR_DF_ONLINE
)
2340 meta
->disk
[disk
].flags
|= INTEL_F_ONLINE
;
2342 meta
->disk
[disk
].flags
|= INTEL_F_DOWN
;
2343 if (rdp
->disks
[disk
].flags
& AR_DF_ASSIGNED
)
2344 meta
->disk
[disk
].flags
|= INTEL_F_ASSIGNED
;
2347 map
= (struct intel_raid_mapping
*)&meta
->disk
[meta
->total_disks
];
2349 bcopy(rdp
->name
, map
->name
, sizeof(rdp
->name
));
2350 map
->total_sectors
= rdp
->total_sectors
;
2351 map
->state
= 12; /* XXX SOS */
2352 map
->offset
= rdp
->offset_sectors
;
2353 map
->stripe_count
= rdp
->total_sectors
/ (rdp
->interleave
*rdp
->total_disks
);
2354 map
->stripe_sectors
= rdp
->interleave
;
2355 map
->disk_sectors
= rdp
->total_sectors
/ rdp
->width
;
2356 map
->status
= INTEL_S_READY
; /* XXX SOS */
2357 switch (rdp
->type
) {
2359 map
->type
= INTEL_T_RAID0
;
2362 map
->type
= INTEL_T_RAID1
;
2365 map
->type
= INTEL_T_RAID1
;
2368 map
->type
= INTEL_T_RAID5
;
2374 map
->total_disks
= rdp
->total_disks
;
2375 map
->magic
[0] = 0x02;
2376 map
->magic
[1] = 0xff;
2377 map
->magic
[2] = 0x01;
2378 for (disk
= 0; disk
< rdp
->total_disks
; disk
++)
2379 map
->disk_idx
[disk
] = disk
;
2381 meta
->config_size
= (char *)&map
->disk_idx
[disk
] - (char *)meta
;
2382 for (checksum
= 0, ptr
= (u_int32_t
*)meta
, count
= 0;
2383 count
< (meta
->config_size
/ sizeof(u_int32_t
)); count
++) {
2386 meta
->checksum
= checksum
;
2388 if (testing
|| bootverbose
)
2389 ata_raid_intel_print_meta(meta
);
2392 bcopy(tmp
, tmp
+1024, 512);
2393 bcopy(tmp
+512, tmp
, 1024);
2394 bzero(tmp
+1024, 512);
2396 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
2397 if (rdp
->disks
[disk
].dev
) {
2398 if (ata_raid_rw(rdp
->disks
[disk
].dev
,
2399 INTEL_LBA(rdp
->disks
[disk
].dev
),
2400 meta
, 1024, ATA_R_WRITE
| ATA_R_DIRECT
)) {
2401 device_printf(rdp
->disks
[disk
].dev
, "write metadata failed\n");
2411 /* Integrated Technology Express Metadata */
2413 ata_raid_ite_read_meta(device_t dev
, struct ar_softc
**raidp
)
2415 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
2416 device_t parent
= device_get_parent(dev
);
2417 struct ite_raid_conf
*meta
;
2418 struct ar_softc
*raid
= NULL
;
2419 int array
, disk_number
, count
, retval
= 0;
2422 meta
= (struct ite_raid_conf
*)kmalloc(sizeof(struct ite_raid_conf
), M_AR
,
2425 if (ata_raid_rw(parent
, ITE_LBA(parent
),
2426 meta
, sizeof(struct ite_raid_conf
), ATA_R_READ
)) {
2427 if (testing
|| bootverbose
)
2428 device_printf(parent
, "ITE read metadata failed\n");
2432 /* check if this is a ITE RAID struct */
2433 for (ptr
= (u_int16_t
*)meta
->ite_id
, count
= 0;
2434 count
< sizeof(meta
->ite_id
)/sizeof(uint16_t); count
++)
2435 ptr
[count
] = be16toh(ptr
[count
]);
2437 if (strncmp(meta
->ite_id
, ITE_MAGIC
, strlen(ITE_MAGIC
))) {
2438 if (testing
|| bootverbose
)
2439 device_printf(parent
, "ITE check1 failed\n");
2443 if (testing
|| bootverbose
)
2444 ata_raid_ite_print_meta(meta
);
2446 /* now convert ITE metadata into our generic form */
2447 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
2448 if ((raid
= raidp
[array
])) {
2449 if (raid
->format
!= AR_F_ITE_RAID
)
2451 if (raid
->magic_0
!= *((u_int64_t
*)meta
->timestamp_0
))
2455 /* if we dont have a disks timestamp the RAID is invalidated */
2456 if (*((u_int64_t
*)meta
->timestamp_1
) == 0)
2460 raidp
[array
] = (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
),
2461 M_AR
, M_WAITOK
| M_ZERO
);
2464 switch (meta
->type
) {
2466 raid
->type
= AR_T_RAID0
;
2467 raid
->width
= meta
->array_width
;
2468 raid
->total_disks
= meta
->array_width
;
2469 disk_number
= meta
->disk_number
;
2473 raid
->type
= AR_T_RAID1
;
2475 raid
->total_disks
= 2;
2476 disk_number
= meta
->disk_number
;
2480 raid
->type
= AR_T_RAID01
;
2481 raid
->width
= meta
->array_width
;
2482 raid
->total_disks
= 4;
2483 disk_number
= ((meta
->disk_number
& 0x02) >> 1) |
2484 ((meta
->disk_number
& 0x01) << 1);
2488 raid
->type
= AR_T_SPAN
;
2490 raid
->total_disks
= meta
->array_width
;
2491 disk_number
= meta
->disk_number
;
2495 device_printf(parent
, "ITE unknown RAID type 0x%02x\n", meta
->type
);
2496 kfree(raidp
[array
], M_AR
);
2497 raidp
[array
] = NULL
;
2501 raid
->magic_0
= *((u_int64_t
*)meta
->timestamp_0
);
2502 raid
->format
= AR_F_ITE_RAID
;
2503 raid
->generation
= 0;
2504 raid
->interleave
= meta
->stripe_sectors
;
2505 raid
->total_sectors
= meta
->total_sectors
;
2508 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
2509 raid
->offset_sectors
= 0;
2510 raid
->rebuild_lba
= 0;
2513 raid
->disks
[disk_number
].dev
= parent
;
2514 raid
->disks
[disk_number
].sectors
= raid
->total_sectors
/ raid
->width
;
2515 raid
->disks
[disk_number
].flags
=
2516 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_ONLINE
);
2517 ars
->raid
[raid
->volume
] = raid
;
2518 ars
->disk_number
[raid
->volume
] = disk_number
;
2527 /* JMicron Technology Corp Metadata */
2529 ata_raid_jmicron_read_meta(device_t dev
, struct ar_softc
**raidp
)
2531 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
2532 device_t parent
= device_get_parent(dev
);
2533 struct jmicron_raid_conf
*meta
;
2534 struct ar_softc
*raid
= NULL
;
2535 u_int16_t checksum
, *ptr
;
2536 u_int64_t disk_size
;
2537 int count
, array
, disk
, total_disks
, retval
= 0;
2539 meta
= (struct jmicron_raid_conf
*)
2540 kmalloc(sizeof(struct jmicron_raid_conf
), M_AR
, M_WAITOK
| M_ZERO
);
2542 if (ata_raid_rw(parent
, JMICRON_LBA(parent
),
2543 meta
, sizeof(struct jmicron_raid_conf
), ATA_R_READ
)) {
2544 if (testing
|| bootverbose
)
2545 device_printf(parent
,
2546 "JMicron read metadata failed\n");
2549 /* check for JMicron signature */
2550 if (strncmp(meta
->signature
, JMICRON_MAGIC
, 2)) {
2551 if (testing
|| bootverbose
)
2552 device_printf(parent
, "JMicron check1 failed\n");
2556 /* calculate checksum and compare for valid */
2557 for (checksum
= 0, ptr
= (u_int16_t
*)meta
, count
= 0; count
< 64; count
++)
2560 if (testing
|| bootverbose
)
2561 device_printf(parent
, "JMicron check2 failed\n");
2565 if (testing
|| bootverbose
)
2566 ata_raid_jmicron_print_meta(meta
);
2568 /* now convert JMicron meta into our generic form */
2569 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
2571 if (!raidp
[array
]) {
2573 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
2576 raid
= raidp
[array
];
2577 if (raid
->format
&& (raid
->format
!= AR_F_JMICRON_RAID
))
2580 for (total_disks
= 0, disk
= 0; disk
< JM_MAX_DISKS
; disk
++) {
2581 if (meta
->disks
[disk
]) {
2582 if (raid
->format
== AR_F_JMICRON_RAID
) {
2583 if (bcmp(&meta
->disks
[disk
],
2584 raid
->disks
[disk
].serial
, sizeof(u_int32_t
))) {
2590 bcopy(&meta
->disks
[disk
],
2591 raid
->disks
[disk
].serial
, sizeof(u_int32_t
));
2595 /* handle spares XXX SOS */
2597 switch (meta
->type
) {
2599 raid
->type
= AR_T_RAID0
;
2600 raid
->width
= total_disks
;
2604 raid
->type
= AR_T_RAID1
;
2609 raid
->type
= AR_T_RAID01
;
2610 raid
->width
= total_disks
/ 2;
2614 raid
->type
= AR_T_RAID5
;
2615 raid
->width
= total_disks
;
2619 raid
->type
= AR_T_SPAN
;
2624 device_printf(parent
,
2625 "JMicron unknown RAID type 0x%02x\n", meta
->type
);
2626 kfree(raidp
[array
], M_AR
);
2627 raidp
[array
] = NULL
;
2630 disk_size
= (meta
->disk_sectors_high
<< 16) + meta
->disk_sectors_low
;
2631 raid
->format
= AR_F_JMICRON_RAID
;
2632 strncpy(raid
->name
, meta
->name
, sizeof(meta
->name
));
2633 raid
->generation
= 0;
2634 raid
->interleave
= 2 << meta
->stripe_shift
;
2635 raid
->total_disks
= total_disks
;
2636 raid
->total_sectors
= disk_size
* (raid
->width
-(raid
->type
==AR_RAID5
));
2639 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
2640 raid
->offset_sectors
= meta
->offset
* 16;
2641 raid
->rebuild_lba
= 0;
2644 for (disk
= 0; disk
< raid
->total_disks
; disk
++) {
2645 if (meta
->disks
[disk
] == meta
->disk_id
) {
2646 raid
->disks
[disk
].dev
= parent
;
2647 raid
->disks
[disk
].sectors
= disk_size
;
2648 raid
->disks
[disk
].flags
=
2649 (AR_DF_ONLINE
| AR_DF_PRESENT
| AR_DF_ASSIGNED
);
2650 ars
->raid
[raid
->volume
] = raid
;
2651 ars
->disk_number
[raid
->volume
] = disk
;
2664 ata_raid_jmicron_write_meta(struct ar_softc
*rdp
)
2666 struct jmicron_raid_conf
*meta
;
2667 u_int64_t disk_sectors
;
2668 int disk
, error
= 0;
2670 meta
= (struct jmicron_raid_conf
*)
2671 kmalloc(sizeof(struct jmicron_raid_conf
), M_AR
, M_WAITOK
| M_ZERO
);
2674 switch (rdp
->type
) {
2676 meta
->type
= JM_T_JBOD
;
2680 meta
->type
= JM_T_RAID0
;
2684 meta
->type
= JM_T_RAID1
;
2688 meta
->type
= JM_T_RAID5
;
2692 meta
->type
= JM_T_RAID01
;
2699 bcopy(JMICRON_MAGIC
, meta
->signature
, sizeof(JMICRON_MAGIC
));
2700 meta
->version
= JMICRON_VERSION
;
2701 meta
->offset
= rdp
->offset_sectors
/ 16;
2702 disk_sectors
= rdp
->total_sectors
/ (rdp
->width
- (rdp
->type
== AR_RAID5
));
2703 meta
->disk_sectors_low
= disk_sectors
& 0xffff;
2704 meta
->disk_sectors_high
= disk_sectors
>> 16;
2705 strncpy(meta
->name
, rdp
->name
, sizeof(meta
->name
));
2706 meta
->stripe_shift
= ffs(rdp
->interleave
) - 2;
2708 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
2709 if (rdp
->disks
[disk
].serial
[0])
2710 bcopy(rdp
->disks
[disk
].serial
,&meta
->disks
[disk
],sizeof(u_int32_t
));
2712 meta
->disks
[disk
] = (u_int32_t
)(uintptr_t)rdp
->disks
[disk
].dev
;
2715 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
2716 if (rdp
->disks
[disk
].dev
) {
2717 u_int16_t checksum
= 0, *ptr
;
2720 meta
->disk_id
= meta
->disks
[disk
];
2722 for (ptr
= (u_int16_t
*)meta
, count
= 0; count
< 64; count
++)
2724 meta
->checksum
-= checksum
;
2726 if (testing
|| bootverbose
)
2727 ata_raid_jmicron_print_meta(meta
);
2729 if (ata_raid_rw(rdp
->disks
[disk
].dev
,
2730 JMICRON_LBA(rdp
->disks
[disk
].dev
),
2731 meta
, sizeof(struct jmicron_raid_conf
),
2732 ATA_R_WRITE
| ATA_R_DIRECT
)) {
2733 device_printf(rdp
->disks
[disk
].dev
, "write metadata failed\n");
2738 /* handle spares XXX SOS */
2744 /* LSILogic V2 MegaRAID Metadata */
2746 ata_raid_lsiv2_read_meta(device_t dev
, struct ar_softc
**raidp
)
2748 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
2749 device_t parent
= device_get_parent(dev
);
2750 struct lsiv2_raid_conf
*meta
;
2751 struct ar_softc
*raid
= NULL
;
2752 int array
, retval
= 0;
2754 meta
= (struct lsiv2_raid_conf
*)kmalloc(sizeof(struct lsiv2_raid_conf
),
2755 M_AR
, M_WAITOK
| M_ZERO
);
2757 if (ata_raid_rw(parent
, LSIV2_LBA(parent
),
2758 meta
, sizeof(struct lsiv2_raid_conf
), ATA_R_READ
)) {
2759 if (testing
|| bootverbose
)
2760 device_printf(parent
, "LSI (v2) read metadata failed\n");
2764 /* check if this is a LSI RAID struct */
2765 if (strncmp(meta
->lsi_id
, LSIV2_MAGIC
, strlen(LSIV2_MAGIC
))) {
2766 if (testing
|| bootverbose
)
2767 device_printf(parent
, "LSI (v2) check1 failed\n");
2771 if (testing
|| bootverbose
)
2772 ata_raid_lsiv2_print_meta(meta
);
2774 /* now convert LSI (v2) config meta into our generic form */
2775 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
2776 int raid_entry
, conf_entry
;
2778 if (!raidp
[array
+ meta
->raid_number
]) {
2779 raidp
[array
+ meta
->raid_number
] =
2780 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
2783 raid
= raidp
[array
+ meta
->raid_number
];
2784 if (raid
->format
&& (raid
->format
!= AR_F_LSIV2_RAID
))
2787 if (raid
->magic_0
&&
2788 ((raid
->magic_0
!= meta
->timestamp
) ||
2789 (raid
->magic_1
!= meta
->raid_number
)))
2792 array
+= meta
->raid_number
;
2794 raid_entry
= meta
->raid_number
;
2795 conf_entry
= (meta
->configs
[raid_entry
].raid
.config_offset
>> 4) +
2796 meta
->disk_number
- 1;
2798 switch (meta
->configs
[raid_entry
].raid
.type
) {
2800 raid
->magic_0
= meta
->timestamp
;
2801 raid
->magic_1
= meta
->raid_number
;
2802 raid
->type
= AR_T_RAID0
;
2803 raid
->interleave
= meta
->configs
[raid_entry
].raid
.stripe_sectors
;
2804 raid
->width
= meta
->configs
[raid_entry
].raid
.array_width
;
2808 raid
->magic_0
= meta
->timestamp
;
2809 raid
->magic_1
= meta
->raid_number
;
2810 raid
->type
= AR_T_RAID1
;
2811 raid
->width
= meta
->configs
[raid_entry
].raid
.array_width
;
2814 case LSIV2_T_RAID0
| LSIV2_T_RAID1
:
2815 raid
->magic_0
= meta
->timestamp
;
2816 raid
->magic_1
= meta
->raid_number
;
2817 raid
->type
= AR_T_RAID01
;
2818 raid
->interleave
= meta
->configs
[raid_entry
].raid
.stripe_sectors
;
2819 raid
->width
= meta
->configs
[raid_entry
].raid
.array_width
;
2823 device_printf(parent
, "LSI v2 unknown RAID type 0x%02x\n",
2824 meta
->configs
[raid_entry
].raid
.type
);
2825 kfree(raidp
[array
], M_AR
);
2826 raidp
[array
] = NULL
;
2830 raid
->format
= AR_F_LSIV2_RAID
;
2831 raid
->generation
= 0;
2832 raid
->total_disks
= meta
->configs
[raid_entry
].raid
.disk_count
;
2833 raid
->total_sectors
= meta
->configs
[raid_entry
].raid
.total_sectors
;
2836 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
2837 raid
->offset_sectors
= 0;
2838 raid
->rebuild_lba
= 0;
2841 if (meta
->configs
[conf_entry
].disk
.device
!= LSIV2_D_NONE
) {
2842 raid
->disks
[meta
->disk_number
].dev
= parent
;
2843 raid
->disks
[meta
->disk_number
].sectors
=
2844 meta
->configs
[conf_entry
].disk
.disk_sectors
;
2845 raid
->disks
[meta
->disk_number
].flags
=
2846 (AR_DF_ONLINE
| AR_DF_PRESENT
| AR_DF_ASSIGNED
);
2847 ars
->raid
[raid
->volume
] = raid
;
2848 ars
->disk_number
[raid
->volume
] = meta
->disk_number
;
2852 raid
->disks
[meta
->disk_number
].flags
&= ~AR_DF_ONLINE
;
2862 /* LSILogic V3 MegaRAID Metadata */
2864 ata_raid_lsiv3_read_meta(device_t dev
, struct ar_softc
**raidp
)
2866 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
2867 device_t parent
= device_get_parent(dev
);
2868 struct lsiv3_raid_conf
*meta
;
2869 struct ar_softc
*raid
= NULL
;
2870 u_int8_t checksum
, *ptr
;
2871 int array
, entry
, count
, disk_number
, retval
= 0;
2873 meta
= (struct lsiv3_raid_conf
*)kmalloc(sizeof(struct lsiv3_raid_conf
),
2874 M_AR
, M_WAITOK
| M_ZERO
);
2876 if (ata_raid_rw(parent
, LSIV3_LBA(parent
),
2877 meta
, sizeof(struct lsiv3_raid_conf
), ATA_R_READ
)) {
2878 if (testing
|| bootverbose
)
2879 device_printf(parent
, "LSI (v3) read metadata failed\n");
2883 /* check if this is a LSI RAID struct */
2884 if (strncmp(meta
->lsi_id
, LSIV3_MAGIC
, strlen(LSIV3_MAGIC
))) {
2885 if (testing
|| bootverbose
)
2886 device_printf(parent
, "LSI (v3) check1 failed\n");
2890 /* check if the checksum is OK */
2891 for (checksum
= 0, ptr
= meta
->lsi_id
, count
= 0; count
< 512; count
++)
2894 if (testing
|| bootverbose
)
2895 device_printf(parent
, "LSI (v3) check2 failed\n");
2899 if (testing
|| bootverbose
)
2900 ata_raid_lsiv3_print_meta(meta
);
2902 /* now convert LSI (v3) config meta into our generic form */
2903 for (array
= 0, entry
= 0; array
< MAX_ARRAYS
&& entry
< 8;) {
2904 if (!raidp
[array
]) {
2906 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
2909 raid
= raidp
[array
];
2910 if (raid
->format
&& (raid
->format
!= AR_F_LSIV3_RAID
)) {
2915 if ((raid
->format
== AR_F_LSIV3_RAID
) &&
2916 (raid
->magic_0
!= meta
->timestamp
)) {
2921 switch (meta
->raid
[entry
].total_disks
) {
2926 if (meta
->raid
[entry
].device
== meta
->device
) {
2935 disk_number
= (meta
->device
& (LSIV3_D_DEVICE
|LSIV3_D_CHANNEL
))?1:0;
2938 device_printf(parent
, "lsiv3 > 2 disk support untested!!\n");
2939 disk_number
= (meta
->device
& LSIV3_D_DEVICE
? 1 : 0) +
2940 (meta
->device
& LSIV3_D_CHANNEL
? 2 : 0);
2944 switch (meta
->raid
[entry
].type
) {
2946 raid
->type
= AR_T_RAID0
;
2947 raid
->width
= meta
->raid
[entry
].total_disks
;
2951 raid
->type
= AR_T_RAID1
;
2952 raid
->width
= meta
->raid
[entry
].array_width
;
2956 device_printf(parent
, "LSI v3 unknown RAID type 0x%02x\n",
2957 meta
->raid
[entry
].type
);
2958 kfree(raidp
[array
], M_AR
);
2959 raidp
[array
] = NULL
;
2964 raid
->magic_0
= meta
->timestamp
;
2965 raid
->format
= AR_F_LSIV3_RAID
;
2966 raid
->generation
= 0;
2967 raid
->interleave
= meta
->raid
[entry
].stripe_pages
* 8;
2968 raid
->total_disks
= meta
->raid
[entry
].total_disks
;
2969 raid
->total_sectors
= raid
->width
* meta
->raid
[entry
].sectors
;
2972 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
2973 raid
->offset_sectors
= meta
->raid
[entry
].offset
;
2974 raid
->rebuild_lba
= 0;
2977 raid
->disks
[disk_number
].dev
= parent
;
2978 raid
->disks
[disk_number
].sectors
= raid
->total_sectors
/ raid
->width
;
2979 raid
->disks
[disk_number
].flags
=
2980 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_ONLINE
);
2981 ars
->raid
[raid
->volume
] = raid
;
2982 ars
->disk_number
[raid
->volume
] = disk_number
;
2993 /* nVidia MediaShield Metadata */
2995 ata_raid_nvidia_read_meta(device_t dev
, struct ar_softc
**raidp
)
2997 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
2998 device_t parent
= device_get_parent(dev
);
2999 struct nvidia_raid_conf
*meta
;
3000 struct ar_softc
*raid
= NULL
;
3001 u_int32_t checksum
, *ptr
;
3002 int array
, count
, retval
= 0;
3004 meta
= (struct nvidia_raid_conf
*)kmalloc(sizeof(struct nvidia_raid_conf
),
3005 M_AR
, M_WAITOK
| M_ZERO
);
3007 if (ata_raid_rw(parent
, NVIDIA_LBA(parent
),
3008 meta
, sizeof(struct nvidia_raid_conf
), ATA_R_READ
)) {
3009 if (testing
|| bootverbose
)
3010 device_printf(parent
, "nVidia read metadata failed\n");
3014 /* check if this is a nVidia RAID struct */
3015 if (strncmp(meta
->nvidia_id
, NV_MAGIC
, strlen(NV_MAGIC
))) {
3016 if (testing
|| bootverbose
)
3017 device_printf(parent
, "nVidia check1 failed\n");
3021 /* check if the checksum is OK */
3022 for (checksum
= 0, ptr
= (u_int32_t
*)meta
, count
= 0;
3023 count
< meta
->config_size
; count
++)
3026 if (testing
|| bootverbose
)
3027 device_printf(parent
, "nVidia check2 failed\n");
3031 if (testing
|| bootverbose
)
3032 ata_raid_nvidia_print_meta(meta
);
3034 /* now convert nVidia meta into our generic form */
3035 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
3036 if (!raidp
[array
]) {
3038 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
3041 raid
= raidp
[array
];
3042 if (raid
->format
&& (raid
->format
!= AR_F_NVIDIA_RAID
))
3045 if (raid
->format
== AR_F_NVIDIA_RAID
&&
3046 ((raid
->magic_0
!= meta
->magic_1
) ||
3047 (raid
->magic_1
!= meta
->magic_2
))) {
3051 switch (meta
->type
) {
3053 raid
->type
= AR_T_SPAN
;
3057 raid
->type
= AR_T_RAID0
;
3061 raid
->type
= AR_T_RAID1
;
3065 raid
->type
= AR_T_RAID5
;
3069 raid
->type
= AR_T_RAID01
;
3073 device_printf(parent
, "nVidia unknown RAID type 0x%02x\n",
3075 kfree(raidp
[array
], M_AR
);
3076 raidp
[array
] = NULL
;
3079 raid
->magic_0
= meta
->magic_1
;
3080 raid
->magic_1
= meta
->magic_2
;
3081 raid
->format
= AR_F_NVIDIA_RAID
;
3082 raid
->generation
= 0;
3083 raid
->interleave
= meta
->stripe_sectors
;
3084 raid
->width
= meta
->array_width
;
3085 raid
->total_disks
= meta
->total_disks
;
3086 raid
->total_sectors
= meta
->total_sectors
;
3089 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
3090 raid
->offset_sectors
= 0;
3091 raid
->rebuild_lba
= meta
->rebuild_lba
;
3093 raid
->status
= AR_S_READY
;
3094 if (meta
->status
& NV_S_DEGRADED
)
3095 raid
->status
|= AR_S_DEGRADED
;
3097 raid
->disks
[meta
->disk_number
].dev
= parent
;
3098 raid
->disks
[meta
->disk_number
].sectors
=
3099 raid
->total_sectors
/ raid
->width
;
3100 raid
->disks
[meta
->disk_number
].flags
=
3101 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_ONLINE
);
3102 ars
->raid
[raid
->volume
] = raid
;
3103 ars
->disk_number
[raid
->volume
] = meta
->disk_number
;
3113 /* Promise FastTrak Metadata */
3115 ata_raid_promise_read_meta(device_t dev
, struct ar_softc
**raidp
, int native
)
3117 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
3118 device_t parent
= device_get_parent(dev
);
3119 struct promise_raid_conf
*meta
;
3120 struct ar_softc
*raid
;
3121 u_int32_t checksum
, *ptr
;
3122 int array
, count
, disk
, disksum
= 0, retval
= 0;
3124 meta
= (struct promise_raid_conf
*)
3125 kmalloc(sizeof(struct promise_raid_conf
), M_AR
, M_WAITOK
| M_ZERO
);
3127 if (ata_raid_rw(parent
, PROMISE_LBA(parent
),
3128 meta
, sizeof(struct promise_raid_conf
), ATA_R_READ
)) {
3129 if (testing
|| bootverbose
)
3130 device_printf(parent
, "%s read metadata failed\n",
3131 native
? "FreeBSD" : "Promise");
3135 /* check the signature */
3137 if (strncmp(meta
->promise_id
, ATA_MAGIC
, strlen(ATA_MAGIC
))) {
3138 if (testing
|| bootverbose
)
3139 device_printf(parent
, "FreeBSD check1 failed\n");
3144 if (strncmp(meta
->promise_id
, PR_MAGIC
, strlen(PR_MAGIC
))) {
3145 if (testing
|| bootverbose
)
3146 device_printf(parent
, "Promise check1 failed\n");
3151 /* check if the checksum is OK */
3152 for (checksum
= 0, ptr
= (u_int32_t
*)meta
, count
= 0; count
< 511; count
++)
3154 if (checksum
!= *ptr
) {
3155 if (testing
|| bootverbose
)
3156 device_printf(parent
, "%s check2 failed\n",
3157 native
? "FreeBSD" : "Promise");
3161 /* check on disk integrity status */
3162 if (meta
->raid
.integrity
!= PR_I_VALID
) {
3163 if (testing
|| bootverbose
)
3164 device_printf(parent
, "%s check3 failed\n",
3165 native
? "FreeBSD" : "Promise");
3169 if (testing
|| bootverbose
)
3170 ata_raid_promise_print_meta(meta
);
3172 /* now convert Promise metadata into our generic form */
3173 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
3174 if (!raidp
[array
]) {
3176 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
3179 raid
= raidp
[array
];
3181 (raid
->format
!= (native
? AR_F_FREEBSD_RAID
: AR_F_PROMISE_RAID
)))
3184 if ((raid
->format
== (native
? AR_F_FREEBSD_RAID
: AR_F_PROMISE_RAID
))&&
3185 !(meta
->raid
.magic_1
== (raid
->magic_1
)))
3188 /* update our knowledge about the array config based on generation */
3189 if (!meta
->raid
.generation
|| meta
->raid
.generation
> raid
->generation
){
3190 switch (meta
->raid
.type
) {
3192 raid
->type
= AR_T_SPAN
;
3196 raid
->type
= AR_T_JBOD
;
3200 raid
->type
= AR_T_RAID0
;
3204 raid
->type
= AR_T_RAID1
;
3205 if (meta
->raid
.array_width
> 1)
3206 raid
->type
= AR_T_RAID01
;
3210 raid
->type
= AR_T_RAID5
;
3214 device_printf(parent
, "%s unknown RAID type 0x%02x\n",
3215 native
? "FreeBSD" : "Promise", meta
->raid
.type
);
3216 kfree(raidp
[array
], M_AR
);
3217 raidp
[array
] = NULL
;
3220 raid
->magic_1
= meta
->raid
.magic_1
;
3221 raid
->format
= (native
? AR_F_FREEBSD_RAID
: AR_F_PROMISE_RAID
);
3222 raid
->generation
= meta
->raid
.generation
;
3223 raid
->interleave
= 1 << meta
->raid
.stripe_shift
;
3224 raid
->width
= meta
->raid
.array_width
;
3225 raid
->total_disks
= meta
->raid
.total_disks
;
3226 raid
->heads
= meta
->raid
.heads
+ 1;
3227 raid
->sectors
= meta
->raid
.sectors
;
3228 raid
->cylinders
= meta
->raid
.cylinders
+ 1;
3229 raid
->total_sectors
= meta
->raid
.total_sectors
;
3230 raid
->offset_sectors
= 0;
3231 raid
->rebuild_lba
= meta
->raid
.rebuild_lba
;
3233 if ((meta
->raid
.status
&
3234 (PR_S_VALID
| PR_S_ONLINE
| PR_S_INITED
| PR_S_READY
)) ==
3235 (PR_S_VALID
| PR_S_ONLINE
| PR_S_INITED
| PR_S_READY
)) {
3236 raid
->status
|= AR_S_READY
;
3237 if (meta
->raid
.status
& PR_S_DEGRADED
)
3238 raid
->status
|= AR_S_DEGRADED
;
3241 raid
->status
&= ~AR_S_READY
;
3243 /* convert disk flags to our internal types */
3244 for (disk
= 0; disk
< meta
->raid
.total_disks
; disk
++) {
3245 raid
->disks
[disk
].dev
= NULL
;
3246 raid
->disks
[disk
].flags
= 0;
3247 *((u_int64_t
*)(raid
->disks
[disk
].serial
)) =
3248 meta
->raid
.disk
[disk
].magic_0
;
3249 disksum
+= meta
->raid
.disk
[disk
].flags
;
3250 if (meta
->raid
.disk
[disk
].flags
& PR_F_ONLINE
)
3251 raid
->disks
[disk
].flags
|= AR_DF_ONLINE
;
3252 if (meta
->raid
.disk
[disk
].flags
& PR_F_ASSIGNED
)
3253 raid
->disks
[disk
].flags
|= AR_DF_ASSIGNED
;
3254 if (meta
->raid
.disk
[disk
].flags
& PR_F_SPARE
) {
3255 raid
->disks
[disk
].flags
&= ~(AR_DF_ONLINE
| AR_DF_ASSIGNED
);
3256 raid
->disks
[disk
].flags
|= AR_DF_SPARE
;
3258 if (meta
->raid
.disk
[disk
].flags
& (PR_F_REDIR
| PR_F_DOWN
))
3259 raid
->disks
[disk
].flags
&= ~AR_DF_ONLINE
;
3262 device_printf(parent
, "%s subdisks has no flags\n",
3263 native
? "FreeBSD" : "Promise");
3264 kfree(raidp
[array
], M_AR
);
3265 raidp
[array
] = NULL
;
3269 if (meta
->raid
.generation
>= raid
->generation
) {
3270 int disk_number
= meta
->raid
.disk_number
;
3272 if (raid
->disks
[disk_number
].flags
&& (meta
->magic_0
==
3273 *((u_int64_t
*)(raid
->disks
[disk_number
].serial
)))) {
3274 raid
->disks
[disk_number
].dev
= parent
;
3275 raid
->disks
[disk_number
].flags
|= AR_DF_PRESENT
;
3276 raid
->disks
[disk_number
].sectors
= meta
->raid
.disk_sectors
;
3277 if ((raid
->disks
[disk_number
].flags
&
3278 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_ONLINE
)) ==
3279 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_ONLINE
)) {
3280 ars
->raid
[raid
->volume
] = raid
;
3281 ars
->disk_number
[raid
->volume
] = disk_number
;
3295 ata_raid_promise_write_meta(struct ar_softc
*rdp
)
3297 struct promise_raid_conf
*meta
;
3298 struct timeval timestamp
;
3300 int count
, disk
, drive
, error
= 0;
3302 meta
= (struct promise_raid_conf
*)
3303 kmalloc(sizeof(struct promise_raid_conf
), M_AR
, M_WAITOK
);
3306 microtime(×tamp
);
3308 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
3309 for (count
= 0; count
< sizeof(struct promise_raid_conf
); count
++)
3310 *(((u_int8_t
*)meta
) + count
) = 255 - (count
% 256);
3311 meta
->dummy_0
= 0x00020000;
3312 meta
->raid
.disk_number
= disk
;
3314 if (rdp
->disks
[disk
].dev
) {
3315 struct ata_device
*atadev
= device_get_softc(rdp
->disks
[disk
].dev
);
3316 struct ata_channel
*ch
=
3317 device_get_softc(device_get_parent(rdp
->disks
[disk
].dev
));
3319 meta
->raid
.channel
= ch
->unit
;
3320 meta
->raid
.device
= ATA_DEV(atadev
->unit
);
3321 meta
->raid
.disk_sectors
= rdp
->disks
[disk
].sectors
;
3322 meta
->raid
.disk_offset
= rdp
->offset_sectors
;
3325 meta
->raid
.channel
= 0;
3326 meta
->raid
.device
= 0;
3327 meta
->raid
.disk_sectors
= 0;
3328 meta
->raid
.disk_offset
= 0;
3330 meta
->magic_0
= PR_MAGIC0(meta
->raid
) | timestamp
.tv_sec
;
3331 meta
->magic_1
= timestamp
.tv_sec
>> 16;
3332 meta
->magic_2
= timestamp
.tv_sec
;
3333 meta
->raid
.integrity
= PR_I_VALID
;
3334 meta
->raid
.magic_0
= meta
->magic_0
;
3335 meta
->raid
.rebuild_lba
= rdp
->rebuild_lba
;
3336 meta
->raid
.generation
= rdp
->generation
;
3338 if (rdp
->status
& AR_S_READY
) {
3339 meta
->raid
.flags
= (PR_F_VALID
| PR_F_ASSIGNED
| PR_F_ONLINE
);
3341 (PR_S_VALID
| PR_S_ONLINE
| PR_S_INITED
| PR_S_READY
);
3342 if (rdp
->status
& AR_S_DEGRADED
)
3343 meta
->raid
.status
|= PR_S_DEGRADED
;
3345 meta
->raid
.status
|= PR_S_FUNCTIONAL
;
3348 meta
->raid
.flags
= PR_F_DOWN
;
3349 meta
->raid
.status
= 0;
3352 switch (rdp
->type
) {
3354 meta
->raid
.type
= PR_T_RAID0
;
3357 meta
->raid
.type
= PR_T_RAID1
;
3360 meta
->raid
.type
= PR_T_RAID1
;
3363 meta
->raid
.type
= PR_T_RAID5
;
3366 meta
->raid
.type
= PR_T_SPAN
;
3369 meta
->raid
.type
= PR_T_JBOD
;
3376 meta
->raid
.total_disks
= rdp
->total_disks
;
3377 meta
->raid
.stripe_shift
= ffs(rdp
->interleave
) - 1;
3378 meta
->raid
.array_width
= rdp
->width
;
3379 meta
->raid
.array_number
= rdp
->lun
;
3380 meta
->raid
.total_sectors
= rdp
->total_sectors
;
3381 meta
->raid
.cylinders
= rdp
->cylinders
- 1;
3382 meta
->raid
.heads
= rdp
->heads
- 1;
3383 meta
->raid
.sectors
= rdp
->sectors
;
3384 meta
->raid
.magic_1
= (u_int64_t
)meta
->magic_2
<<16 | meta
->magic_1
;
3386 bzero(&meta
->raid
.disk
, 8 * 12);
3387 for (drive
= 0; drive
< rdp
->total_disks
; drive
++) {
3388 meta
->raid
.disk
[drive
].flags
= 0;
3389 if (rdp
->disks
[drive
].flags
& AR_DF_PRESENT
)
3390 meta
->raid
.disk
[drive
].flags
|= PR_F_VALID
;
3391 if (rdp
->disks
[drive
].flags
& AR_DF_ASSIGNED
)
3392 meta
->raid
.disk
[drive
].flags
|= PR_F_ASSIGNED
;
3393 if (rdp
->disks
[drive
].flags
& AR_DF_ONLINE
)
3394 meta
->raid
.disk
[drive
].flags
|= PR_F_ONLINE
;
3396 if (rdp
->disks
[drive
].flags
& AR_DF_PRESENT
)
3397 meta
->raid
.disk
[drive
].flags
= (PR_F_REDIR
| PR_F_DOWN
);
3398 if (rdp
->disks
[drive
].flags
& AR_DF_SPARE
)
3399 meta
->raid
.disk
[drive
].flags
|= PR_F_SPARE
;
3400 meta
->raid
.disk
[drive
].dummy_0
= 0x0;
3401 if (rdp
->disks
[drive
].dev
) {
3402 struct ata_channel
*ch
=
3403 device_get_softc(device_get_parent(rdp
->disks
[drive
].dev
));
3404 struct ata_device
*atadev
=
3405 device_get_softc(rdp
->disks
[drive
].dev
);
3407 meta
->raid
.disk
[drive
].channel
= ch
->unit
;
3408 meta
->raid
.disk
[drive
].device
= ATA_DEV(atadev
->unit
);
3410 meta
->raid
.disk
[drive
].magic_0
=
3411 PR_MAGIC0(meta
->raid
.disk
[drive
]) | timestamp
.tv_sec
;
3414 if (rdp
->disks
[disk
].dev
) {
3415 if ((rdp
->disks
[disk
].flags
& (AR_DF_PRESENT
| AR_DF_ONLINE
)) ==
3416 (AR_DF_PRESENT
| AR_DF_ONLINE
)) {
3417 if (rdp
->format
== AR_F_FREEBSD_RAID
)
3418 bcopy(ATA_MAGIC
, meta
->promise_id
, sizeof(ATA_MAGIC
));
3420 bcopy(PR_MAGIC
, meta
->promise_id
, sizeof(PR_MAGIC
));
3423 bzero(meta
->promise_id
, sizeof(meta
->promise_id
));
3425 for (ckptr
= (int32_t *)meta
, count
= 0; count
< 511; count
++)
3426 meta
->checksum
+= *ckptr
++;
3427 if (testing
|| bootverbose
)
3428 ata_raid_promise_print_meta(meta
);
3429 if (ata_raid_rw(rdp
->disks
[disk
].dev
,
3430 PROMISE_LBA(rdp
->disks
[disk
].dev
),
3431 meta
, sizeof(struct promise_raid_conf
),
3432 ATA_R_WRITE
| ATA_R_DIRECT
)) {
3433 device_printf(rdp
->disks
[disk
].dev
, "write metadata failed\n");
3442 /* Silicon Image Medley Metadata */
3444 ata_raid_sii_read_meta(device_t dev
, struct ar_softc
**raidp
)
3446 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
3447 device_t parent
= device_get_parent(dev
);
3448 struct sii_raid_conf
*meta
;
3449 struct ar_softc
*raid
= NULL
;
3450 u_int16_t checksum
, *ptr
;
3451 int array
, count
, disk
, retval
= 0;
3453 meta
= (struct sii_raid_conf
*)kmalloc(sizeof(struct sii_raid_conf
), M_AR
,
3456 if (ata_raid_rw(parent
, SII_LBA(parent
),
3457 meta
, sizeof(struct sii_raid_conf
), ATA_R_READ
)) {
3458 if (testing
|| bootverbose
)
3459 device_printf(parent
, "Silicon Image read metadata failed\n");
3463 /* check if this is a Silicon Image (Medley) RAID struct */
3464 for (checksum
= 0, ptr
= (u_int16_t
*)meta
, count
= 0; count
< 160; count
++)
3467 if (testing
|| bootverbose
)
3468 device_printf(parent
, "Silicon Image check1 failed\n");
3472 for (checksum
= 0, ptr
= (u_int16_t
*)meta
, count
= 0; count
< 256; count
++)
3474 if (checksum
!= meta
->checksum_1
) {
3475 if (testing
|| bootverbose
)
3476 device_printf(parent
, "Silicon Image check2 failed\n");
3481 if (meta
->version_major
!= 0x0002 ||
3482 (meta
->version_minor
!= 0x0000 && meta
->version_minor
!= 0x0001)) {
3483 if (testing
|| bootverbose
)
3484 device_printf(parent
, "Silicon Image check3 failed\n");
3488 if (testing
|| bootverbose
)
3489 ata_raid_sii_print_meta(meta
);
3491 /* now convert Silicon Image meta into our generic form */
3492 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
3493 if (!raidp
[array
]) {
3495 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
3498 raid
= raidp
[array
];
3499 if (raid
->format
&& (raid
->format
!= AR_F_SII_RAID
))
3502 if (raid
->format
== AR_F_SII_RAID
&&
3503 (raid
->magic_0
!= *((u_int64_t
*)meta
->timestamp
))) {
3507 /* update our knowledge about the array config based on generation */
3508 if (!meta
->generation
|| meta
->generation
> raid
->generation
) {
3509 switch (meta
->type
) {
3511 raid
->type
= AR_T_RAID0
;
3515 raid
->type
= AR_T_RAID1
;
3519 raid
->type
= AR_T_RAID01
;
3523 device_printf(parent
, "Silicon Image SPARE disk\n");
3524 kfree(raidp
[array
], M_AR
);
3525 raidp
[array
] = NULL
;
3529 device_printf(parent
,"Silicon Image unknown RAID type 0x%02x\n",
3531 kfree(raidp
[array
], M_AR
);
3532 raidp
[array
] = NULL
;
3535 raid
->magic_0
= *((u_int64_t
*)meta
->timestamp
);
3536 raid
->format
= AR_F_SII_RAID
;
3537 raid
->generation
= meta
->generation
;
3538 raid
->interleave
= meta
->stripe_sectors
;
3539 raid
->width
= (meta
->raid0_disks
!= 0xff) ? meta
->raid0_disks
: 1;
3541 ((meta
->raid0_disks
!= 0xff) ? meta
->raid0_disks
: 0) +
3542 ((meta
->raid1_disks
!= 0xff) ? meta
->raid1_disks
: 0);
3543 raid
->total_sectors
= meta
->total_sectors
;
3546 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
3547 raid
->offset_sectors
= 0;
3548 raid
->rebuild_lba
= meta
->rebuild_lba
;
3550 strncpy(raid
->name
, meta
->name
,
3551 min(sizeof(raid
->name
), sizeof(meta
->name
)));
3553 /* clear out any old info */
3554 if (raid
->generation
) {
3555 for (disk
= 0; disk
< raid
->total_disks
; disk
++) {
3556 raid
->disks
[disk
].dev
= NULL
;
3557 raid
->disks
[disk
].flags
= 0;
3561 if (meta
->generation
>= raid
->generation
) {
3562 /* XXX SOS add check for the right physical disk by serial# */
3563 if (meta
->status
& SII_S_READY
) {
3564 int disk_number
= (raid
->type
== AR_T_RAID01
) ?
3565 meta
->raid1_ident
+ (meta
->raid0_ident
<< 1) :
3568 raid
->disks
[disk_number
].dev
= parent
;
3569 raid
->disks
[disk_number
].sectors
=
3570 raid
->total_sectors
/ raid
->width
;
3571 raid
->disks
[disk_number
].flags
=
3572 (AR_DF_ONLINE
| AR_DF_PRESENT
| AR_DF_ASSIGNED
);
3573 ars
->raid
[raid
->volume
] = raid
;
3574 ars
->disk_number
[raid
->volume
] = disk_number
;
3586 /* Silicon Integrated Systems Metadata */
3588 ata_raid_sis_read_meta(device_t dev
, struct ar_softc
**raidp
)
3590 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
3591 device_t parent
= device_get_parent(dev
);
3592 struct sis_raid_conf
*meta
;
3593 struct ar_softc
*raid
= NULL
;
3594 int array
, disk_number
, drive
, retval
= 0;
3596 meta
= (struct sis_raid_conf
*)kmalloc(sizeof(struct sis_raid_conf
), M_AR
,
3599 if (ata_raid_rw(parent
, SIS_LBA(parent
),
3600 meta
, sizeof(struct sis_raid_conf
), ATA_R_READ
)) {
3601 if (testing
|| bootverbose
)
3602 device_printf(parent
,
3603 "Silicon Integrated Systems read metadata failed\n");
3606 /* check for SiS magic */
3607 if (meta
->magic
!= SIS_MAGIC
) {
3608 if (testing
|| bootverbose
)
3609 device_printf(parent
,
3610 "Silicon Integrated Systems check1 failed\n");
3614 if (testing
|| bootverbose
)
3615 ata_raid_sis_print_meta(meta
);
3617 /* now convert SiS meta into our generic form */
3618 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
3619 if (!raidp
[array
]) {
3621 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
3625 raid
= raidp
[array
];
3626 if (raid
->format
&& (raid
->format
!= AR_F_SIS_RAID
))
3629 if ((raid
->format
== AR_F_SIS_RAID
) &&
3630 ((raid
->magic_0
!= meta
->controller_pci_id
) ||
3631 (raid
->magic_1
!= meta
->timestamp
))) {
3635 switch (meta
->type_total_disks
& SIS_T_MASK
) {
3637 raid
->type
= AR_T_JBOD
;
3638 raid
->width
= (meta
->type_total_disks
& SIS_D_MASK
);
3639 raid
->total_sectors
+= SIS_LBA(parent
);
3643 raid
->type
= AR_T_RAID0
;
3644 raid
->width
= (meta
->type_total_disks
& SIS_D_MASK
);
3645 if (!raid
->total_sectors
||
3646 (raid
->total_sectors
> (raid
->width
* SIS_LBA(parent
))))
3647 raid
->total_sectors
= raid
->width
* SIS_LBA(parent
);
3651 raid
->type
= AR_T_RAID1
;
3653 if (!raid
->total_sectors
|| (raid
->total_sectors
> SIS_LBA(parent
)))
3654 raid
->total_sectors
= SIS_LBA(parent
);
3658 device_printf(parent
, "Silicon Integrated Systems "
3659 "unknown RAID type 0x%08x\n", meta
->magic
);
3660 kfree(raidp
[array
], M_AR
);
3661 raidp
[array
] = NULL
;
3664 raid
->magic_0
= meta
->controller_pci_id
;
3665 raid
->magic_1
= meta
->timestamp
;
3666 raid
->format
= AR_F_SIS_RAID
;
3667 raid
->generation
= 0;
3668 raid
->interleave
= meta
->stripe_sectors
;
3669 raid
->total_disks
= (meta
->type_total_disks
& SIS_D_MASK
);
3672 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
3673 raid
->offset_sectors
= 0;
3674 raid
->rebuild_lba
= 0;
3676 /* XXX SOS if total_disks > 2 this doesn't float */
3677 if (((meta
->disks
& SIS_D_MASTER
) >> 4) == meta
->disk_number
)
3682 for (drive
= 0; drive
< raid
->total_disks
; drive
++) {
3683 raid
->disks
[drive
].sectors
= raid
->total_sectors
/raid
->width
;
3684 if (drive
== disk_number
) {
3685 raid
->disks
[disk_number
].dev
= parent
;
3686 raid
->disks
[disk_number
].flags
=
3687 (AR_DF_ONLINE
| AR_DF_PRESENT
| AR_DF_ASSIGNED
);
3688 ars
->raid
[raid
->volume
] = raid
;
3689 ars
->disk_number
[raid
->volume
] = disk_number
;
3702 ata_raid_sis_write_meta(struct ar_softc
*rdp
)
3704 struct sis_raid_conf
*meta
;
3705 struct timeval timestamp
;
3706 int disk
, error
= 0;
3708 meta
= (struct sis_raid_conf
*)kmalloc(sizeof(struct sis_raid_conf
), M_AR
,
3712 microtime(×tamp
);
3714 meta
->magic
= SIS_MAGIC
;
3715 /* XXX SOS if total_disks > 2 this doesn't float */
3716 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
3717 if (rdp
->disks
[disk
].dev
) {
3718 struct ata_channel
*ch
=
3719 device_get_softc(device_get_parent(rdp
->disks
[disk
].dev
));
3720 struct ata_device
*atadev
= device_get_softc(rdp
->disks
[disk
].dev
);
3721 int disk_number
= 1 + ATA_DEV(atadev
->unit
) + (ch
->unit
<< 1);
3723 meta
->disks
|= disk_number
<< ((1 - disk
) << 2);
3726 switch (rdp
->type
) {
3728 meta
->type_total_disks
= SIS_T_JBOD
;
3732 meta
->type_total_disks
= SIS_T_RAID0
;
3736 meta
->type_total_disks
= SIS_T_RAID1
;
3743 meta
->type_total_disks
|= (rdp
->total_disks
& SIS_D_MASK
);
3744 meta
->stripe_sectors
= rdp
->interleave
;
3745 meta
->timestamp
= timestamp
.tv_sec
;
3747 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
3748 if (rdp
->disks
[disk
].dev
) {
3749 struct ata_channel
*ch
=
3750 device_get_softc(device_get_parent(rdp
->disks
[disk
].dev
));
3751 struct ata_device
*atadev
= device_get_softc(rdp
->disks
[disk
].dev
);
3753 meta
->controller_pci_id
=
3754 (pci_get_vendor(GRANDPARENT(rdp
->disks
[disk
].dev
)) << 16) |
3755 pci_get_device(GRANDPARENT(rdp
->disks
[disk
].dev
));
3756 bcopy(atadev
->param
.model
, meta
->model
, sizeof(meta
->model
));
3758 /* XXX SOS if total_disks > 2 this may not float */
3759 meta
->disk_number
= 1 + ATA_DEV(atadev
->unit
) + (ch
->unit
<< 1);
3761 if (testing
|| bootverbose
)
3762 ata_raid_sis_print_meta(meta
);
3764 if (ata_raid_rw(rdp
->disks
[disk
].dev
,
3765 SIS_LBA(rdp
->disks
[disk
].dev
),
3766 meta
, sizeof(struct sis_raid_conf
),
3767 ATA_R_WRITE
| ATA_R_DIRECT
)) {
3768 device_printf(rdp
->disks
[disk
].dev
, "write metadata failed\n");
3777 /* VIA Tech V-RAID Metadata */
3779 ata_raid_via_read_meta(device_t dev
, struct ar_softc
**raidp
)
3781 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
3782 device_t parent
= device_get_parent(dev
);
3783 struct via_raid_conf
*meta
;
3784 struct ar_softc
*raid
= NULL
;
3785 u_int8_t checksum
, *ptr
;
3786 int array
, count
, disk
, retval
= 0;
3788 meta
= (struct via_raid_conf
*)kmalloc(sizeof(struct via_raid_conf
), M_AR
,
3791 if (ata_raid_rw(parent
, VIA_LBA(parent
),
3792 meta
, sizeof(struct via_raid_conf
), ATA_R_READ
)) {
3793 if (testing
|| bootverbose
)
3794 device_printf(parent
, "VIA read metadata failed\n");
3798 /* check if this is a VIA RAID struct */
3799 if (meta
->magic
!= VIA_MAGIC
) {
3800 if (testing
|| bootverbose
)
3801 device_printf(parent
, "VIA check1 failed\n");
3805 /* calculate checksum and compare for valid */
3806 for (checksum
= 0, ptr
= (u_int8_t
*)meta
, count
= 0; count
< 50; count
++)
3808 if (checksum
!= meta
->checksum
) {
3809 if (testing
|| bootverbose
)
3810 device_printf(parent
, "VIA check2 failed\n");
3814 if (testing
|| bootverbose
)
3815 ata_raid_via_print_meta(meta
);
3817 /* now convert VIA meta into our generic form */
3818 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
3819 if (!raidp
[array
]) {
3821 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
3824 raid
= raidp
[array
];
3825 if (raid
->format
&& (raid
->format
!= AR_F_VIA_RAID
))
3828 if (raid
->format
== AR_F_VIA_RAID
&& (raid
->magic_0
!= meta
->disks
[0]))
3831 switch (meta
->type
& VIA_T_MASK
) {
3833 raid
->type
= AR_T_RAID0
;
3834 raid
->width
= meta
->stripe_layout
& VIA_L_DISKS
;
3835 if (!raid
->total_sectors
||
3836 (raid
->total_sectors
> (raid
->width
* meta
->disk_sectors
)))
3837 raid
->total_sectors
= raid
->width
* meta
->disk_sectors
;
3841 raid
->type
= AR_T_RAID1
;
3843 raid
->total_sectors
= meta
->disk_sectors
;
3847 raid
->type
= AR_T_RAID01
;
3848 raid
->width
= meta
->stripe_layout
& VIA_L_DISKS
;
3849 if (!raid
->total_sectors
||
3850 (raid
->total_sectors
> (raid
->width
* meta
->disk_sectors
)))
3851 raid
->total_sectors
= raid
->width
* meta
->disk_sectors
;
3855 raid
->type
= AR_T_RAID5
;
3856 raid
->width
= meta
->stripe_layout
& VIA_L_DISKS
;
3857 if (!raid
->total_sectors
||
3858 (raid
->total_sectors
> ((raid
->width
- 1)*meta
->disk_sectors
)))
3859 raid
->total_sectors
= (raid
->width
- 1) * meta
->disk_sectors
;
3863 raid
->type
= AR_T_SPAN
;
3865 raid
->total_sectors
+= meta
->disk_sectors
;
3869 device_printf(parent
,"VIA unknown RAID type 0x%02x\n", meta
->type
);
3870 kfree(raidp
[array
], M_AR
);
3871 raidp
[array
] = NULL
;
3874 raid
->magic_0
= meta
->disks
[0];
3875 raid
->format
= AR_F_VIA_RAID
;
3876 raid
->generation
= 0;
3878 0x08 << ((meta
->stripe_layout
& VIA_L_MASK
) >> VIA_L_SHIFT
);
3879 for (count
= 0, disk
= 0; disk
< 8; disk
++)
3880 if (meta
->disks
[disk
])
3882 raid
->total_disks
= count
;
3885 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
3886 raid
->offset_sectors
= 0;
3887 raid
->rebuild_lba
= 0;
3890 for (disk
= 0; disk
< raid
->total_disks
; disk
++) {
3891 if (meta
->disks
[disk
] == meta
->disk_id
) {
3892 raid
->disks
[disk
].dev
= parent
;
3893 bcopy(&meta
->disk_id
, raid
->disks
[disk
].serial
,
3895 raid
->disks
[disk
].sectors
= meta
->disk_sectors
;
3896 raid
->disks
[disk
].flags
=
3897 (AR_DF_ONLINE
| AR_DF_PRESENT
| AR_DF_ASSIGNED
);
3898 ars
->raid
[raid
->volume
] = raid
;
3899 ars
->disk_number
[raid
->volume
] = disk
;
3913 ata_raid_via_write_meta(struct ar_softc
*rdp
)
3915 struct via_raid_conf
*meta
;
3916 int disk
, error
= 0;
3918 meta
= (struct via_raid_conf
*)kmalloc(sizeof(struct via_raid_conf
), M_AR
,
3923 meta
->magic
= VIA_MAGIC
;
3924 meta
->dummy_0
= 0x02;
3925 switch (rdp
->type
) {
3927 meta
->type
= VIA_T_SPAN
;
3928 meta
->stripe_layout
= (rdp
->total_disks
& VIA_L_DISKS
);
3932 meta
->type
= VIA_T_RAID0
;
3933 meta
->stripe_layout
= ((rdp
->interleave
>> 1) & VIA_L_MASK
);
3934 meta
->stripe_layout
|= (rdp
->total_disks
& VIA_L_DISKS
);
3938 meta
->type
= VIA_T_RAID1
;
3939 meta
->stripe_layout
= (rdp
->total_disks
& VIA_L_DISKS
);
3943 meta
->type
= VIA_T_RAID5
;
3944 meta
->stripe_layout
= ((rdp
->interleave
>> 1) & VIA_L_MASK
);
3945 meta
->stripe_layout
|= (rdp
->total_disks
& VIA_L_DISKS
);
3949 meta
->type
= VIA_T_RAID01
;
3950 meta
->stripe_layout
= ((rdp
->interleave
>> 1) & VIA_L_MASK
);
3951 meta
->stripe_layout
|= (rdp
->width
& VIA_L_DISKS
);
3958 meta
->type
|= VIA_T_BOOTABLE
; /* XXX SOS */
3959 meta
->disk_sectors
=
3960 rdp
->total_sectors
/ (rdp
->width
- (rdp
->type
== AR_RAID5
));
3961 for (disk
= 0; disk
< rdp
->total_disks
; disk
++)
3962 meta
->disks
[disk
] = (u_int32_t
)(uintptr_t)rdp
->disks
[disk
].dev
;
3964 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
3965 if (rdp
->disks
[disk
].dev
) {
3969 meta
->disk_index
= disk
* sizeof(u_int32_t
);
3970 if (rdp
->type
== AR_T_RAID01
)
3971 meta
->disk_index
= ((meta
->disk_index
& 0x08) << 2) |
3972 (meta
->disk_index
& ~0x08);
3973 meta
->disk_id
= meta
->disks
[disk
];
3975 for (ptr
= (u_int8_t
*)meta
, count
= 0; count
< 50; count
++)
3976 meta
->checksum
+= *ptr
++;
3978 if (testing
|| bootverbose
)
3979 ata_raid_via_print_meta(meta
);
3981 if (ata_raid_rw(rdp
->disks
[disk
].dev
,
3982 VIA_LBA(rdp
->disks
[disk
].dev
),
3983 meta
, sizeof(struct via_raid_conf
),
3984 ATA_R_WRITE
| ATA_R_DIRECT
)) {
3985 device_printf(rdp
->disks
[disk
].dev
, "write metadata failed\n");
3994 static struct ata_request
*
3995 ata_raid_init_request(struct ar_softc
*rdp
, struct bio
*bio
)
3997 struct ata_request
*request
;
3999 if (!(request
= ata_alloc_request())) {
4000 kprintf("FAILURE - out of memory in ata_raid_init_request\n");
4003 request
->timeout
= ATA_DEFAULT_TIMEOUT
;
4004 request
->retries
= 2;
4005 request
->callback
= ata_raid_done
;
4006 request
->driver
= rdp
;
4008 switch (request
->bio
->bio_buf
->b_cmd
) {
4010 request
->flags
= ATA_R_READ
;
4013 request
->flags
= ATA_R_WRITE
;
4016 request
->flags
= ATA_R_CONTROL
;
4019 kprintf("ar%d: FAILURE - unknown BUF operation\n", rdp
->lun
);
4020 ata_free_request(request
);
4022 bio
->bio_buf
->b_flags
|= B_ERROR
;
4023 bio
->bio_buf
->b_error
= EIO
;
4032 ata_raid_send_request(struct ata_request
*request
)
4034 struct ata_device
*atadev
= device_get_softc(request
->dev
);
4036 request
->transfersize
= min(request
->bytecount
, atadev
->max_iosize
);
4037 if (request
->flags
& ATA_R_READ
) {
4038 if (atadev
->mode
>= ATA_DMA
) {
4039 request
->flags
|= ATA_R_DMA
;
4040 request
->u
.ata
.command
= ATA_READ_DMA
;
4042 else if (atadev
->max_iosize
> DEV_BSIZE
)
4043 request
->u
.ata
.command
= ATA_READ_MUL
;
4045 request
->u
.ata
.command
= ATA_READ
;
4047 else if (request
->flags
& ATA_R_WRITE
) {
4048 if (atadev
->mode
>= ATA_DMA
) {
4049 request
->flags
|= ATA_R_DMA
;
4050 request
->u
.ata
.command
= ATA_WRITE_DMA
;
4052 else if (atadev
->max_iosize
> DEV_BSIZE
)
4053 request
->u
.ata
.command
= ATA_WRITE_MUL
;
4055 request
->u
.ata
.command
= ATA_WRITE
;
4058 device_printf(request
->dev
, "FAILURE - unknown IO operation\n");
4059 ata_free_request(request
);
4062 request
->flags
|= (ATA_R_ORDERED
| ATA_R_THREAD
);
4063 ata_queue_request(request
);
4068 ata_raid_rw(device_t dev
, u_int64_t lba
, void *data
, u_int bcount
, int flags
)
4070 struct ata_device
*atadev
= device_get_softc(dev
);
4071 struct ata_request
*request
;
4074 if (bcount
% DEV_BSIZE
) {
4075 device_printf(dev
, "FAILURE - transfers must be modulo sectorsize\n");
4079 if (!(request
= ata_alloc_request())) {
4080 device_printf(dev
, "FAILURE - out of memory in ata_raid_rw\n");
4086 request
->timeout
= 10;
4087 request
->retries
= 0;
4088 request
->data
= data
;
4089 request
->bytecount
= bcount
;
4090 request
->transfersize
= DEV_BSIZE
;
4091 request
->u
.ata
.lba
= lba
;
4092 request
->u
.ata
.count
= request
->bytecount
/ DEV_BSIZE
;
4093 request
->flags
= flags
;
4095 if (flags
& ATA_R_READ
) {
4096 if (atadev
->mode
>= ATA_DMA
) {
4097 request
->u
.ata
.command
= ATA_READ_DMA
;
4098 request
->flags
|= ATA_R_DMA
;
4101 request
->u
.ata
.command
= ATA_READ
;
4102 ata_queue_request(request
);
4104 else if (flags
& ATA_R_WRITE
) {
4105 if (atadev
->mode
>= ATA_DMA
) {
4106 request
->u
.ata
.command
= ATA_WRITE_DMA
;
4107 request
->flags
|= ATA_R_DMA
;
4110 request
->u
.ata
.command
= ATA_WRITE
;
4111 ata_queue_request(request
);
4114 device_printf(dev
, "FAILURE - unknown IO operation\n");
4115 request
->result
= EIO
;
4117 error
= request
->result
;
4118 ata_free_request(request
);
4126 ata_raid_subdisk_probe(device_t dev
)
4133 ata_raid_subdisk_attach(device_t dev
)
4135 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
4138 for (volume
= 0; volume
< MAX_VOLUMES
; volume
++) {
4139 ars
->raid
[volume
] = NULL
;
4140 ars
->disk_number
[volume
] = -1;
4142 ata_raid_read_metadata(dev
);
4147 ata_raid_subdisk_detach(device_t dev
)
4149 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
4152 for (volume
= 0; volume
< MAX_VOLUMES
; volume
++) {
4153 if (ars
->raid
[volume
]) {
4154 ars
->raid
[volume
]->disks
[ars
->disk_number
[volume
]].flags
&=
4155 ~(AR_DF_PRESENT
| AR_DF_ONLINE
);
4156 ars
->raid
[volume
]->disks
[ars
->disk_number
[volume
]].dev
= NULL
;
4157 ata_raid_config_changed(ars
->raid
[volume
], 1);
4158 ars
->raid
[volume
] = NULL
;
4159 ars
->disk_number
[volume
] = -1;
4165 static device_method_t ata_raid_sub_methods
[] = {
4166 /* device interface */
4167 DEVMETHOD(device_probe
, ata_raid_subdisk_probe
),
4168 DEVMETHOD(device_attach
, ata_raid_subdisk_attach
),
4169 DEVMETHOD(device_detach
, ata_raid_subdisk_detach
),
4173 static driver_t ata_raid_sub_driver
= {
4175 ata_raid_sub_methods
,
4176 sizeof(struct ata_raid_subdisk
)
4179 DRIVER_MODULE(subdisk
, ad
, ata_raid_sub_driver
, ata_raid_sub_devclass
, NULL
, NULL
);
4182 ata_raid_module_event_handler(module_t mod
, int what
, void *arg
)
4188 if (testing
|| bootverbose
)
4189 kprintf("ATA PseudoRAID loaded\n");
4191 /* setup table to hold metadata for all ATA PseudoRAID arrays */
4192 ata_raid_arrays
= kmalloc(sizeof(struct ar_soft
*) * MAX_ARRAYS
,
4193 M_AR
, M_WAITOK
| M_ZERO
);
4195 /* attach found PseudoRAID arrays */
4196 for (i
= 0; i
< MAX_ARRAYS
; i
++) {
4197 struct ar_softc
*rdp
= ata_raid_arrays
[i
];
4199 if (!rdp
|| !rdp
->format
)
4201 if (testing
|| bootverbose
)
4202 ata_raid_print_meta(rdp
);
4203 ata_raid_attach(rdp
, 0);
4205 ata_raid_ioctl_func
= ata_raid_ioctl
;
4209 /* detach found PseudoRAID arrays */
4210 for (i
= 0; i
< MAX_ARRAYS
; i
++) {
4211 struct ar_softc
*rdp
= ata_raid_arrays
[i
];
4213 if (!rdp
|| !rdp
->status
)
4215 disk_destroy(&rdp
->disk
);
4217 if (testing
|| bootverbose
)
4218 kprintf("ATA PseudoRAID unloaded\n");
4220 kfree(ata_raid_arrays
, M_AR
);
4222 ata_raid_ioctl_func
= NULL
;
4230 static moduledata_t ata_raid_moduledata
=
4231 { "ataraid", ata_raid_module_event_handler
, NULL
};
4232 DECLARE_MODULE(ata
, ata_raid_moduledata
, SI_SUB_RAID
, SI_ORDER_FIRST
);
4233 MODULE_VERSION(ataraid
, 1);
4234 MODULE_DEPEND(ataraid
, ata
, 1, 1, 1);
4235 MODULE_DEPEND(ataraid
, ad
, 1, 1, 1);
4238 ata_raid_format(struct ar_softc
*rdp
)
4240 switch (rdp
->format
) {
4241 case AR_F_FREEBSD_RAID
: return "FreeBSD PseudoRAID";
4242 case AR_F_ADAPTEC_RAID
: return "Adaptec HostRAID";
4243 case AR_F_HPTV2_RAID
: return "HighPoint v2 RocketRAID";
4244 case AR_F_HPTV3_RAID
: return "HighPoint v3 RocketRAID";
4245 case AR_F_INTEL_RAID
: return "Intel MatrixRAID";
4246 case AR_F_ITE_RAID
: return "Integrated Technology Express";
4247 case AR_F_JMICRON_RAID
: return "JMicron Technology Corp";
4248 case AR_F_LSIV2_RAID
: return "LSILogic v2 MegaRAID";
4249 case AR_F_LSIV3_RAID
: return "LSILogic v3 MegaRAID";
4250 case AR_F_NVIDIA_RAID
: return "nVidia MediaShield";
4251 case AR_F_PROMISE_RAID
: return "Promise Fasttrak";
4252 case AR_F_SII_RAID
: return "Silicon Image Medley";
4253 case AR_F_SIS_RAID
: return "Silicon Integrated Systems";
4254 case AR_F_VIA_RAID
: return "VIA Tech V-RAID";
4255 default: return "UNKNOWN";
4260 ata_raid_type(struct ar_softc
*rdp
)
4262 switch (rdp
->type
) {
4263 case AR_T_JBOD
: return "JBOD";
4264 case AR_T_SPAN
: return "SPAN";
4265 case AR_T_RAID0
: return "RAID0";
4266 case AR_T_RAID1
: return "RAID1";
4267 case AR_T_RAID3
: return "RAID3";
4268 case AR_T_RAID4
: return "RAID4";
4269 case AR_T_RAID5
: return "RAID5";
4270 case AR_T_RAID01
: return "RAID0+1";
4271 default: return "UNKNOWN";
4276 ata_raid_flags(struct ar_softc
*rdp
)
4278 switch (rdp
->status
& (AR_S_READY
| AR_S_DEGRADED
| AR_S_REBUILDING
)) {
4279 case AR_S_READY
: return "READY";
4280 case AR_S_READY
| AR_S_DEGRADED
: return "DEGRADED";
4281 case AR_S_READY
| AR_S_REBUILDING
:
4282 case AR_S_READY
| AR_S_DEGRADED
| AR_S_REBUILDING
: return "REBUILDING";
4283 default: return "BROKEN";
4287 /* debugging gunk */
4289 ata_raid_print_meta(struct ar_softc
*raid
)
4293 kprintf("********** ATA PseudoRAID ar%d Metadata **********\n", raid
->lun
);
4294 kprintf("=================================================\n");
4295 kprintf("format %s\n", ata_raid_format(raid
));
4296 kprintf("type %s\n", ata_raid_type(raid
));
4297 kprintf("flags 0x%02x %b\n", raid
->status
, raid
->status
,
4298 "\20\3REBUILDING\2DEGRADED\1READY\n");
4299 kprintf("magic_0 0x%016jx\n", raid
->magic_0
);
4300 kprintf("magic_1 0x%016jx\n",raid
->magic_1
);
4301 kprintf("generation %u\n", raid
->generation
);
4302 kprintf("total_sectors %ju\n", raid
->total_sectors
);
4303 kprintf("offset_sectors %ju\n", raid
->offset_sectors
);
4304 kprintf("heads %u\n", raid
->heads
);
4305 kprintf("sectors %u\n", raid
->sectors
);
4306 kprintf("cylinders %u\n", raid
->cylinders
);
4307 kprintf("width %u\n", raid
->width
);
4308 kprintf("interleave %u\n", raid
->interleave
);
4309 kprintf("total_disks %u\n", raid
->total_disks
);
4310 for (i
= 0; i
< raid
->total_disks
; i
++) {
4311 kprintf(" disk %d: flags = 0x%02x %b\n", i
, raid
->disks
[i
].flags
,
4312 raid
->disks
[i
].flags
, "\20\4ONLINE\3SPARE\2ASSIGNED\1PRESENT\n");
4313 if (raid
->disks
[i
].dev
) {
4315 device_printf(raid
->disks
[i
].dev
, " sectors %jd\n",
4316 raid
->disks
[i
].sectors
);
4319 kprintf("=================================================\n");
4323 ata_raid_adaptec_type(int type
)
4325 static char buffer
[16];
4328 case ADP_T_RAID0
: return "RAID0";
4329 case ADP_T_RAID1
: return "RAID1";
4330 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4336 ata_raid_adaptec_print_meta(struct adaptec_raid_conf
*meta
)
4340 kprintf("********* ATA Adaptec HostRAID Metadata *********\n");
4341 kprintf("magic_0 <0x%08x>\n", be32toh(meta
->magic_0
));
4342 kprintf("generation 0x%08x\n", be32toh(meta
->generation
));
4343 kprintf("dummy_0 0x%04x\n", be16toh(meta
->dummy_0
));
4344 kprintf("total_configs %u\n", be16toh(meta
->total_configs
));
4345 kprintf("dummy_1 0x%04x\n", be16toh(meta
->dummy_1
));
4346 kprintf("checksum 0x%04x\n", be16toh(meta
->checksum
));
4347 kprintf("dummy_2 0x%08x\n", be32toh(meta
->dummy_2
));
4348 kprintf("dummy_3 0x%08x\n", be32toh(meta
->dummy_3
));
4349 kprintf("flags 0x%08x\n", be32toh(meta
->flags
));
4350 kprintf("timestamp 0x%08x\n", be32toh(meta
->timestamp
));
4351 kprintf("dummy_4 0x%08x 0x%08x 0x%08x 0x%08x\n",
4352 be32toh(meta
->dummy_4
[0]), be32toh(meta
->dummy_4
[1]),
4353 be32toh(meta
->dummy_4
[2]), be32toh(meta
->dummy_4
[3]));
4354 kprintf("dummy_5 0x%08x 0x%08x 0x%08x 0x%08x\n",
4355 be32toh(meta
->dummy_5
[0]), be32toh(meta
->dummy_5
[1]),
4356 be32toh(meta
->dummy_5
[2]), be32toh(meta
->dummy_5
[3]));
4358 for (i
= 0; i
< be16toh(meta
->total_configs
); i
++) {
4359 kprintf(" %d total_disks %u\n", i
,
4360 be16toh(meta
->configs
[i
].disk_number
));
4361 kprintf(" %d generation %u\n", i
,
4362 be16toh(meta
->configs
[i
].generation
));
4363 kprintf(" %d magic_0 0x%08x\n", i
,
4364 be32toh(meta
->configs
[i
].magic_0
));
4365 kprintf(" %d dummy_0 0x%02x\n", i
, meta
->configs
[i
].dummy_0
);
4366 kprintf(" %d type %s\n", i
,
4367 ata_raid_adaptec_type(meta
->configs
[i
].type
));
4368 kprintf(" %d dummy_1 0x%02x\n", i
, meta
->configs
[i
].dummy_1
);
4369 kprintf(" %d flags %d\n", i
,
4370 be32toh(meta
->configs
[i
].flags
));
4371 kprintf(" %d dummy_2 0x%02x\n", i
, meta
->configs
[i
].dummy_2
);
4372 kprintf(" %d dummy_3 0x%02x\n", i
, meta
->configs
[i
].dummy_3
);
4373 kprintf(" %d dummy_4 0x%02x\n", i
, meta
->configs
[i
].dummy_4
);
4374 kprintf(" %d dummy_5 0x%02x\n", i
, meta
->configs
[i
].dummy_5
);
4375 kprintf(" %d disk_number %u\n", i
,
4376 be32toh(meta
->configs
[i
].disk_number
));
4377 kprintf(" %d dummy_6 0x%08x\n", i
,
4378 be32toh(meta
->configs
[i
].dummy_6
));
4379 kprintf(" %d sectors %u\n", i
,
4380 be32toh(meta
->configs
[i
].sectors
));
4381 kprintf(" %d stripe_shift %u\n", i
,
4382 be16toh(meta
->configs
[i
].stripe_shift
));
4383 kprintf(" %d dummy_7 0x%08x\n", i
,
4384 be32toh(meta
->configs
[i
].dummy_7
));
4385 kprintf(" %d dummy_8 0x%08x 0x%08x 0x%08x 0x%08x\n", i
,
4386 be32toh(meta
->configs
[i
].dummy_8
[0]),
4387 be32toh(meta
->configs
[i
].dummy_8
[1]),
4388 be32toh(meta
->configs
[i
].dummy_8
[2]),
4389 be32toh(meta
->configs
[i
].dummy_8
[3]));
4390 kprintf(" %d name <%s>\n", i
, meta
->configs
[i
].name
);
4392 kprintf("magic_1 <0x%08x>\n", be32toh(meta
->magic_1
));
4393 kprintf("magic_2 <0x%08x>\n", be32toh(meta
->magic_2
));
4394 kprintf("magic_3 <0x%08x>\n", be32toh(meta
->magic_3
));
4395 kprintf("magic_4 <0x%08x>\n", be32toh(meta
->magic_4
));
4396 kprintf("=================================================\n");
4400 ata_raid_hptv2_type(int type
)
4402 static char buffer
[16];
4405 case HPTV2_T_RAID0
: return "RAID0";
4406 case HPTV2_T_RAID1
: return "RAID1";
4407 case HPTV2_T_RAID01_RAID0
: return "RAID01_RAID0";
4408 case HPTV2_T_SPAN
: return "SPAN";
4409 case HPTV2_T_RAID_3
: return "RAID3";
4410 case HPTV2_T_RAID_5
: return "RAID5";
4411 case HPTV2_T_JBOD
: return "JBOD";
4412 case HPTV2_T_RAID01_RAID1
: return "RAID01_RAID1";
4413 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4419 ata_raid_hptv2_print_meta(struct hptv2_raid_conf
*meta
)
4423 kprintf("****** ATA Highpoint V2 RocketRAID Metadata *****\n");
4424 kprintf("magic 0x%08x\n", meta
->magic
);
4425 kprintf("magic_0 0x%08x\n", meta
->magic_0
);
4426 kprintf("magic_1 0x%08x\n", meta
->magic_1
);
4427 kprintf("order 0x%08x\n", meta
->order
);
4428 kprintf("array_width %u\n", meta
->array_width
);
4429 kprintf("stripe_shift %u\n", meta
->stripe_shift
);
4430 kprintf("type %s\n", ata_raid_hptv2_type(meta
->type
));
4431 kprintf("disk_number %u\n", meta
->disk_number
);
4432 kprintf("total_sectors %u\n", meta
->total_sectors
);
4433 kprintf("disk_mode 0x%08x\n", meta
->disk_mode
);
4434 kprintf("boot_mode 0x%08x\n", meta
->boot_mode
);
4435 kprintf("boot_disk 0x%02x\n", meta
->boot_disk
);
4436 kprintf("boot_protect 0x%02x\n", meta
->boot_protect
);
4437 kprintf("log_entries 0x%02x\n", meta
->error_log_entries
);
4438 kprintf("log_index 0x%02x\n", meta
->error_log_index
);
4439 if (meta
->error_log_entries
) {
4440 kprintf(" timestamp reason disk status sectors lba\n");
4441 for (i
= meta
->error_log_index
;
4442 i
< meta
->error_log_index
+ meta
->error_log_entries
; i
++)
4443 kprintf(" 0x%08x 0x%02x 0x%02x 0x%02x 0x%02x 0x%08x\n",
4444 meta
->errorlog
[i
%32].timestamp
,
4445 meta
->errorlog
[i
%32].reason
,
4446 meta
->errorlog
[i
%32].disk
, meta
->errorlog
[i
%32].status
,
4447 meta
->errorlog
[i
%32].sectors
, meta
->errorlog
[i
%32].lba
);
4449 kprintf("rebuild_lba 0x%08x\n", meta
->rebuild_lba
);
4450 kprintf("dummy_1 0x%02x\n", meta
->dummy_1
);
4451 kprintf("name_1 <%.15s>\n", meta
->name_1
);
4452 kprintf("dummy_2 0x%02x\n", meta
->dummy_2
);
4453 kprintf("name_2 <%.15s>\n", meta
->name_2
);
4454 kprintf("=================================================\n");
4458 ata_raid_hptv3_type(int type
)
4460 static char buffer
[16];
4463 case HPTV3_T_SPARE
: return "SPARE";
4464 case HPTV3_T_JBOD
: return "JBOD";
4465 case HPTV3_T_SPAN
: return "SPAN";
4466 case HPTV3_T_RAID0
: return "RAID0";
4467 case HPTV3_T_RAID1
: return "RAID1";
4468 case HPTV3_T_RAID3
: return "RAID3";
4469 case HPTV3_T_RAID5
: return "RAID5";
4470 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4476 ata_raid_hptv3_print_meta(struct hptv3_raid_conf
*meta
)
4480 kprintf("****** ATA Highpoint V3 RocketRAID Metadata *****\n");
4481 kprintf("magic 0x%08x\n", meta
->magic
);
4482 kprintf("magic_0 0x%08x\n", meta
->magic_0
);
4483 kprintf("checksum_0 0x%02x\n", meta
->checksum_0
);
4484 kprintf("mode 0x%02x\n", meta
->mode
);
4485 kprintf("user_mode 0x%02x\n", meta
->user_mode
);
4486 kprintf("config_entries 0x%02x\n", meta
->config_entries
);
4487 for (i
= 0; i
< meta
->config_entries
; i
++) {
4488 kprintf("config %d:\n", i
);
4489 kprintf(" total_sectors %ju\n",
4490 meta
->configs
[0].total_sectors
+
4491 ((u_int64_t
)meta
->configs_high
[0].total_sectors
<< 32));
4492 kprintf(" type %s\n",
4493 ata_raid_hptv3_type(meta
->configs
[i
].type
));
4494 kprintf(" total_disks %u\n", meta
->configs
[i
].total_disks
);
4495 kprintf(" disk_number %u\n", meta
->configs
[i
].disk_number
);
4496 kprintf(" stripe_shift %u\n", meta
->configs
[i
].stripe_shift
);
4497 kprintf(" status %b\n", meta
->configs
[i
].status
,
4498 "\20\2RAID5\1NEED_REBUILD\n");
4499 kprintf(" critical_disks %u\n", meta
->configs
[i
].critical_disks
);
4500 kprintf(" rebuild_lba %ju\n",
4501 meta
->configs_high
[0].rebuild_lba
+
4502 ((u_int64_t
)meta
->configs_high
[0].rebuild_lba
<< 32));
4504 kprintf("name <%.16s>\n", meta
->name
);
4505 kprintf("timestamp 0x%08x\n", meta
->timestamp
);
4506 kprintf("description <%.16s>\n", meta
->description
);
4507 kprintf("creator <%.16s>\n", meta
->creator
);
4508 kprintf("checksum_1 0x%02x\n", meta
->checksum_1
);
4509 kprintf("dummy_0 0x%02x\n", meta
->dummy_0
);
4510 kprintf("dummy_1 0x%02x\n", meta
->dummy_1
);
4511 kprintf("flags %b\n", meta
->flags
,
4512 "\20\4RCACHE\3WCACHE\2NCQ\1TCQ\n");
4513 kprintf("=================================================\n");
4517 ata_raid_intel_type(int type
)
4519 static char buffer
[16];
4522 case INTEL_T_RAID0
: return "RAID0";
4523 case INTEL_T_RAID1
: return "RAID1";
4524 case INTEL_T_RAID5
: return "RAID5";
4525 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4531 ata_raid_intel_print_meta(struct intel_raid_conf
*meta
)
4533 struct intel_raid_mapping
*map
;
4536 kprintf("********* ATA Intel MatrixRAID Metadata *********\n");
4537 kprintf("intel_id <%.24s>\n", meta
->intel_id
);
4538 kprintf("version <%.6s>\n", meta
->version
);
4539 kprintf("checksum 0x%08x\n", meta
->checksum
);
4540 kprintf("config_size 0x%08x\n", meta
->config_size
);
4541 kprintf("config_id 0x%08x\n", meta
->config_id
);
4542 kprintf("generation 0x%08x\n", meta
->generation
);
4543 kprintf("total_disks %u\n", meta
->total_disks
);
4544 kprintf("total_volumes %u\n", meta
->total_volumes
);
4545 kprintf("DISK# serial disk_sectors disk_id flags\n");
4546 for (i
= 0; i
< meta
->total_disks
; i
++ ) {
4547 kprintf(" %d <%.16s> %u 0x%08x 0x%08x\n", i
,
4548 meta
->disk
[i
].serial
, meta
->disk
[i
].sectors
,
4549 meta
->disk
[i
].id
, meta
->disk
[i
].flags
);
4551 map
= (struct intel_raid_mapping
*)&meta
->disk
[meta
->total_disks
];
4552 for (j
= 0; j
< meta
->total_volumes
; j
++) {
4553 kprintf("name %.16s\n", map
->name
);
4554 kprintf("total_sectors %ju\n", map
->total_sectors
);
4555 kprintf("state %u\n", map
->state
);
4556 kprintf("reserved %u\n", map
->reserved
);
4557 kprintf("offset %u\n", map
->offset
);
4558 kprintf("disk_sectors %u\n", map
->disk_sectors
);
4559 kprintf("stripe_count %u\n", map
->stripe_count
);
4560 kprintf("stripe_sectors %u\n", map
->stripe_sectors
);
4561 kprintf("status %u\n", map
->status
);
4562 kprintf("type %s\n", ata_raid_intel_type(map
->type
));
4563 kprintf("total_disks %u\n", map
->total_disks
);
4564 kprintf("magic[0] 0x%02x\n", map
->magic
[0]);
4565 kprintf("magic[1] 0x%02x\n", map
->magic
[1]);
4566 kprintf("magic[2] 0x%02x\n", map
->magic
[2]);
4567 for (i
= 0; i
< map
->total_disks
; i
++ ) {
4568 kprintf(" disk %d at disk_idx 0x%08x\n", i
, map
->disk_idx
[i
]);
4570 map
= (struct intel_raid_mapping
*)&map
->disk_idx
[map
->total_disks
];
4572 kprintf("=================================================\n");
4576 ata_raid_ite_type(int type
)
4578 static char buffer
[16];
4581 case ITE_T_RAID0
: return "RAID0";
4582 case ITE_T_RAID1
: return "RAID1";
4583 case ITE_T_RAID01
: return "RAID0+1";
4584 case ITE_T_SPAN
: return "SPAN";
4585 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4591 ata_raid_ite_print_meta(struct ite_raid_conf
*meta
)
4593 kprintf("*** ATA Integrated Technology Express Metadata **\n");
4594 kprintf("ite_id <%.40s>\n", meta
->ite_id
);
4595 kprintf("timestamp_0 %04x/%02x/%02x %02x:%02x:%02x.%02x\n",
4596 *((u_int16_t
*)meta
->timestamp_0
), meta
->timestamp_0
[2],
4597 meta
->timestamp_0
[3], meta
->timestamp_0
[5], meta
->timestamp_0
[4],
4598 meta
->timestamp_0
[7], meta
->timestamp_0
[6]);
4599 kprintf("total_sectors %jd\n", meta
->total_sectors
);
4600 kprintf("type %s\n", ata_raid_ite_type(meta
->type
));
4601 kprintf("stripe_1kblocks %u\n", meta
->stripe_1kblocks
);
4602 kprintf("timestamp_1 %04x/%02x/%02x %02x:%02x:%02x.%02x\n",
4603 *((u_int16_t
*)meta
->timestamp_1
), meta
->timestamp_1
[2],
4604 meta
->timestamp_1
[3], meta
->timestamp_1
[5], meta
->timestamp_1
[4],
4605 meta
->timestamp_1
[7], meta
->timestamp_1
[6]);
4606 kprintf("stripe_sectors %u\n", meta
->stripe_sectors
);
4607 kprintf("array_width %u\n", meta
->array_width
);
4608 kprintf("disk_number %u\n", meta
->disk_number
);
4609 kprintf("disk_sectors %u\n", meta
->disk_sectors
);
4610 kprintf("=================================================\n");
4614 ata_raid_jmicron_type(int type
)
4616 static char buffer
[16];
4619 case JM_T_RAID0
: return "RAID0";
4620 case JM_T_RAID1
: return "RAID1";
4621 case JM_T_RAID01
: return "RAID0+1";
4622 case JM_T_JBOD
: return "JBOD";
4623 case JM_T_RAID5
: return "RAID5";
4624 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4630 ata_raid_jmicron_print_meta(struct jmicron_raid_conf
*meta
)
4634 kprintf("***** ATA JMicron Technology Corp Metadata ******\n");
4635 kprintf("signature %.2s\n", meta
->signature
);
4636 kprintf("version 0x%04x\n", meta
->version
);
4637 kprintf("checksum 0x%04x\n", meta
->checksum
);
4638 kprintf("disk_id 0x%08x\n", meta
->disk_id
);
4639 kprintf("offset 0x%08x\n", meta
->offset
);
4640 kprintf("disk_sectors_low 0x%08x\n", meta
->disk_sectors_low
);
4641 kprintf("disk_sectors_high 0x%08x\n", meta
->disk_sectors_high
);
4642 kprintf("name %.16s\n", meta
->name
);
4643 kprintf("type %s\n", ata_raid_jmicron_type(meta
->type
));
4644 kprintf("stripe_shift %d\n", meta
->stripe_shift
);
4645 kprintf("flags 0x%04x\n", meta
->flags
);
4646 kprintf("spare:\n");
4647 for (i
=0; i
< 2 && meta
->spare
[i
]; i
++)
4648 kprintf(" %d 0x%08x\n", i
, meta
->spare
[i
]);
4649 kprintf("disks:\n");
4650 for (i
=0; i
< 8 && meta
->disks
[i
]; i
++)
4651 kprintf(" %d 0x%08x\n", i
, meta
->disks
[i
]);
4652 kprintf("=================================================\n");
4656 ata_raid_lsiv2_type(int type
)
4658 static char buffer
[16];
4661 case LSIV2_T_RAID0
: return "RAID0";
4662 case LSIV2_T_RAID1
: return "RAID1";
4663 case LSIV2_T_SPARE
: return "SPARE";
4664 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4670 ata_raid_lsiv2_print_meta(struct lsiv2_raid_conf
*meta
)
4674 kprintf("******* ATA LSILogic V2 MegaRAID Metadata *******\n");
4675 kprintf("lsi_id <%s>\n", meta
->lsi_id
);
4676 kprintf("dummy_0 0x%02x\n", meta
->dummy_0
);
4677 kprintf("flags 0x%02x\n", meta
->flags
);
4678 kprintf("version 0x%04x\n", meta
->version
);
4679 kprintf("config_entries 0x%02x\n", meta
->config_entries
);
4680 kprintf("raid_count 0x%02x\n", meta
->raid_count
);
4681 kprintf("total_disks 0x%02x\n", meta
->total_disks
);
4682 kprintf("dummy_1 0x%02x\n", meta
->dummy_1
);
4683 kprintf("dummy_2 0x%04x\n", meta
->dummy_2
);
4684 for (i
= 0; i
< meta
->config_entries
; i
++) {
4685 kprintf(" type %s\n",
4686 ata_raid_lsiv2_type(meta
->configs
[i
].raid
.type
));
4687 kprintf(" dummy_0 %02x\n", meta
->configs
[i
].raid
.dummy_0
);
4688 kprintf(" stripe_sectors %u\n",
4689 meta
->configs
[i
].raid
.stripe_sectors
);
4690 kprintf(" array_width %u\n",
4691 meta
->configs
[i
].raid
.array_width
);
4692 kprintf(" disk_count %u\n", meta
->configs
[i
].raid
.disk_count
);
4693 kprintf(" config_offset %u\n",
4694 meta
->configs
[i
].raid
.config_offset
);
4695 kprintf(" dummy_1 %u\n", meta
->configs
[i
].raid
.dummy_1
);
4696 kprintf(" flags %02x\n", meta
->configs
[i
].raid
.flags
);
4697 kprintf(" total_sectors %u\n",
4698 meta
->configs
[i
].raid
.total_sectors
);
4700 kprintf("disk_number 0x%02x\n", meta
->disk_number
);
4701 kprintf("raid_number 0x%02x\n", meta
->raid_number
);
4702 kprintf("timestamp 0x%08x\n", meta
->timestamp
);
4703 kprintf("=================================================\n");
4707 ata_raid_lsiv3_type(int type
)
4709 static char buffer
[16];
4712 case LSIV3_T_RAID0
: return "RAID0";
4713 case LSIV3_T_RAID1
: return "RAID1";
4714 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4720 ata_raid_lsiv3_print_meta(struct lsiv3_raid_conf
*meta
)
4724 kprintf("******* ATA LSILogic V3 MegaRAID Metadata *******\n");
4725 kprintf("lsi_id <%.6s>\n", meta
->lsi_id
);
4726 kprintf("dummy_0 0x%04x\n", meta
->dummy_0
);
4727 kprintf("version 0x%04x\n", meta
->version
);
4728 kprintf("dummy_0 0x%04x\n", meta
->dummy_1
);
4729 kprintf("RAID configs:\n");
4730 for (i
= 0; i
< 8; i
++) {
4731 if (meta
->raid
[i
].total_disks
) {
4732 kprintf("%02d stripe_pages %u\n", i
,
4733 meta
->raid
[i
].stripe_pages
);
4734 kprintf("%02d type %s\n", i
,
4735 ata_raid_lsiv3_type(meta
->raid
[i
].type
));
4736 kprintf("%02d total_disks %u\n", i
,
4737 meta
->raid
[i
].total_disks
);
4738 kprintf("%02d array_width %u\n", i
,
4739 meta
->raid
[i
].array_width
);
4740 kprintf("%02d sectors %u\n", i
, meta
->raid
[i
].sectors
);
4741 kprintf("%02d offset %u\n", i
, meta
->raid
[i
].offset
);
4742 kprintf("%02d device 0x%02x\n", i
,
4743 meta
->raid
[i
].device
);
4746 kprintf("DISK configs:\n");
4747 for (i
= 0; i
< 6; i
++) {
4748 if (meta
->disk
[i
].disk_sectors
) {
4749 kprintf("%02d disk_sectors %u\n", i
,
4750 meta
->disk
[i
].disk_sectors
);
4751 kprintf("%02d flags 0x%02x\n", i
, meta
->disk
[i
].flags
);
4754 kprintf("device 0x%02x\n", meta
->device
);
4755 kprintf("timestamp 0x%08x\n", meta
->timestamp
);
4756 kprintf("checksum_1 0x%02x\n", meta
->checksum_1
);
4757 kprintf("=================================================\n");
4761 ata_raid_nvidia_type(int type
)
4763 static char buffer
[16];
4766 case NV_T_SPAN
: return "SPAN";
4767 case NV_T_RAID0
: return "RAID0";
4768 case NV_T_RAID1
: return "RAID1";
4769 case NV_T_RAID3
: return "RAID3";
4770 case NV_T_RAID5
: return "RAID5";
4771 case NV_T_RAID01
: return "RAID0+1";
4772 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4778 ata_raid_nvidia_print_meta(struct nvidia_raid_conf
*meta
)
4780 kprintf("******** ATA nVidia MediaShield Metadata ********\n");
4781 kprintf("nvidia_id <%.8s>\n", meta
->nvidia_id
);
4782 kprintf("config_size %d\n", meta
->config_size
);
4783 kprintf("checksum 0x%08x\n", meta
->checksum
);
4784 kprintf("version 0x%04x\n", meta
->version
);
4785 kprintf("disk_number %d\n", meta
->disk_number
);
4786 kprintf("dummy_0 0x%02x\n", meta
->dummy_0
);
4787 kprintf("total_sectors %d\n", meta
->total_sectors
);
4788 kprintf("sectors_size %d\n", meta
->sector_size
);
4789 kprintf("serial %.16s\n", meta
->serial
);
4790 kprintf("revision %.4s\n", meta
->revision
);
4791 kprintf("dummy_1 0x%08x\n", meta
->dummy_1
);
4792 kprintf("magic_0 0x%08x\n", meta
->magic_0
);
4793 kprintf("magic_1 0x%016jx\n", meta
->magic_1
);
4794 kprintf("magic_2 0x%016jx\n", meta
->magic_2
);
4795 kprintf("flags 0x%02x\n", meta
->flags
);
4796 kprintf("array_width %d\n", meta
->array_width
);
4797 kprintf("total_disks %d\n", meta
->total_disks
);
4798 kprintf("dummy_2 0x%02x\n", meta
->dummy_2
);
4799 kprintf("type %s\n", ata_raid_nvidia_type(meta
->type
));
4800 kprintf("dummy_3 0x%04x\n", meta
->dummy_3
);
4801 kprintf("stripe_sectors %d\n", meta
->stripe_sectors
);
4802 kprintf("stripe_bytes %d\n", meta
->stripe_bytes
);
4803 kprintf("stripe_shift %d\n", meta
->stripe_shift
);
4804 kprintf("stripe_mask 0x%08x\n", meta
->stripe_mask
);
4805 kprintf("stripe_sizesectors %d\n", meta
->stripe_sizesectors
);
4806 kprintf("stripe_sizebytes %d\n", meta
->stripe_sizebytes
);
4807 kprintf("rebuild_lba %d\n", meta
->rebuild_lba
);
4808 kprintf("dummy_4 0x%08x\n", meta
->dummy_4
);
4809 kprintf("dummy_5 0x%08x\n", meta
->dummy_5
);
4810 kprintf("status 0x%08x\n", meta
->status
);
4811 kprintf("=================================================\n");
4815 ata_raid_promise_type(int type
)
4817 static char buffer
[16];
4820 case PR_T_RAID0
: return "RAID0";
4821 case PR_T_RAID1
: return "RAID1";
4822 case PR_T_RAID3
: return "RAID3";
4823 case PR_T_RAID5
: return "RAID5";
4824 case PR_T_SPAN
: return "SPAN";
4825 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4831 ata_raid_promise_print_meta(struct promise_raid_conf
*meta
)
4835 kprintf("********* ATA Promise FastTrak Metadata *********\n");
4836 kprintf("promise_id <%s>\n", meta
->promise_id
);
4837 kprintf("dummy_0 0x%08x\n", meta
->dummy_0
);
4838 kprintf("magic_0 0x%016jx\n", meta
->magic_0
);
4839 kprintf("magic_1 0x%04x\n", meta
->magic_1
);
4840 kprintf("magic_2 0x%08x\n", meta
->magic_2
);
4841 kprintf("integrity 0x%08x %b\n", meta
->raid
.integrity
,
4842 meta
->raid
.integrity
, "\20\10VALID\n" );
4843 kprintf("flags 0x%02x %b\n",
4844 meta
->raid
.flags
, meta
->raid
.flags
,
4845 "\20\10READY\7DOWN\6REDIR\5DUPLICATE\4SPARE"
4846 "\3ASSIGNED\2ONLINE\1VALID\n");
4847 kprintf("disk_number %d\n", meta
->raid
.disk_number
);
4848 kprintf("channel 0x%02x\n", meta
->raid
.channel
);
4849 kprintf("device 0x%02x\n", meta
->raid
.device
);
4850 kprintf("magic_0 0x%016jx\n", meta
->raid
.magic_0
);
4851 kprintf("disk_offset %u\n", meta
->raid
.disk_offset
);
4852 kprintf("disk_sectors %u\n", meta
->raid
.disk_sectors
);
4853 kprintf("rebuild_lba 0x%08x\n", meta
->raid
.rebuild_lba
);
4854 kprintf("generation 0x%04x\n", meta
->raid
.generation
);
4855 kprintf("status 0x%02x %b\n",
4856 meta
->raid
.status
, meta
->raid
.status
,
4857 "\20\6MARKED\5DEGRADED\4READY\3INITED\2ONLINE\1VALID\n");
4858 kprintf("type %s\n", ata_raid_promise_type(meta
->raid
.type
));
4859 kprintf("total_disks %u\n", meta
->raid
.total_disks
);
4860 kprintf("stripe_shift %u\n", meta
->raid
.stripe_shift
);
4861 kprintf("array_width %u\n", meta
->raid
.array_width
);
4862 kprintf("array_number %u\n", meta
->raid
.array_number
);
4863 kprintf("total_sectors %u\n", meta
->raid
.total_sectors
);
4864 kprintf("cylinders %u\n", meta
->raid
.cylinders
);
4865 kprintf("heads %u\n", meta
->raid
.heads
);
4866 kprintf("sectors %u\n", meta
->raid
.sectors
);
4867 kprintf("magic_1 0x%016jx\n", meta
->raid
.magic_1
);
4868 kprintf("DISK# flags dummy_0 channel device magic_0\n");
4869 for (i
= 0; i
< 8; i
++) {
4870 kprintf(" %d %b 0x%02x 0x%02x 0x%02x ",
4871 i
, meta
->raid
.disk
[i
].flags
,
4872 "\20\10READY\7DOWN\6REDIR\5DUPLICATE\4SPARE"
4873 "\3ASSIGNED\2ONLINE\1VALID\n", meta
->raid
.disk
[i
].dummy_0
,
4874 meta
->raid
.disk
[i
].channel
, meta
->raid
.disk
[i
].device
);
4875 kprintf("0x%016jx\n", meta
->raid
.disk
[i
].magic_0
);
4877 kprintf("checksum 0x%08x\n", meta
->checksum
);
4878 kprintf("=================================================\n");
4882 ata_raid_sii_type(int type
)
4884 static char buffer
[16];
4887 case SII_T_RAID0
: return "RAID0";
4888 case SII_T_RAID1
: return "RAID1";
4889 case SII_T_RAID01
: return "RAID0+1";
4890 case SII_T_SPARE
: return "SPARE";
4891 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4897 ata_raid_sii_print_meta(struct sii_raid_conf
*meta
)
4899 kprintf("******* ATA Silicon Image Medley Metadata *******\n");
4900 kprintf("total_sectors %ju\n", meta
->total_sectors
);
4901 kprintf("dummy_0 0x%04x\n", meta
->dummy_0
);
4902 kprintf("dummy_1 0x%04x\n", meta
->dummy_1
);
4903 kprintf("controller_pci_id 0x%08x\n", meta
->controller_pci_id
);
4904 kprintf("version_minor 0x%04x\n", meta
->version_minor
);
4905 kprintf("version_major 0x%04x\n", meta
->version_major
);
4906 kprintf("timestamp 20%02x/%02x/%02x %02x:%02x:%02x\n",
4907 meta
->timestamp
[5], meta
->timestamp
[4], meta
->timestamp
[3],
4908 meta
->timestamp
[2], meta
->timestamp
[1], meta
->timestamp
[0]);
4909 kprintf("stripe_sectors %u\n", meta
->stripe_sectors
);
4910 kprintf("dummy_2 0x%04x\n", meta
->dummy_2
);
4911 kprintf("disk_number %u\n", meta
->disk_number
);
4912 kprintf("type %s\n", ata_raid_sii_type(meta
->type
));
4913 kprintf("raid0_disks %u\n", meta
->raid0_disks
);
4914 kprintf("raid0_ident %u\n", meta
->raid0_ident
);
4915 kprintf("raid1_disks %u\n", meta
->raid1_disks
);
4916 kprintf("raid1_ident %u\n", meta
->raid1_ident
);
4917 kprintf("rebuild_lba %ju\n", meta
->rebuild_lba
);
4918 kprintf("generation 0x%08x\n", meta
->generation
);
4919 kprintf("status 0x%02x %b\n",
4920 meta
->status
, meta
->status
,
4922 kprintf("base_raid1_position %02x\n", meta
->base_raid1_position
);
4923 kprintf("base_raid0_position %02x\n", meta
->base_raid0_position
);
4924 kprintf("position %02x\n", meta
->position
);
4925 kprintf("dummy_3 %04x\n", meta
->dummy_3
);
4926 kprintf("name <%.16s>\n", meta
->name
);
4927 kprintf("checksum_0 0x%04x\n", meta
->checksum_0
);
4928 kprintf("checksum_1 0x%04x\n", meta
->checksum_1
);
4929 kprintf("=================================================\n");
4933 ata_raid_sis_type(int type
)
4935 static char buffer
[16];
4938 case SIS_T_JBOD
: return "JBOD";
4939 case SIS_T_RAID0
: return "RAID0";
4940 case SIS_T_RAID1
: return "RAID1";
4941 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4947 ata_raid_sis_print_meta(struct sis_raid_conf
*meta
)
4949 kprintf("**** ATA Silicon Integrated Systems Metadata ****\n");
4950 kprintf("magic 0x%04x\n", meta
->magic
);
4951 kprintf("disks 0x%02x\n", meta
->disks
);
4952 kprintf("type %s\n",
4953 ata_raid_sis_type(meta
->type_total_disks
& SIS_T_MASK
));
4954 kprintf("total_disks %u\n", meta
->type_total_disks
& SIS_D_MASK
);
4955 kprintf("dummy_0 0x%08x\n", meta
->dummy_0
);
4956 kprintf("controller_pci_id 0x%08x\n", meta
->controller_pci_id
);
4957 kprintf("stripe_sectors %u\n", meta
->stripe_sectors
);
4958 kprintf("dummy_1 0x%04x\n", meta
->dummy_1
);
4959 kprintf("timestamp 0x%08x\n", meta
->timestamp
);
4960 kprintf("model %.40s\n", meta
->model
);
4961 kprintf("disk_number %u\n", meta
->disk_number
);
4962 kprintf("dummy_2 0x%02x 0x%02x 0x%02x\n",
4963 meta
->dummy_2
[0], meta
->dummy_2
[1], meta
->dummy_2
[2]);
4964 kprintf("=================================================\n");
4968 ata_raid_via_type(int type
)
4970 static char buffer
[16];
4973 case VIA_T_RAID0
: return "RAID0";
4974 case VIA_T_RAID1
: return "RAID1";
4975 case VIA_T_RAID5
: return "RAID5";
4976 case VIA_T_RAID01
: return "RAID0+1";
4977 case VIA_T_SPAN
: return "SPAN";
4978 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4984 ata_raid_via_print_meta(struct via_raid_conf
*meta
)
4988 kprintf("*************** ATA VIA Metadata ****************\n");
4989 kprintf("magic 0x%02x\n", meta
->magic
);
4990 kprintf("dummy_0 0x%02x\n", meta
->dummy_0
);
4991 kprintf("type %s\n",
4992 ata_raid_via_type(meta
->type
& VIA_T_MASK
));
4993 kprintf("bootable %d\n", meta
->type
& VIA_T_BOOTABLE
);
4994 kprintf("unknown %d\n", meta
->type
& VIA_T_UNKNOWN
);
4995 kprintf("disk_index 0x%02x\n", meta
->disk_index
);
4996 kprintf("stripe_layout 0x%02x\n", meta
->stripe_layout
);
4997 kprintf(" stripe_disks %d\n", meta
->stripe_layout
& VIA_L_DISKS
);
4998 kprintf(" stripe_sectors %d\n",
4999 0x08 << ((meta
->stripe_layout
& VIA_L_MASK
) >> VIA_L_SHIFT
));
5000 kprintf("disk_sectors %ju\n", meta
->disk_sectors
);
5001 kprintf("disk_id 0x%08x\n", meta
->disk_id
);
5002 kprintf("DISK# disk_id\n");
5003 for (i
= 0; i
< 8; i
++) {
5005 kprintf(" %d 0x%08x\n", i
, meta
->disks
[i
]);
5007 kprintf("checksum 0x%02x\n", meta
->checksum
);
5008 kprintf("=================================================\n");