* Copyright (c) 2003 Wasabi Systems, Inc.

/* $NetBSD: ld_ataraid.c,v 1.52 2025/04/13 02:34:02 rin Exp $ */

/*
* Copyright (c) 2003 Wasabi Systems, Inc.
* All rights reserved.
*
* Written by Jason R. Thorpe for Wasabi Systems, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed for the NetBSD Project by
* Wasabi Systems, Inc.
* 4. The name of Wasabi Systems, Inc. may not be used to endorse
* or promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WASABI SYSTEMS, INC
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

/*
* Support for ATA RAID logical disks.
*
* Note that all the RAID happens in software here; the ATA RAID
* controllers we're dealing with (Promise, etc.) only support
* configuration data on the component disks, with the BIOS supporting
* booting from the RAID volumes.
*
* bio(4) support was written by Juan Romero Pardines <[email protected]>.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: ld_ataraid.c,v 1.52 2025/04/13 02:34:02 rin Exp $");

#if defined(_KERNEL_OPT)
#include "bio.h"
#endif

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/conf.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/buf.h>
#include <sys/bufq.h>
#include <sys/dkio.h>
#include <sys/disk.h>
#include <sys/disklabel.h>
#include <sys/fcntl.h>
#include <sys/vnode.h>
#include <sys/kauth.h>
#include <sys/module.h>
#if NBIO > 0
#include <dev/ata/atavar.h>
#include <dev/ata/atareg.h>
#include <dev/ata/wdvar.h>
#include <dev/biovar.h>
#include <dev/scsipi/scsipiconf.h> /* for scsipi_strvis() */
#endif

#include <miscfs/specfs/specdev.h>

#include <dev/ldvar.h>

#include <dev/ata/ata_raidvar.h>

#include "ioconf.h"

struct ld_ataraid_softc {
struct ld_softc sc_ld;

struct ataraid_array_info *sc_aai;
struct vnode *sc_vnodes[ATA_RAID_MAX_DISKS];

void (*sc_iodone)(struct buf *);

pool_cache_t sc_cbufpool;

SIMPLEQ_HEAD(, cbuf) sc_cbufq;

void *sc_sih_cookie;
};

static int ld_ataraid_match(device_t, cfdata_t, void *);
static void ld_ataraid_attach(device_t, device_t, void *);

static int ld_ataraid_dump(struct ld_softc *, void *, daddr_t, int);
static int ld_ataraid_ioctl(struct ld_softc *, u_long, void *, int32_t,
bool);

static int cbufpool_ctor(void *, void *, int);
static void cbufpool_dtor(void *, void *);

static void ld_ataraid_start_vstrategy(void *);
static int ld_ataraid_start_span(struct ld_softc *, struct buf *);

static int ld_ataraid_start_raid0(struct ld_softc *, struct buf *);
static void ld_ataraid_iodone_raid0(struct buf *);

#if NBIO > 0
static int ld_ataraid_bioctl(device_t, u_long, void *);
static int ld_ataraid_bioinq(struct ld_ataraid_softc *, struct bioc_inq *);
static int ld_ataraid_biovol(struct ld_ataraid_softc *, struct bioc_vol *);
static int ld_ataraid_biodisk(struct ld_ataraid_softc *,
struct bioc_disk *);
#endif

CFATTACH_DECL_NEW(ld_ataraid, sizeof(struct ld_ataraid_softc),
ld_ataraid_match, ld_ataraid_attach, NULL, NULL);

struct cbuf {
struct buf cb_buf; /* new I/O buf */
struct buf *cb_obp; /* ptr. to original I/O buf */
struct ld_ataraid_softc *cb_sc; /* pointer to ld softc */
u_int cb_comp; /* target component */
SIMPLEQ_ENTRY(cbuf) cb_q; /* fifo of component buffers */
struct cbuf *cb_other; /* other cbuf in case of mirror */
int cb_flags;
#define CBUF_IODONE 0x00000001 /* I/O is already successfully done */
};

#define CBUF_GET() pool_cache_get(sc->sc_cbufpool, PR_NOWAIT);
#define CBUF_PUT(cbp) pool_cache_put(sc->sc_cbufpool, (cbp))

static int
ld_ataraid_match(device_t parent, cfdata_t match, void *aux)
{

return (1);
}

