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 $
27 * $DragonFly: src/sys/dev/disk/nata/ata-raid.c,v 1.9 2008/06/27 00:03:56 dillon Exp $
32 #include <sys/param.h>
38 #include <sys/device.h>
40 #include <sys/endian.h>
41 #include <sys/libkern.h>
42 #include <sys/malloc.h>
43 #include <sys/module.h>
45 #include <sys/spinlock2.h>
46 #include <sys/systm.h>
50 #include <machine/md_var.h>
52 #include <bus/pci/pcivar.h>
61 /* device structure */
62 static d_strategy_t ata_raid_strategy
;
63 static d_dump_t ata_raid_dump
;
64 static struct dev_ops ar_ops
= {
65 { "ar", 157, D_DISK
},
70 .d_strategy
= ata_raid_strategy
,
71 .d_dump
= ata_raid_dump
,
75 static void ata_raid_done(struct ata_request
*request
);
76 static void ata_raid_config_changed(struct ar_softc
*rdp
, int writeback
);
77 static int ata_raid_status(struct ata_ioc_raid_config
*config
);
78 static int ata_raid_create(struct ata_ioc_raid_config
*config
);
79 static int ata_raid_delete(int array
);
80 static int ata_raid_addspare(struct ata_ioc_raid_config
*config
);
81 static int ata_raid_rebuild(int array
);
82 static int ata_raid_read_metadata(device_t subdisk
);
83 static int ata_raid_write_metadata(struct ar_softc
*rdp
);
84 static int ata_raid_wipe_metadata(struct ar_softc
*rdp
);
85 static int ata_raid_adaptec_read_meta(device_t dev
, struct ar_softc
**raidp
);
86 static int ata_raid_hptv2_read_meta(device_t dev
, struct ar_softc
**raidp
);
87 static int ata_raid_hptv2_write_meta(struct ar_softc
*rdp
);
88 static int ata_raid_hptv3_read_meta(device_t dev
, struct ar_softc
**raidp
);
89 static int ata_raid_intel_read_meta(device_t dev
, struct ar_softc
**raidp
);
90 static int ata_raid_intel_write_meta(struct ar_softc
*rdp
);
91 static int ata_raid_ite_read_meta(device_t dev
, struct ar_softc
**raidp
);
92 static int ata_raid_jmicron_read_meta(device_t dev
, struct ar_softc
**raidp
);
93 static int ata_raid_jmicron_write_meta(struct ar_softc
*rdp
);
94 static int ata_raid_lsiv2_read_meta(device_t dev
, struct ar_softc
**raidp
);
95 static int ata_raid_lsiv3_read_meta(device_t dev
, struct ar_softc
**raidp
);
96 static int ata_raid_nvidia_read_meta(device_t dev
, struct ar_softc
**raidp
);
97 static int ata_raid_promise_read_meta(device_t dev
, struct ar_softc
**raidp
, int native
);
98 static int ata_raid_promise_write_meta(struct ar_softc
*rdp
);
99 static int ata_raid_sii_read_meta(device_t dev
, struct ar_softc
**raidp
);
100 static int ata_raid_sis_read_meta(device_t dev
, struct ar_softc
**raidp
);
101 static int ata_raid_sis_write_meta(struct ar_softc
*rdp
);
102 static int ata_raid_via_read_meta(device_t dev
, struct ar_softc
**raidp
);
103 static int ata_raid_via_write_meta(struct ar_softc
*rdp
);
104 static struct ata_request
*ata_raid_init_request(struct ar_softc
*rdp
, struct bio
*bio
);
105 static int ata_raid_send_request(struct ata_request
*request
);
106 static int ata_raid_rw(device_t dev
, u_int64_t lba
, void *data
, u_int bcount
, int flags
);
107 static char * ata_raid_format(struct ar_softc
*rdp
);
108 static char * ata_raid_type(struct ar_softc
*rdp
);
109 static char * ata_raid_flags(struct ar_softc
*rdp
);
112 static void ata_raid_print_meta(struct ar_softc
*meta
);
113 static void ata_raid_adaptec_print_meta(struct adaptec_raid_conf
*meta
);
114 static void ata_raid_hptv2_print_meta(struct hptv2_raid_conf
*meta
);
115 static void ata_raid_hptv3_print_meta(struct hptv3_raid_conf
*meta
);
116 static void ata_raid_intel_print_meta(struct intel_raid_conf
*meta
);
117 static void ata_raid_ite_print_meta(struct ite_raid_conf
*meta
);
118 static void ata_raid_jmicron_print_meta(struct jmicron_raid_conf
*meta
);
119 static void ata_raid_lsiv2_print_meta(struct lsiv2_raid_conf
*meta
);
120 static void ata_raid_lsiv3_print_meta(struct lsiv3_raid_conf
*meta
);
121 static void ata_raid_nvidia_print_meta(struct nvidia_raid_conf
*meta
);
122 static void ata_raid_promise_print_meta(struct promise_raid_conf
*meta
);
123 static void ata_raid_sii_print_meta(struct sii_raid_conf
*meta
);
124 static void ata_raid_sis_print_meta(struct sis_raid_conf
*meta
);
125 static void ata_raid_via_print_meta(struct via_raid_conf
*meta
);
128 static struct ar_softc
*ata_raid_arrays
[MAX_ARRAYS
];
129 static MALLOC_DEFINE(M_AR
, "ar_driver", "ATA PseudoRAID driver");
130 static devclass_t ata_raid_sub_devclass
;
131 static int testing
= 0;
134 ata_raid_attach(struct ar_softc
*rdp
, int writeback
)
136 struct disk_info info
;
141 spin_init(&rdp
->lock
);
142 ata_raid_config_changed(rdp
, writeback
);
144 /* sanitize arrays total_size % (width * interleave) == 0 */
145 if (rdp
->type
== AR_T_RAID0
|| rdp
->type
== AR_T_RAID01
||
146 rdp
->type
== AR_T_RAID5
) {
147 rdp
->total_sectors
= (rdp
->total_sectors
/(rdp
->interleave
*rdp
->width
))*
148 (rdp
->interleave
* rdp
->width
);
149 ksprintf(buffer
, " (stripe %d KB)",
150 (rdp
->interleave
* DEV_BSIZE
) / 1024);
154 /* XXX TGEN add devstats? */
155 cdev
= disk_create(rdp
->lun
, &rdp
->disk
, &ar_ops
);
157 cdev
->si_iosize_max
= 128 * DEV_BSIZE
;
160 bzero(&info
, sizeof(info
));
161 info
.d_media_blksize
= DEV_BSIZE
; /* mandatory */
162 info
.d_media_blocks
= rdp
->total_sectors
;
164 info
.d_secpertrack
= rdp
->sectors
; /* optional */
165 info
.d_nheads
= rdp
->heads
;
166 info
.d_ncylinders
= rdp
->total_sectors
/(rdp
->heads
*rdp
->sectors
);
167 info
.d_secpercyl
= rdp
->sectors
* rdp
->heads
;
169 kprintf("ar%d: %juMB <%s %s%s> status: %s\n", rdp
->lun
,
170 rdp
->total_sectors
/ ((1024L * 1024L) / DEV_BSIZE
),
171 ata_raid_format(rdp
), ata_raid_type(rdp
),
172 buffer
, ata_raid_flags(rdp
));
174 if (testing
|| bootverbose
)
175 kprintf("ar%d: %ju sectors [%dC/%dH/%dS] <%s> subdisks defined as:\n",
176 rdp
->lun
, rdp
->total_sectors
,
177 rdp
->cylinders
, rdp
->heads
, rdp
->sectors
, rdp
->name
);
179 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
180 kprintf("ar%d: disk%d ", rdp
->lun
, disk
);
181 if (rdp
->disks
[disk
].dev
) {
182 if (rdp
->disks
[disk
].flags
& AR_DF_PRESENT
) {
183 /* status of this disk in the array */
184 if (rdp
->disks
[disk
].flags
& AR_DF_ONLINE
)
186 else if (rdp
->disks
[disk
].flags
& AR_DF_SPARE
)
191 /* what type of disk is this in the array */
195 if (disk
< rdp
->width
)
196 kprintf("(master) ");
198 kprintf("(mirror) ");
201 /* which physical disk is used */
202 kprintf("using %s at ata%d-%s\n",
203 device_get_nameunit(rdp
->disks
[disk
].dev
),
204 device_get_unit(device_get_parent(rdp
->disks
[disk
].dev
)),
205 (((struct ata_device
*)
206 device_get_softc(rdp
->disks
[disk
].dev
))->unit
==
207 ATA_MASTER
) ? "master" : "slave");
209 else if (rdp
->disks
[disk
].flags
& AR_DF_ASSIGNED
)
212 kprintf("INVALID no RAID config on this subdisk\n");
215 kprintf("DOWN no device found for this subdisk\n");
218 disk_setdiskinfo(&rdp
->disk
, &info
);
222 * ATA PseudoRAID ioctl function. Note that this does not need to be adjusted
223 * to the dev_ops way, because it's just chained from the generic ata ioctl.
226 ata_raid_ioctl(u_long cmd
, caddr_t data
)
228 struct ata_ioc_raid_config
*config
= (struct ata_ioc_raid_config
*)data
;
229 int *lun
= (int *)data
;
230 int error
= EOPNOTSUPP
;
233 case IOCATARAIDSTATUS
:
234 error
= ata_raid_status(config
);
237 case IOCATARAIDCREATE
:
238 error
= ata_raid_create(config
);
241 case IOCATARAIDDELETE
:
242 error
= ata_raid_delete(*lun
);
245 case IOCATARAIDADDSPARE
:
246 error
= ata_raid_addspare(config
);
249 case IOCATARAIDREBUILD
:
250 error
= ata_raid_rebuild(*lun
);
257 * XXX TGEN there are a lot of offset -> block number conversions going on
258 * here, which is suboptimal.
261 ata_raid_strategy(struct dev_strategy_args
*ap
)
263 struct ar_softc
*rdp
= ap
->a_head
.a_dev
->si_drv1
;
264 struct bio
*bp
= ap
->a_bio
;
265 struct buf
*bbp
= bp
->bio_buf
;
266 struct ata_request
*request
;
268 u_int64_t blkno
, lba
, blk
= 0;
269 int count
, chunk
, drv
, par
= 0, change
= 0;
271 if (!(rdp
->status
& AR_S_READY
) ||
272 (bbp
->b_cmd
!= BUF_CMD_READ
&& bbp
->b_cmd
!= BUF_CMD_WRITE
)) {
273 bbp
->b_flags
|= B_ERROR
;
279 bbp
->b_resid
= bbp
->b_bcount
;
280 for (count
= howmany(bbp
->b_bcount
, DEV_BSIZE
),
281 /* bio_offset is byte granularity, convert */
282 blkno
= (u_int64_t
)(bp
->bio_offset
>> DEV_BSHIFT
),
285 count
-= chunk
, blkno
+= chunk
, data
+= (chunk
* DEV_BSIZE
)) {
298 while (lba
>= rdp
->disks
[drv
].sectors
)
299 lba
-= rdp
->disks
[drv
++].sectors
;
300 chunk
= min(rdp
->disks
[drv
].sectors
- lba
, count
);
305 chunk
= blkno
% rdp
->interleave
;
306 drv
= (blkno
/ rdp
->interleave
) % rdp
->width
;
307 lba
= (((blkno
/rdp
->interleave
)/rdp
->width
)*rdp
->interleave
)+chunk
;
308 chunk
= min(count
, rdp
->interleave
- chunk
);
312 drv
= (blkno
/ rdp
->interleave
) % (rdp
->width
- 1);
313 par
= rdp
->width
- 1 -
314 (blkno
/ (rdp
->interleave
* (rdp
->width
- 1))) % rdp
->width
;
317 lba
= ((blkno
/rdp
->interleave
)/(rdp
->width
-1))*(rdp
->interleave
) +
318 ((blkno
%(rdp
->interleave
*(rdp
->width
-1)))%rdp
->interleave
);
319 chunk
= min(count
, rdp
->interleave
- (lba
% rdp
->interleave
));
323 kprintf("ar%d: unknown array type in ata_raid_strategy\n", rdp
->lun
);
324 bbp
->b_flags
|= B_ERROR
;
330 /* offset on all but "first on HPTv2" */
331 if (!(drv
== 0 && rdp
->format
== AR_F_HPTV2_RAID
))
332 lba
+= rdp
->offset_sectors
;
334 if (!(request
= ata_raid_init_request(rdp
, bp
))) {
335 bbp
->b_flags
|= B_ERROR
;
340 request
->data
= data
;
341 request
->bytecount
= chunk
* DEV_BSIZE
;
342 request
->u
.ata
.lba
= lba
;
343 request
->u
.ata
.count
= request
->bytecount
/ DEV_BSIZE
;
349 if (((rdp
->disks
[drv
].flags
& (AR_DF_PRESENT
|AR_DF_ONLINE
)) ==
350 (AR_DF_PRESENT
|AR_DF_ONLINE
) && !rdp
->disks
[drv
].dev
)) {
351 rdp
->disks
[drv
].flags
&= ~AR_DF_ONLINE
;
352 ata_raid_config_changed(rdp
, 1);
353 ata_free_request(request
);
354 bbp
->b_flags
|= B_ERROR
;
360 request
->dev
= rdp
->disks
[request
->this].dev
;
361 ata_raid_send_request(request
);
366 if ((rdp
->disks
[drv
].flags
&
367 (AR_DF_PRESENT
|AR_DF_ONLINE
))==(AR_DF_PRESENT
|AR_DF_ONLINE
) &&
368 !rdp
->disks
[drv
].dev
) {
369 rdp
->disks
[drv
].flags
&= ~AR_DF_ONLINE
;
372 if ((rdp
->disks
[drv
+ rdp
->width
].flags
&
373 (AR_DF_PRESENT
|AR_DF_ONLINE
))==(AR_DF_PRESENT
|AR_DF_ONLINE
) &&
374 !rdp
->disks
[drv
+ rdp
->width
].dev
) {
375 rdp
->disks
[drv
+ rdp
->width
].flags
&= ~AR_DF_ONLINE
;
379 ata_raid_config_changed(rdp
, 1);
380 if (!(rdp
->status
& AR_S_READY
)) {
381 ata_free_request(request
);
382 bbp
->b_flags
|= B_ERROR
;
388 if (rdp
->status
& AR_S_REBUILDING
)
389 blk
= ((lba
/ rdp
->interleave
) * rdp
->width
) * rdp
->interleave
+
390 (rdp
->interleave
* (drv
% rdp
->width
)) +
391 lba
% rdp
->interleave
;;
393 if (bbp
->b_cmd
== BUF_CMD_READ
) {
395 (rdp
->disks
[drv
].flags
& AR_DF_ONLINE
);
397 (rdp
->disks
[drv
+rdp
->width
].flags
& AR_DF_ONLINE
);
399 /* if mirror gone or close to last access on source */
402 ((u_int64_t
)(bp
->bio_offset
>> DEV_BSHIFT
)) >=
403 (rdp
->disks
[drv
].last_lba
- AR_PROXIMITY
) &&
404 ((u_int64_t
)(bp
->bio_offset
>> DEV_BSHIFT
)) <=
405 (rdp
->disks
[drv
].last_lba
+ AR_PROXIMITY
))) {
408 /* if source gone or close to last access on mirror */
409 else if (!src_online
||
411 ((u_int64_t
)(bp
->bio_offset
>> DEV_BSHIFT
)) >=
412 (rdp
->disks
[drv
+rdp
->width
].last_lba
-AR_PROXIMITY
) &&
413 ((u_int64_t
)(bp
->bio_offset
>> DEV_BSHIFT
)) <=
414 (rdp
->disks
[drv
+rdp
->width
].last_lba
+AR_PROXIMITY
))) {
418 /* not close to any previous access, toggle */
428 if ((rdp
->status
& AR_S_REBUILDING
) &&
429 (blk
<= rdp
->rebuild_lba
) &&
430 ((blk
+ chunk
) > rdp
->rebuild_lba
)) {
431 struct ata_composite
*composite
;
432 struct ata_request
*rebuild
;
435 /* figure out what part to rebuild */
436 if (drv
< rdp
->width
)
437 this = drv
+ rdp
->width
;
439 this = drv
- rdp
->width
;
441 /* do we have a spare to rebuild on ? */
442 if (rdp
->disks
[this].flags
& AR_DF_SPARE
) {
443 if ((composite
= ata_alloc_composite())) {
444 if ((rebuild
= ata_alloc_request())) {
445 rdp
->rebuild_lba
= blk
+ chunk
;
446 bcopy(request
, rebuild
,
447 sizeof(struct ata_request
));
448 rebuild
->this = this;
449 rebuild
->dev
= rdp
->disks
[this].dev
;
450 rebuild
->flags
&= ~ATA_R_READ
;
451 rebuild
->flags
|= ATA_R_WRITE
;
452 spin_init(&composite
->lock
);
453 composite
->residual
= request
->bytecount
;
454 composite
->rd_needed
|= (1 << drv
);
455 composite
->wr_depend
|= (1 << drv
);
456 composite
->wr_needed
|= (1 << this);
457 composite
->request
[drv
] = request
;
458 composite
->request
[this] = rebuild
;
459 request
->composite
= composite
;
460 rebuild
->composite
= composite
;
461 ata_raid_send_request(rebuild
);
464 ata_free_composite(composite
);
465 kprintf("DOH! ata_alloc_request failed!\n");
469 kprintf("DOH! ata_alloc_composite failed!\n");
472 else if (rdp
->disks
[this].flags
& AR_DF_ONLINE
) {
474 * if we got here we are a chunk of a RAID01 that
475 * does not need a rebuild, but we need to increment
476 * the rebuild_lba address to get the rebuild to
477 * move to the next chunk correctly
479 rdp
->rebuild_lba
= blk
+ chunk
;
482 kprintf("DOH! we didn't find the rebuild part\n");
485 if (bbp
->b_cmd
== BUF_CMD_WRITE
) {
486 if ((rdp
->disks
[drv
+rdp
->width
].flags
& AR_DF_ONLINE
) ||
487 ((rdp
->status
& AR_S_REBUILDING
) &&
488 (rdp
->disks
[drv
+rdp
->width
].flags
& AR_DF_SPARE
) &&
489 ((blk
< rdp
->rebuild_lba
) ||
490 ((blk
<= rdp
->rebuild_lba
) &&
491 ((blk
+ chunk
) > rdp
->rebuild_lba
))))) {
492 if ((rdp
->disks
[drv
].flags
& AR_DF_ONLINE
) ||
493 ((rdp
->status
& AR_S_REBUILDING
) &&
494 (rdp
->disks
[drv
].flags
& AR_DF_SPARE
) &&
495 ((blk
< rdp
->rebuild_lba
) ||
496 ((blk
<= rdp
->rebuild_lba
) &&
497 ((blk
+ chunk
) > rdp
->rebuild_lba
))))) {
498 struct ata_request
*mirror
;
499 struct ata_composite
*composite
;
500 int this = drv
+ rdp
->width
;
502 if ((composite
= ata_alloc_composite())) {
503 if ((mirror
= ata_alloc_request())) {
504 if ((blk
<= rdp
->rebuild_lba
) &&
505 ((blk
+ chunk
) > rdp
->rebuild_lba
))
506 rdp
->rebuild_lba
= blk
+ chunk
;
507 bcopy(request
, mirror
,
508 sizeof(struct ata_request
));
510 mirror
->dev
= rdp
->disks
[this].dev
;
511 spin_init(&composite
->lock
);
512 composite
->residual
= request
->bytecount
;
513 composite
->wr_needed
|= (1 << drv
);
514 composite
->wr_needed
|= (1 << this);
515 composite
->request
[drv
] = request
;
516 composite
->request
[this] = mirror
;
517 request
->composite
= composite
;
518 mirror
->composite
= composite
;
519 ata_raid_send_request(mirror
);
520 rdp
->disks
[this].last_lba
=
521 (u_int64_t
)(bp
->bio_offset
>> DEV_BSHIFT
) +
525 ata_free_composite(composite
);
526 kprintf("DOH! ata_alloc_request failed!\n");
530 kprintf("DOH! ata_alloc_composite failed!\n");
538 request
->dev
= rdp
->disks
[request
->this].dev
;
539 ata_raid_send_request(request
);
540 rdp
->disks
[request
->this].last_lba
=
541 ((u_int64_t
)(bp
->bio_offset
) >> DEV_BSHIFT
) + chunk
;
545 if (((rdp
->disks
[drv
].flags
& (AR_DF_PRESENT
|AR_DF_ONLINE
)) ==
546 (AR_DF_PRESENT
|AR_DF_ONLINE
) && !rdp
->disks
[drv
].dev
)) {
547 rdp
->disks
[drv
].flags
&= ~AR_DF_ONLINE
;
550 if (((rdp
->disks
[par
].flags
& (AR_DF_PRESENT
|AR_DF_ONLINE
)) ==
551 (AR_DF_PRESENT
|AR_DF_ONLINE
) && !rdp
->disks
[par
].dev
)) {
552 rdp
->disks
[par
].flags
&= ~AR_DF_ONLINE
;
556 ata_raid_config_changed(rdp
, 1);
557 if (!(rdp
->status
& AR_S_READY
)) {
558 ata_free_request(request
);
559 bbp
->b_flags
|= B_ERROR
;
564 if (rdp
->status
& AR_S_DEGRADED
) {
565 /* do the XOR game if possible */
569 request
->dev
= rdp
->disks
[request
->this].dev
;
570 if (bbp
->b_cmd
== BUF_CMD_READ
) {
571 ata_raid_send_request(request
);
573 if (bbp
->b_cmd
== BUF_CMD_WRITE
) {
574 ata_raid_send_request(request
);
575 /* XXX TGEN no, I don't speak Danish either */
577 * sikre at læs-modify-skriv til hver disk er atomarisk.
578 * par kopi af request
579 * læse orgdata fra drv
580 * skriv nydata til drv
581 * læse parorgdata fra par
582 * skriv orgdata xor parorgdata xor nydata til par
589 kprintf("ar%d: unknown array type in ata_raid_strategy\n", rdp
->lun
);
597 ata_raid_done(struct ata_request
*request
)
599 struct ar_softc
*rdp
= request
->driver
;
600 struct ata_composite
*composite
= NULL
;
601 struct bio
*bp
= request
->bio
;
602 struct buf
*bbp
= bp
->bio_buf
;
603 int i
, mirror
, finished
= 0;
609 if (request
->result
) {
610 rdp
->disks
[request
->this].flags
&= ~AR_DF_ONLINE
;
611 ata_raid_config_changed(rdp
, 1);
612 bbp
->b_error
= request
->result
;
616 bbp
->b_resid
-= request
->donecount
;
624 if (request
->this < rdp
->width
)
625 mirror
= request
->this + rdp
->width
;
627 mirror
= request
->this - rdp
->width
;
628 if (request
->result
) {
629 rdp
->disks
[request
->this].flags
&= ~AR_DF_ONLINE
;
630 ata_raid_config_changed(rdp
, 1);
632 if (rdp
->status
& AR_S_READY
) {
635 if (rdp
->status
& AR_S_REBUILDING
)
636 blk
= ((request
->u
.ata
.lba
/ rdp
->interleave
) * rdp
->width
) *
637 rdp
->interleave
+ (rdp
->interleave
*
638 (request
->this % rdp
->width
)) +
639 request
->u
.ata
.lba
% rdp
->interleave
;
641 if (bbp
->b_cmd
== BUF_CMD_READ
) {
643 /* is this a rebuild composite */
644 if ((composite
= request
->composite
)) {
645 spin_lock_wr(&composite
->lock
);
647 /* handle the read part of a rebuild composite */
648 if (request
->flags
& ATA_R_READ
) {
650 /* if read failed array is now broken */
651 if (request
->result
) {
652 rdp
->disks
[request
->this].flags
&= ~AR_DF_ONLINE
;
653 ata_raid_config_changed(rdp
, 1);
654 bbp
->b_error
= request
->result
;
655 rdp
->rebuild_lba
= blk
;
659 /* good data, update how far we've gotten */
661 bbp
->b_resid
-= request
->donecount
;
662 composite
->residual
-= request
->donecount
;
663 if (!composite
->residual
) {
664 if (composite
->wr_done
& (1 << mirror
))
670 /* handle the write part of a rebuild composite */
671 else if (request
->flags
& ATA_R_WRITE
) {
672 if (composite
->rd_done
& (1 << mirror
)) {
673 if (request
->result
) {
674 kprintf("DOH! rebuild failed\n"); /* XXX SOS */
675 rdp
->rebuild_lba
= blk
;
677 if (!composite
->residual
)
681 spin_unlock_wr(&composite
->lock
);
684 /* if read failed retry on the mirror */
685 else if (request
->result
) {
686 request
->dev
= rdp
->disks
[mirror
].dev
;
687 request
->flags
&= ~ATA_R_TIMEOUT
;
688 ata_raid_send_request(request
);
692 /* we have good data */
694 bbp
->b_resid
-= request
->donecount
;
699 else if (bbp
->b_cmd
== BUF_CMD_WRITE
) {
700 /* do we have a mirror or rebuild to deal with ? */
701 if ((composite
= request
->composite
)) {
702 spin_lock_wr(&composite
->lock
);
703 if (composite
->wr_done
& (1 << mirror
)) {
704 if (request
->result
) {
705 if (composite
->request
[mirror
]->result
) {
706 kprintf("DOH! all disks failed and got here\n");
709 if (rdp
->status
& AR_S_REBUILDING
) {
710 rdp
->rebuild_lba
= blk
;
711 kprintf("DOH! rebuild failed\n"); /* XXX SOS */
714 composite
->request
[mirror
]->donecount
;
715 composite
->residual
-=
716 composite
->request
[mirror
]->donecount
;
719 bbp
->b_resid
-= request
->donecount
;
720 composite
->residual
-= request
->donecount
;
722 if (!composite
->residual
)
725 spin_unlock_wr(&composite
->lock
);
727 /* no mirror we are done */
729 bbp
->b_resid
-= request
->donecount
;
736 /* XXX TGEN bbp->b_flags |= B_ERROR; */
737 bbp
->b_error
= request
->result
;
743 if (request
->result
) {
744 rdp
->disks
[request
->this].flags
&= ~AR_DF_ONLINE
;
745 ata_raid_config_changed(rdp
, 1);
746 if (rdp
->status
& AR_S_READY
) {
747 if (bbp
->b_cmd
== BUF_CMD_READ
) {
748 /* do the XOR game to recover data */
750 if (bbp
->b_cmd
== BUF_CMD_WRITE
) {
751 /* if the parity failed we're OK sortof */
752 /* otherwise wee need to do the XOR long dance */
757 /* XXX TGEN bbp->b_flags |= B_ERROR; */
758 bbp
->b_error
= request
->result
;
763 /* did we have an XOR game going ?? */
764 bbp
->b_resid
-= request
->donecount
;
771 kprintf("ar%d: unknown array type in ata_raid_done\n", rdp
->lun
);
775 if ((rdp
->status
& AR_S_REBUILDING
) &&
776 rdp
->rebuild_lba
>= rdp
->total_sectors
) {
779 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
780 if ((rdp
->disks
[disk
].flags
&
781 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_SPARE
)) ==
782 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_SPARE
)) {
783 rdp
->disks
[disk
].flags
&= ~AR_DF_SPARE
;
784 rdp
->disks
[disk
].flags
|= AR_DF_ONLINE
;
787 rdp
->status
&= ~AR_S_REBUILDING
;
788 ata_raid_config_changed(rdp
, 1);
796 /* we are done with this composite, free all resources */
797 for (i
= 0; i
< 32; i
++) {
798 if (composite
->rd_needed
& (1 << i
) ||
799 composite
->wr_needed
& (1 << i
)) {
800 ata_free_request(composite
->request
[i
]);
803 spin_uninit(&composite
->lock
);
804 ata_free_composite(composite
);
808 ata_free_request(request
);
812 ata_raid_dump(struct dev_dump_args
*ap
)
814 struct ar_softc
*rdp
= ap
->a_head
.a_dev
->si_drv1
;
818 int dumppages
= MAXDUMPPGS
;
822 blkcnt
= howmany(PAGE_SIZE
, ap
->a_secsize
);
824 while (ap
->a_count
> 0) {
827 if ((ap
->a_count
/ blkcnt
) < dumppages
)
828 dumppages
= ap
->a_count
/ blkcnt
;
830 for (i
= 0; i
< dumppages
; ++i
) {
831 vm_paddr_t a
= addr
+ (i
* PAGE_SIZE
);
832 if (is_physical_memory(a
))
833 va
= pmap_kenter_temporary(trunc_page(a
), i
);
835 va
= pmap_kenter_temporary(trunc_page(0), i
);
838 bzero(&dbuf
, sizeof(struct buf
));
840 BUF_LOCK(&dbuf
, LK_EXCLUSIVE
);
842 /* bio_offset is byte granularity, convert block granularity a_blkno */
843 dbuf
.b_bio1
.bio_offset
= (off_t
)(ap
->a_blkno
<< DEV_BSHIFT
);
844 dbuf
.b_bio1
.bio_caller_info1
.ptr
= (void *)rdp
;
845 dbuf
.b_bcount
= dumppages
* PAGE_SIZE
;
847 dbuf
.b_cmd
= BUF_CMD_WRITE
;
848 dev_dstrategy(rdp
->cdev
, &dbuf
.b_bio1
);
849 /* wait for completion, unlock the buffer, check status */
850 if (biowait(&dbuf
)) {
852 return(dbuf
.b_error
? dbuf
.b_error
: EIO
);
856 if (dumpstatus(addr
, (off_t
)ap
->a_count
* DEV_BSIZE
) < 0)
859 ap
->a_blkno
+= blkcnt
* dumppages
;
860 ap
->a_count
-= blkcnt
* dumppages
;
861 addr
+= PAGE_SIZE
* dumppages
;
864 /* flush subdisk buffers to media */
865 for (disk
= 0; disk
< rdp
->total_disks
; disk
++)
866 if (rdp
->disks
[disk
].dev
)
867 error
|= ata_controlcmd(rdp
->disks
[disk
].dev
, ATA_FLUSHCACHE
, 0, 0,
869 return (error
? EIO
: 0);
873 ata_raid_config_changed(struct ar_softc
*rdp
, int writeback
)
875 int disk
, count
, status
;
877 spin_lock_wr(&rdp
->lock
);
878 /* set default all working mode */
879 status
= rdp
->status
;
880 rdp
->status
&= ~AR_S_DEGRADED
;
881 rdp
->status
|= AR_S_READY
;
883 /* make sure all lost drives are accounted for */
884 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
885 if (!(rdp
->disks
[disk
].flags
& AR_DF_PRESENT
))
886 rdp
->disks
[disk
].flags
&= ~AR_DF_ONLINE
;
889 /* depending on RAID type figure out our health status */
894 for (disk
= 0; disk
< rdp
->total_disks
; disk
++)
895 if (!(rdp
->disks
[disk
].flags
& AR_DF_ONLINE
))
896 rdp
->status
&= ~AR_S_READY
;
901 for (disk
= 0; disk
< rdp
->width
; disk
++) {
902 if (!(rdp
->disks
[disk
].flags
& AR_DF_ONLINE
) &&
903 !(rdp
->disks
[disk
+ rdp
->width
].flags
& AR_DF_ONLINE
)) {
904 rdp
->status
&= ~AR_S_READY
;
906 else if (((rdp
->disks
[disk
].flags
& AR_DF_ONLINE
) &&
907 !(rdp
->disks
[disk
+ rdp
->width
].flags
& AR_DF_ONLINE
)) ||
908 (!(rdp
->disks
[disk
].flags
& AR_DF_ONLINE
) &&
909 (rdp
->disks
[disk
+ rdp
->width
].flags
& AR_DF_ONLINE
))) {
910 rdp
->status
|= AR_S_DEGRADED
;
916 for (count
= 0, disk
= 0; disk
< rdp
->total_disks
; disk
++) {
917 if (!(rdp
->disks
[disk
].flags
& AR_DF_ONLINE
))
922 rdp
->status
&= ~AR_S_READY
;
924 rdp
->status
|= AR_S_DEGRADED
;
928 rdp
->status
&= ~AR_S_READY
;
932 * Note that when the array breaks so comes up broken we
933 * force a write of the array config to the remaining
934 * drives so that the generation will be incremented past
935 * those of the missing or failed drives (in all cases).
937 if (rdp
->status
!= status
) {
938 if (!(rdp
->status
& AR_S_READY
)) {
939 kprintf("ar%d: FAILURE - %s array broken\n",
940 rdp
->lun
, ata_raid_type(rdp
));
943 else if (rdp
->status
& AR_S_DEGRADED
) {
944 if (rdp
->type
& (AR_T_RAID1
| AR_T_RAID01
))
945 kprintf("ar%d: WARNING - mirror", rdp
->lun
);
947 kprintf("ar%d: WARNING - parity", rdp
->lun
);
948 kprintf(" protection lost. %s array in DEGRADED mode\n",
953 spin_unlock_wr(&rdp
->lock
);
955 ata_raid_write_metadata(rdp
);
960 ata_raid_status(struct ata_ioc_raid_config
*config
)
962 struct ar_softc
*rdp
;
965 if (!(rdp
= ata_raid_arrays
[config
->lun
]))
968 config
->type
= rdp
->type
;
969 config
->total_disks
= rdp
->total_disks
;
970 for (i
= 0; i
< rdp
->total_disks
; i
++ ) {
971 if ((rdp
->disks
[i
].flags
& AR_DF_PRESENT
) && rdp
->disks
[i
].dev
)
972 config
->disks
[i
] = device_get_unit(rdp
->disks
[i
].dev
);
974 config
->disks
[i
] = -1;
976 config
->interleave
= rdp
->interleave
;
977 config
->status
= rdp
->status
;
978 config
->progress
= 100 * rdp
->rebuild_lba
/ rdp
->total_sectors
;
983 ata_raid_create(struct ata_ioc_raid_config
*config
)
985 struct ar_softc
*rdp
;
988 int ctlr
= 0, disk_size
= 0, total_disks
= 0;
990 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
991 if (!ata_raid_arrays
[array
])
994 if (array
>= MAX_ARRAYS
)
997 rdp
= (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
1000 for (disk
= 0; disk
< config
->total_disks
; disk
++) {
1001 if ((subdisk
= devclass_get_device(ata_raid_sub_devclass
,
1002 config
->disks
[disk
]))) {
1003 struct ata_raid_subdisk
*ars
= device_get_softc(subdisk
);
1005 /* is device already assigned to another array ? */
1006 if (ars
->raid
[rdp
->volume
]) {
1007 config
->disks
[disk
] = -1;
1011 rdp
->disks
[disk
].dev
= device_get_parent(subdisk
);
1013 switch (pci_get_vendor(GRANDPARENT(rdp
->disks
[disk
].dev
))) {
1014 case ATA_HIGHPOINT_ID
:
1016 * we need some way to decide if it should be v2 or v3
1017 * for now just use v2 since the v3 BIOS knows how to
1018 * handle that as well.
1020 ctlr
= AR_F_HPTV2_RAID
;
1021 rdp
->disks
[disk
].sectors
= HPTV3_LBA(rdp
->disks
[disk
].dev
);
1025 ctlr
= AR_F_INTEL_RAID
;
1026 rdp
->disks
[disk
].sectors
= INTEL_LBA(rdp
->disks
[disk
].dev
);
1030 ctlr
= AR_F_ITE_RAID
;
1031 rdp
->disks
[disk
].sectors
= ITE_LBA(rdp
->disks
[disk
].dev
);
1034 case ATA_JMICRON_ID
:
1035 ctlr
= AR_F_JMICRON_RAID
;
1036 rdp
->disks
[disk
].sectors
= JMICRON_LBA(rdp
->disks
[disk
].dev
);
1039 case 0: /* XXX SOS cover up for bug in our PCI code */
1040 case ATA_PROMISE_ID
:
1041 ctlr
= AR_F_PROMISE_RAID
;
1042 rdp
->disks
[disk
].sectors
= PROMISE_LBA(rdp
->disks
[disk
].dev
);
1046 ctlr
= AR_F_SIS_RAID
;
1047 rdp
->disks
[disk
].sectors
= SIS_LBA(rdp
->disks
[disk
].dev
);
1052 ctlr
= AR_F_VIA_RAID
;
1053 rdp
->disks
[disk
].sectors
= VIA_LBA(rdp
->disks
[disk
].dev
);
1058 * right, so here we are, we have an ATA chip and we want
1059 * to create a RAID and store the metadata.
1060 * we need to find a way to tell what kind of metadata this
1061 * hardware's BIOS might be using (good ideas are welcomed)
1062 * for now we just use our own native FreeBSD format.
1063 * the only way to get support for the BIOS format is to
1064 * setup the RAID from there, in that case we pickup the
1065 * metadata format from the disks (if we support it).
1067 kprintf("WARNING!! - not able to determine metadata format\n"
1068 "WARNING!! - Using FreeBSD PseudoRAID metadata\n"
1069 "If that is not what you want, use the BIOS to "
1070 "create the array\n");
1071 ctlr
= AR_F_FREEBSD_RAID
;
1072 rdp
->disks
[disk
].sectors
= PROMISE_LBA(rdp
->disks
[disk
].dev
);
1076 /* we need all disks to be of the same format */
1077 if ((rdp
->format
& AR_F_FORMAT_MASK
) &&
1078 (rdp
->format
& AR_F_FORMAT_MASK
) != (ctlr
& AR_F_FORMAT_MASK
)) {
1085 /* use the smallest disk of the lots size */
1086 /* gigabyte boundry ??? XXX SOS */
1088 disk_size
= min(rdp
->disks
[disk
].sectors
, disk_size
);
1090 disk_size
= rdp
->disks
[disk
].sectors
;
1091 rdp
->disks
[disk
].flags
=
1092 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_ONLINE
);
1097 config
->disks
[disk
] = -1;
1103 if (total_disks
!= config
->total_disks
) {
1108 switch (config
->type
) {
1115 if (total_disks
!= 2) {
1122 if (total_disks
% 2 != 0) {
1129 if (total_disks
< 3) {
1139 rdp
->type
= config
->type
;
1141 if (rdp
->type
== AR_T_RAID0
|| rdp
->type
== AR_T_RAID01
||
1142 rdp
->type
== AR_T_RAID5
) {
1145 while (config
->interleave
>>= 1)
1147 rdp
->interleave
= 1 << bit
;
1149 rdp
->offset_sectors
= 0;
1151 /* values that depend on metadata format */
1152 switch (rdp
->format
) {
1153 case AR_F_ADAPTEC_RAID
:
1154 rdp
->interleave
= min(max(32, rdp
->interleave
), 128); /*+*/
1157 case AR_F_HPTV2_RAID
:
1158 rdp
->interleave
= min(max(8, rdp
->interleave
), 128); /*+*/
1159 rdp
->offset_sectors
= HPTV2_LBA(x
) + 1;
1162 case AR_F_HPTV3_RAID
:
1163 rdp
->interleave
= min(max(32, rdp
->interleave
), 4096); /*+*/
1166 case AR_F_INTEL_RAID
:
1167 rdp
->interleave
= min(max(8, rdp
->interleave
), 256); /*+*/
1171 rdp
->interleave
= min(max(2, rdp
->interleave
), 128); /*+*/
1174 case AR_F_JMICRON_RAID
:
1175 rdp
->interleave
= min(max(8, rdp
->interleave
), 256); /*+*/
1178 case AR_F_LSIV2_RAID
:
1179 rdp
->interleave
= min(max(2, rdp
->interleave
), 4096);
1182 case AR_F_LSIV3_RAID
:
1183 rdp
->interleave
= min(max(2, rdp
->interleave
), 256);
1186 case AR_F_PROMISE_RAID
:
1187 rdp
->interleave
= min(max(2, rdp
->interleave
), 2048); /*+*/
1191 rdp
->interleave
= min(max(8, rdp
->interleave
), 256); /*+*/
1195 rdp
->interleave
= min(max(32, rdp
->interleave
), 512); /*+*/
1199 rdp
->interleave
= min(max(8, rdp
->interleave
), 128); /*+*/
1203 rdp
->total_disks
= total_disks
;
1204 rdp
->width
= total_disks
/ (rdp
->type
& (AR_RAID1
| AR_T_RAID01
) ? 2 : 1);
1205 rdp
->total_sectors
= disk_size
* (rdp
->width
- (rdp
->type
== AR_RAID5
));
1208 rdp
->cylinders
= rdp
->total_sectors
/ (255 * 63);
1209 rdp
->rebuild_lba
= 0;
1210 rdp
->status
|= AR_S_READY
;
1212 /* we are committed to this array, grap the subdisks */
1213 for (disk
= 0; disk
< config
->total_disks
; disk
++) {
1214 if ((subdisk
= devclass_get_device(ata_raid_sub_devclass
,
1215 config
->disks
[disk
]))) {
1216 struct ata_raid_subdisk
*ars
= device_get_softc(subdisk
);
1218 ars
->raid
[rdp
->volume
] = rdp
;
1219 ars
->disk_number
[rdp
->volume
] = disk
;
1222 ata_raid_attach(rdp
, 1);
1223 ata_raid_arrays
[array
] = rdp
;
1224 config
->lun
= array
;
1229 ata_raid_delete(int array
)
1231 struct ar_softc
*rdp
;
1235 if (!(rdp
= ata_raid_arrays
[array
]))
1238 rdp
->status
&= ~AR_S_READY
;
1239 disk_destroy(&rdp
->disk
);
1241 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
1242 if ((rdp
->disks
[disk
].flags
& AR_DF_PRESENT
) && rdp
->disks
[disk
].dev
) {
1243 if ((subdisk
= devclass_get_device(ata_raid_sub_devclass
,
1244 device_get_unit(rdp
->disks
[disk
].dev
)))) {
1245 struct ata_raid_subdisk
*ars
= device_get_softc(subdisk
);
1247 if (ars
->raid
[rdp
->volume
] != rdp
) /* XXX SOS */
1248 device_printf(subdisk
, "DOH! this disk doesn't belong\n");
1249 if (ars
->disk_number
[rdp
->volume
] != disk
) /* XXX SOS */
1250 device_printf(subdisk
, "DOH! this disk number is wrong\n");
1251 ars
->raid
[rdp
->volume
] = NULL
;
1252 ars
->disk_number
[rdp
->volume
] = -1;
1254 rdp
->disks
[disk
].flags
= 0;
1257 ata_raid_wipe_metadata(rdp
);
1258 ata_raid_arrays
[array
] = NULL
;
1264 ata_raid_addspare(struct ata_ioc_raid_config
*config
)
1266 struct ar_softc
*rdp
;
1270 if (!(rdp
= ata_raid_arrays
[config
->lun
]))
1272 if (!(rdp
->status
& AR_S_DEGRADED
) || !(rdp
->status
& AR_S_READY
))
1274 if (rdp
->status
& AR_S_REBUILDING
)
1276 switch (rdp
->type
) {
1280 for (disk
= 0; disk
< rdp
->total_disks
; disk
++ ) {
1282 if (((rdp
->disks
[disk
].flags
& (AR_DF_PRESENT
| AR_DF_ONLINE
)) ==
1283 (AR_DF_PRESENT
| AR_DF_ONLINE
)) && rdp
->disks
[disk
].dev
)
1286 if ((subdisk
= devclass_get_device(ata_raid_sub_devclass
,
1287 config
->disks
[0] ))) {
1288 struct ata_raid_subdisk
*ars
= device_get_softc(subdisk
);
1290 if (ars
->raid
[rdp
->volume
])
1293 /* XXX SOS validate size etc etc */
1294 ars
->raid
[rdp
->volume
] = rdp
;
1295 ars
->disk_number
[rdp
->volume
] = disk
;
1296 rdp
->disks
[disk
].dev
= device_get_parent(subdisk
);
1297 rdp
->disks
[disk
].flags
=
1298 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_SPARE
);
1300 device_printf(rdp
->disks
[disk
].dev
,
1301 "inserted into ar%d disk%d as spare\n",
1303 ata_raid_config_changed(rdp
, 1);
1315 ata_raid_rebuild(int array
)
1317 struct ar_softc
*rdp
;
1320 if (!(rdp
= ata_raid_arrays
[array
]))
1322 /* XXX SOS we should lock the rdp softc here */
1323 if (!(rdp
->status
& AR_S_DEGRADED
) || !(rdp
->status
& AR_S_READY
))
1325 if (rdp
->status
& AR_S_REBUILDING
)
1328 switch (rdp
->type
) {
1332 for (count
= 0, disk
= 0; disk
< rdp
->total_disks
; disk
++ ) {
1333 if (((rdp
->disks
[disk
].flags
&
1334 (AR_DF_PRESENT
|AR_DF_ASSIGNED
|AR_DF_ONLINE
|AR_DF_SPARE
)) ==
1335 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_SPARE
)) &&
1336 rdp
->disks
[disk
].dev
) {
1342 rdp
->rebuild_lba
= 0;
1343 rdp
->status
|= AR_S_REBUILDING
;
1354 ata_raid_read_metadata(device_t subdisk
)
1356 devclass_t pci_devclass
= devclass_find("pci");
1357 devclass_t devclass
=device_get_devclass(GRANDPARENT(GRANDPARENT(subdisk
)));
1359 /* prioritize vendor native metadata layout if possible */
1360 if (devclass
== pci_devclass
) {
1361 switch (pci_get_vendor(GRANDPARENT(device_get_parent(subdisk
)))) {
1362 case ATA_HIGHPOINT_ID
:
1363 if (ata_raid_hptv3_read_meta(subdisk
, ata_raid_arrays
))
1365 if (ata_raid_hptv2_read_meta(subdisk
, ata_raid_arrays
))
1370 if (ata_raid_intel_read_meta(subdisk
, ata_raid_arrays
))
1375 if (ata_raid_ite_read_meta(subdisk
, ata_raid_arrays
))
1379 case ATA_JMICRON_ID
:
1380 if (ata_raid_jmicron_read_meta(subdisk
, ata_raid_arrays
))
1385 if (ata_raid_nvidia_read_meta(subdisk
, ata_raid_arrays
))
1389 case 0: /* XXX SOS cover up for bug in our PCI code */
1390 case ATA_PROMISE_ID
:
1391 if (ata_raid_promise_read_meta(subdisk
, ata_raid_arrays
, 0))
1396 case ATA_SILICON_IMAGE_ID
:
1397 if (ata_raid_sii_read_meta(subdisk
, ata_raid_arrays
))
1402 if (ata_raid_sis_read_meta(subdisk
, ata_raid_arrays
))
1407 if (ata_raid_via_read_meta(subdisk
, ata_raid_arrays
))
1413 /* handle controllers that have multiple layout possibilities */
1414 /* NOTE: the order of these are not insignificant */
1416 /* Adaptec HostRAID */
1417 if (ata_raid_adaptec_read_meta(subdisk
, ata_raid_arrays
))
1420 /* LSILogic v3 and v2 */
1421 if (ata_raid_lsiv3_read_meta(subdisk
, ata_raid_arrays
))
1423 if (ata_raid_lsiv2_read_meta(subdisk
, ata_raid_arrays
))
1426 /* if none of the above matched, try FreeBSD native format */
1427 return ata_raid_promise_read_meta(subdisk
, ata_raid_arrays
, 1);
1431 ata_raid_write_metadata(struct ar_softc
*rdp
)
1433 switch (rdp
->format
) {
1434 case AR_F_FREEBSD_RAID
:
1435 case AR_F_PROMISE_RAID
:
1436 return ata_raid_promise_write_meta(rdp
);
1438 case AR_F_HPTV3_RAID
:
1439 case AR_F_HPTV2_RAID
:
1441 * always write HPT v2 metadata, the v3 BIOS knows it as well.
1442 * this is handy since we cannot know what version BIOS is on there
1444 return ata_raid_hptv2_write_meta(rdp
);
1446 case AR_F_INTEL_RAID
:
1447 return ata_raid_intel_write_meta(rdp
);
1449 case AR_F_JMICRON_RAID
:
1450 return ata_raid_jmicron_write_meta(rdp
);
1453 return ata_raid_sis_write_meta(rdp
);
1456 return ata_raid_via_write_meta(rdp
);
1458 case AR_F_HPTV3_RAID
:
1459 return ata_raid_hptv3_write_meta(rdp
);
1461 case AR_F_ADAPTEC_RAID
:
1462 return ata_raid_adaptec_write_meta(rdp
);
1465 return ata_raid_ite_write_meta(rdp
);
1467 case AR_F_LSIV2_RAID
:
1468 return ata_raid_lsiv2_write_meta(rdp
);
1470 case AR_F_LSIV3_RAID
:
1471 return ata_raid_lsiv3_write_meta(rdp
);
1473 case AR_F_NVIDIA_RAID
:
1474 return ata_raid_nvidia_write_meta(rdp
);
1477 return ata_raid_sii_write_meta(rdp
);
1481 kprintf("ar%d: writing of %s metadata is NOT supported yet\n",
1482 rdp
->lun
, ata_raid_format(rdp
));
1488 ata_raid_wipe_metadata(struct ar_softc
*rdp
)
1490 int disk
, error
= 0;
1495 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
1496 if (rdp
->disks
[disk
].dev
) {
1497 switch (rdp
->format
) {
1498 case AR_F_ADAPTEC_RAID
:
1499 lba
= ADP_LBA(rdp
->disks
[disk
].dev
);
1500 size
= sizeof(struct adaptec_raid_conf
);
1503 case AR_F_HPTV2_RAID
:
1504 lba
= HPTV2_LBA(rdp
->disks
[disk
].dev
);
1505 size
= sizeof(struct hptv2_raid_conf
);
1508 case AR_F_HPTV3_RAID
:
1509 lba
= HPTV3_LBA(rdp
->disks
[disk
].dev
);
1510 size
= sizeof(struct hptv3_raid_conf
);
1513 case AR_F_INTEL_RAID
:
1514 lba
= INTEL_LBA(rdp
->disks
[disk
].dev
);
1515 size
= 3 * 512; /* XXX SOS */
1519 lba
= ITE_LBA(rdp
->disks
[disk
].dev
);
1520 size
= sizeof(struct ite_raid_conf
);
1523 case AR_F_JMICRON_RAID
:
1524 lba
= JMICRON_LBA(rdp
->disks
[disk
].dev
);
1525 size
= sizeof(struct jmicron_raid_conf
);
1528 case AR_F_LSIV2_RAID
:
1529 lba
= LSIV2_LBA(rdp
->disks
[disk
].dev
);
1530 size
= sizeof(struct lsiv2_raid_conf
);
1533 case AR_F_LSIV3_RAID
:
1534 lba
= LSIV3_LBA(rdp
->disks
[disk
].dev
);
1535 size
= sizeof(struct lsiv3_raid_conf
);
1538 case AR_F_NVIDIA_RAID
:
1539 lba
= NVIDIA_LBA(rdp
->disks
[disk
].dev
);
1540 size
= sizeof(struct nvidia_raid_conf
);
1543 case AR_F_FREEBSD_RAID
:
1544 case AR_F_PROMISE_RAID
:
1545 lba
= PROMISE_LBA(rdp
->disks
[disk
].dev
);
1546 size
= sizeof(struct promise_raid_conf
);
1550 lba
= SII_LBA(rdp
->disks
[disk
].dev
);
1551 size
= sizeof(struct sii_raid_conf
);
1555 lba
= SIS_LBA(rdp
->disks
[disk
].dev
);
1556 size
= sizeof(struct sis_raid_conf
);
1560 lba
= VIA_LBA(rdp
->disks
[disk
].dev
);
1561 size
= sizeof(struct via_raid_conf
);
1565 kprintf("ar%d: wiping of %s metadata is NOT supported yet\n",
1566 rdp
->lun
, ata_raid_format(rdp
));
1569 meta
= kmalloc(size
, M_AR
, M_WAITOK
| M_ZERO
);
1570 if (ata_raid_rw(rdp
->disks
[disk
].dev
, lba
, meta
, size
,
1571 ATA_R_WRITE
| ATA_R_DIRECT
)) {
1572 device_printf(rdp
->disks
[disk
].dev
, "wipe metadata failed\n");
1581 /* Adaptec HostRAID Metadata */
1583 ata_raid_adaptec_read_meta(device_t dev
, struct ar_softc
**raidp
)
1585 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
1586 device_t parent
= device_get_parent(dev
);
1587 struct adaptec_raid_conf
*meta
;
1588 struct ar_softc
*raid
;
1589 int array
, disk
, retval
= 0;
1591 meta
= (struct adaptec_raid_conf
*)
1592 kmalloc(sizeof(struct adaptec_raid_conf
), M_AR
, M_WAITOK
| M_ZERO
);
1594 if (ata_raid_rw(parent
, ADP_LBA(parent
),
1595 meta
, sizeof(struct adaptec_raid_conf
), ATA_R_READ
)) {
1596 if (testing
|| bootverbose
)
1597 device_printf(parent
, "Adaptec read metadata failed\n");
1601 /* check if this is a Adaptec RAID struct */
1602 if (meta
->magic_0
!= ADP_MAGIC_0
|| meta
->magic_3
!= ADP_MAGIC_3
) {
1603 if (testing
|| bootverbose
)
1604 device_printf(parent
, "Adaptec check1 failed\n");
1608 if (testing
|| bootverbose
)
1609 ata_raid_adaptec_print_meta(meta
);
1611 /* now convert Adaptec metadata into our generic form */
1612 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
1613 if (!raidp
[array
]) {
1615 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
1618 raid
= raidp
[array
];
1619 if (raid
->format
&& (raid
->format
!= AR_F_ADAPTEC_RAID
))
1622 if (raid
->magic_0
&& raid
->magic_0
!= meta
->configs
[0].magic_0
)
1625 if (!meta
->generation
|| be32toh(meta
->generation
) > raid
->generation
) {
1626 switch (meta
->configs
[0].type
) {
1628 raid
->magic_0
= meta
->configs
[0].magic_0
;
1629 raid
->type
= AR_T_RAID0
;
1630 raid
->interleave
= 1 << (meta
->configs
[0].stripe_shift
>> 1);
1631 raid
->width
= be16toh(meta
->configs
[0].total_disks
);
1635 raid
->magic_0
= meta
->configs
[0].magic_0
;
1636 raid
->type
= AR_T_RAID1
;
1637 raid
->width
= be16toh(meta
->configs
[0].total_disks
) / 2;
1641 device_printf(parent
, "Adaptec unknown RAID type 0x%02x\n",
1642 meta
->configs
[0].type
);
1643 kfree(raidp
[array
], M_AR
);
1644 raidp
[array
] = NULL
;
1648 raid
->format
= AR_F_ADAPTEC_RAID
;
1649 raid
->generation
= be32toh(meta
->generation
);
1650 raid
->total_disks
= be16toh(meta
->configs
[0].total_disks
);
1651 raid
->total_sectors
= be32toh(meta
->configs
[0].sectors
);
1654 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
1655 raid
->offset_sectors
= 0;
1656 raid
->rebuild_lba
= 0;
1658 strncpy(raid
->name
, meta
->configs
[0].name
,
1659 min(sizeof(raid
->name
), sizeof(meta
->configs
[0].name
)));
1661 /* clear out any old info */
1662 if (raid
->generation
) {
1663 for (disk
= 0; disk
< raid
->total_disks
; disk
++) {
1664 raid
->disks
[disk
].dev
= NULL
;
1665 raid
->disks
[disk
].flags
= 0;
1669 if (be32toh(meta
->generation
) >= raid
->generation
) {
1670 struct ata_device
*atadev
= device_get_softc(parent
);
1671 struct ata_channel
*ch
= device_get_softc(GRANDPARENT(dev
));
1672 int disk_number
= (ch
->unit
<< !(ch
->flags
& ATA_NO_SLAVE
)) +
1673 ATA_DEV(atadev
->unit
);
1675 raid
->disks
[disk_number
].dev
= parent
;
1676 raid
->disks
[disk_number
].sectors
=
1677 be32toh(meta
->configs
[disk_number
+ 1].sectors
);
1678 raid
->disks
[disk_number
].flags
=
1679 (AR_DF_ONLINE
| AR_DF_PRESENT
| AR_DF_ASSIGNED
);
1680 ars
->raid
[raid
->volume
] = raid
;
1681 ars
->disk_number
[raid
->volume
] = disk_number
;
1692 /* Highpoint V2 RocketRAID Metadata */
1694 ata_raid_hptv2_read_meta(device_t dev
, struct ar_softc
**raidp
)
1696 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
1697 device_t parent
= device_get_parent(dev
);
1698 struct hptv2_raid_conf
*meta
;
1699 struct ar_softc
*raid
= NULL
;
1700 int array
, disk_number
= 0, retval
= 0;
1702 meta
= (struct hptv2_raid_conf
*)kmalloc(sizeof(struct hptv2_raid_conf
),
1703 M_AR
, M_WAITOK
| M_ZERO
);
1705 if (ata_raid_rw(parent
, HPTV2_LBA(parent
),
1706 meta
, sizeof(struct hptv2_raid_conf
), ATA_R_READ
)) {
1707 if (testing
|| bootverbose
)
1708 device_printf(parent
, "HighPoint (v2) read metadata failed\n");
1712 /* check if this is a HighPoint v2 RAID struct */
1713 if (meta
->magic
!= HPTV2_MAGIC_OK
&& meta
->magic
!= HPTV2_MAGIC_BAD
) {
1714 if (testing
|| bootverbose
)
1715 device_printf(parent
, "HighPoint (v2) check1 failed\n");
1719 /* is this disk defined, or an old leftover/spare ? */
1720 if (!meta
->magic_0
) {
1721 if (testing
|| bootverbose
)
1722 device_printf(parent
, "HighPoint (v2) check2 failed\n");
1726 if (testing
|| bootverbose
)
1727 ata_raid_hptv2_print_meta(meta
);
1729 /* now convert HighPoint (v2) metadata into our generic form */
1730 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
1731 if (!raidp
[array
]) {
1733 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
1736 raid
= raidp
[array
];
1737 if (raid
->format
&& (raid
->format
!= AR_F_HPTV2_RAID
))
1740 switch (meta
->type
) {
1742 if ((meta
->order
& (HPTV2_O_RAID0
|HPTV2_O_OK
)) ==
1743 (HPTV2_O_RAID0
|HPTV2_O_OK
))
1744 goto highpoint_raid1
;
1745 if (meta
->order
& (HPTV2_O_RAID0
| HPTV2_O_RAID1
))
1746 goto highpoint_raid01
;
1747 if (raid
->magic_0
&& raid
->magic_0
!= meta
->magic_0
)
1749 raid
->magic_0
= meta
->magic_0
;
1750 raid
->type
= AR_T_RAID0
;
1751 raid
->interleave
= 1 << meta
->stripe_shift
;
1752 disk_number
= meta
->disk_number
;
1753 if (!(meta
->order
& HPTV2_O_OK
))
1754 meta
->magic
= 0; /* mark bad */
1759 if (raid
->magic_0
&& raid
->magic_0
!= meta
->magic_0
)
1761 raid
->magic_0
= meta
->magic_0
;
1762 raid
->type
= AR_T_RAID1
;
1763 disk_number
= (meta
->disk_number
> 0);
1766 case HPTV2_T_RAID01_RAID0
:
1768 if (meta
->order
& HPTV2_O_RAID0
) {
1769 if ((raid
->magic_0
&& raid
->magic_0
!= meta
->magic_0
) ||
1770 (raid
->magic_1
&& raid
->magic_1
!= meta
->magic_1
))
1772 raid
->magic_0
= meta
->magic_0
;
1773 raid
->magic_1
= meta
->magic_1
;
1774 raid
->type
= AR_T_RAID01
;
1775 raid
->interleave
= 1 << meta
->stripe_shift
;
1776 disk_number
= meta
->disk_number
;
1779 if (raid
->magic_1
&& raid
->magic_1
!= meta
->magic_1
)
1781 raid
->magic_1
= meta
->magic_1
;
1782 raid
->type
= AR_T_RAID01
;
1783 raid
->interleave
= 1 << meta
->stripe_shift
;
1784 disk_number
= meta
->disk_number
+ meta
->array_width
;
1785 if (!(meta
->order
& HPTV2_O_RAID1
))
1786 meta
->magic
= 0; /* mark bad */
1791 if (raid
->magic_0
&& raid
->magic_0
!= meta
->magic_0
)
1793 raid
->magic_0
= meta
->magic_0
;
1794 raid
->type
= AR_T_SPAN
;
1795 disk_number
= meta
->disk_number
;
1799 device_printf(parent
, "Highpoint (v2) unknown RAID type 0x%02x\n",
1801 kfree(raidp
[array
], M_AR
);
1802 raidp
[array
] = NULL
;
1806 raid
->format
|= AR_F_HPTV2_RAID
;
1807 raid
->disks
[disk_number
].dev
= parent
;
1808 raid
->disks
[disk_number
].flags
= (AR_DF_PRESENT
| AR_DF_ASSIGNED
);
1810 strncpy(raid
->name
, meta
->name_1
,
1811 min(sizeof(raid
->name
), sizeof(meta
->name_1
)));
1812 if (meta
->magic
== HPTV2_MAGIC_OK
) {
1813 raid
->disks
[disk_number
].flags
|= AR_DF_ONLINE
;
1814 raid
->width
= meta
->array_width
;
1815 raid
->total_sectors
= meta
->total_sectors
;
1818 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
1819 raid
->offset_sectors
= HPTV2_LBA(parent
) + 1;
1820 raid
->rebuild_lba
= meta
->rebuild_lba
;
1821 raid
->disks
[disk_number
].sectors
=
1822 raid
->total_sectors
/ raid
->width
;
1825 raid
->disks
[disk_number
].flags
&= ~AR_DF_ONLINE
;
1827 if ((raid
->type
& AR_T_RAID0
) && (raid
->total_disks
< raid
->width
))
1828 raid
->total_disks
= raid
->width
;
1829 if (disk_number
>= raid
->total_disks
)
1830 raid
->total_disks
= disk_number
+ 1;
1831 ars
->raid
[raid
->volume
] = raid
;
1832 ars
->disk_number
[raid
->volume
] = disk_number
;
1843 ata_raid_hptv2_write_meta(struct ar_softc
*rdp
)
1845 struct hptv2_raid_conf
*meta
;
1846 struct timeval timestamp
;
1847 int disk
, error
= 0;
1849 meta
= (struct hptv2_raid_conf
*)kmalloc(sizeof(struct hptv2_raid_conf
),
1850 M_AR
, M_WAITOK
| M_ZERO
);
1852 microtime(×tamp
);
1853 rdp
->magic_0
= timestamp
.tv_sec
+ 2;
1854 rdp
->magic_1
= timestamp
.tv_sec
;
1856 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
1857 if ((rdp
->disks
[disk
].flags
& (AR_DF_PRESENT
| AR_DF_ONLINE
)) ==
1858 (AR_DF_PRESENT
| AR_DF_ONLINE
))
1859 meta
->magic
= HPTV2_MAGIC_OK
;
1860 if (rdp
->disks
[disk
].flags
& AR_DF_ASSIGNED
) {
1861 meta
->magic_0
= rdp
->magic_0
;
1862 if (strlen(rdp
->name
))
1863 strncpy(meta
->name_1
, rdp
->name
, sizeof(meta
->name_1
));
1865 strcpy(meta
->name_1
, "FreeBSD");
1867 meta
->disk_number
= disk
;
1869 switch (rdp
->type
) {
1871 meta
->type
= HPTV2_T_RAID0
;
1872 strcpy(meta
->name_2
, "RAID 0");
1873 if (rdp
->disks
[disk
].flags
& AR_DF_ONLINE
)
1874 meta
->order
= HPTV2_O_OK
;
1878 meta
->type
= HPTV2_T_RAID0
;
1879 strcpy(meta
->name_2
, "RAID 1");
1880 meta
->disk_number
= (disk
< rdp
->width
) ? disk
: disk
+ 5;
1881 meta
->order
= HPTV2_O_RAID0
| HPTV2_O_OK
;
1885 meta
->type
= HPTV2_T_RAID01_RAID0
;
1886 strcpy(meta
->name_2
, "RAID 0+1");
1887 if (rdp
->disks
[disk
].flags
& AR_DF_ONLINE
) {
1888 if (disk
< rdp
->width
) {
1889 meta
->order
= (HPTV2_O_RAID0
| HPTV2_O_RAID1
);
1890 meta
->magic_0
= rdp
->magic_0
- 1;
1893 meta
->order
= HPTV2_O_RAID1
;
1894 meta
->disk_number
-= rdp
->width
;
1898 meta
->magic_0
= rdp
->magic_0
- 1;
1899 meta
->magic_1
= rdp
->magic_1
;
1903 meta
->type
= HPTV2_T_SPAN
;
1904 strcpy(meta
->name_2
, "SPAN");
1911 meta
->array_width
= rdp
->width
;
1912 meta
->stripe_shift
= (rdp
->width
> 1) ? (ffs(rdp
->interleave
)-1) : 0;
1913 meta
->total_sectors
= rdp
->total_sectors
;
1914 meta
->rebuild_lba
= rdp
->rebuild_lba
;
1915 if (testing
|| bootverbose
)
1916 ata_raid_hptv2_print_meta(meta
);
1917 if (rdp
->disks
[disk
].dev
) {
1918 if (ata_raid_rw(rdp
->disks
[disk
].dev
,
1919 HPTV2_LBA(rdp
->disks
[disk
].dev
), meta
,
1920 sizeof(struct promise_raid_conf
),
1921 ATA_R_WRITE
| ATA_R_DIRECT
)) {
1922 device_printf(rdp
->disks
[disk
].dev
, "write metadata failed\n");
1931 /* Highpoint V3 RocketRAID Metadata */
1933 ata_raid_hptv3_read_meta(device_t dev
, struct ar_softc
**raidp
)
1935 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
1936 device_t parent
= device_get_parent(dev
);
1937 struct hptv3_raid_conf
*meta
;
1938 struct ar_softc
*raid
= NULL
;
1939 int array
, disk_number
, retval
= 0;
1941 meta
= (struct hptv3_raid_conf
*)kmalloc(sizeof(struct hptv3_raid_conf
),
1942 M_AR
, M_WAITOK
| M_ZERO
);
1944 if (ata_raid_rw(parent
, HPTV3_LBA(parent
),
1945 meta
, sizeof(struct hptv3_raid_conf
), ATA_R_READ
)) {
1946 if (testing
|| bootverbose
)
1947 device_printf(parent
, "HighPoint (v3) read metadata failed\n");
1951 /* check if this is a HighPoint v3 RAID struct */
1952 if (meta
->magic
!= HPTV3_MAGIC
) {
1953 if (testing
|| bootverbose
)
1954 device_printf(parent
, "HighPoint (v3) check1 failed\n");
1958 /* check if there are any config_entries */
1959 if (meta
->config_entries
< 1) {
1960 if (testing
|| bootverbose
)
1961 device_printf(parent
, "HighPoint (v3) check2 failed\n");
1965 if (testing
|| bootverbose
)
1966 ata_raid_hptv3_print_meta(meta
);
1968 /* now convert HighPoint (v3) metadata into our generic form */
1969 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
1970 if (!raidp
[array
]) {
1972 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
1975 raid
= raidp
[array
];
1976 if (raid
->format
&& (raid
->format
!= AR_F_HPTV3_RAID
))
1979 if ((raid
->format
& AR_F_HPTV3_RAID
) && raid
->magic_0
!= meta
->magic_0
)
1982 switch (meta
->configs
[0].type
) {
1984 raid
->type
= AR_T_RAID0
;
1985 raid
->width
= meta
->configs
[0].total_disks
;
1986 disk_number
= meta
->configs
[0].disk_number
;
1990 raid
->type
= AR_T_RAID1
;
1991 raid
->width
= meta
->configs
[0].total_disks
/ 2;
1992 disk_number
= meta
->configs
[0].disk_number
;
1996 raid
->type
= AR_T_RAID5
;
1997 raid
->width
= meta
->configs
[0].total_disks
;
1998 disk_number
= meta
->configs
[0].disk_number
;
2002 raid
->type
= AR_T_SPAN
;
2003 raid
->width
= meta
->configs
[0].total_disks
;
2004 disk_number
= meta
->configs
[0].disk_number
;
2008 device_printf(parent
, "Highpoint (v3) unknown RAID type 0x%02x\n",
2009 meta
->configs
[0].type
);
2010 kfree(raidp
[array
], M_AR
);
2011 raidp
[array
] = NULL
;
2014 if (meta
->config_entries
== 2) {
2015 switch (meta
->configs
[1].type
) {
2017 if (raid
->type
== AR_T_RAID0
) {
2018 raid
->type
= AR_T_RAID01
;
2019 disk_number
= meta
->configs
[1].disk_number
+
2020 (meta
->configs
[0].disk_number
<< 1);
2024 device_printf(parent
, "Highpoint (v3) unknown level 2 0x%02x\n",
2025 meta
->configs
[1].type
);
2026 kfree(raidp
[array
], M_AR
);
2027 raidp
[array
] = NULL
;
2032 raid
->magic_0
= meta
->magic_0
;
2033 raid
->format
= AR_F_HPTV3_RAID
;
2034 raid
->generation
= meta
->timestamp
;
2035 raid
->interleave
= 1 << meta
->configs
[0].stripe_shift
;
2036 raid
->total_disks
= meta
->configs
[0].total_disks
+
2037 meta
->configs
[1].total_disks
;
2038 raid
->total_sectors
= meta
->configs
[0].total_sectors
+
2039 ((u_int64_t
)meta
->configs_high
[0].total_sectors
<< 32);
2042 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
2043 raid
->offset_sectors
= 0;
2044 raid
->rebuild_lba
= meta
->configs
[0].rebuild_lba
+
2045 ((u_int64_t
)meta
->configs_high
[0].rebuild_lba
<< 32);
2047 strncpy(raid
->name
, meta
->name
,
2048 min(sizeof(raid
->name
), sizeof(meta
->name
)));
2049 raid
->disks
[disk_number
].sectors
= raid
->total_sectors
/
2050 (raid
->type
== AR_T_RAID5
? raid
->width
- 1 : raid
->width
);
2051 raid
->disks
[disk_number
].dev
= parent
;
2052 raid
->disks
[disk_number
].flags
=
2053 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_ONLINE
);
2054 ars
->raid
[raid
->volume
] = raid
;
2055 ars
->disk_number
[raid
->volume
] = disk_number
;
2065 /* Intel MatrixRAID Metadata */
2067 ata_raid_intel_read_meta(device_t dev
, struct ar_softc
**raidp
)
2069 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
2070 device_t parent
= device_get_parent(dev
);
2071 struct intel_raid_conf
*meta
;
2072 struct intel_raid_mapping
*map
;
2073 struct ar_softc
*raid
= NULL
;
2074 u_int32_t checksum
, *ptr
;
2075 int array
, count
, disk
, volume
= 1, retval
= 0;
2078 meta
= (struct intel_raid_conf
*)kmalloc(1536, M_AR
, M_WAITOK
| M_ZERO
);
2080 if (ata_raid_rw(parent
, INTEL_LBA(parent
), meta
, 1024, ATA_R_READ
)) {
2081 if (testing
|| bootverbose
)
2082 device_printf(parent
, "Intel read metadata failed\n");
2086 bcopy(tmp
, tmp
+1024, 512);
2087 bcopy(tmp
+512, tmp
, 1024);
2088 bzero(tmp
+1024, 512);
2090 /* check if this is a Intel RAID struct */
2091 if (strncmp(meta
->intel_id
, INTEL_MAGIC
, strlen(INTEL_MAGIC
))) {
2092 if (testing
|| bootverbose
)
2093 device_printf(parent
, "Intel check1 failed\n");
2097 for (checksum
= 0, ptr
= (u_int32_t
*)meta
, count
= 0;
2098 count
< (meta
->config_size
/ sizeof(u_int32_t
)); count
++) {
2101 checksum
-= meta
->checksum
;
2102 if (checksum
!= meta
->checksum
) {
2103 if (testing
|| bootverbose
)
2104 device_printf(parent
, "Intel check2 failed\n");
2108 if (testing
|| bootverbose
)
2109 ata_raid_intel_print_meta(meta
);
2111 map
= (struct intel_raid_mapping
*)&meta
->disk
[meta
->total_disks
];
2113 /* now convert Intel metadata into our generic form */
2114 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
2115 if (!raidp
[array
]) {
2117 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
2120 raid
= raidp
[array
];
2121 if (raid
->format
&& (raid
->format
!= AR_F_INTEL_RAID
))
2124 if ((raid
->format
& AR_F_INTEL_RAID
) &&
2125 (raid
->magic_0
!= meta
->config_id
))
2129 * update our knowledge about the array config based on generation
2130 * NOTE: there can be multiple volumes on a disk set
2132 if (!meta
->generation
|| meta
->generation
> raid
->generation
) {
2133 switch (map
->type
) {
2135 raid
->type
= AR_T_RAID0
;
2136 raid
->width
= map
->total_disks
;
2140 if (map
->total_disks
== 4)
2141 raid
->type
= AR_T_RAID01
;
2143 raid
->type
= AR_T_RAID1
;
2144 raid
->width
= map
->total_disks
/ 2;
2148 raid
->type
= AR_T_RAID5
;
2149 raid
->width
= map
->total_disks
;
2153 device_printf(parent
, "Intel unknown RAID type 0x%02x\n",
2155 kfree(raidp
[array
], M_AR
);
2156 raidp
[array
] = NULL
;
2160 switch (map
->status
) {
2162 raid
->status
= AR_S_READY
;
2164 case INTEL_S_DEGRADED
:
2165 raid
->status
|= AR_S_DEGRADED
;
2167 case INTEL_S_DISABLED
:
2168 case INTEL_S_FAILURE
:
2172 raid
->magic_0
= meta
->config_id
;
2173 raid
->format
= AR_F_INTEL_RAID
;
2174 raid
->generation
= meta
->generation
;
2175 raid
->interleave
= map
->stripe_sectors
;
2176 raid
->total_disks
= map
->total_disks
;
2177 raid
->total_sectors
= map
->total_sectors
;
2180 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
2181 raid
->offset_sectors
= map
->offset
;
2182 raid
->rebuild_lba
= 0;
2184 raid
->volume
= volume
- 1;
2185 strncpy(raid
->name
, map
->name
,
2186 min(sizeof(raid
->name
), sizeof(map
->name
)));
2188 /* clear out any old info */
2189 for (disk
= 0; disk
< raid
->total_disks
; disk
++) {
2190 raid
->disks
[disk
].dev
= NULL
;
2191 bcopy(meta
->disk
[map
->disk_idx
[disk
]].serial
,
2192 raid
->disks
[disk
].serial
,
2193 sizeof(raid
->disks
[disk
].serial
));
2194 raid
->disks
[disk
].sectors
=
2195 meta
->disk
[map
->disk_idx
[disk
]].sectors
;
2196 raid
->disks
[disk
].flags
= 0;
2197 if (meta
->disk
[map
->disk_idx
[disk
]].flags
& INTEL_F_ONLINE
)
2198 raid
->disks
[disk
].flags
|= AR_DF_ONLINE
;
2199 if (meta
->disk
[map
->disk_idx
[disk
]].flags
& INTEL_F_ASSIGNED
)
2200 raid
->disks
[disk
].flags
|= AR_DF_ASSIGNED
;
2201 if (meta
->disk
[map
->disk_idx
[disk
]].flags
& INTEL_F_SPARE
) {
2202 raid
->disks
[disk
].flags
&= ~(AR_DF_ONLINE
| AR_DF_ASSIGNED
);
2203 raid
->disks
[disk
].flags
|= AR_DF_SPARE
;
2205 if (meta
->disk
[map
->disk_idx
[disk
]].flags
& INTEL_F_DOWN
)
2206 raid
->disks
[disk
].flags
&= ~AR_DF_ONLINE
;
2209 if (meta
->generation
>= raid
->generation
) {
2210 for (disk
= 0; disk
< raid
->total_disks
; disk
++) {
2211 struct ata_device
*atadev
= device_get_softc(parent
);
2213 if (!strncmp(raid
->disks
[disk
].serial
, atadev
->param
.serial
,
2214 sizeof(raid
->disks
[disk
].serial
))) {
2215 raid
->disks
[disk
].dev
= parent
;
2216 raid
->disks
[disk
].flags
|= (AR_DF_PRESENT
| AR_DF_ONLINE
);
2217 ars
->raid
[raid
->volume
] = raid
;
2218 ars
->disk_number
[raid
->volume
] = disk
;
2227 if (volume
< meta
->total_volumes
) {
2228 map
= (struct intel_raid_mapping
*)
2229 &map
->disk_idx
[map
->total_disks
];
2237 kfree(raidp
[array
], M_AR
);
2238 raidp
[array
] = NULL
;
2250 ata_raid_intel_write_meta(struct ar_softc
*rdp
)
2252 struct intel_raid_conf
*meta
;
2253 struct intel_raid_mapping
*map
;
2254 struct timeval timestamp
;
2255 u_int32_t checksum
, *ptr
;
2256 int count
, disk
, error
= 0;
2259 meta
= (struct intel_raid_conf
*)kmalloc(1536, M_AR
, M_WAITOK
| M_ZERO
);
2263 /* Generate a new config_id if none exists */
2264 if (!rdp
->magic_0
) {
2265 microtime(×tamp
);
2266 rdp
->magic_0
= timestamp
.tv_sec
^ timestamp
.tv_usec
;
2269 bcopy(INTEL_MAGIC
, meta
->intel_id
, sizeof(meta
->intel_id
));
2270 bcopy(INTEL_VERSION_1100
, meta
->version
, sizeof(meta
->version
));
2271 meta
->config_id
= rdp
->magic_0
;
2272 meta
->generation
= rdp
->generation
;
2273 meta
->total_disks
= rdp
->total_disks
;
2274 meta
->total_volumes
= 1; /* XXX SOS */
2275 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
2276 if (rdp
->disks
[disk
].dev
) {
2277 struct ata_channel
*ch
=
2278 device_get_softc(device_get_parent(rdp
->disks
[disk
].dev
));
2279 struct ata_device
*atadev
=
2280 device_get_softc(rdp
->disks
[disk
].dev
);
2282 bcopy(atadev
->param
.serial
, meta
->disk
[disk
].serial
,
2283 sizeof(rdp
->disks
[disk
].serial
));
2284 meta
->disk
[disk
].sectors
= rdp
->disks
[disk
].sectors
;
2285 meta
->disk
[disk
].id
= (ch
->unit
<< 16) | ATA_DEV(atadev
->unit
);
2288 meta
->disk
[disk
].sectors
= rdp
->total_sectors
/ rdp
->width
;
2289 meta
->disk
[disk
].flags
= 0;
2290 if (rdp
->disks
[disk
].flags
& AR_DF_SPARE
)
2291 meta
->disk
[disk
].flags
|= INTEL_F_SPARE
;
2293 if (rdp
->disks
[disk
].flags
& AR_DF_ONLINE
)
2294 meta
->disk
[disk
].flags
|= INTEL_F_ONLINE
;
2296 meta
->disk
[disk
].flags
|= INTEL_F_DOWN
;
2297 if (rdp
->disks
[disk
].flags
& AR_DF_ASSIGNED
)
2298 meta
->disk
[disk
].flags
|= INTEL_F_ASSIGNED
;
2301 map
= (struct intel_raid_mapping
*)&meta
->disk
[meta
->total_disks
];
2303 bcopy(rdp
->name
, map
->name
, sizeof(rdp
->name
));
2304 map
->total_sectors
= rdp
->total_sectors
;
2305 map
->state
= 12; /* XXX SOS */
2306 map
->offset
= rdp
->offset_sectors
;
2307 map
->stripe_count
= rdp
->total_sectors
/ (rdp
->interleave
*rdp
->total_disks
);
2308 map
->stripe_sectors
= rdp
->interleave
;
2309 map
->disk_sectors
= rdp
->total_sectors
/ rdp
->width
;
2310 map
->status
= INTEL_S_READY
; /* XXX SOS */
2311 switch (rdp
->type
) {
2313 map
->type
= INTEL_T_RAID0
;
2316 map
->type
= INTEL_T_RAID1
;
2319 map
->type
= INTEL_T_RAID1
;
2322 map
->type
= INTEL_T_RAID5
;
2328 map
->total_disks
= rdp
->total_disks
;
2329 map
->magic
[0] = 0x02;
2330 map
->magic
[1] = 0xff;
2331 map
->magic
[2] = 0x01;
2332 for (disk
= 0; disk
< rdp
->total_disks
; disk
++)
2333 map
->disk_idx
[disk
] = disk
;
2335 meta
->config_size
= (char *)&map
->disk_idx
[disk
] - (char *)meta
;
2336 for (checksum
= 0, ptr
= (u_int32_t
*)meta
, count
= 0;
2337 count
< (meta
->config_size
/ sizeof(u_int32_t
)); count
++) {
2340 meta
->checksum
= checksum
;
2342 if (testing
|| bootverbose
)
2343 ata_raid_intel_print_meta(meta
);
2346 bcopy(tmp
, tmp
+1024, 512);
2347 bcopy(tmp
+512, tmp
, 1024);
2348 bzero(tmp
+1024, 512);
2350 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
2351 if (rdp
->disks
[disk
].dev
) {
2352 if (ata_raid_rw(rdp
->disks
[disk
].dev
,
2353 INTEL_LBA(rdp
->disks
[disk
].dev
),
2354 meta
, 1024, ATA_R_WRITE
| ATA_R_DIRECT
)) {
2355 device_printf(rdp
->disks
[disk
].dev
, "write metadata failed\n");
2365 /* Integrated Technology Express Metadata */
2367 ata_raid_ite_read_meta(device_t dev
, struct ar_softc
**raidp
)
2369 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
2370 device_t parent
= device_get_parent(dev
);
2371 struct ite_raid_conf
*meta
;
2372 struct ar_softc
*raid
= NULL
;
2373 int array
, disk_number
, count
, retval
= 0;
2376 meta
= (struct ite_raid_conf
*)kmalloc(sizeof(struct ite_raid_conf
), M_AR
,
2379 if (ata_raid_rw(parent
, ITE_LBA(parent
),
2380 meta
, sizeof(struct ite_raid_conf
), ATA_R_READ
)) {
2381 if (testing
|| bootverbose
)
2382 device_printf(parent
, "ITE read metadata failed\n");
2386 /* check if this is a ITE RAID struct */
2387 for (ptr
= (u_int16_t
*)meta
->ite_id
, count
= 0;
2388 count
< sizeof(meta
->ite_id
)/sizeof(uint16_t); count
++)
2389 ptr
[count
] = be16toh(ptr
[count
]);
2391 if (strncmp(meta
->ite_id
, ITE_MAGIC
, strlen(ITE_MAGIC
))) {
2392 if (testing
|| bootverbose
)
2393 device_printf(parent
, "ITE check1 failed\n");
2397 if (testing
|| bootverbose
)
2398 ata_raid_ite_print_meta(meta
);
2400 /* now convert ITE metadata into our generic form */
2401 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
2402 if ((raid
= raidp
[array
])) {
2403 if (raid
->format
!= AR_F_ITE_RAID
)
2405 if (raid
->magic_0
!= *((u_int64_t
*)meta
->timestamp_0
))
2409 /* if we dont have a disks timestamp the RAID is invalidated */
2410 if (*((u_int64_t
*)meta
->timestamp_1
) == 0)
2414 raidp
[array
] = (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
),
2415 M_AR
, M_WAITOK
| M_ZERO
);
2418 switch (meta
->type
) {
2420 raid
->type
= AR_T_RAID0
;
2421 raid
->width
= meta
->array_width
;
2422 raid
->total_disks
= meta
->array_width
;
2423 disk_number
= meta
->disk_number
;
2427 raid
->type
= AR_T_RAID1
;
2429 raid
->total_disks
= 2;
2430 disk_number
= meta
->disk_number
;
2434 raid
->type
= AR_T_RAID01
;
2435 raid
->width
= meta
->array_width
;
2436 raid
->total_disks
= 4;
2437 disk_number
= ((meta
->disk_number
& 0x02) >> 1) |
2438 ((meta
->disk_number
& 0x01) << 1);
2442 raid
->type
= AR_T_SPAN
;
2444 raid
->total_disks
= meta
->array_width
;
2445 disk_number
= meta
->disk_number
;
2449 device_printf(parent
, "ITE unknown RAID type 0x%02x\n", meta
->type
);
2450 kfree(raidp
[array
], M_AR
);
2451 raidp
[array
] = NULL
;
2455 raid
->magic_0
= *((u_int64_t
*)meta
->timestamp_0
);
2456 raid
->format
= AR_F_ITE_RAID
;
2457 raid
->generation
= 0;
2458 raid
->interleave
= meta
->stripe_sectors
;
2459 raid
->total_sectors
= meta
->total_sectors
;
2462 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
2463 raid
->offset_sectors
= 0;
2464 raid
->rebuild_lba
= 0;
2467 raid
->disks
[disk_number
].dev
= parent
;
2468 raid
->disks
[disk_number
].sectors
= raid
->total_sectors
/ raid
->width
;
2469 raid
->disks
[disk_number
].flags
=
2470 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_ONLINE
);
2471 ars
->raid
[raid
->volume
] = raid
;
2472 ars
->disk_number
[raid
->volume
] = disk_number
;
2481 /* JMicron Technology Corp Metadata */
2483 ata_raid_jmicron_read_meta(device_t dev
, struct ar_softc
**raidp
)
2485 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
2486 device_t parent
= device_get_parent(dev
);
2487 struct jmicron_raid_conf
*meta
;
2488 struct ar_softc
*raid
= NULL
;
2489 u_int16_t checksum
, *ptr
;
2490 u_int64_t disk_size
;
2491 int count
, array
, disk
, total_disks
, retval
= 0;
2493 meta
= (struct jmicron_raid_conf
*)
2494 kmalloc(sizeof(struct jmicron_raid_conf
), M_AR
, M_WAITOK
| M_ZERO
);
2496 if (ata_raid_rw(parent
, JMICRON_LBA(parent
),
2497 meta
, sizeof(struct jmicron_raid_conf
), ATA_R_READ
)) {
2498 if (testing
|| bootverbose
)
2499 device_printf(parent
,
2500 "JMicron read metadata failed\n");
2503 /* check for JMicron signature */
2504 if (strncmp(meta
->signature
, JMICRON_MAGIC
, 2)) {
2505 if (testing
|| bootverbose
)
2506 device_printf(parent
, "JMicron check1 failed\n");
2510 /* calculate checksum and compare for valid */
2511 for (checksum
= 0, ptr
= (u_int16_t
*)meta
, count
= 0; count
< 64; count
++)
2514 if (testing
|| bootverbose
)
2515 device_printf(parent
, "JMicron check2 failed\n");
2519 if (testing
|| bootverbose
)
2520 ata_raid_jmicron_print_meta(meta
);
2522 /* now convert JMicron meta into our generic form */
2523 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
2525 if (!raidp
[array
]) {
2527 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
2530 raid
= raidp
[array
];
2531 if (raid
->format
&& (raid
->format
!= AR_F_JMICRON_RAID
))
2534 for (total_disks
= 0, disk
= 0; disk
< JM_MAX_DISKS
; disk
++) {
2535 if (meta
->disks
[disk
]) {
2536 if (raid
->format
== AR_F_JMICRON_RAID
) {
2537 if (bcmp(&meta
->disks
[disk
],
2538 raid
->disks
[disk
].serial
, sizeof(u_int32_t
))) {
2544 bcopy(&meta
->disks
[disk
],
2545 raid
->disks
[disk
].serial
, sizeof(u_int32_t
));
2549 /* handle spares XXX SOS */
2551 switch (meta
->type
) {
2553 raid
->type
= AR_T_RAID0
;
2554 raid
->width
= total_disks
;
2558 raid
->type
= AR_T_RAID1
;
2563 raid
->type
= AR_T_RAID01
;
2564 raid
->width
= total_disks
/ 2;
2568 raid
->type
= AR_T_RAID5
;
2569 raid
->width
= total_disks
;
2573 raid
->type
= AR_T_SPAN
;
2578 device_printf(parent
,
2579 "JMicron unknown RAID type 0x%02x\n", meta
->type
);
2580 kfree(raidp
[array
], M_AR
);
2581 raidp
[array
] = NULL
;
2584 disk_size
= (meta
->disk_sectors_high
<< 16) + meta
->disk_sectors_low
;
2585 raid
->format
= AR_F_JMICRON_RAID
;
2586 strncpy(raid
->name
, meta
->name
, sizeof(meta
->name
));
2587 raid
->generation
= 0;
2588 raid
->interleave
= 2 << meta
->stripe_shift
;
2589 raid
->total_disks
= total_disks
;
2590 raid
->total_sectors
= disk_size
* (raid
->width
-(raid
->type
==AR_RAID5
));
2593 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
2594 raid
->offset_sectors
= meta
->offset
* 16;
2595 raid
->rebuild_lba
= 0;
2598 for (disk
= 0; disk
< raid
->total_disks
; disk
++) {
2599 if (meta
->disks
[disk
] == meta
->disk_id
) {
2600 raid
->disks
[disk
].dev
= parent
;
2601 raid
->disks
[disk
].sectors
= disk_size
;
2602 raid
->disks
[disk
].flags
=
2603 (AR_DF_ONLINE
| AR_DF_PRESENT
| AR_DF_ASSIGNED
);
2604 ars
->raid
[raid
->volume
] = raid
;
2605 ars
->disk_number
[raid
->volume
] = disk
;
2618 ata_raid_jmicron_write_meta(struct ar_softc
*rdp
)
2620 struct jmicron_raid_conf
*meta
;
2621 u_int64_t disk_sectors
;
2622 int disk
, error
= 0;
2624 meta
= (struct jmicron_raid_conf
*)
2625 kmalloc(sizeof(struct jmicron_raid_conf
), M_AR
, M_WAITOK
| M_ZERO
);
2628 switch (rdp
->type
) {
2630 meta
->type
= JM_T_JBOD
;
2634 meta
->type
= JM_T_RAID0
;
2638 meta
->type
= JM_T_RAID1
;
2642 meta
->type
= JM_T_RAID5
;
2646 meta
->type
= JM_T_RAID01
;
2653 bcopy(JMICRON_MAGIC
, meta
->signature
, sizeof(JMICRON_MAGIC
));
2654 meta
->version
= JMICRON_VERSION
;
2655 meta
->offset
= rdp
->offset_sectors
/ 16;
2656 disk_sectors
= rdp
->total_sectors
/ (rdp
->width
- (rdp
->type
== AR_RAID5
));
2657 meta
->disk_sectors_low
= disk_sectors
& 0xffff;
2658 meta
->disk_sectors_high
= disk_sectors
>> 16;
2659 strncpy(meta
->name
, rdp
->name
, sizeof(meta
->name
));
2660 meta
->stripe_shift
= ffs(rdp
->interleave
) - 2;
2662 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
2663 if (rdp
->disks
[disk
].serial
[0])
2664 bcopy(rdp
->disks
[disk
].serial
,&meta
->disks
[disk
],sizeof(u_int32_t
));
2666 meta
->disks
[disk
] = (u_int32_t
)(uintptr_t)rdp
->disks
[disk
].dev
;
2669 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
2670 if (rdp
->disks
[disk
].dev
) {
2671 u_int16_t checksum
= 0, *ptr
;
2674 meta
->disk_id
= meta
->disks
[disk
];
2676 for (ptr
= (u_int16_t
*)meta
, count
= 0; count
< 64; count
++)
2678 meta
->checksum
-= checksum
;
2680 if (testing
|| bootverbose
)
2681 ata_raid_jmicron_print_meta(meta
);
2683 if (ata_raid_rw(rdp
->disks
[disk
].dev
,
2684 JMICRON_LBA(rdp
->disks
[disk
].dev
),
2685 meta
, sizeof(struct jmicron_raid_conf
),
2686 ATA_R_WRITE
| ATA_R_DIRECT
)) {
2687 device_printf(rdp
->disks
[disk
].dev
, "write metadata failed\n");
2692 /* handle spares XXX SOS */
2698 /* LSILogic V2 MegaRAID Metadata */
2700 ata_raid_lsiv2_read_meta(device_t dev
, struct ar_softc
**raidp
)
2702 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
2703 device_t parent
= device_get_parent(dev
);
2704 struct lsiv2_raid_conf
*meta
;
2705 struct ar_softc
*raid
= NULL
;
2706 int array
, retval
= 0;
2708 meta
= (struct lsiv2_raid_conf
*)kmalloc(sizeof(struct lsiv2_raid_conf
),
2709 M_AR
, M_WAITOK
| M_ZERO
);
2711 if (ata_raid_rw(parent
, LSIV2_LBA(parent
),
2712 meta
, sizeof(struct lsiv2_raid_conf
), ATA_R_READ
)) {
2713 if (testing
|| bootverbose
)
2714 device_printf(parent
, "LSI (v2) read metadata failed\n");
2718 /* check if this is a LSI RAID struct */
2719 if (strncmp(meta
->lsi_id
, LSIV2_MAGIC
, strlen(LSIV2_MAGIC
))) {
2720 if (testing
|| bootverbose
)
2721 device_printf(parent
, "LSI (v2) check1 failed\n");
2725 if (testing
|| bootverbose
)
2726 ata_raid_lsiv2_print_meta(meta
);
2728 /* now convert LSI (v2) config meta into our generic form */
2729 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
2730 int raid_entry
, conf_entry
;
2732 if (!raidp
[array
+ meta
->raid_number
]) {
2733 raidp
[array
+ meta
->raid_number
] =
2734 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
2737 raid
= raidp
[array
+ meta
->raid_number
];
2738 if (raid
->format
&& (raid
->format
!= AR_F_LSIV2_RAID
))
2741 if (raid
->magic_0
&&
2742 ((raid
->magic_0
!= meta
->timestamp
) ||
2743 (raid
->magic_1
!= meta
->raid_number
)))
2746 array
+= meta
->raid_number
;
2748 raid_entry
= meta
->raid_number
;
2749 conf_entry
= (meta
->configs
[raid_entry
].raid
.config_offset
>> 4) +
2750 meta
->disk_number
- 1;
2752 switch (meta
->configs
[raid_entry
].raid
.type
) {
2754 raid
->magic_0
= meta
->timestamp
;
2755 raid
->magic_1
= meta
->raid_number
;
2756 raid
->type
= AR_T_RAID0
;
2757 raid
->interleave
= meta
->configs
[raid_entry
].raid
.stripe_sectors
;
2758 raid
->width
= meta
->configs
[raid_entry
].raid
.array_width
;
2762 raid
->magic_0
= meta
->timestamp
;
2763 raid
->magic_1
= meta
->raid_number
;
2764 raid
->type
= AR_T_RAID1
;
2765 raid
->width
= meta
->configs
[raid_entry
].raid
.array_width
;
2768 case LSIV2_T_RAID0
| LSIV2_T_RAID1
:
2769 raid
->magic_0
= meta
->timestamp
;
2770 raid
->magic_1
= meta
->raid_number
;
2771 raid
->type
= AR_T_RAID01
;
2772 raid
->interleave
= meta
->configs
[raid_entry
].raid
.stripe_sectors
;
2773 raid
->width
= meta
->configs
[raid_entry
].raid
.array_width
;
2777 device_printf(parent
, "LSI v2 unknown RAID type 0x%02x\n",
2778 meta
->configs
[raid_entry
].raid
.type
);
2779 kfree(raidp
[array
], M_AR
);
2780 raidp
[array
] = NULL
;
2784 raid
->format
= AR_F_LSIV2_RAID
;
2785 raid
->generation
= 0;
2786 raid
->total_disks
= meta
->configs
[raid_entry
].raid
.disk_count
;
2787 raid
->total_sectors
= meta
->configs
[raid_entry
].raid
.total_sectors
;
2790 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
2791 raid
->offset_sectors
= 0;
2792 raid
->rebuild_lba
= 0;
2795 if (meta
->configs
[conf_entry
].disk
.device
!= LSIV2_D_NONE
) {
2796 raid
->disks
[meta
->disk_number
].dev
= parent
;
2797 raid
->disks
[meta
->disk_number
].sectors
=
2798 meta
->configs
[conf_entry
].disk
.disk_sectors
;
2799 raid
->disks
[meta
->disk_number
].flags
=
2800 (AR_DF_ONLINE
| AR_DF_PRESENT
| AR_DF_ASSIGNED
);
2801 ars
->raid
[raid
->volume
] = raid
;
2802 ars
->disk_number
[raid
->volume
] = meta
->disk_number
;
2806 raid
->disks
[meta
->disk_number
].flags
&= ~AR_DF_ONLINE
;
2816 /* LSILogic V3 MegaRAID Metadata */
2818 ata_raid_lsiv3_read_meta(device_t dev
, struct ar_softc
**raidp
)
2820 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
2821 device_t parent
= device_get_parent(dev
);
2822 struct lsiv3_raid_conf
*meta
;
2823 struct ar_softc
*raid
= NULL
;
2824 u_int8_t checksum
, *ptr
;
2825 int array
, entry
, count
, disk_number
, retval
= 0;
2827 meta
= (struct lsiv3_raid_conf
*)kmalloc(sizeof(struct lsiv3_raid_conf
),
2828 M_AR
, M_WAITOK
| M_ZERO
);
2830 if (ata_raid_rw(parent
, LSIV3_LBA(parent
),
2831 meta
, sizeof(struct lsiv3_raid_conf
), ATA_R_READ
)) {
2832 if (testing
|| bootverbose
)
2833 device_printf(parent
, "LSI (v3) read metadata failed\n");
2837 /* check if this is a LSI RAID struct */
2838 if (strncmp(meta
->lsi_id
, LSIV3_MAGIC
, strlen(LSIV3_MAGIC
))) {
2839 if (testing
|| bootverbose
)
2840 device_printf(parent
, "LSI (v3) check1 failed\n");
2844 /* check if the checksum is OK */
2845 for (checksum
= 0, ptr
= meta
->lsi_id
, count
= 0; count
< 512; count
++)
2848 if (testing
|| bootverbose
)
2849 device_printf(parent
, "LSI (v3) check2 failed\n");
2853 if (testing
|| bootverbose
)
2854 ata_raid_lsiv3_print_meta(meta
);
2856 /* now convert LSI (v3) config meta into our generic form */
2857 for (array
= 0, entry
= 0; array
< MAX_ARRAYS
&& entry
< 8;) {
2858 if (!raidp
[array
]) {
2860 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
2863 raid
= raidp
[array
];
2864 if (raid
->format
&& (raid
->format
!= AR_F_LSIV3_RAID
)) {
2869 if ((raid
->format
== AR_F_LSIV3_RAID
) &&
2870 (raid
->magic_0
!= meta
->timestamp
)) {
2875 switch (meta
->raid
[entry
].total_disks
) {
2880 if (meta
->raid
[entry
].device
== meta
->device
) {
2889 disk_number
= (meta
->device
& (LSIV3_D_DEVICE
|LSIV3_D_CHANNEL
))?1:0;
2892 device_printf(parent
, "lsiv3 > 2 disk support untested!!\n");
2893 disk_number
= (meta
->device
& LSIV3_D_DEVICE
? 1 : 0) +
2894 (meta
->device
& LSIV3_D_CHANNEL
? 2 : 0);
2898 switch (meta
->raid
[entry
].type
) {
2900 raid
->type
= AR_T_RAID0
;
2901 raid
->width
= meta
->raid
[entry
].total_disks
;
2905 raid
->type
= AR_T_RAID1
;
2906 raid
->width
= meta
->raid
[entry
].array_width
;
2910 device_printf(parent
, "LSI v3 unknown RAID type 0x%02x\n",
2911 meta
->raid
[entry
].type
);
2912 kfree(raidp
[array
], M_AR
);
2913 raidp
[array
] = NULL
;
2918 raid
->magic_0
= meta
->timestamp
;
2919 raid
->format
= AR_F_LSIV3_RAID
;
2920 raid
->generation
= 0;
2921 raid
->interleave
= meta
->raid
[entry
].stripe_pages
* 8;
2922 raid
->total_disks
= meta
->raid
[entry
].total_disks
;
2923 raid
->total_sectors
= raid
->width
* meta
->raid
[entry
].sectors
;
2926 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
2927 raid
->offset_sectors
= meta
->raid
[entry
].offset
;
2928 raid
->rebuild_lba
= 0;
2931 raid
->disks
[disk_number
].dev
= parent
;
2932 raid
->disks
[disk_number
].sectors
= raid
->total_sectors
/ raid
->width
;
2933 raid
->disks
[disk_number
].flags
=
2934 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_ONLINE
);
2935 ars
->raid
[raid
->volume
] = raid
;
2936 ars
->disk_number
[raid
->volume
] = disk_number
;
2947 /* nVidia MediaShield Metadata */
2949 ata_raid_nvidia_read_meta(device_t dev
, struct ar_softc
**raidp
)
2951 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
2952 device_t parent
= device_get_parent(dev
);
2953 struct nvidia_raid_conf
*meta
;
2954 struct ar_softc
*raid
= NULL
;
2955 u_int32_t checksum
, *ptr
;
2956 int array
, count
, retval
= 0;
2958 meta
= (struct nvidia_raid_conf
*)kmalloc(sizeof(struct nvidia_raid_conf
),
2959 M_AR
, M_WAITOK
| M_ZERO
);
2961 if (ata_raid_rw(parent
, NVIDIA_LBA(parent
),
2962 meta
, sizeof(struct nvidia_raid_conf
), ATA_R_READ
)) {
2963 if (testing
|| bootverbose
)
2964 device_printf(parent
, "nVidia read metadata failed\n");
2968 /* check if this is a nVidia RAID struct */
2969 if (strncmp(meta
->nvidia_id
, NV_MAGIC
, strlen(NV_MAGIC
))) {
2970 if (testing
|| bootverbose
)
2971 device_printf(parent
, "nVidia check1 failed\n");
2975 /* check if the checksum is OK */
2976 for (checksum
= 0, ptr
= (u_int32_t
*)meta
, count
= 0;
2977 count
< meta
->config_size
; count
++)
2980 if (testing
|| bootverbose
)
2981 device_printf(parent
, "nVidia check2 failed\n");
2985 if (testing
|| bootverbose
)
2986 ata_raid_nvidia_print_meta(meta
);
2988 /* now convert nVidia meta into our generic form */
2989 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
2990 if (!raidp
[array
]) {
2992 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
2995 raid
= raidp
[array
];
2996 if (raid
->format
&& (raid
->format
!= AR_F_NVIDIA_RAID
))
2999 if (raid
->format
== AR_F_NVIDIA_RAID
&&
3000 ((raid
->magic_0
!= meta
->magic_1
) ||
3001 (raid
->magic_1
!= meta
->magic_2
))) {
3005 switch (meta
->type
) {
3007 raid
->type
= AR_T_SPAN
;
3011 raid
->type
= AR_T_RAID0
;
3015 raid
->type
= AR_T_RAID1
;
3019 raid
->type
= AR_T_RAID5
;
3023 raid
->type
= AR_T_RAID01
;
3027 device_printf(parent
, "nVidia unknown RAID type 0x%02x\n",
3029 kfree(raidp
[array
], M_AR
);
3030 raidp
[array
] = NULL
;
3033 raid
->magic_0
= meta
->magic_1
;
3034 raid
->magic_1
= meta
->magic_2
;
3035 raid
->format
= AR_F_NVIDIA_RAID
;
3036 raid
->generation
= 0;
3037 raid
->interleave
= meta
->stripe_sectors
;
3038 raid
->width
= meta
->array_width
;
3039 raid
->total_disks
= meta
->total_disks
;
3040 raid
->total_sectors
= meta
->total_sectors
;
3043 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
3044 raid
->offset_sectors
= 0;
3045 raid
->rebuild_lba
= meta
->rebuild_lba
;
3047 raid
->status
= AR_S_READY
;
3048 if (meta
->status
& NV_S_DEGRADED
)
3049 raid
->status
|= AR_S_DEGRADED
;
3051 raid
->disks
[meta
->disk_number
].dev
= parent
;
3052 raid
->disks
[meta
->disk_number
].sectors
=
3053 raid
->total_sectors
/ raid
->width
;
3054 raid
->disks
[meta
->disk_number
].flags
=
3055 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_ONLINE
);
3056 ars
->raid
[raid
->volume
] = raid
;
3057 ars
->disk_number
[raid
->volume
] = meta
->disk_number
;
3067 /* Promise FastTrak Metadata */
3069 ata_raid_promise_read_meta(device_t dev
, struct ar_softc
**raidp
, int native
)
3071 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
3072 device_t parent
= device_get_parent(dev
);
3073 struct promise_raid_conf
*meta
;
3074 struct ar_softc
*raid
;
3075 u_int32_t checksum
, *ptr
;
3076 int array
, count
, disk
, disksum
= 0, retval
= 0;
3078 meta
= (struct promise_raid_conf
*)
3079 kmalloc(sizeof(struct promise_raid_conf
), M_AR
, M_WAITOK
| M_ZERO
);
3081 if (ata_raid_rw(parent
, PROMISE_LBA(parent
),
3082 meta
, sizeof(struct promise_raid_conf
), ATA_R_READ
)) {
3083 if (testing
|| bootverbose
)
3084 device_printf(parent
, "%s read metadata failed\n",
3085 native
? "FreeBSD" : "Promise");
3089 /* check the signature */
3091 if (strncmp(meta
->promise_id
, ATA_MAGIC
, strlen(ATA_MAGIC
))) {
3092 if (testing
|| bootverbose
)
3093 device_printf(parent
, "FreeBSD check1 failed\n");
3098 if (strncmp(meta
->promise_id
, PR_MAGIC
, strlen(PR_MAGIC
))) {
3099 if (testing
|| bootverbose
)
3100 device_printf(parent
, "Promise check1 failed\n");
3105 /* check if the checksum is OK */
3106 for (checksum
= 0, ptr
= (u_int32_t
*)meta
, count
= 0; count
< 511; count
++)
3108 if (checksum
!= *ptr
) {
3109 if (testing
|| bootverbose
)
3110 device_printf(parent
, "%s check2 failed\n",
3111 native
? "FreeBSD" : "Promise");
3115 /* check on disk integrity status */
3116 if (meta
->raid
.integrity
!= PR_I_VALID
) {
3117 if (testing
|| bootverbose
)
3118 device_printf(parent
, "%s check3 failed\n",
3119 native
? "FreeBSD" : "Promise");
3123 if (testing
|| bootverbose
)
3124 ata_raid_promise_print_meta(meta
);
3126 /* now convert Promise metadata into our generic form */
3127 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
3128 if (!raidp
[array
]) {
3130 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
3133 raid
= raidp
[array
];
3135 (raid
->format
!= (native
? AR_F_FREEBSD_RAID
: AR_F_PROMISE_RAID
)))
3138 if ((raid
->format
== (native
? AR_F_FREEBSD_RAID
: AR_F_PROMISE_RAID
))&&
3139 !(meta
->raid
.magic_1
== (raid
->magic_1
)))
3142 /* update our knowledge about the array config based on generation */
3143 if (!meta
->raid
.generation
|| meta
->raid
.generation
> raid
->generation
){
3144 switch (meta
->raid
.type
) {
3146 raid
->type
= AR_T_SPAN
;
3150 raid
->type
= AR_T_JBOD
;
3154 raid
->type
= AR_T_RAID0
;
3158 raid
->type
= AR_T_RAID1
;
3159 if (meta
->raid
.array_width
> 1)
3160 raid
->type
= AR_T_RAID01
;
3164 raid
->type
= AR_T_RAID5
;
3168 device_printf(parent
, "%s unknown RAID type 0x%02x\n",
3169 native
? "FreeBSD" : "Promise", meta
->raid
.type
);
3170 kfree(raidp
[array
], M_AR
);
3171 raidp
[array
] = NULL
;
3174 raid
->magic_1
= meta
->raid
.magic_1
;
3175 raid
->format
= (native
? AR_F_FREEBSD_RAID
: AR_F_PROMISE_RAID
);
3176 raid
->generation
= meta
->raid
.generation
;
3177 raid
->interleave
= 1 << meta
->raid
.stripe_shift
;
3178 raid
->width
= meta
->raid
.array_width
;
3179 raid
->total_disks
= meta
->raid
.total_disks
;
3180 raid
->heads
= meta
->raid
.heads
+ 1;
3181 raid
->sectors
= meta
->raid
.sectors
;
3182 raid
->cylinders
= meta
->raid
.cylinders
+ 1;
3183 raid
->total_sectors
= meta
->raid
.total_sectors
;
3184 raid
->offset_sectors
= 0;
3185 raid
->rebuild_lba
= meta
->raid
.rebuild_lba
;
3187 if ((meta
->raid
.status
&
3188 (PR_S_VALID
| PR_S_ONLINE
| PR_S_INITED
| PR_S_READY
)) ==
3189 (PR_S_VALID
| PR_S_ONLINE
| PR_S_INITED
| PR_S_READY
)) {
3190 raid
->status
|= AR_S_READY
;
3191 if (meta
->raid
.status
& PR_S_DEGRADED
)
3192 raid
->status
|= AR_S_DEGRADED
;
3195 raid
->status
&= ~AR_S_READY
;
3197 /* convert disk flags to our internal types */
3198 for (disk
= 0; disk
< meta
->raid
.total_disks
; disk
++) {
3199 raid
->disks
[disk
].dev
= NULL
;
3200 raid
->disks
[disk
].flags
= 0;
3201 *((u_int64_t
*)(raid
->disks
[disk
].serial
)) =
3202 meta
->raid
.disk
[disk
].magic_0
;
3203 disksum
+= meta
->raid
.disk
[disk
].flags
;
3204 if (meta
->raid
.disk
[disk
].flags
& PR_F_ONLINE
)
3205 raid
->disks
[disk
].flags
|= AR_DF_ONLINE
;
3206 if (meta
->raid
.disk
[disk
].flags
& PR_F_ASSIGNED
)
3207 raid
->disks
[disk
].flags
|= AR_DF_ASSIGNED
;
3208 if (meta
->raid
.disk
[disk
].flags
& PR_F_SPARE
) {
3209 raid
->disks
[disk
].flags
&= ~(AR_DF_ONLINE
| AR_DF_ASSIGNED
);
3210 raid
->disks
[disk
].flags
|= AR_DF_SPARE
;
3212 if (meta
->raid
.disk
[disk
].flags
& (PR_F_REDIR
| PR_F_DOWN
))
3213 raid
->disks
[disk
].flags
&= ~AR_DF_ONLINE
;
3216 device_printf(parent
, "%s subdisks has no flags\n",
3217 native
? "FreeBSD" : "Promise");
3218 kfree(raidp
[array
], M_AR
);
3219 raidp
[array
] = NULL
;
3223 if (meta
->raid
.generation
>= raid
->generation
) {
3224 int disk_number
= meta
->raid
.disk_number
;
3226 if (raid
->disks
[disk_number
].flags
&& (meta
->magic_0
==
3227 *((u_int64_t
*)(raid
->disks
[disk_number
].serial
)))) {
3228 raid
->disks
[disk_number
].dev
= parent
;
3229 raid
->disks
[disk_number
].flags
|= AR_DF_PRESENT
;
3230 raid
->disks
[disk_number
].sectors
= meta
->raid
.disk_sectors
;
3231 if ((raid
->disks
[disk_number
].flags
&
3232 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_ONLINE
)) ==
3233 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_ONLINE
)) {
3234 ars
->raid
[raid
->volume
] = raid
;
3235 ars
->disk_number
[raid
->volume
] = disk_number
;
3249 ata_raid_promise_write_meta(struct ar_softc
*rdp
)
3251 struct promise_raid_conf
*meta
;
3252 struct timeval timestamp
;
3254 int count
, disk
, drive
, error
= 0;
3256 meta
= (struct promise_raid_conf
*)
3257 kmalloc(sizeof(struct promise_raid_conf
), M_AR
, M_WAITOK
);
3260 microtime(×tamp
);
3262 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
3263 for (count
= 0; count
< sizeof(struct promise_raid_conf
); count
++)
3264 *(((u_int8_t
*)meta
) + count
) = 255 - (count
% 256);
3265 meta
->dummy_0
= 0x00020000;
3266 meta
->raid
.disk_number
= disk
;
3268 if (rdp
->disks
[disk
].dev
) {
3269 struct ata_device
*atadev
= device_get_softc(rdp
->disks
[disk
].dev
);
3270 struct ata_channel
*ch
=
3271 device_get_softc(device_get_parent(rdp
->disks
[disk
].dev
));
3273 meta
->raid
.channel
= ch
->unit
;
3274 meta
->raid
.device
= ATA_DEV(atadev
->unit
);
3275 meta
->raid
.disk_sectors
= rdp
->disks
[disk
].sectors
;
3276 meta
->raid
.disk_offset
= rdp
->offset_sectors
;
3279 meta
->raid
.channel
= 0;
3280 meta
->raid
.device
= 0;
3281 meta
->raid
.disk_sectors
= 0;
3282 meta
->raid
.disk_offset
= 0;
3284 meta
->magic_0
= PR_MAGIC0(meta
->raid
) | timestamp
.tv_sec
;
3285 meta
->magic_1
= timestamp
.tv_sec
>> 16;
3286 meta
->magic_2
= timestamp
.tv_sec
;
3287 meta
->raid
.integrity
= PR_I_VALID
;
3288 meta
->raid
.magic_0
= meta
->magic_0
;
3289 meta
->raid
.rebuild_lba
= rdp
->rebuild_lba
;
3290 meta
->raid
.generation
= rdp
->generation
;
3292 if (rdp
->status
& AR_S_READY
) {
3293 meta
->raid
.flags
= (PR_F_VALID
| PR_F_ASSIGNED
| PR_F_ONLINE
);
3295 (PR_S_VALID
| PR_S_ONLINE
| PR_S_INITED
| PR_S_READY
);
3296 if (rdp
->status
& AR_S_DEGRADED
)
3297 meta
->raid
.status
|= PR_S_DEGRADED
;
3299 meta
->raid
.status
|= PR_S_FUNCTIONAL
;
3302 meta
->raid
.flags
= PR_F_DOWN
;
3303 meta
->raid
.status
= 0;
3306 switch (rdp
->type
) {
3308 meta
->raid
.type
= PR_T_RAID0
;
3311 meta
->raid
.type
= PR_T_RAID1
;
3314 meta
->raid
.type
= PR_T_RAID1
;
3317 meta
->raid
.type
= PR_T_RAID5
;
3320 meta
->raid
.type
= PR_T_SPAN
;
3323 meta
->raid
.type
= PR_T_JBOD
;
3330 meta
->raid
.total_disks
= rdp
->total_disks
;
3331 meta
->raid
.stripe_shift
= ffs(rdp
->interleave
) - 1;
3332 meta
->raid
.array_width
= rdp
->width
;
3333 meta
->raid
.array_number
= rdp
->lun
;
3334 meta
->raid
.total_sectors
= rdp
->total_sectors
;
3335 meta
->raid
.cylinders
= rdp
->cylinders
- 1;
3336 meta
->raid
.heads
= rdp
->heads
- 1;
3337 meta
->raid
.sectors
= rdp
->sectors
;
3338 meta
->raid
.magic_1
= (u_int64_t
)meta
->magic_2
<<16 | meta
->magic_1
;
3340 bzero(&meta
->raid
.disk
, 8 * 12);
3341 for (drive
= 0; drive
< rdp
->total_disks
; drive
++) {
3342 meta
->raid
.disk
[drive
].flags
= 0;
3343 if (rdp
->disks
[drive
].flags
& AR_DF_PRESENT
)
3344 meta
->raid
.disk
[drive
].flags
|= PR_F_VALID
;
3345 if (rdp
->disks
[drive
].flags
& AR_DF_ASSIGNED
)
3346 meta
->raid
.disk
[drive
].flags
|= PR_F_ASSIGNED
;
3347 if (rdp
->disks
[drive
].flags
& AR_DF_ONLINE
)
3348 meta
->raid
.disk
[drive
].flags
|= PR_F_ONLINE
;
3350 if (rdp
->disks
[drive
].flags
& AR_DF_PRESENT
)
3351 meta
->raid
.disk
[drive
].flags
= (PR_F_REDIR
| PR_F_DOWN
);
3352 if (rdp
->disks
[drive
].flags
& AR_DF_SPARE
)
3353 meta
->raid
.disk
[drive
].flags
|= PR_F_SPARE
;
3354 meta
->raid
.disk
[drive
].dummy_0
= 0x0;
3355 if (rdp
->disks
[drive
].dev
) {
3356 struct ata_channel
*ch
=
3357 device_get_softc(device_get_parent(rdp
->disks
[drive
].dev
));
3358 struct ata_device
*atadev
=
3359 device_get_softc(rdp
->disks
[drive
].dev
);
3361 meta
->raid
.disk
[drive
].channel
= ch
->unit
;
3362 meta
->raid
.disk
[drive
].device
= ATA_DEV(atadev
->unit
);
3364 meta
->raid
.disk
[drive
].magic_0
=
3365 PR_MAGIC0(meta
->raid
.disk
[drive
]) | timestamp
.tv_sec
;
3368 if (rdp
->disks
[disk
].dev
) {
3369 if ((rdp
->disks
[disk
].flags
& (AR_DF_PRESENT
| AR_DF_ONLINE
)) ==
3370 (AR_DF_PRESENT
| AR_DF_ONLINE
)) {
3371 if (rdp
->format
== AR_F_FREEBSD_RAID
)
3372 bcopy(ATA_MAGIC
, meta
->promise_id
, sizeof(ATA_MAGIC
));
3374 bcopy(PR_MAGIC
, meta
->promise_id
, sizeof(PR_MAGIC
));
3377 bzero(meta
->promise_id
, sizeof(meta
->promise_id
));
3379 for (ckptr
= (int32_t *)meta
, count
= 0; count
< 511; count
++)
3380 meta
->checksum
+= *ckptr
++;
3381 if (testing
|| bootverbose
)
3382 ata_raid_promise_print_meta(meta
);
3383 if (ata_raid_rw(rdp
->disks
[disk
].dev
,
3384 PROMISE_LBA(rdp
->disks
[disk
].dev
),
3385 meta
, sizeof(struct promise_raid_conf
),
3386 ATA_R_WRITE
| ATA_R_DIRECT
)) {
3387 device_printf(rdp
->disks
[disk
].dev
, "write metadata failed\n");
3396 /* Silicon Image Medley Metadata */
3398 ata_raid_sii_read_meta(device_t dev
, struct ar_softc
**raidp
)
3400 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
3401 device_t parent
= device_get_parent(dev
);
3402 struct sii_raid_conf
*meta
;
3403 struct ar_softc
*raid
= NULL
;
3404 u_int16_t checksum
, *ptr
;
3405 int array
, count
, disk
, retval
= 0;
3407 meta
= (struct sii_raid_conf
*)kmalloc(sizeof(struct sii_raid_conf
), M_AR
,
3410 if (ata_raid_rw(parent
, SII_LBA(parent
),
3411 meta
, sizeof(struct sii_raid_conf
), ATA_R_READ
)) {
3412 if (testing
|| bootverbose
)
3413 device_printf(parent
, "Silicon Image read metadata failed\n");
3417 /* check if this is a Silicon Image (Medley) RAID struct */
3418 for (checksum
= 0, ptr
= (u_int16_t
*)meta
, count
= 0; count
< 160; count
++)
3421 if (testing
|| bootverbose
)
3422 device_printf(parent
, "Silicon Image check1 failed\n");
3426 for (checksum
= 0, ptr
= (u_int16_t
*)meta
, count
= 0; count
< 256; count
++)
3428 if (checksum
!= meta
->checksum_1
) {
3429 if (testing
|| bootverbose
)
3430 device_printf(parent
, "Silicon Image check2 failed\n");
3435 if (meta
->version_major
!= 0x0002 ||
3436 (meta
->version_minor
!= 0x0000 && meta
->version_minor
!= 0x0001)) {
3437 if (testing
|| bootverbose
)
3438 device_printf(parent
, "Silicon Image check3 failed\n");
3442 if (testing
|| bootverbose
)
3443 ata_raid_sii_print_meta(meta
);
3445 /* now convert Silicon Image meta into our generic form */
3446 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
3447 if (!raidp
[array
]) {
3449 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
3452 raid
= raidp
[array
];
3453 if (raid
->format
&& (raid
->format
!= AR_F_SII_RAID
))
3456 if (raid
->format
== AR_F_SII_RAID
&&
3457 (raid
->magic_0
!= *((u_int64_t
*)meta
->timestamp
))) {
3461 /* update our knowledge about the array config based on generation */
3462 if (!meta
->generation
|| meta
->generation
> raid
->generation
) {
3463 switch (meta
->type
) {
3465 raid
->type
= AR_T_RAID0
;
3469 raid
->type
= AR_T_RAID1
;
3473 raid
->type
= AR_T_RAID01
;
3477 device_printf(parent
, "Silicon Image SPARE disk\n");
3478 kfree(raidp
[array
], M_AR
);
3479 raidp
[array
] = NULL
;
3483 device_printf(parent
,"Silicon Image unknown RAID type 0x%02x\n",
3485 kfree(raidp
[array
], M_AR
);
3486 raidp
[array
] = NULL
;
3489 raid
->magic_0
= *((u_int64_t
*)meta
->timestamp
);
3490 raid
->format
= AR_F_SII_RAID
;
3491 raid
->generation
= meta
->generation
;
3492 raid
->interleave
= meta
->stripe_sectors
;
3493 raid
->width
= (meta
->raid0_disks
!= 0xff) ? meta
->raid0_disks
: 1;
3495 ((meta
->raid0_disks
!= 0xff) ? meta
->raid0_disks
: 0) +
3496 ((meta
->raid1_disks
!= 0xff) ? meta
->raid1_disks
: 0);
3497 raid
->total_sectors
= meta
->total_sectors
;
3500 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
3501 raid
->offset_sectors
= 0;
3502 raid
->rebuild_lba
= meta
->rebuild_lba
;
3504 strncpy(raid
->name
, meta
->name
,
3505 min(sizeof(raid
->name
), sizeof(meta
->name
)));
3507 /* clear out any old info */
3508 if (raid
->generation
) {
3509 for (disk
= 0; disk
< raid
->total_disks
; disk
++) {
3510 raid
->disks
[disk
].dev
= NULL
;
3511 raid
->disks
[disk
].flags
= 0;
3515 if (meta
->generation
>= raid
->generation
) {
3516 /* XXX SOS add check for the right physical disk by serial# */
3517 if (meta
->status
& SII_S_READY
) {
3518 int disk_number
= (raid
->type
== AR_T_RAID01
) ?
3519 meta
->raid1_ident
+ (meta
->raid0_ident
<< 1) :
3522 raid
->disks
[disk_number
].dev
= parent
;
3523 raid
->disks
[disk_number
].sectors
=
3524 raid
->total_sectors
/ raid
->width
;
3525 raid
->disks
[disk_number
].flags
=
3526 (AR_DF_ONLINE
| AR_DF_PRESENT
| AR_DF_ASSIGNED
);
3527 ars
->raid
[raid
->volume
] = raid
;
3528 ars
->disk_number
[raid
->volume
] = disk_number
;
3540 /* Silicon Integrated Systems Metadata */
3542 ata_raid_sis_read_meta(device_t dev
, struct ar_softc
**raidp
)
3544 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
3545 device_t parent
= device_get_parent(dev
);
3546 struct sis_raid_conf
*meta
;
3547 struct ar_softc
*raid
= NULL
;
3548 int array
, disk_number
, drive
, retval
= 0;
3550 meta
= (struct sis_raid_conf
*)kmalloc(sizeof(struct sis_raid_conf
), M_AR
,
3553 if (ata_raid_rw(parent
, SIS_LBA(parent
),
3554 meta
, sizeof(struct sis_raid_conf
), ATA_R_READ
)) {
3555 if (testing
|| bootverbose
)
3556 device_printf(parent
,
3557 "Silicon Integrated Systems read metadata failed\n");
3560 /* check for SiS magic */
3561 if (meta
->magic
!= SIS_MAGIC
) {
3562 if (testing
|| bootverbose
)
3563 device_printf(parent
,
3564 "Silicon Integrated Systems check1 failed\n");
3568 if (testing
|| bootverbose
)
3569 ata_raid_sis_print_meta(meta
);
3571 /* now convert SiS meta into our generic form */
3572 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
3573 if (!raidp
[array
]) {
3575 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
3579 raid
= raidp
[array
];
3580 if (raid
->format
&& (raid
->format
!= AR_F_SIS_RAID
))
3583 if ((raid
->format
== AR_F_SIS_RAID
) &&
3584 ((raid
->magic_0
!= meta
->controller_pci_id
) ||
3585 (raid
->magic_1
!= meta
->timestamp
))) {
3589 switch (meta
->type_total_disks
& SIS_T_MASK
) {
3591 raid
->type
= AR_T_JBOD
;
3592 raid
->width
= (meta
->type_total_disks
& SIS_D_MASK
);
3593 raid
->total_sectors
+= SIS_LBA(parent
);
3597 raid
->type
= AR_T_RAID0
;
3598 raid
->width
= (meta
->type_total_disks
& SIS_D_MASK
);
3599 if (!raid
->total_sectors
||
3600 (raid
->total_sectors
> (raid
->width
* SIS_LBA(parent
))))
3601 raid
->total_sectors
= raid
->width
* SIS_LBA(parent
);
3605 raid
->type
= AR_T_RAID1
;
3607 if (!raid
->total_sectors
|| (raid
->total_sectors
> SIS_LBA(parent
)))
3608 raid
->total_sectors
= SIS_LBA(parent
);
3612 device_printf(parent
, "Silicon Integrated Systems "
3613 "unknown RAID type 0x%08x\n", meta
->magic
);
3614 kfree(raidp
[array
], M_AR
);
3615 raidp
[array
] = NULL
;
3618 raid
->magic_0
= meta
->controller_pci_id
;
3619 raid
->magic_1
= meta
->timestamp
;
3620 raid
->format
= AR_F_SIS_RAID
;
3621 raid
->generation
= 0;
3622 raid
->interleave
= meta
->stripe_sectors
;
3623 raid
->total_disks
= (meta
->type_total_disks
& SIS_D_MASK
);
3626 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
3627 raid
->offset_sectors
= 0;
3628 raid
->rebuild_lba
= 0;
3630 /* XXX SOS if total_disks > 2 this doesn't float */
3631 if (((meta
->disks
& SIS_D_MASTER
) >> 4) == meta
->disk_number
)
3636 for (drive
= 0; drive
< raid
->total_disks
; drive
++) {
3637 raid
->disks
[drive
].sectors
= raid
->total_sectors
/raid
->width
;
3638 if (drive
== disk_number
) {
3639 raid
->disks
[disk_number
].dev
= parent
;
3640 raid
->disks
[disk_number
].flags
=
3641 (AR_DF_ONLINE
| AR_DF_PRESENT
| AR_DF_ASSIGNED
);
3642 ars
->raid
[raid
->volume
] = raid
;
3643 ars
->disk_number
[raid
->volume
] = disk_number
;
3656 ata_raid_sis_write_meta(struct ar_softc
*rdp
)
3658 struct sis_raid_conf
*meta
;
3659 struct timeval timestamp
;
3660 int disk
, error
= 0;
3662 meta
= (struct sis_raid_conf
*)kmalloc(sizeof(struct sis_raid_conf
), M_AR
,
3666 microtime(×tamp
);
3668 meta
->magic
= SIS_MAGIC
;
3669 /* XXX SOS if total_disks > 2 this doesn't float */
3670 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
3671 if (rdp
->disks
[disk
].dev
) {
3672 struct ata_channel
*ch
=
3673 device_get_softc(device_get_parent(rdp
->disks
[disk
].dev
));
3674 struct ata_device
*atadev
= device_get_softc(rdp
->disks
[disk
].dev
);
3675 int disk_number
= 1 + ATA_DEV(atadev
->unit
) + (ch
->unit
<< 1);
3677 meta
->disks
|= disk_number
<< ((1 - disk
) << 2);
3680 switch (rdp
->type
) {
3682 meta
->type_total_disks
= SIS_T_JBOD
;
3686 meta
->type_total_disks
= SIS_T_RAID0
;
3690 meta
->type_total_disks
= SIS_T_RAID1
;
3697 meta
->type_total_disks
|= (rdp
->total_disks
& SIS_D_MASK
);
3698 meta
->stripe_sectors
= rdp
->interleave
;
3699 meta
->timestamp
= timestamp
.tv_sec
;
3701 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
3702 if (rdp
->disks
[disk
].dev
) {
3703 struct ata_channel
*ch
=
3704 device_get_softc(device_get_parent(rdp
->disks
[disk
].dev
));
3705 struct ata_device
*atadev
= device_get_softc(rdp
->disks
[disk
].dev
);
3707 meta
->controller_pci_id
=
3708 (pci_get_vendor(GRANDPARENT(rdp
->disks
[disk
].dev
)) << 16) |
3709 pci_get_device(GRANDPARENT(rdp
->disks
[disk
].dev
));
3710 bcopy(atadev
->param
.model
, meta
->model
, sizeof(meta
->model
));
3712 /* XXX SOS if total_disks > 2 this may not float */
3713 meta
->disk_number
= 1 + ATA_DEV(atadev
->unit
) + (ch
->unit
<< 1);
3715 if (testing
|| bootverbose
)
3716 ata_raid_sis_print_meta(meta
);
3718 if (ata_raid_rw(rdp
->disks
[disk
].dev
,
3719 SIS_LBA(rdp
->disks
[disk
].dev
),
3720 meta
, sizeof(struct sis_raid_conf
),
3721 ATA_R_WRITE
| ATA_R_DIRECT
)) {
3722 device_printf(rdp
->disks
[disk
].dev
, "write metadata failed\n");
3731 /* VIA Tech V-RAID Metadata */
3733 ata_raid_via_read_meta(device_t dev
, struct ar_softc
**raidp
)
3735 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
3736 device_t parent
= device_get_parent(dev
);
3737 struct via_raid_conf
*meta
;
3738 struct ar_softc
*raid
= NULL
;
3739 u_int8_t checksum
, *ptr
;
3740 int array
, count
, disk
, retval
= 0;
3742 meta
= (struct via_raid_conf
*)kmalloc(sizeof(struct via_raid_conf
), M_AR
,
3745 if (ata_raid_rw(parent
, VIA_LBA(parent
),
3746 meta
, sizeof(struct via_raid_conf
), ATA_R_READ
)) {
3747 if (testing
|| bootverbose
)
3748 device_printf(parent
, "VIA read metadata failed\n");
3752 /* check if this is a VIA RAID struct */
3753 if (meta
->magic
!= VIA_MAGIC
) {
3754 if (testing
|| bootverbose
)
3755 device_printf(parent
, "VIA check1 failed\n");
3759 /* calculate checksum and compare for valid */
3760 for (checksum
= 0, ptr
= (u_int8_t
*)meta
, count
= 0; count
< 50; count
++)
3762 if (checksum
!= meta
->checksum
) {
3763 if (testing
|| bootverbose
)
3764 device_printf(parent
, "VIA check2 failed\n");
3768 if (testing
|| bootverbose
)
3769 ata_raid_via_print_meta(meta
);
3771 /* now convert VIA meta into our generic form */
3772 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
3773 if (!raidp
[array
]) {
3775 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
3778 raid
= raidp
[array
];
3779 if (raid
->format
&& (raid
->format
!= AR_F_VIA_RAID
))
3782 if (raid
->format
== AR_F_VIA_RAID
&& (raid
->magic_0
!= meta
->disks
[0]))
3785 switch (meta
->type
& VIA_T_MASK
) {
3787 raid
->type
= AR_T_RAID0
;
3788 raid
->width
= meta
->stripe_layout
& VIA_L_DISKS
;
3789 if (!raid
->total_sectors
||
3790 (raid
->total_sectors
> (raid
->width
* meta
->disk_sectors
)))
3791 raid
->total_sectors
= raid
->width
* meta
->disk_sectors
;
3795 raid
->type
= AR_T_RAID1
;
3797 raid
->total_sectors
= meta
->disk_sectors
;
3801 raid
->type
= AR_T_RAID01
;
3802 raid
->width
= meta
->stripe_layout
& VIA_L_DISKS
;
3803 if (!raid
->total_sectors
||
3804 (raid
->total_sectors
> (raid
->width
* meta
->disk_sectors
)))
3805 raid
->total_sectors
= raid
->width
* meta
->disk_sectors
;
3809 raid
->type
= AR_T_RAID5
;
3810 raid
->width
= meta
->stripe_layout
& VIA_L_DISKS
;
3811 if (!raid
->total_sectors
||
3812 (raid
->total_sectors
> ((raid
->width
- 1)*meta
->disk_sectors
)))
3813 raid
->total_sectors
= (raid
->width
- 1) * meta
->disk_sectors
;
3817 raid
->type
= AR_T_SPAN
;
3819 raid
->total_sectors
+= meta
->disk_sectors
;
3823 device_printf(parent
,"VIA unknown RAID type 0x%02x\n", meta
->type
);
3824 kfree(raidp
[array
], M_AR
);
3825 raidp
[array
] = NULL
;
3828 raid
->magic_0
= meta
->disks
[0];
3829 raid
->format
= AR_F_VIA_RAID
;
3830 raid
->generation
= 0;
3832 0x08 << ((meta
->stripe_layout
& VIA_L_MASK
) >> VIA_L_SHIFT
);
3833 for (count
= 0, disk
= 0; disk
< 8; disk
++)
3834 if (meta
->disks
[disk
])
3836 raid
->total_disks
= count
;
3839 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
3840 raid
->offset_sectors
= 0;
3841 raid
->rebuild_lba
= 0;
3844 for (disk
= 0; disk
< raid
->total_disks
; disk
++) {
3845 if (meta
->disks
[disk
] == meta
->disk_id
) {
3846 raid
->disks
[disk
].dev
= parent
;
3847 bcopy(&meta
->disk_id
, raid
->disks
[disk
].serial
,
3849 raid
->disks
[disk
].sectors
= meta
->disk_sectors
;
3850 raid
->disks
[disk
].flags
=
3851 (AR_DF_ONLINE
| AR_DF_PRESENT
| AR_DF_ASSIGNED
);
3852 ars
->raid
[raid
->volume
] = raid
;
3853 ars
->disk_number
[raid
->volume
] = disk
;
3867 ata_raid_via_write_meta(struct ar_softc
*rdp
)
3869 struct via_raid_conf
*meta
;
3870 int disk
, error
= 0;
3872 meta
= (struct via_raid_conf
*)kmalloc(sizeof(struct via_raid_conf
), M_AR
,
3877 meta
->magic
= VIA_MAGIC
;
3878 meta
->dummy_0
= 0x02;
3879 switch (rdp
->type
) {
3881 meta
->type
= VIA_T_SPAN
;
3882 meta
->stripe_layout
= (rdp
->total_disks
& VIA_L_DISKS
);
3886 meta
->type
= VIA_T_RAID0
;
3887 meta
->stripe_layout
= ((rdp
->interleave
>> 1) & VIA_L_MASK
);
3888 meta
->stripe_layout
|= (rdp
->total_disks
& VIA_L_DISKS
);
3892 meta
->type
= VIA_T_RAID1
;
3893 meta
->stripe_layout
= (rdp
->total_disks
& VIA_L_DISKS
);
3897 meta
->type
= VIA_T_RAID5
;
3898 meta
->stripe_layout
= ((rdp
->interleave
>> 1) & VIA_L_MASK
);
3899 meta
->stripe_layout
|= (rdp
->total_disks
& VIA_L_DISKS
);
3903 meta
->type
= VIA_T_RAID01
;
3904 meta
->stripe_layout
= ((rdp
->interleave
>> 1) & VIA_L_MASK
);
3905 meta
->stripe_layout
|= (rdp
->width
& VIA_L_DISKS
);
3912 meta
->type
|= VIA_T_BOOTABLE
; /* XXX SOS */
3913 meta
->disk_sectors
=
3914 rdp
->total_sectors
/ (rdp
->width
- (rdp
->type
== AR_RAID5
));
3915 for (disk
= 0; disk
< rdp
->total_disks
; disk
++)
3916 meta
->disks
[disk
] = (u_int32_t
)(uintptr_t)rdp
->disks
[disk
].dev
;
3918 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
3919 if (rdp
->disks
[disk
].dev
) {
3923 meta
->disk_index
= disk
* sizeof(u_int32_t
);
3924 if (rdp
->type
== AR_T_RAID01
)
3925 meta
->disk_index
= ((meta
->disk_index
& 0x08) << 2) |
3926 (meta
->disk_index
& ~0x08);
3927 meta
->disk_id
= meta
->disks
[disk
];
3929 for (ptr
= (u_int8_t
*)meta
, count
= 0; count
< 50; count
++)
3930 meta
->checksum
+= *ptr
++;
3932 if (testing
|| bootverbose
)
3933 ata_raid_via_print_meta(meta
);
3935 if (ata_raid_rw(rdp
->disks
[disk
].dev
,
3936 VIA_LBA(rdp
->disks
[disk
].dev
),
3937 meta
, sizeof(struct via_raid_conf
),
3938 ATA_R_WRITE
| ATA_R_DIRECT
)) {
3939 device_printf(rdp
->disks
[disk
].dev
, "write metadata failed\n");
3948 static struct ata_request
*
3949 ata_raid_init_request(struct ar_softc
*rdp
, struct bio
*bio
)
3951 struct ata_request
*request
;
3953 if (!(request
= ata_alloc_request())) {
3954 kprintf("FAILURE - out of memory in ata_raid_init_request\n");
3957 request
->timeout
= 5;
3958 request
->retries
= 2;
3959 request
->callback
= ata_raid_done
;
3960 request
->driver
= rdp
;
3962 switch (request
->bio
->bio_buf
->b_cmd
) {
3964 request
->flags
= ATA_R_READ
;
3967 request
->flags
= ATA_R_WRITE
;
3970 kprintf("ar%d: FAILURE - unknown BUF operation\n", rdp
->lun
);
3971 ata_free_request(request
);
3973 bio
->bio_buf
->b_flags
|= B_ERROR
;
3974 bio
->bio_buf
->b_error
= EIO
;
3983 ata_raid_send_request(struct ata_request
*request
)
3985 struct ata_device
*atadev
= device_get_softc(request
->dev
);
3987 request
->transfersize
= min(request
->bytecount
, atadev
->max_iosize
);
3988 if (request
->flags
& ATA_R_READ
) {
3989 if (atadev
->mode
>= ATA_DMA
) {
3990 request
->flags
|= ATA_R_DMA
;
3991 request
->u
.ata
.command
= ATA_READ_DMA
;
3993 else if (atadev
->max_iosize
> DEV_BSIZE
)
3994 request
->u
.ata
.command
= ATA_READ_MUL
;
3996 request
->u
.ata
.command
= ATA_READ
;
3998 else if (request
->flags
& ATA_R_WRITE
) {
3999 if (atadev
->mode
>= ATA_DMA
) {
4000 request
->flags
|= ATA_R_DMA
;
4001 request
->u
.ata
.command
= ATA_WRITE_DMA
;
4003 else if (atadev
->max_iosize
> DEV_BSIZE
)
4004 request
->u
.ata
.command
= ATA_WRITE_MUL
;
4006 request
->u
.ata
.command
= ATA_WRITE
;
4009 device_printf(request
->dev
, "FAILURE - unknown IO operation\n");
4010 ata_free_request(request
);
4013 request
->flags
|= (ATA_R_ORDERED
| ATA_R_THREAD
);
4014 ata_queue_request(request
);
4019 ata_raid_rw(device_t dev
, u_int64_t lba
, void *data
, u_int bcount
, int flags
)
4021 struct ata_device
*atadev
= device_get_softc(dev
);
4022 struct ata_request
*request
;
4025 if (bcount
% DEV_BSIZE
) {
4026 device_printf(dev
, "FAILURE - transfers must be modulo sectorsize\n");
4030 if (!(request
= ata_alloc_request())) {
4031 device_printf(dev
, "FAILURE - out of memory in ata_raid_rw\n");
4037 request
->timeout
= 10;
4038 request
->retries
= 0;
4039 request
->data
= data
;
4040 request
->bytecount
= bcount
;
4041 request
->transfersize
= DEV_BSIZE
;
4042 request
->u
.ata
.lba
= lba
;
4043 request
->u
.ata
.count
= request
->bytecount
/ DEV_BSIZE
;
4044 request
->flags
= flags
;
4046 if (flags
& ATA_R_READ
) {
4047 if (atadev
->mode
>= ATA_DMA
) {
4048 request
->u
.ata
.command
= ATA_READ_DMA
;
4049 request
->flags
|= ATA_R_DMA
;
4052 request
->u
.ata
.command
= ATA_READ
;
4053 ata_queue_request(request
);
4055 else if (flags
& ATA_R_WRITE
) {
4056 if (atadev
->mode
>= ATA_DMA
) {
4057 request
->u
.ata
.command
= ATA_WRITE_DMA
;
4058 request
->flags
|= ATA_R_DMA
;
4061 request
->u
.ata
.command
= ATA_WRITE
;
4062 ata_queue_request(request
);
4065 device_printf(dev
, "FAILURE - unknown IO operation\n");
4066 request
->result
= EIO
;
4068 error
= request
->result
;
4069 ata_free_request(request
);
4077 ata_raid_subdisk_probe(device_t dev
)
4084 ata_raid_subdisk_attach(device_t dev
)
4086 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
4089 for (volume
= 0; volume
< MAX_VOLUMES
; volume
++) {
4090 ars
->raid
[volume
] = NULL
;
4091 ars
->disk_number
[volume
] = -1;
4093 ata_raid_read_metadata(dev
);
4098 ata_raid_subdisk_detach(device_t dev
)
4100 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
4103 for (volume
= 0; volume
< MAX_VOLUMES
; volume
++) {
4104 if (ars
->raid
[volume
]) {
4105 ars
->raid
[volume
]->disks
[ars
->disk_number
[volume
]].flags
&=
4106 ~(AR_DF_PRESENT
| AR_DF_ONLINE
);
4107 ars
->raid
[volume
]->disks
[ars
->disk_number
[volume
]].dev
= NULL
;
4108 ata_raid_config_changed(ars
->raid
[volume
], 1);
4109 ars
->raid
[volume
] = NULL
;
4110 ars
->disk_number
[volume
] = -1;
4116 static device_method_t ata_raid_sub_methods
[] = {
4117 /* device interface */
4118 DEVMETHOD(device_probe
, ata_raid_subdisk_probe
),
4119 DEVMETHOD(device_attach
, ata_raid_subdisk_attach
),
4120 DEVMETHOD(device_detach
, ata_raid_subdisk_detach
),
4124 static driver_t ata_raid_sub_driver
= {
4126 ata_raid_sub_methods
,
4127 sizeof(struct ata_raid_subdisk
)
4130 DRIVER_MODULE(subdisk
, ad
, ata_raid_sub_driver
, ata_raid_sub_devclass
, NULL
, NULL
);
4133 ata_raid_module_event_handler(module_t mod
, int what
, void *arg
)
4139 if (testing
|| bootverbose
)
4140 kprintf("ATA PseudoRAID loaded\n");
4142 /* setup table to hold metadata for all ATA PseudoRAID arrays */
4143 ata_raid_arrays
= kmalloc(sizeof(struct ar_soft
*) * MAX_ARRAYS
,
4144 M_AR
, M_WAITOK
| M_ZERO
);
4146 /* attach found PseudoRAID arrays */
4147 for (i
= 0; i
< MAX_ARRAYS
; i
++) {
4148 struct ar_softc
*rdp
= ata_raid_arrays
[i
];
4150 if (!rdp
|| !rdp
->format
)
4152 if (testing
|| bootverbose
)
4153 ata_raid_print_meta(rdp
);
4154 ata_raid_attach(rdp
, 0);
4156 ata_raid_ioctl_func
= ata_raid_ioctl
;
4160 /* detach found PseudoRAID arrays */
4161 for (i
= 0; i
< MAX_ARRAYS
; i
++) {
4162 struct ar_softc
*rdp
= ata_raid_arrays
[i
];
4164 if (!rdp
|| !rdp
->status
)
4166 disk_destroy(&rdp
->disk
);
4168 if (testing
|| bootverbose
)
4169 kprintf("ATA PseudoRAID unloaded\n");
4171 kfree(ata_raid_arrays
, M_AR
);
4173 ata_raid_ioctl_func
= NULL
;
4181 static moduledata_t ata_raid_moduledata
=
4182 { "ataraid", ata_raid_module_event_handler
, NULL
};
4183 DECLARE_MODULE(ata
, ata_raid_moduledata
, SI_SUB_RAID
, SI_ORDER_FIRST
);
4184 MODULE_VERSION(ataraid
, 1);
4185 MODULE_DEPEND(ataraid
, ata
, 1, 1, 1);
4186 MODULE_DEPEND(ataraid
, ad
, 1, 1, 1);
4189 ata_raid_format(struct ar_softc
*rdp
)
4191 switch (rdp
->format
) {
4192 case AR_F_FREEBSD_RAID
: return "FreeBSD PseudoRAID";
4193 case AR_F_ADAPTEC_RAID
: return "Adaptec HostRAID";
4194 case AR_F_HPTV2_RAID
: return "HighPoint v2 RocketRAID";
4195 case AR_F_HPTV3_RAID
: return "HighPoint v3 RocketRAID";
4196 case AR_F_INTEL_RAID
: return "Intel MatrixRAID";
4197 case AR_F_ITE_RAID
: return "Integrated Technology Express";
4198 case AR_F_JMICRON_RAID
: return "JMicron Technology Corp";
4199 case AR_F_LSIV2_RAID
: return "LSILogic v2 MegaRAID";
4200 case AR_F_LSIV3_RAID
: return "LSILogic v3 MegaRAID";
4201 case AR_F_NVIDIA_RAID
: return "nVidia MediaShield";
4202 case AR_F_PROMISE_RAID
: return "Promise Fasttrak";
4203 case AR_F_SII_RAID
: return "Silicon Image Medley";
4204 case AR_F_SIS_RAID
: return "Silicon Integrated Systems";
4205 case AR_F_VIA_RAID
: return "VIA Tech V-RAID";
4206 default: return "UNKNOWN";
4211 ata_raid_type(struct ar_softc
*rdp
)
4213 switch (rdp
->type
) {
4214 case AR_T_JBOD
: return "JBOD";
4215 case AR_T_SPAN
: return "SPAN";
4216 case AR_T_RAID0
: return "RAID0";
4217 case AR_T_RAID1
: return "RAID1";
4218 case AR_T_RAID3
: return "RAID3";
4219 case AR_T_RAID4
: return "RAID4";
4220 case AR_T_RAID5
: return "RAID5";
4221 case AR_T_RAID01
: return "RAID0+1";
4222 default: return "UNKNOWN";
4227 ata_raid_flags(struct ar_softc
*rdp
)
4229 switch (rdp
->status
& (AR_S_READY
| AR_S_DEGRADED
| AR_S_REBUILDING
)) {
4230 case AR_S_READY
: return "READY";
4231 case AR_S_READY
| AR_S_DEGRADED
: return "DEGRADED";
4232 case AR_S_READY
| AR_S_REBUILDING
:
4233 case AR_S_READY
| AR_S_DEGRADED
| AR_S_REBUILDING
: return "REBUILDING";
4234 default: return "BROKEN";
4238 /* debugging gunk */
4240 ata_raid_print_meta(struct ar_softc
*raid
)
4244 kprintf("********** ATA PseudoRAID ar%d Metadata **********\n", raid
->lun
);
4245 kprintf("=================================================\n");
4246 kprintf("format %s\n", ata_raid_format(raid
));
4247 kprintf("type %s\n", ata_raid_type(raid
));
4248 kprintf("flags 0x%02x %b\n", raid
->status
, raid
->status
,
4249 "\20\3REBUILDING\2DEGRADED\1READY\n");
4250 kprintf("magic_0 0x%016jx\n", raid
->magic_0
);
4251 kprintf("magic_1 0x%016jx\n",raid
->magic_1
);
4252 kprintf("generation %u\n", raid
->generation
);
4253 kprintf("total_sectors %ju\n", raid
->total_sectors
);
4254 kprintf("offset_sectors %ju\n", raid
->offset_sectors
);
4255 kprintf("heads %u\n", raid
->heads
);
4256 kprintf("sectors %u\n", raid
->sectors
);
4257 kprintf("cylinders %u\n", raid
->cylinders
);
4258 kprintf("width %u\n", raid
->width
);
4259 kprintf("interleave %u\n", raid
->interleave
);
4260 kprintf("total_disks %u\n", raid
->total_disks
);
4261 for (i
= 0; i
< raid
->total_disks
; i
++) {
4262 kprintf(" disk %d: flags = 0x%02x %b\n", i
, raid
->disks
[i
].flags
,
4263 raid
->disks
[i
].flags
, "\20\4ONLINE\3SPARE\2ASSIGNED\1PRESENT\n");
4264 if (raid
->disks
[i
].dev
) {
4266 device_printf(raid
->disks
[i
].dev
, " sectors %jd\n",
4267 raid
->disks
[i
].sectors
);
4270 kprintf("=================================================\n");
4274 ata_raid_adaptec_type(int type
)
4276 static char buffer
[16];
4279 case ADP_T_RAID0
: return "RAID0";
4280 case ADP_T_RAID1
: return "RAID1";
4281 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4287 ata_raid_adaptec_print_meta(struct adaptec_raid_conf
*meta
)
4291 kprintf("********* ATA Adaptec HostRAID Metadata *********\n");
4292 kprintf("magic_0 <0x%08x>\n", be32toh(meta
->magic_0
));
4293 kprintf("generation 0x%08x\n", be32toh(meta
->generation
));
4294 kprintf("dummy_0 0x%04x\n", be16toh(meta
->dummy_0
));
4295 kprintf("total_configs %u\n", be16toh(meta
->total_configs
));
4296 kprintf("dummy_1 0x%04x\n", be16toh(meta
->dummy_1
));
4297 kprintf("checksum 0x%04x\n", be16toh(meta
->checksum
));
4298 kprintf("dummy_2 0x%08x\n", be32toh(meta
->dummy_2
));
4299 kprintf("dummy_3 0x%08x\n", be32toh(meta
->dummy_3
));
4300 kprintf("flags 0x%08x\n", be32toh(meta
->flags
));
4301 kprintf("timestamp 0x%08x\n", be32toh(meta
->timestamp
));
4302 kprintf("dummy_4 0x%08x 0x%08x 0x%08x 0x%08x\n",
4303 be32toh(meta
->dummy_4
[0]), be32toh(meta
->dummy_4
[1]),
4304 be32toh(meta
->dummy_4
[2]), be32toh(meta
->dummy_4
[3]));
4305 kprintf("dummy_5 0x%08x 0x%08x 0x%08x 0x%08x\n",
4306 be32toh(meta
->dummy_5
[0]), be32toh(meta
->dummy_5
[1]),
4307 be32toh(meta
->dummy_5
[2]), be32toh(meta
->dummy_5
[3]));
4309 for (i
= 0; i
< be16toh(meta
->total_configs
); i
++) {
4310 kprintf(" %d total_disks %u\n", i
,
4311 be16toh(meta
->configs
[i
].disk_number
));
4312 kprintf(" %d generation %u\n", i
,
4313 be16toh(meta
->configs
[i
].generation
));
4314 kprintf(" %d magic_0 0x%08x\n", i
,
4315 be32toh(meta
->configs
[i
].magic_0
));
4316 kprintf(" %d dummy_0 0x%02x\n", i
, meta
->configs
[i
].dummy_0
);
4317 kprintf(" %d type %s\n", i
,
4318 ata_raid_adaptec_type(meta
->configs
[i
].type
));
4319 kprintf(" %d dummy_1 0x%02x\n", i
, meta
->configs
[i
].dummy_1
);
4320 kprintf(" %d flags %d\n", i
,
4321 be32toh(meta
->configs
[i
].flags
));
4322 kprintf(" %d dummy_2 0x%02x\n", i
, meta
->configs
[i
].dummy_2
);
4323 kprintf(" %d dummy_3 0x%02x\n", i
, meta
->configs
[i
].dummy_3
);
4324 kprintf(" %d dummy_4 0x%02x\n", i
, meta
->configs
[i
].dummy_4
);
4325 kprintf(" %d dummy_5 0x%02x\n", i
, meta
->configs
[i
].dummy_5
);
4326 kprintf(" %d disk_number %u\n", i
,
4327 be32toh(meta
->configs
[i
].disk_number
));
4328 kprintf(" %d dummy_6 0x%08x\n", i
,
4329 be32toh(meta
->configs
[i
].dummy_6
));
4330 kprintf(" %d sectors %u\n", i
,
4331 be32toh(meta
->configs
[i
].sectors
));
4332 kprintf(" %d stripe_shift %u\n", i
,
4333 be16toh(meta
->configs
[i
].stripe_shift
));
4334 kprintf(" %d dummy_7 0x%08x\n", i
,
4335 be32toh(meta
->configs
[i
].dummy_7
));
4336 kprintf(" %d dummy_8 0x%08x 0x%08x 0x%08x 0x%08x\n", i
,
4337 be32toh(meta
->configs
[i
].dummy_8
[0]),
4338 be32toh(meta
->configs
[i
].dummy_8
[1]),
4339 be32toh(meta
->configs
[i
].dummy_8
[2]),
4340 be32toh(meta
->configs
[i
].dummy_8
[3]));
4341 kprintf(" %d name <%s>\n", i
, meta
->configs
[i
].name
);
4343 kprintf("magic_1 <0x%08x>\n", be32toh(meta
->magic_1
));
4344 kprintf("magic_2 <0x%08x>\n", be32toh(meta
->magic_2
));
4345 kprintf("magic_3 <0x%08x>\n", be32toh(meta
->magic_3
));
4346 kprintf("magic_4 <0x%08x>\n", be32toh(meta
->magic_4
));
4347 kprintf("=================================================\n");
4351 ata_raid_hptv2_type(int type
)
4353 static char buffer
[16];
4356 case HPTV2_T_RAID0
: return "RAID0";
4357 case HPTV2_T_RAID1
: return "RAID1";
4358 case HPTV2_T_RAID01_RAID0
: return "RAID01_RAID0";
4359 case HPTV2_T_SPAN
: return "SPAN";
4360 case HPTV2_T_RAID_3
: return "RAID3";
4361 case HPTV2_T_RAID_5
: return "RAID5";
4362 case HPTV2_T_JBOD
: return "JBOD";
4363 case HPTV2_T_RAID01_RAID1
: return "RAID01_RAID1";
4364 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4370 ata_raid_hptv2_print_meta(struct hptv2_raid_conf
*meta
)
4374 kprintf("****** ATA Highpoint V2 RocketRAID Metadata *****\n");
4375 kprintf("magic 0x%08x\n", meta
->magic
);
4376 kprintf("magic_0 0x%08x\n", meta
->magic_0
);
4377 kprintf("magic_1 0x%08x\n", meta
->magic_1
);
4378 kprintf("order 0x%08x\n", meta
->order
);
4379 kprintf("array_width %u\n", meta
->array_width
);
4380 kprintf("stripe_shift %u\n", meta
->stripe_shift
);
4381 kprintf("type %s\n", ata_raid_hptv2_type(meta
->type
));
4382 kprintf("disk_number %u\n", meta
->disk_number
);
4383 kprintf("total_sectors %u\n", meta
->total_sectors
);
4384 kprintf("disk_mode 0x%08x\n", meta
->disk_mode
);
4385 kprintf("boot_mode 0x%08x\n", meta
->boot_mode
);
4386 kprintf("boot_disk 0x%02x\n", meta
->boot_disk
);
4387 kprintf("boot_protect 0x%02x\n", meta
->boot_protect
);
4388 kprintf("log_entries 0x%02x\n", meta
->error_log_entries
);
4389 kprintf("log_index 0x%02x\n", meta
->error_log_index
);
4390 if (meta
->error_log_entries
) {
4391 kprintf(" timestamp reason disk status sectors lba\n");
4392 for (i
= meta
->error_log_index
;
4393 i
< meta
->error_log_index
+ meta
->error_log_entries
; i
++)
4394 kprintf(" 0x%08x 0x%02x 0x%02x 0x%02x 0x%02x 0x%08x\n",
4395 meta
->errorlog
[i
%32].timestamp
,
4396 meta
->errorlog
[i
%32].reason
,
4397 meta
->errorlog
[i
%32].disk
, meta
->errorlog
[i
%32].status
,
4398 meta
->errorlog
[i
%32].sectors
, meta
->errorlog
[i
%32].lba
);
4400 kprintf("rebuild_lba 0x%08x\n", meta
->rebuild_lba
);
4401 kprintf("dummy_1 0x%02x\n", meta
->dummy_1
);
4402 kprintf("name_1 <%.15s>\n", meta
->name_1
);
4403 kprintf("dummy_2 0x%02x\n", meta
->dummy_2
);
4404 kprintf("name_2 <%.15s>\n", meta
->name_2
);
4405 kprintf("=================================================\n");
4409 ata_raid_hptv3_type(int type
)
4411 static char buffer
[16];
4414 case HPTV3_T_SPARE
: return "SPARE";
4415 case HPTV3_T_JBOD
: return "JBOD";
4416 case HPTV3_T_SPAN
: return "SPAN";
4417 case HPTV3_T_RAID0
: return "RAID0";
4418 case HPTV3_T_RAID1
: return "RAID1";
4419 case HPTV3_T_RAID3
: return "RAID3";
4420 case HPTV3_T_RAID5
: return "RAID5";
4421 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4427 ata_raid_hptv3_print_meta(struct hptv3_raid_conf
*meta
)
4431 kprintf("****** ATA Highpoint V3 RocketRAID Metadata *****\n");
4432 kprintf("magic 0x%08x\n", meta
->magic
);
4433 kprintf("magic_0 0x%08x\n", meta
->magic_0
);
4434 kprintf("checksum_0 0x%02x\n", meta
->checksum_0
);
4435 kprintf("mode 0x%02x\n", meta
->mode
);
4436 kprintf("user_mode 0x%02x\n", meta
->user_mode
);
4437 kprintf("config_entries 0x%02x\n", meta
->config_entries
);
4438 for (i
= 0; i
< meta
->config_entries
; i
++) {
4439 kprintf("config %d:\n", i
);
4440 kprintf(" total_sectors %ju\n",
4441 meta
->configs
[0].total_sectors
+
4442 ((u_int64_t
)meta
->configs_high
[0].total_sectors
<< 32));
4443 kprintf(" type %s\n",
4444 ata_raid_hptv3_type(meta
->configs
[i
].type
));
4445 kprintf(" total_disks %u\n", meta
->configs
[i
].total_disks
);
4446 kprintf(" disk_number %u\n", meta
->configs
[i
].disk_number
);
4447 kprintf(" stripe_shift %u\n", meta
->configs
[i
].stripe_shift
);
4448 kprintf(" status %b\n", meta
->configs
[i
].status
,
4449 "\20\2RAID5\1NEED_REBUILD\n");
4450 kprintf(" critical_disks %u\n", meta
->configs
[i
].critical_disks
);
4451 kprintf(" rebuild_lba %ju\n",
4452 meta
->configs_high
[0].rebuild_lba
+
4453 ((u_int64_t
)meta
->configs_high
[0].rebuild_lba
<< 32));
4455 kprintf("name <%.16s>\n", meta
->name
);
4456 kprintf("timestamp 0x%08x\n", meta
->timestamp
);
4457 kprintf("description <%.16s>\n", meta
->description
);
4458 kprintf("creator <%.16s>\n", meta
->creator
);
4459 kprintf("checksum_1 0x%02x\n", meta
->checksum_1
);
4460 kprintf("dummy_0 0x%02x\n", meta
->dummy_0
);
4461 kprintf("dummy_1 0x%02x\n", meta
->dummy_1
);
4462 kprintf("flags %b\n", meta
->flags
,
4463 "\20\4RCACHE\3WCACHE\2NCQ\1TCQ\n");
4464 kprintf("=================================================\n");
4468 ata_raid_intel_type(int type
)
4470 static char buffer
[16];
4473 case INTEL_T_RAID0
: return "RAID0";
4474 case INTEL_T_RAID1
: return "RAID1";
4475 case INTEL_T_RAID5
: return "RAID5";
4476 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4482 ata_raid_intel_print_meta(struct intel_raid_conf
*meta
)
4484 struct intel_raid_mapping
*map
;
4487 kprintf("********* ATA Intel MatrixRAID Metadata *********\n");
4488 kprintf("intel_id <%.24s>\n", meta
->intel_id
);
4489 kprintf("version <%.6s>\n", meta
->version
);
4490 kprintf("checksum 0x%08x\n", meta
->checksum
);
4491 kprintf("config_size 0x%08x\n", meta
->config_size
);
4492 kprintf("config_id 0x%08x\n", meta
->config_id
);
4493 kprintf("generation 0x%08x\n", meta
->generation
);
4494 kprintf("total_disks %u\n", meta
->total_disks
);
4495 kprintf("total_volumes %u\n", meta
->total_volumes
);
4496 kprintf("DISK# serial disk_sectors disk_id flags\n");
4497 for (i
= 0; i
< meta
->total_disks
; i
++ ) {
4498 kprintf(" %d <%.16s> %u 0x%08x 0x%08x\n", i
,
4499 meta
->disk
[i
].serial
, meta
->disk
[i
].sectors
,
4500 meta
->disk
[i
].id
, meta
->disk
[i
].flags
);
4502 map
= (struct intel_raid_mapping
*)&meta
->disk
[meta
->total_disks
];
4503 for (j
= 0; j
< meta
->total_volumes
; j
++) {
4504 kprintf("name %.16s\n", map
->name
);
4505 kprintf("total_sectors %ju\n", map
->total_sectors
);
4506 kprintf("state %u\n", map
->state
);
4507 kprintf("reserved %u\n", map
->reserved
);
4508 kprintf("offset %u\n", map
->offset
);
4509 kprintf("disk_sectors %u\n", map
->disk_sectors
);
4510 kprintf("stripe_count %u\n", map
->stripe_count
);
4511 kprintf("stripe_sectors %u\n", map
->stripe_sectors
);
4512 kprintf("status %u\n", map
->status
);
4513 kprintf("type %s\n", ata_raid_intel_type(map
->type
));
4514 kprintf("total_disks %u\n", map
->total_disks
);
4515 kprintf("magic[0] 0x%02x\n", map
->magic
[0]);
4516 kprintf("magic[1] 0x%02x\n", map
->magic
[1]);
4517 kprintf("magic[2] 0x%02x\n", map
->magic
[2]);
4518 for (i
= 0; i
< map
->total_disks
; i
++ ) {
4519 kprintf(" disk %d at disk_idx 0x%08x\n", i
, map
->disk_idx
[i
]);
4521 map
= (struct intel_raid_mapping
*)&map
->disk_idx
[map
->total_disks
];
4523 kprintf("=================================================\n");
4527 ata_raid_ite_type(int type
)
4529 static char buffer
[16];
4532 case ITE_T_RAID0
: return "RAID0";
4533 case ITE_T_RAID1
: return "RAID1";
4534 case ITE_T_RAID01
: return "RAID0+1";
4535 case ITE_T_SPAN
: return "SPAN";
4536 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4542 ata_raid_ite_print_meta(struct ite_raid_conf
*meta
)
4544 kprintf("*** ATA Integrated Technology Express Metadata **\n");
4545 kprintf("ite_id <%.40s>\n", meta
->ite_id
);
4546 kprintf("timestamp_0 %04x/%02x/%02x %02x:%02x:%02x.%02x\n",
4547 *((u_int16_t
*)meta
->timestamp_0
), meta
->timestamp_0
[2],
4548 meta
->timestamp_0
[3], meta
->timestamp_0
[5], meta
->timestamp_0
[4],
4549 meta
->timestamp_0
[7], meta
->timestamp_0
[6]);
4550 kprintf("total_sectors %jd\n", meta
->total_sectors
);
4551 kprintf("type %s\n", ata_raid_ite_type(meta
->type
));
4552 kprintf("stripe_1kblocks %u\n", meta
->stripe_1kblocks
);
4553 kprintf("timestamp_1 %04x/%02x/%02x %02x:%02x:%02x.%02x\n",
4554 *((u_int16_t
*)meta
->timestamp_1
), meta
->timestamp_1
[2],
4555 meta
->timestamp_1
[3], meta
->timestamp_1
[5], meta
->timestamp_1
[4],
4556 meta
->timestamp_1
[7], meta
->timestamp_1
[6]);
4557 kprintf("stripe_sectors %u\n", meta
->stripe_sectors
);
4558 kprintf("array_width %u\n", meta
->array_width
);
4559 kprintf("disk_number %u\n", meta
->disk_number
);
4560 kprintf("disk_sectors %u\n", meta
->disk_sectors
);
4561 kprintf("=================================================\n");
4565 ata_raid_jmicron_type(int type
)
4567 static char buffer
[16];
4570 case JM_T_RAID0
: return "RAID0";
4571 case JM_T_RAID1
: return "RAID1";
4572 case JM_T_RAID01
: return "RAID0+1";
4573 case JM_T_JBOD
: return "JBOD";
4574 case JM_T_RAID5
: return "RAID5";
4575 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4581 ata_raid_jmicron_print_meta(struct jmicron_raid_conf
*meta
)
4585 kprintf("***** ATA JMicron Technology Corp Metadata ******\n");
4586 kprintf("signature %.2s\n", meta
->signature
);
4587 kprintf("version 0x%04x\n", meta
->version
);
4588 kprintf("checksum 0x%04x\n", meta
->checksum
);
4589 kprintf("disk_id 0x%08x\n", meta
->disk_id
);
4590 kprintf("offset 0x%08x\n", meta
->offset
);
4591 kprintf("disk_sectors_low 0x%08x\n", meta
->disk_sectors_low
);
4592 kprintf("disk_sectors_high 0x%08x\n", meta
->disk_sectors_high
);
4593 kprintf("name %.16s\n", meta
->name
);
4594 kprintf("type %s\n", ata_raid_jmicron_type(meta
->type
));
4595 kprintf("stripe_shift %d\n", meta
->stripe_shift
);
4596 kprintf("flags 0x%04x\n", meta
->flags
);
4597 kprintf("spare:\n");
4598 for (i
=0; i
< 2 && meta
->spare
[i
]; i
++)
4599 kprintf(" %d 0x%08x\n", i
, meta
->spare
[i
]);
4600 kprintf("disks:\n");
4601 for (i
=0; i
< 8 && meta
->disks
[i
]; i
++)
4602 kprintf(" %d 0x%08x\n", i
, meta
->disks
[i
]);
4603 kprintf("=================================================\n");
4607 ata_raid_lsiv2_type(int type
)
4609 static char buffer
[16];
4612 case LSIV2_T_RAID0
: return "RAID0";
4613 case LSIV2_T_RAID1
: return "RAID1";
4614 case LSIV2_T_SPARE
: return "SPARE";
4615 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4621 ata_raid_lsiv2_print_meta(struct lsiv2_raid_conf
*meta
)
4625 kprintf("******* ATA LSILogic V2 MegaRAID Metadata *******\n");
4626 kprintf("lsi_id <%s>\n", meta
->lsi_id
);
4627 kprintf("dummy_0 0x%02x\n", meta
->dummy_0
);
4628 kprintf("flags 0x%02x\n", meta
->flags
);
4629 kprintf("version 0x%04x\n", meta
->version
);
4630 kprintf("config_entries 0x%02x\n", meta
->config_entries
);
4631 kprintf("raid_count 0x%02x\n", meta
->raid_count
);
4632 kprintf("total_disks 0x%02x\n", meta
->total_disks
);
4633 kprintf("dummy_1 0x%02x\n", meta
->dummy_1
);
4634 kprintf("dummy_2 0x%04x\n", meta
->dummy_2
);
4635 for (i
= 0; i
< meta
->config_entries
; i
++) {
4636 kprintf(" type %s\n",
4637 ata_raid_lsiv2_type(meta
->configs
[i
].raid
.type
));
4638 kprintf(" dummy_0 %02x\n", meta
->configs
[i
].raid
.dummy_0
);
4639 kprintf(" stripe_sectors %u\n",
4640 meta
->configs
[i
].raid
.stripe_sectors
);
4641 kprintf(" array_width %u\n",
4642 meta
->configs
[i
].raid
.array_width
);
4643 kprintf(" disk_count %u\n", meta
->configs
[i
].raid
.disk_count
);
4644 kprintf(" config_offset %u\n",
4645 meta
->configs
[i
].raid
.config_offset
);
4646 kprintf(" dummy_1 %u\n", meta
->configs
[i
].raid
.dummy_1
);
4647 kprintf(" flags %02x\n", meta
->configs
[i
].raid
.flags
);
4648 kprintf(" total_sectors %u\n",
4649 meta
->configs
[i
].raid
.total_sectors
);
4651 kprintf("disk_number 0x%02x\n", meta
->disk_number
);
4652 kprintf("raid_number 0x%02x\n", meta
->raid_number
);
4653 kprintf("timestamp 0x%08x\n", meta
->timestamp
);
4654 kprintf("=================================================\n");
4658 ata_raid_lsiv3_type(int type
)
4660 static char buffer
[16];
4663 case LSIV3_T_RAID0
: return "RAID0";
4664 case LSIV3_T_RAID1
: return "RAID1";
4665 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4671 ata_raid_lsiv3_print_meta(struct lsiv3_raid_conf
*meta
)
4675 kprintf("******* ATA LSILogic V3 MegaRAID Metadata *******\n");
4676 kprintf("lsi_id <%.6s>\n", meta
->lsi_id
);
4677 kprintf("dummy_0 0x%04x\n", meta
->dummy_0
);
4678 kprintf("version 0x%04x\n", meta
->version
);
4679 kprintf("dummy_0 0x%04x\n", meta
->dummy_1
);
4680 kprintf("RAID configs:\n");
4681 for (i
= 0; i
< 8; i
++) {
4682 if (meta
->raid
[i
].total_disks
) {
4683 kprintf("%02d stripe_pages %u\n", i
,
4684 meta
->raid
[i
].stripe_pages
);
4685 kprintf("%02d type %s\n", i
,
4686 ata_raid_lsiv3_type(meta
->raid
[i
].type
));
4687 kprintf("%02d total_disks %u\n", i
,
4688 meta
->raid
[i
].total_disks
);
4689 kprintf("%02d array_width %u\n", i
,
4690 meta
->raid
[i
].array_width
);
4691 kprintf("%02d sectors %u\n", i
, meta
->raid
[i
].sectors
);
4692 kprintf("%02d offset %u\n", i
, meta
->raid
[i
].offset
);
4693 kprintf("%02d device 0x%02x\n", i
,
4694 meta
->raid
[i
].device
);
4697 kprintf("DISK configs:\n");
4698 for (i
= 0; i
< 6; i
++) {
4699 if (meta
->disk
[i
].disk_sectors
) {
4700 kprintf("%02d disk_sectors %u\n", i
,
4701 meta
->disk
[i
].disk_sectors
);
4702 kprintf("%02d flags 0x%02x\n", i
, meta
->disk
[i
].flags
);
4705 kprintf("device 0x%02x\n", meta
->device
);
4706 kprintf("timestamp 0x%08x\n", meta
->timestamp
);
4707 kprintf("checksum_1 0x%02x\n", meta
->checksum_1
);
4708 kprintf("=================================================\n");
4712 ata_raid_nvidia_type(int type
)
4714 static char buffer
[16];
4717 case NV_T_SPAN
: return "SPAN";
4718 case NV_T_RAID0
: return "RAID0";
4719 case NV_T_RAID1
: return "RAID1";
4720 case NV_T_RAID3
: return "RAID3";
4721 case NV_T_RAID5
: return "RAID5";
4722 case NV_T_RAID01
: return "RAID0+1";
4723 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4729 ata_raid_nvidia_print_meta(struct nvidia_raid_conf
*meta
)
4731 kprintf("******** ATA nVidia MediaShield Metadata ********\n");
4732 kprintf("nvidia_id <%.8s>\n", meta
->nvidia_id
);
4733 kprintf("config_size %d\n", meta
->config_size
);
4734 kprintf("checksum 0x%08x\n", meta
->checksum
);
4735 kprintf("version 0x%04x\n", meta
->version
);
4736 kprintf("disk_number %d\n", meta
->disk_number
);
4737 kprintf("dummy_0 0x%02x\n", meta
->dummy_0
);
4738 kprintf("total_sectors %d\n", meta
->total_sectors
);
4739 kprintf("sectors_size %d\n", meta
->sector_size
);
4740 kprintf("serial %.16s\n", meta
->serial
);
4741 kprintf("revision %.4s\n", meta
->revision
);
4742 kprintf("dummy_1 0x%08x\n", meta
->dummy_1
);
4743 kprintf("magic_0 0x%08x\n", meta
->magic_0
);
4744 kprintf("magic_1 0x%016jx\n", meta
->magic_1
);
4745 kprintf("magic_2 0x%016jx\n", meta
->magic_2
);
4746 kprintf("flags 0x%02x\n", meta
->flags
);
4747 kprintf("array_width %d\n", meta
->array_width
);
4748 kprintf("total_disks %d\n", meta
->total_disks
);
4749 kprintf("dummy_2 0x%02x\n", meta
->dummy_2
);
4750 kprintf("type %s\n", ata_raid_nvidia_type(meta
->type
));
4751 kprintf("dummy_3 0x%04x\n", meta
->dummy_3
);
4752 kprintf("stripe_sectors %d\n", meta
->stripe_sectors
);
4753 kprintf("stripe_bytes %d\n", meta
->stripe_bytes
);
4754 kprintf("stripe_shift %d\n", meta
->stripe_shift
);
4755 kprintf("stripe_mask 0x%08x\n", meta
->stripe_mask
);
4756 kprintf("stripe_sizesectors %d\n", meta
->stripe_sizesectors
);
4757 kprintf("stripe_sizebytes %d\n", meta
->stripe_sizebytes
);
4758 kprintf("rebuild_lba %d\n", meta
->rebuild_lba
);
4759 kprintf("dummy_4 0x%08x\n", meta
->dummy_4
);
4760 kprintf("dummy_5 0x%08x\n", meta
->dummy_5
);
4761 kprintf("status 0x%08x\n", meta
->status
);
4762 kprintf("=================================================\n");
4766 ata_raid_promise_type(int type
)
4768 static char buffer
[16];
4771 case PR_T_RAID0
: return "RAID0";
4772 case PR_T_RAID1
: return "RAID1";
4773 case PR_T_RAID3
: return "RAID3";
4774 case PR_T_RAID5
: return "RAID5";
4775 case PR_T_SPAN
: return "SPAN";
4776 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4782 ata_raid_promise_print_meta(struct promise_raid_conf
*meta
)
4786 kprintf("********* ATA Promise FastTrak Metadata *********\n");
4787 kprintf("promise_id <%s>\n", meta
->promise_id
);
4788 kprintf("dummy_0 0x%08x\n", meta
->dummy_0
);
4789 kprintf("magic_0 0x%016jx\n", meta
->magic_0
);
4790 kprintf("magic_1 0x%04x\n", meta
->magic_1
);
4791 kprintf("magic_2 0x%08x\n", meta
->magic_2
);
4792 kprintf("integrity 0x%08x %b\n", meta
->raid
.integrity
,
4793 meta
->raid
.integrity
, "\20\10VALID\n" );
4794 kprintf("flags 0x%02x %b\n",
4795 meta
->raid
.flags
, meta
->raid
.flags
,
4796 "\20\10READY\7DOWN\6REDIR\5DUPLICATE\4SPARE"
4797 "\3ASSIGNED\2ONLINE\1VALID\n");
4798 kprintf("disk_number %d\n", meta
->raid
.disk_number
);
4799 kprintf("channel 0x%02x\n", meta
->raid
.channel
);
4800 kprintf("device 0x%02x\n", meta
->raid
.device
);
4801 kprintf("magic_0 0x%016jx\n", meta
->raid
.magic_0
);
4802 kprintf("disk_offset %u\n", meta
->raid
.disk_offset
);
4803 kprintf("disk_sectors %u\n", meta
->raid
.disk_sectors
);
4804 kprintf("rebuild_lba 0x%08x\n", meta
->raid
.rebuild_lba
);
4805 kprintf("generation 0x%04x\n", meta
->raid
.generation
);
4806 kprintf("status 0x%02x %b\n",
4807 meta
->raid
.status
, meta
->raid
.status
,
4808 "\20\6MARKED\5DEGRADED\4READY\3INITED\2ONLINE\1VALID\n");
4809 kprintf("type %s\n", ata_raid_promise_type(meta
->raid
.type
));
4810 kprintf("total_disks %u\n", meta
->raid
.total_disks
);
4811 kprintf("stripe_shift %u\n", meta
->raid
.stripe_shift
);
4812 kprintf("array_width %u\n", meta
->raid
.array_width
);
4813 kprintf("array_number %u\n", meta
->raid
.array_number
);
4814 kprintf("total_sectors %u\n", meta
->raid
.total_sectors
);
4815 kprintf("cylinders %u\n", meta
->raid
.cylinders
);
4816 kprintf("heads %u\n", meta
->raid
.heads
);
4817 kprintf("sectors %u\n", meta
->raid
.sectors
);
4818 kprintf("magic_1 0x%016jx\n", meta
->raid
.magic_1
);
4819 kprintf("DISK# flags dummy_0 channel device magic_0\n");
4820 for (i
= 0; i
< 8; i
++) {
4821 kprintf(" %d %b 0x%02x 0x%02x 0x%02x ",
4822 i
, meta
->raid
.disk
[i
].flags
,
4823 "\20\10READY\7DOWN\6REDIR\5DUPLICATE\4SPARE"
4824 "\3ASSIGNED\2ONLINE\1VALID\n", meta
->raid
.disk
[i
].dummy_0
,
4825 meta
->raid
.disk
[i
].channel
, meta
->raid
.disk
[i
].device
);
4826 kprintf("0x%016jx\n", meta
->raid
.disk
[i
].magic_0
);
4828 kprintf("checksum 0x%08x\n", meta
->checksum
);
4829 kprintf("=================================================\n");
4833 ata_raid_sii_type(int type
)
4835 static char buffer
[16];
4838 case SII_T_RAID0
: return "RAID0";
4839 case SII_T_RAID1
: return "RAID1";
4840 case SII_T_RAID01
: return "RAID0+1";
4841 case SII_T_SPARE
: return "SPARE";
4842 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4848 ata_raid_sii_print_meta(struct sii_raid_conf
*meta
)
4850 kprintf("******* ATA Silicon Image Medley Metadata *******\n");
4851 kprintf("total_sectors %ju\n", meta
->total_sectors
);
4852 kprintf("dummy_0 0x%04x\n", meta
->dummy_0
);
4853 kprintf("dummy_1 0x%04x\n", meta
->dummy_1
);
4854 kprintf("controller_pci_id 0x%08x\n", meta
->controller_pci_id
);
4855 kprintf("version_minor 0x%04x\n", meta
->version_minor
);
4856 kprintf("version_major 0x%04x\n", meta
->version_major
);
4857 kprintf("timestamp 20%02x/%02x/%02x %02x:%02x:%02x\n",
4858 meta
->timestamp
[5], meta
->timestamp
[4], meta
->timestamp
[3],
4859 meta
->timestamp
[2], meta
->timestamp
[1], meta
->timestamp
[0]);
4860 kprintf("stripe_sectors %u\n", meta
->stripe_sectors
);
4861 kprintf("dummy_2 0x%04x\n", meta
->dummy_2
);
4862 kprintf("disk_number %u\n", meta
->disk_number
);
4863 kprintf("type %s\n", ata_raid_sii_type(meta
->type
));
4864 kprintf("raid0_disks %u\n", meta
->raid0_disks
);
4865 kprintf("raid0_ident %u\n", meta
->raid0_ident
);
4866 kprintf("raid1_disks %u\n", meta
->raid1_disks
);
4867 kprintf("raid1_ident %u\n", meta
->raid1_ident
);
4868 kprintf("rebuild_lba %ju\n", meta
->rebuild_lba
);
4869 kprintf("generation 0x%08x\n", meta
->generation
);
4870 kprintf("status 0x%02x %b\n",
4871 meta
->status
, meta
->status
,
4873 kprintf("base_raid1_position %02x\n", meta
->base_raid1_position
);
4874 kprintf("base_raid0_position %02x\n", meta
->base_raid0_position
);
4875 kprintf("position %02x\n", meta
->position
);
4876 kprintf("dummy_3 %04x\n", meta
->dummy_3
);
4877 kprintf("name <%.16s>\n", meta
->name
);
4878 kprintf("checksum_0 0x%04x\n", meta
->checksum_0
);
4879 kprintf("checksum_1 0x%04x\n", meta
->checksum_1
);
4880 kprintf("=================================================\n");
4884 ata_raid_sis_type(int type
)
4886 static char buffer
[16];
4889 case SIS_T_JBOD
: return "JBOD";
4890 case SIS_T_RAID0
: return "RAID0";
4891 case SIS_T_RAID1
: return "RAID1";
4892 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4898 ata_raid_sis_print_meta(struct sis_raid_conf
*meta
)
4900 kprintf("**** ATA Silicon Integrated Systems Metadata ****\n");
4901 kprintf("magic 0x%04x\n", meta
->magic
);
4902 kprintf("disks 0x%02x\n", meta
->disks
);
4903 kprintf("type %s\n",
4904 ata_raid_sis_type(meta
->type_total_disks
& SIS_T_MASK
));
4905 kprintf("total_disks %u\n", meta
->type_total_disks
& SIS_D_MASK
);
4906 kprintf("dummy_0 0x%08x\n", meta
->dummy_0
);
4907 kprintf("controller_pci_id 0x%08x\n", meta
->controller_pci_id
);
4908 kprintf("stripe_sectors %u\n", meta
->stripe_sectors
);
4909 kprintf("dummy_1 0x%04x\n", meta
->dummy_1
);
4910 kprintf("timestamp 0x%08x\n", meta
->timestamp
);
4911 kprintf("model %.40s\n", meta
->model
);
4912 kprintf("disk_number %u\n", meta
->disk_number
);
4913 kprintf("dummy_2 0x%02x 0x%02x 0x%02x\n",
4914 meta
->dummy_2
[0], meta
->dummy_2
[1], meta
->dummy_2
[2]);
4915 kprintf("=================================================\n");
4919 ata_raid_via_type(int type
)
4921 static char buffer
[16];
4924 case VIA_T_RAID0
: return "RAID0";
4925 case VIA_T_RAID1
: return "RAID1";
4926 case VIA_T_RAID5
: return "RAID5";
4927 case VIA_T_RAID01
: return "RAID0+1";
4928 case VIA_T_SPAN
: return "SPAN";
4929 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4935 ata_raid_via_print_meta(struct via_raid_conf
*meta
)
4939 kprintf("*************** ATA VIA Metadata ****************\n");
4940 kprintf("magic 0x%02x\n", meta
->magic
);
4941 kprintf("dummy_0 0x%02x\n", meta
->dummy_0
);
4942 kprintf("type %s\n",
4943 ata_raid_via_type(meta
->type
& VIA_T_MASK
));
4944 kprintf("bootable %d\n", meta
->type
& VIA_T_BOOTABLE
);
4945 kprintf("unknown %d\n", meta
->type
& VIA_T_UNKNOWN
);
4946 kprintf("disk_index 0x%02x\n", meta
->disk_index
);
4947 kprintf("stripe_layout 0x%02x\n", meta
->stripe_layout
);
4948 kprintf(" stripe_disks %d\n", meta
->stripe_layout
& VIA_L_DISKS
);
4949 kprintf(" stripe_sectors %d\n",
4950 0x08 << ((meta
->stripe_layout
& VIA_L_MASK
) >> VIA_L_SHIFT
));
4951 kprintf("disk_sectors %ju\n", meta
->disk_sectors
);
4952 kprintf("disk_id 0x%08x\n", meta
->disk_id
);
4953 kprintf("DISK# disk_id\n");
4954 for (i
= 0; i
< 8; i
++) {
4956 kprintf(" %d 0x%08x\n", i
, meta
->disks
[i
]);
4958 kprintf("checksum 0x%02x\n", meta
->checksum
);
4959 kprintf("=================================================\n");