Home | History | Annotate | Line # | Download | only in raidframe
rf_netbsdkintf.c revision 1.155
      1  1.155   thorpej /*	$NetBSD: rf_netbsdkintf.c,v 1.155 2003/02/25 20:35:36 thorpej Exp $	*/
      2    1.1     oster /*-
      3    1.1     oster  * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc.
      4    1.1     oster  * All rights reserved.
      5    1.1     oster  *
      6    1.1     oster  * This code is derived from software contributed to The NetBSD Foundation
      7    1.1     oster  * by Greg Oster; Jason R. Thorpe.
      8    1.1     oster  *
      9    1.1     oster  * Redistribution and use in source and binary forms, with or without
     10    1.1     oster  * modification, are permitted provided that the following conditions
     11    1.1     oster  * are met:
     12    1.1     oster  * 1. Redistributions of source code must retain the above copyright
     13    1.1     oster  *    notice, this list of conditions and the following disclaimer.
     14    1.1     oster  * 2. Redistributions in binary form must reproduce the above copyright
     15    1.1     oster  *    notice, this list of conditions and the following disclaimer in the
     16    1.1     oster  *    documentation and/or other materials provided with the distribution.
     17    1.1     oster  * 3. All advertising materials mentioning features or use of this software
     18    1.1     oster  *    must display the following acknowledgement:
     19    1.1     oster  *        This product includes software developed by the NetBSD
     20    1.1     oster  *        Foundation, Inc. and its contributors.
     21    1.1     oster  * 4. Neither the name of The NetBSD Foundation nor the names of its
     22    1.1     oster  *    contributors may be used to endorse or promote products derived
     23    1.1     oster  *    from this software without specific prior written permission.
     24    1.1     oster  *
     25    1.1     oster  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     26    1.1     oster  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     27    1.1     oster  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     28    1.1     oster  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     29    1.1     oster  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     30    1.1     oster  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     31    1.1     oster  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     32    1.1     oster  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     33    1.1     oster  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     34    1.1     oster  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     35    1.1     oster  * POSSIBILITY OF SUCH DAMAGE.
     36    1.1     oster  */
     37    1.1     oster 
     38    1.1     oster /*
     39    1.1     oster  * Copyright (c) 1988 University of Utah.
     40    1.1     oster  * Copyright (c) 1990, 1993
     41    1.1     oster  *      The Regents of the University of California.  All rights reserved.
     42    1.1     oster  *
     43    1.1     oster  * This code is derived from software contributed to Berkeley by
     44    1.1     oster  * the Systems Programming Group of the University of Utah Computer
     45    1.1     oster  * Science Department.
     46    1.1     oster  *
     47    1.1     oster  * Redistribution and use in source and binary forms, with or without
     48    1.1     oster  * modification, are permitted provided that the following conditions
     49    1.1     oster  * are met:
     50    1.1     oster  * 1. Redistributions of source code must retain the above copyright
     51    1.1     oster  *    notice, this list of conditions and the following disclaimer.
     52    1.1     oster  * 2. Redistributions in binary form must reproduce the above copyright
     53    1.1     oster  *    notice, this list of conditions and the following disclaimer in the
     54    1.1     oster  *    documentation and/or other materials provided with the distribution.
     55    1.1     oster  * 3. All advertising materials mentioning features or use of this software
     56    1.1     oster  *    must display the following acknowledgement:
     57    1.1     oster  *      This product includes software developed by the University of
     58    1.1     oster  *      California, Berkeley and its contributors.
     59    1.1     oster  * 4. Neither the name of the University nor the names of its contributors
     60    1.1     oster  *    may be used to endorse or promote products derived from this software
     61    1.1     oster  *    without specific prior written permission.
     62    1.1     oster  *
     63    1.1     oster  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     64    1.1     oster  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     65    1.1     oster  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     66    1.1     oster  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     67    1.1     oster  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     68    1.1     oster  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     69    1.1     oster  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     70    1.1     oster  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     71    1.1     oster  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     72    1.1     oster  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     73    1.1     oster  * SUCH DAMAGE.
     74    1.1     oster  *
     75    1.1     oster  * from: Utah $Hdr: cd.c 1.6 90/11/28$
     76    1.1     oster  *
     77    1.1     oster  *      @(#)cd.c        8.2 (Berkeley) 11/16/93
     78    1.1     oster  */
     79    1.1     oster 
     80    1.1     oster /*
     81    1.1     oster  * Copyright (c) 1995 Carnegie-Mellon University.
     82    1.1     oster  * All rights reserved.
     83    1.1     oster  *
     84    1.1     oster  * Authors: Mark Holland, Jim Zelenka
     85    1.1     oster  *
     86    1.1     oster  * Permission to use, copy, modify and distribute this software and
     87    1.1     oster  * its documentation is hereby granted, provided that both the copyright
     88    1.1     oster  * notice and this permission notice appear in all copies of the
     89    1.1     oster  * software, derivative works or modified versions, and any portions
     90    1.1     oster  * thereof, and that both notices appear in supporting documentation.
     91    1.1     oster  *
     92    1.1     oster  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
     93    1.1     oster  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
     94    1.1     oster  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
     95    1.1     oster  *
     96    1.1     oster  * Carnegie Mellon requests users of this software to return to
     97    1.1     oster  *
     98    1.1     oster  *  Software Distribution Coordinator  or  Software.Distribution (at) CS.CMU.EDU
     99    1.1     oster  *  School of Computer Science
    100    1.1     oster  *  Carnegie Mellon University
    101    1.1     oster  *  Pittsburgh PA 15213-3890
    102    1.1     oster  *
    103    1.1     oster  * any improvements or extensions that they make and grant Carnegie the
    104    1.1     oster  * rights to redistribute these changes.
    105    1.1     oster  */
    106    1.1     oster 
    107    1.1     oster /***********************************************************
    108    1.1     oster  *
    109    1.1     oster  * rf_kintf.c -- the kernel interface routines for RAIDframe
    110    1.1     oster  *
    111    1.1     oster  ***********************************************************/
    112  1.112     lukem 
    113  1.112     lukem #include <sys/cdefs.h>
    114  1.155   thorpej __KERNEL_RCSID(0, "$NetBSD: rf_netbsdkintf.c,v 1.155 2003/02/25 20:35:36 thorpej Exp $");
    115    1.1     oster 
    116  1.113     lukem #include <sys/param.h>
    117    1.1     oster #include <sys/errno.h>
    118    1.1     oster #include <sys/pool.h>
    119  1.152   thorpej #include <sys/proc.h>
    120    1.1     oster #include <sys/queue.h>
    121    1.1     oster #include <sys/disk.h>
    122    1.1     oster #include <sys/device.h>
    123    1.1     oster #include <sys/stat.h>
    124    1.1     oster #include <sys/ioctl.h>
    125    1.1     oster #include <sys/fcntl.h>
    126    1.1     oster #include <sys/systm.h>
    127    1.1     oster #include <sys/namei.h>
    128    1.1     oster #include <sys/vnode.h>
    129    1.1     oster #include <sys/disklabel.h>
    130    1.1     oster #include <sys/conf.h>
    131    1.1     oster #include <sys/lock.h>
    132    1.1     oster #include <sys/buf.h>
    133    1.1     oster #include <sys/user.h>
    134   1.65     oster #include <sys/reboot.h>
    135    1.8     oster 
    136  1.110     oster #include <dev/raidframe/raidframevar.h>
    137  1.110     oster #include <dev/raidframe/raidframeio.h>
    138    1.8     oster #include "raid.h"
    139   1.62     oster #include "opt_raid_autoconfig.h"
    140    1.1     oster #include "rf_raid.h"
    141   1.44     oster #include "rf_copyback.h"
    142    1.1     oster #include "rf_dag.h"
    143    1.1     oster #include "rf_dagflags.h"
    144   1.99     oster #include "rf_desc.h"
    145    1.1     oster #include "rf_diskqueue.h"
    146    1.1     oster #include "rf_etimer.h"
    147    1.1     oster #include "rf_general.h"
    148    1.1     oster #include "rf_kintf.h"
    149    1.1     oster #include "rf_options.h"
    150    1.1     oster #include "rf_driver.h"
    151    1.1     oster #include "rf_parityscan.h"
    152    1.1     oster #include "rf_threadstuff.h"
    153    1.1     oster 
    154  1.133     oster #ifdef DEBUG
    155    1.9     oster int     rf_kdebug_level = 0;
    156    1.1     oster #define db1_printf(a) if (rf_kdebug_level > 0) printf a
    157    1.9     oster #else				/* DEBUG */
    158    1.1     oster #define db1_printf(a) { }
    159    1.9     oster #endif				/* DEBUG */
    160    1.1     oster 
    161    1.9     oster static RF_Raid_t **raidPtrs;	/* global raid device descriptors */
    162    1.1     oster 
    163   1.11     oster RF_DECLARE_STATIC_MUTEX(rf_sparet_wait_mutex)
    164    1.1     oster 
    165   1.10     oster static RF_SparetWait_t *rf_sparet_wait_queue;	/* requests to install a
    166   1.10     oster 						 * spare table */
    167   1.10     oster static RF_SparetWait_t *rf_sparet_resp_queue;	/* responses from
    168   1.10     oster 						 * installation process */
    169  1.153   thorpej 
    170  1.153   thorpej MALLOC_DEFINE(M_RAIDFRAME, "RAIDframe", "RAIDframe structures");
    171   1.10     oster 
    172    1.1     oster /* prototypes */
    173   1.10     oster static void KernelWakeupFunc(struct buf * bp);
    174   1.10     oster static void InitBP(struct buf * bp, struct vnode *, unsigned rw_flag,
    175   1.10     oster 		   dev_t dev, RF_SectorNum_t startSect,
    176   1.10     oster 		   RF_SectorCount_t numSect, caddr_t buf,
    177   1.10     oster 		   void (*cbFunc) (struct buf *), void *cbArg,
    178   1.10     oster 		   int logBytesPerSector, struct proc * b_proc);
    179  1.104     oster static void raidinit(RF_Raid_t *);
    180    1.1     oster 
    181  1.104     oster void raidattach(int);
    182  1.130   gehenna 
    183  1.130   gehenna dev_type_open(raidopen);
    184  1.130   gehenna dev_type_close(raidclose);
    185  1.130   gehenna dev_type_read(raidread);
    186  1.130   gehenna dev_type_write(raidwrite);
    187  1.130   gehenna dev_type_ioctl(raidioctl);
    188  1.130   gehenna dev_type_strategy(raidstrategy);
    189  1.130   gehenna dev_type_dump(raiddump);
    190  1.130   gehenna dev_type_size(raidsize);
    191  1.130   gehenna 
    192  1.130   gehenna const struct bdevsw raid_bdevsw = {
    193  1.130   gehenna 	raidopen, raidclose, raidstrategy, raidioctl,
    194  1.130   gehenna 	raiddump, raidsize, D_DISK
    195  1.130   gehenna };
    196  1.130   gehenna 
    197  1.130   gehenna const struct cdevsw raid_cdevsw = {
    198  1.130   gehenna 	raidopen, raidclose, raidread, raidwrite, raidioctl,
    199  1.144  jdolecek 	nostop, notty, nopoll, nommap, nokqfilter, D_DISK
    200  1.130   gehenna };
    201    1.1     oster 
    202    1.1     oster /*
    203    1.1     oster  * Pilfered from ccd.c
    204    1.1     oster  */
    205    1.1     oster 
    206   1.10     oster struct raidbuf {
    207   1.10     oster 	struct buf rf_buf;	/* new I/O buf.  MUST BE FIRST!!! */
    208   1.10     oster 	struct buf *rf_obp;	/* ptr. to original I/O buf */
    209   1.11     oster 	RF_DiskQueueData_t *req;/* the request that this was part of.. */
    210   1.10     oster };
    211    1.1     oster 
    212  1.116   thorpej /* component buffer pool */
    213  1.116   thorpej struct pool raidframe_cbufpool;
    214    1.1     oster 
    215    1.9     oster /* XXX Not sure if the following should be replacing the raidPtrs above,
    216   1.53     oster    or if it should be used in conjunction with that...
    217   1.59     oster */
    218    1.1     oster 
    219   1.10     oster struct raid_softc {
    220   1.10     oster 	int     sc_flags;	/* flags */
    221   1.10     oster 	int     sc_cflags;	/* configuration flags */
    222   1.11     oster 	size_t  sc_size;        /* size of the raid device */
    223   1.10     oster 	char    sc_xname[20];	/* XXX external name */
    224   1.10     oster 	struct disk sc_dkdev;	/* generic disk device info */
    225  1.125   hannken 	struct bufq_state buf_queue;	/* used for the device queue */
    226   1.10     oster };
    227    1.1     oster /* sc_flags */
    228    1.1     oster #define RAIDF_INITED	0x01	/* unit has been initialized */
    229    1.1     oster #define RAIDF_WLABEL	0x02	/* label area is writable */
    230    1.1     oster #define RAIDF_LABELLING	0x04	/* unit is currently being labelled */
    231    1.1     oster #define RAIDF_WANTED	0x40	/* someone is waiting to obtain a lock */
    232    1.1     oster #define RAIDF_LOCKED	0x80	/* unit is locked */
    233    1.1     oster 
    234    1.1     oster #define	raidunit(x)	DISKUNIT(x)
    235   1.48     oster int numraid = 0;
    236    1.1     oster 
    237   1.20     oster /*
    238   1.20     oster  * Allow RAIDOUTSTANDING number of simultaneous IO's to this RAID device.
    239   1.20     oster  * Be aware that large numbers can allow the driver to consume a lot of
    240   1.28     oster  * kernel memory, especially on writes, and in degraded mode reads.
    241   1.28     oster  *
    242   1.28     oster  * For example: with a stripe width of 64 blocks (32k) and 5 disks,
    243   1.28     oster  * a single 64K write will typically require 64K for the old data,
    244   1.28     oster  * 64K for the old parity, and 64K for the new parity, for a total
    245   1.28     oster  * of 192K (if the parity buffer is not re-used immediately).
    246  1.110     oster  * Even it if is used immediately, that's still 128K, which when multiplied
    247   1.28     oster  * by say 10 requests, is 1280K, *on top* of the 640K of incoming data.
    248   1.28     oster  *
    249   1.28     oster  * Now in degraded mode, for example, a 64K read on the above setup may
    250   1.28     oster  * require data reconstruction, which will require *all* of the 4 remaining
    251   1.28     oster  * disks to participate -- 4 * 32K/disk == 128K again.
    252   1.20     oster  */
    253   1.20     oster 
    254   1.20     oster #ifndef RAIDOUTSTANDING
    255   1.28     oster #define RAIDOUTSTANDING   6
    256   1.20     oster #endif
    257   1.20     oster 
    258    1.1     oster #define RAIDLABELDEV(dev)	\
    259    1.1     oster 	(MAKEDISKDEV(major((dev)), raidunit((dev)), RAW_PART))
    260    1.1     oster 
    261    1.1     oster /* declared here, and made public, for the benefit of KVM stuff.. */
    262   1.10     oster struct raid_softc *raid_softc;
    263    1.9     oster 
    264  1.104     oster static void raidgetdefaultlabel(RF_Raid_t *, struct raid_softc *,
    265  1.104     oster 				     struct disklabel *);
    266  1.104     oster static void raidgetdisklabel(dev_t);
    267  1.104     oster static void raidmakedisklabel(struct raid_softc *);
    268    1.1     oster 
    269  1.104     oster static int raidlock(struct raid_softc *);
    270  1.104     oster static void raidunlock(struct raid_softc *);
    271    1.1     oster 
    272  1.104     oster static void rf_markalldirty(RF_Raid_t *);
    273   1.48     oster 
    274   1.48     oster struct device *raidrootdev;
    275    1.1     oster 
    276  1.104     oster void rf_ReconThread(struct rf_recon_req *);
    277   1.37     oster /* XXX what I want is: */
    278  1.104     oster /*void rf_ReconThread(RF_Raid_t *raidPtr);  */
    279  1.104     oster void rf_RewriteParityThread(RF_Raid_t *raidPtr);
    280  1.104     oster void rf_CopybackThread(RF_Raid_t *raidPtr);
    281  1.104     oster void rf_ReconstructInPlaceThread(struct rf_recon_req *);
    282  1.142   thorpej int rf_autoconfig(struct device *self);
    283  1.142   thorpej void rf_buildroothack(RF_ConfigSet_t *);
    284  1.104     oster 
    285  1.104     oster RF_AutoConfig_t *rf_find_raid_components(void);
    286  1.104     oster RF_ConfigSet_t *rf_create_auto_sets(RF_AutoConfig_t *);
    287  1.104     oster static int rf_does_it_fit(RF_ConfigSet_t *,RF_AutoConfig_t *);
    288  1.104     oster static int rf_reasonable_label(RF_ComponentLabel_t *);
    289  1.104     oster void rf_create_configuration(RF_AutoConfig_t *,RF_Config_t *, RF_Raid_t *);
    290  1.104     oster int rf_set_autoconfig(RF_Raid_t *, int);
    291  1.104     oster int rf_set_rootpartition(RF_Raid_t *, int);
    292  1.104     oster void rf_release_all_vps(RF_ConfigSet_t *);
    293  1.104     oster void rf_cleanup_config_set(RF_ConfigSet_t *);
    294  1.104     oster int rf_have_enough_components(RF_ConfigSet_t *);
    295  1.104     oster int rf_auto_config_set(RF_ConfigSet_t *, int *);
    296   1.48     oster 
    297   1.48     oster static int raidautoconfig = 0; /* Debugging, mostly.  Set to 0 to not
    298   1.62     oster 				  allow autoconfig to take place.
    299   1.62     oster 			          Note that this is overridden by having
    300   1.62     oster 			          RAID_AUTOCONFIG as an option in the
    301   1.62     oster 			          kernel config file.  */
    302   1.37     oster 
    303   1.10     oster void
    304   1.10     oster raidattach(num)
    305    1.9     oster 	int     num;
    306    1.1     oster {
    307   1.14     oster 	int raidID;
    308   1.14     oster 	int i, rc;
    309    1.1     oster 
    310    1.1     oster #ifdef DEBUG
    311    1.9     oster 	printf("raidattach: Asked for %d units\n", num);
    312    1.1     oster #endif
    313    1.1     oster 
    314    1.1     oster 	if (num <= 0) {
    315    1.1     oster #ifdef DIAGNOSTIC
    316    1.1     oster 		panic("raidattach: count <= 0");
    317    1.1     oster #endif
    318    1.1     oster 		return;
    319    1.1     oster 	}
    320    1.9     oster 	/* This is where all the initialization stuff gets done. */
    321    1.1     oster 
    322   1.50     oster 	numraid = num;
    323   1.50     oster 
    324    1.1     oster 	/* Make some space for requested number of units... */
    325    1.1     oster 
    326    1.1     oster 	RF_Calloc(raidPtrs, num, sizeof(RF_Raid_t *), (RF_Raid_t **));
    327    1.1     oster 	if (raidPtrs == NULL) {
    328  1.141    provos 		panic("raidPtrs is NULL!!");
    329    1.1     oster 	}
    330  1.116   thorpej 
    331  1.116   thorpej 	/* Initialize the component buffer pool. */
    332  1.116   thorpej 	pool_init(&raidframe_cbufpool, sizeof(struct raidbuf), 0,
    333  1.117   thorpej 	    0, 0, "raidpl", NULL);
    334  1.116   thorpej 
    335   1.14     oster 	rc = rf_mutex_init(&rf_sparet_wait_mutex);
    336   1.14     oster 	if (rc) {
    337   1.14     oster 		RF_PANIC();
    338   1.14     oster 	}
    339   1.14     oster 
    340   1.14     oster 	rf_sparet_wait_queue = rf_sparet_resp_queue = NULL;
    341   1.14     oster 
    342   1.58     oster 	for (i = 0; i < num; i++)
    343   1.14     oster 		raidPtrs[i] = NULL;
    344   1.14     oster 	rc = rf_BootRaidframe();
    345   1.14     oster 	if (rc == 0)
    346   1.14     oster 		printf("Kernelized RAIDframe activated\n");
    347   1.14     oster 	else
    348  1.141    provos 		panic("Serious error booting RAID!!");
    349   1.14     oster 
    350    1.9     oster 	/* put together some datastructures like the CCD device does.. This
    351    1.9     oster 	 * lets us lock the device and what-not when it gets opened. */
    352    1.1     oster 
    353    1.1     oster 	raid_softc = (struct raid_softc *)
    354   1.48     oster 		malloc(num * sizeof(struct raid_softc),
    355   1.48     oster 		       M_RAIDFRAME, M_NOWAIT);
    356    1.1     oster 	if (raid_softc == NULL) {
    357    1.1     oster 		printf("WARNING: no memory for RAIDframe driver\n");
    358    1.1     oster 		return;
    359    1.1     oster 	}
    360   1.50     oster 
    361  1.108   thorpej 	memset(raid_softc, 0, num * sizeof(struct raid_softc));
    362   1.34     oster 
    363   1.48     oster 	raidrootdev = (struct device *)malloc(num * sizeof(struct device),
    364   1.48     oster 					      M_RAIDFRAME, M_NOWAIT);
    365   1.48     oster 	if (raidrootdev == NULL) {
    366  1.141    provos 		panic("No memory for RAIDframe driver!!?!?!");
    367   1.48     oster 	}
    368   1.48     oster 
    369    1.9     oster 	for (raidID = 0; raidID < num; raidID++) {
    370  1.126   hannken 		bufq_alloc(&raid_softc[raidID].buf_queue, BUFQ_FCFS);
    371   1.48     oster 
    372   1.48     oster 		raidrootdev[raidID].dv_class  = DV_DISK;
    373   1.48     oster 		raidrootdev[raidID].dv_cfdata = NULL;
    374   1.48     oster 		raidrootdev[raidID].dv_unit   = raidID;
    375   1.48     oster 		raidrootdev[raidID].dv_parent = NULL;
    376   1.48     oster 		raidrootdev[raidID].dv_flags  = 0;
    377   1.48     oster 		sprintf(raidrootdev[raidID].dv_xname,"raid%d",raidID);
    378   1.48     oster 
    379    1.9     oster 		RF_Calloc(raidPtrs[raidID], 1, sizeof(RF_Raid_t),
    380   1.11     oster 			  (RF_Raid_t *));
    381    1.9     oster 		if (raidPtrs[raidID] == NULL) {
    382   1.39     oster 			printf("WARNING: raidPtrs[%d] is NULL\n", raidID);
    383   1.39     oster 			numraid = raidID;
    384   1.39     oster 			return;
    385    1.1     oster 		}
    386    1.1     oster 	}
    387   1.48     oster 
    388  1.114     lukem #ifdef RAID_AUTOCONFIG
    389   1.62     oster 	raidautoconfig = 1;
    390   1.62     oster #endif
    391   1.62     oster 
    392  1.142   thorpej 	/*
    393  1.142   thorpej 	 * Register a finalizer which will be used to auto-config RAID
    394  1.142   thorpej 	 * sets once all real hardware devices have been found.
    395  1.142   thorpej 	 */
    396  1.142   thorpej 	if (config_finalize_register(NULL, rf_autoconfig) != 0)
    397  1.142   thorpej 		printf("WARNING: unable to register RAIDframe finalizer\n");
    398  1.142   thorpej }
    399  1.142   thorpej 
    400  1.142   thorpej int
    401  1.142   thorpej rf_autoconfig(struct device *self)
    402  1.142   thorpej {
    403  1.142   thorpej 	RF_AutoConfig_t *ac_list;
    404  1.142   thorpej 	RF_ConfigSet_t *config_sets;
    405  1.142   thorpej 
    406  1.142   thorpej 	if (raidautoconfig == 0)
    407  1.142   thorpej 		return (0);
    408  1.142   thorpej 
    409  1.142   thorpej 	/* XXX This code can only be run once. */
    410  1.142   thorpej 	raidautoconfig = 0;
    411  1.142   thorpej 
    412   1.48     oster 	/* 1. locate all RAID components on the system */
    413  1.142   thorpej #ifdef DEBUG
    414  1.142   thorpej 	printf("Searching for RAID components...\n");
    415   1.48     oster #endif
    416   1.48     oster 	ac_list = rf_find_raid_components();
    417   1.48     oster 
    418  1.142   thorpej 	/* 2. Sort them into their respective sets. */
    419   1.48     oster 	config_sets = rf_create_auto_sets(ac_list);
    420   1.48     oster 
    421  1.142   thorpej 	/*
    422  1.142   thorpej 	 * 3. Evaluate each set andconfigure the valid ones.
    423  1.142   thorpej 	 * This gets done in rf_buildroothack().
    424  1.142   thorpej 	 */
    425  1.142   thorpej 	rf_buildroothack(config_sets);
    426   1.48     oster 
    427  1.142   thorpej 	return (1);
    428   1.48     oster }
    429   1.48     oster 
    430   1.48     oster void
    431  1.142   thorpej rf_buildroothack(RF_ConfigSet_t *config_sets)
    432   1.48     oster {
    433   1.48     oster 	RF_ConfigSet_t *cset;
    434   1.48     oster 	RF_ConfigSet_t *next_cset;
    435   1.51     oster 	int retcode;
    436   1.48     oster 	int raidID;
    437   1.51     oster 	int rootID;
    438   1.51     oster 	int num_root;
    439   1.48     oster 
    440  1.101     oster 	rootID = 0;
    441   1.51     oster 	num_root = 0;
    442   1.48     oster 	cset = config_sets;
    443   1.48     oster 	while(cset != NULL ) {
    444   1.48     oster 		next_cset = cset->next;
    445   1.51     oster 		if (rf_have_enough_components(cset) &&
    446   1.51     oster 		    cset->ac->clabel->autoconfigure==1) {
    447   1.51     oster 			retcode = rf_auto_config_set(cset,&raidID);
    448   1.51     oster 			if (!retcode) {
    449   1.51     oster 				if (cset->rootable) {
    450   1.51     oster 					rootID = raidID;
    451   1.51     oster 					num_root++;
    452   1.51     oster 				}
    453   1.51     oster 			} else {
    454   1.51     oster 				/* The autoconfig didn't work :( */
    455   1.51     oster #if DEBUG
    456   1.51     oster 				printf("Autoconfig failed with code %d for raid%d\n", retcode, raidID);
    457   1.51     oster #endif
    458   1.51     oster 				rf_release_all_vps(cset);
    459   1.48     oster 			}
    460   1.48     oster 		} else {
    461   1.48     oster 			/* we're not autoconfiguring this set...
    462   1.48     oster 			   release the associated resources */
    463   1.49     oster 			rf_release_all_vps(cset);
    464   1.48     oster 		}
    465   1.48     oster 		/* cleanup */
    466   1.49     oster 		rf_cleanup_config_set(cset);
    467   1.48     oster 		cset = next_cset;
    468   1.48     oster 	}
    469  1.122     oster 
    470  1.122     oster 	/* we found something bootable... */
    471  1.122     oster 
    472  1.122     oster 	if (num_root == 1) {
    473  1.122     oster 		booted_device = &raidrootdev[rootID];
    474  1.122     oster 	} else if (num_root > 1) {
    475  1.122     oster 		/* we can't guess.. require the user to answer... */
    476  1.122     oster 		boothowto |= RB_ASKNAME;
    477   1.51     oster 	}
    478    1.1     oster }
    479    1.1     oster 
    480    1.1     oster 
    481    1.1     oster int
    482    1.1     oster raidsize(dev)
    483    1.9     oster 	dev_t   dev;
    484    1.1     oster {
    485    1.1     oster 	struct raid_softc *rs;
    486    1.1     oster 	struct disklabel *lp;
    487    1.9     oster 	int     part, unit, omask, size;
    488    1.1     oster 
    489    1.1     oster 	unit = raidunit(dev);
    490    1.1     oster 	if (unit >= numraid)
    491    1.1     oster 		return (-1);
    492    1.1     oster 	rs = &raid_softc[unit];
    493    1.1     oster 
    494    1.1     oster 	if ((rs->sc_flags & RAIDF_INITED) == 0)
    495    1.1     oster 		return (-1);
    496    1.1     oster 
    497    1.1     oster 	part = DISKPART(dev);
    498    1.1     oster 	omask = rs->sc_dkdev.dk_openmask & (1 << part);
    499    1.1     oster 	lp = rs->sc_dkdev.dk_label;
    500    1.1     oster 
    501    1.1     oster 	if (omask == 0 && raidopen(dev, 0, S_IFBLK, curproc))
    502    1.1     oster 		return (-1);
    503    1.1     oster 
    504    1.1     oster 	if (lp->d_partitions[part].p_fstype != FS_SWAP)
    505    1.1     oster 		size = -1;
    506    1.1     oster 	else
    507    1.1     oster 		size = lp->d_partitions[part].p_size *
    508    1.1     oster 		    (lp->d_secsize / DEV_BSIZE);
    509    1.1     oster 
    510    1.1     oster 	if (omask == 0 && raidclose(dev, 0, S_IFBLK, curproc))
    511    1.1     oster 		return (-1);
    512    1.1     oster 
    513    1.1     oster 	return (size);
    514    1.1     oster 
    515    1.1     oster }
    516    1.1     oster 
    517    1.1     oster int
    518    1.1     oster raiddump(dev, blkno, va, size)
    519    1.9     oster 	dev_t   dev;
    520    1.1     oster 	daddr_t blkno;
    521    1.1     oster 	caddr_t va;
    522    1.9     oster 	size_t  size;
    523    1.1     oster {
    524    1.1     oster 	/* Not implemented. */
    525    1.1     oster 	return ENXIO;
    526    1.1     oster }
    527    1.1     oster /* ARGSUSED */
    528    1.1     oster int
    529    1.1     oster raidopen(dev, flags, fmt, p)
    530    1.9     oster 	dev_t   dev;
    531    1.9     oster 	int     flags, fmt;
    532    1.1     oster 	struct proc *p;
    533    1.1     oster {
    534    1.9     oster 	int     unit = raidunit(dev);
    535    1.1     oster 	struct raid_softc *rs;
    536    1.1     oster 	struct disklabel *lp;
    537    1.9     oster 	int     part, pmask;
    538    1.9     oster 	int     error = 0;
    539    1.9     oster 
    540    1.1     oster 	if (unit >= numraid)
    541    1.1     oster 		return (ENXIO);
    542    1.1     oster 	rs = &raid_softc[unit];
    543    1.1     oster 
    544    1.1     oster 	if ((error = raidlock(rs)) != 0)
    545    1.9     oster 		return (error);
    546    1.1     oster 	lp = rs->sc_dkdev.dk_label;
    547    1.1     oster 
    548    1.1     oster 	part = DISKPART(dev);
    549    1.1     oster 	pmask = (1 << part);
    550    1.1     oster 
    551    1.1     oster 	if ((rs->sc_flags & RAIDF_INITED) &&
    552    1.1     oster 	    (rs->sc_dkdev.dk_openmask == 0))
    553    1.9     oster 		raidgetdisklabel(dev);
    554    1.1     oster 
    555    1.1     oster 	/* make sure that this partition exists */
    556    1.1     oster 
    557    1.1     oster 	if (part != RAW_PART) {
    558    1.1     oster 		if (((rs->sc_flags & RAIDF_INITED) == 0) ||
    559    1.1     oster 		    ((part >= lp->d_npartitions) ||
    560    1.9     oster 			(lp->d_partitions[part].p_fstype == FS_UNUSED))) {
    561    1.1     oster 			error = ENXIO;
    562    1.1     oster 			raidunlock(rs);
    563    1.9     oster 			return (error);
    564    1.1     oster 		}
    565    1.1     oster 	}
    566    1.1     oster 	/* Prevent this unit from being unconfigured while open. */
    567    1.1     oster 	switch (fmt) {
    568    1.1     oster 	case S_IFCHR:
    569    1.1     oster 		rs->sc_dkdev.dk_copenmask |= pmask;
    570    1.1     oster 		break;
    571    1.1     oster 
    572    1.1     oster 	case S_IFBLK:
    573    1.1     oster 		rs->sc_dkdev.dk_bopenmask |= pmask;
    574    1.1     oster 		break;
    575    1.1     oster 	}
    576   1.13     oster 
    577   1.13     oster 	if ((rs->sc_dkdev.dk_openmask == 0) &&
    578   1.13     oster 	    ((rs->sc_flags & RAIDF_INITED) != 0)) {
    579   1.13     oster 		/* First one... mark things as dirty... Note that we *MUST*
    580   1.13     oster 		 have done a configure before this.  I DO NOT WANT TO BE
    581   1.13     oster 		 SCRIBBLING TO RANDOM COMPONENTS UNTIL IT'S BEEN DETERMINED
    582   1.13     oster 		 THAT THEY BELONG TOGETHER!!!!! */
    583   1.13     oster 		/* XXX should check to see if we're only open for reading
    584   1.13     oster 		   here... If so, we needn't do this, but then need some
    585   1.13     oster 		   other way of keeping track of what's happened.. */
    586   1.13     oster 
    587   1.13     oster 		rf_markalldirty( raidPtrs[unit] );
    588   1.13     oster 	}
    589   1.13     oster 
    590   1.13     oster 
    591    1.1     oster 	rs->sc_dkdev.dk_openmask =
    592    1.1     oster 	    rs->sc_dkdev.dk_copenmask | rs->sc_dkdev.dk_bopenmask;
    593    1.1     oster 
    594    1.1     oster 	raidunlock(rs);
    595    1.1     oster 
    596    1.9     oster 	return (error);
    597    1.1     oster 
    598    1.1     oster 
    599    1.1     oster }
    600    1.1     oster /* ARGSUSED */
    601    1.1     oster int
    602    1.1     oster raidclose(dev, flags, fmt, p)
    603    1.9     oster 	dev_t   dev;
    604    1.9     oster 	int     flags, fmt;
    605    1.1     oster 	struct proc *p;
    606    1.1     oster {
    607    1.9     oster 	int     unit = raidunit(dev);
    608    1.1     oster 	struct raid_softc *rs;
    609    1.9     oster 	int     error = 0;
    610    1.9     oster 	int     part;
    611    1.1     oster 
    612    1.1     oster 	if (unit >= numraid)
    613    1.1     oster 		return (ENXIO);
    614    1.1     oster 	rs = &raid_softc[unit];
    615    1.1     oster 
    616    1.1     oster 	if ((error = raidlock(rs)) != 0)
    617    1.1     oster 		return (error);
    618    1.1     oster 
    619    1.1     oster 	part = DISKPART(dev);
    620    1.1     oster 
    621    1.1     oster 	/* ...that much closer to allowing unconfiguration... */
    622    1.1     oster 	switch (fmt) {
    623    1.1     oster 	case S_IFCHR:
    624    1.1     oster 		rs->sc_dkdev.dk_copenmask &= ~(1 << part);
    625    1.1     oster 		break;
    626    1.1     oster 
    627    1.1     oster 	case S_IFBLK:
    628    1.1     oster 		rs->sc_dkdev.dk_bopenmask &= ~(1 << part);
    629    1.1     oster 		break;
    630    1.1     oster 	}
    631    1.1     oster 	rs->sc_dkdev.dk_openmask =
    632    1.1     oster 	    rs->sc_dkdev.dk_copenmask | rs->sc_dkdev.dk_bopenmask;
    633   1.13     oster 
    634   1.13     oster 	if ((rs->sc_dkdev.dk_openmask == 0) &&
    635   1.13     oster 	    ((rs->sc_flags & RAIDF_INITED) != 0)) {
    636   1.13     oster 		/* Last one... device is not unconfigured yet.
    637   1.13     oster 		   Device shutdown has taken care of setting the
    638   1.13     oster 		   clean bits if RAIDF_INITED is not set
    639   1.13     oster 		   mark things as clean... */
    640  1.147     oster 
    641   1.91     oster 		rf_update_component_labels(raidPtrs[unit],
    642   1.91     oster 						 RF_FINAL_COMPONENT_UPDATE);
    643  1.107     oster 		if (doing_shutdown) {
    644  1.107     oster 			/* last one, and we're going down, so
    645  1.107     oster 			   lights out for this RAID set too. */
    646  1.107     oster 			error = rf_Shutdown(raidPtrs[unit]);
    647  1.107     oster 
    648  1.107     oster 			/* It's no longer initialized... */
    649  1.107     oster 			rs->sc_flags &= ~RAIDF_INITED;
    650  1.107     oster 
    651  1.107     oster 			/* Detach the disk. */
    652  1.107     oster 			disk_detach(&rs->sc_dkdev);
    653  1.107     oster 		}
    654   1.13     oster 	}
    655    1.1     oster 
    656    1.1     oster 	raidunlock(rs);
    657    1.1     oster 	return (0);
    658    1.1     oster 
    659    1.1     oster }
    660    1.1     oster 
    661    1.1     oster void
    662    1.1     oster raidstrategy(bp)
    663   1.74  augustss 	struct buf *bp;
    664    1.1     oster {
    665   1.74  augustss 	int s;
    666    1.1     oster 
    667    1.1     oster 	unsigned int raidID = raidunit(bp->b_dev);
    668    1.1     oster 	RF_Raid_t *raidPtr;
    669    1.1     oster 	struct raid_softc *rs = &raid_softc[raidID];
    670    1.1     oster 	struct disklabel *lp;
    671    1.9     oster 	int     wlabel;
    672    1.1     oster 
    673   1.30     oster 	if ((rs->sc_flags & RAIDF_INITED) ==0) {
    674   1.30     oster 		bp->b_error = ENXIO;
    675  1.100       chs 		bp->b_flags |= B_ERROR;
    676   1.30     oster 		bp->b_resid = bp->b_bcount;
    677   1.30     oster 		biodone(bp);
    678    1.1     oster 		return;
    679   1.30     oster 	}
    680    1.1     oster 	if (raidID >= numraid || !raidPtrs[raidID]) {
    681    1.1     oster 		bp->b_error = ENODEV;
    682    1.1     oster 		bp->b_flags |= B_ERROR;
    683    1.1     oster 		bp->b_resid = bp->b_bcount;
    684    1.1     oster 		biodone(bp);
    685    1.1     oster 		return;
    686    1.1     oster 	}
    687    1.1     oster 	raidPtr = raidPtrs[raidID];
    688    1.1     oster 	if (!raidPtr->valid) {
    689    1.1     oster 		bp->b_error = ENODEV;
    690    1.1     oster 		bp->b_flags |= B_ERROR;
    691    1.1     oster 		bp->b_resid = bp->b_bcount;
    692    1.1     oster 		biodone(bp);
    693    1.1     oster 		return;
    694    1.1     oster 	}
    695    1.1     oster 	if (bp->b_bcount == 0) {
    696    1.1     oster 		db1_printf(("b_bcount is zero..\n"));
    697    1.1     oster 		biodone(bp);
    698    1.1     oster 		return;
    699    1.1     oster 	}
    700    1.1     oster 	lp = rs->sc_dkdev.dk_label;
    701    1.1     oster 
    702    1.1     oster 	/*
    703    1.1     oster 	 * Do bounds checking and adjust transfer.  If there's an
    704    1.1     oster 	 * error, the bounds check will flag that for us.
    705    1.1     oster 	 */
    706    1.1     oster 
    707    1.9     oster 	wlabel = rs->sc_flags & (RAIDF_WLABEL | RAIDF_LABELLING);
    708    1.1     oster 	if (DISKPART(bp->b_dev) != RAW_PART)
    709    1.1     oster 		if (bounds_check_with_label(bp, lp, wlabel) <= 0) {
    710    1.1     oster 			db1_printf(("Bounds check failed!!:%d %d\n",
    711    1.9     oster 				(int) bp->b_blkno, (int) wlabel));
    712    1.1     oster 			biodone(bp);
    713    1.1     oster 			return;
    714    1.1     oster 		}
    715   1.34     oster 	s = splbio();
    716    1.1     oster 
    717    1.1     oster 	bp->b_resid = 0;
    718   1.34     oster 
    719   1.34     oster 	/* stuff it onto our queue */
    720  1.125   hannken 	BUFQ_PUT(&rs->buf_queue, bp);
    721   1.34     oster 
    722   1.34     oster 	raidstart(raidPtrs[raidID]);
    723   1.34     oster 
    724    1.1     oster 	splx(s);
    725    1.1     oster }
    726    1.1     oster /* ARGSUSED */
    727    1.1     oster int
    728    1.1     oster raidread(dev, uio, flags)
    729    1.9     oster 	dev_t   dev;
    730    1.1     oster 	struct uio *uio;
    731    1.9     oster 	int     flags;
    732    1.1     oster {
    733    1.9     oster 	int     unit = raidunit(dev);
    734    1.1     oster 	struct raid_softc *rs;
    735    1.9     oster 	int     part;
    736    1.1     oster 
    737    1.1     oster 	if (unit >= numraid)
    738    1.1     oster 		return (ENXIO);
    739    1.1     oster 	rs = &raid_softc[unit];
    740    1.1     oster 
    741    1.1     oster 	if ((rs->sc_flags & RAIDF_INITED) == 0)
    742    1.1     oster 		return (ENXIO);
    743    1.1     oster 	part = DISKPART(dev);
    744    1.1     oster 
    745    1.1     oster 	return (physio(raidstrategy, NULL, dev, B_READ, minphys, uio));
    746    1.1     oster 
    747    1.1     oster }
    748    1.1     oster /* ARGSUSED */
    749    1.1     oster int
    750    1.1     oster raidwrite(dev, uio, flags)
    751    1.9     oster 	dev_t   dev;
    752    1.1     oster 	struct uio *uio;
    753    1.9     oster 	int     flags;
    754    1.1     oster {
    755    1.9     oster 	int     unit = raidunit(dev);
    756    1.1     oster 	struct raid_softc *rs;
    757    1.1     oster 
    758    1.1     oster 	if (unit >= numraid)
    759    1.1     oster 		return (ENXIO);
    760    1.1     oster 	rs = &raid_softc[unit];
    761    1.1     oster 
    762    1.1     oster 	if ((rs->sc_flags & RAIDF_INITED) == 0)
    763    1.1     oster 		return (ENXIO);
    764  1.147     oster 
    765    1.1     oster 	return (physio(raidstrategy, NULL, dev, B_WRITE, minphys, uio));
    766    1.1     oster 
    767    1.1     oster }
    768    1.1     oster 
    769    1.1     oster int
    770    1.1     oster raidioctl(dev, cmd, data, flag, p)
    771    1.9     oster 	dev_t   dev;
    772    1.9     oster 	u_long  cmd;
    773    1.1     oster 	caddr_t data;
    774    1.9     oster 	int     flag;
    775    1.1     oster 	struct proc *p;
    776    1.1     oster {
    777    1.9     oster 	int     unit = raidunit(dev);
    778    1.9     oster 	int     error = 0;
    779    1.9     oster 	int     part, pmask;
    780    1.1     oster 	struct raid_softc *rs;
    781    1.1     oster 	RF_Config_t *k_cfg, *u_cfg;
    782   1.42     oster 	RF_Raid_t *raidPtr;
    783   1.48     oster 	RF_RaidDisk_t *diskPtr;
    784   1.41     oster 	RF_AccTotals_t *totals;
    785   1.41     oster 	RF_DeviceConfig_t *d_cfg, **ucfgp;
    786    1.1     oster 	u_char *specific_buf;
    787   1.11     oster 	int retcode = 0;
    788   1.11     oster 	int row;
    789   1.11     oster 	int column;
    790  1.123     oster 	int raidid;
    791    1.1     oster 	struct rf_recon_req *rrcopy, *rr;
    792   1.48     oster 	RF_ComponentLabel_t *clabel;
    793   1.11     oster 	RF_ComponentLabel_t ci_label;
    794   1.48     oster 	RF_ComponentLabel_t **clabel_ptr;
    795   1.12     oster 	RF_SingleComponent_t *sparePtr,*componentPtr;
    796   1.12     oster 	RF_SingleComponent_t hot_spare;
    797   1.12     oster 	RF_SingleComponent_t component;
    798   1.83     oster 	RF_ProgressInfo_t progressInfo, **progressInfoPtr;
    799   1.41     oster 	int i, j, d;
    800  1.102      fvdl #ifdef __HAVE_OLD_DISKLABEL
    801  1.102      fvdl 	struct disklabel newlabel;
    802  1.102      fvdl #endif
    803    1.1     oster 
    804    1.1     oster 	if (unit >= numraid)
    805    1.1     oster 		return (ENXIO);
    806    1.1     oster 	rs = &raid_softc[unit];
    807   1.42     oster 	raidPtr = raidPtrs[unit];
    808    1.1     oster 
    809    1.9     oster 	db1_printf(("raidioctl: %d %d %d %d\n", (int) dev,
    810    1.9     oster 		(int) DISKPART(dev), (int) unit, (int) cmd));
    811    1.1     oster 
    812    1.1     oster 	/* Must be open for writes for these commands... */
    813    1.1     oster 	switch (cmd) {
    814    1.1     oster 	case DIOCSDINFO:
    815    1.1     oster 	case DIOCWDINFO:
    816  1.102      fvdl #ifdef __HAVE_OLD_DISKLABEL
    817  1.102      fvdl 	case ODIOCWDINFO:
    818  1.102      fvdl 	case ODIOCSDINFO:
    819  1.102      fvdl #endif
    820    1.1     oster 	case DIOCWLABEL:
    821    1.1     oster 		if ((flag & FWRITE) == 0)
    822    1.1     oster 			return (EBADF);
    823    1.1     oster 	}
    824    1.1     oster 
    825    1.1     oster 	/* Must be initialized for these... */
    826    1.1     oster 	switch (cmd) {
    827    1.1     oster 	case DIOCGDINFO:
    828    1.1     oster 	case DIOCSDINFO:
    829    1.1     oster 	case DIOCWDINFO:
    830  1.102      fvdl #ifdef __HAVE_OLD_DISKLABEL
    831  1.102      fvdl 	case ODIOCGDINFO:
    832  1.102      fvdl 	case ODIOCWDINFO:
    833  1.102      fvdl 	case ODIOCSDINFO:
    834  1.102      fvdl 	case ODIOCGDEFLABEL:
    835  1.102      fvdl #endif
    836    1.1     oster 	case DIOCGPART:
    837    1.1     oster 	case DIOCWLABEL:
    838    1.1     oster 	case DIOCGDEFLABEL:
    839    1.1     oster 	case RAIDFRAME_SHUTDOWN:
    840    1.1     oster 	case RAIDFRAME_REWRITEPARITY:
    841    1.1     oster 	case RAIDFRAME_GET_INFO:
    842    1.1     oster 	case RAIDFRAME_RESET_ACCTOTALS:
    843    1.1     oster 	case RAIDFRAME_GET_ACCTOTALS:
    844    1.1     oster 	case RAIDFRAME_KEEP_ACCTOTALS:
    845    1.1     oster 	case RAIDFRAME_GET_SIZE:
    846    1.1     oster 	case RAIDFRAME_FAIL_DISK:
    847    1.1     oster 	case RAIDFRAME_COPYBACK:
    848   1.37     oster 	case RAIDFRAME_CHECK_RECON_STATUS:
    849   1.83     oster 	case RAIDFRAME_CHECK_RECON_STATUS_EXT:
    850   1.11     oster 	case RAIDFRAME_GET_COMPONENT_LABEL:
    851   1.11     oster 	case RAIDFRAME_SET_COMPONENT_LABEL:
    852   1.11     oster 	case RAIDFRAME_ADD_HOT_SPARE:
    853   1.11     oster 	case RAIDFRAME_REMOVE_HOT_SPARE:
    854   1.11     oster 	case RAIDFRAME_INIT_LABELS:
    855   1.12     oster 	case RAIDFRAME_REBUILD_IN_PLACE:
    856   1.23     oster 	case RAIDFRAME_CHECK_PARITY:
    857   1.37     oster 	case RAIDFRAME_CHECK_PARITYREWRITE_STATUS:
    858   1.83     oster 	case RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT:
    859   1.37     oster 	case RAIDFRAME_CHECK_COPYBACK_STATUS:
    860   1.83     oster 	case RAIDFRAME_CHECK_COPYBACK_STATUS_EXT:
    861   1.48     oster 	case RAIDFRAME_SET_AUTOCONFIG:
    862   1.48     oster 	case RAIDFRAME_SET_ROOT:
    863   1.73     oster 	case RAIDFRAME_DELETE_COMPONENT:
    864   1.73     oster 	case RAIDFRAME_INCORPORATE_HOT_SPARE:
    865    1.1     oster 		if ((rs->sc_flags & RAIDF_INITED) == 0)
    866    1.1     oster 			return (ENXIO);
    867    1.1     oster 	}
    868    1.9     oster 
    869    1.1     oster 	switch (cmd) {
    870    1.1     oster 
    871    1.1     oster 		/* configure the system */
    872    1.1     oster 	case RAIDFRAME_CONFIGURE:
    873   1.48     oster 
    874   1.48     oster 		if (raidPtr->valid) {
    875   1.48     oster 			/* There is a valid RAID set running on this unit! */
    876   1.48     oster 			printf("raid%d: Device already configured!\n",unit);
    877   1.66     oster 			return(EINVAL);
    878   1.48     oster 		}
    879   1.48     oster 
    880    1.1     oster 		/* copy-in the configuration information */
    881    1.1     oster 		/* data points to a pointer to the configuration structure */
    882   1.43     oster 
    883    1.9     oster 		u_cfg = *((RF_Config_t **) data);
    884    1.9     oster 		RF_Malloc(k_cfg, sizeof(RF_Config_t), (RF_Config_t *));
    885    1.1     oster 		if (k_cfg == NULL) {
    886    1.9     oster 			return (ENOMEM);
    887    1.1     oster 		}
    888    1.9     oster 		retcode = copyin((caddr_t) u_cfg, (caddr_t) k_cfg,
    889    1.9     oster 		    sizeof(RF_Config_t));
    890    1.1     oster 		if (retcode) {
    891   1.33     oster 			RF_Free(k_cfg, sizeof(RF_Config_t));
    892   1.46     oster 			db1_printf(("rf_ioctl: retcode=%d copyin.1\n",
    893    1.9     oster 				retcode));
    894    1.9     oster 			return (retcode);
    895    1.1     oster 		}
    896    1.9     oster 		/* allocate a buffer for the layout-specific data, and copy it
    897    1.9     oster 		 * in */
    898    1.1     oster 		if (k_cfg->layoutSpecificSize) {
    899    1.9     oster 			if (k_cfg->layoutSpecificSize > 10000) {
    900    1.1     oster 				/* sanity check */
    901   1.33     oster 				RF_Free(k_cfg, sizeof(RF_Config_t));
    902    1.9     oster 				return (EINVAL);
    903    1.1     oster 			}
    904    1.9     oster 			RF_Malloc(specific_buf, k_cfg->layoutSpecificSize,
    905    1.9     oster 			    (u_char *));
    906    1.1     oster 			if (specific_buf == NULL) {
    907    1.9     oster 				RF_Free(k_cfg, sizeof(RF_Config_t));
    908    1.9     oster 				return (ENOMEM);
    909    1.1     oster 			}
    910    1.9     oster 			retcode = copyin(k_cfg->layoutSpecific,
    911    1.9     oster 			    (caddr_t) specific_buf,
    912    1.9     oster 			    k_cfg->layoutSpecificSize);
    913    1.1     oster 			if (retcode) {
    914   1.33     oster 				RF_Free(k_cfg, sizeof(RF_Config_t));
    915   1.42     oster 				RF_Free(specific_buf,
    916   1.42     oster 					k_cfg->layoutSpecificSize);
    917   1.46     oster 				db1_printf(("rf_ioctl: retcode=%d copyin.2\n",
    918    1.9     oster 					retcode));
    919    1.9     oster 				return (retcode);
    920    1.1     oster 			}
    921    1.9     oster 		} else
    922    1.9     oster 			specific_buf = NULL;
    923    1.1     oster 		k_cfg->layoutSpecific = specific_buf;
    924    1.9     oster 
    925    1.9     oster 		/* should do some kind of sanity check on the configuration.
    926    1.9     oster 		 * Store the sum of all the bytes in the last byte? */
    927    1.1     oster 
    928    1.1     oster 		/* configure the system */
    929    1.1     oster 
    930   1.48     oster 		/*
    931   1.48     oster 		 * Clear the entire RAID descriptor, just to make sure
    932   1.48     oster 		 *  there is no stale data left in the case of a
    933   1.48     oster 		 *  reconfiguration
    934   1.48     oster 		 */
    935  1.108   thorpej 		memset((char *) raidPtr, 0, sizeof(RF_Raid_t));
    936   1.42     oster 		raidPtr->raidid = unit;
    937   1.20     oster 
    938   1.48     oster 		retcode = rf_Configure(raidPtr, k_cfg, NULL);
    939    1.1     oster 
    940   1.40     oster 		if (retcode == 0) {
    941   1.37     oster 
    942   1.40     oster 			/* allow this many simultaneous IO's to
    943   1.40     oster 			   this RAID device */
    944   1.42     oster 			raidPtr->openings = RAIDOUTSTANDING;
    945   1.48     oster 
    946   1.59     oster 			raidinit(raidPtr);
    947   1.59     oster 			rf_markalldirty(raidPtr);
    948    1.9     oster 		}
    949    1.1     oster 		/* free the buffers.  No return code here. */
    950    1.1     oster 		if (k_cfg->layoutSpecificSize) {
    951    1.9     oster 			RF_Free(specific_buf, k_cfg->layoutSpecificSize);
    952    1.1     oster 		}
    953    1.9     oster 		RF_Free(k_cfg, sizeof(RF_Config_t));
    954    1.9     oster 
    955    1.9     oster 		return (retcode);
    956    1.9     oster 
    957    1.9     oster 		/* shutdown the system */
    958    1.1     oster 	case RAIDFRAME_SHUTDOWN:
    959    1.9     oster 
    960    1.9     oster 		if ((error = raidlock(rs)) != 0)
    961    1.9     oster 			return (error);
    962    1.1     oster 
    963    1.1     oster 		/*
    964    1.1     oster 		 * If somebody has a partition mounted, we shouldn't
    965    1.1     oster 		 * shutdown.
    966    1.1     oster 		 */
    967    1.1     oster 
    968    1.1     oster 		part = DISKPART(dev);
    969    1.1     oster 		pmask = (1 << part);
    970    1.9     oster 		if ((rs->sc_dkdev.dk_openmask & ~pmask) ||
    971    1.9     oster 		    ((rs->sc_dkdev.dk_bopenmask & pmask) &&
    972    1.9     oster 			(rs->sc_dkdev.dk_copenmask & pmask))) {
    973    1.9     oster 			raidunlock(rs);
    974    1.9     oster 			return (EBUSY);
    975    1.9     oster 		}
    976   1.11     oster 
    977   1.42     oster 		retcode = rf_Shutdown(raidPtr);
    978    1.1     oster 
    979    1.1     oster 		/* It's no longer initialized... */
    980    1.1     oster 		rs->sc_flags &= ~RAIDF_INITED;
    981   1.16     oster 
    982    1.9     oster 		/* Detach the disk. */
    983    1.9     oster 		disk_detach(&rs->sc_dkdev);
    984    1.1     oster 
    985    1.1     oster 		raidunlock(rs);
    986    1.1     oster 
    987    1.9     oster 		return (retcode);
    988   1.11     oster 	case RAIDFRAME_GET_COMPONENT_LABEL:
    989   1.48     oster 		clabel_ptr = (RF_ComponentLabel_t **) data;
    990   1.11     oster 		/* need to read the component label for the disk indicated
    991   1.48     oster 		   by row,column in clabel */
    992   1.11     oster 
    993   1.11     oster 		/* For practice, let's get it directly fromdisk, rather
    994   1.11     oster 		   than from the in-core copy */
    995   1.48     oster 		RF_Malloc( clabel, sizeof( RF_ComponentLabel_t ),
    996   1.11     oster 			   (RF_ComponentLabel_t *));
    997   1.48     oster 		if (clabel == NULL)
    998   1.11     oster 			return (ENOMEM);
    999   1.11     oster 
   1000  1.108   thorpej 		memset((char *) clabel, 0, sizeof(RF_ComponentLabel_t));
   1001   1.11     oster 
   1002   1.48     oster 		retcode = copyin( *clabel_ptr, clabel,
   1003   1.11     oster 				  sizeof(RF_ComponentLabel_t));
   1004   1.11     oster 
   1005   1.11     oster 		if (retcode) {
   1006   1.48     oster 			RF_Free( clabel, sizeof(RF_ComponentLabel_t));
   1007   1.11     oster 			return(retcode);
   1008   1.11     oster 		}
   1009   1.11     oster 
   1010   1.48     oster 		row = clabel->row;
   1011   1.48     oster 		column = clabel->column;
   1012   1.26     oster 
   1013   1.42     oster 		if ((row < 0) || (row >= raidPtr->numRow) ||
   1014   1.90     oster 		    (column < 0) || (column >= raidPtr->numCol +
   1015   1.90     oster 				     raidPtr->numSpare)) {
   1016   1.48     oster 			RF_Free( clabel, sizeof(RF_ComponentLabel_t));
   1017   1.26     oster 			return(EINVAL);
   1018   1.11     oster 		}
   1019   1.11     oster 
   1020   1.48     oster 		raidread_component_label(raidPtr->Disks[row][column].dev,
   1021   1.48     oster 				raidPtr->raid_cinfo[row][column].ci_vp,
   1022   1.48     oster 				clabel );
   1023   1.11     oster 
   1024   1.48     oster 		retcode = copyout((caddr_t) clabel,
   1025   1.48     oster 				  (caddr_t) *clabel_ptr,
   1026   1.11     oster 				  sizeof(RF_ComponentLabel_t));
   1027   1.48     oster 		RF_Free( clabel, sizeof(RF_ComponentLabel_t));
   1028   1.11     oster 		return (retcode);
   1029   1.11     oster 
   1030   1.11     oster 	case RAIDFRAME_SET_COMPONENT_LABEL:
   1031   1.48     oster 		clabel = (RF_ComponentLabel_t *) data;
   1032   1.11     oster 
   1033   1.11     oster 		/* XXX check the label for valid stuff... */
   1034   1.11     oster 		/* Note that some things *should not* get modified --
   1035   1.11     oster 		   the user should be re-initing the labels instead of
   1036   1.11     oster 		   trying to patch things.
   1037   1.11     oster 		   */
   1038   1.11     oster 
   1039  1.123     oster 		raidid = raidPtr->raidid;
   1040  1.123     oster 		printf("raid%d: Got component label:\n", raidid);
   1041  1.123     oster 		printf("raid%d: Version: %d\n", raidid, clabel->version);
   1042  1.123     oster 		printf("raid%d: Serial Number: %d\n", raidid, clabel->serial_number);
   1043  1.123     oster 		printf("raid%d: Mod counter: %d\n", raidid, clabel->mod_counter);
   1044  1.123     oster 		printf("raid%d: Row: %d\n", raidid, clabel->row);
   1045  1.123     oster 		printf("raid%d: Column: %d\n", raidid, clabel->column);
   1046  1.123     oster 		printf("raid%d: Num Rows: %d\n", raidid, clabel->num_rows);
   1047  1.123     oster 		printf("raid%d: Num Columns: %d\n", raidid, clabel->num_columns);
   1048  1.123     oster 		printf("raid%d: Clean: %d\n", raidid, clabel->clean);
   1049  1.123     oster 		printf("raid%d: Status: %d\n", raidid, clabel->status);
   1050   1.11     oster 
   1051   1.48     oster 		row = clabel->row;
   1052   1.48     oster 		column = clabel->column;
   1053   1.12     oster 
   1054   1.42     oster 		if ((row < 0) || (row >= raidPtr->numRow) ||
   1055   1.42     oster 		    (column < 0) || (column >= raidPtr->numCol)) {
   1056   1.12     oster 			return(EINVAL);
   1057   1.11     oster 		}
   1058   1.12     oster 
   1059   1.12     oster 		/* XXX this isn't allowed to do anything for now :-) */
   1060   1.48     oster 
   1061   1.48     oster 		/* XXX and before it is, we need to fill in the rest
   1062   1.48     oster 		   of the fields!?!?!?! */
   1063   1.12     oster #if 0
   1064   1.11     oster 		raidwrite_component_label(
   1065   1.42     oster                             raidPtr->Disks[row][column].dev,
   1066   1.42     oster 			    raidPtr->raid_cinfo[row][column].ci_vp,
   1067   1.48     oster 			    clabel );
   1068   1.12     oster #endif
   1069   1.12     oster 		return (0);
   1070   1.11     oster 
   1071   1.11     oster 	case RAIDFRAME_INIT_LABELS:
   1072   1.48     oster 		clabel = (RF_ComponentLabel_t *) data;
   1073   1.11     oster 		/*
   1074   1.11     oster 		   we only want the serial number from
   1075   1.11     oster 		   the above.  We get all the rest of the information
   1076   1.11     oster 		   from the config that was used to create this RAID
   1077   1.11     oster 		   set.
   1078   1.11     oster 		   */
   1079   1.12     oster 
   1080   1.48     oster 		raidPtr->serial_number = clabel->serial_number;
   1081   1.51     oster 
   1082   1.51     oster 		raid_init_component_label(raidPtr, &ci_label);
   1083   1.51     oster 		ci_label.serial_number = clabel->serial_number;
   1084   1.11     oster 
   1085   1.42     oster 		for(row=0;row<raidPtr->numRow;row++) {
   1086   1.11     oster 			ci_label.row = row;
   1087   1.42     oster 			for(column=0;column<raidPtr->numCol;column++) {
   1088   1.48     oster 				diskPtr = &raidPtr->Disks[row][column];
   1089   1.98     oster 				if (!RF_DEAD_DISK(diskPtr->status)) {
   1090   1.94     oster 					ci_label.partitionSize = diskPtr->partitionSize;
   1091   1.94     oster 					ci_label.column = column;
   1092   1.94     oster 					raidwrite_component_label(
   1093   1.94     oster 					  raidPtr->Disks[row][column].dev,
   1094   1.94     oster 					  raidPtr->raid_cinfo[row][column].ci_vp,
   1095   1.94     oster 					  &ci_label );
   1096   1.94     oster 				}
   1097   1.11     oster 			}
   1098   1.11     oster 		}
   1099   1.11     oster 
   1100   1.11     oster 		return (retcode);
   1101   1.48     oster 	case RAIDFRAME_SET_AUTOCONFIG:
   1102   1.78   minoura 		d = rf_set_autoconfig(raidPtr, *(int *) data);
   1103  1.123     oster 		printf("raid%d: New autoconfig value is: %d\n",
   1104  1.123     oster 		       raidPtr->raidid, d);
   1105   1.78   minoura 		*(int *) data = d;
   1106   1.48     oster 		return (retcode);
   1107   1.48     oster 
   1108   1.48     oster 	case RAIDFRAME_SET_ROOT:
   1109   1.78   minoura 		d = rf_set_rootpartition(raidPtr, *(int *) data);
   1110  1.123     oster 		printf("raid%d: New rootpartition value is: %d\n",
   1111  1.123     oster 		       raidPtr->raidid, d);
   1112   1.78   minoura 		*(int *) data = d;
   1113   1.48     oster 		return (retcode);
   1114    1.9     oster 
   1115    1.1     oster 		/* initialize all parity */
   1116    1.1     oster 	case RAIDFRAME_REWRITEPARITY:
   1117    1.1     oster 
   1118   1.42     oster 		if (raidPtr->Layout.map->faultsTolerated == 0) {
   1119   1.17     oster 			/* Parity for RAID 0 is trivially correct */
   1120   1.42     oster 			raidPtr->parity_good = RF_RAID_CLEAN;
   1121   1.17     oster 			return(0);
   1122   1.17     oster 		}
   1123   1.37     oster 
   1124   1.42     oster 		if (raidPtr->parity_rewrite_in_progress == 1) {
   1125   1.37     oster 			/* Re-write is already in progress! */
   1126   1.37     oster 			return(EINVAL);
   1127   1.37     oster 		}
   1128   1.27     oster 
   1129   1.42     oster 		retcode = RF_CREATE_THREAD(raidPtr->parity_rewrite_thread,
   1130   1.37     oster 					   rf_RewriteParityThread,
   1131   1.42     oster 					   raidPtr,"raid_parity");
   1132    1.9     oster 		return (retcode);
   1133    1.9     oster 
   1134   1.11     oster 
   1135   1.11     oster 	case RAIDFRAME_ADD_HOT_SPARE:
   1136   1.12     oster 		sparePtr = (RF_SingleComponent_t *) data;
   1137   1.12     oster 		memcpy( &hot_spare, sparePtr, sizeof(RF_SingleComponent_t));
   1138   1.42     oster 		retcode = rf_add_hot_spare(raidPtr, &hot_spare);
   1139   1.11     oster 		return(retcode);
   1140   1.11     oster 
   1141   1.11     oster 	case RAIDFRAME_REMOVE_HOT_SPARE:
   1142   1.73     oster 		return(retcode);
   1143   1.73     oster 
   1144   1.73     oster 	case RAIDFRAME_DELETE_COMPONENT:
   1145   1.73     oster 		componentPtr = (RF_SingleComponent_t *)data;
   1146   1.73     oster 		memcpy( &component, componentPtr,
   1147   1.73     oster 			sizeof(RF_SingleComponent_t));
   1148   1.73     oster 		retcode = rf_delete_component(raidPtr, &component);
   1149   1.73     oster 		return(retcode);
   1150   1.73     oster 
   1151   1.73     oster 	case RAIDFRAME_INCORPORATE_HOT_SPARE:
   1152   1.73     oster 		componentPtr = (RF_SingleComponent_t *)data;
   1153   1.73     oster 		memcpy( &component, componentPtr,
   1154   1.73     oster 			sizeof(RF_SingleComponent_t));
   1155   1.73     oster 		retcode = rf_incorporate_hot_spare(raidPtr, &component);
   1156   1.11     oster 		return(retcode);
   1157   1.11     oster 
   1158   1.12     oster 	case RAIDFRAME_REBUILD_IN_PLACE:
   1159   1.24     oster 
   1160   1.42     oster 		if (raidPtr->Layout.map->faultsTolerated == 0) {
   1161   1.24     oster 			/* Can't do this on a RAID 0!! */
   1162   1.24     oster 			return(EINVAL);
   1163   1.24     oster 		}
   1164   1.24     oster 
   1165   1.42     oster 		if (raidPtr->recon_in_progress == 1) {
   1166   1.37     oster 			/* a reconstruct is already in progress! */
   1167   1.37     oster 			return(EINVAL);
   1168   1.37     oster 		}
   1169   1.37     oster 
   1170   1.12     oster 		componentPtr = (RF_SingleComponent_t *) data;
   1171   1.12     oster 		memcpy( &component, componentPtr,
   1172   1.12     oster 			sizeof(RF_SingleComponent_t));
   1173   1.12     oster 		row = component.row;
   1174   1.12     oster 		column = component.column;
   1175  1.147     oster 
   1176   1.42     oster 		if ((row < 0) || (row >= raidPtr->numRow) ||
   1177   1.42     oster 		    (column < 0) || (column >= raidPtr->numCol)) {
   1178   1.12     oster 			return(EINVAL);
   1179   1.12     oster 		}
   1180   1.37     oster 
   1181  1.149     oster 		RF_LOCK_MUTEX(raidPtr->mutex);
   1182  1.149     oster 		if ((raidPtr->Disks[row][column].status == rf_ds_optimal) &&
   1183  1.149     oster 		    (raidPtr->numFailures > 0)) {
   1184  1.149     oster 			/* XXX 0 above shouldn't be constant!!! */
   1185  1.149     oster 			/* some component other than this has failed.
   1186  1.149     oster 			   Let's not make things worse than they already
   1187  1.149     oster 			   are... */
   1188  1.149     oster 			printf("raid%d: Unable to reconstruct to disk at:\n",
   1189  1.149     oster 			       raidPtr->raidid);
   1190  1.149     oster 			printf("raid%d:     Row: %d Col: %d   Too many failures.\n",
   1191  1.149     oster 			       raidPtr->raidid, row, column);
   1192  1.149     oster 			RF_UNLOCK_MUTEX(raidPtr->mutex);
   1193  1.149     oster 			return (EINVAL);
   1194  1.149     oster 		}
   1195  1.149     oster 		if (raidPtr->Disks[row][column].status ==
   1196  1.149     oster 		    rf_ds_reconstructing) {
   1197  1.149     oster 			printf("raid%d: Unable to reconstruct to disk at:\n",
   1198  1.149     oster 			       raidPtr->raidid);
   1199  1.149     oster 			printf("raid%d:    Row: %d Col: %d   Reconstruction already occuring!\n", raidPtr->raidid, row, column);
   1200  1.149     oster 
   1201  1.149     oster 			RF_UNLOCK_MUTEX(raidPtr->mutex);
   1202  1.149     oster 			return (EINVAL);
   1203  1.149     oster 		}
   1204  1.149     oster 		if (raidPtr->Disks[row][column].status == rf_ds_spared) {
   1205  1.149     oster 			RF_UNLOCK_MUTEX(raidPtr->mutex);
   1206  1.149     oster 			return (EINVAL);
   1207  1.149     oster 		}
   1208  1.149     oster 		RF_UNLOCK_MUTEX(raidPtr->mutex);
   1209  1.149     oster 
   1210   1.37     oster 		RF_Malloc(rrcopy, sizeof(*rrcopy), (struct rf_recon_req *));
   1211   1.38     oster 		if (rrcopy == NULL)
   1212   1.38     oster 			return(ENOMEM);
   1213   1.37     oster 
   1214   1.42     oster 		rrcopy->raidPtr = (void *) raidPtr;
   1215   1.37     oster 		rrcopy->row = row;
   1216   1.37     oster 		rrcopy->col = column;
   1217   1.37     oster 
   1218   1.42     oster 		retcode = RF_CREATE_THREAD(raidPtr->recon_thread,
   1219   1.37     oster 					   rf_ReconstructInPlaceThread,
   1220   1.37     oster 					   rrcopy,"raid_reconip");
   1221   1.12     oster 		return(retcode);
   1222   1.12     oster 
   1223    1.1     oster 	case RAIDFRAME_GET_INFO:
   1224   1.42     oster 		if (!raidPtr->valid)
   1225   1.41     oster 			return (ENODEV);
   1226   1.41     oster 		ucfgp = (RF_DeviceConfig_t **) data;
   1227   1.41     oster 		RF_Malloc(d_cfg, sizeof(RF_DeviceConfig_t),
   1228   1.41     oster 			  (RF_DeviceConfig_t *));
   1229   1.41     oster 		if (d_cfg == NULL)
   1230   1.41     oster 			return (ENOMEM);
   1231  1.108   thorpej 		memset((char *) d_cfg, 0, sizeof(RF_DeviceConfig_t));
   1232   1.42     oster 		d_cfg->rows = raidPtr->numRow;
   1233   1.42     oster 		d_cfg->cols = raidPtr->numCol;
   1234   1.42     oster 		d_cfg->ndevs = raidPtr->numRow * raidPtr->numCol;
   1235   1.41     oster 		if (d_cfg->ndevs >= RF_MAX_DISKS) {
   1236   1.41     oster 			RF_Free(d_cfg, sizeof(RF_DeviceConfig_t));
   1237   1.41     oster 			return (ENOMEM);
   1238   1.41     oster 		}
   1239   1.42     oster 		d_cfg->nspares = raidPtr->numSpare;
   1240   1.41     oster 		if (d_cfg->nspares >= RF_MAX_DISKS) {
   1241   1.41     oster 			RF_Free(d_cfg, sizeof(RF_DeviceConfig_t));
   1242   1.41     oster 			return (ENOMEM);
   1243   1.41     oster 		}
   1244   1.42     oster 		d_cfg->maxqdepth = raidPtr->maxQueueDepth;
   1245   1.41     oster 		d = 0;
   1246   1.41     oster 		for (i = 0; i < d_cfg->rows; i++) {
   1247   1.41     oster 			for (j = 0; j < d_cfg->cols; j++) {
   1248   1.42     oster 				d_cfg->devs[d] = raidPtr->Disks[i][j];
   1249   1.41     oster 				d++;
   1250    1.1     oster 			}
   1251   1.41     oster 		}
   1252   1.41     oster 		for (j = d_cfg->cols, i = 0; i < d_cfg->nspares; i++, j++) {
   1253   1.42     oster 			d_cfg->spares[i] = raidPtr->Disks[0][j];
   1254   1.41     oster 		}
   1255   1.41     oster 		retcode = copyout((caddr_t) d_cfg, (caddr_t) * ucfgp,
   1256   1.41     oster 				  sizeof(RF_DeviceConfig_t));
   1257   1.41     oster 		RF_Free(d_cfg, sizeof(RF_DeviceConfig_t));
   1258   1.41     oster 
   1259   1.41     oster 		return (retcode);
   1260    1.9     oster 
   1261   1.22     oster 	case RAIDFRAME_CHECK_PARITY:
   1262   1.42     oster 		*(int *) data = raidPtr->parity_good;
   1263   1.22     oster 		return (0);
   1264   1.41     oster 
   1265    1.1     oster 	case RAIDFRAME_RESET_ACCTOTALS:
   1266  1.108   thorpej 		memset(&raidPtr->acc_totals, 0, sizeof(raidPtr->acc_totals));
   1267   1.41     oster 		return (0);
   1268    1.9     oster 
   1269    1.1     oster 	case RAIDFRAME_GET_ACCTOTALS:
   1270   1.41     oster 		totals = (RF_AccTotals_t *) data;
   1271   1.42     oster 		*totals = raidPtr->acc_totals;
   1272   1.41     oster 		return (0);
   1273    1.9     oster 
   1274    1.1     oster 	case RAIDFRAME_KEEP_ACCTOTALS:
   1275   1.42     oster 		raidPtr->keep_acc_totals = *(int *)data;
   1276   1.41     oster 		return (0);
   1277    1.9     oster 
   1278    1.1     oster 	case RAIDFRAME_GET_SIZE:
   1279   1.42     oster 		*(int *) data = raidPtr->totalSectors;
   1280    1.9     oster 		return (0);
   1281    1.1     oster 
   1282    1.1     oster 		/* fail a disk & optionally start reconstruction */
   1283    1.1     oster 	case RAIDFRAME_FAIL_DISK:
   1284   1.24     oster 
   1285   1.42     oster 		if (raidPtr->Layout.map->faultsTolerated == 0) {
   1286   1.24     oster 			/* Can't do this on a RAID 0!! */
   1287   1.24     oster 			return(EINVAL);
   1288   1.24     oster 		}
   1289   1.24     oster 
   1290    1.1     oster 		rr = (struct rf_recon_req *) data;
   1291    1.9     oster 
   1292   1.42     oster 		if (rr->row < 0 || rr->row >= raidPtr->numRow
   1293   1.42     oster 		    || rr->col < 0 || rr->col >= raidPtr->numCol)
   1294    1.9     oster 			return (EINVAL);
   1295  1.149     oster 
   1296  1.149     oster 
   1297  1.149     oster 		RF_LOCK_MUTEX(raidPtr->mutex);
   1298  1.149     oster 		if ((raidPtr->Disks[rr->row][rr->col].status ==
   1299  1.149     oster 		     rf_ds_optimal) && (raidPtr->numFailures > 0)) {
   1300  1.149     oster 			/* some other component has failed.  Let's not make
   1301  1.149     oster 			   things worse. XXX wrong for RAID6 */
   1302  1.149     oster 			RF_UNLOCK_MUTEX(raidPtr->mutex);
   1303  1.149     oster 			return (EINVAL);
   1304  1.149     oster 		}
   1305  1.149     oster 		if (raidPtr->Disks[rr->row][rr->col].status == rf_ds_spared) {
   1306  1.149     oster 			/* Can't fail a spared disk! */
   1307  1.149     oster 			RF_UNLOCK_MUTEX(raidPtr->mutex);
   1308  1.149     oster 			return (EINVAL);
   1309  1.149     oster 		}
   1310  1.149     oster 		RF_UNLOCK_MUTEX(raidPtr->mutex);
   1311    1.1     oster 
   1312    1.9     oster 		/* make a copy of the recon request so that we don't rely on
   1313    1.9     oster 		 * the user's buffer */
   1314    1.1     oster 		RF_Malloc(rrcopy, sizeof(*rrcopy), (struct rf_recon_req *));
   1315   1.38     oster 		if (rrcopy == NULL)
   1316   1.38     oster 			return(ENOMEM);
   1317  1.118       wiz 		memcpy(rrcopy, rr, sizeof(*rr));
   1318   1.42     oster 		rrcopy->raidPtr = (void *) raidPtr;
   1319    1.1     oster 
   1320   1.42     oster 		retcode = RF_CREATE_THREAD(raidPtr->recon_thread,
   1321   1.37     oster 					   rf_ReconThread,
   1322   1.37     oster 					   rrcopy,"raid_recon");
   1323    1.9     oster 		return (0);
   1324    1.9     oster 
   1325    1.9     oster 		/* invoke a copyback operation after recon on whatever disk
   1326    1.9     oster 		 * needs it, if any */
   1327    1.9     oster 	case RAIDFRAME_COPYBACK:
   1328   1.24     oster 
   1329   1.42     oster 		if (raidPtr->Layout.map->faultsTolerated == 0) {
   1330   1.24     oster 			/* This makes no sense on a RAID 0!! */
   1331   1.24     oster 			return(EINVAL);
   1332   1.24     oster 		}
   1333   1.24     oster 
   1334   1.42     oster 		if (raidPtr->copyback_in_progress == 1) {
   1335   1.37     oster 			/* Copyback is already in progress! */
   1336   1.37     oster 			return(EINVAL);
   1337   1.37     oster 		}
   1338   1.27     oster 
   1339   1.42     oster 		retcode = RF_CREATE_THREAD(raidPtr->copyback_thread,
   1340   1.37     oster 					   rf_CopybackThread,
   1341   1.42     oster 					   raidPtr,"raid_copyback");
   1342   1.37     oster 		return (retcode);
   1343    1.9     oster 
   1344    1.1     oster 		/* return the percentage completion of reconstruction */
   1345   1.37     oster 	case RAIDFRAME_CHECK_RECON_STATUS:
   1346   1.42     oster 		if (raidPtr->Layout.map->faultsTolerated == 0) {
   1347   1.71     oster 			/* This makes no sense on a RAID 0, so tell the
   1348   1.71     oster 			   user it's done. */
   1349   1.71     oster 			*(int *) data = 100;
   1350   1.71     oster 			return(0);
   1351   1.24     oster 		}
   1352   1.37     oster 		row = 0; /* XXX we only consider a single row... */
   1353   1.42     oster 		if (raidPtr->status[row] != rf_rs_reconstructing)
   1354    1.1     oster 			*(int *) data = 100;
   1355    1.9     oster 		else
   1356   1.42     oster 			*(int *) data = raidPtr->reconControl[row]->percentComplete;
   1357    1.9     oster 		return (0);
   1358   1.83     oster 	case RAIDFRAME_CHECK_RECON_STATUS_EXT:
   1359   1.83     oster 		progressInfoPtr = (RF_ProgressInfo_t **) data;
   1360   1.83     oster 		row = 0; /* XXX we only consider a single row... */
   1361   1.83     oster 		if (raidPtr->status[row] != rf_rs_reconstructing) {
   1362   1.83     oster 			progressInfo.remaining = 0;
   1363   1.83     oster 			progressInfo.completed = 100;
   1364   1.83     oster 			progressInfo.total = 100;
   1365   1.83     oster 		} else {
   1366   1.83     oster 			progressInfo.total =
   1367   1.83     oster 				raidPtr->reconControl[row]->numRUsTotal;
   1368   1.83     oster 			progressInfo.completed =
   1369   1.83     oster 				raidPtr->reconControl[row]->numRUsComplete;
   1370   1.83     oster 			progressInfo.remaining = progressInfo.total -
   1371   1.83     oster 				progressInfo.completed;
   1372   1.83     oster 		}
   1373   1.83     oster 		retcode = copyout((caddr_t) &progressInfo,
   1374   1.83     oster 				  (caddr_t) *progressInfoPtr,
   1375   1.83     oster 				  sizeof(RF_ProgressInfo_t));
   1376   1.83     oster 		return (retcode);
   1377    1.9     oster 
   1378   1.37     oster 	case RAIDFRAME_CHECK_PARITYREWRITE_STATUS:
   1379   1.42     oster 		if (raidPtr->Layout.map->faultsTolerated == 0) {
   1380   1.80     oster 			/* This makes no sense on a RAID 0, so tell the
   1381   1.80     oster 			   user it's done. */
   1382   1.80     oster 			*(int *) data = 100;
   1383   1.80     oster 			return(0);
   1384   1.37     oster 		}
   1385   1.42     oster 		if (raidPtr->parity_rewrite_in_progress == 1) {
   1386   1.83     oster 			*(int *) data = 100 *
   1387   1.83     oster 				raidPtr->parity_rewrite_stripes_done /
   1388   1.83     oster 				raidPtr->Layout.numStripe;
   1389   1.37     oster 		} else {
   1390   1.37     oster 			*(int *) data = 100;
   1391   1.37     oster 		}
   1392   1.37     oster 		return (0);
   1393   1.37     oster 
   1394   1.83     oster 	case RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT:
   1395   1.83     oster 		progressInfoPtr = (RF_ProgressInfo_t **) data;
   1396   1.83     oster 		if (raidPtr->parity_rewrite_in_progress == 1) {
   1397   1.83     oster 			progressInfo.total = raidPtr->Layout.numStripe;
   1398   1.83     oster 			progressInfo.completed =
   1399   1.83     oster 				raidPtr->parity_rewrite_stripes_done;
   1400   1.83     oster 			progressInfo.remaining = progressInfo.total -
   1401   1.83     oster 				progressInfo.completed;
   1402   1.83     oster 		} else {
   1403   1.83     oster 			progressInfo.remaining = 0;
   1404   1.83     oster 			progressInfo.completed = 100;
   1405   1.83     oster 			progressInfo.total = 100;
   1406   1.83     oster 		}
   1407   1.83     oster 		retcode = copyout((caddr_t) &progressInfo,
   1408   1.83     oster 				  (caddr_t) *progressInfoPtr,
   1409   1.83     oster 				  sizeof(RF_ProgressInfo_t));
   1410   1.83     oster 		return (retcode);
   1411   1.83     oster 
   1412   1.37     oster 	case RAIDFRAME_CHECK_COPYBACK_STATUS:
   1413   1.42     oster 		if (raidPtr->Layout.map->faultsTolerated == 0) {
   1414   1.37     oster 			/* This makes no sense on a RAID 0 */
   1415   1.83     oster 			*(int *) data = 100;
   1416   1.83     oster 			return(0);
   1417   1.37     oster 		}
   1418   1.42     oster 		if (raidPtr->copyback_in_progress == 1) {
   1419   1.42     oster 			*(int *) data = 100 * raidPtr->copyback_stripes_done /
   1420   1.42     oster 				raidPtr->Layout.numStripe;
   1421   1.37     oster 		} else {
   1422   1.37     oster 			*(int *) data = 100;
   1423   1.37     oster 		}
   1424   1.37     oster 		return (0);
   1425   1.37     oster 
   1426   1.83     oster 	case RAIDFRAME_CHECK_COPYBACK_STATUS_EXT:
   1427   1.93     oster 		progressInfoPtr = (RF_ProgressInfo_t **) data;
   1428   1.83     oster 		if (raidPtr->copyback_in_progress == 1) {
   1429   1.83     oster 			progressInfo.total = raidPtr->Layout.numStripe;
   1430   1.83     oster 			progressInfo.completed =
   1431   1.93     oster 				raidPtr->copyback_stripes_done;
   1432   1.83     oster 			progressInfo.remaining = progressInfo.total -
   1433   1.83     oster 				progressInfo.completed;
   1434   1.83     oster 		} else {
   1435   1.83     oster 			progressInfo.remaining = 0;
   1436   1.83     oster 			progressInfo.completed = 100;
   1437   1.83     oster 			progressInfo.total = 100;
   1438   1.83     oster 		}
   1439   1.83     oster 		retcode = copyout((caddr_t) &progressInfo,
   1440   1.83     oster 				  (caddr_t) *progressInfoPtr,
   1441   1.83     oster 				  sizeof(RF_ProgressInfo_t));
   1442   1.83     oster 		return (retcode);
   1443   1.37     oster 
   1444    1.9     oster 		/* the sparetable daemon calls this to wait for the kernel to
   1445    1.9     oster 		 * need a spare table. this ioctl does not return until a
   1446    1.9     oster 		 * spare table is needed. XXX -- calling mpsleep here in the
   1447    1.9     oster 		 * ioctl code is almost certainly wrong and evil. -- XXX XXX
   1448    1.9     oster 		 * -- I should either compute the spare table in the kernel,
   1449    1.9     oster 		 * or have a different -- XXX XXX -- interface (a different
   1450   1.42     oster 		 * character device) for delivering the table     -- XXX */
   1451    1.1     oster #if 0
   1452    1.1     oster 	case RAIDFRAME_SPARET_WAIT:
   1453    1.1     oster 		RF_LOCK_MUTEX(rf_sparet_wait_mutex);
   1454    1.9     oster 		while (!rf_sparet_wait_queue)
   1455    1.9     oster 			mpsleep(&rf_sparet_wait_queue, (PZERO + 1) | PCATCH, "sparet wait", 0, (void *) simple_lock_addr(rf_sparet_wait_mutex), MS_LOCK_SIMPLE);
   1456    1.1     oster 		waitreq = rf_sparet_wait_queue;
   1457    1.1     oster 		rf_sparet_wait_queue = rf_sparet_wait_queue->next;
   1458    1.1     oster 		RF_UNLOCK_MUTEX(rf_sparet_wait_mutex);
   1459    1.9     oster 
   1460   1.42     oster 		/* structure assignment */
   1461   1.42     oster 		*((RF_SparetWait_t *) data) = *waitreq;
   1462    1.9     oster 
   1463    1.1     oster 		RF_Free(waitreq, sizeof(*waitreq));
   1464    1.9     oster 		return (0);
   1465    1.9     oster 
   1466    1.9     oster 		/* wakes up a process waiting on SPARET_WAIT and puts an error
   1467    1.9     oster 		 * code in it that will cause the dameon to exit */
   1468    1.1     oster 	case RAIDFRAME_ABORT_SPARET_WAIT:
   1469    1.1     oster 		RF_Malloc(waitreq, sizeof(*waitreq), (RF_SparetWait_t *));
   1470    1.1     oster 		waitreq->fcol = -1;
   1471    1.1     oster 		RF_LOCK_MUTEX(rf_sparet_wait_mutex);
   1472    1.1     oster 		waitreq->next = rf_sparet_wait_queue;
   1473    1.1     oster 		rf_sparet_wait_queue = waitreq;
   1474    1.1     oster 		RF_UNLOCK_MUTEX(rf_sparet_wait_mutex);
   1475    1.1     oster 		wakeup(&rf_sparet_wait_queue);
   1476    1.9     oster 		return (0);
   1477    1.1     oster 
   1478    1.9     oster 		/* used by the spare table daemon to deliver a spare table
   1479    1.9     oster 		 * into the kernel */
   1480    1.1     oster 	case RAIDFRAME_SEND_SPARET:
   1481    1.9     oster 
   1482    1.1     oster 		/* install the spare table */
   1483   1.42     oster 		retcode = rf_SetSpareTable(raidPtr, *(void **) data);
   1484    1.9     oster 
   1485    1.9     oster 		/* respond to the requestor.  the return status of the spare
   1486    1.9     oster 		 * table installation is passed in the "fcol" field */
   1487    1.1     oster 		RF_Malloc(waitreq, sizeof(*waitreq), (RF_SparetWait_t *));
   1488    1.1     oster 		waitreq->fcol = retcode;
   1489    1.1     oster 		RF_LOCK_MUTEX(rf_sparet_wait_mutex);
   1490    1.1     oster 		waitreq->next = rf_sparet_resp_queue;
   1491    1.1     oster 		rf_sparet_resp_queue = waitreq;
   1492    1.1     oster 		wakeup(&rf_sparet_resp_queue);
   1493    1.1     oster 		RF_UNLOCK_MUTEX(rf_sparet_wait_mutex);
   1494    1.9     oster 
   1495    1.9     oster 		return (retcode);
   1496    1.1     oster #endif
   1497    1.1     oster 
   1498    1.9     oster 	default:
   1499   1.36     oster 		break; /* fall through to the os-specific code below */
   1500    1.1     oster 
   1501    1.1     oster 	}
   1502    1.9     oster 
   1503   1.42     oster 	if (!raidPtr->valid)
   1504    1.9     oster 		return (EINVAL);
   1505    1.9     oster 
   1506    1.1     oster 	/*
   1507    1.1     oster 	 * Add support for "regular" device ioctls here.
   1508    1.1     oster 	 */
   1509    1.9     oster 
   1510    1.1     oster 	switch (cmd) {
   1511    1.1     oster 	case DIOCGDINFO:
   1512    1.9     oster 		*(struct disklabel *) data = *(rs->sc_dkdev.dk_label);
   1513    1.1     oster 		break;
   1514  1.102      fvdl #ifdef __HAVE_OLD_DISKLABEL
   1515  1.102      fvdl 	case ODIOCGDINFO:
   1516  1.102      fvdl 		newlabel = *(rs->sc_dkdev.dk_label);
   1517  1.102      fvdl 		if (newlabel.d_npartitions > OLDMAXPARTITIONS)
   1518  1.103      fvdl 			return ENOTTY;
   1519  1.102      fvdl 		memcpy(data, &newlabel, sizeof (struct olddisklabel));
   1520  1.102      fvdl 		break;
   1521  1.102      fvdl #endif
   1522    1.1     oster 
   1523    1.1     oster 	case DIOCGPART:
   1524    1.9     oster 		((struct partinfo *) data)->disklab = rs->sc_dkdev.dk_label;
   1525    1.9     oster 		((struct partinfo *) data)->part =
   1526    1.1     oster 		    &rs->sc_dkdev.dk_label->d_partitions[DISKPART(dev)];
   1527    1.1     oster 		break;
   1528    1.1     oster 
   1529    1.1     oster 	case DIOCWDINFO:
   1530    1.1     oster 	case DIOCSDINFO:
   1531  1.102      fvdl #ifdef __HAVE_OLD_DISKLABEL
   1532  1.102      fvdl 	case ODIOCWDINFO:
   1533  1.102      fvdl 	case ODIOCSDINFO:
   1534  1.102      fvdl #endif
   1535  1.102      fvdl 	{
   1536  1.102      fvdl 		struct disklabel *lp;
   1537  1.102      fvdl #ifdef __HAVE_OLD_DISKLABEL
   1538  1.102      fvdl 		if (cmd == ODIOCSDINFO || cmd == ODIOCWDINFO) {
   1539  1.102      fvdl 			memset(&newlabel, 0, sizeof newlabel);
   1540  1.102      fvdl 			memcpy(&newlabel, data, sizeof (struct olddisklabel));
   1541  1.102      fvdl 			lp = &newlabel;
   1542  1.102      fvdl 		} else
   1543  1.102      fvdl #endif
   1544  1.102      fvdl 		lp = (struct disklabel *)data;
   1545  1.102      fvdl 
   1546    1.1     oster 		if ((error = raidlock(rs)) != 0)
   1547    1.1     oster 			return (error);
   1548    1.1     oster 
   1549    1.1     oster 		rs->sc_flags |= RAIDF_LABELLING;
   1550    1.1     oster 
   1551    1.1     oster 		error = setdisklabel(rs->sc_dkdev.dk_label,
   1552  1.102      fvdl 		    lp, 0, rs->sc_dkdev.dk_cpulabel);
   1553    1.1     oster 		if (error == 0) {
   1554  1.102      fvdl 			if (cmd == DIOCWDINFO
   1555  1.102      fvdl #ifdef __HAVE_OLD_DISKLABEL
   1556  1.102      fvdl 			    || cmd == ODIOCWDINFO
   1557  1.102      fvdl #endif
   1558  1.102      fvdl 			   )
   1559    1.1     oster 				error = writedisklabel(RAIDLABELDEV(dev),
   1560    1.1     oster 				    raidstrategy, rs->sc_dkdev.dk_label,
   1561    1.1     oster 				    rs->sc_dkdev.dk_cpulabel);
   1562    1.1     oster 		}
   1563    1.1     oster 		rs->sc_flags &= ~RAIDF_LABELLING;
   1564    1.1     oster 
   1565    1.1     oster 		raidunlock(rs);
   1566    1.1     oster 
   1567    1.1     oster 		if (error)
   1568    1.1     oster 			return (error);
   1569    1.1     oster 		break;
   1570  1.102      fvdl 	}
   1571    1.1     oster 
   1572    1.1     oster 	case DIOCWLABEL:
   1573    1.9     oster 		if (*(int *) data != 0)
   1574    1.1     oster 			rs->sc_flags |= RAIDF_WLABEL;
   1575    1.1     oster 		else
   1576    1.1     oster 			rs->sc_flags &= ~RAIDF_WLABEL;
   1577    1.1     oster 		break;
   1578    1.1     oster 
   1579    1.1     oster 	case DIOCGDEFLABEL:
   1580  1.102      fvdl 		raidgetdefaultlabel(raidPtr, rs, (struct disklabel *) data);
   1581    1.1     oster 		break;
   1582  1.102      fvdl 
   1583  1.102      fvdl #ifdef __HAVE_OLD_DISKLABEL
   1584  1.102      fvdl 	case ODIOCGDEFLABEL:
   1585  1.102      fvdl 		raidgetdefaultlabel(raidPtr, rs, &newlabel);
   1586  1.102      fvdl 		if (newlabel.d_npartitions > OLDMAXPARTITIONS)
   1587  1.103      fvdl 			return ENOTTY;
   1588  1.102      fvdl 		memcpy(data, &newlabel, sizeof (struct olddisklabel));
   1589  1.102      fvdl 		break;
   1590  1.102      fvdl #endif
   1591    1.1     oster 
   1592    1.1     oster 	default:
   1593   1.39     oster 		retcode = ENOTTY;
   1594    1.1     oster 	}
   1595    1.9     oster 	return (retcode);
   1596    1.1     oster 
   1597    1.1     oster }
   1598    1.1     oster 
   1599    1.1     oster 
   1600    1.9     oster /* raidinit -- complete the rest of the initialization for the
   1601    1.1     oster    RAIDframe device.  */
   1602    1.1     oster 
   1603    1.1     oster 
   1604   1.59     oster static void
   1605   1.59     oster raidinit(raidPtr)
   1606    1.1     oster 	RF_Raid_t *raidPtr;
   1607    1.1     oster {
   1608    1.1     oster 	struct raid_softc *rs;
   1609   1.59     oster 	int     unit;
   1610    1.1     oster 
   1611   1.59     oster 	unit = raidPtr->raidid;
   1612    1.1     oster 
   1613    1.1     oster 	rs = &raid_softc[unit];
   1614    1.1     oster 
   1615    1.1     oster 	/* XXX should check return code first... */
   1616    1.1     oster 	rs->sc_flags |= RAIDF_INITED;
   1617    1.1     oster 
   1618    1.9     oster 	sprintf(rs->sc_xname, "raid%d", unit);	/* XXX doesn't check bounds. */
   1619    1.1     oster 
   1620    1.9     oster 	rs->sc_dkdev.dk_name = rs->sc_xname;
   1621   1.11     oster 
   1622    1.1     oster 	/* disk_attach actually creates space for the CPU disklabel, among
   1623    1.9     oster 	 * other things, so it's critical to call this *BEFORE* we try putzing
   1624    1.9     oster 	 * with disklabels. */
   1625   1.11     oster 
   1626    1.1     oster 	disk_attach(&rs->sc_dkdev);
   1627    1.1     oster 
   1628    1.1     oster 	/* XXX There may be a weird interaction here between this, and
   1629    1.9     oster 	 * protectedSectors, as used in RAIDframe.  */
   1630   1.11     oster 
   1631    1.9     oster 	rs->sc_size = raidPtr->totalSectors;
   1632   1.11     oster 
   1633    1.1     oster }
   1634  1.150     oster #if (RF_INCLUDE_PARITY_DECLUSTERING_DS > 0)
   1635    1.1     oster /* wake up the daemon & tell it to get us a spare table
   1636    1.1     oster  * XXX
   1637    1.9     oster  * the entries in the queues should be tagged with the raidPtr
   1638   1.11     oster  * so that in the extremely rare case that two recons happen at once,
   1639   1.11     oster  * we know for which device were requesting a spare table
   1640    1.1     oster  * XXX
   1641   1.39     oster  *
   1642   1.39     oster  * XXX This code is not currently used. GO
   1643    1.1     oster  */
   1644    1.9     oster int
   1645    1.9     oster rf_GetSpareTableFromDaemon(req)
   1646    1.9     oster 	RF_SparetWait_t *req;
   1647    1.9     oster {
   1648    1.9     oster 	int     retcode;
   1649    1.9     oster 
   1650    1.9     oster 	RF_LOCK_MUTEX(rf_sparet_wait_mutex);
   1651    1.9     oster 	req->next = rf_sparet_wait_queue;
   1652    1.9     oster 	rf_sparet_wait_queue = req;
   1653    1.9     oster 	wakeup(&rf_sparet_wait_queue);
   1654    1.9     oster 
   1655    1.9     oster 	/* mpsleep unlocks the mutex */
   1656    1.9     oster 	while (!rf_sparet_resp_queue) {
   1657   1.15     oster 		tsleep(&rf_sparet_resp_queue, PRIBIO,
   1658    1.9     oster 		    "raidframe getsparetable", 0);
   1659    1.9     oster 	}
   1660    1.9     oster 	req = rf_sparet_resp_queue;
   1661    1.9     oster 	rf_sparet_resp_queue = req->next;
   1662    1.9     oster 	RF_UNLOCK_MUTEX(rf_sparet_wait_mutex);
   1663    1.9     oster 
   1664    1.9     oster 	retcode = req->fcol;
   1665    1.9     oster 	RF_Free(req, sizeof(*req));	/* this is not the same req as we
   1666    1.9     oster 					 * alloc'd */
   1667    1.9     oster 	return (retcode);
   1668    1.1     oster }
   1669  1.150     oster #endif
   1670   1.39     oster 
   1671   1.11     oster /* a wrapper around rf_DoAccess that extracts appropriate info from the
   1672   1.11     oster  * bp & passes it down.
   1673    1.1     oster  * any calls originating in the kernel must use non-blocking I/O
   1674    1.1     oster  * do some extra sanity checking to return "appropriate" error values for
   1675    1.1     oster  * certain conditions (to make some standard utilities work)
   1676   1.34     oster  *
   1677   1.34     oster  * Formerly known as: rf_DoAccessKernel
   1678    1.1     oster  */
   1679   1.34     oster void
   1680   1.34     oster raidstart(raidPtr)
   1681    1.9     oster 	RF_Raid_t *raidPtr;
   1682    1.1     oster {
   1683    1.1     oster 	RF_SectorCount_t num_blocks, pb, sum;
   1684    1.1     oster 	RF_RaidAddr_t raid_addr;
   1685    1.1     oster 	struct partition *pp;
   1686    1.9     oster 	daddr_t blocknum;
   1687    1.9     oster 	int     unit;
   1688    1.1     oster 	struct raid_softc *rs;
   1689    1.9     oster 	int     do_async;
   1690   1.34     oster 	struct buf *bp;
   1691    1.1     oster 
   1692    1.1     oster 	unit = raidPtr->raidid;
   1693    1.1     oster 	rs = &raid_softc[unit];
   1694   1.34     oster 
   1695   1.56     oster 	/* quick check to see if anything has died recently */
   1696   1.56     oster 	RF_LOCK_MUTEX(raidPtr->mutex);
   1697   1.56     oster 	if (raidPtr->numNewFailures > 0) {
   1698  1.151     oster 		RF_UNLOCK_MUTEX(raidPtr->mutex);
   1699   1.91     oster 		rf_update_component_labels(raidPtr,
   1700   1.91     oster 					   RF_NORMAL_COMPONENT_UPDATE);
   1701  1.151     oster 		RF_LOCK_MUTEX(raidPtr->mutex);
   1702   1.56     oster 		raidPtr->numNewFailures--;
   1703   1.56     oster 	}
   1704   1.56     oster 
   1705   1.34     oster 	/* Check to see if we're at the limit... */
   1706   1.34     oster 	while (raidPtr->openings > 0) {
   1707   1.34     oster 		RF_UNLOCK_MUTEX(raidPtr->mutex);
   1708   1.34     oster 
   1709   1.34     oster 		/* get the next item, if any, from the queue */
   1710  1.125   hannken 		if ((bp = BUFQ_GET(&rs->buf_queue)) == NULL) {
   1711   1.34     oster 			/* nothing more to do */
   1712   1.34     oster 			return;
   1713   1.34     oster 		}
   1714   1.34     oster 
   1715   1.34     oster 		/* Ok, for the bp we have here, bp->b_blkno is relative to the
   1716   1.34     oster 		 * partition.. Need to make it absolute to the underlying
   1717   1.34     oster 		 * device.. */
   1718    1.1     oster 
   1719   1.34     oster 		blocknum = bp->b_blkno;
   1720   1.34     oster 		if (DISKPART(bp->b_dev) != RAW_PART) {
   1721   1.34     oster 			pp = &rs->sc_dkdev.dk_label->d_partitions[DISKPART(bp->b_dev)];
   1722   1.34     oster 			blocknum += pp->p_offset;
   1723   1.34     oster 		}
   1724    1.1     oster 
   1725   1.34     oster 		db1_printf(("Blocks: %d, %d\n", (int) bp->b_blkno,
   1726   1.34     oster 			    (int) blocknum));
   1727   1.34     oster 
   1728   1.34     oster 		db1_printf(("bp->b_bcount = %d\n", (int) bp->b_bcount));
   1729   1.34     oster 		db1_printf(("bp->b_resid = %d\n", (int) bp->b_resid));
   1730   1.34     oster 
   1731   1.34     oster 		/* *THIS* is where we adjust what block we're going to...
   1732   1.34     oster 		 * but DO NOT TOUCH bp->b_blkno!!! */
   1733   1.34     oster 		raid_addr = blocknum;
   1734   1.34     oster 
   1735   1.34     oster 		num_blocks = bp->b_bcount >> raidPtr->logBytesPerSector;
   1736   1.34     oster 		pb = (bp->b_bcount & raidPtr->sectorMask) ? 1 : 0;
   1737   1.34     oster 		sum = raid_addr + num_blocks + pb;
   1738   1.34     oster 		if (1 || rf_debugKernelAccess) {
   1739   1.34     oster 			db1_printf(("raid_addr=%d sum=%d num_blocks=%d(+%d) (%d)\n",
   1740   1.34     oster 				    (int) raid_addr, (int) sum, (int) num_blocks,
   1741   1.34     oster 				    (int) pb, (int) bp->b_resid));
   1742   1.34     oster 		}
   1743   1.34     oster 		if ((sum > raidPtr->totalSectors) || (sum < raid_addr)
   1744   1.34     oster 		    || (sum < num_blocks) || (sum < pb)) {
   1745   1.34     oster 			bp->b_error = ENOSPC;
   1746   1.34     oster 			bp->b_flags |= B_ERROR;
   1747   1.34     oster 			bp->b_resid = bp->b_bcount;
   1748   1.34     oster 			biodone(bp);
   1749   1.34     oster 			RF_LOCK_MUTEX(raidPtr->mutex);
   1750   1.34     oster 			continue;
   1751   1.34     oster 		}
   1752   1.34     oster 		/*
   1753   1.34     oster 		 * XXX rf_DoAccess() should do this, not just DoAccessKernel()
   1754   1.34     oster 		 */
   1755   1.34     oster 
   1756   1.34     oster 		if (bp->b_bcount & raidPtr->sectorMask) {
   1757   1.34     oster 			bp->b_error = EINVAL;
   1758   1.34     oster 			bp->b_flags |= B_ERROR;
   1759   1.34     oster 			bp->b_resid = bp->b_bcount;
   1760   1.34     oster 			biodone(bp);
   1761   1.34     oster 			RF_LOCK_MUTEX(raidPtr->mutex);
   1762   1.34     oster 			continue;
   1763   1.34     oster 
   1764   1.34     oster 		}
   1765   1.34     oster 		db1_printf(("Calling DoAccess..\n"));
   1766   1.34     oster 
   1767    1.1     oster 
   1768   1.34     oster 		RF_LOCK_MUTEX(raidPtr->mutex);
   1769   1.34     oster 		raidPtr->openings--;
   1770   1.34     oster 		RF_UNLOCK_MUTEX(raidPtr->mutex);
   1771    1.1     oster 
   1772   1.34     oster 		/*
   1773   1.34     oster 		 * Everything is async.
   1774   1.34     oster 		 */
   1775   1.34     oster 		do_async = 1;
   1776   1.34     oster 
   1777   1.99     oster 		disk_busy(&rs->sc_dkdev);
   1778   1.99     oster 
   1779   1.34     oster 		/* XXX we're still at splbio() here... do we *really*
   1780   1.34     oster 		   need to be? */
   1781   1.20     oster 
   1782   1.99     oster 		/* don't ever condition on bp->b_flags & B_WRITE.
   1783   1.99     oster 		 * always condition on B_READ instead */
   1784   1.37     oster 
   1785  1.151     oster 		bp->b_error = rf_DoAccess(raidPtr, (bp->b_flags & B_READ) ?
   1786   1.34     oster 				      RF_IO_TYPE_READ : RF_IO_TYPE_WRITE,
   1787   1.34     oster 				      do_async, raid_addr, num_blocks,
   1788  1.109     oster 				      bp->b_data, bp, RF_DAG_NONBLOCKING_IO);
   1789  1.151     oster 
   1790  1.151     oster 		if (bp->b_error) {
   1791  1.151     oster 			bp->b_flags |= B_ERROR;
   1792  1.151     oster 		}
   1793   1.20     oster 
   1794   1.20     oster 		RF_LOCK_MUTEX(raidPtr->mutex);
   1795   1.20     oster 	}
   1796   1.34     oster 	RF_UNLOCK_MUTEX(raidPtr->mutex);
   1797   1.34     oster }
   1798   1.20     oster 
   1799   1.20     oster 
   1800    1.7  explorer 
   1801    1.7  explorer 
   1802    1.1     oster /* invoke an I/O from kernel mode.  Disk queue should be locked upon entry */
   1803    1.1     oster 
   1804    1.9     oster int
   1805    1.9     oster rf_DispatchKernelIO(queue, req)
   1806    1.9     oster 	RF_DiskQueue_t *queue;
   1807    1.9     oster 	RF_DiskQueueData_t *req;
   1808    1.1     oster {
   1809    1.9     oster 	int     op = (req->type == RF_IO_TYPE_READ) ? B_READ : B_WRITE;
   1810    1.1     oster 	struct buf *bp;
   1811    1.9     oster 	struct raidbuf *raidbp = NULL;
   1812    1.9     oster 
   1813    1.1     oster 	req->queue = queue;
   1814    1.9     oster 
   1815  1.134     oster #if DIAGNOSTIC
   1816  1.134     oster 	if (queue->raidPtr->raidid >= numraid) {
   1817  1.137    itojun 		printf("Invalid unit number: %d %d\n", queue->raidPtr->raidid,
   1818  1.137    itojun 		    numraid);
   1819  1.141    provos 		panic("Invalid Unit number in rf_DispatchKernelIO");
   1820    1.1     oster 	}
   1821  1.134     oster #endif
   1822    1.1     oster 
   1823    1.1     oster 	bp = req->bp;
   1824   1.16     oster #if 1
   1825    1.9     oster 	/* XXX when there is a physical disk failure, someone is passing us a
   1826    1.9     oster 	 * buffer that contains old stuff!!  Attempt to deal with this problem
   1827    1.9     oster 	 * without taking a performance hit... (not sure where the real bug
   1828    1.9     oster 	 * is.  It's buried in RAIDframe somewhere) :-(  GO ) */
   1829    1.4     oster 
   1830    1.4     oster 	if (bp->b_flags & B_ERROR) {
   1831    1.4     oster 		bp->b_flags &= ~B_ERROR;
   1832    1.4     oster 	}
   1833    1.9     oster 	if (bp->b_error != 0) {
   1834    1.4     oster 		bp->b_error = 0;
   1835    1.4     oster 	}
   1836   1.16     oster #endif
   1837  1.136     oster 	raidbp = pool_get(&raidframe_cbufpool, PR_NOWAIT);
   1838  1.154        pk 	if (raidbp == NULL) {
   1839  1.154        pk 		bp->b_flags |= B_ERROR;
   1840  1.154        pk 		bp->b_error = ENOMEM;
   1841  1.154        pk 		return (ENOMEM);
   1842  1.154        pk 	}
   1843  1.155   thorpej 	BUF_INIT(&raidbp->rf_buf);
   1844    1.1     oster 
   1845    1.1     oster 	/*
   1846    1.1     oster 	 * context for raidiodone
   1847    1.1     oster 	 */
   1848    1.1     oster 	raidbp->rf_obp = bp;
   1849    1.1     oster 	raidbp->req = req;
   1850   1.32     oster 
   1851    1.1     oster 	switch (req->type) {
   1852    1.9     oster 	case RF_IO_TYPE_NOP:	/* used primarily to unlock a locked queue */
   1853    1.1     oster 		/* XXX need to do something extra here.. */
   1854    1.9     oster 		/* I'm leaving this in, as I've never actually seen it used,
   1855    1.9     oster 		 * and I'd like folks to report it... GO */
   1856    1.1     oster 		printf(("WAKEUP CALLED\n"));
   1857    1.1     oster 		queue->numOutstanding++;
   1858    1.1     oster 
   1859    1.1     oster 		/* XXX need to glue the original buffer into this??  */
   1860    1.1     oster 
   1861    1.1     oster 		KernelWakeupFunc(&raidbp->rf_buf);
   1862    1.1     oster 		break;
   1863    1.9     oster 
   1864    1.1     oster 	case RF_IO_TYPE_READ:
   1865    1.1     oster 	case RF_IO_TYPE_WRITE:
   1866    1.9     oster 
   1867    1.1     oster 		if (req->tracerec) {
   1868    1.1     oster 			RF_ETIMER_START(req->tracerec->timer);
   1869    1.1     oster 		}
   1870    1.9     oster 		InitBP(&raidbp->rf_buf, queue->rf_cinfo->ci_vp,
   1871    1.9     oster 		    op | bp->b_flags, queue->rf_cinfo->ci_dev,
   1872    1.9     oster 		    req->sectorOffset, req->numSector,
   1873    1.9     oster 		    req->buf, KernelWakeupFunc, (void *) req,
   1874    1.9     oster 		    queue->raidPtr->logBytesPerSector, req->b_proc);
   1875    1.1     oster 
   1876    1.1     oster 		if (rf_debugKernelAccess) {
   1877    1.9     oster 			db1_printf(("dispatch: bp->b_blkno = %ld\n",
   1878    1.9     oster 				(long) bp->b_blkno));
   1879    1.1     oster 		}
   1880    1.1     oster 		queue->numOutstanding++;
   1881    1.1     oster 		queue->last_deq_sector = req->sectorOffset;
   1882    1.9     oster 		/* acc wouldn't have been let in if there were any pending
   1883    1.9     oster 		 * reqs at any other priority */
   1884    1.1     oster 		queue->curPriority = req->priority;
   1885    1.1     oster 
   1886    1.1     oster 		db1_printf(("Going for %c to unit %d row %d col %d\n",
   1887  1.134     oster 			    req->type, queue->raidPtr->raidid,
   1888  1.134     oster 			    queue->row, queue->col));
   1889    1.1     oster 		db1_printf(("sector %d count %d (%d bytes) %d\n",
   1890    1.9     oster 			(int) req->sectorOffset, (int) req->numSector,
   1891    1.9     oster 			(int) (req->numSector <<
   1892    1.9     oster 			    queue->raidPtr->logBytesPerSector),
   1893    1.9     oster 			(int) queue->raidPtr->logBytesPerSector));
   1894    1.1     oster 		if ((raidbp->rf_buf.b_flags & B_READ) == 0) {
   1895    1.1     oster 			raidbp->rf_buf.b_vp->v_numoutput++;
   1896    1.1     oster 		}
   1897    1.9     oster 		VOP_STRATEGY(&raidbp->rf_buf);
   1898    1.1     oster 
   1899    1.1     oster 		break;
   1900    1.9     oster 
   1901    1.1     oster 	default:
   1902    1.1     oster 		panic("bad req->type in rf_DispatchKernelIO");
   1903    1.1     oster 	}
   1904    1.1     oster 	db1_printf(("Exiting from DispatchKernelIO\n"));
   1905  1.134     oster 
   1906    1.9     oster 	return (0);
   1907    1.1     oster }
   1908    1.9     oster /* this is the callback function associated with a I/O invoked from
   1909    1.1     oster    kernel code.
   1910    1.1     oster  */
   1911    1.9     oster static void
   1912    1.9     oster KernelWakeupFunc(vbp)
   1913    1.9     oster 	struct buf *vbp;
   1914    1.9     oster {
   1915    1.9     oster 	RF_DiskQueueData_t *req = NULL;
   1916    1.9     oster 	RF_DiskQueue_t *queue;
   1917    1.9     oster 	struct raidbuf *raidbp = (struct raidbuf *) vbp;
   1918    1.9     oster 	struct buf *bp;
   1919   1.74  augustss 	int s;
   1920    1.9     oster 
   1921   1.36     oster 	s = splbio();
   1922    1.9     oster 	db1_printf(("recovering the request queue:\n"));
   1923    1.9     oster 	req = raidbp->req;
   1924    1.1     oster 
   1925    1.9     oster 	bp = raidbp->rf_obp;
   1926    1.1     oster 
   1927    1.9     oster 	queue = (RF_DiskQueue_t *) req->queue;
   1928    1.1     oster 
   1929    1.9     oster 	if (raidbp->rf_buf.b_flags & B_ERROR) {
   1930    1.9     oster 		bp->b_flags |= B_ERROR;
   1931    1.9     oster 		bp->b_error = raidbp->rf_buf.b_error ?
   1932    1.9     oster 		    raidbp->rf_buf.b_error : EIO;
   1933    1.9     oster 	}
   1934    1.1     oster 
   1935    1.9     oster 	/* XXX methinks this could be wrong... */
   1936    1.1     oster #if 1
   1937    1.9     oster 	bp->b_resid = raidbp->rf_buf.b_resid;
   1938    1.1     oster #endif
   1939    1.1     oster 
   1940    1.9     oster 	if (req->tracerec) {
   1941    1.9     oster 		RF_ETIMER_STOP(req->tracerec->timer);
   1942    1.9     oster 		RF_ETIMER_EVAL(req->tracerec->timer);
   1943    1.9     oster 		RF_LOCK_MUTEX(rf_tracing_mutex);
   1944    1.9     oster 		req->tracerec->diskwait_us += RF_ETIMER_VAL_US(req->tracerec->timer);
   1945    1.9     oster 		req->tracerec->phys_io_us += RF_ETIMER_VAL_US(req->tracerec->timer);
   1946    1.9     oster 		req->tracerec->num_phys_ios++;
   1947    1.9     oster 		RF_UNLOCK_MUTEX(rf_tracing_mutex);
   1948    1.9     oster 	}
   1949    1.9     oster 	bp->b_bcount = raidbp->rf_buf.b_bcount;	/* XXXX ?? */
   1950    1.1     oster 
   1951    1.9     oster 	/* XXX Ok, let's get aggressive... If B_ERROR is set, let's go
   1952    1.9     oster 	 * ballistic, and mark the component as hosed... */
   1953   1.36     oster 
   1954    1.9     oster 	if (bp->b_flags & B_ERROR) {
   1955    1.9     oster 		/* Mark the disk as dead */
   1956    1.9     oster 		/* but only mark it once... */
   1957    1.9     oster 		if (queue->raidPtr->Disks[queue->row][queue->col].status ==
   1958    1.9     oster 		    rf_ds_optimal) {
   1959    1.9     oster 			printf("raid%d: IO Error.  Marking %s as failed.\n",
   1960  1.136     oster 			       queue->raidPtr->raidid,
   1961  1.136     oster 			       queue->raidPtr->Disks[queue->row][queue->col].devname);
   1962    1.9     oster 			queue->raidPtr->Disks[queue->row][queue->col].status =
   1963    1.9     oster 			    rf_ds_failed;
   1964    1.9     oster 			queue->raidPtr->status[queue->row] = rf_rs_degraded;
   1965    1.9     oster 			queue->raidPtr->numFailures++;
   1966   1.56     oster 			queue->raidPtr->numNewFailures++;
   1967    1.9     oster 		} else {	/* Disk is already dead... */
   1968    1.9     oster 			/* printf("Disk already marked as dead!\n"); */
   1969    1.9     oster 		}
   1970    1.4     oster 
   1971    1.9     oster 	}
   1972    1.4     oster 
   1973  1.136     oster 	pool_put(&raidframe_cbufpool, raidbp);
   1974    1.9     oster 
   1975  1.143     oster 	/* Fill in the error value */
   1976  1.143     oster 
   1977  1.143     oster 	req->error = (bp->b_flags & B_ERROR) ? bp->b_error : 0;
   1978  1.143     oster 
   1979  1.143     oster 	simple_lock(&queue->raidPtr->iodone_lock);
   1980  1.143     oster 
   1981  1.143     oster 	/* Drop this one on the "finished" queue... */
   1982  1.143     oster 	TAILQ_INSERT_TAIL(&(queue->raidPtr->iodone), req, iodone_entries);
   1983  1.143     oster 
   1984  1.143     oster 	/* Let the raidio thread know there is work to be done. */
   1985  1.143     oster 	wakeup(&(queue->raidPtr->iodone));
   1986  1.143     oster 
   1987  1.143     oster 	simple_unlock(&queue->raidPtr->iodone_lock);
   1988    1.1     oster 
   1989   1.36     oster 	splx(s);
   1990    1.1     oster }
   1991    1.1     oster 
   1992    1.1     oster 
   1993    1.1     oster 
   1994    1.1     oster /*
   1995    1.1     oster  * initialize a buf structure for doing an I/O in the kernel.
   1996    1.1     oster  */
   1997    1.9     oster static void
   1998   1.70     oster InitBP(bp, b_vp, rw_flag, dev, startSect, numSect, buf, cbFunc, cbArg,
   1999   1.70     oster        logBytesPerSector, b_proc)
   2000   1.70     oster 	struct buf *bp;
   2001   1.70     oster 	struct vnode *b_vp;
   2002   1.70     oster 	unsigned rw_flag;
   2003   1.70     oster 	dev_t dev;
   2004   1.70     oster 	RF_SectorNum_t startSect;
   2005   1.70     oster 	RF_SectorCount_t numSect;
   2006   1.70     oster 	caddr_t buf;
   2007   1.70     oster 	void (*cbFunc) (struct buf *);
   2008   1.70     oster 	void *cbArg;
   2009   1.70     oster 	int logBytesPerSector;
   2010   1.70     oster 	struct proc *b_proc;
   2011    1.9     oster {
   2012    1.9     oster 	/* bp->b_flags       = B_PHYS | rw_flag; */
   2013    1.9     oster 	bp->b_flags = B_CALL | rw_flag;	/* XXX need B_PHYS here too??? */
   2014    1.9     oster 	bp->b_bcount = numSect << logBytesPerSector;
   2015    1.9     oster 	bp->b_bufsize = bp->b_bcount;
   2016    1.9     oster 	bp->b_error = 0;
   2017    1.9     oster 	bp->b_dev = dev;
   2018   1.79   thorpej 	bp->b_data = buf;
   2019    1.9     oster 	bp->b_blkno = startSect;
   2020    1.9     oster 	bp->b_resid = bp->b_bcount;	/* XXX is this right!??!?!! */
   2021    1.1     oster 	if (bp->b_bcount == 0) {
   2022  1.141    provos 		panic("bp->b_bcount is zero in InitBP!!");
   2023    1.1     oster 	}
   2024    1.9     oster 	bp->b_proc = b_proc;
   2025    1.9     oster 	bp->b_iodone = cbFunc;
   2026    1.9     oster 	bp->b_vp = b_vp;
   2027    1.9     oster 
   2028    1.1     oster }
   2029    1.1     oster 
   2030    1.1     oster static void
   2031    1.1     oster raidgetdefaultlabel(raidPtr, rs, lp)
   2032    1.1     oster 	RF_Raid_t *raidPtr;
   2033    1.1     oster 	struct raid_softc *rs;
   2034    1.1     oster 	struct disklabel *lp;
   2035    1.1     oster {
   2036  1.108   thorpej 	memset(lp, 0, sizeof(*lp));
   2037    1.1     oster 
   2038    1.1     oster 	/* fabricate a label... */
   2039    1.1     oster 	lp->d_secperunit = raidPtr->totalSectors;
   2040    1.1     oster 	lp->d_secsize = raidPtr->bytesPerSector;
   2041   1.45     oster 	lp->d_nsectors = raidPtr->Layout.dataSectorsPerStripe;
   2042  1.105     oster 	lp->d_ntracks = 4 * raidPtr->numCol;
   2043   1.45     oster 	lp->d_ncylinders = raidPtr->totalSectors /
   2044   1.45     oster 		(lp->d_nsectors * lp->d_ntracks);
   2045    1.1     oster 	lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
   2046    1.1     oster 
   2047    1.1     oster 	strncpy(lp->d_typename, "raid", sizeof(lp->d_typename));
   2048    1.9     oster 	lp->d_type = DTYPE_RAID;
   2049    1.1     oster 	strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname));
   2050    1.1     oster 	lp->d_rpm = 3600;
   2051    1.1     oster 	lp->d_interleave = 1;
   2052    1.1     oster 	lp->d_flags = 0;
   2053    1.1     oster 
   2054    1.1     oster 	lp->d_partitions[RAW_PART].p_offset = 0;
   2055    1.1     oster 	lp->d_partitions[RAW_PART].p_size = raidPtr->totalSectors;
   2056    1.1     oster 	lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED;
   2057    1.1     oster 	lp->d_npartitions = RAW_PART + 1;
   2058    1.1     oster 
   2059    1.1     oster 	lp->d_magic = DISKMAGIC;
   2060    1.1     oster 	lp->d_magic2 = DISKMAGIC;
   2061    1.1     oster 	lp->d_checksum = dkcksum(rs->sc_dkdev.dk_label);
   2062    1.1     oster 
   2063    1.1     oster }
   2064    1.1     oster /*
   2065    1.1     oster  * Read the disklabel from the raid device.  If one is not present, fake one
   2066    1.1     oster  * up.
   2067    1.1     oster  */
   2068    1.1     oster static void
   2069    1.1     oster raidgetdisklabel(dev)
   2070    1.9     oster 	dev_t   dev;
   2071    1.1     oster {
   2072    1.9     oster 	int     unit = raidunit(dev);
   2073    1.1     oster 	struct raid_softc *rs = &raid_softc[unit];
   2074    1.9     oster 	char   *errstring;
   2075    1.1     oster 	struct disklabel *lp = rs->sc_dkdev.dk_label;
   2076    1.1     oster 	struct cpu_disklabel *clp = rs->sc_dkdev.dk_cpulabel;
   2077    1.1     oster 	RF_Raid_t *raidPtr;
   2078    1.1     oster 
   2079    1.1     oster 	db1_printf(("Getting the disklabel...\n"));
   2080    1.1     oster 
   2081  1.108   thorpej 	memset(clp, 0, sizeof(*clp));
   2082    1.1     oster 
   2083    1.1     oster 	raidPtr = raidPtrs[unit];
   2084    1.1     oster 
   2085    1.1     oster 	raidgetdefaultlabel(raidPtr, rs, lp);
   2086    1.1     oster 
   2087    1.1     oster 	/*
   2088    1.1     oster 	 * Call the generic disklabel extraction routine.
   2089    1.1     oster 	 */
   2090    1.1     oster 	errstring = readdisklabel(RAIDLABELDEV(dev), raidstrategy,
   2091    1.1     oster 	    rs->sc_dkdev.dk_label, rs->sc_dkdev.dk_cpulabel);
   2092    1.9     oster 	if (errstring)
   2093    1.1     oster 		raidmakedisklabel(rs);
   2094    1.1     oster 	else {
   2095    1.9     oster 		int     i;
   2096    1.1     oster 		struct partition *pp;
   2097    1.1     oster 
   2098    1.1     oster 		/*
   2099    1.1     oster 		 * Sanity check whether the found disklabel is valid.
   2100    1.1     oster 		 *
   2101    1.1     oster 		 * This is necessary since total size of the raid device
   2102    1.1     oster 		 * may vary when an interleave is changed even though exactly
   2103    1.1     oster 		 * same componets are used, and old disklabel may used
   2104    1.1     oster 		 * if that is found.
   2105    1.1     oster 		 */
   2106    1.1     oster 		if (lp->d_secperunit != rs->sc_size)
   2107  1.123     oster 			printf("raid%d: WARNING: %s: "
   2108    1.1     oster 			    "total sector size in disklabel (%d) != "
   2109  1.123     oster 			    "the size of raid (%ld)\n", unit, rs->sc_xname,
   2110   1.18     oster 			    lp->d_secperunit, (long) rs->sc_size);
   2111    1.1     oster 		for (i = 0; i < lp->d_npartitions; i++) {
   2112    1.1     oster 			pp = &lp->d_partitions[i];
   2113    1.1     oster 			if (pp->p_offset + pp->p_size > rs->sc_size)
   2114  1.123     oster 				printf("raid%d: WARNING: %s: end of partition `%c' "
   2115  1.123     oster 				       "exceeds the size of raid (%ld)\n",
   2116  1.123     oster 				       unit, rs->sc_xname, 'a' + i, (long) rs->sc_size);
   2117    1.1     oster 		}
   2118    1.1     oster 	}
   2119    1.1     oster 
   2120    1.1     oster }
   2121    1.1     oster /*
   2122    1.1     oster  * Take care of things one might want to take care of in the event
   2123    1.1     oster  * that a disklabel isn't present.
   2124    1.1     oster  */
   2125    1.1     oster static void
   2126    1.1     oster raidmakedisklabel(rs)
   2127    1.1     oster 	struct raid_softc *rs;
   2128    1.1     oster {
   2129    1.1     oster 	struct disklabel *lp = rs->sc_dkdev.dk_label;
   2130    1.1     oster 	db1_printf(("Making a label..\n"));
   2131    1.1     oster 
   2132    1.1     oster 	/*
   2133    1.1     oster 	 * For historical reasons, if there's no disklabel present
   2134    1.1     oster 	 * the raw partition must be marked FS_BSDFFS.
   2135    1.1     oster 	 */
   2136    1.1     oster 
   2137    1.1     oster 	lp->d_partitions[RAW_PART].p_fstype = FS_BSDFFS;
   2138    1.1     oster 
   2139    1.1     oster 	strncpy(lp->d_packname, "default label", sizeof(lp->d_packname));
   2140    1.1     oster 
   2141    1.1     oster 	lp->d_checksum = dkcksum(lp);
   2142    1.1     oster }
   2143    1.1     oster /*
   2144    1.1     oster  * Lookup the provided name in the filesystem.  If the file exists,
   2145    1.1     oster  * is a valid block device, and isn't being used by anyone else,
   2146    1.1     oster  * set *vpp to the file's vnode.
   2147    1.9     oster  * You'll find the original of this in ccd.c
   2148    1.1     oster  */
   2149    1.1     oster int
   2150    1.1     oster raidlookup(path, p, vpp)
   2151    1.9     oster 	char   *path;
   2152    1.1     oster 	struct proc *p;
   2153    1.1     oster 	struct vnode **vpp;	/* result */
   2154    1.1     oster {
   2155    1.1     oster 	struct nameidata nd;
   2156    1.1     oster 	struct vnode *vp;
   2157    1.1     oster 	struct vattr va;
   2158    1.9     oster 	int     error;
   2159    1.1     oster 
   2160    1.1     oster 	NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, path, p);
   2161    1.9     oster 	if ((error = vn_open(&nd, FREAD | FWRITE, 0)) != 0) {
   2162    1.1     oster 		return (error);
   2163    1.1     oster 	}
   2164    1.1     oster 	vp = nd.ni_vp;
   2165    1.1     oster 	if (vp->v_usecount > 1) {
   2166    1.1     oster 		VOP_UNLOCK(vp, 0);
   2167    1.9     oster 		(void) vn_close(vp, FREAD | FWRITE, p->p_ucred, p);
   2168    1.1     oster 		return (EBUSY);
   2169    1.1     oster 	}
   2170    1.1     oster 	if ((error = VOP_GETATTR(vp, &va, p->p_ucred, p)) != 0) {
   2171    1.1     oster 		VOP_UNLOCK(vp, 0);
   2172    1.9     oster 		(void) vn_close(vp, FREAD | FWRITE, p->p_ucred, p);
   2173    1.1     oster 		return (error);
   2174    1.1     oster 	}
   2175    1.1     oster 	/* XXX: eventually we should handle VREG, too. */
   2176    1.1     oster 	if (va.va_type != VBLK) {
   2177    1.1     oster 		VOP_UNLOCK(vp, 0);
   2178    1.9     oster 		(void) vn_close(vp, FREAD | FWRITE, p->p_ucred, p);
   2179    1.1     oster 		return (ENOTBLK);
   2180    1.1     oster 	}
   2181    1.1     oster 	VOP_UNLOCK(vp, 0);
   2182    1.1     oster 	*vpp = vp;
   2183    1.1     oster 	return (0);
   2184    1.1     oster }
   2185    1.1     oster /*
   2186    1.1     oster  * Wait interruptibly for an exclusive lock.
   2187    1.1     oster  *
   2188    1.1     oster  * XXX
   2189    1.1     oster  * Several drivers do this; it should be abstracted and made MP-safe.
   2190    1.1     oster  * (Hmm... where have we seen this warning before :->  GO )
   2191    1.1     oster  */
   2192    1.1     oster static int
   2193    1.1     oster raidlock(rs)
   2194    1.1     oster 	struct raid_softc *rs;
   2195    1.1     oster {
   2196    1.9     oster 	int     error;
   2197    1.1     oster 
   2198    1.1     oster 	while ((rs->sc_flags & RAIDF_LOCKED) != 0) {
   2199    1.1     oster 		rs->sc_flags |= RAIDF_WANTED;
   2200    1.9     oster 		if ((error =
   2201    1.9     oster 			tsleep(rs, PRIBIO | PCATCH, "raidlck", 0)) != 0)
   2202    1.1     oster 			return (error);
   2203    1.1     oster 	}
   2204    1.1     oster 	rs->sc_flags |= RAIDF_LOCKED;
   2205    1.1     oster 	return (0);
   2206    1.1     oster }
   2207    1.1     oster /*
   2208    1.1     oster  * Unlock and wake up any waiters.
   2209    1.1     oster  */
   2210    1.1     oster static void
   2211    1.1     oster raidunlock(rs)
   2212    1.1     oster 	struct raid_softc *rs;
   2213    1.1     oster {
   2214    1.1     oster 
   2215    1.1     oster 	rs->sc_flags &= ~RAIDF_LOCKED;
   2216    1.1     oster 	if ((rs->sc_flags & RAIDF_WANTED) != 0) {
   2217    1.1     oster 		rs->sc_flags &= ~RAIDF_WANTED;
   2218    1.1     oster 		wakeup(rs);
   2219    1.1     oster 	}
   2220   1.11     oster }
   2221   1.11     oster 
   2222   1.11     oster 
   2223   1.11     oster #define RF_COMPONENT_INFO_OFFSET  16384 /* bytes */
   2224   1.11     oster #define RF_COMPONENT_INFO_SIZE     1024 /* bytes */
   2225   1.11     oster 
   2226   1.11     oster int
   2227   1.12     oster raidmarkclean(dev_t dev, struct vnode *b_vp, int mod_counter)
   2228   1.12     oster {
   2229   1.48     oster 	RF_ComponentLabel_t clabel;
   2230   1.48     oster 	raidread_component_label(dev, b_vp, &clabel);
   2231   1.48     oster 	clabel.mod_counter = mod_counter;
   2232   1.48     oster 	clabel.clean = RF_RAID_CLEAN;
   2233   1.48     oster 	raidwrite_component_label(dev, b_vp, &clabel);
   2234   1.12     oster 	return(0);
   2235   1.12     oster }
   2236   1.12     oster 
   2237   1.12     oster 
   2238   1.12     oster int
   2239   1.12     oster raidmarkdirty(dev_t dev, struct vnode *b_vp, int mod_counter)
   2240   1.11     oster {
   2241   1.48     oster 	RF_ComponentLabel_t clabel;
   2242   1.48     oster 	raidread_component_label(dev, b_vp, &clabel);
   2243   1.48     oster 	clabel.mod_counter = mod_counter;
   2244   1.48     oster 	clabel.clean = RF_RAID_DIRTY;
   2245   1.48     oster 	raidwrite_component_label(dev, b_vp, &clabel);
   2246   1.11     oster 	return(0);
   2247   1.11     oster }
   2248   1.11     oster 
   2249   1.11     oster /* ARGSUSED */
   2250   1.11     oster int
   2251   1.48     oster raidread_component_label(dev, b_vp, clabel)
   2252   1.11     oster 	dev_t dev;
   2253   1.11     oster 	struct vnode *b_vp;
   2254   1.48     oster 	RF_ComponentLabel_t *clabel;
   2255   1.11     oster {
   2256   1.11     oster 	struct buf *bp;
   2257  1.130   gehenna 	const struct bdevsw *bdev;
   2258   1.11     oster 	int error;
   2259   1.11     oster 
   2260   1.11     oster 	/* XXX should probably ensure that we don't try to do this if
   2261   1.11     oster 	   someone has changed rf_protected_sectors. */
   2262   1.11     oster 
   2263   1.98     oster 	if (b_vp == NULL) {
   2264   1.98     oster 		/* For whatever reason, this component is not valid.
   2265   1.98     oster 		   Don't try to read a component label from it. */
   2266   1.98     oster 		return(EINVAL);
   2267   1.98     oster 	}
   2268   1.98     oster 
   2269   1.11     oster 	/* get a block of the appropriate size... */
   2270   1.11     oster 	bp = geteblk((int)RF_COMPONENT_INFO_SIZE);
   2271   1.11     oster 	bp->b_dev = dev;
   2272   1.11     oster 
   2273   1.11     oster 	/* get our ducks in a row for the read */
   2274   1.11     oster 	bp->b_blkno = RF_COMPONENT_INFO_OFFSET / DEV_BSIZE;
   2275   1.11     oster 	bp->b_bcount = RF_COMPONENT_INFO_SIZE;
   2276  1.100       chs 	bp->b_flags |= B_READ;
   2277   1.11     oster  	bp->b_resid = RF_COMPONENT_INFO_SIZE / DEV_BSIZE;
   2278   1.11     oster 
   2279  1.130   gehenna 	bdev = bdevsw_lookup(bp->b_dev);
   2280  1.130   gehenna 	if (bdev == NULL)
   2281  1.130   gehenna 		return (ENXIO);
   2282  1.130   gehenna 	(*bdev->d_strategy)(bp);
   2283   1.11     oster 
   2284   1.11     oster 	error = biowait(bp);
   2285   1.11     oster 
   2286   1.11     oster 	if (!error) {
   2287   1.79   thorpej 		memcpy(clabel, bp->b_data,
   2288   1.11     oster 		       sizeof(RF_ComponentLabel_t));
   2289  1.147     oster         }
   2290   1.11     oster 
   2291   1.11     oster 	brelse(bp);
   2292   1.11     oster 	return(error);
   2293   1.11     oster }
   2294   1.11     oster /* ARGSUSED */
   2295   1.11     oster int
   2296   1.48     oster raidwrite_component_label(dev, b_vp, clabel)
   2297   1.11     oster 	dev_t dev;
   2298   1.11     oster 	struct vnode *b_vp;
   2299   1.48     oster 	RF_ComponentLabel_t *clabel;
   2300   1.11     oster {
   2301   1.11     oster 	struct buf *bp;
   2302  1.130   gehenna 	const struct bdevsw *bdev;
   2303   1.11     oster 	int error;
   2304   1.11     oster 
   2305   1.11     oster 	/* get a block of the appropriate size... */
   2306   1.11     oster 	bp = geteblk((int)RF_COMPONENT_INFO_SIZE);
   2307   1.11     oster 	bp->b_dev = dev;
   2308   1.11     oster 
   2309   1.11     oster 	/* get our ducks in a row for the write */
   2310   1.11     oster 	bp->b_blkno = RF_COMPONENT_INFO_OFFSET / DEV_BSIZE;
   2311   1.11     oster 	bp->b_bcount = RF_COMPONENT_INFO_SIZE;
   2312  1.100       chs 	bp->b_flags |= B_WRITE;
   2313   1.11     oster  	bp->b_resid = RF_COMPONENT_INFO_SIZE / DEV_BSIZE;
   2314   1.11     oster 
   2315   1.79   thorpej 	memset(bp->b_data, 0, RF_COMPONENT_INFO_SIZE );
   2316   1.11     oster 
   2317   1.79   thorpej 	memcpy(bp->b_data, clabel, sizeof(RF_ComponentLabel_t));
   2318   1.11     oster 
   2319  1.130   gehenna 	bdev = bdevsw_lookup(bp->b_dev);
   2320  1.130   gehenna 	if (bdev == NULL)
   2321  1.130   gehenna 		return (ENXIO);
   2322  1.130   gehenna 	(*bdev->d_strategy)(bp);
   2323   1.11     oster 	error = biowait(bp);
   2324   1.11     oster 	brelse(bp);
   2325   1.11     oster 	if (error) {
   2326   1.48     oster #if 1
   2327   1.11     oster 		printf("Failed to write RAID component info!\n");
   2328   1.48     oster #endif
   2329   1.11     oster 	}
   2330   1.11     oster 
   2331   1.11     oster 	return(error);
   2332    1.1     oster }
   2333   1.12     oster 
   2334   1.12     oster void
   2335   1.70     oster rf_markalldirty(raidPtr)
   2336   1.12     oster 	RF_Raid_t *raidPtr;
   2337   1.12     oster {
   2338   1.48     oster 	RF_ComponentLabel_t clabel;
   2339  1.146     oster 	int sparecol;
   2340   1.12     oster 	int r,c;
   2341  1.146     oster 	int i,j;
   2342  1.146     oster 	int srow, scol;
   2343   1.12     oster 
   2344   1.12     oster 	raidPtr->mod_counter++;
   2345   1.12     oster 	for (r = 0; r < raidPtr->numRow; r++) {
   2346   1.12     oster 		for (c = 0; c < raidPtr->numCol; c++) {
   2347   1.98     oster 			/* we don't want to touch (at all) a disk that has
   2348   1.98     oster 			   failed */
   2349   1.98     oster 			if (!RF_DEAD_DISK(raidPtr->Disks[r][c].status)) {
   2350   1.12     oster 				raidread_component_label(
   2351   1.12     oster 					raidPtr->Disks[r][c].dev,
   2352   1.12     oster 					raidPtr->raid_cinfo[r][c].ci_vp,
   2353   1.48     oster 					&clabel);
   2354   1.48     oster 				if (clabel.status == rf_ds_spared) {
   2355   1.12     oster 					/* XXX do something special...
   2356   1.12     oster 					 but whatever you do, don't
   2357   1.12     oster 					 try to access it!! */
   2358   1.12     oster 				} else {
   2359  1.146     oster 					raidmarkdirty(
   2360  1.146     oster 					      raidPtr->Disks[r][c].dev,
   2361  1.146     oster 					      raidPtr->raid_cinfo[r][c].ci_vp,
   2362  1.146     oster 					      raidPtr->mod_counter);
   2363   1.12     oster 				}
   2364   1.12     oster 			}
   2365   1.12     oster 		}
   2366   1.12     oster 	}
   2367  1.146     oster 
   2368   1.12     oster 	for( c = 0; c < raidPtr->numSpare ; c++) {
   2369   1.12     oster 		sparecol = raidPtr->numCol + c;
   2370  1.146     oster 		if (raidPtr->Disks[0][sparecol].status == rf_ds_used_spare) {
   2371   1.12     oster 			/*
   2372   1.12     oster 
   2373   1.12     oster 			   we claim this disk is "optimal" if it's
   2374   1.12     oster 			   rf_ds_used_spare, as that means it should be
   2375   1.12     oster 			   directly substitutable for the disk it replaced.
   2376   1.12     oster 			   We note that too...
   2377   1.12     oster 
   2378   1.12     oster 			 */
   2379   1.12     oster 
   2380   1.12     oster 			for(i=0;i<raidPtr->numRow;i++) {
   2381   1.12     oster 				for(j=0;j<raidPtr->numCol;j++) {
   2382   1.12     oster 					if ((raidPtr->Disks[i][j].spareRow ==
   2383  1.146     oster 					     0) &&
   2384   1.12     oster 					    (raidPtr->Disks[i][j].spareCol ==
   2385   1.12     oster 					     sparecol)) {
   2386  1.146     oster 						srow = i;
   2387  1.146     oster 						scol = j;
   2388   1.12     oster 						break;
   2389   1.12     oster 					}
   2390   1.12     oster 				}
   2391   1.12     oster 			}
   2392  1.146     oster 
   2393   1.12     oster 			raidread_component_label(
   2394  1.146     oster 				 raidPtr->Disks[0][sparecol].dev,
   2395  1.146     oster 				 raidPtr->raid_cinfo[0][sparecol].ci_vp,
   2396  1.146     oster 				 &clabel);
   2397   1.12     oster 			/* make sure status is noted */
   2398  1.146     oster 
   2399  1.146     oster 			raid_init_component_label(raidPtr, &clabel);
   2400  1.146     oster 
   2401   1.48     oster 			clabel.row = srow;
   2402   1.48     oster 			clabel.column = scol;
   2403  1.146     oster 			/* Note: we *don't* change status from rf_ds_used_spare
   2404  1.146     oster 			   to rf_ds_optimal */
   2405  1.146     oster 			/* clabel.status = rf_ds_optimal; */
   2406  1.146     oster 
   2407  1.146     oster 			raidmarkdirty(raidPtr->Disks[0][sparecol].dev,
   2408  1.146     oster 				      raidPtr->raid_cinfo[0][sparecol].ci_vp,
   2409  1.146     oster 				      raidPtr->mod_counter);
   2410   1.12     oster 		}
   2411   1.12     oster 	}
   2412   1.12     oster }
   2413   1.12     oster 
   2414   1.13     oster 
   2415   1.13     oster void
   2416   1.91     oster rf_update_component_labels(raidPtr, final)
   2417   1.13     oster 	RF_Raid_t *raidPtr;
   2418   1.91     oster 	int final;
   2419   1.13     oster {
   2420   1.48     oster 	RF_ComponentLabel_t clabel;
   2421   1.13     oster 	int sparecol;
   2422   1.13     oster 	int r,c;
   2423   1.13     oster 	int i,j;
   2424   1.13     oster 	int srow, scol;
   2425   1.13     oster 
   2426   1.13     oster 	srow = -1;
   2427   1.13     oster 	scol = -1;
   2428   1.13     oster 
   2429   1.13     oster 	/* XXX should do extra checks to make sure things really are clean,
   2430   1.13     oster 	   rather than blindly setting the clean bit... */
   2431   1.13     oster 
   2432   1.13     oster 	raidPtr->mod_counter++;
   2433   1.13     oster 
   2434   1.13     oster 	for (r = 0; r < raidPtr->numRow; r++) {
   2435   1.13     oster 		for (c = 0; c < raidPtr->numCol; c++) {
   2436   1.13     oster 			if (raidPtr->Disks[r][c].status == rf_ds_optimal) {
   2437   1.13     oster 				raidread_component_label(
   2438   1.13     oster 					raidPtr->Disks[r][c].dev,
   2439   1.13     oster 					raidPtr->raid_cinfo[r][c].ci_vp,
   2440   1.48     oster 					&clabel);
   2441   1.13     oster 				/* make sure status is noted */
   2442   1.48     oster 				clabel.status = rf_ds_optimal;
   2443   1.57     oster 				/* bump the counter */
   2444   1.60     oster 				clabel.mod_counter = raidPtr->mod_counter;
   2445   1.57     oster 
   2446   1.13     oster 				raidwrite_component_label(
   2447   1.13     oster 					raidPtr->Disks[r][c].dev,
   2448   1.13     oster 					raidPtr->raid_cinfo[r][c].ci_vp,
   2449   1.48     oster 					&clabel);
   2450   1.91     oster 				if (final == RF_FINAL_COMPONENT_UPDATE) {
   2451   1.91     oster 					if (raidPtr->parity_good == RF_RAID_CLEAN) {
   2452   1.91     oster 						raidmarkclean(
   2453   1.91     oster 							      raidPtr->Disks[r][c].dev,
   2454   1.91     oster 							      raidPtr->raid_cinfo[r][c].ci_vp,
   2455   1.91     oster 							      raidPtr->mod_counter);
   2456   1.91     oster 					}
   2457   1.91     oster 				}
   2458   1.13     oster 			}
   2459   1.13     oster 			/* else we don't touch it.. */
   2460   1.63     oster 		}
   2461   1.63     oster 	}
   2462   1.63     oster 
   2463   1.63     oster 	for( c = 0; c < raidPtr->numSpare ; c++) {
   2464   1.63     oster 		sparecol = raidPtr->numCol + c;
   2465  1.110     oster 		/* Need to ensure that the reconstruct actually completed! */
   2466  1.111     oster 		if (raidPtr->Disks[0][sparecol].status == rf_ds_used_spare) {
   2467   1.63     oster 			/*
   2468   1.63     oster 
   2469   1.63     oster 			   we claim this disk is "optimal" if it's
   2470   1.63     oster 			   rf_ds_used_spare, as that means it should be
   2471   1.63     oster 			   directly substitutable for the disk it replaced.
   2472   1.63     oster 			   We note that too...
   2473   1.63     oster 
   2474   1.63     oster 			 */
   2475   1.63     oster 
   2476   1.63     oster 			for(i=0;i<raidPtr->numRow;i++) {
   2477   1.63     oster 				for(j=0;j<raidPtr->numCol;j++) {
   2478   1.63     oster 					if ((raidPtr->Disks[i][j].spareRow ==
   2479   1.63     oster 					     0) &&
   2480   1.63     oster 					    (raidPtr->Disks[i][j].spareCol ==
   2481   1.63     oster 					     sparecol)) {
   2482   1.63     oster 						srow = i;
   2483   1.63     oster 						scol = j;
   2484   1.63     oster 						break;
   2485   1.63     oster 					}
   2486   1.63     oster 				}
   2487   1.63     oster 			}
   2488   1.63     oster 
   2489   1.63     oster 			/* XXX shouldn't *really* need this... */
   2490   1.63     oster 			raidread_component_label(
   2491   1.63     oster 				      raidPtr->Disks[0][sparecol].dev,
   2492   1.63     oster 				      raidPtr->raid_cinfo[0][sparecol].ci_vp,
   2493   1.63     oster 				      &clabel);
   2494   1.63     oster 			/* make sure status is noted */
   2495   1.63     oster 
   2496   1.63     oster 			raid_init_component_label(raidPtr, &clabel);
   2497   1.63     oster 
   2498   1.63     oster 			clabel.mod_counter = raidPtr->mod_counter;
   2499   1.63     oster 			clabel.row = srow;
   2500   1.63     oster 			clabel.column = scol;
   2501   1.63     oster 			clabel.status = rf_ds_optimal;
   2502   1.63     oster 
   2503   1.63     oster 			raidwrite_component_label(
   2504   1.63     oster 				      raidPtr->Disks[0][sparecol].dev,
   2505   1.63     oster 				      raidPtr->raid_cinfo[0][sparecol].ci_vp,
   2506   1.63     oster 				      &clabel);
   2507   1.91     oster 			if (final == RF_FINAL_COMPONENT_UPDATE) {
   2508   1.13     oster 				if (raidPtr->parity_good == RF_RAID_CLEAN) {
   2509   1.91     oster 					raidmarkclean( raidPtr->Disks[0][sparecol].dev,
   2510   1.91     oster 						       raidPtr->raid_cinfo[0][sparecol].ci_vp,
   2511   1.91     oster 						       raidPtr->mod_counter);
   2512   1.13     oster 				}
   2513   1.13     oster 			}
   2514   1.13     oster 		}
   2515   1.13     oster 	}
   2516   1.68     oster }
   2517   1.68     oster 
   2518   1.68     oster void
   2519   1.70     oster rf_close_component(raidPtr, vp, auto_configured)
   2520   1.69     oster 	RF_Raid_t *raidPtr;
   2521   1.69     oster 	struct vnode *vp;
   2522   1.69     oster 	int auto_configured;
   2523   1.69     oster {
   2524   1.69     oster 	struct proc *p;
   2525   1.69     oster 
   2526   1.69     oster 	p = raidPtr->engine_thread;
   2527   1.69     oster 
   2528   1.69     oster 	if (vp != NULL) {
   2529   1.69     oster 		if (auto_configured == 1) {
   2530   1.96     oster 			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
   2531   1.97     oster 			VOP_CLOSE(vp, FREAD | FWRITE, NOCRED, 0);
   2532   1.69     oster 			vput(vp);
   2533   1.69     oster 
   2534   1.69     oster 		} else {
   2535   1.69     oster 			(void) vn_close(vp, FREAD | FWRITE, p->p_ucred, p);
   2536   1.69     oster 		}
   2537  1.147     oster 	}
   2538   1.69     oster }
   2539   1.69     oster 
   2540   1.69     oster 
   2541   1.69     oster void
   2542   1.70     oster rf_UnconfigureVnodes(raidPtr)
   2543   1.68     oster 	RF_Raid_t *raidPtr;
   2544   1.68     oster {
   2545   1.68     oster 	int r,c;
   2546   1.69     oster 	struct vnode *vp;
   2547   1.69     oster 	int acd;
   2548   1.68     oster 
   2549   1.68     oster 
   2550   1.68     oster 	/* We take this opportunity to close the vnodes like we should.. */
   2551   1.68     oster 
   2552   1.68     oster 	for (r = 0; r < raidPtr->numRow; r++) {
   2553   1.68     oster 		for (c = 0; c < raidPtr->numCol; c++) {
   2554   1.69     oster 			vp = raidPtr->raid_cinfo[r][c].ci_vp;
   2555   1.69     oster 			acd = raidPtr->Disks[r][c].auto_configured;
   2556   1.69     oster 			rf_close_component(raidPtr, vp, acd);
   2557   1.69     oster 			raidPtr->raid_cinfo[r][c].ci_vp = NULL;
   2558   1.69     oster 			raidPtr->Disks[r][c].auto_configured = 0;
   2559   1.68     oster 		}
   2560   1.68     oster 	}
   2561   1.68     oster 	for (r = 0; r < raidPtr->numSpare; r++) {
   2562   1.69     oster 		vp = raidPtr->raid_cinfo[0][raidPtr->numCol + r].ci_vp;
   2563   1.69     oster 		acd = raidPtr->Disks[0][raidPtr->numCol + r].auto_configured;
   2564   1.69     oster 		rf_close_component(raidPtr, vp, acd);
   2565   1.69     oster 		raidPtr->raid_cinfo[0][raidPtr->numCol + r].ci_vp = NULL;
   2566   1.69     oster 		raidPtr->Disks[0][raidPtr->numCol + r].auto_configured = 0;
   2567   1.68     oster 	}
   2568   1.37     oster }
   2569   1.63     oster 
   2570   1.37     oster 
   2571   1.37     oster void
   2572   1.37     oster rf_ReconThread(req)
   2573   1.37     oster 	struct rf_recon_req *req;
   2574   1.37     oster {
   2575   1.37     oster 	int     s;
   2576   1.37     oster 	RF_Raid_t *raidPtr;
   2577   1.37     oster 
   2578   1.37     oster 	s = splbio();
   2579   1.37     oster 	raidPtr = (RF_Raid_t *) req->raidPtr;
   2580   1.37     oster 	raidPtr->recon_in_progress = 1;
   2581   1.37     oster 
   2582   1.37     oster 	rf_FailDisk((RF_Raid_t *) req->raidPtr, req->row, req->col,
   2583   1.37     oster 		    ((req->flags & RF_FDFLAGS_RECON) ? 1 : 0));
   2584   1.37     oster 
   2585   1.37     oster 	/* XXX get rid of this! we don't need it at all.. */
   2586   1.37     oster 	RF_Free(req, sizeof(*req));
   2587   1.37     oster 
   2588   1.37     oster 	raidPtr->recon_in_progress = 0;
   2589   1.37     oster 	splx(s);
   2590   1.37     oster 
   2591   1.37     oster 	/* That's all... */
   2592   1.37     oster 	kthread_exit(0);        /* does not return */
   2593   1.37     oster }
   2594   1.37     oster 
   2595   1.37     oster void
   2596   1.37     oster rf_RewriteParityThread(raidPtr)
   2597   1.37     oster 	RF_Raid_t *raidPtr;
   2598   1.37     oster {
   2599   1.37     oster 	int retcode;
   2600   1.37     oster 	int s;
   2601   1.37     oster 
   2602   1.37     oster 	raidPtr->parity_rewrite_in_progress = 1;
   2603   1.37     oster 	s = splbio();
   2604   1.37     oster 	retcode = rf_RewriteParity(raidPtr);
   2605   1.37     oster 	splx(s);
   2606   1.37     oster 	if (retcode) {
   2607   1.37     oster 		printf("raid%d: Error re-writing parity!\n",raidPtr->raidid);
   2608   1.37     oster 	} else {
   2609   1.37     oster 		/* set the clean bit!  If we shutdown correctly,
   2610   1.37     oster 		   the clean bit on each component label will get
   2611   1.37     oster 		   set */
   2612   1.37     oster 		raidPtr->parity_good = RF_RAID_CLEAN;
   2613   1.37     oster 	}
   2614   1.37     oster 	raidPtr->parity_rewrite_in_progress = 0;
   2615   1.85     oster 
   2616   1.85     oster 	/* Anyone waiting for us to stop?  If so, inform them... */
   2617   1.85     oster 	if (raidPtr->waitShutdown) {
   2618   1.85     oster 		wakeup(&raidPtr->parity_rewrite_in_progress);
   2619   1.85     oster 	}
   2620   1.37     oster 
   2621   1.37     oster 	/* That's all... */
   2622   1.37     oster 	kthread_exit(0);        /* does not return */
   2623   1.37     oster }
   2624   1.37     oster 
   2625   1.37     oster 
   2626   1.37     oster void
   2627   1.37     oster rf_CopybackThread(raidPtr)
   2628   1.37     oster 	RF_Raid_t *raidPtr;
   2629   1.37     oster {
   2630   1.37     oster 	int s;
   2631   1.37     oster 
   2632   1.37     oster 	raidPtr->copyback_in_progress = 1;
   2633   1.37     oster 	s = splbio();
   2634   1.37     oster 	rf_CopybackReconstructedData(raidPtr);
   2635   1.37     oster 	splx(s);
   2636   1.37     oster 	raidPtr->copyback_in_progress = 0;
   2637   1.37     oster 
   2638   1.37     oster 	/* That's all... */
   2639   1.37     oster 	kthread_exit(0);        /* does not return */
   2640   1.37     oster }
   2641   1.37     oster 
   2642   1.37     oster 
   2643   1.37     oster void
   2644   1.37     oster rf_ReconstructInPlaceThread(req)
   2645   1.37     oster 	struct rf_recon_req *req;
   2646   1.37     oster {
   2647   1.37     oster 	int retcode;
   2648   1.37     oster 	int s;
   2649   1.37     oster 	RF_Raid_t *raidPtr;
   2650   1.37     oster 
   2651   1.37     oster 	s = splbio();
   2652   1.37     oster 	raidPtr = req->raidPtr;
   2653   1.37     oster 	raidPtr->recon_in_progress = 1;
   2654   1.37     oster 	retcode = rf_ReconstructInPlace(raidPtr, req->row, req->col);
   2655   1.37     oster 	RF_Free(req, sizeof(*req));
   2656   1.37     oster 	raidPtr->recon_in_progress = 0;
   2657   1.37     oster 	splx(s);
   2658   1.37     oster 
   2659   1.37     oster 	/* That's all... */
   2660   1.37     oster 	kthread_exit(0);        /* does not return */
   2661   1.48     oster }
   2662   1.48     oster 
   2663   1.48     oster RF_AutoConfig_t *
   2664   1.48     oster rf_find_raid_components()
   2665   1.48     oster {
   2666   1.48     oster 	struct vnode *vp;
   2667   1.48     oster 	struct disklabel label;
   2668   1.48     oster 	struct device *dv;
   2669   1.48     oster 	dev_t dev;
   2670  1.130   gehenna 	int bmajor;
   2671   1.48     oster 	int error;
   2672   1.48     oster 	int i;
   2673   1.48     oster 	int good_one;
   2674   1.48     oster 	RF_ComponentLabel_t *clabel;
   2675   1.48     oster 	RF_AutoConfig_t *ac_list;
   2676   1.48     oster 	RF_AutoConfig_t *ac;
   2677   1.48     oster 
   2678   1.48     oster 
   2679   1.48     oster 	/* initialize the AutoConfig list */
   2680   1.48     oster 	ac_list = NULL;
   2681   1.48     oster 
   2682   1.48     oster 	/* we begin by trolling through *all* the devices on the system */
   2683   1.48     oster 
   2684   1.48     oster 	for (dv = alldevs.tqh_first; dv != NULL;
   2685   1.48     oster 	     dv = dv->dv_list.tqe_next) {
   2686   1.48     oster 
   2687   1.48     oster 		/* we are only interested in disks... */
   2688   1.48     oster 		if (dv->dv_class != DV_DISK)
   2689   1.48     oster 			continue;
   2690   1.48     oster 
   2691   1.48     oster 		/* we don't care about floppies... */
   2692  1.140   thorpej 		if (!strcmp(dv->dv_cfdata->cf_name,"fd")) {
   2693  1.119       leo 			continue;
   2694  1.119       leo 		}
   2695  1.129     oster 
   2696  1.129     oster 		/* we don't care about CD's... */
   2697  1.140   thorpej 		if (!strcmp(dv->dv_cfdata->cf_name,"cd")) {
   2698  1.129     oster 			continue;
   2699  1.129     oster 		}
   2700  1.129     oster 
   2701  1.120       leo 		/* hdfd is the Atari/Hades floppy driver */
   2702  1.140   thorpej 		if (!strcmp(dv->dv_cfdata->cf_name,"hdfd")) {
   2703  1.121       leo 			continue;
   2704  1.121       leo 		}
   2705  1.121       leo 		/* fdisa is the Atari/Milan floppy driver */
   2706  1.140   thorpej 		if (!strcmp(dv->dv_cfdata->cf_name,"fdisa")) {
   2707   1.48     oster 			continue;
   2708   1.48     oster 		}
   2709   1.48     oster 
   2710   1.48     oster 		/* need to find the device_name_to_block_device_major stuff */
   2711  1.130   gehenna 		bmajor = devsw_name2blk(dv->dv_xname, NULL, 0);
   2712   1.48     oster 
   2713   1.48     oster 		/* get a vnode for the raw partition of this disk */
   2714   1.48     oster 
   2715  1.130   gehenna 		dev = MAKEDISKDEV(bmajor, dv->dv_unit, RAW_PART);
   2716   1.48     oster 		if (bdevvp(dev, &vp))
   2717   1.48     oster 			panic("RAID can't alloc vnode");
   2718   1.48     oster 
   2719   1.48     oster 		error = VOP_OPEN(vp, FREAD, NOCRED, 0);
   2720   1.48     oster 
   2721   1.48     oster 		if (error) {
   2722   1.48     oster 			/* "Who cares."  Continue looking
   2723   1.48     oster 			   for something that exists*/
   2724   1.48     oster 			vput(vp);
   2725   1.48     oster 			continue;
   2726   1.48     oster 		}
   2727   1.48     oster 
   2728   1.48     oster 		/* Ok, the disk exists.  Go get the disklabel. */
   2729   1.48     oster 		error = VOP_IOCTL(vp, DIOCGDINFO, (caddr_t)&label,
   2730   1.48     oster 				  FREAD, NOCRED, 0);
   2731   1.48     oster 		if (error) {
   2732   1.48     oster 			/*
   2733   1.48     oster 			 * XXX can't happen - open() would
   2734   1.48     oster 			 * have errored out (or faked up one)
   2735   1.48     oster 			 */
   2736   1.48     oster 			printf("can't get label for dev %s%c (%d)!?!?\n",
   2737   1.48     oster 			       dv->dv_xname, 'a' + RAW_PART, error);
   2738   1.48     oster 		}
   2739   1.48     oster 
   2740   1.48     oster 		/* don't need this any more.  We'll allocate it again
   2741   1.48     oster 		   a little later if we really do... */
   2742   1.96     oster 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
   2743   1.97     oster 		VOP_CLOSE(vp, FREAD | FWRITE, NOCRED, 0);
   2744   1.48     oster 		vput(vp);
   2745   1.48     oster 
   2746   1.48     oster 		for (i=0; i < label.d_npartitions; i++) {
   2747   1.48     oster 			/* We only support partitions marked as RAID */
   2748   1.48     oster 			if (label.d_partitions[i].p_fstype != FS_RAID)
   2749   1.48     oster 				continue;
   2750   1.48     oster 
   2751  1.130   gehenna 			dev = MAKEDISKDEV(bmajor, dv->dv_unit, i);
   2752   1.48     oster 			if (bdevvp(dev, &vp))
   2753   1.48     oster 				panic("RAID can't alloc vnode");
   2754   1.48     oster 
   2755   1.48     oster 			error = VOP_OPEN(vp, FREAD, NOCRED, 0);
   2756   1.48     oster 			if (error) {
   2757   1.48     oster 				/* Whatever... */
   2758   1.48     oster 				vput(vp);
   2759   1.48     oster 				continue;
   2760   1.48     oster 			}
   2761   1.48     oster 
   2762   1.48     oster 			good_one = 0;
   2763   1.48     oster 
   2764   1.48     oster 			clabel = (RF_ComponentLabel_t *)
   2765   1.48     oster 				malloc(sizeof(RF_ComponentLabel_t),
   2766   1.48     oster 				       M_RAIDFRAME, M_NOWAIT);
   2767   1.48     oster 			if (clabel == NULL) {
   2768   1.48     oster 				/* XXX CLEANUP HERE */
   2769   1.48     oster 				printf("RAID auto config: out of memory!\n");
   2770   1.48     oster 				return(NULL); /* XXX probably should panic? */
   2771   1.48     oster 			}
   2772   1.48     oster 
   2773   1.48     oster 			if (!raidread_component_label(dev, vp, clabel)) {
   2774   1.48     oster 				/* Got the label.  Does it look reasonable? */
   2775   1.49     oster 				if (rf_reasonable_label(clabel) &&
   2776   1.54     oster 				    (clabel->partitionSize <=
   2777   1.48     oster 				     label.d_partitions[i].p_size)) {
   2778   1.48     oster #if DEBUG
   2779   1.48     oster 					printf("Component on: %s%c: %d\n",
   2780   1.48     oster 					       dv->dv_xname, 'a'+i,
   2781   1.48     oster 					       label.d_partitions[i].p_size);
   2782   1.67     oster 					rf_print_component_label(clabel);
   2783   1.48     oster #endif
   2784   1.48     oster 					/* if it's reasonable, add it,
   2785   1.48     oster 					   else ignore it. */
   2786   1.48     oster 					ac = (RF_AutoConfig_t *)
   2787   1.48     oster 						malloc(sizeof(RF_AutoConfig_t),
   2788   1.48     oster 						       M_RAIDFRAME,
   2789   1.48     oster 						       M_NOWAIT);
   2790   1.48     oster 					if (ac == NULL) {
   2791   1.48     oster 						/* XXX should panic?? */
   2792   1.48     oster 						return(NULL);
   2793   1.48     oster 					}
   2794   1.48     oster 
   2795   1.48     oster 					sprintf(ac->devname, "%s%c",
   2796   1.48     oster 						dv->dv_xname, 'a'+i);
   2797   1.48     oster 					ac->dev = dev;
   2798   1.48     oster 					ac->vp = vp;
   2799   1.48     oster 					ac->clabel = clabel;
   2800   1.48     oster 					ac->next = ac_list;
   2801   1.48     oster 					ac_list = ac;
   2802   1.48     oster 					good_one = 1;
   2803   1.48     oster 				}
   2804   1.48     oster 			}
   2805   1.48     oster 			if (!good_one) {
   2806   1.48     oster 				/* cleanup */
   2807   1.48     oster 				free(clabel, M_RAIDFRAME);
   2808   1.96     oster 				vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
   2809   1.97     oster 				VOP_CLOSE(vp, FREAD | FWRITE, NOCRED, 0);
   2810   1.48     oster 				vput(vp);
   2811   1.48     oster 			}
   2812   1.48     oster 		}
   2813   1.48     oster 	}
   2814  1.106     oster 	return(ac_list);
   2815   1.48     oster }
   2816   1.48     oster 
   2817   1.48     oster static int
   2818   1.49     oster rf_reasonable_label(clabel)
   2819   1.48     oster 	RF_ComponentLabel_t *clabel;
   2820   1.48     oster {
   2821   1.48     oster 
   2822   1.48     oster 	if (((clabel->version==RF_COMPONENT_LABEL_VERSION_1) ||
   2823   1.48     oster 	     (clabel->version==RF_COMPONENT_LABEL_VERSION)) &&
   2824   1.48     oster 	    ((clabel->clean == RF_RAID_CLEAN) ||
   2825   1.48     oster 	     (clabel->clean == RF_RAID_DIRTY)) &&
   2826   1.48     oster 	    clabel->row >=0 &&
   2827   1.48     oster 	    clabel->column >= 0 &&
   2828   1.48     oster 	    clabel->num_rows > 0 &&
   2829   1.48     oster 	    clabel->num_columns > 0 &&
   2830   1.48     oster 	    clabel->row < clabel->num_rows &&
   2831   1.48     oster 	    clabel->column < clabel->num_columns &&
   2832   1.48     oster 	    clabel->blockSize > 0 &&
   2833   1.48     oster 	    clabel->numBlocks > 0) {
   2834   1.48     oster 		/* label looks reasonable enough... */
   2835   1.48     oster 		return(1);
   2836   1.48     oster 	}
   2837   1.48     oster 	return(0);
   2838   1.48     oster }
   2839   1.48     oster 
   2840   1.48     oster 
   2841  1.138     oster #if DEBUG
   2842   1.48     oster void
   2843   1.67     oster rf_print_component_label(clabel)
   2844   1.48     oster 	RF_ComponentLabel_t *clabel;
   2845   1.48     oster {
   2846   1.48     oster 	printf("   Row: %d Column: %d Num Rows: %d Num Columns: %d\n",
   2847   1.48     oster 	       clabel->row, clabel->column,
   2848   1.48     oster 	       clabel->num_rows, clabel->num_columns);
   2849   1.48     oster 	printf("   Version: %d Serial Number: %d Mod Counter: %d\n",
   2850   1.48     oster 	       clabel->version, clabel->serial_number,
   2851   1.48     oster 	       clabel->mod_counter);
   2852   1.48     oster 	printf("   Clean: %s Status: %d\n",
   2853   1.48     oster 	       clabel->clean ? "Yes" : "No", clabel->status );
   2854   1.48     oster 	printf("   sectPerSU: %d SUsPerPU: %d SUsPerRU: %d\n",
   2855   1.48     oster 	       clabel->sectPerSU, clabel->SUsPerPU, clabel->SUsPerRU);
   2856   1.48     oster 	printf("   RAID Level: %c  blocksize: %d numBlocks: %d\n",
   2857   1.48     oster 	       (char) clabel->parityConfig, clabel->blockSize,
   2858   1.48     oster 	       clabel->numBlocks);
   2859   1.48     oster 	printf("   Autoconfig: %s\n", clabel->autoconfigure ? "Yes" : "No" );
   2860   1.75     oster 	printf("   Contains root partition: %s\n",
   2861   1.75     oster 	       clabel->root_partition ? "Yes" : "No" );
   2862   1.48     oster 	printf("   Last configured as: raid%d\n", clabel->last_unit );
   2863   1.51     oster #if 0
   2864   1.51     oster 	   printf("   Config order: %d\n", clabel->config_order);
   2865   1.51     oster #endif
   2866   1.48     oster 
   2867   1.48     oster }
   2868  1.133     oster #endif
   2869   1.48     oster 
   2870   1.48     oster RF_ConfigSet_t *
   2871   1.48     oster rf_create_auto_sets(ac_list)
   2872   1.48     oster 	RF_AutoConfig_t *ac_list;
   2873   1.48     oster {
   2874   1.48     oster 	RF_AutoConfig_t *ac;
   2875   1.48     oster 	RF_ConfigSet_t *config_sets;
   2876   1.48     oster 	RF_ConfigSet_t *cset;
   2877   1.48     oster 	RF_AutoConfig_t *ac_next;
   2878   1.48     oster 
   2879   1.48     oster 
   2880   1.48     oster 	config_sets = NULL;
   2881   1.48     oster 
   2882   1.48     oster 	/* Go through the AutoConfig list, and figure out which components
   2883   1.48     oster 	   belong to what sets.  */
   2884   1.48     oster 	ac = ac_list;
   2885   1.48     oster 	while(ac!=NULL) {
   2886   1.48     oster 		/* we're going to putz with ac->next, so save it here
   2887   1.48     oster 		   for use at the end of the loop */
   2888   1.48     oster 		ac_next = ac->next;
   2889   1.48     oster 
   2890   1.48     oster 		if (config_sets == NULL) {
   2891   1.48     oster 			/* will need at least this one... */
   2892   1.48     oster 			config_sets = (RF_ConfigSet_t *)
   2893   1.48     oster 				malloc(sizeof(RF_ConfigSet_t),
   2894   1.48     oster 				       M_RAIDFRAME, M_NOWAIT);
   2895   1.48     oster 			if (config_sets == NULL) {
   2896  1.141    provos 				panic("rf_create_auto_sets: No memory!");
   2897   1.48     oster 			}
   2898   1.48     oster 			/* this one is easy :) */
   2899   1.48     oster 			config_sets->ac = ac;
   2900   1.48     oster 			config_sets->next = NULL;
   2901   1.51     oster 			config_sets->rootable = 0;
   2902   1.48     oster 			ac->next = NULL;
   2903   1.48     oster 		} else {
   2904   1.48     oster 			/* which set does this component fit into? */
   2905   1.48     oster 			cset = config_sets;
   2906   1.48     oster 			while(cset!=NULL) {
   2907   1.49     oster 				if (rf_does_it_fit(cset, ac)) {
   2908   1.86     oster 					/* looks like it matches... */
   2909   1.86     oster 					ac->next = cset->ac;
   2910   1.86     oster 					cset->ac = ac;
   2911   1.48     oster 					break;
   2912   1.48     oster 				}
   2913   1.48     oster 				cset = cset->next;
   2914   1.48     oster 			}
   2915   1.48     oster 			if (cset==NULL) {
   2916   1.48     oster 				/* didn't find a match above... new set..*/
   2917   1.48     oster 				cset = (RF_ConfigSet_t *)
   2918   1.48     oster 					malloc(sizeof(RF_ConfigSet_t),
   2919   1.48     oster 					       M_RAIDFRAME, M_NOWAIT);
   2920   1.48     oster 				if (cset == NULL) {
   2921  1.141    provos 					panic("rf_create_auto_sets: No memory!");
   2922   1.48     oster 				}
   2923   1.48     oster 				cset->ac = ac;
   2924   1.48     oster 				ac->next = NULL;
   2925   1.48     oster 				cset->next = config_sets;
   2926   1.51     oster 				cset->rootable = 0;
   2927   1.48     oster 				config_sets = cset;
   2928   1.48     oster 			}
   2929   1.48     oster 		}
   2930   1.48     oster 		ac = ac_next;
   2931   1.48     oster 	}
   2932   1.48     oster 
   2933   1.48     oster 
   2934   1.48     oster 	return(config_sets);
   2935   1.48     oster }
   2936   1.48     oster 
   2937   1.48     oster static int
   2938   1.49     oster rf_does_it_fit(cset, ac)
   2939   1.48     oster 	RF_ConfigSet_t *cset;
   2940   1.48     oster 	RF_AutoConfig_t *ac;
   2941   1.48     oster {
   2942   1.48     oster 	RF_ComponentLabel_t *clabel1, *clabel2;
   2943   1.48     oster 
   2944   1.48     oster 	/* If this one matches the *first* one in the set, that's good
   2945   1.48     oster 	   enough, since the other members of the set would have been
   2946   1.48     oster 	   through here too... */
   2947   1.60     oster 	/* note that we are not checking partitionSize here..
   2948   1.60     oster 
   2949   1.60     oster 	   Note that we are also not checking the mod_counters here.
   2950   1.60     oster 	   If everything else matches execpt the mod_counter, that's
   2951   1.60     oster 	   good enough for this test.  We will deal with the mod_counters
   2952   1.60     oster 	   a little later in the autoconfiguration process.
   2953   1.60     oster 
   2954   1.60     oster 	    (clabel1->mod_counter == clabel2->mod_counter) &&
   2955   1.81     oster 
   2956   1.81     oster 	   The reason we don't check for this is that failed disks
   2957   1.81     oster 	   will have lower modification counts.  If those disks are
   2958   1.81     oster 	   not added to the set they used to belong to, then they will
   2959   1.81     oster 	   form their own set, which may result in 2 different sets,
   2960   1.81     oster 	   for example, competing to be configured at raid0, and
   2961   1.81     oster 	   perhaps competing to be the root filesystem set.  If the
   2962   1.81     oster 	   wrong ones get configured, or both attempt to become /,
   2963   1.81     oster 	   weird behaviour and or serious lossage will occur.  Thus we
   2964   1.81     oster 	   need to bring them into the fold here, and kick them out at
   2965   1.81     oster 	   a later point.
   2966   1.60     oster 
   2967   1.60     oster 	*/
   2968   1.48     oster 
   2969   1.48     oster 	clabel1 = cset->ac->clabel;
   2970   1.48     oster 	clabel2 = ac->clabel;
   2971   1.48     oster 	if ((clabel1->version == clabel2->version) &&
   2972   1.48     oster 	    (clabel1->serial_number == clabel2->serial_number) &&
   2973   1.48     oster 	    (clabel1->num_rows == clabel2->num_rows) &&
   2974   1.48     oster 	    (clabel1->num_columns == clabel2->num_columns) &&
   2975   1.48     oster 	    (clabel1->sectPerSU == clabel2->sectPerSU) &&
   2976   1.48     oster 	    (clabel1->SUsPerPU == clabel2->SUsPerPU) &&
   2977   1.48     oster 	    (clabel1->SUsPerRU == clabel2->SUsPerRU) &&
   2978   1.48     oster 	    (clabel1->parityConfig == clabel2->parityConfig) &&
   2979   1.48     oster 	    (clabel1->maxOutstanding == clabel2->maxOutstanding) &&
   2980   1.48     oster 	    (clabel1->blockSize == clabel2->blockSize) &&
   2981   1.48     oster 	    (clabel1->numBlocks == clabel2->numBlocks) &&
   2982   1.48     oster 	    (clabel1->autoconfigure == clabel2->autoconfigure) &&
   2983   1.48     oster 	    (clabel1->root_partition == clabel2->root_partition) &&
   2984   1.48     oster 	    (clabel1->last_unit == clabel2->last_unit) &&
   2985   1.48     oster 	    (clabel1->config_order == clabel2->config_order)) {
   2986   1.48     oster 		/* if it get's here, it almost *has* to be a match */
   2987   1.48     oster 	} else {
   2988   1.48     oster 		/* it's not consistent with somebody in the set..
   2989   1.48     oster 		   punt */
   2990   1.48     oster 		return(0);
   2991   1.48     oster 	}
   2992   1.48     oster 	/* all was fine.. it must fit... */
   2993   1.48     oster 	return(1);
   2994   1.48     oster }
   2995   1.48     oster 
   2996   1.48     oster int
   2997   1.51     oster rf_have_enough_components(cset)
   2998   1.51     oster 	RF_ConfigSet_t *cset;
   2999   1.48     oster {
   3000   1.51     oster 	RF_AutoConfig_t *ac;
   3001   1.51     oster 	RF_AutoConfig_t *auto_config;
   3002   1.51     oster 	RF_ComponentLabel_t *clabel;
   3003   1.51     oster 	int r,c;
   3004   1.51     oster 	int num_rows;
   3005   1.51     oster 	int num_cols;
   3006   1.51     oster 	int num_missing;
   3007   1.86     oster 	int mod_counter;
   3008   1.87     oster 	int mod_counter_found;
   3009   1.88     oster 	int even_pair_failed;
   3010   1.88     oster 	char parity_type;
   3011   1.88     oster 
   3012   1.51     oster 
   3013   1.48     oster 	/* check to see that we have enough 'live' components
   3014   1.48     oster 	   of this set.  If so, we can configure it if necessary */
   3015   1.48     oster 
   3016   1.51     oster 	num_rows = cset->ac->clabel->num_rows;
   3017   1.51     oster 	num_cols = cset->ac->clabel->num_columns;
   3018   1.88     oster 	parity_type = cset->ac->clabel->parityConfig;
   3019   1.51     oster 
   3020   1.51     oster 	/* XXX Check for duplicate components!?!?!? */
   3021   1.51     oster 
   3022   1.86     oster 	/* Determine what the mod_counter is supposed to be for this set. */
   3023   1.86     oster 
   3024   1.87     oster 	mod_counter_found = 0;
   3025  1.101     oster 	mod_counter = 0;
   3026   1.86     oster 	ac = cset->ac;
   3027   1.86     oster 	while(ac!=NULL) {
   3028   1.87     oster 		if (mod_counter_found==0) {
   3029   1.86     oster 			mod_counter = ac->clabel->mod_counter;
   3030   1.87     oster 			mod_counter_found = 1;
   3031   1.87     oster 		} else {
   3032   1.87     oster 			if (ac->clabel->mod_counter > mod_counter) {
   3033   1.87     oster 				mod_counter = ac->clabel->mod_counter;
   3034   1.87     oster 			}
   3035   1.86     oster 		}
   3036   1.86     oster 		ac = ac->next;
   3037   1.86     oster 	}
   3038   1.86     oster 
   3039   1.51     oster 	num_missing = 0;
   3040   1.51     oster 	auto_config = cset->ac;
   3041   1.51     oster 
   3042   1.51     oster 	for(r=0; r<num_rows; r++) {
   3043   1.88     oster 		even_pair_failed = 0;
   3044   1.51     oster 		for(c=0; c<num_cols; c++) {
   3045   1.51     oster 			ac = auto_config;
   3046   1.51     oster 			while(ac!=NULL) {
   3047   1.51     oster 				if ((ac->clabel->row == r) &&
   3048   1.86     oster 				    (ac->clabel->column == c) &&
   3049   1.86     oster 				    (ac->clabel->mod_counter == mod_counter)) {
   3050   1.51     oster 					/* it's this one... */
   3051   1.51     oster #if DEBUG
   3052   1.51     oster 					printf("Found: %s at %d,%d\n",
   3053   1.51     oster 					       ac->devname,r,c);
   3054   1.51     oster #endif
   3055   1.51     oster 					break;
   3056   1.51     oster 				}
   3057   1.51     oster 				ac=ac->next;
   3058   1.51     oster 			}
   3059   1.51     oster 			if (ac==NULL) {
   3060   1.51     oster 				/* Didn't find one here! */
   3061   1.88     oster 				/* special case for RAID 1, especially
   3062   1.88     oster 				   where there are more than 2
   3063   1.88     oster 				   components (where RAIDframe treats
   3064   1.88     oster 				   things a little differently :( ) */
   3065   1.88     oster 				if (parity_type == '1') {
   3066   1.88     oster 					if (c%2 == 0) { /* even component */
   3067   1.88     oster 						even_pair_failed = 1;
   3068   1.88     oster 					} else { /* odd component.  If
   3069   1.88     oster                                                     we're failed, and
   3070   1.88     oster                                                     so is the even
   3071   1.88     oster                                                     component, it's
   3072   1.88     oster                                                     "Good Night, Charlie" */
   3073   1.88     oster 						if (even_pair_failed == 1) {
   3074   1.88     oster 							return(0);
   3075   1.88     oster 						}
   3076   1.88     oster 					}
   3077   1.88     oster 				} else {
   3078   1.88     oster 					/* normal accounting */
   3079   1.88     oster 					num_missing++;
   3080   1.88     oster 				}
   3081   1.88     oster 			}
   3082   1.88     oster 			if ((parity_type == '1') && (c%2 == 1)) {
   3083   1.88     oster 				/* Just did an even component, and we didn't
   3084   1.88     oster 				   bail.. reset the even_pair_failed flag,
   3085   1.88     oster 				   and go on to the next component.... */
   3086   1.88     oster 				even_pair_failed = 0;
   3087   1.51     oster 			}
   3088   1.51     oster 		}
   3089   1.51     oster 	}
   3090   1.51     oster 
   3091   1.51     oster 	clabel = cset->ac->clabel;
   3092   1.51     oster 
   3093   1.51     oster 	if (((clabel->parityConfig == '0') && (num_missing > 0)) ||
   3094   1.51     oster 	    ((clabel->parityConfig == '4') && (num_missing > 1)) ||
   3095   1.51     oster 	    ((clabel->parityConfig == '5') && (num_missing > 1))) {
   3096   1.51     oster 		/* XXX this needs to be made *much* more general */
   3097   1.51     oster 		/* Too many failures */
   3098   1.51     oster 		return(0);
   3099   1.51     oster 	}
   3100   1.51     oster 	/* otherwise, all is well, and we've got enough to take a kick
   3101   1.51     oster 	   at autoconfiguring this set */
   3102   1.51     oster 	return(1);
   3103   1.48     oster }
   3104   1.48     oster 
   3105   1.48     oster void
   3106   1.49     oster rf_create_configuration(ac,config,raidPtr)
   3107   1.48     oster 	RF_AutoConfig_t *ac;
   3108   1.48     oster 	RF_Config_t *config;
   3109   1.48     oster 	RF_Raid_t *raidPtr;
   3110   1.48     oster {
   3111   1.48     oster 	RF_ComponentLabel_t *clabel;
   3112   1.77     oster 	int i;
   3113   1.48     oster 
   3114   1.48     oster 	clabel = ac->clabel;
   3115   1.48     oster 
   3116   1.48     oster 	/* 1. Fill in the common stuff */
   3117   1.48     oster 	config->numRow = clabel->num_rows;
   3118   1.48     oster 	config->numCol = clabel->num_columns;
   3119   1.48     oster 	config->numSpare = 0; /* XXX should this be set here? */
   3120   1.48     oster 	config->sectPerSU = clabel->sectPerSU;
   3121   1.48     oster 	config->SUsPerPU = clabel->SUsPerPU;
   3122   1.48     oster 	config->SUsPerRU = clabel->SUsPerRU;
   3123   1.48     oster 	config->parityConfig = clabel->parityConfig;
   3124   1.48     oster 	/* XXX... */
   3125   1.48     oster 	strcpy(config->diskQueueType,"fifo");
   3126   1.48     oster 	config->maxOutstandingDiskReqs = clabel->maxOutstanding;
   3127   1.48     oster 	config->layoutSpecificSize = 0; /* XXX ?? */
   3128   1.48     oster 
   3129   1.48     oster 	while(ac!=NULL) {
   3130   1.48     oster 		/* row/col values will be in range due to the checks
   3131   1.48     oster 		   in reasonable_label() */
   3132   1.48     oster 		strcpy(config->devnames[ac->clabel->row][ac->clabel->column],
   3133   1.48     oster 		       ac->devname);
   3134   1.48     oster 		ac = ac->next;
   3135   1.48     oster 	}
   3136   1.48     oster 
   3137   1.77     oster 	for(i=0;i<RF_MAXDBGV;i++) {
   3138   1.77     oster 		config->debugVars[i][0] = NULL;
   3139   1.77     oster 	}
   3140   1.48     oster }
   3141   1.48     oster 
   3142   1.48     oster int
   3143   1.48     oster rf_set_autoconfig(raidPtr, new_value)
   3144   1.48     oster 	RF_Raid_t *raidPtr;
   3145   1.48     oster 	int new_value;
   3146   1.48     oster {
   3147   1.48     oster 	RF_ComponentLabel_t clabel;
   3148   1.48     oster 	struct vnode *vp;
   3149   1.48     oster 	dev_t dev;
   3150   1.48     oster 	int row, column;
   3151  1.148     oster 	int sparecol;
   3152   1.48     oster 
   3153   1.54     oster 	raidPtr->autoconfigure = new_value;
   3154   1.48     oster 	for(row=0; row<raidPtr->numRow; row++) {
   3155   1.48     oster 		for(column=0; column<raidPtr->numCol; column++) {
   3156   1.84     oster 			if (raidPtr->Disks[row][column].status ==
   3157   1.84     oster 			    rf_ds_optimal) {
   3158   1.84     oster 				dev = raidPtr->Disks[row][column].dev;
   3159   1.84     oster 				vp = raidPtr->raid_cinfo[row][column].ci_vp;
   3160   1.84     oster 				raidread_component_label(dev, vp, &clabel);
   3161   1.84     oster 				clabel.autoconfigure = new_value;
   3162   1.84     oster 				raidwrite_component_label(dev, vp, &clabel);
   3163   1.84     oster 			}
   3164   1.48     oster 		}
   3165   1.48     oster 	}
   3166  1.148     oster 	for(column = 0; column < raidPtr->numSpare ; column++) {
   3167  1.148     oster 		sparecol = raidPtr->numCol + column;
   3168  1.148     oster 		if (raidPtr->Disks[0][sparecol].status == rf_ds_used_spare) {
   3169  1.148     oster 			dev = raidPtr->Disks[0][sparecol].dev;
   3170  1.148     oster 			vp = raidPtr->raid_cinfo[0][sparecol].ci_vp;
   3171  1.148     oster 			raidread_component_label(dev, vp, &clabel);
   3172  1.148     oster 			clabel.autoconfigure = new_value;
   3173  1.148     oster 			raidwrite_component_label(dev, vp, &clabel);
   3174  1.148     oster 		}
   3175  1.148     oster 	}
   3176   1.48     oster 	return(new_value);
   3177   1.48     oster }
   3178   1.48     oster 
   3179   1.48     oster int
   3180   1.48     oster rf_set_rootpartition(raidPtr, new_value)
   3181   1.48     oster 	RF_Raid_t *raidPtr;
   3182   1.48     oster 	int new_value;
   3183   1.48     oster {
   3184   1.48     oster 	RF_ComponentLabel_t clabel;
   3185   1.48     oster 	struct vnode *vp;
   3186   1.48     oster 	dev_t dev;
   3187   1.48     oster 	int row, column;
   3188  1.148     oster 	int sparecol;
   3189   1.48     oster 
   3190   1.54     oster 	raidPtr->root_partition = new_value;
   3191   1.48     oster 	for(row=0; row<raidPtr->numRow; row++) {
   3192   1.48     oster 		for(column=0; column<raidPtr->numCol; column++) {
   3193   1.84     oster 			if (raidPtr->Disks[row][column].status ==
   3194   1.84     oster 			    rf_ds_optimal) {
   3195   1.84     oster 				dev = raidPtr->Disks[row][column].dev;
   3196   1.84     oster 				vp = raidPtr->raid_cinfo[row][column].ci_vp;
   3197   1.84     oster 				raidread_component_label(dev, vp, &clabel);
   3198   1.84     oster 				clabel.root_partition = new_value;
   3199   1.84     oster 				raidwrite_component_label(dev, vp, &clabel);
   3200   1.84     oster 			}
   3201  1.148     oster 		}
   3202  1.148     oster 	}
   3203  1.148     oster 	for(column = 0; column < raidPtr->numSpare ; column++) {
   3204  1.148     oster 		sparecol = raidPtr->numCol + column;
   3205  1.148     oster 		if (raidPtr->Disks[0][sparecol].status == rf_ds_used_spare) {
   3206  1.148     oster 			dev = raidPtr->Disks[0][sparecol].dev;
   3207  1.148     oster 			vp = raidPtr->raid_cinfo[0][sparecol].ci_vp;
   3208  1.148     oster 			raidread_component_label(dev, vp, &clabel);
   3209  1.148     oster 			clabel.root_partition = new_value;
   3210  1.148     oster 			raidwrite_component_label(dev, vp, &clabel);
   3211   1.48     oster 		}
   3212   1.48     oster 	}
   3213   1.48     oster 	return(new_value);
   3214   1.48     oster }
   3215   1.48     oster 
   3216   1.48     oster void
   3217   1.49     oster rf_release_all_vps(cset)
   3218   1.48     oster 	RF_ConfigSet_t *cset;
   3219   1.48     oster {
   3220   1.48     oster 	RF_AutoConfig_t *ac;
   3221   1.48     oster 
   3222   1.48     oster 	ac = cset->ac;
   3223   1.48     oster 	while(ac!=NULL) {
   3224   1.48     oster 		/* Close the vp, and give it back */
   3225   1.48     oster 		if (ac->vp) {
   3226   1.96     oster 			vn_lock(ac->vp, LK_EXCLUSIVE | LK_RETRY);
   3227   1.48     oster 			VOP_CLOSE(ac->vp, FREAD, NOCRED, 0);
   3228   1.48     oster 			vput(ac->vp);
   3229   1.86     oster 			ac->vp = NULL;
   3230   1.48     oster 		}
   3231   1.48     oster 		ac = ac->next;
   3232   1.48     oster 	}
   3233   1.48     oster }
   3234   1.48     oster 
   3235   1.48     oster 
   3236   1.48     oster void
   3237   1.49     oster rf_cleanup_config_set(cset)
   3238   1.48     oster 	RF_ConfigSet_t *cset;
   3239   1.48     oster {
   3240   1.48     oster 	RF_AutoConfig_t *ac;
   3241   1.48     oster 	RF_AutoConfig_t *next_ac;
   3242   1.48     oster 
   3243   1.48     oster 	ac = cset->ac;
   3244   1.48     oster 	while(ac!=NULL) {
   3245   1.48     oster 		next_ac = ac->next;
   3246   1.48     oster 		/* nuke the label */
   3247   1.48     oster 		free(ac->clabel, M_RAIDFRAME);
   3248   1.48     oster 		/* cleanup the config structure */
   3249   1.48     oster 		free(ac, M_RAIDFRAME);
   3250   1.48     oster 		/* "next.." */
   3251   1.48     oster 		ac = next_ac;
   3252   1.48     oster 	}
   3253   1.48     oster 	/* and, finally, nuke the config set */
   3254   1.48     oster 	free(cset, M_RAIDFRAME);
   3255   1.48     oster }
   3256   1.48     oster 
   3257   1.48     oster 
   3258   1.48     oster void
   3259   1.48     oster raid_init_component_label(raidPtr, clabel)
   3260   1.48     oster 	RF_Raid_t *raidPtr;
   3261   1.48     oster 	RF_ComponentLabel_t *clabel;
   3262   1.48     oster {
   3263   1.48     oster 	/* current version number */
   3264   1.48     oster 	clabel->version = RF_COMPONENT_LABEL_VERSION;
   3265   1.57     oster 	clabel->serial_number = raidPtr->serial_number;
   3266   1.48     oster 	clabel->mod_counter = raidPtr->mod_counter;
   3267   1.48     oster 	clabel->num_rows = raidPtr->numRow;
   3268   1.48     oster 	clabel->num_columns = raidPtr->numCol;
   3269   1.48     oster 	clabel->clean = RF_RAID_DIRTY; /* not clean */
   3270   1.48     oster 	clabel->status = rf_ds_optimal; /* "It's good!" */
   3271   1.48     oster 
   3272   1.48     oster 	clabel->sectPerSU = raidPtr->Layout.sectorsPerStripeUnit;
   3273   1.48     oster 	clabel->SUsPerPU = raidPtr->Layout.SUsPerPU;
   3274   1.48     oster 	clabel->SUsPerRU = raidPtr->Layout.SUsPerRU;
   3275   1.54     oster 
   3276   1.54     oster 	clabel->blockSize = raidPtr->bytesPerSector;
   3277   1.54     oster 	clabel->numBlocks = raidPtr->sectorsPerDisk;
   3278   1.54     oster 
   3279   1.48     oster 	/* XXX not portable */
   3280   1.48     oster 	clabel->parityConfig = raidPtr->Layout.map->parityConfig;
   3281   1.54     oster 	clabel->maxOutstanding = raidPtr->maxOutstanding;
   3282   1.54     oster 	clabel->autoconfigure = raidPtr->autoconfigure;
   3283   1.54     oster 	clabel->root_partition = raidPtr->root_partition;
   3284   1.48     oster 	clabel->last_unit = raidPtr->raidid;
   3285   1.54     oster 	clabel->config_order = raidPtr->config_order;
   3286   1.51     oster }
   3287   1.51     oster 
   3288   1.51     oster int
   3289   1.51     oster rf_auto_config_set(cset,unit)
   3290   1.51     oster 	RF_ConfigSet_t *cset;
   3291   1.51     oster 	int *unit;
   3292   1.51     oster {
   3293   1.51     oster 	RF_Raid_t *raidPtr;
   3294   1.51     oster 	RF_Config_t *config;
   3295   1.51     oster 	int raidID;
   3296   1.51     oster 	int retcode;
   3297   1.51     oster 
   3298  1.127     oster #if DEBUG
   3299   1.72     oster 	printf("RAID autoconfigure\n");
   3300  1.127     oster #endif
   3301   1.51     oster 
   3302   1.51     oster 	retcode = 0;
   3303   1.51     oster 	*unit = -1;
   3304   1.51     oster 
   3305   1.51     oster 	/* 1. Create a config structure */
   3306   1.51     oster 
   3307   1.51     oster 	config = (RF_Config_t *)malloc(sizeof(RF_Config_t),
   3308   1.51     oster 				       M_RAIDFRAME,
   3309   1.51     oster 				       M_NOWAIT);
   3310   1.51     oster 	if (config==NULL) {
   3311   1.51     oster 		printf("Out of mem!?!?\n");
   3312   1.51     oster 				/* XXX do something more intelligent here. */
   3313   1.51     oster 		return(1);
   3314   1.51     oster 	}
   3315   1.77     oster 
   3316   1.77     oster 	memset(config, 0, sizeof(RF_Config_t));
   3317   1.51     oster 
   3318   1.51     oster 	/*
   3319   1.51     oster 	   2. Figure out what RAID ID this one is supposed to live at
   3320   1.51     oster 	   See if we can get the same RAID dev that it was configured
   3321   1.51     oster 	   on last time..
   3322   1.51     oster 	*/
   3323   1.51     oster 
   3324   1.51     oster 	raidID = cset->ac->clabel->last_unit;
   3325   1.52     oster 	if ((raidID < 0) || (raidID >= numraid)) {
   3326   1.51     oster 		/* let's not wander off into lala land. */
   3327   1.51     oster 		raidID = numraid - 1;
   3328   1.51     oster 	}
   3329   1.51     oster 	if (raidPtrs[raidID]->valid != 0) {
   3330   1.51     oster 
   3331   1.51     oster 		/*
   3332   1.51     oster 		   Nope... Go looking for an alternative...
   3333   1.51     oster 		   Start high so we don't immediately use raid0 if that's
   3334   1.51     oster 		   not taken.
   3335   1.51     oster 		*/
   3336   1.51     oster 
   3337  1.115     oster 		for(raidID = numraid - 1; raidID >= 0; raidID--) {
   3338   1.51     oster 			if (raidPtrs[raidID]->valid == 0) {
   3339   1.51     oster 				/* can use this one! */
   3340   1.51     oster 				break;
   3341   1.51     oster 			}
   3342   1.51     oster 		}
   3343   1.51     oster 	}
   3344   1.51     oster 
   3345   1.51     oster 	if (raidID < 0) {
   3346   1.51     oster 		/* punt... */
   3347   1.51     oster 		printf("Unable to auto configure this set!\n");
   3348   1.51     oster 		printf("(Out of RAID devs!)\n");
   3349   1.51     oster 		return(1);
   3350   1.51     oster 	}
   3351  1.127     oster 
   3352  1.127     oster #if DEBUG
   3353   1.72     oster 	printf("Configuring raid%d:\n",raidID);
   3354  1.127     oster #endif
   3355  1.127     oster 
   3356   1.51     oster 	raidPtr = raidPtrs[raidID];
   3357   1.51     oster 
   3358   1.51     oster 	/* XXX all this stuff should be done SOMEWHERE ELSE! */
   3359   1.51     oster 	raidPtr->raidid = raidID;
   3360   1.51     oster 	raidPtr->openings = RAIDOUTSTANDING;
   3361   1.51     oster 
   3362   1.51     oster 	/* 3. Build the configuration structure */
   3363   1.51     oster 	rf_create_configuration(cset->ac, config, raidPtr);
   3364   1.51     oster 
   3365   1.51     oster 	/* 4. Do the configuration */
   3366   1.51     oster 	retcode = rf_Configure(raidPtr, config, cset->ac);
   3367   1.51     oster 
   3368   1.51     oster 	if (retcode == 0) {
   3369   1.61     oster 
   3370   1.59     oster 		raidinit(raidPtrs[raidID]);
   3371   1.59     oster 
   3372   1.59     oster 		rf_markalldirty(raidPtrs[raidID]);
   3373   1.54     oster 		raidPtrs[raidID]->autoconfigure = 1; /* XXX do this here? */
   3374   1.51     oster 		if (cset->ac->clabel->root_partition==1) {
   3375   1.51     oster 			/* everything configured just fine.  Make a note
   3376   1.51     oster 			   that this set is eligible to be root. */
   3377   1.51     oster 			cset->rootable = 1;
   3378   1.54     oster 			/* XXX do this here? */
   3379   1.54     oster 			raidPtrs[raidID]->root_partition = 1;
   3380   1.51     oster 		}
   3381   1.51     oster 	}
   3382   1.51     oster 
   3383   1.51     oster 	/* 5. Cleanup */
   3384   1.51     oster 	free(config, M_RAIDFRAME);
   3385   1.51     oster 
   3386   1.51     oster 	*unit = raidID;
   3387   1.51     oster 	return(retcode);
   3388   1.99     oster }
   3389   1.99     oster 
   3390   1.99     oster void
   3391   1.99     oster rf_disk_unbusy(desc)
   3392   1.99     oster 	RF_RaidAccessDesc_t *desc;
   3393   1.99     oster {
   3394   1.99     oster 	struct buf *bp;
   3395   1.99     oster 
   3396   1.99     oster 	bp = (struct buf *)desc->bp;
   3397   1.99     oster 	disk_unbusy(&raid_softc[desc->raidPtr->raidid].sc_dkdev,
   3398  1.145       mrg 	    (bp->b_bcount - bp->b_resid), (bp->b_flags & B_READ));
   3399   1.13     oster }
   3400