static void
ld_ataraid_attach(device_t parent, device_t self, void *aux)
{
struct ld_ataraid_softc *sc = device_private(self);
struct ld_softc *ld = &sc->sc_ld;
struct ataraid_array_info *aai = aux;
struct ataraid_disk_info *adi = NULL;
const char *level;
struct vnode *vp;
char unklev[32];
u_int i;

ld->sc_dv = self;

sc->sc_cbufpool = pool_cache_init(sizeof(struct cbuf), 0,
0, 0, "ldcbuf", NULL, IPL_BIO, cbufpool_ctor, cbufpool_dtor, sc);
sc->sc_sih_cookie = softint_establish(SOFTINT_BIO,
ld_ataraid_start_vstrategy, sc);

sc->sc_aai = aai; /* this data persists */

ld->sc_maxxfer = MAXPHYS * aai->aai_width; /* XXX */
ld->sc_secperunit = aai->aai_capacity;
ld->sc_secsize = 512; /* XXX */
ld->sc_maxqueuecnt = 128; /* XXX */
ld->sc_dump = ld_ataraid_dump;
ld->sc_ioctl = ld_ataraid_ioctl;

switch (aai->aai_level) {
case AAI_L_SPAN:
level = "SPAN";
ld->sc_start = ld_ataraid_start_span;
sc->sc_iodone = ld_ataraid_iodone_raid0;
break;

case AAI_L_RAID0:
level = "RAID-0";
ld->sc_start = ld_ataraid_start_raid0;
sc->sc_iodone = ld_ataraid_iodone_raid0;
break;

case AAI_L_RAID1:
level = "RAID-1";
ld->sc_start = ld_ataraid_start_raid0;
sc->sc_iodone = ld_ataraid_iodone_raid0;
break;

case AAI_L_RAID0 | AAI_L_RAID1:
level = "RAID-10";
ld->sc_start = ld_ataraid_start_raid0;
sc->sc_iodone = ld_ataraid_iodone_raid0;
break;

default:
snprintf(unklev, sizeof(unklev), "<unknown level 0x%x>",
aai->aai_level);
level = unklev;
}

aprint_naive(": ATA %s array\n", level);
aprint_normal(": %s ATA %s array\n",
ata_raid_type_name(aai->aai_type), level);

if (ld->sc_start == NULL) {
aprint_error_dev(ld->sc_dv, "unsupported array type\n");
return;
}

/*
* We get a geometry from the device; use it.
*/
ld->sc_nheads = aai->aai_heads;
ld->sc_nsectors = aai->aai_sectors;
ld->sc_ncylinders = aai->aai_cylinders;

/*
* Configure all the component disks.
*/
for (i = 0; i < aai->aai_ndisks; i++) {
adi = &aai->aai_disks[i];
vp = NULL;
if (adi->adi_status &
(ADI_S_ONLINE | ADI_S_ASSIGNED | ADI_S_SPARE))
vp = ata_raid_disk_vnode_find(adi);

if (vp == NULL) {
/*
* XXX This is bogus. We should just mark the
* XXX component as FAILED, and write-back new
* XXX config blocks.
*/
break;
}
sc->sc_vnodes[i] = vp;
}
if (i == aai->aai_ndisks) {
ld->sc_flags = LDF_ENABLED;
goto finish;
}

for (i = 0; i < aai->aai_ndisks; i++) {
vp = sc->sc_vnodes[i];
sc->sc_vnodes[i] = NULL;
if (vp != NULL)
(void) vn_close(vp, FREAD|FWRITE, NOCRED);
}

finish:
#if NBIO > 0
if (bio_register(self, ld_ataraid_bioctl) != 0)
panic("%s: bioctl registration failed\n",
device_xname(ld->sc_dv));
#endif
SIMPLEQ_INIT(&sc->sc_cbufq);
ldattach(ld, BUFQ_DISK_DEFAULT_STRAT);
}

static int
cbufpool_ctor(void *arg, void *obj, int flags)
{
struct ld_ataraid_softc *sc = arg;
struct ld_softc *ld = &sc->sc_ld;
struct cbuf *cbp = obj;

/* We release/reacquire the spinlock before calling buf_init() */
mutex_exit(&ld->sc_mutex);
buf_init(&cbp->cb_buf);
mutex_enter(&ld->sc_mutex);

return 0;
}

static void
cbufpool_dtor(void *arg, void *obj)
{
struct cbuf *cbp = obj;

buf_destroy(&cbp->cb_buf);
}

