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.10.2.1 2008/09/25 01:44:55 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 ata_raid_flush(struct ar_softc
*rdp
, struct bio
*bp
)
259 struct ata_request
*request
;
264 bp
->bio_driver_info
= (void *)0;
266 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
267 if ((dev
= rdp
->disks
[disk
].dev
) != NULL
)
268 bp
->bio_driver_info
= (void *)((intptr_t)bp
->bio_driver_info
+ 1);
270 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
271 if ((dev
= rdp
->disks
[disk
].dev
) == NULL
)
273 if (!(request
= ata_raid_init_request(rdp
, bp
)))
276 request
->u
.ata
.command
= ATA_FLUSHCACHE
;
277 request
->u
.ata
.lba
= 0;
278 request
->u
.ata
.count
= 0;
279 request
->u
.ata
.feature
= 0;
280 request
->timeout
= 1;
281 request
->retries
= 0;
282 request
->flags
|= ATA_R_ORDERED
| ATA_R_DIRECT
;
283 ata_queue_request(request
);
289 * XXX TGEN there are a lot of offset -> block number conversions going on
290 * here, which is suboptimal.
293 ata_raid_strategy(struct dev_strategy_args
*ap
)
295 struct ar_softc
*rdp
= ap
->a_head
.a_dev
->si_drv1
;
296 struct bio
*bp
= ap
->a_bio
;
297 struct buf
*bbp
= bp
->bio_buf
;
298 struct ata_request
*request
;
300 u_int64_t blkno
, lba
, blk
= 0;
301 int count
, chunk
, drv
, par
= 0, change
= 0;
303 if (bbp
->b_cmd
== BUF_CMD_FLUSH
) {
306 error
= ata_raid_flush(rdp
, bp
);
308 bbp
->b_flags
|= B_ERROR
;
309 bbp
->b_error
= error
;
315 if (!(rdp
->status
& AR_S_READY
) ||
316 (bbp
->b_cmd
!= BUF_CMD_READ
&& bbp
->b_cmd
!= BUF_CMD_WRITE
)) {
317 bbp
->b_flags
|= B_ERROR
;
323 bbp
->b_resid
= bbp
->b_bcount
;
324 for (count
= howmany(bbp
->b_bcount
, DEV_BSIZE
),
325 /* bio_offset is byte granularity, convert */
326 blkno
= (u_int64_t
)(bp
->bio_offset
>> DEV_BSHIFT
),
329 count
-= chunk
, blkno
+= chunk
, data
+= (chunk
* DEV_BSIZE
)) {
342 while (lba
>= rdp
->disks
[drv
].sectors
)
343 lba
-= rdp
->disks
[drv
++].sectors
;
344 chunk
= min(rdp
->disks
[drv
].sectors
- lba
, count
);
349 chunk
= blkno
% rdp
->interleave
;
350 drv
= (blkno
/ rdp
->interleave
) % rdp
->width
;
351 lba
= (((blkno
/rdp
->interleave
)/rdp
->width
)*rdp
->interleave
)+chunk
;
352 chunk
= min(count
, rdp
->interleave
- chunk
);
356 drv
= (blkno
/ rdp
->interleave
) % (rdp
->width
- 1);
357 par
= rdp
->width
- 1 -
358 (blkno
/ (rdp
->interleave
* (rdp
->width
- 1))) % rdp
->width
;
361 lba
= ((blkno
/rdp
->interleave
)/(rdp
->width
-1))*(rdp
->interleave
) +
362 ((blkno
%(rdp
->interleave
*(rdp
->width
-1)))%rdp
->interleave
);
363 chunk
= min(count
, rdp
->interleave
- (lba
% rdp
->interleave
));
367 kprintf("ar%d: unknown array type in ata_raid_strategy\n", rdp
->lun
);
368 bbp
->b_flags
|= B_ERROR
;
374 /* offset on all but "first on HPTv2" */
375 if (!(drv
== 0 && rdp
->format
== AR_F_HPTV2_RAID
))
376 lba
+= rdp
->offset_sectors
;
378 if (!(request
= ata_raid_init_request(rdp
, bp
))) {
379 bbp
->b_flags
|= B_ERROR
;
384 request
->data
= data
;
385 request
->bytecount
= chunk
* DEV_BSIZE
;
386 request
->u
.ata
.lba
= lba
;
387 request
->u
.ata
.count
= request
->bytecount
/ DEV_BSIZE
;
393 if (((rdp
->disks
[drv
].flags
& (AR_DF_PRESENT
|AR_DF_ONLINE
)) ==
394 (AR_DF_PRESENT
|AR_DF_ONLINE
) && !rdp
->disks
[drv
].dev
)) {
395 rdp
->disks
[drv
].flags
&= ~AR_DF_ONLINE
;
396 ata_raid_config_changed(rdp
, 1);
397 ata_free_request(request
);
398 bbp
->b_flags
|= B_ERROR
;
404 request
->dev
= rdp
->disks
[request
->this].dev
;
405 ata_raid_send_request(request
);
410 if ((rdp
->disks
[drv
].flags
&
411 (AR_DF_PRESENT
|AR_DF_ONLINE
))==(AR_DF_PRESENT
|AR_DF_ONLINE
) &&
412 !rdp
->disks
[drv
].dev
) {
413 rdp
->disks
[drv
].flags
&= ~AR_DF_ONLINE
;
416 if ((rdp
->disks
[drv
+ rdp
->width
].flags
&
417 (AR_DF_PRESENT
|AR_DF_ONLINE
))==(AR_DF_PRESENT
|AR_DF_ONLINE
) &&
418 !rdp
->disks
[drv
+ rdp
->width
].dev
) {
419 rdp
->disks
[drv
+ rdp
->width
].flags
&= ~AR_DF_ONLINE
;
423 ata_raid_config_changed(rdp
, 1);
424 if (!(rdp
->status
& AR_S_READY
)) {
425 ata_free_request(request
);
426 bbp
->b_flags
|= B_ERROR
;
432 if (rdp
->status
& AR_S_REBUILDING
)
433 blk
= ((lba
/ rdp
->interleave
) * rdp
->width
) * rdp
->interleave
+
434 (rdp
->interleave
* (drv
% rdp
->width
)) +
435 lba
% rdp
->interleave
;;
437 if (bbp
->b_cmd
== BUF_CMD_READ
) {
439 (rdp
->disks
[drv
].flags
& AR_DF_ONLINE
);
441 (rdp
->disks
[drv
+rdp
->width
].flags
& AR_DF_ONLINE
);
443 /* if mirror gone or close to last access on source */
446 ((u_int64_t
)(bp
->bio_offset
>> DEV_BSHIFT
)) >=
447 (rdp
->disks
[drv
].last_lba
- AR_PROXIMITY
) &&
448 ((u_int64_t
)(bp
->bio_offset
>> DEV_BSHIFT
)) <=
449 (rdp
->disks
[drv
].last_lba
+ AR_PROXIMITY
))) {
452 /* if source gone or close to last access on mirror */
453 else if (!src_online
||
455 ((u_int64_t
)(bp
->bio_offset
>> DEV_BSHIFT
)) >=
456 (rdp
->disks
[drv
+rdp
->width
].last_lba
-AR_PROXIMITY
) &&
457 ((u_int64_t
)(bp
->bio_offset
>> DEV_BSHIFT
)) <=
458 (rdp
->disks
[drv
+rdp
->width
].last_lba
+AR_PROXIMITY
))) {
462 /* not close to any previous access, toggle */
472 if ((rdp
->status
& AR_S_REBUILDING
) &&
473 (blk
<= rdp
->rebuild_lba
) &&
474 ((blk
+ chunk
) > rdp
->rebuild_lba
)) {
475 struct ata_composite
*composite
;
476 struct ata_request
*rebuild
;
479 /* figure out what part to rebuild */
480 if (drv
< rdp
->width
)
481 this = drv
+ rdp
->width
;
483 this = drv
- rdp
->width
;
485 /* do we have a spare to rebuild on ? */
486 if (rdp
->disks
[this].flags
& AR_DF_SPARE
) {
487 if ((composite
= ata_alloc_composite())) {
488 if ((rebuild
= ata_alloc_request())) {
489 rdp
->rebuild_lba
= blk
+ chunk
;
490 bcopy(request
, rebuild
,
491 sizeof(struct ata_request
));
492 rebuild
->this = this;
493 rebuild
->dev
= rdp
->disks
[this].dev
;
494 rebuild
->flags
&= ~ATA_R_READ
;
495 rebuild
->flags
|= ATA_R_WRITE
;
496 spin_init(&composite
->lock
);
497 composite
->residual
= request
->bytecount
;
498 composite
->rd_needed
|= (1 << drv
);
499 composite
->wr_depend
|= (1 << drv
);
500 composite
->wr_needed
|= (1 << this);
501 composite
->request
[drv
] = request
;
502 composite
->request
[this] = rebuild
;
503 request
->composite
= composite
;
504 rebuild
->composite
= composite
;
505 ata_raid_send_request(rebuild
);
508 ata_free_composite(composite
);
509 kprintf("DOH! ata_alloc_request failed!\n");
513 kprintf("DOH! ata_alloc_composite failed!\n");
516 else if (rdp
->disks
[this].flags
& AR_DF_ONLINE
) {
518 * if we got here we are a chunk of a RAID01 that
519 * does not need a rebuild, but we need to increment
520 * the rebuild_lba address to get the rebuild to
521 * move to the next chunk correctly
523 rdp
->rebuild_lba
= blk
+ chunk
;
526 kprintf("DOH! we didn't find the rebuild part\n");
529 if (bbp
->b_cmd
== BUF_CMD_WRITE
) {
530 if ((rdp
->disks
[drv
+rdp
->width
].flags
& AR_DF_ONLINE
) ||
531 ((rdp
->status
& AR_S_REBUILDING
) &&
532 (rdp
->disks
[drv
+rdp
->width
].flags
& AR_DF_SPARE
) &&
533 ((blk
< rdp
->rebuild_lba
) ||
534 ((blk
<= rdp
->rebuild_lba
) &&
535 ((blk
+ chunk
) > rdp
->rebuild_lba
))))) {
536 if ((rdp
->disks
[drv
].flags
& AR_DF_ONLINE
) ||
537 ((rdp
->status
& AR_S_REBUILDING
) &&
538 (rdp
->disks
[drv
].flags
& AR_DF_SPARE
) &&
539 ((blk
< rdp
->rebuild_lba
) ||
540 ((blk
<= rdp
->rebuild_lba
) &&
541 ((blk
+ chunk
) > rdp
->rebuild_lba
))))) {
542 struct ata_request
*mirror
;
543 struct ata_composite
*composite
;
544 int this = drv
+ rdp
->width
;
546 if ((composite
= ata_alloc_composite())) {
547 if ((mirror
= ata_alloc_request())) {
548 if ((blk
<= rdp
->rebuild_lba
) &&
549 ((blk
+ chunk
) > rdp
->rebuild_lba
))
550 rdp
->rebuild_lba
= blk
+ chunk
;
551 bcopy(request
, mirror
,
552 sizeof(struct ata_request
));
554 mirror
->dev
= rdp
->disks
[this].dev
;
555 spin_init(&composite
->lock
);
556 composite
->residual
= request
->bytecount
;
557 composite
->wr_needed
|= (1 << drv
);
558 composite
->wr_needed
|= (1 << this);
559 composite
->request
[drv
] = request
;
560 composite
->request
[this] = mirror
;
561 request
->composite
= composite
;
562 mirror
->composite
= composite
;
563 ata_raid_send_request(mirror
);
564 rdp
->disks
[this].last_lba
=
565 (u_int64_t
)(bp
->bio_offset
>> DEV_BSHIFT
) +
569 ata_free_composite(composite
);
570 kprintf("DOH! ata_alloc_request failed!\n");
574 kprintf("DOH! ata_alloc_composite failed!\n");
582 request
->dev
= rdp
->disks
[request
->this].dev
;
583 ata_raid_send_request(request
);
584 rdp
->disks
[request
->this].last_lba
=
585 ((u_int64_t
)(bp
->bio_offset
) >> DEV_BSHIFT
) + chunk
;
589 if (((rdp
->disks
[drv
].flags
& (AR_DF_PRESENT
|AR_DF_ONLINE
)) ==
590 (AR_DF_PRESENT
|AR_DF_ONLINE
) && !rdp
->disks
[drv
].dev
)) {
591 rdp
->disks
[drv
].flags
&= ~AR_DF_ONLINE
;
594 if (((rdp
->disks
[par
].flags
& (AR_DF_PRESENT
|AR_DF_ONLINE
)) ==
595 (AR_DF_PRESENT
|AR_DF_ONLINE
) && !rdp
->disks
[par
].dev
)) {
596 rdp
->disks
[par
].flags
&= ~AR_DF_ONLINE
;
600 ata_raid_config_changed(rdp
, 1);
601 if (!(rdp
->status
& AR_S_READY
)) {
602 ata_free_request(request
);
603 bbp
->b_flags
|= B_ERROR
;
608 if (rdp
->status
& AR_S_DEGRADED
) {
609 /* do the XOR game if possible */
613 request
->dev
= rdp
->disks
[request
->this].dev
;
614 if (bbp
->b_cmd
== BUF_CMD_READ
) {
615 ata_raid_send_request(request
);
617 if (bbp
->b_cmd
== BUF_CMD_WRITE
) {
618 ata_raid_send_request(request
);
619 /* XXX TGEN no, I don't speak Danish either */
621 * sikre at læs-modify-skriv til hver disk er atomarisk.
622 * par kopi af request
623 * læse orgdata fra drv
624 * skriv nydata til drv
625 * læse parorgdata fra par
626 * skriv orgdata xor parorgdata xor nydata til par
633 kprintf("ar%d: unknown array type in ata_raid_strategy\n", rdp
->lun
);
641 ata_raid_done(struct ata_request
*request
)
643 struct ar_softc
*rdp
= request
->driver
;
644 struct ata_composite
*composite
= NULL
;
645 struct bio
*bp
= request
->bio
;
646 struct buf
*bbp
= bp
->bio_buf
;
647 int i
, mirror
, finished
= 0;
649 if (bbp
->b_cmd
== BUF_CMD_FLUSH
) {
650 if (bbp
->b_error
== 0)
651 bbp
->b_error
= request
->result
;
652 ata_free_request(request
);
653 bp
->bio_driver_info
= (void *)((intptr_t)bp
->bio_driver_info
- 1);
654 if ((intptr_t)bp
->bio_driver_info
== 0) {
656 bbp
->b_flags
|= B_ERROR
;
666 if (request
->result
) {
667 rdp
->disks
[request
->this].flags
&= ~AR_DF_ONLINE
;
668 ata_raid_config_changed(rdp
, 1);
669 bbp
->b_error
= request
->result
;
673 bbp
->b_resid
-= request
->donecount
;
681 if (request
->this < rdp
->width
)
682 mirror
= request
->this + rdp
->width
;
684 mirror
= request
->this - rdp
->width
;
685 if (request
->result
) {
686 rdp
->disks
[request
->this].flags
&= ~AR_DF_ONLINE
;
687 ata_raid_config_changed(rdp
, 1);
689 if (rdp
->status
& AR_S_READY
) {
692 if (rdp
->status
& AR_S_REBUILDING
)
693 blk
= ((request
->u
.ata
.lba
/ rdp
->interleave
) * rdp
->width
) *
694 rdp
->interleave
+ (rdp
->interleave
*
695 (request
->this % rdp
->width
)) +
696 request
->u
.ata
.lba
% rdp
->interleave
;
698 if (bbp
->b_cmd
== BUF_CMD_READ
) {
700 /* is this a rebuild composite */
701 if ((composite
= request
->composite
)) {
702 spin_lock_wr(&composite
->lock
);
704 /* handle the read part of a rebuild composite */
705 if (request
->flags
& ATA_R_READ
) {
707 /* if read failed array is now broken */
708 if (request
->result
) {
709 rdp
->disks
[request
->this].flags
&= ~AR_DF_ONLINE
;
710 ata_raid_config_changed(rdp
, 1);
711 bbp
->b_error
= request
->result
;
712 rdp
->rebuild_lba
= blk
;
716 /* good data, update how far we've gotten */
718 bbp
->b_resid
-= request
->donecount
;
719 composite
->residual
-= request
->donecount
;
720 if (!composite
->residual
) {
721 if (composite
->wr_done
& (1 << mirror
))
727 /* handle the write part of a rebuild composite */
728 else if (request
->flags
& ATA_R_WRITE
) {
729 if (composite
->rd_done
& (1 << mirror
)) {
730 if (request
->result
) {
731 kprintf("DOH! rebuild failed\n"); /* XXX SOS */
732 rdp
->rebuild_lba
= blk
;
734 if (!composite
->residual
)
738 spin_unlock_wr(&composite
->lock
);
741 /* if read failed retry on the mirror */
742 else if (request
->result
) {
743 request
->dev
= rdp
->disks
[mirror
].dev
;
744 request
->flags
&= ~ATA_R_TIMEOUT
;
745 ata_raid_send_request(request
);
749 /* we have good data */
751 bbp
->b_resid
-= request
->donecount
;
756 else if (bbp
->b_cmd
== BUF_CMD_WRITE
) {
757 /* do we have a mirror or rebuild to deal with ? */
758 if ((composite
= request
->composite
)) {
759 spin_lock_wr(&composite
->lock
);
760 if (composite
->wr_done
& (1 << mirror
)) {
761 if (request
->result
) {
762 if (composite
->request
[mirror
]->result
) {
763 kprintf("DOH! all disks failed and got here\n");
766 if (rdp
->status
& AR_S_REBUILDING
) {
767 rdp
->rebuild_lba
= blk
;
768 kprintf("DOH! rebuild failed\n"); /* XXX SOS */
771 composite
->request
[mirror
]->donecount
;
772 composite
->residual
-=
773 composite
->request
[mirror
]->donecount
;
776 bbp
->b_resid
-= request
->donecount
;
777 composite
->residual
-= request
->donecount
;
779 if (!composite
->residual
)
782 spin_unlock_wr(&composite
->lock
);
784 /* no mirror we are done */
786 bbp
->b_resid
-= request
->donecount
;
793 /* XXX TGEN bbp->b_flags |= B_ERROR; */
794 bbp
->b_error
= request
->result
;
800 if (request
->result
) {
801 rdp
->disks
[request
->this].flags
&= ~AR_DF_ONLINE
;
802 ata_raid_config_changed(rdp
, 1);
803 if (rdp
->status
& AR_S_READY
) {
804 if (bbp
->b_cmd
== BUF_CMD_READ
) {
805 /* do the XOR game to recover data */
807 if (bbp
->b_cmd
== BUF_CMD_WRITE
) {
808 /* if the parity failed we're OK sortof */
809 /* otherwise wee need to do the XOR long dance */
814 /* XXX TGEN bbp->b_flags |= B_ERROR; */
815 bbp
->b_error
= request
->result
;
820 /* did we have an XOR game going ?? */
821 bbp
->b_resid
-= request
->donecount
;
828 kprintf("ar%d: unknown array type in ata_raid_done\n", rdp
->lun
);
832 if ((rdp
->status
& AR_S_REBUILDING
) &&
833 rdp
->rebuild_lba
>= rdp
->total_sectors
) {
836 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
837 if ((rdp
->disks
[disk
].flags
&
838 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_SPARE
)) ==
839 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_SPARE
)) {
840 rdp
->disks
[disk
].flags
&= ~AR_DF_SPARE
;
841 rdp
->disks
[disk
].flags
|= AR_DF_ONLINE
;
844 rdp
->status
&= ~AR_S_REBUILDING
;
845 ata_raid_config_changed(rdp
, 1);
853 /* we are done with this composite, free all resources */
854 for (i
= 0; i
< 32; i
++) {
855 if (composite
->rd_needed
& (1 << i
) ||
856 composite
->wr_needed
& (1 << i
)) {
857 ata_free_request(composite
->request
[i
]);
860 spin_uninit(&composite
->lock
);
861 ata_free_composite(composite
);
865 ata_free_request(request
);
869 ata_raid_dump(struct dev_dump_args
*ap
)
871 struct ar_softc
*rdp
= ap
->a_head
.a_dev
->si_drv1
;
875 int dumppages
= MAXDUMPPGS
;
879 blkcnt
= howmany(PAGE_SIZE
, ap
->a_secsize
);
881 while (ap
->a_count
> 0) {
884 if ((ap
->a_count
/ blkcnt
) < dumppages
)
885 dumppages
= ap
->a_count
/ blkcnt
;
887 for (i
= 0; i
< dumppages
; ++i
) {
888 vm_paddr_t a
= addr
+ (i
* PAGE_SIZE
);
889 if (is_physical_memory(a
))
890 va
= pmap_kenter_temporary(trunc_page(a
), i
);
892 va
= pmap_kenter_temporary(trunc_page(0), i
);
895 bzero(&dbuf
, sizeof(struct buf
));
897 BUF_LOCK(&dbuf
, LK_EXCLUSIVE
);
899 /* bio_offset is byte granularity, convert block granularity a_blkno */
900 dbuf
.b_bio1
.bio_offset
= (off_t
)(ap
->a_blkno
<< DEV_BSHIFT
);
901 dbuf
.b_bio1
.bio_caller_info1
.ptr
= (void *)rdp
;
902 dbuf
.b_bcount
= dumppages
* PAGE_SIZE
;
904 dbuf
.b_cmd
= BUF_CMD_WRITE
;
905 dev_dstrategy(rdp
->cdev
, &dbuf
.b_bio1
);
906 /* wait for completion, unlock the buffer, check status */
907 if (biowait(&dbuf
)) {
909 return(dbuf
.b_error
? dbuf
.b_error
: EIO
);
913 if (dumpstatus(addr
, (off_t
)ap
->a_count
* DEV_BSIZE
) < 0)
916 ap
->a_blkno
+= blkcnt
* dumppages
;
917 ap
->a_count
-= blkcnt
* dumppages
;
918 addr
+= PAGE_SIZE
* dumppages
;
921 /* flush subdisk buffers to media */
922 for (disk
= 0; disk
< rdp
->total_disks
; disk
++)
923 if (rdp
->disks
[disk
].dev
)
924 error
|= ata_controlcmd(rdp
->disks
[disk
].dev
, ATA_FLUSHCACHE
, 0, 0,
926 return (error
? EIO
: 0);
930 ata_raid_config_changed(struct ar_softc
*rdp
, int writeback
)
932 int disk
, count
, status
;
934 spin_lock_wr(&rdp
->lock
);
935 /* set default all working mode */
936 status
= rdp
->status
;
937 rdp
->status
&= ~AR_S_DEGRADED
;
938 rdp
->status
|= AR_S_READY
;
940 /* make sure all lost drives are accounted for */
941 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
942 if (!(rdp
->disks
[disk
].flags
& AR_DF_PRESENT
))
943 rdp
->disks
[disk
].flags
&= ~AR_DF_ONLINE
;
946 /* depending on RAID type figure out our health status */
951 for (disk
= 0; disk
< rdp
->total_disks
; disk
++)
952 if (!(rdp
->disks
[disk
].flags
& AR_DF_ONLINE
))
953 rdp
->status
&= ~AR_S_READY
;
958 for (disk
= 0; disk
< rdp
->width
; disk
++) {
959 if (!(rdp
->disks
[disk
].flags
& AR_DF_ONLINE
) &&
960 !(rdp
->disks
[disk
+ rdp
->width
].flags
& AR_DF_ONLINE
)) {
961 rdp
->status
&= ~AR_S_READY
;
963 else if (((rdp
->disks
[disk
].flags
& AR_DF_ONLINE
) &&
964 !(rdp
->disks
[disk
+ rdp
->width
].flags
& AR_DF_ONLINE
)) ||
965 (!(rdp
->disks
[disk
].flags
& AR_DF_ONLINE
) &&
966 (rdp
->disks
[disk
+ rdp
->width
].flags
& AR_DF_ONLINE
))) {
967 rdp
->status
|= AR_S_DEGRADED
;
973 for (count
= 0, disk
= 0; disk
< rdp
->total_disks
; disk
++) {
974 if (!(rdp
->disks
[disk
].flags
& AR_DF_ONLINE
))
979 rdp
->status
&= ~AR_S_READY
;
981 rdp
->status
|= AR_S_DEGRADED
;
985 rdp
->status
&= ~AR_S_READY
;
989 * Note that when the array breaks so comes up broken we
990 * force a write of the array config to the remaining
991 * drives so that the generation will be incremented past
992 * those of the missing or failed drives (in all cases).
994 if (rdp
->status
!= status
) {
995 if (!(rdp
->status
& AR_S_READY
)) {
996 kprintf("ar%d: FAILURE - %s array broken\n",
997 rdp
->lun
, ata_raid_type(rdp
));
1000 else if (rdp
->status
& AR_S_DEGRADED
) {
1001 if (rdp
->type
& (AR_T_RAID1
| AR_T_RAID01
))
1002 kprintf("ar%d: WARNING - mirror", rdp
->lun
);
1004 kprintf("ar%d: WARNING - parity", rdp
->lun
);
1005 kprintf(" protection lost. %s array in DEGRADED mode\n",
1006 ata_raid_type(rdp
));
1010 spin_unlock_wr(&rdp
->lock
);
1012 ata_raid_write_metadata(rdp
);
1017 ata_raid_status(struct ata_ioc_raid_config
*config
)
1019 struct ar_softc
*rdp
;
1022 if (!(rdp
= ata_raid_arrays
[config
->lun
]))
1025 config
->type
= rdp
->type
;
1026 config
->total_disks
= rdp
->total_disks
;
1027 for (i
= 0; i
< rdp
->total_disks
; i
++ ) {
1028 if ((rdp
->disks
[i
].flags
& AR_DF_PRESENT
) && rdp
->disks
[i
].dev
)
1029 config
->disks
[i
] = device_get_unit(rdp
->disks
[i
].dev
);
1031 config
->disks
[i
] = -1;
1033 config
->interleave
= rdp
->interleave
;
1034 config
->status
= rdp
->status
;
1035 config
->progress
= 100 * rdp
->rebuild_lba
/ rdp
->total_sectors
;
1040 ata_raid_create(struct ata_ioc_raid_config
*config
)
1042 struct ar_softc
*rdp
;
1045 int ctlr
= 0, disk_size
= 0, total_disks
= 0;
1047 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
1048 if (!ata_raid_arrays
[array
])
1051 if (array
>= MAX_ARRAYS
)
1054 rdp
= (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
1057 for (disk
= 0; disk
< config
->total_disks
; disk
++) {
1058 if ((subdisk
= devclass_get_device(ata_raid_sub_devclass
,
1059 config
->disks
[disk
]))) {
1060 struct ata_raid_subdisk
*ars
= device_get_softc(subdisk
);
1062 /* is device already assigned to another array ? */
1063 if (ars
->raid
[rdp
->volume
]) {
1064 config
->disks
[disk
] = -1;
1068 rdp
->disks
[disk
].dev
= device_get_parent(subdisk
);
1070 switch (pci_get_vendor(GRANDPARENT(rdp
->disks
[disk
].dev
))) {
1071 case ATA_HIGHPOINT_ID
:
1073 * we need some way to decide if it should be v2 or v3
1074 * for now just use v2 since the v3 BIOS knows how to
1075 * handle that as well.
1077 ctlr
= AR_F_HPTV2_RAID
;
1078 rdp
->disks
[disk
].sectors
= HPTV3_LBA(rdp
->disks
[disk
].dev
);
1082 ctlr
= AR_F_INTEL_RAID
;
1083 rdp
->disks
[disk
].sectors
= INTEL_LBA(rdp
->disks
[disk
].dev
);
1087 ctlr
= AR_F_ITE_RAID
;
1088 rdp
->disks
[disk
].sectors
= ITE_LBA(rdp
->disks
[disk
].dev
);
1091 case ATA_JMICRON_ID
:
1092 ctlr
= AR_F_JMICRON_RAID
;
1093 rdp
->disks
[disk
].sectors
= JMICRON_LBA(rdp
->disks
[disk
].dev
);
1096 case 0: /* XXX SOS cover up for bug in our PCI code */
1097 case ATA_PROMISE_ID
:
1098 ctlr
= AR_F_PROMISE_RAID
;
1099 rdp
->disks
[disk
].sectors
= PROMISE_LBA(rdp
->disks
[disk
].dev
);
1103 ctlr
= AR_F_SIS_RAID
;
1104 rdp
->disks
[disk
].sectors
= SIS_LBA(rdp
->disks
[disk
].dev
);
1109 ctlr
= AR_F_VIA_RAID
;
1110 rdp
->disks
[disk
].sectors
= VIA_LBA(rdp
->disks
[disk
].dev
);
1115 * right, so here we are, we have an ATA chip and we want
1116 * to create a RAID and store the metadata.
1117 * we need to find a way to tell what kind of metadata this
1118 * hardware's BIOS might be using (good ideas are welcomed)
1119 * for now we just use our own native FreeBSD format.
1120 * the only way to get support for the BIOS format is to
1121 * setup the RAID from there, in that case we pickup the
1122 * metadata format from the disks (if we support it).
1124 kprintf("WARNING!! - not able to determine metadata format\n"
1125 "WARNING!! - Using FreeBSD PseudoRAID metadata\n"
1126 "If that is not what you want, use the BIOS to "
1127 "create the array\n");
1128 ctlr
= AR_F_FREEBSD_RAID
;
1129 rdp
->disks
[disk
].sectors
= PROMISE_LBA(rdp
->disks
[disk
].dev
);
1133 /* we need all disks to be of the same format */
1134 if ((rdp
->format
& AR_F_FORMAT_MASK
) &&
1135 (rdp
->format
& AR_F_FORMAT_MASK
) != (ctlr
& AR_F_FORMAT_MASK
)) {
1142 /* use the smallest disk of the lots size */
1143 /* gigabyte boundry ??? XXX SOS */
1145 disk_size
= min(rdp
->disks
[disk
].sectors
, disk_size
);
1147 disk_size
= rdp
->disks
[disk
].sectors
;
1148 rdp
->disks
[disk
].flags
=
1149 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_ONLINE
);
1154 config
->disks
[disk
] = -1;
1160 if (total_disks
!= config
->total_disks
) {
1165 switch (config
->type
) {
1172 if (total_disks
!= 2) {
1179 if (total_disks
% 2 != 0) {
1186 if (total_disks
< 3) {
1196 rdp
->type
= config
->type
;
1198 if (rdp
->type
== AR_T_RAID0
|| rdp
->type
== AR_T_RAID01
||
1199 rdp
->type
== AR_T_RAID5
) {
1202 while (config
->interleave
>>= 1)
1204 rdp
->interleave
= 1 << bit
;
1206 rdp
->offset_sectors
= 0;
1208 /* values that depend on metadata format */
1209 switch (rdp
->format
) {
1210 case AR_F_ADAPTEC_RAID
:
1211 rdp
->interleave
= min(max(32, rdp
->interleave
), 128); /*+*/
1214 case AR_F_HPTV2_RAID
:
1215 rdp
->interleave
= min(max(8, rdp
->interleave
), 128); /*+*/
1216 rdp
->offset_sectors
= HPTV2_LBA(x
) + 1;
1219 case AR_F_HPTV3_RAID
:
1220 rdp
->interleave
= min(max(32, rdp
->interleave
), 4096); /*+*/
1223 case AR_F_INTEL_RAID
:
1224 rdp
->interleave
= min(max(8, rdp
->interleave
), 256); /*+*/
1228 rdp
->interleave
= min(max(2, rdp
->interleave
), 128); /*+*/
1231 case AR_F_JMICRON_RAID
:
1232 rdp
->interleave
= min(max(8, rdp
->interleave
), 256); /*+*/
1235 case AR_F_LSIV2_RAID
:
1236 rdp
->interleave
= min(max(2, rdp
->interleave
), 4096);
1239 case AR_F_LSIV3_RAID
:
1240 rdp
->interleave
= min(max(2, rdp
->interleave
), 256);
1243 case AR_F_PROMISE_RAID
:
1244 rdp
->interleave
= min(max(2, rdp
->interleave
), 2048); /*+*/
1248 rdp
->interleave
= min(max(8, rdp
->interleave
), 256); /*+*/
1252 rdp
->interleave
= min(max(32, rdp
->interleave
), 512); /*+*/
1256 rdp
->interleave
= min(max(8, rdp
->interleave
), 128); /*+*/
1260 rdp
->total_disks
= total_disks
;
1261 rdp
->width
= total_disks
/ (rdp
->type
& (AR_RAID1
| AR_T_RAID01
) ? 2 : 1);
1262 rdp
->total_sectors
= disk_size
* (rdp
->width
- (rdp
->type
== AR_RAID5
));
1265 rdp
->cylinders
= rdp
->total_sectors
/ (255 * 63);
1266 rdp
->rebuild_lba
= 0;
1267 rdp
->status
|= AR_S_READY
;
1269 /* we are committed to this array, grap the subdisks */
1270 for (disk
= 0; disk
< config
->total_disks
; disk
++) {
1271 if ((subdisk
= devclass_get_device(ata_raid_sub_devclass
,
1272 config
->disks
[disk
]))) {
1273 struct ata_raid_subdisk
*ars
= device_get_softc(subdisk
);
1275 ars
->raid
[rdp
->volume
] = rdp
;
1276 ars
->disk_number
[rdp
->volume
] = disk
;
1279 ata_raid_attach(rdp
, 1);
1280 ata_raid_arrays
[array
] = rdp
;
1281 config
->lun
= array
;
1286 ata_raid_delete(int array
)
1288 struct ar_softc
*rdp
;
1292 if (!(rdp
= ata_raid_arrays
[array
]))
1295 rdp
->status
&= ~AR_S_READY
;
1296 disk_destroy(&rdp
->disk
);
1298 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
1299 if ((rdp
->disks
[disk
].flags
& AR_DF_PRESENT
) && rdp
->disks
[disk
].dev
) {
1300 if ((subdisk
= devclass_get_device(ata_raid_sub_devclass
,
1301 device_get_unit(rdp
->disks
[disk
].dev
)))) {
1302 struct ata_raid_subdisk
*ars
= device_get_softc(subdisk
);
1304 if (ars
->raid
[rdp
->volume
] != rdp
) /* XXX SOS */
1305 device_printf(subdisk
, "DOH! this disk doesn't belong\n");
1306 if (ars
->disk_number
[rdp
->volume
] != disk
) /* XXX SOS */
1307 device_printf(subdisk
, "DOH! this disk number is wrong\n");
1308 ars
->raid
[rdp
->volume
] = NULL
;
1309 ars
->disk_number
[rdp
->volume
] = -1;
1311 rdp
->disks
[disk
].flags
= 0;
1314 ata_raid_wipe_metadata(rdp
);
1315 ata_raid_arrays
[array
] = NULL
;
1321 ata_raid_addspare(struct ata_ioc_raid_config
*config
)
1323 struct ar_softc
*rdp
;
1327 if (!(rdp
= ata_raid_arrays
[config
->lun
]))
1329 if (!(rdp
->status
& AR_S_DEGRADED
) || !(rdp
->status
& AR_S_READY
))
1331 if (rdp
->status
& AR_S_REBUILDING
)
1333 switch (rdp
->type
) {
1337 for (disk
= 0; disk
< rdp
->total_disks
; disk
++ ) {
1339 if (((rdp
->disks
[disk
].flags
& (AR_DF_PRESENT
| AR_DF_ONLINE
)) ==
1340 (AR_DF_PRESENT
| AR_DF_ONLINE
)) && rdp
->disks
[disk
].dev
)
1343 if ((subdisk
= devclass_get_device(ata_raid_sub_devclass
,
1344 config
->disks
[0] ))) {
1345 struct ata_raid_subdisk
*ars
= device_get_softc(subdisk
);
1347 if (ars
->raid
[rdp
->volume
])
1350 /* XXX SOS validate size etc etc */
1351 ars
->raid
[rdp
->volume
] = rdp
;
1352 ars
->disk_number
[rdp
->volume
] = disk
;
1353 rdp
->disks
[disk
].dev
= device_get_parent(subdisk
);
1354 rdp
->disks
[disk
].flags
=
1355 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_SPARE
);
1357 device_printf(rdp
->disks
[disk
].dev
,
1358 "inserted into ar%d disk%d as spare\n",
1360 ata_raid_config_changed(rdp
, 1);
1372 ata_raid_rebuild(int array
)
1374 struct ar_softc
*rdp
;
1377 if (!(rdp
= ata_raid_arrays
[array
]))
1379 /* XXX SOS we should lock the rdp softc here */
1380 if (!(rdp
->status
& AR_S_DEGRADED
) || !(rdp
->status
& AR_S_READY
))
1382 if (rdp
->status
& AR_S_REBUILDING
)
1385 switch (rdp
->type
) {
1389 for (count
= 0, disk
= 0; disk
< rdp
->total_disks
; disk
++ ) {
1390 if (((rdp
->disks
[disk
].flags
&
1391 (AR_DF_PRESENT
|AR_DF_ASSIGNED
|AR_DF_ONLINE
|AR_DF_SPARE
)) ==
1392 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_SPARE
)) &&
1393 rdp
->disks
[disk
].dev
) {
1399 rdp
->rebuild_lba
= 0;
1400 rdp
->status
|= AR_S_REBUILDING
;
1411 ata_raid_read_metadata(device_t subdisk
)
1413 devclass_t pci_devclass
= devclass_find("pci");
1414 devclass_t devclass
=device_get_devclass(GRANDPARENT(GRANDPARENT(subdisk
)));
1416 /* prioritize vendor native metadata layout if possible */
1417 if (devclass
== pci_devclass
) {
1418 switch (pci_get_vendor(GRANDPARENT(device_get_parent(subdisk
)))) {
1419 case ATA_HIGHPOINT_ID
:
1420 if (ata_raid_hptv3_read_meta(subdisk
, ata_raid_arrays
))
1422 if (ata_raid_hptv2_read_meta(subdisk
, ata_raid_arrays
))
1427 if (ata_raid_intel_read_meta(subdisk
, ata_raid_arrays
))
1432 if (ata_raid_ite_read_meta(subdisk
, ata_raid_arrays
))
1436 case ATA_JMICRON_ID
:
1437 if (ata_raid_jmicron_read_meta(subdisk
, ata_raid_arrays
))
1442 if (ata_raid_nvidia_read_meta(subdisk
, ata_raid_arrays
))
1446 case 0: /* XXX SOS cover up for bug in our PCI code */
1447 case ATA_PROMISE_ID
:
1448 if (ata_raid_promise_read_meta(subdisk
, ata_raid_arrays
, 0))
1453 case ATA_SILICON_IMAGE_ID
:
1454 if (ata_raid_sii_read_meta(subdisk
, ata_raid_arrays
))
1459 if (ata_raid_sis_read_meta(subdisk
, ata_raid_arrays
))
1464 if (ata_raid_via_read_meta(subdisk
, ata_raid_arrays
))
1470 /* handle controllers that have multiple layout possibilities */
1471 /* NOTE: the order of these are not insignificant */
1473 /* Adaptec HostRAID */
1474 if (ata_raid_adaptec_read_meta(subdisk
, ata_raid_arrays
))
1477 /* LSILogic v3 and v2 */
1478 if (ata_raid_lsiv3_read_meta(subdisk
, ata_raid_arrays
))
1480 if (ata_raid_lsiv2_read_meta(subdisk
, ata_raid_arrays
))
1483 /* if none of the above matched, try FreeBSD native format */
1484 return ata_raid_promise_read_meta(subdisk
, ata_raid_arrays
, 1);
1488 ata_raid_write_metadata(struct ar_softc
*rdp
)
1490 switch (rdp
->format
) {
1491 case AR_F_FREEBSD_RAID
:
1492 case AR_F_PROMISE_RAID
:
1493 return ata_raid_promise_write_meta(rdp
);
1495 case AR_F_HPTV3_RAID
:
1496 case AR_F_HPTV2_RAID
:
1498 * always write HPT v2 metadata, the v3 BIOS knows it as well.
1499 * this is handy since we cannot know what version BIOS is on there
1501 return ata_raid_hptv2_write_meta(rdp
);
1503 case AR_F_INTEL_RAID
:
1504 return ata_raid_intel_write_meta(rdp
);
1506 case AR_F_JMICRON_RAID
:
1507 return ata_raid_jmicron_write_meta(rdp
);
1510 return ata_raid_sis_write_meta(rdp
);
1513 return ata_raid_via_write_meta(rdp
);
1515 case AR_F_HPTV3_RAID
:
1516 return ata_raid_hptv3_write_meta(rdp
);
1518 case AR_F_ADAPTEC_RAID
:
1519 return ata_raid_adaptec_write_meta(rdp
);
1522 return ata_raid_ite_write_meta(rdp
);
1524 case AR_F_LSIV2_RAID
:
1525 return ata_raid_lsiv2_write_meta(rdp
);
1527 case AR_F_LSIV3_RAID
:
1528 return ata_raid_lsiv3_write_meta(rdp
);
1530 case AR_F_NVIDIA_RAID
:
1531 return ata_raid_nvidia_write_meta(rdp
);
1534 return ata_raid_sii_write_meta(rdp
);
1538 kprintf("ar%d: writing of %s metadata is NOT supported yet\n",
1539 rdp
->lun
, ata_raid_format(rdp
));
1545 ata_raid_wipe_metadata(struct ar_softc
*rdp
)
1547 int disk
, error
= 0;
1552 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
1553 if (rdp
->disks
[disk
].dev
) {
1554 switch (rdp
->format
) {
1555 case AR_F_ADAPTEC_RAID
:
1556 lba
= ADP_LBA(rdp
->disks
[disk
].dev
);
1557 size
= sizeof(struct adaptec_raid_conf
);
1560 case AR_F_HPTV2_RAID
:
1561 lba
= HPTV2_LBA(rdp
->disks
[disk
].dev
);
1562 size
= sizeof(struct hptv2_raid_conf
);
1565 case AR_F_HPTV3_RAID
:
1566 lba
= HPTV3_LBA(rdp
->disks
[disk
].dev
);
1567 size
= sizeof(struct hptv3_raid_conf
);
1570 case AR_F_INTEL_RAID
:
1571 lba
= INTEL_LBA(rdp
->disks
[disk
].dev
);
1572 size
= 3 * 512; /* XXX SOS */
1576 lba
= ITE_LBA(rdp
->disks
[disk
].dev
);
1577 size
= sizeof(struct ite_raid_conf
);
1580 case AR_F_JMICRON_RAID
:
1581 lba
= JMICRON_LBA(rdp
->disks
[disk
].dev
);
1582 size
= sizeof(struct jmicron_raid_conf
);
1585 case AR_F_LSIV2_RAID
:
1586 lba
= LSIV2_LBA(rdp
->disks
[disk
].dev
);
1587 size
= sizeof(struct lsiv2_raid_conf
);
1590 case AR_F_LSIV3_RAID
:
1591 lba
= LSIV3_LBA(rdp
->disks
[disk
].dev
);
1592 size
= sizeof(struct lsiv3_raid_conf
);
1595 case AR_F_NVIDIA_RAID
:
1596 lba
= NVIDIA_LBA(rdp
->disks
[disk
].dev
);
1597 size
= sizeof(struct nvidia_raid_conf
);
1600 case AR_F_FREEBSD_RAID
:
1601 case AR_F_PROMISE_RAID
:
1602 lba
= PROMISE_LBA(rdp
->disks
[disk
].dev
);
1603 size
= sizeof(struct promise_raid_conf
);
1607 lba
= SII_LBA(rdp
->disks
[disk
].dev
);
1608 size
= sizeof(struct sii_raid_conf
);
1612 lba
= SIS_LBA(rdp
->disks
[disk
].dev
);
1613 size
= sizeof(struct sis_raid_conf
);
1617 lba
= VIA_LBA(rdp
->disks
[disk
].dev
);
1618 size
= sizeof(struct via_raid_conf
);
1622 kprintf("ar%d: wiping of %s metadata is NOT supported yet\n",
1623 rdp
->lun
, ata_raid_format(rdp
));
1626 meta
= kmalloc(size
, M_AR
, M_WAITOK
| M_ZERO
);
1627 if (ata_raid_rw(rdp
->disks
[disk
].dev
, lba
, meta
, size
,
1628 ATA_R_WRITE
| ATA_R_DIRECT
)) {
1629 device_printf(rdp
->disks
[disk
].dev
, "wipe metadata failed\n");
1638 /* Adaptec HostRAID Metadata */
1640 ata_raid_adaptec_read_meta(device_t dev
, struct ar_softc
**raidp
)
1642 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
1643 device_t parent
= device_get_parent(dev
);
1644 struct adaptec_raid_conf
*meta
;
1645 struct ar_softc
*raid
;
1646 int array
, disk
, retval
= 0;
1648 meta
= (struct adaptec_raid_conf
*)
1649 kmalloc(sizeof(struct adaptec_raid_conf
), M_AR
, M_WAITOK
| M_ZERO
);
1651 if (ata_raid_rw(parent
, ADP_LBA(parent
),
1652 meta
, sizeof(struct adaptec_raid_conf
), ATA_R_READ
)) {
1653 if (testing
|| bootverbose
)
1654 device_printf(parent
, "Adaptec read metadata failed\n");
1658 /* check if this is a Adaptec RAID struct */
1659 if (meta
->magic_0
!= ADP_MAGIC_0
|| meta
->magic_3
!= ADP_MAGIC_3
) {
1660 if (testing
|| bootverbose
)
1661 device_printf(parent
, "Adaptec check1 failed\n");
1665 if (testing
|| bootverbose
)
1666 ata_raid_adaptec_print_meta(meta
);
1668 /* now convert Adaptec metadata into our generic form */
1669 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
1670 if (!raidp
[array
]) {
1672 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
1675 raid
= raidp
[array
];
1676 if (raid
->format
&& (raid
->format
!= AR_F_ADAPTEC_RAID
))
1679 if (raid
->magic_0
&& raid
->magic_0
!= meta
->configs
[0].magic_0
)
1682 if (!meta
->generation
|| be32toh(meta
->generation
) > raid
->generation
) {
1683 switch (meta
->configs
[0].type
) {
1685 raid
->magic_0
= meta
->configs
[0].magic_0
;
1686 raid
->type
= AR_T_RAID0
;
1687 raid
->interleave
= 1 << (meta
->configs
[0].stripe_shift
>> 1);
1688 raid
->width
= be16toh(meta
->configs
[0].total_disks
);
1692 raid
->magic_0
= meta
->configs
[0].magic_0
;
1693 raid
->type
= AR_T_RAID1
;
1694 raid
->width
= be16toh(meta
->configs
[0].total_disks
) / 2;
1698 device_printf(parent
, "Adaptec unknown RAID type 0x%02x\n",
1699 meta
->configs
[0].type
);
1700 kfree(raidp
[array
], M_AR
);
1701 raidp
[array
] = NULL
;
1705 raid
->format
= AR_F_ADAPTEC_RAID
;
1706 raid
->generation
= be32toh(meta
->generation
);
1707 raid
->total_disks
= be16toh(meta
->configs
[0].total_disks
);
1708 raid
->total_sectors
= be32toh(meta
->configs
[0].sectors
);
1711 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
1712 raid
->offset_sectors
= 0;
1713 raid
->rebuild_lba
= 0;
1715 strncpy(raid
->name
, meta
->configs
[0].name
,
1716 min(sizeof(raid
->name
), sizeof(meta
->configs
[0].name
)));
1718 /* clear out any old info */
1719 if (raid
->generation
) {
1720 for (disk
= 0; disk
< raid
->total_disks
; disk
++) {
1721 raid
->disks
[disk
].dev
= NULL
;
1722 raid
->disks
[disk
].flags
= 0;
1726 if (be32toh(meta
->generation
) >= raid
->generation
) {
1727 struct ata_device
*atadev
= device_get_softc(parent
);
1728 struct ata_channel
*ch
= device_get_softc(GRANDPARENT(dev
));
1729 int disk_number
= (ch
->unit
<< !(ch
->flags
& ATA_NO_SLAVE
)) +
1730 ATA_DEV(atadev
->unit
);
1732 raid
->disks
[disk_number
].dev
= parent
;
1733 raid
->disks
[disk_number
].sectors
=
1734 be32toh(meta
->configs
[disk_number
+ 1].sectors
);
1735 raid
->disks
[disk_number
].flags
=
1736 (AR_DF_ONLINE
| AR_DF_PRESENT
| AR_DF_ASSIGNED
);
1737 ars
->raid
[raid
->volume
] = raid
;
1738 ars
->disk_number
[raid
->volume
] = disk_number
;
1749 /* Highpoint V2 RocketRAID Metadata */
1751 ata_raid_hptv2_read_meta(device_t dev
, struct ar_softc
**raidp
)
1753 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
1754 device_t parent
= device_get_parent(dev
);
1755 struct hptv2_raid_conf
*meta
;
1756 struct ar_softc
*raid
= NULL
;
1757 int array
, disk_number
= 0, retval
= 0;
1759 meta
= (struct hptv2_raid_conf
*)kmalloc(sizeof(struct hptv2_raid_conf
),
1760 M_AR
, M_WAITOK
| M_ZERO
);
1762 if (ata_raid_rw(parent
, HPTV2_LBA(parent
),
1763 meta
, sizeof(struct hptv2_raid_conf
), ATA_R_READ
)) {
1764 if (testing
|| bootverbose
)
1765 device_printf(parent
, "HighPoint (v2) read metadata failed\n");
1769 /* check if this is a HighPoint v2 RAID struct */
1770 if (meta
->magic
!= HPTV2_MAGIC_OK
&& meta
->magic
!= HPTV2_MAGIC_BAD
) {
1771 if (testing
|| bootverbose
)
1772 device_printf(parent
, "HighPoint (v2) check1 failed\n");
1776 /* is this disk defined, or an old leftover/spare ? */
1777 if (!meta
->magic_0
) {
1778 if (testing
|| bootverbose
)
1779 device_printf(parent
, "HighPoint (v2) check2 failed\n");
1783 if (testing
|| bootverbose
)
1784 ata_raid_hptv2_print_meta(meta
);
1786 /* now convert HighPoint (v2) metadata into our generic form */
1787 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
1788 if (!raidp
[array
]) {
1790 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
1793 raid
= raidp
[array
];
1794 if (raid
->format
&& (raid
->format
!= AR_F_HPTV2_RAID
))
1797 switch (meta
->type
) {
1799 if ((meta
->order
& (HPTV2_O_RAID0
|HPTV2_O_OK
)) ==
1800 (HPTV2_O_RAID0
|HPTV2_O_OK
))
1801 goto highpoint_raid1
;
1802 if (meta
->order
& (HPTV2_O_RAID0
| HPTV2_O_RAID1
))
1803 goto highpoint_raid01
;
1804 if (raid
->magic_0
&& raid
->magic_0
!= meta
->magic_0
)
1806 raid
->magic_0
= meta
->magic_0
;
1807 raid
->type
= AR_T_RAID0
;
1808 raid
->interleave
= 1 << meta
->stripe_shift
;
1809 disk_number
= meta
->disk_number
;
1810 if (!(meta
->order
& HPTV2_O_OK
))
1811 meta
->magic
= 0; /* mark bad */
1816 if (raid
->magic_0
&& raid
->magic_0
!= meta
->magic_0
)
1818 raid
->magic_0
= meta
->magic_0
;
1819 raid
->type
= AR_T_RAID1
;
1820 disk_number
= (meta
->disk_number
> 0);
1823 case HPTV2_T_RAID01_RAID0
:
1825 if (meta
->order
& HPTV2_O_RAID0
) {
1826 if ((raid
->magic_0
&& raid
->magic_0
!= meta
->magic_0
) ||
1827 (raid
->magic_1
&& raid
->magic_1
!= meta
->magic_1
))
1829 raid
->magic_0
= meta
->magic_0
;
1830 raid
->magic_1
= meta
->magic_1
;
1831 raid
->type
= AR_T_RAID01
;
1832 raid
->interleave
= 1 << meta
->stripe_shift
;
1833 disk_number
= meta
->disk_number
;
1836 if (raid
->magic_1
&& raid
->magic_1
!= meta
->magic_1
)
1838 raid
->magic_1
= meta
->magic_1
;
1839 raid
->type
= AR_T_RAID01
;
1840 raid
->interleave
= 1 << meta
->stripe_shift
;
1841 disk_number
= meta
->disk_number
+ meta
->array_width
;
1842 if (!(meta
->order
& HPTV2_O_RAID1
))
1843 meta
->magic
= 0; /* mark bad */
1848 if (raid
->magic_0
&& raid
->magic_0
!= meta
->magic_0
)
1850 raid
->magic_0
= meta
->magic_0
;
1851 raid
->type
= AR_T_SPAN
;
1852 disk_number
= meta
->disk_number
;
1856 device_printf(parent
, "Highpoint (v2) unknown RAID type 0x%02x\n",
1858 kfree(raidp
[array
], M_AR
);
1859 raidp
[array
] = NULL
;
1863 raid
->format
|= AR_F_HPTV2_RAID
;
1864 raid
->disks
[disk_number
].dev
= parent
;
1865 raid
->disks
[disk_number
].flags
= (AR_DF_PRESENT
| AR_DF_ASSIGNED
);
1867 strncpy(raid
->name
, meta
->name_1
,
1868 min(sizeof(raid
->name
), sizeof(meta
->name_1
)));
1869 if (meta
->magic
== HPTV2_MAGIC_OK
) {
1870 raid
->disks
[disk_number
].flags
|= AR_DF_ONLINE
;
1871 raid
->width
= meta
->array_width
;
1872 raid
->total_sectors
= meta
->total_sectors
;
1875 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
1876 raid
->offset_sectors
= HPTV2_LBA(parent
) + 1;
1877 raid
->rebuild_lba
= meta
->rebuild_lba
;
1878 raid
->disks
[disk_number
].sectors
=
1879 raid
->total_sectors
/ raid
->width
;
1882 raid
->disks
[disk_number
].flags
&= ~AR_DF_ONLINE
;
1884 if ((raid
->type
& AR_T_RAID0
) && (raid
->total_disks
< raid
->width
))
1885 raid
->total_disks
= raid
->width
;
1886 if (disk_number
>= raid
->total_disks
)
1887 raid
->total_disks
= disk_number
+ 1;
1888 ars
->raid
[raid
->volume
] = raid
;
1889 ars
->disk_number
[raid
->volume
] = disk_number
;
1900 ata_raid_hptv2_write_meta(struct ar_softc
*rdp
)
1902 struct hptv2_raid_conf
*meta
;
1903 struct timeval timestamp
;
1904 int disk
, error
= 0;
1906 meta
= (struct hptv2_raid_conf
*)kmalloc(sizeof(struct hptv2_raid_conf
),
1907 M_AR
, M_WAITOK
| M_ZERO
);
1909 microtime(×tamp
);
1910 rdp
->magic_0
= timestamp
.tv_sec
+ 2;
1911 rdp
->magic_1
= timestamp
.tv_sec
;
1913 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
1914 if ((rdp
->disks
[disk
].flags
& (AR_DF_PRESENT
| AR_DF_ONLINE
)) ==
1915 (AR_DF_PRESENT
| AR_DF_ONLINE
))
1916 meta
->magic
= HPTV2_MAGIC_OK
;
1917 if (rdp
->disks
[disk
].flags
& AR_DF_ASSIGNED
) {
1918 meta
->magic_0
= rdp
->magic_0
;
1919 if (strlen(rdp
->name
))
1920 strncpy(meta
->name_1
, rdp
->name
, sizeof(meta
->name_1
));
1922 strcpy(meta
->name_1
, "FreeBSD");
1924 meta
->disk_number
= disk
;
1926 switch (rdp
->type
) {
1928 meta
->type
= HPTV2_T_RAID0
;
1929 strcpy(meta
->name_2
, "RAID 0");
1930 if (rdp
->disks
[disk
].flags
& AR_DF_ONLINE
)
1931 meta
->order
= HPTV2_O_OK
;
1935 meta
->type
= HPTV2_T_RAID0
;
1936 strcpy(meta
->name_2
, "RAID 1");
1937 meta
->disk_number
= (disk
< rdp
->width
) ? disk
: disk
+ 5;
1938 meta
->order
= HPTV2_O_RAID0
| HPTV2_O_OK
;
1942 meta
->type
= HPTV2_T_RAID01_RAID0
;
1943 strcpy(meta
->name_2
, "RAID 0+1");
1944 if (rdp
->disks
[disk
].flags
& AR_DF_ONLINE
) {
1945 if (disk
< rdp
->width
) {
1946 meta
->order
= (HPTV2_O_RAID0
| HPTV2_O_RAID1
);
1947 meta
->magic_0
= rdp
->magic_0
- 1;
1950 meta
->order
= HPTV2_O_RAID1
;
1951 meta
->disk_number
-= rdp
->width
;
1955 meta
->magic_0
= rdp
->magic_0
- 1;
1956 meta
->magic_1
= rdp
->magic_1
;
1960 meta
->type
= HPTV2_T_SPAN
;
1961 strcpy(meta
->name_2
, "SPAN");
1968 meta
->array_width
= rdp
->width
;
1969 meta
->stripe_shift
= (rdp
->width
> 1) ? (ffs(rdp
->interleave
)-1) : 0;
1970 meta
->total_sectors
= rdp
->total_sectors
;
1971 meta
->rebuild_lba
= rdp
->rebuild_lba
;
1972 if (testing
|| bootverbose
)
1973 ata_raid_hptv2_print_meta(meta
);
1974 if (rdp
->disks
[disk
].dev
) {
1975 if (ata_raid_rw(rdp
->disks
[disk
].dev
,
1976 HPTV2_LBA(rdp
->disks
[disk
].dev
), meta
,
1977 sizeof(struct promise_raid_conf
),
1978 ATA_R_WRITE
| ATA_R_DIRECT
)) {
1979 device_printf(rdp
->disks
[disk
].dev
, "write metadata failed\n");
1988 /* Highpoint V3 RocketRAID Metadata */
1990 ata_raid_hptv3_read_meta(device_t dev
, struct ar_softc
**raidp
)
1992 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
1993 device_t parent
= device_get_parent(dev
);
1994 struct hptv3_raid_conf
*meta
;
1995 struct ar_softc
*raid
= NULL
;
1996 int array
, disk_number
, retval
= 0;
1998 meta
= (struct hptv3_raid_conf
*)kmalloc(sizeof(struct hptv3_raid_conf
),
1999 M_AR
, M_WAITOK
| M_ZERO
);
2001 if (ata_raid_rw(parent
, HPTV3_LBA(parent
),
2002 meta
, sizeof(struct hptv3_raid_conf
), ATA_R_READ
)) {
2003 if (testing
|| bootverbose
)
2004 device_printf(parent
, "HighPoint (v3) read metadata failed\n");
2008 /* check if this is a HighPoint v3 RAID struct */
2009 if (meta
->magic
!= HPTV3_MAGIC
) {
2010 if (testing
|| bootverbose
)
2011 device_printf(parent
, "HighPoint (v3) check1 failed\n");
2015 /* check if there are any config_entries */
2016 if (meta
->config_entries
< 1) {
2017 if (testing
|| bootverbose
)
2018 device_printf(parent
, "HighPoint (v3) check2 failed\n");
2022 if (testing
|| bootverbose
)
2023 ata_raid_hptv3_print_meta(meta
);
2025 /* now convert HighPoint (v3) metadata into our generic form */
2026 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
2027 if (!raidp
[array
]) {
2029 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
2032 raid
= raidp
[array
];
2033 if (raid
->format
&& (raid
->format
!= AR_F_HPTV3_RAID
))
2036 if ((raid
->format
& AR_F_HPTV3_RAID
) && raid
->magic_0
!= meta
->magic_0
)
2039 switch (meta
->configs
[0].type
) {
2041 raid
->type
= AR_T_RAID0
;
2042 raid
->width
= meta
->configs
[0].total_disks
;
2043 disk_number
= meta
->configs
[0].disk_number
;
2047 raid
->type
= AR_T_RAID1
;
2048 raid
->width
= meta
->configs
[0].total_disks
/ 2;
2049 disk_number
= meta
->configs
[0].disk_number
;
2053 raid
->type
= AR_T_RAID5
;
2054 raid
->width
= meta
->configs
[0].total_disks
;
2055 disk_number
= meta
->configs
[0].disk_number
;
2059 raid
->type
= AR_T_SPAN
;
2060 raid
->width
= meta
->configs
[0].total_disks
;
2061 disk_number
= meta
->configs
[0].disk_number
;
2065 device_printf(parent
, "Highpoint (v3) unknown RAID type 0x%02x\n",
2066 meta
->configs
[0].type
);
2067 kfree(raidp
[array
], M_AR
);
2068 raidp
[array
] = NULL
;
2071 if (meta
->config_entries
== 2) {
2072 switch (meta
->configs
[1].type
) {
2074 if (raid
->type
== AR_T_RAID0
) {
2075 raid
->type
= AR_T_RAID01
;
2076 disk_number
= meta
->configs
[1].disk_number
+
2077 (meta
->configs
[0].disk_number
<< 1);
2081 device_printf(parent
, "Highpoint (v3) unknown level 2 0x%02x\n",
2082 meta
->configs
[1].type
);
2083 kfree(raidp
[array
], M_AR
);
2084 raidp
[array
] = NULL
;
2089 raid
->magic_0
= meta
->magic_0
;
2090 raid
->format
= AR_F_HPTV3_RAID
;
2091 raid
->generation
= meta
->timestamp
;
2092 raid
->interleave
= 1 << meta
->configs
[0].stripe_shift
;
2093 raid
->total_disks
= meta
->configs
[0].total_disks
+
2094 meta
->configs
[1].total_disks
;
2095 raid
->total_sectors
= meta
->configs
[0].total_sectors
+
2096 ((u_int64_t
)meta
->configs_high
[0].total_sectors
<< 32);
2099 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
2100 raid
->offset_sectors
= 0;
2101 raid
->rebuild_lba
= meta
->configs
[0].rebuild_lba
+
2102 ((u_int64_t
)meta
->configs_high
[0].rebuild_lba
<< 32);
2104 strncpy(raid
->name
, meta
->name
,
2105 min(sizeof(raid
->name
), sizeof(meta
->name
)));
2106 raid
->disks
[disk_number
].sectors
= raid
->total_sectors
/
2107 (raid
->type
== AR_T_RAID5
? raid
->width
- 1 : raid
->width
);
2108 raid
->disks
[disk_number
].dev
= parent
;
2109 raid
->disks
[disk_number
].flags
=
2110 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_ONLINE
);
2111 ars
->raid
[raid
->volume
] = raid
;
2112 ars
->disk_number
[raid
->volume
] = disk_number
;
2122 /* Intel MatrixRAID Metadata */
2124 ata_raid_intel_read_meta(device_t dev
, struct ar_softc
**raidp
)
2126 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
2127 device_t parent
= device_get_parent(dev
);
2128 struct intel_raid_conf
*meta
;
2129 struct intel_raid_mapping
*map
;
2130 struct ar_softc
*raid
= NULL
;
2131 u_int32_t checksum
, *ptr
;
2132 int array
, count
, disk
, volume
= 1, retval
= 0;
2135 meta
= (struct intel_raid_conf
*)kmalloc(1536, M_AR
, M_WAITOK
| M_ZERO
);
2137 if (ata_raid_rw(parent
, INTEL_LBA(parent
), meta
, 1024, ATA_R_READ
)) {
2138 if (testing
|| bootverbose
)
2139 device_printf(parent
, "Intel read metadata failed\n");
2143 bcopy(tmp
, tmp
+1024, 512);
2144 bcopy(tmp
+512, tmp
, 1024);
2145 bzero(tmp
+1024, 512);
2147 /* check if this is a Intel RAID struct */
2148 if (strncmp(meta
->intel_id
, INTEL_MAGIC
, strlen(INTEL_MAGIC
))) {
2149 if (testing
|| bootverbose
)
2150 device_printf(parent
, "Intel check1 failed\n");
2154 for (checksum
= 0, ptr
= (u_int32_t
*)meta
, count
= 0;
2155 count
< (meta
->config_size
/ sizeof(u_int32_t
)); count
++) {
2158 checksum
-= meta
->checksum
;
2159 if (checksum
!= meta
->checksum
) {
2160 if (testing
|| bootverbose
)
2161 device_printf(parent
, "Intel check2 failed\n");
2165 if (testing
|| bootverbose
)
2166 ata_raid_intel_print_meta(meta
);
2168 map
= (struct intel_raid_mapping
*)&meta
->disk
[meta
->total_disks
];
2170 /* now convert Intel metadata into our generic form */
2171 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
2172 if (!raidp
[array
]) {
2174 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
2177 raid
= raidp
[array
];
2178 if (raid
->format
&& (raid
->format
!= AR_F_INTEL_RAID
))
2181 if ((raid
->format
& AR_F_INTEL_RAID
) &&
2182 (raid
->magic_0
!= meta
->config_id
))
2186 * update our knowledge about the array config based on generation
2187 * NOTE: there can be multiple volumes on a disk set
2189 if (!meta
->generation
|| meta
->generation
> raid
->generation
) {
2190 switch (map
->type
) {
2192 raid
->type
= AR_T_RAID0
;
2193 raid
->width
= map
->total_disks
;
2197 if (map
->total_disks
== 4)
2198 raid
->type
= AR_T_RAID01
;
2200 raid
->type
= AR_T_RAID1
;
2201 raid
->width
= map
->total_disks
/ 2;
2205 raid
->type
= AR_T_RAID5
;
2206 raid
->width
= map
->total_disks
;
2210 device_printf(parent
, "Intel unknown RAID type 0x%02x\n",
2212 kfree(raidp
[array
], M_AR
);
2213 raidp
[array
] = NULL
;
2217 switch (map
->status
) {
2219 raid
->status
= AR_S_READY
;
2221 case INTEL_S_DEGRADED
:
2222 raid
->status
|= AR_S_DEGRADED
;
2224 case INTEL_S_DISABLED
:
2225 case INTEL_S_FAILURE
:
2229 raid
->magic_0
= meta
->config_id
;
2230 raid
->format
= AR_F_INTEL_RAID
;
2231 raid
->generation
= meta
->generation
;
2232 raid
->interleave
= map
->stripe_sectors
;
2233 raid
->total_disks
= map
->total_disks
;
2234 raid
->total_sectors
= map
->total_sectors
;
2237 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
2238 raid
->offset_sectors
= map
->offset
;
2239 raid
->rebuild_lba
= 0;
2241 raid
->volume
= volume
- 1;
2242 strncpy(raid
->name
, map
->name
,
2243 min(sizeof(raid
->name
), sizeof(map
->name
)));
2245 /* clear out any old info */
2246 for (disk
= 0; disk
< raid
->total_disks
; disk
++) {
2247 raid
->disks
[disk
].dev
= NULL
;
2248 bcopy(meta
->disk
[map
->disk_idx
[disk
]].serial
,
2249 raid
->disks
[disk
].serial
,
2250 sizeof(raid
->disks
[disk
].serial
));
2251 raid
->disks
[disk
].sectors
=
2252 meta
->disk
[map
->disk_idx
[disk
]].sectors
;
2253 raid
->disks
[disk
].flags
= 0;
2254 if (meta
->disk
[map
->disk_idx
[disk
]].flags
& INTEL_F_ONLINE
)
2255 raid
->disks
[disk
].flags
|= AR_DF_ONLINE
;
2256 if (meta
->disk
[map
->disk_idx
[disk
]].flags
& INTEL_F_ASSIGNED
)
2257 raid
->disks
[disk
].flags
|= AR_DF_ASSIGNED
;
2258 if (meta
->disk
[map
->disk_idx
[disk
]].flags
& INTEL_F_SPARE
) {
2259 raid
->disks
[disk
].flags
&= ~(AR_DF_ONLINE
| AR_DF_ASSIGNED
);
2260 raid
->disks
[disk
].flags
|= AR_DF_SPARE
;
2262 if (meta
->disk
[map
->disk_idx
[disk
]].flags
& INTEL_F_DOWN
)
2263 raid
->disks
[disk
].flags
&= ~AR_DF_ONLINE
;
2266 if (meta
->generation
>= raid
->generation
) {
2267 for (disk
= 0; disk
< raid
->total_disks
; disk
++) {
2268 struct ata_device
*atadev
= device_get_softc(parent
);
2270 if (!strncmp(raid
->disks
[disk
].serial
, atadev
->param
.serial
,
2271 sizeof(raid
->disks
[disk
].serial
))) {
2272 raid
->disks
[disk
].dev
= parent
;
2273 raid
->disks
[disk
].flags
|= (AR_DF_PRESENT
| AR_DF_ONLINE
);
2274 ars
->raid
[raid
->volume
] = raid
;
2275 ars
->disk_number
[raid
->volume
] = disk
;
2284 if (volume
< meta
->total_volumes
) {
2285 map
= (struct intel_raid_mapping
*)
2286 &map
->disk_idx
[map
->total_disks
];
2294 kfree(raidp
[array
], M_AR
);
2295 raidp
[array
] = NULL
;
2307 ata_raid_intel_write_meta(struct ar_softc
*rdp
)
2309 struct intel_raid_conf
*meta
;
2310 struct intel_raid_mapping
*map
;
2311 struct timeval timestamp
;
2312 u_int32_t checksum
, *ptr
;
2313 int count
, disk
, error
= 0;
2316 meta
= (struct intel_raid_conf
*)kmalloc(1536, M_AR
, M_WAITOK
| M_ZERO
);
2320 /* Generate a new config_id if none exists */
2321 if (!rdp
->magic_0
) {
2322 microtime(×tamp
);
2323 rdp
->magic_0
= timestamp
.tv_sec
^ timestamp
.tv_usec
;
2326 bcopy(INTEL_MAGIC
, meta
->intel_id
, sizeof(meta
->intel_id
));
2327 bcopy(INTEL_VERSION_1100
, meta
->version
, sizeof(meta
->version
));
2328 meta
->config_id
= rdp
->magic_0
;
2329 meta
->generation
= rdp
->generation
;
2330 meta
->total_disks
= rdp
->total_disks
;
2331 meta
->total_volumes
= 1; /* XXX SOS */
2332 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
2333 if (rdp
->disks
[disk
].dev
) {
2334 struct ata_channel
*ch
=
2335 device_get_softc(device_get_parent(rdp
->disks
[disk
].dev
));
2336 struct ata_device
*atadev
=
2337 device_get_softc(rdp
->disks
[disk
].dev
);
2339 bcopy(atadev
->param
.serial
, meta
->disk
[disk
].serial
,
2340 sizeof(rdp
->disks
[disk
].serial
));
2341 meta
->disk
[disk
].sectors
= rdp
->disks
[disk
].sectors
;
2342 meta
->disk
[disk
].id
= (ch
->unit
<< 16) | ATA_DEV(atadev
->unit
);
2345 meta
->disk
[disk
].sectors
= rdp
->total_sectors
/ rdp
->width
;
2346 meta
->disk
[disk
].flags
= 0;
2347 if (rdp
->disks
[disk
].flags
& AR_DF_SPARE
)
2348 meta
->disk
[disk
].flags
|= INTEL_F_SPARE
;
2350 if (rdp
->disks
[disk
].flags
& AR_DF_ONLINE
)
2351 meta
->disk
[disk
].flags
|= INTEL_F_ONLINE
;
2353 meta
->disk
[disk
].flags
|= INTEL_F_DOWN
;
2354 if (rdp
->disks
[disk
].flags
& AR_DF_ASSIGNED
)
2355 meta
->disk
[disk
].flags
|= INTEL_F_ASSIGNED
;
2358 map
= (struct intel_raid_mapping
*)&meta
->disk
[meta
->total_disks
];
2360 bcopy(rdp
->name
, map
->name
, sizeof(rdp
->name
));
2361 map
->total_sectors
= rdp
->total_sectors
;
2362 map
->state
= 12; /* XXX SOS */
2363 map
->offset
= rdp
->offset_sectors
;
2364 map
->stripe_count
= rdp
->total_sectors
/ (rdp
->interleave
*rdp
->total_disks
);
2365 map
->stripe_sectors
= rdp
->interleave
;
2366 map
->disk_sectors
= rdp
->total_sectors
/ rdp
->width
;
2367 map
->status
= INTEL_S_READY
; /* XXX SOS */
2368 switch (rdp
->type
) {
2370 map
->type
= INTEL_T_RAID0
;
2373 map
->type
= INTEL_T_RAID1
;
2376 map
->type
= INTEL_T_RAID1
;
2379 map
->type
= INTEL_T_RAID5
;
2385 map
->total_disks
= rdp
->total_disks
;
2386 map
->magic
[0] = 0x02;
2387 map
->magic
[1] = 0xff;
2388 map
->magic
[2] = 0x01;
2389 for (disk
= 0; disk
< rdp
->total_disks
; disk
++)
2390 map
->disk_idx
[disk
] = disk
;
2392 meta
->config_size
= (char *)&map
->disk_idx
[disk
] - (char *)meta
;
2393 for (checksum
= 0, ptr
= (u_int32_t
*)meta
, count
= 0;
2394 count
< (meta
->config_size
/ sizeof(u_int32_t
)); count
++) {
2397 meta
->checksum
= checksum
;
2399 if (testing
|| bootverbose
)
2400 ata_raid_intel_print_meta(meta
);
2403 bcopy(tmp
, tmp
+1024, 512);
2404 bcopy(tmp
+512, tmp
, 1024);
2405 bzero(tmp
+1024, 512);
2407 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
2408 if (rdp
->disks
[disk
].dev
) {
2409 if (ata_raid_rw(rdp
->disks
[disk
].dev
,
2410 INTEL_LBA(rdp
->disks
[disk
].dev
),
2411 meta
, 1024, ATA_R_WRITE
| ATA_R_DIRECT
)) {
2412 device_printf(rdp
->disks
[disk
].dev
, "write metadata failed\n");
2422 /* Integrated Technology Express Metadata */
2424 ata_raid_ite_read_meta(device_t dev
, struct ar_softc
**raidp
)
2426 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
2427 device_t parent
= device_get_parent(dev
);
2428 struct ite_raid_conf
*meta
;
2429 struct ar_softc
*raid
= NULL
;
2430 int array
, disk_number
, count
, retval
= 0;
2433 meta
= (struct ite_raid_conf
*)kmalloc(sizeof(struct ite_raid_conf
), M_AR
,
2436 if (ata_raid_rw(parent
, ITE_LBA(parent
),
2437 meta
, sizeof(struct ite_raid_conf
), ATA_R_READ
)) {
2438 if (testing
|| bootverbose
)
2439 device_printf(parent
, "ITE read metadata failed\n");
2443 /* check if this is a ITE RAID struct */
2444 for (ptr
= (u_int16_t
*)meta
->ite_id
, count
= 0;
2445 count
< sizeof(meta
->ite_id
)/sizeof(uint16_t); count
++)
2446 ptr
[count
] = be16toh(ptr
[count
]);
2448 if (strncmp(meta
->ite_id
, ITE_MAGIC
, strlen(ITE_MAGIC
))) {
2449 if (testing
|| bootverbose
)
2450 device_printf(parent
, "ITE check1 failed\n");
2454 if (testing
|| bootverbose
)
2455 ata_raid_ite_print_meta(meta
);
2457 /* now convert ITE metadata into our generic form */
2458 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
2459 if ((raid
= raidp
[array
])) {
2460 if (raid
->format
!= AR_F_ITE_RAID
)
2462 if (raid
->magic_0
!= *((u_int64_t
*)meta
->timestamp_0
))
2466 /* if we dont have a disks timestamp the RAID is invalidated */
2467 if (*((u_int64_t
*)meta
->timestamp_1
) == 0)
2471 raidp
[array
] = (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
),
2472 M_AR
, M_WAITOK
| M_ZERO
);
2475 switch (meta
->type
) {
2477 raid
->type
= AR_T_RAID0
;
2478 raid
->width
= meta
->array_width
;
2479 raid
->total_disks
= meta
->array_width
;
2480 disk_number
= meta
->disk_number
;
2484 raid
->type
= AR_T_RAID1
;
2486 raid
->total_disks
= 2;
2487 disk_number
= meta
->disk_number
;
2491 raid
->type
= AR_T_RAID01
;
2492 raid
->width
= meta
->array_width
;
2493 raid
->total_disks
= 4;
2494 disk_number
= ((meta
->disk_number
& 0x02) >> 1) |
2495 ((meta
->disk_number
& 0x01) << 1);
2499 raid
->type
= AR_T_SPAN
;
2501 raid
->total_disks
= meta
->array_width
;
2502 disk_number
= meta
->disk_number
;
2506 device_printf(parent
, "ITE unknown RAID type 0x%02x\n", meta
->type
);
2507 kfree(raidp
[array
], M_AR
);
2508 raidp
[array
] = NULL
;
2512 raid
->magic_0
= *((u_int64_t
*)meta
->timestamp_0
);
2513 raid
->format
= AR_F_ITE_RAID
;
2514 raid
->generation
= 0;
2515 raid
->interleave
= meta
->stripe_sectors
;
2516 raid
->total_sectors
= meta
->total_sectors
;
2519 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
2520 raid
->offset_sectors
= 0;
2521 raid
->rebuild_lba
= 0;
2524 raid
->disks
[disk_number
].dev
= parent
;
2525 raid
->disks
[disk_number
].sectors
= raid
->total_sectors
/ raid
->width
;
2526 raid
->disks
[disk_number
].flags
=
2527 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_ONLINE
);
2528 ars
->raid
[raid
->volume
] = raid
;
2529 ars
->disk_number
[raid
->volume
] = disk_number
;
2538 /* JMicron Technology Corp Metadata */
2540 ata_raid_jmicron_read_meta(device_t dev
, struct ar_softc
**raidp
)
2542 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
2543 device_t parent
= device_get_parent(dev
);
2544 struct jmicron_raid_conf
*meta
;
2545 struct ar_softc
*raid
= NULL
;
2546 u_int16_t checksum
, *ptr
;
2547 u_int64_t disk_size
;
2548 int count
, array
, disk
, total_disks
, retval
= 0;
2550 meta
= (struct jmicron_raid_conf
*)
2551 kmalloc(sizeof(struct jmicron_raid_conf
), M_AR
, M_WAITOK
| M_ZERO
);
2553 if (ata_raid_rw(parent
, JMICRON_LBA(parent
),
2554 meta
, sizeof(struct jmicron_raid_conf
), ATA_R_READ
)) {
2555 if (testing
|| bootverbose
)
2556 device_printf(parent
,
2557 "JMicron read metadata failed\n");
2560 /* check for JMicron signature */
2561 if (strncmp(meta
->signature
, JMICRON_MAGIC
, 2)) {
2562 if (testing
|| bootverbose
)
2563 device_printf(parent
, "JMicron check1 failed\n");
2567 /* calculate checksum and compare for valid */
2568 for (checksum
= 0, ptr
= (u_int16_t
*)meta
, count
= 0; count
< 64; count
++)
2571 if (testing
|| bootverbose
)
2572 device_printf(parent
, "JMicron check2 failed\n");
2576 if (testing
|| bootverbose
)
2577 ata_raid_jmicron_print_meta(meta
);
2579 /* now convert JMicron meta into our generic form */
2580 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
2582 if (!raidp
[array
]) {
2584 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
2587 raid
= raidp
[array
];
2588 if (raid
->format
&& (raid
->format
!= AR_F_JMICRON_RAID
))
2591 for (total_disks
= 0, disk
= 0; disk
< JM_MAX_DISKS
; disk
++) {
2592 if (meta
->disks
[disk
]) {
2593 if (raid
->format
== AR_F_JMICRON_RAID
) {
2594 if (bcmp(&meta
->disks
[disk
],
2595 raid
->disks
[disk
].serial
, sizeof(u_int32_t
))) {
2601 bcopy(&meta
->disks
[disk
],
2602 raid
->disks
[disk
].serial
, sizeof(u_int32_t
));
2606 /* handle spares XXX SOS */
2608 switch (meta
->type
) {
2610 raid
->type
= AR_T_RAID0
;
2611 raid
->width
= total_disks
;
2615 raid
->type
= AR_T_RAID1
;
2620 raid
->type
= AR_T_RAID01
;
2621 raid
->width
= total_disks
/ 2;
2625 raid
->type
= AR_T_RAID5
;
2626 raid
->width
= total_disks
;
2630 raid
->type
= AR_T_SPAN
;
2635 device_printf(parent
,
2636 "JMicron unknown RAID type 0x%02x\n", meta
->type
);
2637 kfree(raidp
[array
], M_AR
);
2638 raidp
[array
] = NULL
;
2641 disk_size
= (meta
->disk_sectors_high
<< 16) + meta
->disk_sectors_low
;
2642 raid
->format
= AR_F_JMICRON_RAID
;
2643 strncpy(raid
->name
, meta
->name
, sizeof(meta
->name
));
2644 raid
->generation
= 0;
2645 raid
->interleave
= 2 << meta
->stripe_shift
;
2646 raid
->total_disks
= total_disks
;
2647 raid
->total_sectors
= disk_size
* (raid
->width
-(raid
->type
==AR_RAID5
));
2650 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
2651 raid
->offset_sectors
= meta
->offset
* 16;
2652 raid
->rebuild_lba
= 0;
2655 for (disk
= 0; disk
< raid
->total_disks
; disk
++) {
2656 if (meta
->disks
[disk
] == meta
->disk_id
) {
2657 raid
->disks
[disk
].dev
= parent
;
2658 raid
->disks
[disk
].sectors
= disk_size
;
2659 raid
->disks
[disk
].flags
=
2660 (AR_DF_ONLINE
| AR_DF_PRESENT
| AR_DF_ASSIGNED
);
2661 ars
->raid
[raid
->volume
] = raid
;
2662 ars
->disk_number
[raid
->volume
] = disk
;
2675 ata_raid_jmicron_write_meta(struct ar_softc
*rdp
)
2677 struct jmicron_raid_conf
*meta
;
2678 u_int64_t disk_sectors
;
2679 int disk
, error
= 0;
2681 meta
= (struct jmicron_raid_conf
*)
2682 kmalloc(sizeof(struct jmicron_raid_conf
), M_AR
, M_WAITOK
| M_ZERO
);
2685 switch (rdp
->type
) {
2687 meta
->type
= JM_T_JBOD
;
2691 meta
->type
= JM_T_RAID0
;
2695 meta
->type
= JM_T_RAID1
;
2699 meta
->type
= JM_T_RAID5
;
2703 meta
->type
= JM_T_RAID01
;
2710 bcopy(JMICRON_MAGIC
, meta
->signature
, sizeof(JMICRON_MAGIC
));
2711 meta
->version
= JMICRON_VERSION
;
2712 meta
->offset
= rdp
->offset_sectors
/ 16;
2713 disk_sectors
= rdp
->total_sectors
/ (rdp
->width
- (rdp
->type
== AR_RAID5
));
2714 meta
->disk_sectors_low
= disk_sectors
& 0xffff;
2715 meta
->disk_sectors_high
= disk_sectors
>> 16;
2716 strncpy(meta
->name
, rdp
->name
, sizeof(meta
->name
));
2717 meta
->stripe_shift
= ffs(rdp
->interleave
) - 2;
2719 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
2720 if (rdp
->disks
[disk
].serial
[0])
2721 bcopy(rdp
->disks
[disk
].serial
,&meta
->disks
[disk
],sizeof(u_int32_t
));
2723 meta
->disks
[disk
] = (u_int32_t
)(uintptr_t)rdp
->disks
[disk
].dev
;
2726 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
2727 if (rdp
->disks
[disk
].dev
) {
2728 u_int16_t checksum
= 0, *ptr
;
2731 meta
->disk_id
= meta
->disks
[disk
];
2733 for (ptr
= (u_int16_t
*)meta
, count
= 0; count
< 64; count
++)
2735 meta
->checksum
-= checksum
;
2737 if (testing
|| bootverbose
)
2738 ata_raid_jmicron_print_meta(meta
);
2740 if (ata_raid_rw(rdp
->disks
[disk
].dev
,
2741 JMICRON_LBA(rdp
->disks
[disk
].dev
),
2742 meta
, sizeof(struct jmicron_raid_conf
),
2743 ATA_R_WRITE
| ATA_R_DIRECT
)) {
2744 device_printf(rdp
->disks
[disk
].dev
, "write metadata failed\n");
2749 /* handle spares XXX SOS */
2755 /* LSILogic V2 MegaRAID Metadata */
2757 ata_raid_lsiv2_read_meta(device_t dev
, struct ar_softc
**raidp
)
2759 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
2760 device_t parent
= device_get_parent(dev
);
2761 struct lsiv2_raid_conf
*meta
;
2762 struct ar_softc
*raid
= NULL
;
2763 int array
, retval
= 0;
2765 meta
= (struct lsiv2_raid_conf
*)kmalloc(sizeof(struct lsiv2_raid_conf
),
2766 M_AR
, M_WAITOK
| M_ZERO
);
2768 if (ata_raid_rw(parent
, LSIV2_LBA(parent
),
2769 meta
, sizeof(struct lsiv2_raid_conf
), ATA_R_READ
)) {
2770 if (testing
|| bootverbose
)
2771 device_printf(parent
, "LSI (v2) read metadata failed\n");
2775 /* check if this is a LSI RAID struct */
2776 if (strncmp(meta
->lsi_id
, LSIV2_MAGIC
, strlen(LSIV2_MAGIC
))) {
2777 if (testing
|| bootverbose
)
2778 device_printf(parent
, "LSI (v2) check1 failed\n");
2782 if (testing
|| bootverbose
)
2783 ata_raid_lsiv2_print_meta(meta
);
2785 /* now convert LSI (v2) config meta into our generic form */
2786 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
2787 int raid_entry
, conf_entry
;
2789 if (!raidp
[array
+ meta
->raid_number
]) {
2790 raidp
[array
+ meta
->raid_number
] =
2791 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
2794 raid
= raidp
[array
+ meta
->raid_number
];
2795 if (raid
->format
&& (raid
->format
!= AR_F_LSIV2_RAID
))
2798 if (raid
->magic_0
&&
2799 ((raid
->magic_0
!= meta
->timestamp
) ||
2800 (raid
->magic_1
!= meta
->raid_number
)))
2803 array
+= meta
->raid_number
;
2805 raid_entry
= meta
->raid_number
;
2806 conf_entry
= (meta
->configs
[raid_entry
].raid
.config_offset
>> 4) +
2807 meta
->disk_number
- 1;
2809 switch (meta
->configs
[raid_entry
].raid
.type
) {
2811 raid
->magic_0
= meta
->timestamp
;
2812 raid
->magic_1
= meta
->raid_number
;
2813 raid
->type
= AR_T_RAID0
;
2814 raid
->interleave
= meta
->configs
[raid_entry
].raid
.stripe_sectors
;
2815 raid
->width
= meta
->configs
[raid_entry
].raid
.array_width
;
2819 raid
->magic_0
= meta
->timestamp
;
2820 raid
->magic_1
= meta
->raid_number
;
2821 raid
->type
= AR_T_RAID1
;
2822 raid
->width
= meta
->configs
[raid_entry
].raid
.array_width
;
2825 case LSIV2_T_RAID0
| LSIV2_T_RAID1
:
2826 raid
->magic_0
= meta
->timestamp
;
2827 raid
->magic_1
= meta
->raid_number
;
2828 raid
->type
= AR_T_RAID01
;
2829 raid
->interleave
= meta
->configs
[raid_entry
].raid
.stripe_sectors
;
2830 raid
->width
= meta
->configs
[raid_entry
].raid
.array_width
;
2834 device_printf(parent
, "LSI v2 unknown RAID type 0x%02x\n",
2835 meta
->configs
[raid_entry
].raid
.type
);
2836 kfree(raidp
[array
], M_AR
);
2837 raidp
[array
] = NULL
;
2841 raid
->format
= AR_F_LSIV2_RAID
;
2842 raid
->generation
= 0;
2843 raid
->total_disks
= meta
->configs
[raid_entry
].raid
.disk_count
;
2844 raid
->total_sectors
= meta
->configs
[raid_entry
].raid
.total_sectors
;
2847 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
2848 raid
->offset_sectors
= 0;
2849 raid
->rebuild_lba
= 0;
2852 if (meta
->configs
[conf_entry
].disk
.device
!= LSIV2_D_NONE
) {
2853 raid
->disks
[meta
->disk_number
].dev
= parent
;
2854 raid
->disks
[meta
->disk_number
].sectors
=
2855 meta
->configs
[conf_entry
].disk
.disk_sectors
;
2856 raid
->disks
[meta
->disk_number
].flags
=
2857 (AR_DF_ONLINE
| AR_DF_PRESENT
| AR_DF_ASSIGNED
);
2858 ars
->raid
[raid
->volume
] = raid
;
2859 ars
->disk_number
[raid
->volume
] = meta
->disk_number
;
2863 raid
->disks
[meta
->disk_number
].flags
&= ~AR_DF_ONLINE
;
2873 /* LSILogic V3 MegaRAID Metadata */
2875 ata_raid_lsiv3_read_meta(device_t dev
, struct ar_softc
**raidp
)
2877 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
2878 device_t parent
= device_get_parent(dev
);
2879 struct lsiv3_raid_conf
*meta
;
2880 struct ar_softc
*raid
= NULL
;
2881 u_int8_t checksum
, *ptr
;
2882 int array
, entry
, count
, disk_number
, retval
= 0;
2884 meta
= (struct lsiv3_raid_conf
*)kmalloc(sizeof(struct lsiv3_raid_conf
),
2885 M_AR
, M_WAITOK
| M_ZERO
);
2887 if (ata_raid_rw(parent
, LSIV3_LBA(parent
),
2888 meta
, sizeof(struct lsiv3_raid_conf
), ATA_R_READ
)) {
2889 if (testing
|| bootverbose
)
2890 device_printf(parent
, "LSI (v3) read metadata failed\n");
2894 /* check if this is a LSI RAID struct */
2895 if (strncmp(meta
->lsi_id
, LSIV3_MAGIC
, strlen(LSIV3_MAGIC
))) {
2896 if (testing
|| bootverbose
)
2897 device_printf(parent
, "LSI (v3) check1 failed\n");
2901 /* check if the checksum is OK */
2902 for (checksum
= 0, ptr
= meta
->lsi_id
, count
= 0; count
< 512; count
++)
2905 if (testing
|| bootverbose
)
2906 device_printf(parent
, "LSI (v3) check2 failed\n");
2910 if (testing
|| bootverbose
)
2911 ata_raid_lsiv3_print_meta(meta
);
2913 /* now convert LSI (v3) config meta into our generic form */
2914 for (array
= 0, entry
= 0; array
< MAX_ARRAYS
&& entry
< 8;) {
2915 if (!raidp
[array
]) {
2917 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
2920 raid
= raidp
[array
];
2921 if (raid
->format
&& (raid
->format
!= AR_F_LSIV3_RAID
)) {
2926 if ((raid
->format
== AR_F_LSIV3_RAID
) &&
2927 (raid
->magic_0
!= meta
->timestamp
)) {
2932 switch (meta
->raid
[entry
].total_disks
) {
2937 if (meta
->raid
[entry
].device
== meta
->device
) {
2946 disk_number
= (meta
->device
& (LSIV3_D_DEVICE
|LSIV3_D_CHANNEL
))?1:0;
2949 device_printf(parent
, "lsiv3 > 2 disk support untested!!\n");
2950 disk_number
= (meta
->device
& LSIV3_D_DEVICE
? 1 : 0) +
2951 (meta
->device
& LSIV3_D_CHANNEL
? 2 : 0);
2955 switch (meta
->raid
[entry
].type
) {
2957 raid
->type
= AR_T_RAID0
;
2958 raid
->width
= meta
->raid
[entry
].total_disks
;
2962 raid
->type
= AR_T_RAID1
;
2963 raid
->width
= meta
->raid
[entry
].array_width
;
2967 device_printf(parent
, "LSI v3 unknown RAID type 0x%02x\n",
2968 meta
->raid
[entry
].type
);
2969 kfree(raidp
[array
], M_AR
);
2970 raidp
[array
] = NULL
;
2975 raid
->magic_0
= meta
->timestamp
;
2976 raid
->format
= AR_F_LSIV3_RAID
;
2977 raid
->generation
= 0;
2978 raid
->interleave
= meta
->raid
[entry
].stripe_pages
* 8;
2979 raid
->total_disks
= meta
->raid
[entry
].total_disks
;
2980 raid
->total_sectors
= raid
->width
* meta
->raid
[entry
].sectors
;
2983 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
2984 raid
->offset_sectors
= meta
->raid
[entry
].offset
;
2985 raid
->rebuild_lba
= 0;
2988 raid
->disks
[disk_number
].dev
= parent
;
2989 raid
->disks
[disk_number
].sectors
= raid
->total_sectors
/ raid
->width
;
2990 raid
->disks
[disk_number
].flags
=
2991 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_ONLINE
);
2992 ars
->raid
[raid
->volume
] = raid
;
2993 ars
->disk_number
[raid
->volume
] = disk_number
;
3004 /* nVidia MediaShield Metadata */
3006 ata_raid_nvidia_read_meta(device_t dev
, struct ar_softc
**raidp
)
3008 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
3009 device_t parent
= device_get_parent(dev
);
3010 struct nvidia_raid_conf
*meta
;
3011 struct ar_softc
*raid
= NULL
;
3012 u_int32_t checksum
, *ptr
;
3013 int array
, count
, retval
= 0;
3015 meta
= (struct nvidia_raid_conf
*)kmalloc(sizeof(struct nvidia_raid_conf
),
3016 M_AR
, M_WAITOK
| M_ZERO
);
3018 if (ata_raid_rw(parent
, NVIDIA_LBA(parent
),
3019 meta
, sizeof(struct nvidia_raid_conf
), ATA_R_READ
)) {
3020 if (testing
|| bootverbose
)
3021 device_printf(parent
, "nVidia read metadata failed\n");
3025 /* check if this is a nVidia RAID struct */
3026 if (strncmp(meta
->nvidia_id
, NV_MAGIC
, strlen(NV_MAGIC
))) {
3027 if (testing
|| bootverbose
)
3028 device_printf(parent
, "nVidia check1 failed\n");
3032 /* check if the checksum is OK */
3033 for (checksum
= 0, ptr
= (u_int32_t
*)meta
, count
= 0;
3034 count
< meta
->config_size
; count
++)
3037 if (testing
|| bootverbose
)
3038 device_printf(parent
, "nVidia check2 failed\n");
3042 if (testing
|| bootverbose
)
3043 ata_raid_nvidia_print_meta(meta
);
3045 /* now convert nVidia meta into our generic form */
3046 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
3047 if (!raidp
[array
]) {
3049 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
3052 raid
= raidp
[array
];
3053 if (raid
->format
&& (raid
->format
!= AR_F_NVIDIA_RAID
))
3056 if (raid
->format
== AR_F_NVIDIA_RAID
&&
3057 ((raid
->magic_0
!= meta
->magic_1
) ||
3058 (raid
->magic_1
!= meta
->magic_2
))) {
3062 switch (meta
->type
) {
3064 raid
->type
= AR_T_SPAN
;
3068 raid
->type
= AR_T_RAID0
;
3072 raid
->type
= AR_T_RAID1
;
3076 raid
->type
= AR_T_RAID5
;
3080 raid
->type
= AR_T_RAID01
;
3084 device_printf(parent
, "nVidia unknown RAID type 0x%02x\n",
3086 kfree(raidp
[array
], M_AR
);
3087 raidp
[array
] = NULL
;
3090 raid
->magic_0
= meta
->magic_1
;
3091 raid
->magic_1
= meta
->magic_2
;
3092 raid
->format
= AR_F_NVIDIA_RAID
;
3093 raid
->generation
= 0;
3094 raid
->interleave
= meta
->stripe_sectors
;
3095 raid
->width
= meta
->array_width
;
3096 raid
->total_disks
= meta
->total_disks
;
3097 raid
->total_sectors
= meta
->total_sectors
;
3100 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
3101 raid
->offset_sectors
= 0;
3102 raid
->rebuild_lba
= meta
->rebuild_lba
;
3104 raid
->status
= AR_S_READY
;
3105 if (meta
->status
& NV_S_DEGRADED
)
3106 raid
->status
|= AR_S_DEGRADED
;
3108 raid
->disks
[meta
->disk_number
].dev
= parent
;
3109 raid
->disks
[meta
->disk_number
].sectors
=
3110 raid
->total_sectors
/ raid
->width
;
3111 raid
->disks
[meta
->disk_number
].flags
=
3112 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_ONLINE
);
3113 ars
->raid
[raid
->volume
] = raid
;
3114 ars
->disk_number
[raid
->volume
] = meta
->disk_number
;
3124 /* Promise FastTrak Metadata */
3126 ata_raid_promise_read_meta(device_t dev
, struct ar_softc
**raidp
, int native
)
3128 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
3129 device_t parent
= device_get_parent(dev
);
3130 struct promise_raid_conf
*meta
;
3131 struct ar_softc
*raid
;
3132 u_int32_t checksum
, *ptr
;
3133 int array
, count
, disk
, disksum
= 0, retval
= 0;
3135 meta
= (struct promise_raid_conf
*)
3136 kmalloc(sizeof(struct promise_raid_conf
), M_AR
, M_WAITOK
| M_ZERO
);
3138 if (ata_raid_rw(parent
, PROMISE_LBA(parent
),
3139 meta
, sizeof(struct promise_raid_conf
), ATA_R_READ
)) {
3140 if (testing
|| bootverbose
)
3141 device_printf(parent
, "%s read metadata failed\n",
3142 native
? "FreeBSD" : "Promise");
3146 /* check the signature */
3148 if (strncmp(meta
->promise_id
, ATA_MAGIC
, strlen(ATA_MAGIC
))) {
3149 if (testing
|| bootverbose
)
3150 device_printf(parent
, "FreeBSD check1 failed\n");
3155 if (strncmp(meta
->promise_id
, PR_MAGIC
, strlen(PR_MAGIC
))) {
3156 if (testing
|| bootverbose
)
3157 device_printf(parent
, "Promise check1 failed\n");
3162 /* check if the checksum is OK */
3163 for (checksum
= 0, ptr
= (u_int32_t
*)meta
, count
= 0; count
< 511; count
++)
3165 if (checksum
!= *ptr
) {
3166 if (testing
|| bootverbose
)
3167 device_printf(parent
, "%s check2 failed\n",
3168 native
? "FreeBSD" : "Promise");
3172 /* check on disk integrity status */
3173 if (meta
->raid
.integrity
!= PR_I_VALID
) {
3174 if (testing
|| bootverbose
)
3175 device_printf(parent
, "%s check3 failed\n",
3176 native
? "FreeBSD" : "Promise");
3180 if (testing
|| bootverbose
)
3181 ata_raid_promise_print_meta(meta
);
3183 /* now convert Promise metadata into our generic form */
3184 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
3185 if (!raidp
[array
]) {
3187 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
3190 raid
= raidp
[array
];
3192 (raid
->format
!= (native
? AR_F_FREEBSD_RAID
: AR_F_PROMISE_RAID
)))
3195 if ((raid
->format
== (native
? AR_F_FREEBSD_RAID
: AR_F_PROMISE_RAID
))&&
3196 !(meta
->raid
.magic_1
== (raid
->magic_1
)))
3199 /* update our knowledge about the array config based on generation */
3200 if (!meta
->raid
.generation
|| meta
->raid
.generation
> raid
->generation
){
3201 switch (meta
->raid
.type
) {
3203 raid
->type
= AR_T_SPAN
;
3207 raid
->type
= AR_T_JBOD
;
3211 raid
->type
= AR_T_RAID0
;
3215 raid
->type
= AR_T_RAID1
;
3216 if (meta
->raid
.array_width
> 1)
3217 raid
->type
= AR_T_RAID01
;
3221 raid
->type
= AR_T_RAID5
;
3225 device_printf(parent
, "%s unknown RAID type 0x%02x\n",
3226 native
? "FreeBSD" : "Promise", meta
->raid
.type
);
3227 kfree(raidp
[array
], M_AR
);
3228 raidp
[array
] = NULL
;
3231 raid
->magic_1
= meta
->raid
.magic_1
;
3232 raid
->format
= (native
? AR_F_FREEBSD_RAID
: AR_F_PROMISE_RAID
);
3233 raid
->generation
= meta
->raid
.generation
;
3234 raid
->interleave
= 1 << meta
->raid
.stripe_shift
;
3235 raid
->width
= meta
->raid
.array_width
;
3236 raid
->total_disks
= meta
->raid
.total_disks
;
3237 raid
->heads
= meta
->raid
.heads
+ 1;
3238 raid
->sectors
= meta
->raid
.sectors
;
3239 raid
->cylinders
= meta
->raid
.cylinders
+ 1;
3240 raid
->total_sectors
= meta
->raid
.total_sectors
;
3241 raid
->offset_sectors
= 0;
3242 raid
->rebuild_lba
= meta
->raid
.rebuild_lba
;
3244 if ((meta
->raid
.status
&
3245 (PR_S_VALID
| PR_S_ONLINE
| PR_S_INITED
| PR_S_READY
)) ==
3246 (PR_S_VALID
| PR_S_ONLINE
| PR_S_INITED
| PR_S_READY
)) {
3247 raid
->status
|= AR_S_READY
;
3248 if (meta
->raid
.status
& PR_S_DEGRADED
)
3249 raid
->status
|= AR_S_DEGRADED
;
3252 raid
->status
&= ~AR_S_READY
;
3254 /* convert disk flags to our internal types */
3255 for (disk
= 0; disk
< meta
->raid
.total_disks
; disk
++) {
3256 raid
->disks
[disk
].dev
= NULL
;
3257 raid
->disks
[disk
].flags
= 0;
3258 *((u_int64_t
*)(raid
->disks
[disk
].serial
)) =
3259 meta
->raid
.disk
[disk
].magic_0
;
3260 disksum
+= meta
->raid
.disk
[disk
].flags
;
3261 if (meta
->raid
.disk
[disk
].flags
& PR_F_ONLINE
)
3262 raid
->disks
[disk
].flags
|= AR_DF_ONLINE
;
3263 if (meta
->raid
.disk
[disk
].flags
& PR_F_ASSIGNED
)
3264 raid
->disks
[disk
].flags
|= AR_DF_ASSIGNED
;
3265 if (meta
->raid
.disk
[disk
].flags
& PR_F_SPARE
) {
3266 raid
->disks
[disk
].flags
&= ~(AR_DF_ONLINE
| AR_DF_ASSIGNED
);
3267 raid
->disks
[disk
].flags
|= AR_DF_SPARE
;
3269 if (meta
->raid
.disk
[disk
].flags
& (PR_F_REDIR
| PR_F_DOWN
))
3270 raid
->disks
[disk
].flags
&= ~AR_DF_ONLINE
;
3273 device_printf(parent
, "%s subdisks has no flags\n",
3274 native
? "FreeBSD" : "Promise");
3275 kfree(raidp
[array
], M_AR
);
3276 raidp
[array
] = NULL
;
3280 if (meta
->raid
.generation
>= raid
->generation
) {
3281 int disk_number
= meta
->raid
.disk_number
;
3283 if (raid
->disks
[disk_number
].flags
&& (meta
->magic_0
==
3284 *((u_int64_t
*)(raid
->disks
[disk_number
].serial
)))) {
3285 raid
->disks
[disk_number
].dev
= parent
;
3286 raid
->disks
[disk_number
].flags
|= AR_DF_PRESENT
;
3287 raid
->disks
[disk_number
].sectors
= meta
->raid
.disk_sectors
;
3288 if ((raid
->disks
[disk_number
].flags
&
3289 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_ONLINE
)) ==
3290 (AR_DF_PRESENT
| AR_DF_ASSIGNED
| AR_DF_ONLINE
)) {
3291 ars
->raid
[raid
->volume
] = raid
;
3292 ars
->disk_number
[raid
->volume
] = disk_number
;
3306 ata_raid_promise_write_meta(struct ar_softc
*rdp
)
3308 struct promise_raid_conf
*meta
;
3309 struct timeval timestamp
;
3311 int count
, disk
, drive
, error
= 0;
3313 meta
= (struct promise_raid_conf
*)
3314 kmalloc(sizeof(struct promise_raid_conf
), M_AR
, M_WAITOK
);
3317 microtime(×tamp
);
3319 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
3320 for (count
= 0; count
< sizeof(struct promise_raid_conf
); count
++)
3321 *(((u_int8_t
*)meta
) + count
) = 255 - (count
% 256);
3322 meta
->dummy_0
= 0x00020000;
3323 meta
->raid
.disk_number
= disk
;
3325 if (rdp
->disks
[disk
].dev
) {
3326 struct ata_device
*atadev
= device_get_softc(rdp
->disks
[disk
].dev
);
3327 struct ata_channel
*ch
=
3328 device_get_softc(device_get_parent(rdp
->disks
[disk
].dev
));
3330 meta
->raid
.channel
= ch
->unit
;
3331 meta
->raid
.device
= ATA_DEV(atadev
->unit
);
3332 meta
->raid
.disk_sectors
= rdp
->disks
[disk
].sectors
;
3333 meta
->raid
.disk_offset
= rdp
->offset_sectors
;
3336 meta
->raid
.channel
= 0;
3337 meta
->raid
.device
= 0;
3338 meta
->raid
.disk_sectors
= 0;
3339 meta
->raid
.disk_offset
= 0;
3341 meta
->magic_0
= PR_MAGIC0(meta
->raid
) | timestamp
.tv_sec
;
3342 meta
->magic_1
= timestamp
.tv_sec
>> 16;
3343 meta
->magic_2
= timestamp
.tv_sec
;
3344 meta
->raid
.integrity
= PR_I_VALID
;
3345 meta
->raid
.magic_0
= meta
->magic_0
;
3346 meta
->raid
.rebuild_lba
= rdp
->rebuild_lba
;
3347 meta
->raid
.generation
= rdp
->generation
;
3349 if (rdp
->status
& AR_S_READY
) {
3350 meta
->raid
.flags
= (PR_F_VALID
| PR_F_ASSIGNED
| PR_F_ONLINE
);
3352 (PR_S_VALID
| PR_S_ONLINE
| PR_S_INITED
| PR_S_READY
);
3353 if (rdp
->status
& AR_S_DEGRADED
)
3354 meta
->raid
.status
|= PR_S_DEGRADED
;
3356 meta
->raid
.status
|= PR_S_FUNCTIONAL
;
3359 meta
->raid
.flags
= PR_F_DOWN
;
3360 meta
->raid
.status
= 0;
3363 switch (rdp
->type
) {
3365 meta
->raid
.type
= PR_T_RAID0
;
3368 meta
->raid
.type
= PR_T_RAID1
;
3371 meta
->raid
.type
= PR_T_RAID1
;
3374 meta
->raid
.type
= PR_T_RAID5
;
3377 meta
->raid
.type
= PR_T_SPAN
;
3380 meta
->raid
.type
= PR_T_JBOD
;
3387 meta
->raid
.total_disks
= rdp
->total_disks
;
3388 meta
->raid
.stripe_shift
= ffs(rdp
->interleave
) - 1;
3389 meta
->raid
.array_width
= rdp
->width
;
3390 meta
->raid
.array_number
= rdp
->lun
;
3391 meta
->raid
.total_sectors
= rdp
->total_sectors
;
3392 meta
->raid
.cylinders
= rdp
->cylinders
- 1;
3393 meta
->raid
.heads
= rdp
->heads
- 1;
3394 meta
->raid
.sectors
= rdp
->sectors
;
3395 meta
->raid
.magic_1
= (u_int64_t
)meta
->magic_2
<<16 | meta
->magic_1
;
3397 bzero(&meta
->raid
.disk
, 8 * 12);
3398 for (drive
= 0; drive
< rdp
->total_disks
; drive
++) {
3399 meta
->raid
.disk
[drive
].flags
= 0;
3400 if (rdp
->disks
[drive
].flags
& AR_DF_PRESENT
)
3401 meta
->raid
.disk
[drive
].flags
|= PR_F_VALID
;
3402 if (rdp
->disks
[drive
].flags
& AR_DF_ASSIGNED
)
3403 meta
->raid
.disk
[drive
].flags
|= PR_F_ASSIGNED
;
3404 if (rdp
->disks
[drive
].flags
& AR_DF_ONLINE
)
3405 meta
->raid
.disk
[drive
].flags
|= PR_F_ONLINE
;
3407 if (rdp
->disks
[drive
].flags
& AR_DF_PRESENT
)
3408 meta
->raid
.disk
[drive
].flags
= (PR_F_REDIR
| PR_F_DOWN
);
3409 if (rdp
->disks
[drive
].flags
& AR_DF_SPARE
)
3410 meta
->raid
.disk
[drive
].flags
|= PR_F_SPARE
;
3411 meta
->raid
.disk
[drive
].dummy_0
= 0x0;
3412 if (rdp
->disks
[drive
].dev
) {
3413 struct ata_channel
*ch
=
3414 device_get_softc(device_get_parent(rdp
->disks
[drive
].dev
));
3415 struct ata_device
*atadev
=
3416 device_get_softc(rdp
->disks
[drive
].dev
);
3418 meta
->raid
.disk
[drive
].channel
= ch
->unit
;
3419 meta
->raid
.disk
[drive
].device
= ATA_DEV(atadev
->unit
);
3421 meta
->raid
.disk
[drive
].magic_0
=
3422 PR_MAGIC0(meta
->raid
.disk
[drive
]) | timestamp
.tv_sec
;
3425 if (rdp
->disks
[disk
].dev
) {
3426 if ((rdp
->disks
[disk
].flags
& (AR_DF_PRESENT
| AR_DF_ONLINE
)) ==
3427 (AR_DF_PRESENT
| AR_DF_ONLINE
)) {
3428 if (rdp
->format
== AR_F_FREEBSD_RAID
)
3429 bcopy(ATA_MAGIC
, meta
->promise_id
, sizeof(ATA_MAGIC
));
3431 bcopy(PR_MAGIC
, meta
->promise_id
, sizeof(PR_MAGIC
));
3434 bzero(meta
->promise_id
, sizeof(meta
->promise_id
));
3436 for (ckptr
= (int32_t *)meta
, count
= 0; count
< 511; count
++)
3437 meta
->checksum
+= *ckptr
++;
3438 if (testing
|| bootverbose
)
3439 ata_raid_promise_print_meta(meta
);
3440 if (ata_raid_rw(rdp
->disks
[disk
].dev
,
3441 PROMISE_LBA(rdp
->disks
[disk
].dev
),
3442 meta
, sizeof(struct promise_raid_conf
),
3443 ATA_R_WRITE
| ATA_R_DIRECT
)) {
3444 device_printf(rdp
->disks
[disk
].dev
, "write metadata failed\n");
3453 /* Silicon Image Medley Metadata */
3455 ata_raid_sii_read_meta(device_t dev
, struct ar_softc
**raidp
)
3457 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
3458 device_t parent
= device_get_parent(dev
);
3459 struct sii_raid_conf
*meta
;
3460 struct ar_softc
*raid
= NULL
;
3461 u_int16_t checksum
, *ptr
;
3462 int array
, count
, disk
, retval
= 0;
3464 meta
= (struct sii_raid_conf
*)kmalloc(sizeof(struct sii_raid_conf
), M_AR
,
3467 if (ata_raid_rw(parent
, SII_LBA(parent
),
3468 meta
, sizeof(struct sii_raid_conf
), ATA_R_READ
)) {
3469 if (testing
|| bootverbose
)
3470 device_printf(parent
, "Silicon Image read metadata failed\n");
3474 /* check if this is a Silicon Image (Medley) RAID struct */
3475 for (checksum
= 0, ptr
= (u_int16_t
*)meta
, count
= 0; count
< 160; count
++)
3478 if (testing
|| bootverbose
)
3479 device_printf(parent
, "Silicon Image check1 failed\n");
3483 for (checksum
= 0, ptr
= (u_int16_t
*)meta
, count
= 0; count
< 256; count
++)
3485 if (checksum
!= meta
->checksum_1
) {
3486 if (testing
|| bootverbose
)
3487 device_printf(parent
, "Silicon Image check2 failed\n");
3492 if (meta
->version_major
!= 0x0002 ||
3493 (meta
->version_minor
!= 0x0000 && meta
->version_minor
!= 0x0001)) {
3494 if (testing
|| bootverbose
)
3495 device_printf(parent
, "Silicon Image check3 failed\n");
3499 if (testing
|| bootverbose
)
3500 ata_raid_sii_print_meta(meta
);
3502 /* now convert Silicon Image meta into our generic form */
3503 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
3504 if (!raidp
[array
]) {
3506 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
3509 raid
= raidp
[array
];
3510 if (raid
->format
&& (raid
->format
!= AR_F_SII_RAID
))
3513 if (raid
->format
== AR_F_SII_RAID
&&
3514 (raid
->magic_0
!= *((u_int64_t
*)meta
->timestamp
))) {
3518 /* update our knowledge about the array config based on generation */
3519 if (!meta
->generation
|| meta
->generation
> raid
->generation
) {
3520 switch (meta
->type
) {
3522 raid
->type
= AR_T_RAID0
;
3526 raid
->type
= AR_T_RAID1
;
3530 raid
->type
= AR_T_RAID01
;
3534 device_printf(parent
, "Silicon Image SPARE disk\n");
3535 kfree(raidp
[array
], M_AR
);
3536 raidp
[array
] = NULL
;
3540 device_printf(parent
,"Silicon Image unknown RAID type 0x%02x\n",
3542 kfree(raidp
[array
], M_AR
);
3543 raidp
[array
] = NULL
;
3546 raid
->magic_0
= *((u_int64_t
*)meta
->timestamp
);
3547 raid
->format
= AR_F_SII_RAID
;
3548 raid
->generation
= meta
->generation
;
3549 raid
->interleave
= meta
->stripe_sectors
;
3550 raid
->width
= (meta
->raid0_disks
!= 0xff) ? meta
->raid0_disks
: 1;
3552 ((meta
->raid0_disks
!= 0xff) ? meta
->raid0_disks
: 0) +
3553 ((meta
->raid1_disks
!= 0xff) ? meta
->raid1_disks
: 0);
3554 raid
->total_sectors
= meta
->total_sectors
;
3557 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
3558 raid
->offset_sectors
= 0;
3559 raid
->rebuild_lba
= meta
->rebuild_lba
;
3561 strncpy(raid
->name
, meta
->name
,
3562 min(sizeof(raid
->name
), sizeof(meta
->name
)));
3564 /* clear out any old info */
3565 if (raid
->generation
) {
3566 for (disk
= 0; disk
< raid
->total_disks
; disk
++) {
3567 raid
->disks
[disk
].dev
= NULL
;
3568 raid
->disks
[disk
].flags
= 0;
3572 if (meta
->generation
>= raid
->generation
) {
3573 /* XXX SOS add check for the right physical disk by serial# */
3574 if (meta
->status
& SII_S_READY
) {
3575 int disk_number
= (raid
->type
== AR_T_RAID01
) ?
3576 meta
->raid1_ident
+ (meta
->raid0_ident
<< 1) :
3579 raid
->disks
[disk_number
].dev
= parent
;
3580 raid
->disks
[disk_number
].sectors
=
3581 raid
->total_sectors
/ raid
->width
;
3582 raid
->disks
[disk_number
].flags
=
3583 (AR_DF_ONLINE
| AR_DF_PRESENT
| AR_DF_ASSIGNED
);
3584 ars
->raid
[raid
->volume
] = raid
;
3585 ars
->disk_number
[raid
->volume
] = disk_number
;
3597 /* Silicon Integrated Systems Metadata */
3599 ata_raid_sis_read_meta(device_t dev
, struct ar_softc
**raidp
)
3601 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
3602 device_t parent
= device_get_parent(dev
);
3603 struct sis_raid_conf
*meta
;
3604 struct ar_softc
*raid
= NULL
;
3605 int array
, disk_number
, drive
, retval
= 0;
3607 meta
= (struct sis_raid_conf
*)kmalloc(sizeof(struct sis_raid_conf
), M_AR
,
3610 if (ata_raid_rw(parent
, SIS_LBA(parent
),
3611 meta
, sizeof(struct sis_raid_conf
), ATA_R_READ
)) {
3612 if (testing
|| bootverbose
)
3613 device_printf(parent
,
3614 "Silicon Integrated Systems read metadata failed\n");
3617 /* check for SiS magic */
3618 if (meta
->magic
!= SIS_MAGIC
) {
3619 if (testing
|| bootverbose
)
3620 device_printf(parent
,
3621 "Silicon Integrated Systems check1 failed\n");
3625 if (testing
|| bootverbose
)
3626 ata_raid_sis_print_meta(meta
);
3628 /* now convert SiS meta into our generic form */
3629 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
3630 if (!raidp
[array
]) {
3632 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
3636 raid
= raidp
[array
];
3637 if (raid
->format
&& (raid
->format
!= AR_F_SIS_RAID
))
3640 if ((raid
->format
== AR_F_SIS_RAID
) &&
3641 ((raid
->magic_0
!= meta
->controller_pci_id
) ||
3642 (raid
->magic_1
!= meta
->timestamp
))) {
3646 switch (meta
->type_total_disks
& SIS_T_MASK
) {
3648 raid
->type
= AR_T_JBOD
;
3649 raid
->width
= (meta
->type_total_disks
& SIS_D_MASK
);
3650 raid
->total_sectors
+= SIS_LBA(parent
);
3654 raid
->type
= AR_T_RAID0
;
3655 raid
->width
= (meta
->type_total_disks
& SIS_D_MASK
);
3656 if (!raid
->total_sectors
||
3657 (raid
->total_sectors
> (raid
->width
* SIS_LBA(parent
))))
3658 raid
->total_sectors
= raid
->width
* SIS_LBA(parent
);
3662 raid
->type
= AR_T_RAID1
;
3664 if (!raid
->total_sectors
|| (raid
->total_sectors
> SIS_LBA(parent
)))
3665 raid
->total_sectors
= SIS_LBA(parent
);
3669 device_printf(parent
, "Silicon Integrated Systems "
3670 "unknown RAID type 0x%08x\n", meta
->magic
);
3671 kfree(raidp
[array
], M_AR
);
3672 raidp
[array
] = NULL
;
3675 raid
->magic_0
= meta
->controller_pci_id
;
3676 raid
->magic_1
= meta
->timestamp
;
3677 raid
->format
= AR_F_SIS_RAID
;
3678 raid
->generation
= 0;
3679 raid
->interleave
= meta
->stripe_sectors
;
3680 raid
->total_disks
= (meta
->type_total_disks
& SIS_D_MASK
);
3683 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
3684 raid
->offset_sectors
= 0;
3685 raid
->rebuild_lba
= 0;
3687 /* XXX SOS if total_disks > 2 this doesn't float */
3688 if (((meta
->disks
& SIS_D_MASTER
) >> 4) == meta
->disk_number
)
3693 for (drive
= 0; drive
< raid
->total_disks
; drive
++) {
3694 raid
->disks
[drive
].sectors
= raid
->total_sectors
/raid
->width
;
3695 if (drive
== disk_number
) {
3696 raid
->disks
[disk_number
].dev
= parent
;
3697 raid
->disks
[disk_number
].flags
=
3698 (AR_DF_ONLINE
| AR_DF_PRESENT
| AR_DF_ASSIGNED
);
3699 ars
->raid
[raid
->volume
] = raid
;
3700 ars
->disk_number
[raid
->volume
] = disk_number
;
3713 ata_raid_sis_write_meta(struct ar_softc
*rdp
)
3715 struct sis_raid_conf
*meta
;
3716 struct timeval timestamp
;
3717 int disk
, error
= 0;
3719 meta
= (struct sis_raid_conf
*)kmalloc(sizeof(struct sis_raid_conf
), M_AR
,
3723 microtime(×tamp
);
3725 meta
->magic
= SIS_MAGIC
;
3726 /* XXX SOS if total_disks > 2 this doesn't float */
3727 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
3728 if (rdp
->disks
[disk
].dev
) {
3729 struct ata_channel
*ch
=
3730 device_get_softc(device_get_parent(rdp
->disks
[disk
].dev
));
3731 struct ata_device
*atadev
= device_get_softc(rdp
->disks
[disk
].dev
);
3732 int disk_number
= 1 + ATA_DEV(atadev
->unit
) + (ch
->unit
<< 1);
3734 meta
->disks
|= disk_number
<< ((1 - disk
) << 2);
3737 switch (rdp
->type
) {
3739 meta
->type_total_disks
= SIS_T_JBOD
;
3743 meta
->type_total_disks
= SIS_T_RAID0
;
3747 meta
->type_total_disks
= SIS_T_RAID1
;
3754 meta
->type_total_disks
|= (rdp
->total_disks
& SIS_D_MASK
);
3755 meta
->stripe_sectors
= rdp
->interleave
;
3756 meta
->timestamp
= timestamp
.tv_sec
;
3758 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
3759 if (rdp
->disks
[disk
].dev
) {
3760 struct ata_channel
*ch
=
3761 device_get_softc(device_get_parent(rdp
->disks
[disk
].dev
));
3762 struct ata_device
*atadev
= device_get_softc(rdp
->disks
[disk
].dev
);
3764 meta
->controller_pci_id
=
3765 (pci_get_vendor(GRANDPARENT(rdp
->disks
[disk
].dev
)) << 16) |
3766 pci_get_device(GRANDPARENT(rdp
->disks
[disk
].dev
));
3767 bcopy(atadev
->param
.model
, meta
->model
, sizeof(meta
->model
));
3769 /* XXX SOS if total_disks > 2 this may not float */
3770 meta
->disk_number
= 1 + ATA_DEV(atadev
->unit
) + (ch
->unit
<< 1);
3772 if (testing
|| bootverbose
)
3773 ata_raid_sis_print_meta(meta
);
3775 if (ata_raid_rw(rdp
->disks
[disk
].dev
,
3776 SIS_LBA(rdp
->disks
[disk
].dev
),
3777 meta
, sizeof(struct sis_raid_conf
),
3778 ATA_R_WRITE
| ATA_R_DIRECT
)) {
3779 device_printf(rdp
->disks
[disk
].dev
, "write metadata failed\n");
3788 /* VIA Tech V-RAID Metadata */
3790 ata_raid_via_read_meta(device_t dev
, struct ar_softc
**raidp
)
3792 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
3793 device_t parent
= device_get_parent(dev
);
3794 struct via_raid_conf
*meta
;
3795 struct ar_softc
*raid
= NULL
;
3796 u_int8_t checksum
, *ptr
;
3797 int array
, count
, disk
, retval
= 0;
3799 meta
= (struct via_raid_conf
*)kmalloc(sizeof(struct via_raid_conf
), M_AR
,
3802 if (ata_raid_rw(parent
, VIA_LBA(parent
),
3803 meta
, sizeof(struct via_raid_conf
), ATA_R_READ
)) {
3804 if (testing
|| bootverbose
)
3805 device_printf(parent
, "VIA read metadata failed\n");
3809 /* check if this is a VIA RAID struct */
3810 if (meta
->magic
!= VIA_MAGIC
) {
3811 if (testing
|| bootverbose
)
3812 device_printf(parent
, "VIA check1 failed\n");
3816 /* calculate checksum and compare for valid */
3817 for (checksum
= 0, ptr
= (u_int8_t
*)meta
, count
= 0; count
< 50; count
++)
3819 if (checksum
!= meta
->checksum
) {
3820 if (testing
|| bootverbose
)
3821 device_printf(parent
, "VIA check2 failed\n");
3825 if (testing
|| bootverbose
)
3826 ata_raid_via_print_meta(meta
);
3828 /* now convert VIA meta into our generic form */
3829 for (array
= 0; array
< MAX_ARRAYS
; array
++) {
3830 if (!raidp
[array
]) {
3832 (struct ar_softc
*)kmalloc(sizeof(struct ar_softc
), M_AR
,
3835 raid
= raidp
[array
];
3836 if (raid
->format
&& (raid
->format
!= AR_F_VIA_RAID
))
3839 if (raid
->format
== AR_F_VIA_RAID
&& (raid
->magic_0
!= meta
->disks
[0]))
3842 switch (meta
->type
& VIA_T_MASK
) {
3844 raid
->type
= AR_T_RAID0
;
3845 raid
->width
= meta
->stripe_layout
& VIA_L_DISKS
;
3846 if (!raid
->total_sectors
||
3847 (raid
->total_sectors
> (raid
->width
* meta
->disk_sectors
)))
3848 raid
->total_sectors
= raid
->width
* meta
->disk_sectors
;
3852 raid
->type
= AR_T_RAID1
;
3854 raid
->total_sectors
= meta
->disk_sectors
;
3858 raid
->type
= AR_T_RAID01
;
3859 raid
->width
= meta
->stripe_layout
& VIA_L_DISKS
;
3860 if (!raid
->total_sectors
||
3861 (raid
->total_sectors
> (raid
->width
* meta
->disk_sectors
)))
3862 raid
->total_sectors
= raid
->width
* meta
->disk_sectors
;
3866 raid
->type
= AR_T_RAID5
;
3867 raid
->width
= meta
->stripe_layout
& VIA_L_DISKS
;
3868 if (!raid
->total_sectors
||
3869 (raid
->total_sectors
> ((raid
->width
- 1)*meta
->disk_sectors
)))
3870 raid
->total_sectors
= (raid
->width
- 1) * meta
->disk_sectors
;
3874 raid
->type
= AR_T_SPAN
;
3876 raid
->total_sectors
+= meta
->disk_sectors
;
3880 device_printf(parent
,"VIA unknown RAID type 0x%02x\n", meta
->type
);
3881 kfree(raidp
[array
], M_AR
);
3882 raidp
[array
] = NULL
;
3885 raid
->magic_0
= meta
->disks
[0];
3886 raid
->format
= AR_F_VIA_RAID
;
3887 raid
->generation
= 0;
3889 0x08 << ((meta
->stripe_layout
& VIA_L_MASK
) >> VIA_L_SHIFT
);
3890 for (count
= 0, disk
= 0; disk
< 8; disk
++)
3891 if (meta
->disks
[disk
])
3893 raid
->total_disks
= count
;
3896 raid
->cylinders
= raid
->total_sectors
/ (63 * 255);
3897 raid
->offset_sectors
= 0;
3898 raid
->rebuild_lba
= 0;
3901 for (disk
= 0; disk
< raid
->total_disks
; disk
++) {
3902 if (meta
->disks
[disk
] == meta
->disk_id
) {
3903 raid
->disks
[disk
].dev
= parent
;
3904 bcopy(&meta
->disk_id
, raid
->disks
[disk
].serial
,
3906 raid
->disks
[disk
].sectors
= meta
->disk_sectors
;
3907 raid
->disks
[disk
].flags
=
3908 (AR_DF_ONLINE
| AR_DF_PRESENT
| AR_DF_ASSIGNED
);
3909 ars
->raid
[raid
->volume
] = raid
;
3910 ars
->disk_number
[raid
->volume
] = disk
;
3924 ata_raid_via_write_meta(struct ar_softc
*rdp
)
3926 struct via_raid_conf
*meta
;
3927 int disk
, error
= 0;
3929 meta
= (struct via_raid_conf
*)kmalloc(sizeof(struct via_raid_conf
), M_AR
,
3934 meta
->magic
= VIA_MAGIC
;
3935 meta
->dummy_0
= 0x02;
3936 switch (rdp
->type
) {
3938 meta
->type
= VIA_T_SPAN
;
3939 meta
->stripe_layout
= (rdp
->total_disks
& VIA_L_DISKS
);
3943 meta
->type
= VIA_T_RAID0
;
3944 meta
->stripe_layout
= ((rdp
->interleave
>> 1) & VIA_L_MASK
);
3945 meta
->stripe_layout
|= (rdp
->total_disks
& VIA_L_DISKS
);
3949 meta
->type
= VIA_T_RAID1
;
3950 meta
->stripe_layout
= (rdp
->total_disks
& VIA_L_DISKS
);
3954 meta
->type
= VIA_T_RAID5
;
3955 meta
->stripe_layout
= ((rdp
->interleave
>> 1) & VIA_L_MASK
);
3956 meta
->stripe_layout
|= (rdp
->total_disks
& VIA_L_DISKS
);
3960 meta
->type
= VIA_T_RAID01
;
3961 meta
->stripe_layout
= ((rdp
->interleave
>> 1) & VIA_L_MASK
);
3962 meta
->stripe_layout
|= (rdp
->width
& VIA_L_DISKS
);
3969 meta
->type
|= VIA_T_BOOTABLE
; /* XXX SOS */
3970 meta
->disk_sectors
=
3971 rdp
->total_sectors
/ (rdp
->width
- (rdp
->type
== AR_RAID5
));
3972 for (disk
= 0; disk
< rdp
->total_disks
; disk
++)
3973 meta
->disks
[disk
] = (u_int32_t
)(uintptr_t)rdp
->disks
[disk
].dev
;
3975 for (disk
= 0; disk
< rdp
->total_disks
; disk
++) {
3976 if (rdp
->disks
[disk
].dev
) {
3980 meta
->disk_index
= disk
* sizeof(u_int32_t
);
3981 if (rdp
->type
== AR_T_RAID01
)
3982 meta
->disk_index
= ((meta
->disk_index
& 0x08) << 2) |
3983 (meta
->disk_index
& ~0x08);
3984 meta
->disk_id
= meta
->disks
[disk
];
3986 for (ptr
= (u_int8_t
*)meta
, count
= 0; count
< 50; count
++)
3987 meta
->checksum
+= *ptr
++;
3989 if (testing
|| bootverbose
)
3990 ata_raid_via_print_meta(meta
);
3992 if (ata_raid_rw(rdp
->disks
[disk
].dev
,
3993 VIA_LBA(rdp
->disks
[disk
].dev
),
3994 meta
, sizeof(struct via_raid_conf
),
3995 ATA_R_WRITE
| ATA_R_DIRECT
)) {
3996 device_printf(rdp
->disks
[disk
].dev
, "write metadata failed\n");
4005 static struct ata_request
*
4006 ata_raid_init_request(struct ar_softc
*rdp
, struct bio
*bio
)
4008 struct ata_request
*request
;
4010 if (!(request
= ata_alloc_request())) {
4011 kprintf("FAILURE - out of memory in ata_raid_init_request\n");
4014 request
->timeout
= ATA_DEFAULT_TIMEOUT
;
4015 request
->retries
= 2;
4016 request
->callback
= ata_raid_done
;
4017 request
->driver
= rdp
;
4019 switch (request
->bio
->bio_buf
->b_cmd
) {
4021 request
->flags
= ATA_R_READ
;
4024 request
->flags
= ATA_R_WRITE
;
4027 request
->flags
= ATA_R_CONTROL
;
4030 kprintf("ar%d: FAILURE - unknown BUF operation\n", rdp
->lun
);
4031 ata_free_request(request
);
4033 bio
->bio_buf
->b_flags
|= B_ERROR
;
4034 bio
->bio_buf
->b_error
= EIO
;
4043 ata_raid_send_request(struct ata_request
*request
)
4045 struct ata_device
*atadev
= device_get_softc(request
->dev
);
4047 request
->transfersize
= min(request
->bytecount
, atadev
->max_iosize
);
4048 if (request
->flags
& ATA_R_READ
) {
4049 if (atadev
->mode
>= ATA_DMA
) {
4050 request
->flags
|= ATA_R_DMA
;
4051 request
->u
.ata
.command
= ATA_READ_DMA
;
4053 else if (atadev
->max_iosize
> DEV_BSIZE
)
4054 request
->u
.ata
.command
= ATA_READ_MUL
;
4056 request
->u
.ata
.command
= ATA_READ
;
4058 else if (request
->flags
& ATA_R_WRITE
) {
4059 if (atadev
->mode
>= ATA_DMA
) {
4060 request
->flags
|= ATA_R_DMA
;
4061 request
->u
.ata
.command
= ATA_WRITE_DMA
;
4063 else if (atadev
->max_iosize
> DEV_BSIZE
)
4064 request
->u
.ata
.command
= ATA_WRITE_MUL
;
4066 request
->u
.ata
.command
= ATA_WRITE
;
4069 device_printf(request
->dev
, "FAILURE - unknown IO operation\n");
4070 ata_free_request(request
);
4073 request
->flags
|= (ATA_R_ORDERED
| ATA_R_THREAD
);
4074 ata_queue_request(request
);
4079 ata_raid_rw(device_t dev
, u_int64_t lba
, void *data
, u_int bcount
, int flags
)
4081 struct ata_device
*atadev
= device_get_softc(dev
);
4082 struct ata_request
*request
;
4085 if (bcount
% DEV_BSIZE
) {
4086 device_printf(dev
, "FAILURE - transfers must be modulo sectorsize\n");
4090 if (!(request
= ata_alloc_request())) {
4091 device_printf(dev
, "FAILURE - out of memory in ata_raid_rw\n");
4097 request
->timeout
= 10;
4098 request
->retries
= 0;
4099 request
->data
= data
;
4100 request
->bytecount
= bcount
;
4101 request
->transfersize
= DEV_BSIZE
;
4102 request
->u
.ata
.lba
= lba
;
4103 request
->u
.ata
.count
= request
->bytecount
/ DEV_BSIZE
;
4104 request
->flags
= flags
;
4106 if (flags
& ATA_R_READ
) {
4107 if (atadev
->mode
>= ATA_DMA
) {
4108 request
->u
.ata
.command
= ATA_READ_DMA
;
4109 request
->flags
|= ATA_R_DMA
;
4112 request
->u
.ata
.command
= ATA_READ
;
4113 ata_queue_request(request
);
4115 else if (flags
& ATA_R_WRITE
) {
4116 if (atadev
->mode
>= ATA_DMA
) {
4117 request
->u
.ata
.command
= ATA_WRITE_DMA
;
4118 request
->flags
|= ATA_R_DMA
;
4121 request
->u
.ata
.command
= ATA_WRITE
;
4122 ata_queue_request(request
);
4125 device_printf(dev
, "FAILURE - unknown IO operation\n");
4126 request
->result
= EIO
;
4128 error
= request
->result
;
4129 ata_free_request(request
);
4137 ata_raid_subdisk_probe(device_t dev
)
4144 ata_raid_subdisk_attach(device_t dev
)
4146 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
4149 for (volume
= 0; volume
< MAX_VOLUMES
; volume
++) {
4150 ars
->raid
[volume
] = NULL
;
4151 ars
->disk_number
[volume
] = -1;
4153 ata_raid_read_metadata(dev
);
4158 ata_raid_subdisk_detach(device_t dev
)
4160 struct ata_raid_subdisk
*ars
= device_get_softc(dev
);
4163 for (volume
= 0; volume
< MAX_VOLUMES
; volume
++) {
4164 if (ars
->raid
[volume
]) {
4165 ars
->raid
[volume
]->disks
[ars
->disk_number
[volume
]].flags
&=
4166 ~(AR_DF_PRESENT
| AR_DF_ONLINE
);
4167 ars
->raid
[volume
]->disks
[ars
->disk_number
[volume
]].dev
= NULL
;
4168 ata_raid_config_changed(ars
->raid
[volume
], 1);
4169 ars
->raid
[volume
] = NULL
;
4170 ars
->disk_number
[volume
] = -1;
4176 static device_method_t ata_raid_sub_methods
[] = {
4177 /* device interface */
4178 DEVMETHOD(device_probe
, ata_raid_subdisk_probe
),
4179 DEVMETHOD(device_attach
, ata_raid_subdisk_attach
),
4180 DEVMETHOD(device_detach
, ata_raid_subdisk_detach
),
4184 static driver_t ata_raid_sub_driver
= {
4186 ata_raid_sub_methods
,
4187 sizeof(struct ata_raid_subdisk
)
4190 DRIVER_MODULE(subdisk
, ad
, ata_raid_sub_driver
, ata_raid_sub_devclass
, NULL
, NULL
);
4193 ata_raid_module_event_handler(module_t mod
, int what
, void *arg
)
4199 if (testing
|| bootverbose
)
4200 kprintf("ATA PseudoRAID loaded\n");
4202 /* setup table to hold metadata for all ATA PseudoRAID arrays */
4203 ata_raid_arrays
= kmalloc(sizeof(struct ar_soft
*) * MAX_ARRAYS
,
4204 M_AR
, M_WAITOK
| M_ZERO
);
4206 /* attach found PseudoRAID arrays */
4207 for (i
= 0; i
< MAX_ARRAYS
; i
++) {
4208 struct ar_softc
*rdp
= ata_raid_arrays
[i
];
4210 if (!rdp
|| !rdp
->format
)
4212 if (testing
|| bootverbose
)
4213 ata_raid_print_meta(rdp
);
4214 ata_raid_attach(rdp
, 0);
4216 ata_raid_ioctl_func
= ata_raid_ioctl
;
4220 /* detach found PseudoRAID arrays */
4221 for (i
= 0; i
< MAX_ARRAYS
; i
++) {
4222 struct ar_softc
*rdp
= ata_raid_arrays
[i
];
4224 if (!rdp
|| !rdp
->status
)
4226 disk_destroy(&rdp
->disk
);
4228 if (testing
|| bootverbose
)
4229 kprintf("ATA PseudoRAID unloaded\n");
4231 kfree(ata_raid_arrays
, M_AR
);
4233 ata_raid_ioctl_func
= NULL
;
4241 static moduledata_t ata_raid_moduledata
=
4242 { "ataraid", ata_raid_module_event_handler
, NULL
};
4243 DECLARE_MODULE(ata
, ata_raid_moduledata
, SI_SUB_RAID
, SI_ORDER_FIRST
);
4244 MODULE_VERSION(ataraid
, 1);
4245 MODULE_DEPEND(ataraid
, ata
, 1, 1, 1);
4246 MODULE_DEPEND(ataraid
, ad
, 1, 1, 1);
4249 ata_raid_format(struct ar_softc
*rdp
)
4251 switch (rdp
->format
) {
4252 case AR_F_FREEBSD_RAID
: return "FreeBSD PseudoRAID";
4253 case AR_F_ADAPTEC_RAID
: return "Adaptec HostRAID";
4254 case AR_F_HPTV2_RAID
: return "HighPoint v2 RocketRAID";
4255 case AR_F_HPTV3_RAID
: return "HighPoint v3 RocketRAID";
4256 case AR_F_INTEL_RAID
: return "Intel MatrixRAID";
4257 case AR_F_ITE_RAID
: return "Integrated Technology Express";
4258 case AR_F_JMICRON_RAID
: return "JMicron Technology Corp";
4259 case AR_F_LSIV2_RAID
: return "LSILogic v2 MegaRAID";
4260 case AR_F_LSIV3_RAID
: return "LSILogic v3 MegaRAID";
4261 case AR_F_NVIDIA_RAID
: return "nVidia MediaShield";
4262 case AR_F_PROMISE_RAID
: return "Promise Fasttrak";
4263 case AR_F_SII_RAID
: return "Silicon Image Medley";
4264 case AR_F_SIS_RAID
: return "Silicon Integrated Systems";
4265 case AR_F_VIA_RAID
: return "VIA Tech V-RAID";
4266 default: return "UNKNOWN";
4271 ata_raid_type(struct ar_softc
*rdp
)
4273 switch (rdp
->type
) {
4274 case AR_T_JBOD
: return "JBOD";
4275 case AR_T_SPAN
: return "SPAN";
4276 case AR_T_RAID0
: return "RAID0";
4277 case AR_T_RAID1
: return "RAID1";
4278 case AR_T_RAID3
: return "RAID3";
4279 case AR_T_RAID4
: return "RAID4";
4280 case AR_T_RAID5
: return "RAID5";
4281 case AR_T_RAID01
: return "RAID0+1";
4282 default: return "UNKNOWN";
4287 ata_raid_flags(struct ar_softc
*rdp
)
4289 switch (rdp
->status
& (AR_S_READY
| AR_S_DEGRADED
| AR_S_REBUILDING
)) {
4290 case AR_S_READY
: return "READY";
4291 case AR_S_READY
| AR_S_DEGRADED
: return "DEGRADED";
4292 case AR_S_READY
| AR_S_REBUILDING
:
4293 case AR_S_READY
| AR_S_DEGRADED
| AR_S_REBUILDING
: return "REBUILDING";
4294 default: return "BROKEN";
4298 /* debugging gunk */
4300 ata_raid_print_meta(struct ar_softc
*raid
)
4304 kprintf("********** ATA PseudoRAID ar%d Metadata **********\n", raid
->lun
);
4305 kprintf("=================================================\n");
4306 kprintf("format %s\n", ata_raid_format(raid
));
4307 kprintf("type %s\n", ata_raid_type(raid
));
4308 kprintf("flags 0x%02x %b\n", raid
->status
, raid
->status
,
4309 "\20\3REBUILDING\2DEGRADED\1READY\n");
4310 kprintf("magic_0 0x%016jx\n", raid
->magic_0
);
4311 kprintf("magic_1 0x%016jx\n",raid
->magic_1
);
4312 kprintf("generation %u\n", raid
->generation
);
4313 kprintf("total_sectors %ju\n", raid
->total_sectors
);
4314 kprintf("offset_sectors %ju\n", raid
->offset_sectors
);
4315 kprintf("heads %u\n", raid
->heads
);
4316 kprintf("sectors %u\n", raid
->sectors
);
4317 kprintf("cylinders %u\n", raid
->cylinders
);
4318 kprintf("width %u\n", raid
->width
);
4319 kprintf("interleave %u\n", raid
->interleave
);
4320 kprintf("total_disks %u\n", raid
->total_disks
);
4321 for (i
= 0; i
< raid
->total_disks
; i
++) {
4322 kprintf(" disk %d: flags = 0x%02x %b\n", i
, raid
->disks
[i
].flags
,
4323 raid
->disks
[i
].flags
, "\20\4ONLINE\3SPARE\2ASSIGNED\1PRESENT\n");
4324 if (raid
->disks
[i
].dev
) {
4326 device_printf(raid
->disks
[i
].dev
, " sectors %jd\n",
4327 raid
->disks
[i
].sectors
);
4330 kprintf("=================================================\n");
4334 ata_raid_adaptec_type(int type
)
4336 static char buffer
[16];
4339 case ADP_T_RAID0
: return "RAID0";
4340 case ADP_T_RAID1
: return "RAID1";
4341 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4347 ata_raid_adaptec_print_meta(struct adaptec_raid_conf
*meta
)
4351 kprintf("********* ATA Adaptec HostRAID Metadata *********\n");
4352 kprintf("magic_0 <0x%08x>\n", be32toh(meta
->magic_0
));
4353 kprintf("generation 0x%08x\n", be32toh(meta
->generation
));
4354 kprintf("dummy_0 0x%04x\n", be16toh(meta
->dummy_0
));
4355 kprintf("total_configs %u\n", be16toh(meta
->total_configs
));
4356 kprintf("dummy_1 0x%04x\n", be16toh(meta
->dummy_1
));
4357 kprintf("checksum 0x%04x\n", be16toh(meta
->checksum
));
4358 kprintf("dummy_2 0x%08x\n", be32toh(meta
->dummy_2
));
4359 kprintf("dummy_3 0x%08x\n", be32toh(meta
->dummy_3
));
4360 kprintf("flags 0x%08x\n", be32toh(meta
->flags
));
4361 kprintf("timestamp 0x%08x\n", be32toh(meta
->timestamp
));
4362 kprintf("dummy_4 0x%08x 0x%08x 0x%08x 0x%08x\n",
4363 be32toh(meta
->dummy_4
[0]), be32toh(meta
->dummy_4
[1]),
4364 be32toh(meta
->dummy_4
[2]), be32toh(meta
->dummy_4
[3]));
4365 kprintf("dummy_5 0x%08x 0x%08x 0x%08x 0x%08x\n",
4366 be32toh(meta
->dummy_5
[0]), be32toh(meta
->dummy_5
[1]),
4367 be32toh(meta
->dummy_5
[2]), be32toh(meta
->dummy_5
[3]));
4369 for (i
= 0; i
< be16toh(meta
->total_configs
); i
++) {
4370 kprintf(" %d total_disks %u\n", i
,
4371 be16toh(meta
->configs
[i
].disk_number
));
4372 kprintf(" %d generation %u\n", i
,
4373 be16toh(meta
->configs
[i
].generation
));
4374 kprintf(" %d magic_0 0x%08x\n", i
,
4375 be32toh(meta
->configs
[i
].magic_0
));
4376 kprintf(" %d dummy_0 0x%02x\n", i
, meta
->configs
[i
].dummy_0
);
4377 kprintf(" %d type %s\n", i
,
4378 ata_raid_adaptec_type(meta
->configs
[i
].type
));
4379 kprintf(" %d dummy_1 0x%02x\n", i
, meta
->configs
[i
].dummy_1
);
4380 kprintf(" %d flags %d\n", i
,
4381 be32toh(meta
->configs
[i
].flags
));
4382 kprintf(" %d dummy_2 0x%02x\n", i
, meta
->configs
[i
].dummy_2
);
4383 kprintf(" %d dummy_3 0x%02x\n", i
, meta
->configs
[i
].dummy_3
);
4384 kprintf(" %d dummy_4 0x%02x\n", i
, meta
->configs
[i
].dummy_4
);
4385 kprintf(" %d dummy_5 0x%02x\n", i
, meta
->configs
[i
].dummy_5
);
4386 kprintf(" %d disk_number %u\n", i
,
4387 be32toh(meta
->configs
[i
].disk_number
));
4388 kprintf(" %d dummy_6 0x%08x\n", i
,
4389 be32toh(meta
->configs
[i
].dummy_6
));
4390 kprintf(" %d sectors %u\n", i
,
4391 be32toh(meta
->configs
[i
].sectors
));
4392 kprintf(" %d stripe_shift %u\n", i
,
4393 be16toh(meta
->configs
[i
].stripe_shift
));
4394 kprintf(" %d dummy_7 0x%08x\n", i
,
4395 be32toh(meta
->configs
[i
].dummy_7
));
4396 kprintf(" %d dummy_8 0x%08x 0x%08x 0x%08x 0x%08x\n", i
,
4397 be32toh(meta
->configs
[i
].dummy_8
[0]),
4398 be32toh(meta
->configs
[i
].dummy_8
[1]),
4399 be32toh(meta
->configs
[i
].dummy_8
[2]),
4400 be32toh(meta
->configs
[i
].dummy_8
[3]));
4401 kprintf(" %d name <%s>\n", i
, meta
->configs
[i
].name
);
4403 kprintf("magic_1 <0x%08x>\n", be32toh(meta
->magic_1
));
4404 kprintf("magic_2 <0x%08x>\n", be32toh(meta
->magic_2
));
4405 kprintf("magic_3 <0x%08x>\n", be32toh(meta
->magic_3
));
4406 kprintf("magic_4 <0x%08x>\n", be32toh(meta
->magic_4
));
4407 kprintf("=================================================\n");
4411 ata_raid_hptv2_type(int type
)
4413 static char buffer
[16];
4416 case HPTV2_T_RAID0
: return "RAID0";
4417 case HPTV2_T_RAID1
: return "RAID1";
4418 case HPTV2_T_RAID01_RAID0
: return "RAID01_RAID0";
4419 case HPTV2_T_SPAN
: return "SPAN";
4420 case HPTV2_T_RAID_3
: return "RAID3";
4421 case HPTV2_T_RAID_5
: return "RAID5";
4422 case HPTV2_T_JBOD
: return "JBOD";
4423 case HPTV2_T_RAID01_RAID1
: return "RAID01_RAID1";
4424 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4430 ata_raid_hptv2_print_meta(struct hptv2_raid_conf
*meta
)
4434 kprintf("****** ATA Highpoint V2 RocketRAID Metadata *****\n");
4435 kprintf("magic 0x%08x\n", meta
->magic
);
4436 kprintf("magic_0 0x%08x\n", meta
->magic_0
);
4437 kprintf("magic_1 0x%08x\n", meta
->magic_1
);
4438 kprintf("order 0x%08x\n", meta
->order
);
4439 kprintf("array_width %u\n", meta
->array_width
);
4440 kprintf("stripe_shift %u\n", meta
->stripe_shift
);
4441 kprintf("type %s\n", ata_raid_hptv2_type(meta
->type
));
4442 kprintf("disk_number %u\n", meta
->disk_number
);
4443 kprintf("total_sectors %u\n", meta
->total_sectors
);
4444 kprintf("disk_mode 0x%08x\n", meta
->disk_mode
);
4445 kprintf("boot_mode 0x%08x\n", meta
->boot_mode
);
4446 kprintf("boot_disk 0x%02x\n", meta
->boot_disk
);
4447 kprintf("boot_protect 0x%02x\n", meta
->boot_protect
);
4448 kprintf("log_entries 0x%02x\n", meta
->error_log_entries
);
4449 kprintf("log_index 0x%02x\n", meta
->error_log_index
);
4450 if (meta
->error_log_entries
) {
4451 kprintf(" timestamp reason disk status sectors lba\n");
4452 for (i
= meta
->error_log_index
;
4453 i
< meta
->error_log_index
+ meta
->error_log_entries
; i
++)
4454 kprintf(" 0x%08x 0x%02x 0x%02x 0x%02x 0x%02x 0x%08x\n",
4455 meta
->errorlog
[i
%32].timestamp
,
4456 meta
->errorlog
[i
%32].reason
,
4457 meta
->errorlog
[i
%32].disk
, meta
->errorlog
[i
%32].status
,
4458 meta
->errorlog
[i
%32].sectors
, meta
->errorlog
[i
%32].lba
);
4460 kprintf("rebuild_lba 0x%08x\n", meta
->rebuild_lba
);
4461 kprintf("dummy_1 0x%02x\n", meta
->dummy_1
);
4462 kprintf("name_1 <%.15s>\n", meta
->name_1
);
4463 kprintf("dummy_2 0x%02x\n", meta
->dummy_2
);
4464 kprintf("name_2 <%.15s>\n", meta
->name_2
);
4465 kprintf("=================================================\n");
4469 ata_raid_hptv3_type(int type
)
4471 static char buffer
[16];
4474 case HPTV3_T_SPARE
: return "SPARE";
4475 case HPTV3_T_JBOD
: return "JBOD";
4476 case HPTV3_T_SPAN
: return "SPAN";
4477 case HPTV3_T_RAID0
: return "RAID0";
4478 case HPTV3_T_RAID1
: return "RAID1";
4479 case HPTV3_T_RAID3
: return "RAID3";
4480 case HPTV3_T_RAID5
: return "RAID5";
4481 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4487 ata_raid_hptv3_print_meta(struct hptv3_raid_conf
*meta
)
4491 kprintf("****** ATA Highpoint V3 RocketRAID Metadata *****\n");
4492 kprintf("magic 0x%08x\n", meta
->magic
);
4493 kprintf("magic_0 0x%08x\n", meta
->magic_0
);
4494 kprintf("checksum_0 0x%02x\n", meta
->checksum_0
);
4495 kprintf("mode 0x%02x\n", meta
->mode
);
4496 kprintf("user_mode 0x%02x\n", meta
->user_mode
);
4497 kprintf("config_entries 0x%02x\n", meta
->config_entries
);
4498 for (i
= 0; i
< meta
->config_entries
; i
++) {
4499 kprintf("config %d:\n", i
);
4500 kprintf(" total_sectors %ju\n",
4501 meta
->configs
[0].total_sectors
+
4502 ((u_int64_t
)meta
->configs_high
[0].total_sectors
<< 32));
4503 kprintf(" type %s\n",
4504 ata_raid_hptv3_type(meta
->configs
[i
].type
));
4505 kprintf(" total_disks %u\n", meta
->configs
[i
].total_disks
);
4506 kprintf(" disk_number %u\n", meta
->configs
[i
].disk_number
);
4507 kprintf(" stripe_shift %u\n", meta
->configs
[i
].stripe_shift
);
4508 kprintf(" status %b\n", meta
->configs
[i
].status
,
4509 "\20\2RAID5\1NEED_REBUILD\n");
4510 kprintf(" critical_disks %u\n", meta
->configs
[i
].critical_disks
);
4511 kprintf(" rebuild_lba %ju\n",
4512 meta
->configs_high
[0].rebuild_lba
+
4513 ((u_int64_t
)meta
->configs_high
[0].rebuild_lba
<< 32));
4515 kprintf("name <%.16s>\n", meta
->name
);
4516 kprintf("timestamp 0x%08x\n", meta
->timestamp
);
4517 kprintf("description <%.16s>\n", meta
->description
);
4518 kprintf("creator <%.16s>\n", meta
->creator
);
4519 kprintf("checksum_1 0x%02x\n", meta
->checksum_1
);
4520 kprintf("dummy_0 0x%02x\n", meta
->dummy_0
);
4521 kprintf("dummy_1 0x%02x\n", meta
->dummy_1
);
4522 kprintf("flags %b\n", meta
->flags
,
4523 "\20\4RCACHE\3WCACHE\2NCQ\1TCQ\n");
4524 kprintf("=================================================\n");
4528 ata_raid_intel_type(int type
)
4530 static char buffer
[16];
4533 case INTEL_T_RAID0
: return "RAID0";
4534 case INTEL_T_RAID1
: return "RAID1";
4535 case INTEL_T_RAID5
: return "RAID5";
4536 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4542 ata_raid_intel_print_meta(struct intel_raid_conf
*meta
)
4544 struct intel_raid_mapping
*map
;
4547 kprintf("********* ATA Intel MatrixRAID Metadata *********\n");
4548 kprintf("intel_id <%.24s>\n", meta
->intel_id
);
4549 kprintf("version <%.6s>\n", meta
->version
);
4550 kprintf("checksum 0x%08x\n", meta
->checksum
);
4551 kprintf("config_size 0x%08x\n", meta
->config_size
);
4552 kprintf("config_id 0x%08x\n", meta
->config_id
);
4553 kprintf("generation 0x%08x\n", meta
->generation
);
4554 kprintf("total_disks %u\n", meta
->total_disks
);
4555 kprintf("total_volumes %u\n", meta
->total_volumes
);
4556 kprintf("DISK# serial disk_sectors disk_id flags\n");
4557 for (i
= 0; i
< meta
->total_disks
; i
++ ) {
4558 kprintf(" %d <%.16s> %u 0x%08x 0x%08x\n", i
,
4559 meta
->disk
[i
].serial
, meta
->disk
[i
].sectors
,
4560 meta
->disk
[i
].id
, meta
->disk
[i
].flags
);
4562 map
= (struct intel_raid_mapping
*)&meta
->disk
[meta
->total_disks
];
4563 for (j
= 0; j
< meta
->total_volumes
; j
++) {
4564 kprintf("name %.16s\n", map
->name
);
4565 kprintf("total_sectors %ju\n", map
->total_sectors
);
4566 kprintf("state %u\n", map
->state
);
4567 kprintf("reserved %u\n", map
->reserved
);
4568 kprintf("offset %u\n", map
->offset
);
4569 kprintf("disk_sectors %u\n", map
->disk_sectors
);
4570 kprintf("stripe_count %u\n", map
->stripe_count
);
4571 kprintf("stripe_sectors %u\n", map
->stripe_sectors
);
4572 kprintf("status %u\n", map
->status
);
4573 kprintf("type %s\n", ata_raid_intel_type(map
->type
));
4574 kprintf("total_disks %u\n", map
->total_disks
);
4575 kprintf("magic[0] 0x%02x\n", map
->magic
[0]);
4576 kprintf("magic[1] 0x%02x\n", map
->magic
[1]);
4577 kprintf("magic[2] 0x%02x\n", map
->magic
[2]);
4578 for (i
= 0; i
< map
->total_disks
; i
++ ) {
4579 kprintf(" disk %d at disk_idx 0x%08x\n", i
, map
->disk_idx
[i
]);
4581 map
= (struct intel_raid_mapping
*)&map
->disk_idx
[map
->total_disks
];
4583 kprintf("=================================================\n");
4587 ata_raid_ite_type(int type
)
4589 static char buffer
[16];
4592 case ITE_T_RAID0
: return "RAID0";
4593 case ITE_T_RAID1
: return "RAID1";
4594 case ITE_T_RAID01
: return "RAID0+1";
4595 case ITE_T_SPAN
: return "SPAN";
4596 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4602 ata_raid_ite_print_meta(struct ite_raid_conf
*meta
)
4604 kprintf("*** ATA Integrated Technology Express Metadata **\n");
4605 kprintf("ite_id <%.40s>\n", meta
->ite_id
);
4606 kprintf("timestamp_0 %04x/%02x/%02x %02x:%02x:%02x.%02x\n",
4607 *((u_int16_t
*)meta
->timestamp_0
), meta
->timestamp_0
[2],
4608 meta
->timestamp_0
[3], meta
->timestamp_0
[5], meta
->timestamp_0
[4],
4609 meta
->timestamp_0
[7], meta
->timestamp_0
[6]);
4610 kprintf("total_sectors %jd\n", meta
->total_sectors
);
4611 kprintf("type %s\n", ata_raid_ite_type(meta
->type
));
4612 kprintf("stripe_1kblocks %u\n", meta
->stripe_1kblocks
);
4613 kprintf("timestamp_1 %04x/%02x/%02x %02x:%02x:%02x.%02x\n",
4614 *((u_int16_t
*)meta
->timestamp_1
), meta
->timestamp_1
[2],
4615 meta
->timestamp_1
[3], meta
->timestamp_1
[5], meta
->timestamp_1
[4],
4616 meta
->timestamp_1
[7], meta
->timestamp_1
[6]);
4617 kprintf("stripe_sectors %u\n", meta
->stripe_sectors
);
4618 kprintf("array_width %u\n", meta
->array_width
);
4619 kprintf("disk_number %u\n", meta
->disk_number
);
4620 kprintf("disk_sectors %u\n", meta
->disk_sectors
);
4621 kprintf("=================================================\n");
4625 ata_raid_jmicron_type(int type
)
4627 static char buffer
[16];
4630 case JM_T_RAID0
: return "RAID0";
4631 case JM_T_RAID1
: return "RAID1";
4632 case JM_T_RAID01
: return "RAID0+1";
4633 case JM_T_JBOD
: return "JBOD";
4634 case JM_T_RAID5
: return "RAID5";
4635 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4641 ata_raid_jmicron_print_meta(struct jmicron_raid_conf
*meta
)
4645 kprintf("***** ATA JMicron Technology Corp Metadata ******\n");
4646 kprintf("signature %.2s\n", meta
->signature
);
4647 kprintf("version 0x%04x\n", meta
->version
);
4648 kprintf("checksum 0x%04x\n", meta
->checksum
);
4649 kprintf("disk_id 0x%08x\n", meta
->disk_id
);
4650 kprintf("offset 0x%08x\n", meta
->offset
);
4651 kprintf("disk_sectors_low 0x%08x\n", meta
->disk_sectors_low
);
4652 kprintf("disk_sectors_high 0x%08x\n", meta
->disk_sectors_high
);
4653 kprintf("name %.16s\n", meta
->name
);
4654 kprintf("type %s\n", ata_raid_jmicron_type(meta
->type
));
4655 kprintf("stripe_shift %d\n", meta
->stripe_shift
);
4656 kprintf("flags 0x%04x\n", meta
->flags
);
4657 kprintf("spare:\n");
4658 for (i
=0; i
< 2 && meta
->spare
[i
]; i
++)
4659 kprintf(" %d 0x%08x\n", i
, meta
->spare
[i
]);
4660 kprintf("disks:\n");
4661 for (i
=0; i
< 8 && meta
->disks
[i
]; i
++)
4662 kprintf(" %d 0x%08x\n", i
, meta
->disks
[i
]);
4663 kprintf("=================================================\n");
4667 ata_raid_lsiv2_type(int type
)
4669 static char buffer
[16];
4672 case LSIV2_T_RAID0
: return "RAID0";
4673 case LSIV2_T_RAID1
: return "RAID1";
4674 case LSIV2_T_SPARE
: return "SPARE";
4675 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4681 ata_raid_lsiv2_print_meta(struct lsiv2_raid_conf
*meta
)
4685 kprintf("******* ATA LSILogic V2 MegaRAID Metadata *******\n");
4686 kprintf("lsi_id <%s>\n", meta
->lsi_id
);
4687 kprintf("dummy_0 0x%02x\n", meta
->dummy_0
);
4688 kprintf("flags 0x%02x\n", meta
->flags
);
4689 kprintf("version 0x%04x\n", meta
->version
);
4690 kprintf("config_entries 0x%02x\n", meta
->config_entries
);
4691 kprintf("raid_count 0x%02x\n", meta
->raid_count
);
4692 kprintf("total_disks 0x%02x\n", meta
->total_disks
);
4693 kprintf("dummy_1 0x%02x\n", meta
->dummy_1
);
4694 kprintf("dummy_2 0x%04x\n", meta
->dummy_2
);
4695 for (i
= 0; i
< meta
->config_entries
; i
++) {
4696 kprintf(" type %s\n",
4697 ata_raid_lsiv2_type(meta
->configs
[i
].raid
.type
));
4698 kprintf(" dummy_0 %02x\n", meta
->configs
[i
].raid
.dummy_0
);
4699 kprintf(" stripe_sectors %u\n",
4700 meta
->configs
[i
].raid
.stripe_sectors
);
4701 kprintf(" array_width %u\n",
4702 meta
->configs
[i
].raid
.array_width
);
4703 kprintf(" disk_count %u\n", meta
->configs
[i
].raid
.disk_count
);
4704 kprintf(" config_offset %u\n",
4705 meta
->configs
[i
].raid
.config_offset
);
4706 kprintf(" dummy_1 %u\n", meta
->configs
[i
].raid
.dummy_1
);
4707 kprintf(" flags %02x\n", meta
->configs
[i
].raid
.flags
);
4708 kprintf(" total_sectors %u\n",
4709 meta
->configs
[i
].raid
.total_sectors
);
4711 kprintf("disk_number 0x%02x\n", meta
->disk_number
);
4712 kprintf("raid_number 0x%02x\n", meta
->raid_number
);
4713 kprintf("timestamp 0x%08x\n", meta
->timestamp
);
4714 kprintf("=================================================\n");
4718 ata_raid_lsiv3_type(int type
)
4720 static char buffer
[16];
4723 case LSIV3_T_RAID0
: return "RAID0";
4724 case LSIV3_T_RAID1
: return "RAID1";
4725 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4731 ata_raid_lsiv3_print_meta(struct lsiv3_raid_conf
*meta
)
4735 kprintf("******* ATA LSILogic V3 MegaRAID Metadata *******\n");
4736 kprintf("lsi_id <%.6s>\n", meta
->lsi_id
);
4737 kprintf("dummy_0 0x%04x\n", meta
->dummy_0
);
4738 kprintf("version 0x%04x\n", meta
->version
);
4739 kprintf("dummy_0 0x%04x\n", meta
->dummy_1
);
4740 kprintf("RAID configs:\n");
4741 for (i
= 0; i
< 8; i
++) {
4742 if (meta
->raid
[i
].total_disks
) {
4743 kprintf("%02d stripe_pages %u\n", i
,
4744 meta
->raid
[i
].stripe_pages
);
4745 kprintf("%02d type %s\n", i
,
4746 ata_raid_lsiv3_type(meta
->raid
[i
].type
));
4747 kprintf("%02d total_disks %u\n", i
,
4748 meta
->raid
[i
].total_disks
);
4749 kprintf("%02d array_width %u\n", i
,
4750 meta
->raid
[i
].array_width
);
4751 kprintf("%02d sectors %u\n", i
, meta
->raid
[i
].sectors
);
4752 kprintf("%02d offset %u\n", i
, meta
->raid
[i
].offset
);
4753 kprintf("%02d device 0x%02x\n", i
,
4754 meta
->raid
[i
].device
);
4757 kprintf("DISK configs:\n");
4758 for (i
= 0; i
< 6; i
++) {
4759 if (meta
->disk
[i
].disk_sectors
) {
4760 kprintf("%02d disk_sectors %u\n", i
,
4761 meta
->disk
[i
].disk_sectors
);
4762 kprintf("%02d flags 0x%02x\n", i
, meta
->disk
[i
].flags
);
4765 kprintf("device 0x%02x\n", meta
->device
);
4766 kprintf("timestamp 0x%08x\n", meta
->timestamp
);
4767 kprintf("checksum_1 0x%02x\n", meta
->checksum_1
);
4768 kprintf("=================================================\n");
4772 ata_raid_nvidia_type(int type
)
4774 static char buffer
[16];
4777 case NV_T_SPAN
: return "SPAN";
4778 case NV_T_RAID0
: return "RAID0";
4779 case NV_T_RAID1
: return "RAID1";
4780 case NV_T_RAID3
: return "RAID3";
4781 case NV_T_RAID5
: return "RAID5";
4782 case NV_T_RAID01
: return "RAID0+1";
4783 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4789 ata_raid_nvidia_print_meta(struct nvidia_raid_conf
*meta
)
4791 kprintf("******** ATA nVidia MediaShield Metadata ********\n");
4792 kprintf("nvidia_id <%.8s>\n", meta
->nvidia_id
);
4793 kprintf("config_size %d\n", meta
->config_size
);
4794 kprintf("checksum 0x%08x\n", meta
->checksum
);
4795 kprintf("version 0x%04x\n", meta
->version
);
4796 kprintf("disk_number %d\n", meta
->disk_number
);
4797 kprintf("dummy_0 0x%02x\n", meta
->dummy_0
);
4798 kprintf("total_sectors %d\n", meta
->total_sectors
);
4799 kprintf("sectors_size %d\n", meta
->sector_size
);
4800 kprintf("serial %.16s\n", meta
->serial
);
4801 kprintf("revision %.4s\n", meta
->revision
);
4802 kprintf("dummy_1 0x%08x\n", meta
->dummy_1
);
4803 kprintf("magic_0 0x%08x\n", meta
->magic_0
);
4804 kprintf("magic_1 0x%016jx\n", meta
->magic_1
);
4805 kprintf("magic_2 0x%016jx\n", meta
->magic_2
);
4806 kprintf("flags 0x%02x\n", meta
->flags
);
4807 kprintf("array_width %d\n", meta
->array_width
);
4808 kprintf("total_disks %d\n", meta
->total_disks
);
4809 kprintf("dummy_2 0x%02x\n", meta
->dummy_2
);
4810 kprintf("type %s\n", ata_raid_nvidia_type(meta
->type
));
4811 kprintf("dummy_3 0x%04x\n", meta
->dummy_3
);
4812 kprintf("stripe_sectors %d\n", meta
->stripe_sectors
);
4813 kprintf("stripe_bytes %d\n", meta
->stripe_bytes
);
4814 kprintf("stripe_shift %d\n", meta
->stripe_shift
);
4815 kprintf("stripe_mask 0x%08x\n", meta
->stripe_mask
);
4816 kprintf("stripe_sizesectors %d\n", meta
->stripe_sizesectors
);
4817 kprintf("stripe_sizebytes %d\n", meta
->stripe_sizebytes
);
4818 kprintf("rebuild_lba %d\n", meta
->rebuild_lba
);
4819 kprintf("dummy_4 0x%08x\n", meta
->dummy_4
);
4820 kprintf("dummy_5 0x%08x\n", meta
->dummy_5
);
4821 kprintf("status 0x%08x\n", meta
->status
);
4822 kprintf("=================================================\n");
4826 ata_raid_promise_type(int type
)
4828 static char buffer
[16];
4831 case PR_T_RAID0
: return "RAID0";
4832 case PR_T_RAID1
: return "RAID1";
4833 case PR_T_RAID3
: return "RAID3";
4834 case PR_T_RAID5
: return "RAID5";
4835 case PR_T_SPAN
: return "SPAN";
4836 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4842 ata_raid_promise_print_meta(struct promise_raid_conf
*meta
)
4846 kprintf("********* ATA Promise FastTrak Metadata *********\n");
4847 kprintf("promise_id <%s>\n", meta
->promise_id
);
4848 kprintf("dummy_0 0x%08x\n", meta
->dummy_0
);
4849 kprintf("magic_0 0x%016jx\n", meta
->magic_0
);
4850 kprintf("magic_1 0x%04x\n", meta
->magic_1
);
4851 kprintf("magic_2 0x%08x\n", meta
->magic_2
);
4852 kprintf("integrity 0x%08x %b\n", meta
->raid
.integrity
,
4853 meta
->raid
.integrity
, "\20\10VALID\n" );
4854 kprintf("flags 0x%02x %b\n",
4855 meta
->raid
.flags
, meta
->raid
.flags
,
4856 "\20\10READY\7DOWN\6REDIR\5DUPLICATE\4SPARE"
4857 "\3ASSIGNED\2ONLINE\1VALID\n");
4858 kprintf("disk_number %d\n", meta
->raid
.disk_number
);
4859 kprintf("channel 0x%02x\n", meta
->raid
.channel
);
4860 kprintf("device 0x%02x\n", meta
->raid
.device
);
4861 kprintf("magic_0 0x%016jx\n", meta
->raid
.magic_0
);
4862 kprintf("disk_offset %u\n", meta
->raid
.disk_offset
);
4863 kprintf("disk_sectors %u\n", meta
->raid
.disk_sectors
);
4864 kprintf("rebuild_lba 0x%08x\n", meta
->raid
.rebuild_lba
);
4865 kprintf("generation 0x%04x\n", meta
->raid
.generation
);
4866 kprintf("status 0x%02x %b\n",
4867 meta
->raid
.status
, meta
->raid
.status
,
4868 "\20\6MARKED\5DEGRADED\4READY\3INITED\2ONLINE\1VALID\n");
4869 kprintf("type %s\n", ata_raid_promise_type(meta
->raid
.type
));
4870 kprintf("total_disks %u\n", meta
->raid
.total_disks
);
4871 kprintf("stripe_shift %u\n", meta
->raid
.stripe_shift
);
4872 kprintf("array_width %u\n", meta
->raid
.array_width
);
4873 kprintf("array_number %u\n", meta
->raid
.array_number
);
4874 kprintf("total_sectors %u\n", meta
->raid
.total_sectors
);
4875 kprintf("cylinders %u\n", meta
->raid
.cylinders
);
4876 kprintf("heads %u\n", meta
->raid
.heads
);
4877 kprintf("sectors %u\n", meta
->raid
.sectors
);
4878 kprintf("magic_1 0x%016jx\n", meta
->raid
.magic_1
);
4879 kprintf("DISK# flags dummy_0 channel device magic_0\n");
4880 for (i
= 0; i
< 8; i
++) {
4881 kprintf(" %d %b 0x%02x 0x%02x 0x%02x ",
4882 i
, meta
->raid
.disk
[i
].flags
,
4883 "\20\10READY\7DOWN\6REDIR\5DUPLICATE\4SPARE"
4884 "\3ASSIGNED\2ONLINE\1VALID\n", meta
->raid
.disk
[i
].dummy_0
,
4885 meta
->raid
.disk
[i
].channel
, meta
->raid
.disk
[i
].device
);
4886 kprintf("0x%016jx\n", meta
->raid
.disk
[i
].magic_0
);
4888 kprintf("checksum 0x%08x\n", meta
->checksum
);
4889 kprintf("=================================================\n");
4893 ata_raid_sii_type(int type
)
4895 static char buffer
[16];
4898 case SII_T_RAID0
: return "RAID0";
4899 case SII_T_RAID1
: return "RAID1";
4900 case SII_T_RAID01
: return "RAID0+1";
4901 case SII_T_SPARE
: return "SPARE";
4902 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4908 ata_raid_sii_print_meta(struct sii_raid_conf
*meta
)
4910 kprintf("******* ATA Silicon Image Medley Metadata *******\n");
4911 kprintf("total_sectors %ju\n", meta
->total_sectors
);
4912 kprintf("dummy_0 0x%04x\n", meta
->dummy_0
);
4913 kprintf("dummy_1 0x%04x\n", meta
->dummy_1
);
4914 kprintf("controller_pci_id 0x%08x\n", meta
->controller_pci_id
);
4915 kprintf("version_minor 0x%04x\n", meta
->version_minor
);
4916 kprintf("version_major 0x%04x\n", meta
->version_major
);
4917 kprintf("timestamp 20%02x/%02x/%02x %02x:%02x:%02x\n",
4918 meta
->timestamp
[5], meta
->timestamp
[4], meta
->timestamp
[3],
4919 meta
->timestamp
[2], meta
->timestamp
[1], meta
->timestamp
[0]);
4920 kprintf("stripe_sectors %u\n", meta
->stripe_sectors
);
4921 kprintf("dummy_2 0x%04x\n", meta
->dummy_2
);
4922 kprintf("disk_number %u\n", meta
->disk_number
);
4923 kprintf("type %s\n", ata_raid_sii_type(meta
->type
));
4924 kprintf("raid0_disks %u\n", meta
->raid0_disks
);
4925 kprintf("raid0_ident %u\n", meta
->raid0_ident
);
4926 kprintf("raid1_disks %u\n", meta
->raid1_disks
);
4927 kprintf("raid1_ident %u\n", meta
->raid1_ident
);
4928 kprintf("rebuild_lba %ju\n", meta
->rebuild_lba
);
4929 kprintf("generation 0x%08x\n", meta
->generation
);
4930 kprintf("status 0x%02x %b\n",
4931 meta
->status
, meta
->status
,
4933 kprintf("base_raid1_position %02x\n", meta
->base_raid1_position
);
4934 kprintf("base_raid0_position %02x\n", meta
->base_raid0_position
);
4935 kprintf("position %02x\n", meta
->position
);
4936 kprintf("dummy_3 %04x\n", meta
->dummy_3
);
4937 kprintf("name <%.16s>\n", meta
->name
);
4938 kprintf("checksum_0 0x%04x\n", meta
->checksum_0
);
4939 kprintf("checksum_1 0x%04x\n", meta
->checksum_1
);
4940 kprintf("=================================================\n");
4944 ata_raid_sis_type(int type
)
4946 static char buffer
[16];
4949 case SIS_T_JBOD
: return "JBOD";
4950 case SIS_T_RAID0
: return "RAID0";
4951 case SIS_T_RAID1
: return "RAID1";
4952 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4958 ata_raid_sis_print_meta(struct sis_raid_conf
*meta
)
4960 kprintf("**** ATA Silicon Integrated Systems Metadata ****\n");
4961 kprintf("magic 0x%04x\n", meta
->magic
);
4962 kprintf("disks 0x%02x\n", meta
->disks
);
4963 kprintf("type %s\n",
4964 ata_raid_sis_type(meta
->type_total_disks
& SIS_T_MASK
));
4965 kprintf("total_disks %u\n", meta
->type_total_disks
& SIS_D_MASK
);
4966 kprintf("dummy_0 0x%08x\n", meta
->dummy_0
);
4967 kprintf("controller_pci_id 0x%08x\n", meta
->controller_pci_id
);
4968 kprintf("stripe_sectors %u\n", meta
->stripe_sectors
);
4969 kprintf("dummy_1 0x%04x\n", meta
->dummy_1
);
4970 kprintf("timestamp 0x%08x\n", meta
->timestamp
);
4971 kprintf("model %.40s\n", meta
->model
);
4972 kprintf("disk_number %u\n", meta
->disk_number
);
4973 kprintf("dummy_2 0x%02x 0x%02x 0x%02x\n",
4974 meta
->dummy_2
[0], meta
->dummy_2
[1], meta
->dummy_2
[2]);
4975 kprintf("=================================================\n");
4979 ata_raid_via_type(int type
)
4981 static char buffer
[16];
4984 case VIA_T_RAID0
: return "RAID0";
4985 case VIA_T_RAID1
: return "RAID1";
4986 case VIA_T_RAID5
: return "RAID5";
4987 case VIA_T_RAID01
: return "RAID0+1";
4988 case VIA_T_SPAN
: return "SPAN";
4989 default: ksprintf(buffer
, "UNKNOWN 0x%02x", type
);
4995 ata_raid_via_print_meta(struct via_raid_conf
*meta
)
4999 kprintf("*************** ATA VIA Metadata ****************\n");
5000 kprintf("magic 0x%02x\n", meta
->magic
);
5001 kprintf("dummy_0 0x%02x\n", meta
->dummy_0
);
5002 kprintf("type %s\n",
5003 ata_raid_via_type(meta
->type
& VIA_T_MASK
));
5004 kprintf("bootable %d\n", meta
->type
& VIA_T_BOOTABLE
);
5005 kprintf("unknown %d\n", meta
->type
& VIA_T_UNKNOWN
);
5006 kprintf("disk_index 0x%02x\n", meta
->disk_index
);
5007 kprintf("stripe_layout 0x%02x\n", meta
->stripe_layout
);
5008 kprintf(" stripe_disks %d\n", meta
->stripe_layout
& VIA_L_DISKS
);
5009 kprintf(" stripe_sectors %d\n",
5010 0x08 << ((meta
->stripe_layout
& VIA_L_MASK
) >> VIA_L_SHIFT
));
5011 kprintf("disk_sectors %ju\n", meta
->disk_sectors
);
5012 kprintf("disk_id 0x%08x\n", meta
->disk_id
);
5013 kprintf("DISK# disk_id\n");
5014 for (i
= 0; i
< 8; i
++) {
5016 kprintf(" %d 0x%08x\n", i
, meta
->disks
[i
]);
5018 kprintf("checksum 0x%02x\n", meta
->checksum
);
5019 kprintf("=================================================\n");