diff options
Diffstat (limited to 'sys/dev/raidframe/rf_freebsdkintf.c')
| -rw-r--r-- | sys/dev/raidframe/rf_freebsdkintf.c | 3294 |
1 files changed, 3294 insertions, 0 deletions
diff --git a/sys/dev/raidframe/rf_freebsdkintf.c b/sys/dev/raidframe/rf_freebsdkintf.c new file mode 100644 index 0000000..b7003b5 --- /dev/null +++ b/sys/dev/raidframe/rf_freebsdkintf.c @@ -0,0 +1,3294 @@ +/*- + * Copyright (c) 2002 Scott Long <scottl@freebsd.org> + * All rights reserved. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 THE AUTHOR OR CONTRIBUTORS 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. + * + * $FreeBSD$ + */ + +/* $NetBSD: rf_netbsdkintf.c,v 1.105 2001/04/05 02:48:51 oster Exp $ */ +/*- + * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc. + * All rights reserved. + * + * This code is derived from software contributed to The NetBSD Foundation + * by Greg Oster; Jason R. Thorpe. + * + * 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 by the NetBSD + * Foundation, Inc. and its contributors. + * 4. Neither the name of The NetBSD Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS + * ``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 THE FOUNDATION OR CONTRIBUTORS + * 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. + */ + +/* + * Copyright (c) 1988 University of Utah. + * Copyright (c) 1990, 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * the Systems Programming Group of the University of Utah Computer + * Science Department. + * + * 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 by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS 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. + * + * from: Utah $Hdr: cd.c 1.6 90/11/28$ + * + * @(#)cd.c 8.2 (Berkeley) 11/16/93 + */ + + + + +/* + * Copyright (c) 1995 Carnegie-Mellon University. + * All rights reserved. + * + * Authors: Mark Holland, Jim Zelenka + * + * Permission to use, copy, modify and distribute this software and + * its documentation is hereby granted, provided that both the copyright + * notice and this permission notice appear in all copies of the + * software, derivative works or modified versions, and any portions + * thereof, and that both notices appear in supporting documentation. + * + * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" + * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND + * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. + * + * Carnegie Mellon requests users of this software to return to + * + * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU + * School of Computer Science + * Carnegie Mellon University + * Pittsburgh PA 15213-3890 + * + * any improvements or extensions that they make and grant Carnegie the + * rights to redistribute these changes. + */ + +/*********************************************************** + * + * rf_kintf.c -- the kernel interface routines for RAIDframe + * + ***********************************************************/ + +#include <sys/types.h> +#include <sys/param.h> +#include <sys/errno.h> +#include <sys/param.h> +#include <sys/queue.h> +#include <sys/stat.h> +#include <sys/ioccom.h> +#include <sys/filio.h> +#include <sys/fcntl.h> +#include <sys/systm.h> +#include <sys/namei.h> +#include <sys/vnode.h> +#include <sys/bio.h> +#include <sys/buf.h> +#include <sys/disk.h> +#include <sys/diskslice.h> +#include <sys/disklabel.h> +#include <sys/conf.h> +#include <sys/lock.h> +#include <sys/reboot.h> +#include <sys/module.h> +#include <sys/devicestat.h> +#include <vm/uma.h> + +#include "opt_raid.h" +#include <dev/raidframe/rf_raid.h> +#include <dev/raidframe/rf_raidframe.h> +#include <dev/raidframe/rf_copyback.h> +#include <dev/raidframe/rf_dag.h> +#include <dev/raidframe/rf_dagflags.h> +#include <dev/raidframe/rf_desc.h> +#include <dev/raidframe/rf_diskqueue.h> +#include <dev/raidframe/rf_acctrace.h> +#include <dev/raidframe/rf_etimer.h> +#include <dev/raidframe/rf_general.h> +#include <dev/raidframe/rf_debugMem.h> +#include <dev/raidframe/rf_kintf.h> +#include <dev/raidframe/rf_options.h> +#include <dev/raidframe/rf_driver.h> +#include <dev/raidframe/rf_parityscan.h> +#include <dev/raidframe/rf_debugprint.h> +#include <dev/raidframe/rf_threadstuff.h> +#include <dev/raidframe/rf_configure.h> + +RF_DECLARE_STATIC_MUTEX(rf_sparet_wait_mutex) + +static RF_SparetWait_t *rf_sparet_wait_queue; /* requests to install a + * spare table */ +static RF_SparetWait_t *rf_sparet_resp_queue; /* responses from + * installation process */ + +/* prototypes */ +static void KernelWakeupFunc(struct bio *); +static void InitBP(struct bio *, struct vnode *, unsigned rw_flag, + dev_t dev, RF_SectorNum_t startSect, + RF_SectorCount_t numSect, caddr_t buf, + void (*cbFunc) (struct bio *), void *cbArg, + int logBytesPerSector, struct proc * b_proc); +static dev_t raidinit(RF_Raid_t *); +static void rf_search_label(dev_t, struct disklabel *, + RF_AutoConfig_t **) __unused; + +static int raid_modevent(module_t, int, void*); +void raidattach(void); +d_psize_t raidsize; +d_open_t raidopen; +d_close_t raidclose; +d_ioctl_t raidioctl; +d_write_t raidwrite; +d_read_t raidread; +d_strategy_t raidstrategy; +#if 0 +d_dump_t raiddump; +#endif + +d_open_t raidctlopen; +d_close_t raidctlclose; +d_ioctl_t raidctlioctl; + +static struct cdevsw raid_cdevsw = { + raidopen, + raidclose, + raidread, + raidwrite, + raidioctl, + nopoll, + nommap, + raidstrategy, + "raid", + 200, + nodump, + nopsize, + D_DISK, +}; + +static struct cdevsw raidctl_cdevsw = { + raidctlopen, + raidctlclose, + noread, + nowrite, + raidctlioctl, + nopoll, + nommap, + nostrategy, + "raidctl", + 201, + nodump, + nopsize, + 0, +}; + +static struct cdevsw raiddisk_cdevsw; + +/* + * Pilfered from ccd.c + */ + +struct raidbuf { + struct bio rf_buf; /* new I/O buf. MUST BE FIRST!!! */ + struct bio *rf_obp; /* ptr. to original I/O buf */ + int rf_flags; /* misc. flags */ + RF_DiskQueueData_t *req;/* the request that this was part of.. */ +}; + + +#define RAIDGETBUF(sc) uma_zalloc((sc)->sc_cbufpool, M_NOWAIT) +#define RAIDPUTBUF(sc, cbp) uma_zfree((sc)->sc_cbufpool, cbp) + +#define RF_MAX_ARRAYS 32 + +/* Raid control device */ +struct raidctl_softc { + dev_t sc_dev; /* Device node */ + int sc_flags; /* flags */ + int sc_numraid; /* Number of configured raid devices */ + dev_t sc_raiddevs[RF_MAX_ARRAYS]; +}; + +struct raid_softc { + dev_t sc_dev; /* Our device */ + dev_t sc_parent_dev; + int sc_flags; /* flags */ + int sc_busycount; /* How many times are we opened? */ + size_t sc_size; /* size of the raid device */ + dev_t sc_parent; /* Parent device */ + struct disk sc_dkdev; /* generic disk device info */ + uma_zone_t sc_cbufpool; /* component buffer pool */ + RF_Raid_t *raidPtr; /* Raid information struct */ + struct bio_queue_head bio_queue; /* used for the device queue */ + struct devstat device_stats; /* devstat gathering */ +}; +/* sc_flags */ +#define RAIDF_OPEN 0x01 /* unit has been initialized */ +#define RAIDF_WLABEL 0x02 /* label area is writable */ +#define RAIDF_LABELLING 0x04 /* unit is currently being labelled */ +#define RAIDF_WANTED 0x40 /* someone is waiting to obtain a lock */ +#define RAIDF_LOCKED 0x80 /* unit is locked */ + +/* + * Allow RAIDOUTSTANDING number of simultaneous IO's to this RAID device. + * Be aware that large numbers can allow the driver to consume a lot of + * kernel memory, especially on writes, and in degraded mode reads. + * + * For example: with a stripe width of 64 blocks (32k) and 5 disks, + * a single 64K write will typically require 64K for the old data, + * 64K for the old parity, and 64K for the new parity, for a total + * of 192K (if the parity buffer is not re-used immediately). + * Even it if is used immedately, that's still 128K, which when multiplied + * by say 10 requests, is 1280K, *on top* of the 640K of incoming data. + * + * Now in degraded mode, for example, a 64K read on the above setup may + * require data reconstruction, which will require *all* of the 4 remaining + * disks to participate -- 4 * 32K/disk == 128K again. + */ + +#ifndef RAIDOUTSTANDING +#define RAIDOUTSTANDING 10 +#endif + +#define RAIDLABELDEV(dev) dkmodpart(dev, RAW_PART) +#define DISKPART(dev) dkpart(dev) + +static void raidgetdefaultlabel(RF_Raid_t *, struct raid_softc *, struct disk*); +static int raidlock(struct raid_softc *); +static void raidunlock(struct raid_softc *); + +static void rf_markalldirty(RF_Raid_t *); + +static dev_t raidctl_dev; + +void rf_ReconThread(struct rf_recon_req *); +/* XXX what I want is: */ +/*void rf_ReconThread(RF_Raid_t *raidPtr); */ +void rf_RewriteParityThread(RF_Raid_t *raidPtr); +void rf_CopybackThread(RF_Raid_t *raidPtr); +void rf_ReconstructInPlaceThread(struct rf_recon_req *); +void rf_buildroothack(void *, struct raidctl_softc *); + +RF_AutoConfig_t *rf_find_raid_components(void); +RF_ConfigSet_t *rf_create_auto_sets(RF_AutoConfig_t *); +static int rf_does_it_fit(RF_ConfigSet_t *,RF_AutoConfig_t *); +static int rf_reasonable_label(RF_ComponentLabel_t *); +void rf_create_configuration(RF_AutoConfig_t *,RF_Config_t *, RF_Raid_t *); +int rf_set_autoconfig(RF_Raid_t *, int); +int rf_set_rootpartition(RF_Raid_t *, int); +void rf_release_all_vps(RF_ConfigSet_t *); +void rf_cleanup_config_set(RF_ConfigSet_t *); +int rf_have_enough_components(RF_ConfigSet_t *); +int rf_auto_config_set(RF_ConfigSet_t *, int *, struct raidctl_softc *); +static int raidgetunit(struct raidctl_softc *, int); +static int raidshutdown(void); + +void +raidattach(void) +{ + struct raidctl_softc *parent_sc = NULL; + RF_AutoConfig_t *ac_list; /* autoconfig list */ + RF_ConfigSet_t *config_sets; + int autoconfig = 0; + + /* This is where all the initialization stuff gets done. */ + + if(rf_mutex_init(&rf_sparet_wait_mutex, __FUNCTION__)) { + rf_printf(0, "RAIDframe: failed to initialize mutexes\n"); + return; + } + + rf_sparet_wait_queue = rf_sparet_resp_queue = NULL; + + if (rf_BootRaidframe() != 0) { + rf_printf(0, "Serious error booting RAIDframe!!\n"); + return; + } + + rf_printf(0, "Kernelized RAIDframe activated\n"); + MALLOC(parent_sc, struct raidctl_softc *, sizeof(*parent_sc), + M_RAIDFRAME, M_NOWAIT|M_ZERO); + if (parent_sc == NULL) { + RF_PANIC(); + return; + } + + parent_sc->sc_dev= make_dev(&raidctl_cdevsw, 0, 0, 0, 0x644, "raidctl"); + parent_sc->sc_dev->si_drv1 = parent_sc; + raidctl_dev = parent_sc->sc_dev; + +#if RAID_AUTOCONFIG + autoconfig = 1; +#endif + + if (autoconfig) { + /* 1. locate all RAID components on the system */ + + rf_printf(0, "Searching for raid components...\n"); + ac_list = rf_find_raid_components(); + if (ac_list == NULL) + return; + + /* 2. sort them into their respective sets */ + + config_sets = rf_create_auto_sets(ac_list); + + /* 3. evaluate each set and configure the valid ones + This gets done in rf_buildroothack() */ + + /* schedule the creation of the thread to do the + "/ on RAID" stuff */ + + rf_buildroothack(config_sets, parent_sc); +#if 0 + kthread_create(rf_buildroothack,config_sets); + +#endif /* RAID_AUTOCONFIG */ + } +} + +void +rf_buildroothack(arg, parent_sc) + void *arg; + struct raidctl_softc *parent_sc; +{ + RF_ConfigSet_t *config_sets = arg; + RF_ConfigSet_t *cset; + RF_ConfigSet_t *next_cset; + int retcode; + int raidID; + int rootID; + int num_root; + + rootID = 0; + num_root = 0; + cset = config_sets; + while(cset != NULL ) { + next_cset = cset->next; + if (rf_have_enough_components(cset) && + cset->ac->clabel->autoconfigure==1) { + retcode = rf_auto_config_set(cset, &raidID, parent_sc); + if (!retcode) { + if (cset->rootable) { + rootID = raidID; + num_root++; + } + } else { + /* The autoconfig didn't work :( */ + rf_printf(1, "Autoconfig failed with code %d" + "for raid%d\n", retcode, raidID); + rf_release_all_vps(cset); + } + } else { + /* we're not autoconfiguring this set... + release the associated resources */ + rf_release_all_vps(cset); + } + /* cleanup */ + rf_cleanup_config_set(cset); + cset = next_cset; + } + if (boothowto & RB_ASKNAME) { + /* We don't auto-config... */ + } else { + /* They didn't ask, and we found something bootable... */ + +#if 0 + if (num_root == 1) { + booted_device = &raidrootdev[rootID]; + } else if (num_root > 1) { + /* we can't guess.. require the user to answer... */ + boothowto |= RB_ASKNAME; + } +#endif + } +} + +int +raidctlopen(dev_t dev, int flags, int fmt, struct thread *td) +{ + struct raidctl_softc *parent_sc; + + parent_sc = dev->si_drv1; + + if ((parent_sc->sc_flags & RAIDF_OPEN) != 0) + return (EBUSY); + + parent_sc->sc_flags |= RAIDF_OPEN; + return (0); +} + +int +raidctlclose(dev_t dev, int flags, int fmt, struct thread *td) +{ + struct raidctl_softc *parent_sc; + + parent_sc = dev->si_drv1; + + parent_sc->sc_flags &= ~RAIDF_OPEN; + return (0); +} + +int +raidctlioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct thread *td) +{ + struct raidctl_softc *parent_sc; + struct raid_softc *sc; + RF_Config_t *u_cfg, *k_cfg; + RF_Raid_t *raidPtr; + u_char *specific_buf; + u_int unit; + int retcode = 0; + + parent_sc = dev->si_drv1; + + switch (cmd) { + /* configure the system */ + case RAIDFRAME_CONFIGURE: + + /* copy-in the configuration information */ + /* data points to a pointer to the configuration structure */ + + u_cfg = *((RF_Config_t **) data); + RF_Malloc(k_cfg, sizeof(RF_Config_t), (RF_Config_t *)); + if (k_cfg == NULL) { + return (ENOMEM); + } + retcode = copyin((caddr_t) u_cfg, (caddr_t) k_cfg, + sizeof(RF_Config_t)); + if (retcode) { + RF_Free(k_cfg, sizeof(RF_Config_t)); + rf_printf(2, "raidctlioctl: retcode=%d copyin.1\n", + retcode); + return (retcode); + } + /* allocate a buffer for the layout-specific data, and copy it + * in */ + if (k_cfg->layoutSpecificSize) { + if (k_cfg->layoutSpecificSize > 10000) { + /* sanity check */ + RF_Free(k_cfg, sizeof(RF_Config_t)); + return (EINVAL); + } + RF_Malloc(specific_buf, k_cfg->layoutSpecificSize, + (u_char *)); + if (specific_buf == NULL) { + RF_Free(k_cfg, sizeof(RF_Config_t)); + return (ENOMEM); + } + retcode = copyin(k_cfg->layoutSpecific, + (caddr_t) specific_buf, + k_cfg->layoutSpecificSize); + if (retcode) { + RF_Free(k_cfg, sizeof(RF_Config_t)); + RF_Free(specific_buf, + k_cfg->layoutSpecificSize); + rf_printf(2, "raidctlioctl: retcode=%d " + "copyin.2\n", retcode); + return (retcode); + } + } else + specific_buf = NULL; + k_cfg->layoutSpecific = specific_buf; + + /* should do some kind of sanity check on the configuration. + * Store the sum of all the bytes in the last byte? */ + + /* configure the system */ + + RF_Malloc(raidPtr, sizeof(*raidPtr), (RF_Raid_t *)); + if (raidPtr == NULL) { + rf_printf(0, "No memory for raid device\n"); + RF_Free(k_cfg, sizeof(RF_Config_t)); + retcode = ENOMEM; + } + bzero((char *) raidPtr, sizeof(RF_Raid_t)); + + /* Request a unit number for this soon-to-be device. */ + unit = raidgetunit(parent_sc, 0); + if (unit == -1) { + rf_printf(0, "Cannot allocate raid unit\n"); + RF_Free(raidPtr, sizeof(*raidPtr)); + goto out; + } + raidPtr->raidid = unit; + + if ((retcode = rf_Configure(raidPtr, k_cfg, NULL)) == 0) { + + /* allow this many simultaneous IO's to + this RAID device */ + raidPtr->openings = RAIDOUTSTANDING; + + parent_sc->sc_raiddevs[unit] = raidinit(raidPtr); + if (parent_sc->sc_raiddevs[unit] == NULL) { + rf_printf(0, "Could not create raid device\n"); + RF_Free(raidPtr, sizeof(*raidPtr)); + goto out; + } + parent_sc->sc_numraid++; + ((struct raid_softc *)raidPtr->sc)->sc_parent_dev = dev; + rf_markalldirty(raidPtr); + } else { + parent_sc->sc_raiddevs[unit] = NULL; + RF_Free(raidPtr, sizeof(*raidPtr)); + } + +out: + /* free the buffers. No return code here. */ + if (k_cfg->layoutSpecificSize) { + RF_Free(specific_buf, k_cfg->layoutSpecificSize); + } + RF_Free(k_cfg, sizeof(RF_Config_t)); + break; + + case RAIDFRAME_SHUTDOWN: + + unit = *(u_int *)data; + if ((unit >= RF_MAX_ARRAYS) || + (parent_sc->sc_raiddevs[unit] == NULL)) + return (EINVAL); + + sc = parent_sc->sc_raiddevs[unit]->si_drv1; + if ((retcode = raidlock(sc)) != 0) + return (retcode); + + /* + * If somebody has a partition mounted, we shouldn't + * shutdown. + */ + + if ((sc->sc_flags & RAIDF_OPEN) != 0) { + raidunlock(sc); + return (EBUSY); + } + + rf_printf(0, "Shutting down RAIDframe engine\n"); + retcode = rf_Shutdown(sc->raidPtr); + RF_THREADGROUP_WAIT_STOP(&sc->raidPtr->engine_tg); + + devstat_remove_entry(&sc->device_stats); + + disk_destroy(parent_sc->sc_raiddevs[unit]); + raidunlock(sc); + + /* XXX Need to be able to destroy the zone */ + uma_zdestroy(sc->sc_cbufpool); + + parent_sc->sc_numraid--; + parent_sc->sc_raiddevs[unit] = NULL; + + RF_Free(sc->raidPtr, sizeof(*raidPtr)); + RF_Free(sc, sizeof(*sc)); + + break; + + default: + retcode = ENOIOCTL; + } + + return (retcode); +} + +#if 0 /* XXX DUMP!!!! */ +int +raiddump(dev) + dev_t dev; +{ + /* Not implemented. */ + return ENXIO; +} +#endif + +/* ARGSUSED */ +int +raidopen(dev, flags, fmt, td) + dev_t dev; + int flags, fmt; + struct thread *td; +{ + struct raid_softc *sc; + struct disk *dp; + int error = 0; + + sc = dev->si_drv1; + + if ((error = raidlock(sc)) != 0) + return (error); + dp = &sc->sc_dkdev; + + rf_printf(1, "Opening raid device %s\n", dev->si_name); + + /* Generate overall disklabel */ + raidgetdefaultlabel(sc->raidPtr, sc, dp); + + if (sc->sc_busycount == 0) { + /* First one... mark things as dirty... Note that we *MUST* + have done a configure before this. I DO NOT WANT TO BE + SCRIBBLING TO RANDOM COMPONENTS UNTIL IT'S BEEN DETERMINED + THAT THEY BELONG TOGETHER!!!!! */ + /* XXX should check to see if we're only open for reading + here... If so, we needn't do this, but then need some + other way of keeping track of what's happened.. */ + + rf_markalldirty( sc->raidPtr ); + sc->sc_flags |= RAIDF_OPEN; + } + + /* Prevent this unit from being unconfigured while open. */ + sc->sc_busycount++; + + raidunlock(sc); + + return (error); + + +} +/* ARGSUSED */ +int +raidclose(dev, flags, fmt, td) + dev_t dev; + int flags, fmt; + struct thread *td; +{ + struct raid_softc *sc; + int error = 0; + + sc = dev->si_drv1; + + if ((error = raidlock(sc)) != 0) + return (error); + + sc->sc_busycount--; + if (sc->sc_busycount == 0) { + sc->sc_flags &= ~RAIDF_OPEN; + rf_update_component_labels(sc->raidPtr, + RF_FINAL_COMPONENT_UPDATE); + } + + raidunlock(sc); + return (0); + +} + +void +raidstrategy(bp) + struct bio *bp; +{ + RF_Raid_t *raidPtr; + struct raid_softc *sc = bp->bio_dev->si_drv1; + int s; + + raidPtr = sc->raidPtr; + if (raidPtr == NULL) { + bp->bio_error = ENODEV; + bp->bio_flags |= BIO_ERROR; + bp->bio_resid = bp->bio_bcount; + biodone(bp); + return; + } + if (!raidPtr->valid) { + bp->bio_error = ENODEV; + bp->bio_flags |= BIO_ERROR; + bp->bio_resid = bp->bio_bcount; + biodone(bp); + return; + } + if (bp->bio_bcount == 0) { + rf_printf(2, "b_bcount is zero..\n"); + biodone(bp); + return; + } + + s = splbio(); + + bp->bio_resid = 0; + + /* stuff it onto our queue. XXX locking? */ + bioq_insert_tail(&sc->bio_queue, bp); + + raidstart(raidPtr); + + splx(s); +} + +int +raidread(dev, uio, flags) + dev_t dev; + struct uio *uio; + int flags; +{ + struct raid_softc *sc; + + sc = dev->si_drv1; + + return (physio(dev, uio, BIO_READ)); + +} + +int +raidwrite(dev, uio, flags) + dev_t dev; + struct uio *uio; + int flags; +{ + struct raid_softc *sc; + int ret; + + sc = dev->si_drv1; + + rf_printf(3, "raidwrite\n"); + ret = physio(dev, uio, BIO_WRITE); + + return (ret); + +} + +int +raidioctl(dev, cmd, data, flag, td) + dev_t dev; + u_long cmd; + caddr_t data; + int flag; + struct thread *td; +{ + struct raid_softc *sc; + RF_Raid_t *raidPtr; + RF_RaidDisk_t *diskPtr; + RF_AccTotals_t *totals; + RF_DeviceConfig_t *d_cfg, **ucfgp; + struct rf_recon_req *rrcopy, *rr; + RF_ComponentLabel_t *clabel; + RF_ComponentLabel_t *ci_label; + RF_SingleComponent_t *sparePtr,*componentPtr; + RF_SingleComponent_t *hot_spare, *component; + RF_ProgressInfo_t progressInfo; + int retcode = 0; + int row, column; + int unit; + int i, j, d; + + sc = dev->si_drv1; + raidPtr = sc->raidPtr; + + rf_printf(2, "raidioctl: %s %ld\n", dev->si_name, cmd); + + switch (cmd) { + + case RAIDFRAME_GET_COMPONENT_LABEL: + /* need to read the component label for the disk indicated + by row,column in clabel */ + + /* For practice, let's get it directly fromdisk, rather + than from the in-core copy */ + RF_Malloc( clabel, sizeof( RF_ComponentLabel_t ), + (RF_ComponentLabel_t *)); + if (clabel == NULL) + return (ENOMEM); + + bzero((char *) clabel, sizeof(RF_ComponentLabel_t)); + + bcopy(data, clabel, sizeof(RF_ComponentLabel_t)); + + row = clabel->row; + column = clabel->column; + + if ((row < 0) || (row >= raidPtr->numRow) || + (column < 0) || (column >= raidPtr->numCol + + raidPtr->numSpare)) { + RF_Free( clabel, sizeof(RF_ComponentLabel_t)); + return(EINVAL); + } + + raidread_component_label(raidPtr->Disks[row][column].dev, + raidPtr->raid_cinfo[row][column].ci_vp, + clabel ); + + bcopy(clabel, data, sizeof(RF_ComponentLabel_t)); + RF_Free( clabel, sizeof(RF_ComponentLabel_t)); + return (retcode); + + case RAIDFRAME_SET_COMPONENT_LABEL: + clabel = (RF_ComponentLabel_t *) data; + + /* XXX check the label for valid stuff... */ + /* Note that some things *should not* get modified -- + the user should be re-initing the labels instead of + trying to patch things. + */ + + rf_printf(1, "Got component label:\n"); + rf_printf(1, "Version: %d\n",clabel->version); + rf_printf(1, "Serial Number: %d\n",clabel->serial_number); + rf_printf(1, "Mod counter: %d\n",clabel->mod_counter); + rf_printf(1, "Row: %d\n", clabel->row); + rf_printf(1, "Column: %d\n", clabel->column); + rf_printf(1, "Num Rows: %d\n", clabel->num_rows); + rf_printf(1, "Num Columns: %d\n", clabel->num_columns); + rf_printf(1, "Clean: %d\n", clabel->clean); + rf_printf(1, "Status: %d\n", clabel->status); + + row = clabel->row; + column = clabel->column; + + if ((row < 0) || (row >= raidPtr->numRow) || + (column < 0) || (column >= raidPtr->numCol)) { + return(EINVAL); + } + + /* XXX this isn't allowed to do anything for now :-) */ + + /* XXX and before it is, we need to fill in the rest + of the fields!?!?!?! */ +#if 0 + raidwrite_component_label( + raidPtr->Disks[row][column].dev, + raidPtr->raid_cinfo[row][column].ci_vp, + clabel ); +#endif + return (0); + + case RAIDFRAME_INIT_LABELS: + MALLOC(ci_label, RF_ComponentLabel_t *, + sizeof(RF_ComponentLabel_t), M_RAIDFRAME, + M_WAITOK | M_ZERO); + clabel = (RF_ComponentLabel_t *) data; + /* + we only want the serial number from + the above. We get all the rest of the information + from the config that was used to create this RAID + set. + */ + + raidPtr->serial_number = clabel->serial_number; + + raid_init_component_label(raidPtr, ci_label); + ci_label->serial_number = clabel->serial_number; + + for(row=0;row<raidPtr->numRow;row++) { + ci_label->row = row; + for(column=0;column<raidPtr->numCol;column++) { + diskPtr = &raidPtr->Disks[row][column]; + if (!RF_DEAD_DISK(diskPtr->status)) { + ci_label->partitionSize = + diskPtr->partitionSize; + ci_label->column = column; + raidwrite_component_label( + raidPtr->Disks[row][column].dev, + raidPtr->raid_cinfo[row][column].ci_vp, + ci_label ); + } + } + } + + FREE(ci_label, M_RAIDFRAME); + return (retcode); + case RAIDFRAME_SET_AUTOCONFIG: + d = rf_set_autoconfig(raidPtr, *(int *) data); + rf_printf(1, "New autoconfig value is: %d\n", d); + *(int *) data = d; + return (retcode); + + case RAIDFRAME_SET_ROOT: + d = rf_set_rootpartition(raidPtr, *(int *) data); + rf_printf(1, "New rootpartition value is: %d\n", d); + *(int *) data = d; + return (retcode); + + /* initialize all parity */ + case RAIDFRAME_REWRITEPARITY: + + if (raidPtr->Layout.map->faultsTolerated == 0) { + /* Parity for RAID 0 is trivially correct */ + raidPtr->parity_good = RF_RAID_CLEAN; + return(0); + } + + if (raidPtr->parity_rewrite_in_progress == 1) { + /* Re-write is already in progress! */ + return(EINVAL); + } + + retcode = RF_CREATE_THREAD(raidPtr->parity_rewrite_thread, + rf_RewriteParityThread, + raidPtr,"raid_parity"); + return (retcode); + + + case RAIDFRAME_ADD_HOT_SPARE: + MALLOC(hot_spare, RF_SingleComponent_t *, + sizeof(RF_SingleComponent_t), M_RAIDFRAME, + M_WAITOK | M_ZERO); + sparePtr = (RF_SingleComponent_t *) data; + memcpy( hot_spare, sparePtr, sizeof(RF_SingleComponent_t)); + retcode = rf_add_hot_spare(raidPtr, hot_spare); + FREE(hot_spare, M_RAIDFRAME); + return(retcode); + + case RAIDFRAME_REMOVE_HOT_SPARE: + return(retcode); + + case RAIDFRAME_DELETE_COMPONENT: + MALLOC(component, RF_SingleComponent_t *, + sizeof(RF_SingleComponent_t), M_RAIDFRAME, + M_WAITOK | M_ZERO); + componentPtr = (RF_SingleComponent_t *)data; + memcpy( component, componentPtr, + sizeof(RF_SingleComponent_t)); + retcode = rf_delete_component(raidPtr, component); + FREE(component, M_RAIDFRAME); + return(retcode); + + case RAIDFRAME_INCORPORATE_HOT_SPARE: + MALLOC(component, RF_SingleComponent_t *, + sizeof(RF_SingleComponent_t), M_RAIDFRAME, + M_WAITOK | M_ZERO); + componentPtr = (RF_SingleComponent_t *)data; + memcpy( component, componentPtr, + sizeof(RF_SingleComponent_t)); + retcode = rf_incorporate_hot_spare(raidPtr, component); + FREE(component, M_RAIDFRAME); + return(retcode); + + case RAIDFRAME_REBUILD_IN_PLACE: + + MALLOC(component, RF_SingleComponent_t *, + sizeof(RF_SingleComponent_t), M_RAIDFRAME, + M_WAITOK | M_ZERO); + if (raidPtr->Layout.map->faultsTolerated == 0) { + /* Can't do this on a RAID 0!! */ + FREE(component, M_RAIDFRAME); + return(EINVAL); + } + + if (raidPtr->recon_in_progress == 1) { + /* a reconstruct is already in progress! */ + FREE(component, M_RAIDFRAME); + return(EINVAL); + } + + componentPtr = (RF_SingleComponent_t *) data; + memcpy( component, componentPtr, + sizeof(RF_SingleComponent_t)); + row = component->row; + column = component->column; + unit = raidPtr->raidid; + rf_printf(0, "raid%d Rebuild: %d %d\n", unit, row, column); + if ((row < 0) || (row >= raidPtr->numRow) || + (column < 0) || (column >= raidPtr->numCol)) { + FREE(component, M_RAIDFRAME); + return(EINVAL); + } + + RF_Malloc(rrcopy, sizeof(*rrcopy), (struct rf_recon_req *)); + if (rrcopy == NULL) { + FREE(component, M_RAIDFRAME); + return(ENOMEM); + } + + rrcopy->raidPtr = (void *) raidPtr; + rrcopy->row = row; + rrcopy->col = column; + + retcode = RF_CREATE_THREAD(raidPtr->recon_thread, + rf_ReconstructInPlaceThread, + rrcopy,"raid_reconip"); + FREE(component, M_RAIDFRAME); + return(retcode); + + case RAIDFRAME_GET_UNIT: + + *(int *)data = raidPtr->raidid; + return (0); + + case RAIDFRAME_GET_INFO: + if (!raidPtr->valid) + return (ENODEV); + ucfgp = (RF_DeviceConfig_t **) data; + RF_Malloc(d_cfg, sizeof(RF_DeviceConfig_t), + (RF_DeviceConfig_t *)); + if (d_cfg == NULL) + return (ENOMEM); + bzero((char *) d_cfg, sizeof(RF_DeviceConfig_t)); + d_cfg->rows = raidPtr->numRow; + d_cfg->cols = raidPtr->numCol; + d_cfg->ndevs = raidPtr->numRow * raidPtr->numCol; + if (d_cfg->ndevs >= RF_MAX_DISKS) { + RF_Free(d_cfg, sizeof(RF_DeviceConfig_t)); + return (ENOMEM); + } + d_cfg->nspares = raidPtr->numSpare; + if (d_cfg->nspares >= RF_MAX_DISKS) { + RF_Free(d_cfg, sizeof(RF_DeviceConfig_t)); + return (ENOMEM); + } + d_cfg->maxqdepth = raidPtr->maxQueueDepth; + d = 0; + for (i = 0; i < d_cfg->rows; i++) { + for (j = 0; j < d_cfg->cols; j++) { + d_cfg->devs[d] = raidPtr->Disks[i][j]; + d++; + } + } + for (j = d_cfg->cols, i = 0; i < d_cfg->nspares; i++, j++) { + d_cfg->spares[i] = raidPtr->Disks[0][j]; + } + + retcode = copyout(d_cfg, *ucfgp, sizeof(RF_DeviceConfig_t)); + + RF_Free(d_cfg, sizeof(RF_DeviceConfig_t)); + + return (retcode); + + case RAIDFRAME_CHECK_PARITY: + *(int *) data = raidPtr->parity_good; + return (0); + + case RAIDFRAME_RESET_ACCTOTALS: + bzero(&raidPtr->acc_totals, sizeof(raidPtr->acc_totals)); + return (0); + + case RAIDFRAME_GET_ACCTOTALS: + totals = (RF_AccTotals_t *) data; + *totals = raidPtr->acc_totals; + return (0); + + case RAIDFRAME_KEEP_ACCTOTALS: + raidPtr->keep_acc_totals = *(int *)data; + return (0); + + case RAIDFRAME_GET_SIZE: + *(int *) data = raidPtr->totalSectors; + return (0); + + /* fail a disk & optionally start reconstruction */ + case RAIDFRAME_FAIL_DISK: + + if (raidPtr->Layout.map->faultsTolerated == 0) { + /* Can't do this on a RAID 0!! */ + return(EINVAL); + } + + rr = (struct rf_recon_req *) data; + + if (rr->row < 0 || rr->row >= raidPtr->numRow + || rr->col < 0 || rr->col >= raidPtr->numCol) + return (EINVAL); + + rf_printf(0, "%s: Failing the disk: row: %d col: %d\n", + dev->si_name, rr->row, rr->col); + + /* make a copy of the recon request so that we don't rely on + * the user's buffer */ + RF_Malloc(rrcopy, sizeof(*rrcopy), (struct rf_recon_req *)); + if (rrcopy == NULL) + return(ENOMEM); + bcopy(rr, rrcopy, sizeof(*rr)); + rrcopy->raidPtr = (void *) raidPtr; + + retcode = RF_CREATE_THREAD(raidPtr->recon_thread, + rf_ReconThread, + rrcopy,"raid_recon"); + return (0); + + /* invoke a copyback operation after recon on whatever disk + * needs it, if any */ + case RAIDFRAME_COPYBACK: + + if (raidPtr->Layout.map->faultsTolerated == 0) { + /* This makes no sense on a RAID 0!! */ + return(EINVAL); + } + + if (raidPtr->copyback_in_progress == 1) { + /* Copyback is already in progress! */ + return(EINVAL); + } + + retcode = RF_CREATE_THREAD(raidPtr->copyback_thread, + rf_CopybackThread, + raidPtr,"raid_copyback"); + return (retcode); + + /* return the percentage completion of reconstruction */ + case RAIDFRAME_CHECK_RECON_STATUS: + if (raidPtr->Layout.map->faultsTolerated == 0) { + /* This makes no sense on a RAID 0, so tell the + user it's done. */ + *(int *) data = 100; + return(0); + } + row = 0; /* XXX we only consider a single row... */ + if (raidPtr->status[row] != rf_rs_reconstructing) + *(int *) data = 100; + else + *(int *) data = raidPtr->reconControl[row]->percentComplete; + return (0); + case RAIDFRAME_CHECK_RECON_STATUS_EXT: + row = 0; /* XXX we only consider a single row... */ + if (raidPtr->status[row] != rf_rs_reconstructing) { + progressInfo.remaining = 0; + progressInfo.completed = 100; + progressInfo.total = 100; + } else { + progressInfo.total = + raidPtr->reconControl[row]->numRUsTotal; + progressInfo.completed = + raidPtr->reconControl[row]->numRUsComplete; + progressInfo.remaining = progressInfo.total - + progressInfo.completed; + } + bcopy((caddr_t) &progressInfo, data, sizeof(RF_ProgressInfo_t)); + return (retcode); + + case RAIDFRAME_CHECK_PARITYREWRITE_STATUS: + if (raidPtr->Layout.map->faultsTolerated == 0) { + /* This makes no sense on a RAID 0, so tell the + user it's done. */ + *(int *) data = 100; + return(0); + } + if (raidPtr->parity_rewrite_in_progress == 1) { + *(int *) data = 100 * + raidPtr->parity_rewrite_stripes_done / + raidPtr->Layout.numStripe; + } else { + *(int *) data = 100; + } + return (0); + + case RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT: + if (raidPtr->parity_rewrite_in_progress == 1) { + progressInfo.total = raidPtr->Layout.numStripe; + progressInfo.completed = + raidPtr->parity_rewrite_stripes_done; + progressInfo.remaining = progressInfo.total - + progressInfo.completed; + } else { + progressInfo.remaining = 0; + progressInfo.completed = 100; + progressInfo.total = 100; + } + bcopy((caddr_t) &progressInfo, data, sizeof(RF_ProgressInfo_t)); + return (retcode); + + case RAIDFRAME_CHECK_COPYBACK_STATUS: + if (raidPtr->Layout.map->faultsTolerated == 0) { + /* This makes no sense on a RAID 0 */ + *(int *) data = 100; + return(0); + } + if (raidPtr->copyback_in_progress == 1) { + *(int *) data = 100 * raidPtr->copyback_stripes_done / + raidPtr->Layout.numStripe; + } else { + *(int *) data = 100; + } + return (0); + + case RAIDFRAME_CHECK_COPYBACK_STATUS_EXT: + if (raidPtr->copyback_in_progress == 1) { + progressInfo.total = raidPtr->Layout.numStripe; + progressInfo.completed = + raidPtr->copyback_stripes_done; + progressInfo.remaining = progressInfo.total - + progressInfo.completed; + } else { + progressInfo.remaining = 0; + progressInfo.completed = 100; + progressInfo.total = 100; + } + bcopy((caddr_t) &progressInfo, data, sizeof(RF_ProgressInfo_t)); + return (retcode); + + /* the sparetable daemon calls this to wait for the kernel to + * need a spare table. this ioctl does not return until a + * spare table is needed. XXX -- calling mpsleep here in the + * ioctl code is almost certainly wrong and evil. -- XXX XXX + * -- I should either compute the spare table in the kernel, + * or have a different -- XXX XXX -- interface (a different + * character device) for delivering the table -- XXX */ +#if 0 + case RAIDFRAME_SPARET_WAIT: + RF_LOCK_MUTEX(rf_sparet_wait_mutex); + while (!rf_sparet_wait_queue) + mpsleep(&rf_sparet_wait_queue, (PZERO + 1) | PCATCH, "sparet wait", 0, (void *) simple_lock_addr(rf_sparet_wait_mutex), MS_LOCK_SIMPLE); + waitreq = rf_sparet_wait_queue; + rf_sparet_wait_queue = rf_sparet_wait_queue->next; + RF_UNLOCK_MUTEX(rf_sparet_wait_mutex); + + /* structure assignment */ + *((RF_SparetWait_t *) data) = *waitreq; + + RF_Free(waitreq, sizeof(*waitreq)); + return (0); + + /* wakes up a process waiting on SPARET_WAIT and puts an error + * code in it that will cause the dameon to exit */ + case RAIDFRAME_ABORT_SPARET_WAIT: + RF_Malloc(waitreq, sizeof(*waitreq), (RF_SparetWait_t *)); + waitreq->fcol = -1; + RF_LOCK_MUTEX(rf_sparet_wait_mutex); + waitreq->next = rf_sparet_wait_queue; + rf_sparet_wait_queue = waitreq; + RF_UNLOCK_MUTEX(rf_sparet_wait_mutex); + wakeup(&rf_sparet_wait_queue); + return (0); + + /* used by the spare table daemon to deliver a spare table + * into the kernel */ + case RAIDFRAME_SEND_SPARET: + + /* install the spare table */ + retcode = rf_SetSpareTable(raidPtr, *(void **) data); + + /* respond to the requestor. the return status of the spare + * table installation is passed in the "fcol" field */ + RF_Malloc(waitreq, sizeof(*waitreq), (RF_SparetWait_t *)); + waitreq->fcol = retcode; + RF_LOCK_MUTEX(rf_sparet_wait_mutex); + waitreq->next = rf_sparet_resp_queue; + rf_sparet_resp_queue = waitreq; + wakeup(&rf_sparet_resp_queue); + RF_UNLOCK_MUTEX(rf_sparet_wait_mutex); + + return (retcode); +#endif + + default: + retcode = ENOIOCTL; + break; /* fall through to the os-specific code below */ + + } + + return (retcode); + +} + + +/* raidinit -- complete the rest of the initialization for the + RAIDframe device. */ + + +static dev_t +raidinit(raidPtr) + RF_Raid_t *raidPtr; +{ + struct raid_softc *sc; + dev_t diskdev; + + RF_Malloc(sc, sizeof(struct raid_softc), (struct raid_softc *)); + if (sc == NULL) { + rf_printf(1, "No memory for raid device\n"); + return(NULL); + } + + sc->raidPtr = raidPtr; + + /* XXX Should check return code here */ + bioq_init(&sc->bio_queue); + sc->sc_cbufpool = uma_zcreate("raidpl", sizeof(struct raidbuf), NULL, + NULL, NULL, NULL, 0, 0); + + /* XXX There may be a weird interaction here between this, and + * protectedSectors, as used in RAIDframe. */ + + sc->sc_size = raidPtr->totalSectors; + + /* Create the disk device */ + diskdev = disk_create(raidPtr->raidid, &sc->sc_dkdev, 0, &raid_cdevsw, + &raiddisk_cdevsw); + if (diskdev == NODEV) { + rf_printf(1, "disk_create failed\n"); + return (NULL); + } + sc->sc_dkdev.d_dev->si_drv1 = sc; + sc->sc_dev = diskdev; + raidPtr->sc = sc; + + /* Register with devstat */ + devstat_add_entry(&sc->device_stats, "raid", raidPtr->raidid, 0, + DEVSTAT_NO_BLOCKSIZE | DEVSTAT_NO_ORDERED_TAGS, + DEVSTAT_TYPE_IF_OTHER, DEVSTAT_PRIORITY_ARRAY); + + return (diskdev); +} + +/* wake up the daemon & tell it to get us a spare table + * XXX + * the entries in the queues should be tagged with the raidPtr + * so that in the extremely rare case that two recons happen at once, + * we know for which device were requesting a spare table + * XXX + * + * XXX This code is not currently used. GO + */ +int +rf_GetSpareTableFromDaemon(req) + RF_SparetWait_t *req; +{ + int retcode; + + RF_LOCK_MUTEX(rf_sparet_wait_mutex); + req->next = rf_sparet_wait_queue; + rf_sparet_wait_queue = req; + wakeup(&rf_sparet_wait_queue); + + /* mpsleep unlocks the mutex */ + while (!rf_sparet_resp_queue) { + tsleep(&rf_sparet_resp_queue, PRIBIO, + "raidframe getsparetable", 0); + } + req = rf_sparet_resp_queue; + rf_sparet_resp_queue = req->next; + RF_UNLOCK_MUTEX(rf_sparet_wait_mutex); + + retcode = req->fcol; + RF_Free(req, sizeof(*req)); /* this is not the same req as we + * alloc'd */ + return (retcode); +} + +/* a wrapper around rf_DoAccess that extracts appropriate info from the + * bp & passes it down. + * any calls originating in the kernel must use non-blocking I/O + * do some extra sanity checking to return "appropriate" error values for + * certain conditions (to make some standard utilities work) + * + * Formerly known as: rf_DoAccessKernel + */ +void +raidstart(raidPtr) + RF_Raid_t *raidPtr; +{ + RF_SectorCount_t num_blocks, pb, sum; + RF_RaidAddr_t raid_addr; + struct raid_softc *sc; + struct bio *bp; + daddr_t blocknum; + int unit, retcode, do_async; + + unit = raidPtr->raidid; + sc = raidPtr->sc; + + /* quick check to see if anything has died recently */ + RF_LOCK_MUTEX(raidPtr->mutex); + if (raidPtr->numNewFailures > 0) { + raidPtr->numNewFailures--; + RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_update_component_labels(raidPtr, + RF_NORMAL_COMPONENT_UPDATE); + } else + RF_UNLOCK_MUTEX(raidPtr->mutex); + + /* Check to see if we're at the limit... */ + RF_LOCK_MUTEX(raidPtr->mutex); + while (raidPtr->openings > 0) { + RF_UNLOCK_MUTEX(raidPtr->mutex); + + /* get the next item, if any, from the queue */ + if ((bp = bioq_first(&sc->bio_queue)) == NULL) { + /* nothing more to do */ + return; + } + bioq_remove(&sc->bio_queue, bp); + + /* Ok, for the bp we have here, bp->b_blkno is relative to the + * partition.. Need to make it absolute to the underlying + * device.. */ + + blocknum = bp->bio_blkno; +#if 0 /* XXX Is this needed? */ + if (DISKPART(bp->bio_dev) != RAW_PART) { + struct partition *pp; + pp = &sc->sc_dkdev.d_label.d_partitions[DISKPART( + bp->bio_dev)]; + blocknum += pp->p_offset; + } +#endif + + rf_printf(3, "Blocks: %ld, %ld\n", (long)bp->bio_blkno, (long)blocknum); + + rf_printf(3, "bp->bio_bcount = %d\n", (int) bp->bio_bcount); + rf_printf(3, "bp->bio_resid = %d\n", (int) bp->bio_resid); + + /* *THIS* is where we adjust what block we're going to... + * but DO NOT TOUCH bp->bio_blkno!!! */ + raid_addr = blocknum; + + num_blocks = bp->bio_bcount >> raidPtr->logBytesPerSector; + pb = (bp->bio_bcount & raidPtr->sectorMask) ? 1 : 0; + sum = raid_addr + num_blocks + pb; + if (rf_debugKernelAccess) { + rf_printf(0, "raid_addr=0x%x sum=%d num_blocks=%d(+%d) " + "(%d)\n", (int)raid_addr, (int)sum, + (int)num_blocks, (int)pb, + (int)bp->bio_resid); + } + if ((sum > raidPtr->totalSectors) || (sum < raid_addr) + || (sum < num_blocks) || (sum < pb)) { + bp->bio_error = ENOSPC; + bp->bio_flags |= BIO_ERROR; + bp->bio_resid = bp->bio_bcount; + biodone(bp); + RF_LOCK_MUTEX(raidPtr->mutex); + continue; + } + /* + * XXX rf_DoAccess() should do this, not just DoAccessKernel() + */ + + if (bp->bio_bcount & raidPtr->sectorMask) { + bp->bio_error = EINVAL; + bp->bio_flags |= BIO_ERROR; + bp->bio_resid = bp->bio_bcount; + biodone(bp); + RF_LOCK_MUTEX(raidPtr->mutex); + continue; + + } + rf_printf(3, "Calling DoAccess..\n"); + + + RF_LOCK_MUTEX(raidPtr->mutex); + raidPtr->openings--; + RF_UNLOCK_MUTEX(raidPtr->mutex); + + /* + * Everything is async. + */ + do_async = 1; + + devstat_start_transaction(&sc->device_stats); + + /* XXX we're still at splbio() here... do we *really* + need to be? */ + + /* don't ever condition on bp->bio_cmd & BIO_WRITE. + * always condition on BIO_READ instead */ + + retcode = rf_DoAccess(raidPtr, (bp->bio_cmd & BIO_READ) ? + RF_IO_TYPE_READ : RF_IO_TYPE_WRITE, + do_async, raid_addr, num_blocks, + bp->bio_data, bp, NULL, NULL, + RF_DAG_NONBLOCKING_IO, NULL, NULL, NULL); + + + RF_LOCK_MUTEX(raidPtr->mutex); + } + RF_UNLOCK_MUTEX(raidPtr->mutex); +} + + + + +/* invoke an I/O from kernel mode. Disk queue should be locked upon entry */ + +int +rf_DispatchKernelIO(queue, req) + RF_DiskQueue_t *queue; + RF_DiskQueueData_t *req; +{ + int op = (req->type == RF_IO_TYPE_READ) ? BIO_READ : BIO_WRITE; + struct bio *bp; + struct raidbuf *raidbp = NULL; + struct raid_softc *sc; + + /* XXX along with the vnode, we also need the softc associated with + * this device.. */ + + req->queue = queue; + + sc = queue->raidPtr->sc; + + rf_printf(3, "DispatchKernelIO %s\n", sc->sc_dev->si_name); + + bp = req->bp; +#if 1 + /* XXX when there is a physical disk failure, someone is passing us a + * buffer that contains old stuff!! Attempt to deal with this problem + * without taking a performance hit... (not sure where the real bug + * is. It's buried in RAIDframe somewhere) :-( GO ) */ + + if (bp->bio_flags & BIO_ERROR) { + bp->bio_flags &= ~BIO_ERROR; + } + if (bp->bio_error != 0) { + bp->bio_error = 0; + } +#endif + raidbp = RAIDGETBUF(sc); + + raidbp->rf_flags = 0; /* XXX not really used anywhere... */ + + /* + * context for raidiodone + */ + raidbp->rf_obp = bp; + raidbp->req = req; + +#if 0 /* XXX */ + LIST_INIT(&raidbp->rf_buf.b_dep); +#endif + + switch (req->type) { + case RF_IO_TYPE_NOP: /* used primarily to unlock a locked queue */ + /* XXX need to do something extra here.. */ + /* I'm leaving this in, as I've never actually seen it used, + * and I'd like folks to report it... GO */ + rf_printf(2, "WAKEUP CALLED\n"); + queue->numOutstanding++; + + /* XXX need to glue the original buffer into this? */ + + KernelWakeupFunc(&raidbp->rf_buf); + break; + + case RF_IO_TYPE_READ: + case RF_IO_TYPE_WRITE: + + if (req->tracerec) { + RF_ETIMER_START(req->tracerec->timer); + } + InitBP(&raidbp->rf_buf, queue->rf_cinfo->ci_vp, + op | bp->bio_cmd, queue->rf_cinfo->ci_dev, + req->sectorOffset, req->numSector, + req->buf, KernelWakeupFunc, (void *) req, + queue->raidPtr->logBytesPerSector, req->b_proc); + + if (rf_debugKernelAccess) { + rf_printf(0, "dispatch: bp->bio_blkno = %ld\n", + (long) bp->bio_blkno); + } + queue->numOutstanding++; + queue->last_deq_sector = req->sectorOffset; + /* acc wouldn't have been let in if there were any pending + * reqs at any other priority */ + queue->curPriority = req->priority; + + rf_printf(3, "Going for %c to %s row %d col %d\n", + req->type, sc->sc_dev->si_name, queue->row, queue->col); + rf_printf(3, "sector %d count %d (%d bytes) %d\n", + (int) req->sectorOffset, (int) req->numSector, + (int) (req->numSector << + queue->raidPtr->logBytesPerSector), + (int) queue->raidPtr->logBytesPerSector); +#if 0 /* XXX */ + if ((raidbp->rf_buf.bio_cmd & BIO_READ) == 0) { + raidbp->rf_buf.b_vp->v_numoutput++; + } +#endif + BIO_STRATEGY(&raidbp->rf_buf, 0); + + break; + + default: + panic("bad req->type in rf_DispatchKernelIO"); + } + rf_printf(3, "Exiting from DispatchKernelIO\n"); + /* splx(s); */ /* want to test this */ + return (0); +} +/* this is the callback function associated with a I/O invoked from + kernel code. + */ +static void +KernelWakeupFunc(vbp) + struct bio *vbp; +{ + RF_DiskQueueData_t *req = NULL; + RF_DiskQueue_t *queue; + struct raidbuf *raidbp = (struct raidbuf *) vbp; + struct bio *bp; + struct raid_softc *sc; + int s; + + s = splbio(); + rf_printf(2, "recovering the request queue:\n"); + req = raidbp->req; + + bp = raidbp->rf_obp; + queue = (RF_DiskQueue_t *) req->queue; + sc = queue->raidPtr->sc; + + if (raidbp->rf_buf.bio_flags & BIO_ERROR) { + bp->bio_flags |= BIO_ERROR; + bp->bio_error = raidbp->rf_buf.bio_error ? + raidbp->rf_buf.bio_error : EIO; + } + + /* XXX methinks this could be wrong... */ +#if 1 + bp->bio_resid = raidbp->rf_buf.bio_resid; +#endif + + if (req->tracerec) { + RF_ETIMER_STOP(req->tracerec->timer); + RF_ETIMER_EVAL(req->tracerec->timer); + RF_LOCK_MUTEX(rf_tracing_mutex); + req->tracerec->diskwait_us += RF_ETIMER_VAL_US(req->tracerec->timer); + req->tracerec->phys_io_us += RF_ETIMER_VAL_US(req->tracerec->timer); + req->tracerec->num_phys_ios++; + RF_UNLOCK_MUTEX(rf_tracing_mutex); + } + bp->bio_bcount = raidbp->rf_buf.bio_bcount; /* XXXX ? */ + + /* XXX Ok, let's get aggressive... If BIO_ERROR is set, let's go + * ballistic, and mark the component as hosed... */ + + if (bp->bio_flags & BIO_ERROR) { + /* Mark the disk as dead */ + /* but only mark it once... */ + if (queue->raidPtr->Disks[queue->row][queue->col].status == + rf_ds_optimal) { + rf_printf(0, "%s: IO Error. Marking %s as " + "failed.\n", sc->sc_dev->si_name, queue->raidPtr-> + Disks[queue->row][queue->col].devname); + queue->raidPtr->Disks[queue->row][queue->col].status = + rf_ds_failed; + queue->raidPtr->status[queue->row] = rf_rs_degraded; + queue->raidPtr->numFailures++; + queue->raidPtr->numNewFailures++; + } else { /* Disk is already dead... */ + /* printf("Disk already marked as dead!\n"); */ + } + + } + + RAIDPUTBUF(sc, raidbp); + + rf_DiskIOComplete(queue, req, (bp->bio_flags & BIO_ERROR) ? 1 : 0); + (req->CompleteFunc)(req->argument, (bp->bio_flags & BIO_ERROR) ? 1 : 0); + + splx(s); +} + + + +/* + * initialize a buf structure for doing an I/O in the kernel. + */ +static void +InitBP(bp, b_vp, rw_flag, dev, startSect, numSect, buf, cbFunc, cbArg, + logBytesPerSector, b_proc) + struct bio *bp; + struct vnode *b_vp; + unsigned rw_flag; + dev_t dev; + RF_SectorNum_t startSect; + RF_SectorCount_t numSect; + caddr_t buf; + void (*cbFunc) (struct bio *); + void *cbArg; + int logBytesPerSector; + struct proc *b_proc; +{ + /* bp->b_flags = B_PHYS | rw_flag; */ + bp->bio_cmd = rw_flag; /* XXX need B_PHYS here too? */ + bp->bio_bcount = numSect << logBytesPerSector; +#if 0 /* XXX */ + bp->bio_bufsize = bp->bio_bcount; +#endif + bp->bio_error = 0; + bp->bio_dev = dev; + bp->bio_data = buf; + bp->bio_blkno = startSect; + bp->bio_resid = bp->bio_bcount; /* XXX is this right!?!?!! */ + if (bp->bio_bcount == 0) { + panic("bp->bio_bcount is zero in InitBP!!\n"); + } +/* + bp->b_proc = b_proc; + bp->b_vp = b_vp; +*/ + bp->bio_done = cbFunc; + +} + +static void +raidgetdefaultlabel(raidPtr, sc, dp) + RF_Raid_t *raidPtr; + struct raid_softc *sc; + struct disk *dp; +{ + rf_printf(1, "Building a default label...\n"); + if (dp == NULL) + panic("raidgetdefaultlabel(): dp is NULL\n"); + + /* fabricate a label... */ + dp->d_mediasize = raidPtr->totalSectors * raidPtr->bytesPerSector; + dp->d_sectorsize = raidPtr->bytesPerSector; + dp->d_fwsectors = raidPtr->Layout.dataSectorsPerStripe; + dp->d_fwheads = 4 * raidPtr->numCol; + +} +/* + * Lookup the provided name in the filesystem. If the file exists, + * is a valid block device, and isn't being used by anyone else, + * set *vpp to the file's vnode. + * You'll find the original of this in ccd.c + */ +int +raidlookup(path, td, vpp) + char *path; + struct thread *td; + struct vnode **vpp; /* result */ +{ + struct nameidata *nd; + struct vnode *vp; + struct vattr *va; + struct proc *p; + int error = 0, flags; + + MALLOC(nd, struct nameidata *, sizeof(struct nameidata), M_TEMP, M_NOWAIT | M_ZERO); + MALLOC(va, struct vattr *, sizeof(struct vattr), M_TEMP, M_NOWAIT | M_ZERO); + if ((nd == NULL) || (va == NULL)) { + printf("Out of memory?\n"); + return (ENOMEM); + } + + /* Sanity check the p_fd fields. This is really just a hack */ + p = td->td_proc; + if (!p->p_fd->fd_rdir || !p->p_fd->fd_cdir) + printf("Warning: p_fd fields not set\n"); + + if (!td->td_proc->p_fd->fd_rdir) + p->p_fd->fd_rdir = rootvnode; + + if (!p->p_fd->fd_cdir) + p->p_fd->fd_cdir = rootvnode; + + NDINIT(nd, LOOKUP, FOLLOW, UIO_SYSSPACE, path, curthread); + flags = FREAD | FWRITE; + if ((error = vn_open(nd, &flags, 0)) != 0) { + rf_printf(2, "RAIDframe: vn_open returned %d\n", error); + goto end1; + } + vp = nd->ni_vp; + if (vp->v_usecount > 1) { + rf_printf(1, "raidlookup() vp->v_usecount= %d\n", vp->v_usecount); + error = EBUSY; + goto end; + } + if ((error = VOP_GETATTR(vp, va, td->td_ucred, td)) != 0) { + rf_printf(1, "raidlookup() VOP_GETATTR returned %d", error); + goto end; + } + /* XXX: eventually we should handle VREG, too. */ + if (va->va_type != VCHR) { + rf_printf(1, "Returning ENOTBLK\n"); + error = ENOTBLK; + } + *vpp = vp; + +end: + VOP_UNLOCK(vp, 0, td); + NDFREE(nd, NDF_ONLY_PNBUF); +end1: + FREE(nd, M_TEMP); + FREE(va, M_TEMP); + return (error); +} +/* + * Wait interruptibly for an exclusive lock. + * + * XXX + * Several drivers do this; it should be abstracted and made MP-safe. + * (Hmm... where have we seen this warning before :-> GO ) + */ +static int +raidlock(sc) + struct raid_softc *sc; +{ + int error; + + while ((sc->sc_flags & RAIDF_LOCKED) != 0) { + sc->sc_flags |= RAIDF_WANTED; + if ((error = + tsleep(sc, PRIBIO | PCATCH, "raidlck", 0)) != 0) + return (error); + } + sc->sc_flags |= RAIDF_LOCKED; + return (0); +} +/* + * Unlock and wake up any waiters. + */ +static void +raidunlock(sc) + struct raid_softc *sc; +{ + + sc->sc_flags &= ~RAIDF_LOCKED; + if ((sc->sc_flags & RAIDF_WANTED) != 0) { + sc->sc_flags &= ~RAIDF_WANTED; + wakeup(sc); + } +} + + +#define RF_COMPONENT_INFO_OFFSET 16384 /* bytes */ +#define RF_COMPONENT_INFO_SIZE 1024 /* bytes */ + +int +raidmarkclean(dev_t dev, struct vnode *b_vp, int mod_counter) +{ + RF_ComponentLabel_t *clabel; + + MALLOC(clabel, RF_ComponentLabel_t *, sizeof(RF_ComponentLabel_t), + M_RAIDFRAME, M_NOWAIT | M_ZERO); + if (clabel == NULL) { + printf("raidmarkclean: Out of memory?\n"); + return (ENOMEM); + } + + raidread_component_label(dev, b_vp, clabel); + clabel->mod_counter = mod_counter; + clabel->clean = RF_RAID_CLEAN; + raidwrite_component_label(dev, b_vp, clabel); + FREE(clabel, M_RAIDFRAME); + return(0); +} + + +int +raidmarkdirty(dev_t dev, struct vnode *b_vp, int mod_counter) +{ + RF_ComponentLabel_t *clabel; + + MALLOC(clabel, RF_ComponentLabel_t *, sizeof(RF_ComponentLabel_t), + M_RAIDFRAME, M_NOWAIT | M_ZERO); + if (clabel == NULL) { + printf("raidmarkclean: Out of memory?\n"); + return (ENOMEM); + } + + raidread_component_label(dev, b_vp, clabel); + clabel->mod_counter = mod_counter; + clabel->clean = RF_RAID_DIRTY; + raidwrite_component_label(dev, b_vp, clabel); + FREE(clabel, M_RAIDFRAME); + return(0); +} + +/* ARGSUSED */ +int +raidread_component_label(dev, b_vp, clabel) + dev_t dev; + struct vnode *b_vp; + RF_ComponentLabel_t *clabel; +{ + struct buf *bp; + int error; + + /* XXX should probably ensure that we don't try to do this if + someone has changed rf_protected_sectors. */ + + if (b_vp == NULL) { + /* For whatever reason, this component is not valid. + Don't try to read a component label from it. */ + return(EINVAL); + } + + /* get a block of the appropriate size... */ + bp = geteblk((int)RF_COMPONENT_INFO_SIZE); + bp->b_dev = dev; + + /* get our ducks in a row for the read */ + bp->b_blkno = RF_COMPONENT_INFO_OFFSET / DEV_BSIZE; + bp->b_bcount = RF_COMPONENT_INFO_SIZE; + bp->b_iocmd = BIO_READ; + bp->b_resid = RF_COMPONENT_INFO_SIZE / DEV_BSIZE; + + DEV_STRATEGY(bp, 0); + error = bufwait(bp); + + if (!error) { + memcpy(clabel, bp->b_data, sizeof(RF_ComponentLabel_t)); +#if 0 + rf_print_component_label( clabel ); +#endif + } else { +#if 0 + rf_printf(0, "Failed to read RAID component label!\n"); +#endif + } + + bp->b_flags |= B_INVAL | B_AGE; + brelse(bp); + return(error); +} +/* ARGSUSED */ +int +raidwrite_component_label(dev, b_vp, clabel) + dev_t dev; + struct vnode *b_vp; + RF_ComponentLabel_t *clabel; +{ + struct buf *bp; + int error; + + /* get a block of the appropriate size... */ + bp = geteblk((int)RF_COMPONENT_INFO_SIZE); + bp->b_dev = dev; + + /* get our ducks in a row for the write */ + bp->b_flags = 0; + bp->b_blkno = RF_COMPONENT_INFO_OFFSET / DEV_BSIZE; + bp->b_bcount = RF_COMPONENT_INFO_SIZE; + bp->b_iocmd = BIO_WRITE; + bp->b_resid = RF_COMPONENT_INFO_SIZE / DEV_BSIZE; + + memset(bp->b_data, 0, RF_COMPONENT_INFO_SIZE ); + + memcpy(bp->b_data, clabel, sizeof(RF_ComponentLabel_t)); + + DEV_STRATEGY(bp, 0); + error = bufwait(bp); + + bp->b_flags |= B_INVAL | B_AGE; + brelse(bp); + if (error) { +#if 1 + rf_printf(0, "Failed to write RAID component info!\n"); + rf_printf(0, "b_error= %d\n", bp->b_error); +#endif + } + + return(error); +} + +void +rf_markalldirty(raidPtr) + RF_Raid_t *raidPtr; +{ + RF_ComponentLabel_t *clabel; + int r,c; + + MALLOC(clabel, RF_ComponentLabel_t *, sizeof(RF_ComponentLabel_t), + M_RAIDFRAME, M_NOWAIT | M_ZERO); + + if (clabel == NULL) { + printf("rf_markalldirty: Out of memory?\n"); + return; + } + + raidPtr->mod_counter++; + for (r = 0; r < raidPtr->numRow; r++) { + for (c = 0; c < raidPtr->numCol; c++) { + /* we don't want to touch (at all) a disk that has + failed */ + if (!RF_DEAD_DISK(raidPtr->Disks[r][c].status)) { + raidread_component_label( + raidPtr->Disks[r][c].dev, + raidPtr->raid_cinfo[r][c].ci_vp, + clabel); + if (clabel->status == rf_ds_spared) { + /* XXX do something special... + but whatever you do, don't + try to access it!! */ + } else { +#if 0 + clabel->status = + raidPtr->Disks[r][c].status; + raidwrite_component_label( + raidPtr->Disks[r][c].dev, + raidPtr->raid_cinfo[r][c].ci_vp, + clabel); +#endif + raidmarkdirty( + raidPtr->Disks[r][c].dev, + raidPtr->raid_cinfo[r][c].ci_vp, + raidPtr->mod_counter); + } + } + } + } + /* printf("Component labels marked dirty.\n"); */ +#if 0 + for( c = 0; c < raidPtr->numSpare ; c++) { + sparecol = raidPtr->numCol + c; + if (raidPtr->Disks[r][sparecol].status == rf_ds_used_spare) { + /* + + XXX this is where we get fancy and map this spare + into it's correct spot in the array. + + */ + /* + + we claim this disk is "optimal" if it's + rf_ds_used_spare, as that means it should be + directly substitutable for the disk it replaced. + We note that too... + + */ + + for(i=0;i<raidPtr->numRow;i++) { + for(j=0;j<raidPtr->numCol;j++) { + if ((raidPtr->Disks[i][j].spareRow == + r) && + (raidPtr->Disks[i][j].spareCol == + sparecol)) { + srow = r; + scol = sparecol; + break; + } + } + } + + raidread_component_label( + raidPtr->Disks[r][sparecol].dev, + raidPtr->raid_cinfo[r][sparecol].ci_vp, + &clabel); + /* make sure status is noted */ + clabel.version = RF_COMPONENT_LABEL_VERSION; + clabel.mod_counter = raidPtr->mod_counter; + clabel.serial_number = raidPtr->serial_number; + clabel.row = srow; + clabel.column = scol; + clabel.num_rows = raidPtr->numRow; + clabel.num_columns = raidPtr->numCol; + clabel.clean = RF_RAID_DIRTY; /* changed in a bit*/ + clabel.status = rf_ds_optimal; + raidwrite_component_label( + raidPtr->Disks[r][sparecol].dev, + raidPtr->raid_cinfo[r][sparecol].ci_vp, + &clabel); + raidmarkclean( raidPtr->Disks[r][sparecol].dev, + raidPtr->raid_cinfo[r][sparecol].ci_vp); + } + } + +#endif + FREE(clabel, M_RAIDFRAME); +} + + +void +rf_update_component_labels(raidPtr, final) + RF_Raid_t *raidPtr; + int final; +{ + RF_ComponentLabel_t *clabel; + int sparecol; + int r,c; + int i,j; + int srow, scol; + + srow = -1; + scol = -1; + + MALLOC(clabel, RF_ComponentLabel_t *, sizeof(RF_ComponentLabel_t), + M_RAIDFRAME, M_NOWAIT | M_ZERO); + if (clabel == NULL) { + printf("rf_update_component_labels: Out of memory?\n"); + return; + } + + /* XXX should do extra checks to make sure things really are clean, + rather than blindly setting the clean bit... */ + + raidPtr->mod_counter++; + + for (r = 0; r < raidPtr->numRow; r++) { + for (c = 0; c < raidPtr->numCol; c++) { + if (raidPtr->Disks[r][c].status == rf_ds_optimal) { + raidread_component_label( + raidPtr->Disks[r][c].dev, + raidPtr->raid_cinfo[r][c].ci_vp, + clabel); + /* make sure status is noted */ + clabel->status = rf_ds_optimal; + /* bump the counter */ + clabel->mod_counter = raidPtr->mod_counter; + + raidwrite_component_label( + raidPtr->Disks[r][c].dev, + raidPtr->raid_cinfo[r][c].ci_vp, + clabel); + if (final == RF_FINAL_COMPONENT_UPDATE) { + if (raidPtr->parity_good == RF_RAID_CLEAN) { + raidmarkclean( + raidPtr->Disks[r][c].dev, + raidPtr->raid_cinfo[r][c].ci_vp, + raidPtr->mod_counter); + } + } + } + /* else we don't touch it.. */ + } + } + + for( c = 0; c < raidPtr->numSpare ; c++) { + sparecol = raidPtr->numCol + c; + if (raidPtr->Disks[0][sparecol].status == rf_ds_used_spare) { + /* + + we claim this disk is "optimal" if it's + rf_ds_used_spare, as that means it should be + directly substitutable for the disk it replaced. + We note that too... + + */ + + for(i=0;i<raidPtr->numRow;i++) { + for(j=0;j<raidPtr->numCol;j++) { + if ((raidPtr->Disks[i][j].spareRow == + 0) && + (raidPtr->Disks[i][j].spareCol == + sparecol)) { + srow = i; + scol = j; + break; + } + } + } + + /* XXX shouldn't *really* need this... */ + raidread_component_label( + raidPtr->Disks[0][sparecol].dev, + raidPtr->raid_cinfo[0][sparecol].ci_vp, + clabel); + /* make sure status is noted */ + + raid_init_component_label(raidPtr, clabel); + + clabel->mod_counter = raidPtr->mod_counter; + clabel->row = srow; + clabel->column = scol; + clabel->status = rf_ds_optimal; + + raidwrite_component_label( + raidPtr->Disks[0][sparecol].dev, + raidPtr->raid_cinfo[0][sparecol].ci_vp, + clabel); + if (final == RF_FINAL_COMPONENT_UPDATE) { + if (raidPtr->parity_good == RF_RAID_CLEAN) { + raidmarkclean( raidPtr->Disks[0][sparecol].dev, + raidPtr->raid_cinfo[0][sparecol].ci_vp, + raidPtr->mod_counter); + } + } + } + } + FREE(clabel, M_RAIDFRAME); + rf_printf(1, "Component labels updated\n"); +} + +void +rf_close_component(raidPtr, vp, auto_configured) + RF_Raid_t *raidPtr; + struct vnode *vp; + int auto_configured; +{ + struct thread *td; + + td = raidPtr->engine_thread; + + if (vp != NULL) { + if (auto_configured == 1) { + VOP_CLOSE(vp, FREAD | FWRITE, td->td_ucred, td); + + vrele(vp); + } else { + vn_close(vp, FREAD | FWRITE, td->td_ucred, td); + } + } else { + rf_printf(1, "vnode was NULL\n"); + } +} + + +void +rf_UnconfigureVnodes(raidPtr) + RF_Raid_t *raidPtr; +{ + int r,c; + struct thread *td; + struct vnode *vp; + int acd; + + + /* We take this opportunity to close the vnodes like we should.. */ + + td = raidPtr->engine_thread; + + for (r = 0; r < raidPtr->numRow; r++) { + for (c = 0; c < raidPtr->numCol; c++) { + rf_printf(1, "Closing vnode for row: %d col: %d\n", r, c); + vp = raidPtr->raid_cinfo[r][c].ci_vp; + acd = raidPtr->Disks[r][c].auto_configured; + rf_close_component(raidPtr, vp, acd); + raidPtr->raid_cinfo[r][c].ci_vp = NULL; + raidPtr->Disks[r][c].auto_configured = 0; + } + } + for (r = 0; r < raidPtr->numSpare; r++) { + rf_printf(1, "Closing vnode for spare: %d\n", r); + vp = raidPtr->raid_cinfo[0][raidPtr->numCol + r].ci_vp; + acd = raidPtr->Disks[0][raidPtr->numCol + r].auto_configured; + rf_close_component(raidPtr, vp, acd); + raidPtr->raid_cinfo[0][raidPtr->numCol + r].ci_vp = NULL; + raidPtr->Disks[0][raidPtr->numCol + r].auto_configured = 0; + } +} + + +void +rf_ReconThread(req) + struct rf_recon_req *req; +{ + RF_Raid_t *raidPtr; + + mtx_lock(&Giant); + raidPtr = (RF_Raid_t *) req->raidPtr; + raidPtr->recon_in_progress = 1; + + rf_FailDisk((RF_Raid_t *) req->raidPtr, req->row, req->col, + ((req->flags & RF_FDFLAGS_RECON) ? 1 : 0)); + + /* XXX get rid of this! we don't need it at all.. */ + RF_Free(req, sizeof(*req)); + + raidPtr->recon_in_progress = 0; + + /* That's all... */ + RF_THREAD_EXIT(0); /* does not return */ +} + +void +rf_RewriteParityThread(raidPtr) + RF_Raid_t *raidPtr; +{ + int retcode; + + mtx_lock(&Giant); + raidPtr->parity_rewrite_in_progress = 1; + retcode = rf_RewriteParity(raidPtr); + if (retcode) { + rf_printf(0, "raid%d: Error re-writing parity!\n",raidPtr->raidid); + } else { + /* set the clean bit! If we shutdown correctly, + the clean bit on each component label will get + set */ + raidPtr->parity_good = RF_RAID_CLEAN; + } + raidPtr->parity_rewrite_in_progress = 0; + + /* Anyone waiting for us to stop? If so, inform them... */ + if (raidPtr->waitShutdown) { + wakeup(&raidPtr->parity_rewrite_in_progress); + } + + /* That's all... */ + RF_THREAD_EXIT(0); /* does not return */ +} + + +void +rf_CopybackThread(raidPtr) + RF_Raid_t *raidPtr; +{ + mtx_lock(&Giant); + raidPtr->copyback_in_progress = 1; + rf_CopybackReconstructedData(raidPtr); + raidPtr->copyback_in_progress = 0; + + /* That's all... */ + RF_THREAD_EXIT(0); /* does not return */ +} + + +void +rf_ReconstructInPlaceThread(req) + struct rf_recon_req *req; +{ + int retcode; + RF_Raid_t *raidPtr; + + mtx_lock(&Giant); + raidPtr = req->raidPtr; + raidPtr->recon_in_progress = 1; + retcode = rf_ReconstructInPlace(raidPtr, req->row, req->col); + RF_Free(req, sizeof(*req)); + raidPtr->recon_in_progress = 0; + + /* That's all... */ + RF_THREAD_EXIT(0); /* does not return */ +} + +RF_AutoConfig_t * +rf_find_raid_components() +{ + RF_AutoConfig_t *ac_list = NULL; +#if 0 /* XXX GEOM */ + struct vnode *vp; + struct disklabel *label; + struct diskslice *slice; + struct diskslices *slices; + struct disk *disk; + struct thread *td; + dev_t dev; + char *devname; + int error, j; + int nslices; + + td = curthread; + + MALLOC(label, struct disklabel *, sizeof(struct disklabel), + M_RAIDFRAME, M_NOWAIT|M_ZERO); + MALLOC(slices, struct diskslices *, sizeof(struct diskslices), + M_RAIDFRAME, M_NOWAIT|M_ZERO); + if ((label == NULL) || (slices == NULL)) { + printf("rf_find_raid_components: Out of Memory?\n"); + return (NULL); + } + + /* initialize the AutoConfig list */ + ac_list = NULL; + + /* we begin by trolling through *all* the disk devices on the system */ + + disk = NULL; + while ((disk = disk_enumerate(disk))) { + + /* we don't care about floppies... */ + devname = disk->d_dev->si_name; + if (!strncmp(devname, "fd", 2) || + !strncmp(devname, "cd", 2) || + !strncmp(devname, "acd", 3)) + continue; + + rf_printf(1, "Examining %s\n", disk->d_dev->si_name); + if (bdevvp(disk->d_dev, &vp)) + panic("RAIDframe can't alloc vnode"); + vref(vp); + + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_OPEN(vp, FREAD, td->td_ucred, td); + VOP_UNLOCK(vp, 0, td); + if (error) { + vput(vp); + continue; + } + + error = VOP_IOCTL(vp, DIOCGSLICEINFO, (caddr_t)slices, + FREAD, td->td_ucred, td); + VOP_CLOSE(vp, FREAD | FWRITE, td->td_ucred, td); + vrele(vp); + if (error) { + /* No slice table. */ + continue; + } + + nslices = slices->dss_nslices; + if ((nslices == 0) || (nslices > MAX_SLICES)) + continue; + + /* Iterate through the slices */ + for (j = 1; j < nslices; j++) { + + rf_printf(1, "Examining slice %d\n", j); + slice = &slices->dss_slices[j - 1]; + dev = dkmodslice(disk->d_dev, j); + if (bdevvp(dev, &vp)) + panic("RAIDframe can't alloc vnode"); + + vref(vp); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_OPEN(vp, FREAD, td->td_ucred, td); + VOP_UNLOCK(vp, 0, td); + if (error) { + continue; + } + + error = VOP_IOCTL(vp, DIOCGDINFO, (caddr_t)label, + FREAD, td->td_ucred, td); + VOP_CLOSE(vp, FREAD | FWRITE, td->td_ucred, td); + vrele(vp); + if (error) + continue; + + rf_search_label(dev, label, &ac_list); + } + } + + FREE(label, M_RAIDFRAME); + FREE(slices, M_RAIDFRAME); +#endif + return (ac_list); +} + +static void +rf_search_label(dev_t dev, struct disklabel *label, RF_AutoConfig_t **ac_list) +{ + RF_AutoConfig_t *ac; + RF_ComponentLabel_t *clabel; + struct vnode *vp; + struct thread *td; + dev_t dev1; + int i, error, good_one; + + td = curthread; + + /* Iterate through the partitions */ + for (i=0; i < label->d_npartitions; i++) { + /* We only support partitions marked as RAID */ + if (label->d_partitions[i].p_fstype != FS_RAID) + continue; + + dev1 = dkmodpart(dev, i); + if (dev1 == NULL) { + rf_printf(1, "dev1 == null\n"); + continue; + } + if (bdevvp(dev1, &vp)) + panic("RAIDframe can't alloc vnode"); + + vref(vp); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_OPEN(vp, FREAD, td->td_ucred, td); + VOP_UNLOCK(vp, 0, td); + if (error) { + /* Whatever... */ + continue; + } + + good_one = 0; + + clabel = (RF_ComponentLabel_t *) + malloc(sizeof(RF_ComponentLabel_t), M_RAIDFRAME, + M_NOWAIT); + if (clabel == NULL) { + /* XXX CLEANUP HERE */ + panic("RAID autoconfig: no memory!\n"); + } + + if (!raidread_component_label(dev1, vp, clabel)) { + /* Got the label. Is it reasonable? */ + if (rf_reasonable_label(clabel) && + (clabel->partitionSize <= + label->d_partitions[i].p_size)) { + rf_printf(1, "Component on: %s: %d\n", + dev1->si_name, label->d_partitions[i].p_size); + rf_print_component_label(clabel); + /* if it's reasonable, add it, else ignore it */ + ac = (RF_AutoConfig_t *) + malloc(sizeof(RF_AutoConfig_t), + M_RAIDFRAME, M_NOWAIT); + if (ac == NULL) { + /* XXX should panic? */ + panic("RAID autoconfig: no memory!\n"); + } + + sprintf(ac->devname, "%s", dev->si_name); + ac->dev = dev1; + ac->vp = vp; + ac->clabel = clabel; + ac->next = *ac_list; + *ac_list = ac; + good_one = 1; + } + } + if (!good_one) { + /* cleanup */ + free(clabel, M_RAIDFRAME); + VOP_CLOSE(vp, FREAD | FWRITE, td->td_ucred, td); + vrele(vp); + } + } +} + +static int +rf_reasonable_label(clabel) + RF_ComponentLabel_t *clabel; +{ + + if (((clabel->version==RF_COMPONENT_LABEL_VERSION_1) || + (clabel->version==RF_COMPONENT_LABEL_VERSION)) && + ((clabel->clean == RF_RAID_CLEAN) || + (clabel->clean == RF_RAID_DIRTY)) && + clabel->row >=0 && + clabel->column >= 0 && + clabel->num_rows > 0 && + clabel->num_columns > 0 && + clabel->row < clabel->num_rows && + clabel->column < clabel->num_columns && + clabel->blockSize > 0 && + clabel->numBlocks > 0) { + /* label looks reasonable enough... */ + return(1); + } + return(0); +} + + +void +rf_print_component_label(clabel) + RF_ComponentLabel_t *clabel; +{ + rf_printf(1, " Row: %d Column: %d Num Rows: %d Num Columns: %d\n", + clabel->row, clabel->column, + clabel->num_rows, clabel->num_columns); + rf_printf(1, " Version: %d Serial Number: %d Mod Counter: %d\n", + clabel->version, clabel->serial_number, + clabel->mod_counter); + rf_printf(1, " Clean: %s Status: %d\n", + clabel->clean ? "Yes" : "No", clabel->status ); + rf_printf(1, " sectPerSU: %d SUsPerPU: %d SUsPerRU: %d\n", + clabel->sectPerSU, clabel->SUsPerPU, clabel->SUsPerRU); + rf_printf(1, " RAID Level: %c blocksize: %d numBlocks: %d\n", + (char) clabel->parityConfig, clabel->blockSize, + clabel->numBlocks); + rf_printf(1, " Autoconfig: %s\n", clabel->autoconfigure ? "Yes":"No"); + rf_printf(1, " Contains root partition: %s\n", + clabel->root_partition ? "Yes" : "No" ); + rf_printf(1, " Last configured as: raid%d\n", clabel->last_unit ); +#if 0 + rf_printf(1, " Config order: %d\n", clabel->config_order); +#endif + +} + +RF_ConfigSet_t * +rf_create_auto_sets(ac_list) + RF_AutoConfig_t *ac_list; +{ + RF_AutoConfig_t *ac; + RF_ConfigSet_t *config_sets; + RF_ConfigSet_t *cset; + RF_AutoConfig_t *ac_next; + + + config_sets = NULL; + + /* Go through the AutoConfig list, and figure out which components + belong to what sets. */ + ac = ac_list; + while(ac!=NULL) { + /* we're going to putz with ac->next, so save it here + for use at the end of the loop */ + ac_next = ac->next; + + if (config_sets == NULL) { + /* will need at least this one... */ + config_sets = (RF_ConfigSet_t *) + malloc(sizeof(RF_ConfigSet_t), + M_RAIDFRAME, M_NOWAIT); + if (config_sets == NULL) { + panic("rf_create_auto_sets: No memory!\n"); + } + /* this one is easy :) */ + config_sets->ac = ac; + config_sets->next = NULL; + config_sets->rootable = 0; + ac->next = NULL; + } else { + /* which set does this component fit into? */ + cset = config_sets; + while(cset!=NULL) { + if (rf_does_it_fit(cset, ac)) { + /* looks like it matches... */ + ac->next = cset->ac; + cset->ac = ac; + break; + } + cset = cset->next; + } + if (cset==NULL) { + /* didn't find a match above... new set..*/ + cset = (RF_ConfigSet_t *) + malloc(sizeof(RF_ConfigSet_t), + M_RAIDFRAME, M_NOWAIT); + if (cset == NULL) { + panic("rf_create_auto_sets: No memory!\n"); + } + cset->ac = ac; + ac->next = NULL; + cset->next = config_sets; + cset->rootable = 0; + config_sets = cset; + } + } + ac = ac_next; + } + + + return(config_sets); +} + +static int +rf_does_it_fit(cset, ac) + RF_ConfigSet_t *cset; + RF_AutoConfig_t *ac; +{ + RF_ComponentLabel_t *clabel1, *clabel2; + + /* If this one matches the *first* one in the set, that's good + enough, since the other members of the set would have been + through here too... */ + /* note that we are not checking partitionSize here.. + + Note that we are also not checking the mod_counters here. + If everything else matches execpt the mod_counter, that's + good enough for this test. We will deal with the mod_counters + a little later in the autoconfiguration process. + + (clabel1->mod_counter == clabel2->mod_counter) && + + The reason we don't check for this is that failed disks + will have lower modification counts. If those disks are + not added to the set they used to belong to, then they will + form their own set, which may result in 2 different sets, + for example, competing to be configured at raid0, and + perhaps competing to be the root filesystem set. If the + wrong ones get configured, or both attempt to become /, + weird behaviour and or serious lossage will occur. Thus we + need to bring them into the fold here, and kick them out at + a later point. + + */ + + clabel1 = cset->ac->clabel; + clabel2 = ac->clabel; + if ((clabel1->version == clabel2->version) && + (clabel1->serial_number == clabel2->serial_number) && + (clabel1->num_rows == clabel2->num_rows) && + (clabel1->num_columns == clabel2->num_columns) && + (clabel1->sectPerSU == clabel2->sectPerSU) && + (clabel1->SUsPerPU == clabel2->SUsPerPU) && + (clabel1->SUsPerRU == clabel2->SUsPerRU) && + (clabel1->parityConfig == clabel2->parityConfig) && + (clabel1->maxOutstanding == clabel2->maxOutstanding) && + (clabel1->blockSize == clabel2->blockSize) && + (clabel1->numBlocks == clabel2->numBlocks) && + (clabel1->autoconfigure == clabel2->autoconfigure) && + (clabel1->root_partition == clabel2->root_partition) && + (clabel1->last_unit == clabel2->last_unit) && + (clabel1->config_order == clabel2->config_order)) { + /* if it get's here, it almost *has* to be a match */ + } else { + /* it's not consistent with somebody in the set.. + punt */ + return(0); + } + /* all was fine.. it must fit... */ + return(1); +} + +int +rf_have_enough_components(cset) + RF_ConfigSet_t *cset; +{ + RF_AutoConfig_t *ac; + RF_AutoConfig_t *auto_config; + RF_ComponentLabel_t *clabel; + int r,c; + int num_rows; + int num_cols; + int num_missing; + int mod_counter; + int mod_counter_found; + int even_pair_failed; + char parity_type; + + + /* check to see that we have enough 'live' components + of this set. If so, we can configure it if necessary */ + + num_rows = cset->ac->clabel->num_rows; + num_cols = cset->ac->clabel->num_columns; + parity_type = cset->ac->clabel->parityConfig; + + /* XXX Check for duplicate components!?!?!? */ + + /* Determine what the mod_counter is supposed to be for this set. */ + + mod_counter_found = 0; + mod_counter = 0; + ac = cset->ac; + while(ac!=NULL) { + if (mod_counter_found==0) { + mod_counter = ac->clabel->mod_counter; + mod_counter_found = 1; + } else { + if (ac->clabel->mod_counter > mod_counter) { + mod_counter = ac->clabel->mod_counter; + } + } + ac = ac->next; + } + + num_missing = 0; + auto_config = cset->ac; + + for(r=0; r<num_rows; r++) { + even_pair_failed = 0; + for(c=0; c<num_cols; c++) { + ac = auto_config; + while(ac!=NULL) { + if ((ac->clabel->row == r) && + (ac->clabel->column == c) && + (ac->clabel->mod_counter == mod_counter)) { + /* it's this one... */ + rf_printf(1, "Found: %s at %d,%d\n", + ac->devname,r,c); + break; + } + ac=ac->next; + } + if (ac==NULL) { + /* Didn't find one here! */ + /* special case for RAID 1, especially + where there are more than 2 + components (where RAIDframe treats + things a little differently :( ) */ + if (parity_type == '1') { + if (c%2 == 0) { /* even component */ + even_pair_failed = 1; + } else { /* odd component. If + we're failed, and + so is the even + component, it's + "Good Night, Charlie" */ + if (even_pair_failed == 1) { + return(0); + } + } + } else { + /* normal accounting */ + num_missing++; + } + } + if ((parity_type == '1') && (c%2 == 1)) { + /* Just did an even component, and we didn't + bail.. reset the even_pair_failed flag, + and go on to the next component.... */ + even_pair_failed = 0; + } + } + } + + clabel = cset->ac->clabel; + + if (((clabel->parityConfig == '0') && (num_missing > 0)) || + ((clabel->parityConfig == '4') && (num_missing > 1)) || + ((clabel->parityConfig == '5') && (num_missing > 1))) { + /* XXX this needs to be made *much* more general */ + /* Too many failures */ + return(0); + } + /* otherwise, all is well, and we've got enough to take a kick + at autoconfiguring this set */ + return(1); +} + +void +rf_create_configuration(ac,config,raidPtr) + RF_AutoConfig_t *ac; + RF_Config_t *config; + RF_Raid_t *raidPtr; +{ + RF_ComponentLabel_t *clabel; + int i; + + clabel = ac->clabel; + + /* 1. Fill in the common stuff */ + config->numRow = clabel->num_rows; + config->numCol = clabel->num_columns; + config->numSpare = 0; /* XXX should this be set here? */ + config->sectPerSU = clabel->sectPerSU; + config->SUsPerPU = clabel->SUsPerPU; + config->SUsPerRU = clabel->SUsPerRU; + config->parityConfig = clabel->parityConfig; + /* XXX... */ + strcpy(config->diskQueueType,"fifo"); + config->maxOutstandingDiskReqs = clabel->maxOutstanding; + config->layoutSpecificSize = 0; /* XXX ? */ + + while(ac!=NULL) { + /* row/col values will be in range due to the checks + in reasonable_label() */ + strcpy(config->devnames[ac->clabel->row][ac->clabel->column], + ac->devname); + ac = ac->next; + } + + for(i=0;i<RF_MAXDBGV;i++) { + config->debugVars[i][0] = NULL; + } +} + +int +rf_set_autoconfig(raidPtr, new_value) + RF_Raid_t *raidPtr; + int new_value; +{ + RF_ComponentLabel_t *clabel; + struct vnode *vp; + dev_t dev; + int row, column; + + MALLOC(clabel, RF_ComponentLabel_t *, sizeof(RF_ComponentLabel_t), + M_RAIDFRAME, M_WAITOK | M_ZERO); + + raidPtr->autoconfigure = new_value; + for(row=0; row<raidPtr->numRow; row++) { + for(column=0; column<raidPtr->numCol; column++) { + if (raidPtr->Disks[row][column].status == + rf_ds_optimal) { + dev = raidPtr->Disks[row][column].dev; + vp = raidPtr->raid_cinfo[row][column].ci_vp; + raidread_component_label(dev, vp, clabel); + clabel->autoconfigure = new_value; + raidwrite_component_label(dev, vp, clabel); + } + } + } + FREE(clabel, M_RAIDFRAME); + return(new_value); +} + +int +rf_set_rootpartition(raidPtr, new_value) + RF_Raid_t *raidPtr; + int new_value; +{ + RF_ComponentLabel_t *clabel; + struct vnode *vp; + dev_t dev; + int row, column; + + MALLOC(clabel, RF_ComponentLabel_t *, sizeof(RF_ComponentLabel_t), + M_RAIDFRAME, M_WAITOK | M_ZERO); + + raidPtr->root_partition = new_value; + for(row=0; row<raidPtr->numRow; row++) { + for(column=0; column<raidPtr->numCol; column++) { + if (raidPtr->Disks[row][column].status == + rf_ds_optimal) { + dev = raidPtr->Disks[row][column].dev; + vp = raidPtr->raid_cinfo[row][column].ci_vp; + raidread_component_label(dev, vp, clabel); + clabel->root_partition = new_value; + raidwrite_component_label(dev, vp, clabel); + } + } + } + FREE(clabel, M_RAIDFRAME); + return(new_value); +} + +void +rf_release_all_vps(cset) + RF_ConfigSet_t *cset; +{ + RF_AutoConfig_t *ac; + struct thread *td; + + td = curthread; + ac = cset->ac; + while(ac!=NULL) { + /* Close the vp, and give it back */ + if (ac->vp) { + VOP_CLOSE(ac->vp, FREAD, td->td_ucred, td); + vrele(ac->vp); + ac->vp = NULL; + } + ac = ac->next; + } +} + + +void +rf_cleanup_config_set(cset) + RF_ConfigSet_t *cset; +{ + RF_AutoConfig_t *ac; + RF_AutoConfig_t *next_ac; + + ac = cset->ac; + while(ac!=NULL) { + next_ac = ac->next; + /* nuke the label */ + free(ac->clabel, M_RAIDFRAME); + /* cleanup the config structure */ + free(ac, M_RAIDFRAME); + /* "next.." */ + ac = next_ac; + } + /* and, finally, nuke the config set */ + free(cset, M_RAIDFRAME); +} + + +void +raid_init_component_label(raidPtr, clabel) + RF_Raid_t *raidPtr; + RF_ComponentLabel_t *clabel; +{ + /* current version number */ + clabel->version = RF_COMPONENT_LABEL_VERSION; + clabel->serial_number = raidPtr->serial_number; + clabel->mod_counter = raidPtr->mod_counter; + clabel->num_rows = raidPtr->numRow; + clabel->num_columns = raidPtr->numCol; + clabel->clean = RF_RAID_DIRTY; /* not clean */ + clabel->status = rf_ds_optimal; /* "It's good!" */ + + clabel->sectPerSU = raidPtr->Layout.sectorsPerStripeUnit; + clabel->SUsPerPU = raidPtr->Layout.SUsPerPU; + clabel->SUsPerRU = raidPtr->Layout.SUsPerRU; + + clabel->blockSize = raidPtr->bytesPerSector; + clabel->numBlocks = raidPtr->sectorsPerDisk; + + /* XXX not portable */ + clabel->parityConfig = raidPtr->Layout.map->parityConfig; + clabel->maxOutstanding = raidPtr->maxOutstanding; + clabel->autoconfigure = raidPtr->autoconfigure; + clabel->root_partition = raidPtr->root_partition; + clabel->last_unit = raidPtr->raidid; + clabel->config_order = raidPtr->config_order; +} + +int +rf_auto_config_set(cset, unit, parent_sc) + RF_ConfigSet_t *cset; + int *unit; + struct raidctl_softc *parent_sc; +{ + int retcode = 0; + RF_Raid_t *raidPtr; + RF_Config_t *config; + int raidID; + + rf_printf(0, "RAIDframe autoconfigure\n"); + + *unit = -1; + + /* 1. Create a config structure */ + + config = (RF_Config_t *)malloc(sizeof(RF_Config_t), M_RAIDFRAME, + M_NOWAIT|M_ZERO); + if (config==NULL) { + rf_printf(0, "Out of mem at rf_auto_config_set\n"); + /* XXX do something more intelligent here. */ + return(1); + } + + /* XXX raidID needs to be set correctly.. */ + + /* + 2. Figure out what RAID ID this one is supposed to live at + See if we can get the same RAID dev that it was configured + on last time.. + */ + + raidID = cset->ac->clabel->last_unit; + if (raidID < 0) { + /* let's not wander off into lala land. */ + raidID = raidgetunit(parent_sc, 0); + } else { + raidID = raidgetunit(parent_sc, raidID); + } + + if (raidID < 0) { + /* punt... */ + rf_printf(0, "Unable to auto configure this set!\n"); + rf_printf(1, "Out of RAID devs!\n"); + return(1); + } + rf_printf(0, "Configuring raid%d:\n",raidID); + RF_Malloc(raidPtr, sizeof(*raidPtr), (RF_Raid_t *)); + if (raidPtr == NULL) { + rf_printf(0, "Out of mem at rf_auto_config_set\n"); + return (1); + } + bzero((char *)raidPtr, sizeof(RF_Raid_t)); + + /* XXX all this stuff should be done SOMEWHERE ELSE! */ + raidPtr->raidid = raidID; + raidPtr->openings = RAIDOUTSTANDING; + + /* 3. Build the configuration structure */ + rf_create_configuration(cset->ac, config, raidPtr); + + /* 4. Do the configuration */ + retcode = rf_Configure(raidPtr, config, cset->ac); + + if (retcode == 0) { + + parent_sc->sc_raiddevs[raidID] = raidinit(raidPtr); + if (parent_sc->sc_raiddevs[raidID] == NULL) { + rf_printf(0, "Could not create RAID device\n"); + RF_Free(raidPtr, sizeof(RF_Raid_t)); + free(config, M_RAIDFRAME); + return (1); + } + + parent_sc->sc_numraid++; + ((struct raid_softc *)raidPtr->sc)->sc_parent_dev = + parent_sc->sc_dev; + rf_markalldirty(raidPtr); + raidPtr->autoconfigure = 1; /* XXX do this here? */ + if (cset->ac->clabel->root_partition==1) { + /* everything configured just fine. Make a note + that this set is eligible to be root. */ + cset->rootable = 1; + /* XXX do this here? */ + raidPtr->root_partition = 1; + } + } + + /* 5. Cleanup */ + free(config, M_RAIDFRAME); + + *unit = raidID; + return(retcode); +} + +void +rf_disk_unbusy(desc) + RF_RaidAccessDesc_t *desc; +{ + struct raid_softc *sc; + struct bio *bp; + + sc = desc->raidPtr->sc; + bp = (struct bio *)desc->bp; + + devstat_end_transaction_bio(&sc->device_stats, bp); +} + +/* + * Get the next available unit number from the bitmap. You can also request + * a particular unit number by passing it in the second arg. If it's not + * available, then grab the next free one. Return -1 if none are available. + */ +static int +raidgetunit(struct raidctl_softc *parent_sc, int id) +{ + int i; + + if (id >= RF_MAX_ARRAYS) + return (-1); + + for (i = id; i < RF_MAX_ARRAYS; i++) { + if (parent_sc->sc_raiddevs[i] == NULL) + return (i); + } + + if (id != 0) { + for (i = 0; i < id; i++) { + if (parent_sc->sc_raiddevs[i] == NULL) + return (i); + } + } + + return (-1); +} + +static int +raidshutdown(void) +{ + struct raidctl_softc *parent_sc; + int i, error = 0; + + parent_sc = raidctl_dev->si_drv1; + + if (parent_sc->sc_numraid != 0) { +#if XXX_KTHREAD_EXIT_RACE + return (EBUSY); +#else + for (i = 0; i < RF_MAX_ARRAYS; i++) { + if (parent_sc->sc_raiddevs[i] != NULL) { + rf_printf(0, "Shutting down raid%d\n", i); + error = raidctlioctl(raidctl_dev, + RAIDFRAME_SHUTDOWN, (caddr_t)&i, 0, NULL); + if (error) + return (error); + if (parent_sc->sc_numraid == 0) + break; + } + } +#endif + } + + destroy_dev(raidctl_dev); + + return (error); +} + +int +raid_getcomponentsize(RF_Raid_t *raidPtr, RF_RowCol_t row, RF_RowCol_t col) +{ + struct disklabel *dlabel; + struct vnode *vp; + struct vattr va; + RF_Thread_t td; + int retcode; + + td = raidPtr->engine_thread; + + MALLOC(dlabel, struct disklabel *, sizeof(struct disklabel), + M_RAIDFRAME, M_NOWAIT | M_ZERO); + if (dlabel == NULL) { + printf("rf_getcomponentsize: Out of memory?\n"); + return (ENOMEM); + } + + retcode = raidlookup(raidPtr->Disks[row][col].devname, td, &vp); + + if (retcode) { + printf("raid%d: rebuilding: raidlookup on device: %s failed: %d!\n",raidPtr->raidid, + raidPtr->Disks[row][col].devname, retcode); + + /* XXX the component isn't responding properly... + must be still dead :-( */ + raidPtr->reconInProgress--; + FREE(dlabel, M_RAIDFRAME); + return(retcode); + + } else { + + /* Ok, so we can at least do a lookup... + How about actually getting a vp for it? */ + + if ((retcode = VOP_GETATTR(vp, &va, rf_getucred(td), + td)) != 0) { + raidPtr->reconInProgress--; + FREE(dlabel, M_RAIDFRAME); + return(retcode); + } + + retcode = VOP_IOCTL(vp, DIOCGDINFO, (caddr_t)dlabel, + FREAD, rf_getucred(td), td); + if (retcode) { + FREE(dlabel, M_RAIDFRAME); + return(retcode); + } + raidPtr->Disks[row][col].blockSize = dlabel->d_secsize; + raidPtr->Disks[row][col].numBlocks = + dlabel->d_partitions[dkpart(vn_todev(vp))].p_size - + rf_protectedSectors; + + raidPtr->raid_cinfo[row][col].ci_vp = vp; + raidPtr->raid_cinfo[row][col].ci_dev = udev2dev(va.va_rdev, 0); + raidPtr->Disks[row][col].dev = udev2dev(va.va_rdev, 0); + + /* we allow the user to specify that only a + fraction of the disks should be used this is + just for debug: it speeds up + * the parity scan */ + raidPtr->Disks[row][col].numBlocks = + raidPtr->Disks[row][col].numBlocks * + rf_sizePercentage / 100; + } + + FREE(dlabel, M_RAIDFRAME); + return(retcode); +} + +static int +raid_modevent(mod, type, data) + module_t mod; + int type; + void *data; +{ + int error = 0; + + switch (type) { + case MOD_LOAD: + raidattach(); + break; + + case MOD_UNLOAD: + case MOD_SHUTDOWN: + error = raidshutdown(); + break; + + default: + break; + } + + return (error); +} + +moduledata_t raid_mod = { + "raidframe", + (modeventhand_t) raid_modevent, + 0}; + +DECLARE_MODULE(raidframe, raid_mod, SI_SUB_RAID, SI_ORDER_MIDDLE); |