static struct cbuf *
ld_ataraid_make_cbuf(struct ld_ataraid_softc *sc, struct buf *bp,
u_int comp, daddr_t bn, void *addr, long bcount)
{
struct cbuf *cbp;

cbp = CBUF_GET();
if (cbp == NULL)
return NULL;
cbp->cb_buf.b_flags = bp->b_flags;
cbp->cb_buf.b_oflags = bp->b_oflags;
cbp->cb_buf.b_cflags = bp->b_cflags;
cbp->cb_buf.b_iodone = sc->sc_iodone;
cbp->cb_buf.b_proc = bp->b_proc;
cbp->cb_buf.b_vp = sc->sc_vnodes[comp];
cbp->cb_buf.b_objlock = sc->sc_vnodes[comp]->v_interlock;
cbp->cb_buf.b_blkno = bn + sc->sc_aai->aai_offset;
cbp->cb_buf.b_data = addr;
cbp->cb_buf.b_bcount = bcount;

/* Context for iodone */
cbp->cb_obp = bp;
cbp->cb_sc = sc;
cbp->cb_comp = comp;
cbp->cb_other = NULL;
cbp->cb_flags = 0;

return cbp;
}

static void
ld_ataraid_start_vstrategy(void *arg)
{
struct ld_ataraid_softc *sc = arg;
struct cbuf *cbp;

while ((cbp = SIMPLEQ_FIRST(&sc->sc_cbufq)) != NULL) {
SIMPLEQ_REMOVE_HEAD(&sc->sc_cbufq, cb_q);
if ((cbp->cb_buf.b_flags & B_READ) == 0) {
mutex_enter(cbp->cb_buf.b_vp->v_interlock);
cbp->cb_buf.b_vp->v_numoutput++;
mutex_exit(cbp->cb_buf.b_vp->v_interlock);
}
VOP_STRATEGY(cbp->cb_buf.b_vp, &cbp->cb_buf);
}
}

static int
ld_ataraid_start_span(struct ld_softc *ld, struct buf *bp)
{
struct ld_ataraid_softc *sc = (void *) ld;
struct ataraid_array_info *aai = sc->sc_aai;
struct ataraid_disk_info *adi;
struct cbuf *cbp;
char *addr;
daddr_t bn;
long bcount, rcount;
u_int comp;

/* Allocate component buffers. */
addr = bp->b_data;

/* Find the first component. */
comp = 0;
adi = &aai->aai_disks[comp];
bn = bp->b_rawblkno;
while (bn >= adi->adi_compsize) {
bn -= adi->adi_compsize;
adi = &aai->aai_disks[++comp];
}

bp->b_resid = bp->b_bcount;

for (bcount = bp->b_bcount; bcount > 0; bcount -= rcount) {
rcount = bp->b_bcount;
if ((adi->adi_compsize - bn) < btodb(rcount))
rcount = dbtob(adi->adi_compsize - bn);

cbp = ld_ataraid_make_cbuf(sc, bp, comp, bn, addr, rcount);
if (cbp == NULL) {
/* Free the already allocated component buffers. */
while ((cbp = SIMPLEQ_FIRST(&sc->sc_cbufq)) != NULL) {
SIMPLEQ_REMOVE_HEAD(&sc->sc_cbufq, cb_q);
CBUF_PUT(cbp);
}
return EAGAIN;
}

/*
* For a span, we always know we advance to the next disk,
* and always start at offset 0 on that disk.
*/
adi = &aai->aai_disks[++comp];
bn = 0;

SIMPLEQ_INSERT_TAIL(&sc->sc_cbufq, cbp, cb_q);
addr += rcount;
}

/* Now fire off the requests. */
softint_schedule(sc->sc_sih_cookie);

return 0;
}

static int
ld_ataraid_start_raid0(struct ld_softc *ld, struct buf *bp)
{
struct ld_ataraid_softc *sc = (void *)ld;
struct ataraid_array_info *aai = sc->sc_aai;
struct ataraid_disk_info *adi;
struct cbuf *cbp, *other_cbp;
char *addr;
daddr_t bn, cbn, tbn, off;
long bcount, rcount;
u_int comp;
const int read = bp->b_flags & B_READ;
const int mirror = aai->aai_level & AAI_L_RAID1;
int error = 0;

/* Allocate component buffers. */
addr = bp->b_data;
bn = bp->b_rawblkno;

bp->b_resid = bp->b_bcount;

for (bcount = bp->b_bcount; bcount > 0; bcount -= rcount) {
tbn = bn / aai->aai_interleave;
off = bn % aai->aai_interleave;

if (__predict_false(tbn == aai->aai_capacity /
aai->aai_interleave)) {
/* Last stripe. */
daddr_t sz = (aai->aai_capacity -
(tbn * aai->aai_interleave)) /
aai->aai_width;
comp = off / sz;
cbn = ((tbn / aai->aai_width) * aai->aai_interleave) +
(off % sz);
rcount = uimin(bcount, dbtob(sz));
} else {
comp = tbn % aai->aai_width;
cbn = ((tbn / aai->aai_width) * aai->aai_interleave) +
off;
rcount = uimin(bcount, dbtob(aai->aai_interleave - off));
}

/*
* See if a component is valid.
*/
try_mirror:
adi = &aai->aai_disks[comp];
if ((adi->adi_status & ADI_S_ONLINE) == 0) {
if (mirror && comp < aai->aai_width) {
comp += aai->aai_width;
goto try_mirror;
}

/*
* No component available.
*/
error = EIO;
goto free_and_exit;
}

cbp = ld_ataraid_make_cbuf(sc, bp, comp, cbn, addr, rcount);
if (cbp == NULL) {
resource_shortage:
error = EAGAIN;
free_and_exit:
/* Free the already allocated component buffers. */
while ((cbp = SIMPLEQ_FIRST(&sc->sc_cbufq)) != NULL) {
SIMPLEQ_REMOVE_HEAD(&sc->sc_cbufq, cb_q);
CBUF_PUT(cbp);
}
return error;
}
SIMPLEQ_INSERT_TAIL(&sc->sc_cbufq, cbp, cb_q);
if (mirror && !read && comp < aai->aai_width) {
comp += aai->aai_width;
adi = &aai->aai_disks[comp];
if (adi->adi_status & ADI_S_ONLINE) {
other_cbp = ld_ataraid_make_cbuf(sc, bp,
comp, cbn, addr, rcount);
if (other_cbp == NULL)
goto resource_shortage;
SIMPLEQ_INSERT_TAIL(&sc->sc_cbufq,
other_cbp, cb_q);
other_cbp->cb_other = cbp;
cbp->cb_other = other_cbp;
}
}
bn += btodb(rcount);
addr += rcount;
}

/* Now fire off the requests. */
softint_schedule(sc->sc_sih_cookie);

return error;
}

/*
* Called at interrupt time. Mark the component as done and if all
* components are done, take an "interrupt".
*/
static void
ld_ataraid_iodone_raid0(struct buf *vbp)
{
struct cbuf *cbp = (struct cbuf *) vbp, *other_cbp;
struct buf *bp = cbp->cb_obp;
struct ld_ataraid_softc *sc = cbp->cb_sc;
struct ataraid_array_info *aai = sc->sc_aai;
struct ataraid_disk_info *adi;
long count;
int s, iodone;

s = splbio();
KERNEL_LOCK(1, NULL); /* XXXSMP */

iodone = cbp->cb_flags & CBUF_IODONE;
other_cbp = cbp->cb_other;
if (other_cbp != NULL)
/* You are alone */
other_cbp->cb_other = NULL;

if (cbp->cb_buf.b_error != 0) {
/*
* Mark this component broken.
*/
adi = &aai->aai_disks[cbp->cb_comp];
adi->adi_status &= ~ADI_S_ONLINE;

printf("%s: error %d on component %d (%s)\n",
device_xname(sc->sc_ld.sc_dv), bp->b_error, cbp->cb_comp,
device_xname(adi->adi_dev));

/*
* If we didn't see an error yet and we are reading
* RAID1 disk, try another component.
*/
if (bp->b_error == 0 &&
(cbp->cb_buf.b_flags & B_READ) != 0 &&
(aai->aai_level & AAI_L_RAID1) != 0 &&
cbp->cb_comp < aai->aai_width) {
cbp->cb_comp += aai->aai_width;
adi = &aai->aai_disks[cbp->cb_comp];
if (adi->adi_status & ADI_S_ONLINE) {
cbp->cb_buf.b_error = 0;
VOP_STRATEGY(cbp->cb_buf.b_vp, &cbp->cb_buf);
goto out;
}
}

if (iodone || other_cbp != NULL)
/*
* If I/O on other component successfully done
* or the I/O is still in progress, no need
* to tell an error to upper layer.
*/
;
else {
bp->b_error = cbp->cb_buf.b_error ?
cbp->cb_buf.b_error : EIO;
}

/* XXX Update component config blocks. */

} else {
/*
* If other I/O is still in progress, tell it that
* our I/O is successfully done.
*/
if (other_cbp != NULL)
other_cbp->cb_flags |= CBUF_IODONE;
}
count = cbp->cb_buf.b_bcount;
CBUF_PUT(cbp);

if (other_cbp != NULL)
goto out;

/* If all done, "interrupt". */
bp->b_resid -= count;
if (bp->b_resid < 0)
panic("ld_ataraid_iodone_raid0: count");
if (bp->b_resid == 0)
lddone(&sc->sc_ld, bp);

out:
KERNEL_UNLOCK_ONE(NULL); /* XXXSMP */
splx(s);
}

static int
ld_ataraid_dump(struct ld_softc *sc, void *data, daddr_t blkno, int blkcnt)
{

return (EIO);
}

#if NBIO > 0
static int
ld_ataraid_bioctl(device_t self, u_long cmd, void *addr)
{
struct ld_ataraid_softc *sc = device_private(self);
int error = 0;

switch (cmd) {
case BIOCINQ:
error = ld_ataraid_bioinq(sc, (struct bioc_inq *)addr);
break;
case BIOCVOL:
error = ld_ataraid_biovol(sc, (struct bioc_vol *)addr);
break;
case BIOCDISK:
error = ld_ataraid_biodisk(sc, (struct bioc_disk *)addr);
break;
default:
error = ENOTTY;
break;
}

return error;
}

static int
ld_ataraid_bioinq(struct ld_ataraid_softc *sc, struct bioc_inq *bi)
{
struct ataraid_array_info *aai = sc->sc_aai;

/* there's always one volume per ld device */
bi->bi_novol = 1;
bi->bi_nodisk = aai->aai_ndisks;

return 0;
}

static int
ld_ataraid_biovol(struct ld_ataraid_softc *sc, struct bioc_vol *bv)
{
struct ataraid_array_info *aai = sc->sc_aai;
struct ld_softc *ld = &sc->sc_ld;
#define to_kibytes(ld,s) (ld->sc_secsize*(s)/1024)

/* Fill in data for _this_ volume */
bv->bv_percent = -1;
bv->bv_seconds = 0;

switch (aai->aai_status) {
case AAI_S_READY:
bv->bv_status = BIOC_SVONLINE;
break;
case AAI_S_DEGRADED:
bv->bv_status = BIOC_SVDEGRADED;
break;
}

bv->bv_size = ld->sc_secsize * ld->sc_secperunit;

switch (aai->aai_level) {
case AAI_L_SPAN:
case AAI_L_RAID0:
bv->bv_stripe_size = to_kibytes(ld, aai->aai_interleave);
bv->bv_level = 0;
break;
case AAI_L_RAID1:
bv->bv_stripe_size = 0;
bv->bv_level = 1;
break;
case AAI_L_RAID5:
bv->bv_stripe_size = to_kibytes(ld, aai->aai_interleave);
bv->bv_level = 5;
break;
}

bv->bv_nodisk = aai->aai_ndisks;
strlcpy(bv->bv_dev, device_xname(ld->sc_dv), sizeof(bv->bv_dev));
if (aai->aai_name[0] != '\0')
strlcpy(bv->bv_vendor, aai->aai_name, sizeof(bv->bv_vendor));

return 0;
}

static int
ld_ataraid_biodisk(struct ld_ataraid_softc *sc, struct bioc_disk *bd)
{
struct ataraid_array_info *aai = sc->sc_aai;
struct ataraid_disk_info *adi;
struct ld_softc *ld = &sc->sc_ld;
struct atabus_softc *atabus;
struct wd_softc *wd;
char model[81], serial[41], rev[17];

/* sanity check */
if (bd->bd_diskid > aai->aai_ndisks)
return EINVAL;

adi = &aai->aai_disks[bd->bd_diskid];
atabus = device_private(device_parent(adi->adi_dev));
wd = device_private(adi->adi_dev);

/* fill in data for _this_ disk */
switch (adi->adi_status) {
case ADI_S_ONLINE | ADI_S_ASSIGNED:
bd->bd_status = BIOC_SDONLINE;
break;
case ADI_S_SPARE:
bd->bd_status = BIOC_SDHOTSPARE;
break;
default:
bd->bd_status = BIOC_SDOFFLINE;
break;
}

bd->bd_channel = 0;
bd->bd_target = atabus->sc_chan->ch_channel;
bd->bd_lun = 0;
bd->bd_size = (wd->sc_capacity * ld->sc_secsize) - aai->aai_reserved;

strlcpy(bd->bd_procdev, device_xname(adi->adi_dev),
sizeof(bd->bd_procdev));

strnvisx(serial, sizeof(serial), wd->sc_params.atap_serial,
sizeof(wd->sc_params.atap_serial), VIS_TRIM|VIS_SAFE|VIS_OCTAL);
strnvisx(model, sizeof(model), wd->sc_params.atap_model,
sizeof(wd->sc_params.atap_model), VIS_TRIM|VIS_SAFE|VIS_OCTAL);
strnvisx(rev, sizeof(rev), wd->sc_params.atap_revision,
sizeof(wd->sc_params.atap_revision), VIS_TRIM|VIS_SAFE|VIS_OCTAL);

snprintf(bd->bd_vendor, sizeof(bd->bd_vendor), "%s %s", model, rev);
strlcpy(bd->bd_serial, serial, sizeof(bd->bd_serial));

return 0;
}
#endif /* NBIO > 0 */

static int
ld_ataraid_ioctl(struct ld_softc *ld, u_long cmd, void *addr, int32_t flag,
bool poll)
{
struct ld_ataraid_softc *sc = (void *)ld;
int error, i, j;
kauth_cred_t uc;

uc = kauth_cred_get();

switch (cmd) {
case DIOCGCACHE:
{
int dkcache = 0;

/*
* We pass this call down to all components and report
* intersection of the flags returned by the components.
* If any errors out, we return error. ATA RAID components
* can only change via BIOS, device feature flags will remain
* static. RCE/WCE can change if set directly on underlying
* device.
*/
for (error = 0, i = 0; i < sc->sc_aai->aai_ndisks; i++) {
KASSERT(sc->sc_vnodes[i] != NULL);

error = VOP_IOCTL(sc->sc_vnodes[i], cmd, &j,
flag, uc);
if (error)
break;

if (i == 0)
dkcache = j;
else
dkcache = DKCACHE_COMBINE(dkcache, j);
}

*((int *)addr) = dkcache;
break;
}

case DIOCCACHESYNC:
{
/*
* We pass this call down to all components and report
* the first error we encounter.
*/
for (error = 0, i = 0; i < sc->sc_aai->aai_ndisks; i++) {
KASSERT(sc->sc_vnodes[i] != NULL);

j = VOP_IOCTL(sc->sc_vnodes[i], cmd, addr,
flag, uc);
if (j != 0 && error == 0)
error = j;
}
break;
}

default:
error = EPASSTHROUGH;
break;
}

return error;
}

MODULE(MODULE_CLASS_DRIVER, ld_ataraid, "ld,ataraid");

#ifdef _MODULE
/*
* XXX Don't allow ioconf.c to redefine the "struct cfdriver ld_ataraid"
* XXX it will be defined in the common-code module
*/
#undef CFDRIVER_DECL
#define CFDRIVER_DECL(name, class, attr)
#include "ioconf.c"
#endif

static int
ld_ataraid_modcmd(modcmd_t cmd, void *opaque)
{
#ifdef _MODULE
/*
* We ignore the cfdriver_vec[] that ioconf provides, since
* the cfdrivers are attached already.
*/
static struct cfdriver * const no_cfdriver_vec[] = { NULL };
#endif
int error = 0;

#ifdef _MODULE
switch (cmd) {
case MODULE_CMD_INIT:
error = config_init_component(no_cfdriver_vec,
cfattach_ioconf_ld_ataraid, cfdata_ioconf_ld_ataraid);
break;
case MODULE_CMD_FINI:
error = config_fini_component(no_cfdriver_vec,
cfattach_ioconf_ld_ataraid, cfdata_ioconf_ld_ataraid);
break;
default:
error = ENOTTY;
break;
}
#endif

return error;
}