root/dev/raidframe/rf_openbsdkintf.c

DEFINITIONS

1. rf_probe
2. rf_attach
3. rf_detach
4. rf_activate
5. raidattach
6. rf_buildroothack
7. rf_shutdown_hook
8. raidsize
9. raiddump
10. raidopen
11. raidclose
12. raidstrategy
13. raidread
14. raidwrite
15. raidioctl
16. raidinit
17. rf_GetSpareTableFromDaemon
18. raidstart
19. rf_DispatchKernelIO
20. rf_KernelWakeupFunc
21. rf_InitBP
22. raidgetdefaultlabel
23. raidgetdisklabel
24. raidlookup
25. raidlock
26. raidunlock
27. raidmarkclean
28. raidmarkdirty
29. raidread_component_label
30. raidwrite_component_label
31. rf_markalldirty
32. rf_update_component_labels
33. rf_close_component
34. rf_UnconfigureVnodes
35. rf_ReconThread
36. rf_RewriteParityThread
37. rf_CopybackThread
38. rf_ReconstructInPlaceThread
39. rf_find_raid_components
40. rf_reasonable_label
41. rf_print_component_label
42. rf_create_auto_sets
43. rf_does_it_fit
44. rf_have_enough_components
45. rf_create_configuration
46. rf_set_autoconfig
47. rf_set_rootpartition
48. rf_release_all_vps
49. rf_cleanup_config_set
50. raid_init_component_label
51. rf_auto_config_set
52. rf_disk_unbusy

    1 /* $OpenBSD: rf_openbsdkintf.c,v 1.42 2007/06/23 03:11:34 krw Exp $     */
    2 /* $NetBSD: rf_netbsdkintf.c,v 1.109 2001/07/27 03:30:07 oster Exp $    */
    4 /*-
    5  * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc.
    6  * All rights reserved.
    7  *
    8  * This code is derived from software contributed to The NetBSD Foundation
    9  * by Greg Oster; Jason R. Thorpe.
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 3. All advertising materials mentioning features or use of this software
   20  *    must display the following acknowledgement:
   21  *        This product includes software developed by the NetBSD
   22  *        Foundation, Inc. and its contributors.
   23  * 4. Neither the name of The NetBSD Foundation nor the names of its
   24  *    contributors may be used to endorse or promote products derived
   25  *    from this software without specific prior written permission.
   26  *
   27  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   28  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   29  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   30  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   31  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   37  * POSSIBILITY OF SUCH DAMAGE.
   38  */
   40 /*
   41  * Copyright (c) 1988 University of Utah.
   42  * Copyright (c) 1990, 1993
   43  *      The Regents of the University of California.  All rights reserved.
   44  *
   45  * This code is derived from software contributed to Berkeley by
   46  * the Systems Programming Group of the University of Utah Computer
   47  * Science Department.
   48  *
   49  * Redistribution and use in source and binary forms, with or without
   50  * modification, are permitted provided that the following conditions
   51  * are met:
   52  * 1. Redistributions of source code must retain the above copyright
   53  *    notice, this list of conditions and the following disclaimer.
   54  * 2. Redistributions in binary form must reproduce the above copyright
   55  *    notice, this list of conditions and the following disclaimer in the
   56  *    documentation and/or other materials provided with the distribution.
   57  * 3. Neither the name of the University nor the names of its contributors
   58  *    may be used to endorse or promote products derived from this software
   59  *    without specific prior written permission.
   60  *
   61  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   62  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   63  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   64  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   65  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   66  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   67  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   68  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   69  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   70  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   71  * SUCH DAMAGE.
   72  *
   73  * from: Utah $Hdr: cd.c 1.6 90/11/28$
   74  *
   75  *      @(#)cd.c        8.2 (Berkeley) 11/16/93
   76  */
   78 /*
   79  * Copyright (c) 1995 Carnegie-Mellon University.
   80  * All rights reserved.
   81  *
   82  * Authors: Mark Holland, Jim Zelenka
   83  *
   84  * Permission to use, copy, modify and distribute this software and
   85  * its documentation is hereby granted, provided that both the copyright
   86  * notice and this permission notice appear in all copies of the
   87  * software, derivative works or modified versions, and any portions
   88  * thereof, and that both notices appear in supporting documentation.
   89  *
   90  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
   91  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
   92  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
   93  *
   94  * Carnegie Mellon requests users of this software to return to
   95  *
   96  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
   97  *  School of Computer Science
   98  *  Carnegie Mellon University
   99  *  Pittsburgh PA 15213-3890
  100  *
  101  * any improvements or extensions that they make and grant Carnegie the
  102  * rights to redistribute these changes.
  103  */
  105 /*****************************************************************************
  106  *
  107  * rf_kintf.c -- The kernel interface routines for RAIDframe.
  108  *
  109  *****************************************************************************/
  111 #include <sys/errno.h>
  113 #include <sys/param.h>
  114 #include <sys/pool.h>
  115 #include <sys/malloc.h>
  116 #include <sys/queue.h>
  117 #include <sys/disk.h>
  118 #include <sys/device.h>
  119 #include <sys/stat.h>
  120 #include <sys/ioctl.h>
  121 #include <sys/fcntl.h>
  122 #include <sys/systm.h>
  123 #include <sys/namei.h>
  124 #include <sys/conf.h>
  125 #include <sys/lock.h>
  126 #include <sys/buf.h>
  127 #include <sys/user.h>
  128 #include <sys/reboot.h>
  130 #include "raid.h"
  131 #include "rf_raid.h"
  132 #include "rf_raidframe.h"
  133 #include "rf_copyback.h"
  134 #include "rf_dag.h"
  135 #include "rf_dagflags.h"
  136 #include "rf_desc.h"
  137 #include "rf_diskqueue.h"
  138 #include "rf_engine.h"
  139 #include "rf_acctrace.h"
  140 #include "rf_etimer.h"
  141 #include "rf_general.h"
  142 #include "rf_debugMem.h"
  143 #include "rf_kintf.h"
  144 #include "rf_options.h"
  145 #include "rf_driver.h"
  146 #include "rf_parityscan.h"
  147 #include "rf_debugprint.h"
  148 #include "rf_threadstuff.h"
  149 #include "rf_configure.h"
  151 int     rf_kdebug_level = 0;
  153 #ifdef  RAIDDEBUG
  154 #define db1_printf(a) do { if (rf_kdebug_level > 0) printf a; } while(0)
  155 #else   /* RAIDDEBUG */
  156 #define db1_printf(a) (void)0
  157 #endif  /* ! RAIDDEBUG */
  159 static RF_Raid_t **raidPtrs;    /* Global raid device descriptors. */
RF_DECLARE_STATIC_MUTEX(rf_sparet_wait_mutex);
  163 /* Requests to install a spare table. */
  164 static RF_SparetWait_t *rf_sparet_wait_queue;
  166 /* Responses from installation process. */
  167 static RF_SparetWait_t *rf_sparet_resp_queue;
  169 /* Prototypes. */
  170 void rf_KernelWakeupFunc(struct buf *);
  171 void rf_InitBP(struct buf *, struct vnode *, unsigned, dev_t, RF_SectorNum_t,
RF_SectorCount_t, caddr_t, void (*)(struct buf *), void *, int,
  173     struct proc *);
  174 void raidinit(RF_Raid_t *);
  176 void raidattach(int);
daddr64_t raidsize(dev_t);
  178 int  raidopen(dev_t, int, int, struct proc *);
  179 int  raidclose(dev_t, int, int, struct proc *);
  180 int  raidioctl(dev_t, u_long, caddr_t, int, struct proc *);
  181 int  raidwrite(dev_t, struct uio *, int);
  182 int  raidread(dev_t, struct uio *, int);
  183 void raidstrategy(struct buf *);
  184 int  raiddump(dev_t, daddr64_t, caddr_t, size_t);
  186 /*
  187  * Pilfered from ccd.c
  188  */
  189 struct raidbuf {
  190         struct buf       rf_buf;        /* New I/O buf.  MUST BE FIRST!!! */
  191         struct buf      *rf_obp;        /* Ptr. to original I/O buf. */
  192         int              rf_flags;      /* Miscellaneous flags. */
RF_DiskQueueData_t *req;        /* The request that this was part of. */
  194 };
  196 #define RAIDGETBUF(rs)          pool_get(&(rs)->sc_cbufpool, PR_NOWAIT)
  197 #define RAIDPUTBUF(rs, cbp)     pool_put(&(rs)->sc_cbufpool, cbp)
  199 /*
  200  * Some port (like i386) use a swapgeneric that wants to snoop around
  201  * in this raid_cd structure.  It is preserved (for now) to remain
  202  * compatible with such practice.
  203  */
  204 struct cfdriver raid_cd = {
NULL, "raid", DV_DISK
  206 };
  208 /*
  209  * XXX Not sure if the following should be replacing the raidPtrs above,
  210  * or if it should be used in conjunction with that...
  211  */
  212 struct raid_softc {
  213         int             sc_flags;               /* Flags. */
  214         int             sc_cflags;              /* Configuration flags. */
size_t          sc_size;                /* Size of the raid device. */
  216         char            sc_xname[20];           /* XXX external name. */
  217         struct disk     sc_dkdev;               /* Generic disk device info. */
  218         struct pool     sc_cbufpool;            /* Component buffer pool. */
  219         struct buf      sc_q;                   /* Used for the device queue. */
  220 };
  222 /* sc_flags */
  223 #define RAIDF_INITED    0x01    /* Unit has been initialized. */
  224 #define RAIDF_WLABEL    0x02    /* Label area is writable. */
  225 #define RAIDF_LABELLING 0x04    /* Unit is currently being labelled. */
  226 #define RAIDF_WANTED    0x40    /* Someone is waiting to obtain a lock. */
  227 #define RAIDF_LOCKED    0x80    /* Unit is locked. */
  229 int numraid = 0;
  231 /*
  232  * Here we define a cfattach structure for inserting any new raid device
  233  * into the device tree.  This is needed by some archs that look for
  234  * bootable devices in there.
  235  */
  236 int  rf_probe(struct device *, void *, void *);
  237 void rf_attach(struct device *, struct device *, void *);
  238 int  rf_detach(struct device *, int);
  239 int  rf_activate(struct device *, enum devact);
  241 struct cfattach raid_ca = {
  242         sizeof(struct raid_softc), rf_probe, rf_attach,
rf_detach, rf_activate
  244 };
  246 /*
  247  * Allow RAIDOUTSTANDING number of simultaneous IO's to this RAID device.
  248  * Be aware that large numbers can allow the driver to consume a lot of
  249  * kernel memory, especially on writes, and in degraded mode reads.
  250  *
  251  * For example: with a stripe width of 64 blocks (32k) and 5 disks,
  252  * a single 64K write will typically require 64K for the old data,
  253  * 64K for the old parity, and 64K for the new parity, for a total
  254  * of 192K (if the parity buffer is not re-used immediately).
  255  * Even it if is used immedately, that's still 128K, which when multiplied
  256  * by say 10 requests, is 1280K, *on top* of the 640K of incoming data.
  257  *
  258  * Now in degraded mode, for example, a 64K read on the above setup may
  259  * require data reconstruction, which will require *all* of the 4 remaining
  260  * disks to participate -- 4 * 32K/disk == 128K again.
  261  */
  263 #ifndef RAIDOUTSTANDING
  264 #define RAIDOUTSTANDING         6
  265 #endif
  267 /* Declared here, and made public, for the benefit of KVM stuff... */
  268 struct raid_softc  *raid_softc;
  269 struct raid_softc **raid_scPtrs;
  271 void rf_shutdown_hook(RF_ThreadArg_t);
  272 void raidgetdefaultlabel(RF_Raid_t *, struct raid_softc *, struct disklabel *);
  273 void raidgetdisklabel(dev_t, struct disklabel *, int);
  275 int  raidlock(struct raid_softc *);
  276 void raidunlock(struct raid_softc *);
  278 void rf_markalldirty(RF_Raid_t *);
  280 struct device *raidrootdev;
  282 int  findblkmajor(struct device *dv);
  283 char *findblkname(int);
  285 void rf_ReconThread(struct rf_recon_req *);
  286 /* XXX what I want is: */
  287 /*void rf_ReconThread(RF_Raid_t *raidPtr);*/
  288 void rf_RewriteParityThread(RF_Raid_t *raidPtr);
  289 void rf_CopybackThread(RF_Raid_t *raidPtr);
  290 void rf_ReconstructInPlaceThread(struct rf_recon_req *);
  291 #ifdef  RAID_AUTOCONFIG
  292 void rf_buildroothack(void *);
  293 int  rf_reasonable_label(RF_ComponentLabel_t *);
  294 #endif  /* RAID_AUTOCONFIG */
RF_AutoConfig_t *rf_find_raid_components(void);
RF_ConfigSet_t *rf_create_auto_sets(RF_AutoConfig_t *);
  298 int  rf_does_it_fit(RF_ConfigSet_t *,RF_AutoConfig_t *);
  299 void rf_create_configuration(RF_AutoConfig_t *,RF_Config_t *,
RF_Raid_t *);
  301 int  rf_set_autoconfig(RF_Raid_t *, int);
  302 int  rf_set_rootpartition(RF_Raid_t *, int);
  303 void rf_release_all_vps(RF_ConfigSet_t *);
  304 void rf_cleanup_config_set(RF_ConfigSet_t *);
  305 int  rf_have_enough_components(RF_ConfigSet_t *);
  306 int  rf_auto_config_set(RF_ConfigSet_t *, int *);
  308 #ifdef  RAID_AUTOCONFIG
  309 static int raidautoconfig = 0;  /*
  310                                  * Debugging, mostly.  Set to 0 to not
  311                                  * allow autoconfig to take place.
  312                                  * Note that this is overridden by having
  313                                  * RAID_AUTOCONFIG as an option in the
  314                                  * kernel config file.
  315                                  */
  316 #endif  /* RAID_AUTOCONFIG */
  318 int
rf_probe(struct device *parent, void *match_, void *aux)
  320 {
  321         return 0;
  322 }
  324 void
rf_attach(struct device *parent, struct device *self, void *aux)
  326 {
  327         /*struct raid_softc *raid = (void *)self;*/
  328 }
  330 int
rf_detach(struct device *self, int flags)
  332 {
  333         return 0;
  334 }
  336 int
rf_activate(struct device *self, enum devact act)
  338 {
  339         return 0;
  340 }
  342 void
raidattach(int num)
  344 {
  345         int raidID;
  346         int i, rc;
  347 #ifdef  RAID_AUTOCONFIG
RF_AutoConfig_t *ac_list;       /* Autoconfig list. */
RF_ConfigSet_t *config_sets;
  350 #endif  /* RAID_AUTOCONFIG */
db1_printf(("raidattach: Asked for %d units\n", num));
  354         if (num <= 0) {
  355 #ifdef  DIAGNOSTIC
panic("raidattach: count <= 0");
  357 #endif  /* DIAGNOSTIC */
  358                 return;
  359         }
  361         /* This is where all the initialization stuff gets done. */
numraid = num;
  365         /* Make some space for requested number of units... */
RF_Calloc(raidPtrs, num, sizeof(RF_Raid_t *), (RF_Raid_t **));
  367         if (raidPtrs == NULL) {
panic("raidPtrs is NULL!!");
  369         }
rc = rf_mutex_init(&rf_sparet_wait_mutex);
  372         if (rc) {
RF_PANIC();
  374         }
rf_sparet_wait_queue = rf_sparet_resp_queue = NULL;
  378         for (i = 0; i < num; i++)
raidPtrs[i] = NULL;
rc = rf_BootRaidframe();
  381         if (rc == 0)
printf("Kernelized RAIDframe activated\n");
  383         else
panic("Serious error booting RAID !!!");
  386         /*
  387          * Put together some datastructures like the CCD device does...
  388          * This lets us lock the device and what-not when it gets opened.
  389          */
raid_softc = (struct raid_softc *)
malloc(num * sizeof(struct raid_softc), M_RAIDFRAME, M_NOWAIT);
  393         if (raid_softc == NULL) {
printf("WARNING: no memory for RAIDframe driver\n");
  395                 return;
  396         }
bzero(raid_softc, num * sizeof (struct raid_softc));
raid_scPtrs = (struct raid_softc **)
malloc(num * sizeof(struct raid_softc *), M_RAIDFRAME,
M_NOWAIT);
  403         if (raid_scPtrs == NULL) {
printf("WARNING: no memory for RAIDframe driver\n");
  405                 return;
  406         }
bzero(raid_scPtrs, num * sizeof (struct raid_softc *));
raidrootdev = (struct device *)malloc(num * sizeof(struct device),
M_RAIDFRAME, M_NOWAIT);
  412         if (raidrootdev == NULL) {
panic("No memory for RAIDframe driver!!?!?!");
  414         }
  416         for (raidID = 0; raidID < num; raidID++) {
  417 #if 0
SIMPLEQ_INIT(&raid_softc[raidID].sc_q);
  419 #endif
raidrootdev[raidID].dv_class  = DV_DISK;
raidrootdev[raidID].dv_cfdata = NULL;
raidrootdev[raidID].dv_unit   = raidID;
raidrootdev[raidID].dv_parent = NULL;
raidrootdev[raidID].dv_flags  = 0;
snprintf(raidrootdev[raidID].dv_xname,
  427                     sizeof raidrootdev[raidID].dv_xname,"raid%d",raidID);
RF_Calloc(raidPtrs[raidID], 1, sizeof (RF_Raid_t),
  430                     (RF_Raid_t *));
  431                 if (raidPtrs[raidID] == NULL) {
printf("WARNING: raidPtrs[%d] is NULL\n", raidID);
numraid = raidID;
  434                         return;
  435                 }
  436         }
raid_cd.cd_devs = (void **) raid_scPtrs;
raid_cd.cd_ndevs = num;
  441 #ifdef  RAID_AUTOCONFIG
raidautoconfig = 1;
  444         if (raidautoconfig) {
  445                 /* 1. Locate all RAID components on the system. */
  447 #ifdef  RAIDDEBUG
printf("Searching for raid components...\n");
  449 #endif  /* RAIDDEBUG */
ac_list = rf_find_raid_components();
  452                 /* 2. Sort them into their respective sets. */
config_sets = rf_create_auto_sets(ac_list);
  456                 /*
  457                  * 3. Evaluate each set and configure the valid ones
  458                  * This gets done in rf_buildroothack().
  459                  */
  461                 /*
  462                  * Schedule the creation of the thread to do the
  463                  * "/ on RAID" stuff.
  464                  */
rf_buildroothack(config_sets);
  468         }
  469 #endif  /* RAID_AUTOCONFIG */
  471 }
  473 #ifdef  RAID_AUTOCONFIG
  474 void
rf_buildroothack(void *arg)
  476 {
RF_ConfigSet_t *config_sets = arg;
RF_ConfigSet_t *cset;
RF_ConfigSet_t *next_cset;
  480         int retcode;
  481         int raidID;
  482         int rootID;
  483         int num_root;
  484         int majdev;
rootID = 0;
num_root = 0;
cset = config_sets;
  489         while(cset != NULL ) {
next_cset = cset->next;
  491                 if (rf_have_enough_components(cset) &&
cset->ac->clabel->autoconfigure==1) {
retcode = rf_auto_config_set(cset,&raidID);
  494                         if (!retcode) {
  495                                 if (cset->rootable) {
rootID = raidID;
  497 #ifdef  RAIDDEBUG
printf("eligible root device %d:"
  499                                             " raid%d\n", num_root, rootID);
  500 #endif  /* RAIDDEBUG */
num_root++;
  502                                 }
  503                         } else {
  504                                 /* The autoconfig didn't work :( */
  505 #ifdef  RAIDDEBUG
printf("Autoconfig failed with code %d for"
  507                                     " raid%d\n", retcode, raidID);
  508 #endif  /* RAIDDEBUG */
rf_release_all_vps(cset);
  510                         }
  511                 } else {
  512                         /*
  513                          * We're not autoconfiguring this set...
  514                          * Release the associated resources.
  515                          */
rf_release_all_vps(cset);
  517                 }
  518                 /* Cleanup. */
rf_cleanup_config_set(cset);
cset = next_cset;
  521         }
  522         if (boothowto & RB_ASKNAME) {
  523                 /* We don't auto-config... */
  524         } else {
  525                 /* They didn't ask, and we found something bootable... */
  527                 if (num_root == 1) {
majdev = findblkmajor(&raidrootdev[rootID]);
  529                         if (majdev < 0)
boothowto |= RB_ASKNAME;
  531                         else {
rootdev = MAKEDISKDEV(majdev,rootID,0);
boothowto |= RB_DFLTROOT;
  534                         }
  535                 } else if (num_root > 1) {
  536                         /* We can't guess... Require the user to answer... */
boothowto |= RB_ASKNAME;
  538                 }
  539         }
  540 }
  541 #endif  /* RAID_AUTOCONFIG */
  543 void
rf_shutdown_hook(RF_ThreadArg_t arg)
  545 {
  546         int unit;
  547         struct raid_softc *rs;
RF_Raid_t *raidPtr;
  550         /* Don't do it if we are not "safe". */
  551         if (boothowto & RB_NOSYNC)
  552                 return;
raidPtr = (RF_Raid_t *) arg;
unit = raidPtr->raidid;
rs = &raid_softc[unit];
  558         /* Shutdown the system. */
  560         if (rf_hook_cookies != NULL && rf_hook_cookies[unit] != NULL)
rf_hook_cookies[unit] = NULL;
rf_Shutdown(raidPtr);
pool_destroy(&rs->sc_cbufpool);
  567         /* It's no longer initialized... */
rs->sc_flags &= ~RAIDF_INITED;
  570         /* config_detach the device. */
config_detach(device_lookup(&raid_cd, unit), 0);
  573         /* Detach the disk. */
disk_detach(&rs->sc_dkdev);
  575 }
daddr64_t
raidsize(dev_t dev)
  579 {
  580         struct raid_softc *rs;
  581         struct disklabel *lp;
  582         int part, unit, omask, size;
unit = DISKUNIT(dev);
  585         if (unit >= numraid)
  586                 return (-1);
rs = &raid_softc[unit];
  589         if ((rs->sc_flags & RAIDF_INITED) == 0)
  590                 return (-1);
part = DISKPART(dev);
omask = rs->sc_dkdev.dk_openmask & (1 << part);
lp = rs->sc_dkdev.dk_label;
  596         if (omask == 0 && raidopen(dev, 0, S_IFBLK, curproc))
  597                 return (-1);
  599         if (lp->d_partitions[part].p_fstype != FS_SWAP)
size = -1;
  601         else
size = DL_GETPSIZE(&lp->d_partitions[part]) *
  603                     (lp->d_secsize / DEV_BSIZE);
  605         if (omask == 0 && raidclose(dev, 0, S_IFBLK, curproc))
  606                 return (-1);
  608         return (size);
  610 }
  612 int
raiddump(dev_t dev, daddr64_t blkno, caddr_t va, size_t size)
  614 {
  615         /* Not implemented. */
  616         return (ENXIO);
  617 }
  619 /* ARGSUSED */
  620 int
raidopen(dev_t dev, int flags, int fmt, struct proc *p)
  622 {
  623         int unit = DISKUNIT(dev);
  624         struct raid_softc *rs;
  625         int part,pmask;
  626         int error = 0;
  628         if (unit >= numraid)
  629                 return (ENXIO);
rs = &raid_softc[unit];
  632         if ((error = raidlock(rs)) != 0)
  633                 return (error);
part = DISKPART(dev);
pmask = (1 << part);
db1_printf(
  639             ("Opening raid device number: %d partition: %d\n", unit, part));
  642         if ((rs->sc_flags & RAIDF_INITED) && (rs->sc_dkdev.dk_openmask == 0))
raidgetdisklabel(dev, rs->sc_dkdev.dk_label, 0);
  645         /* Make sure that this partition exists. */
  647         if (part != RAW_PART) {
db1_printf(("Not a raw partition..\n"));
  649                 if (((rs->sc_flags & RAIDF_INITED) == 0) ||
  650                     ((part >= rs->sc_dkdev.dk_label->d_npartitions) ||
  651                     (rs->sc_dkdev.dk_label->d_partitions[part].p_fstype ==
FS_UNUSED))) {
error = ENXIO;
raidunlock(rs);
db1_printf(("Bailing out...\n"));
  656                         return (error);
  657                 }
  658         }
  660         /* Prevent this unit from being unconfigured while opened. */
  661         switch (fmt) {
  662         case S_IFCHR:
rs->sc_dkdev.dk_copenmask |= pmask;
  664                 break;
  666         case S_IFBLK:
rs->sc_dkdev.dk_bopenmask |= pmask;
  668                 break;
  669         }
  671         if ((rs->sc_dkdev.dk_openmask == 0) &&
  672             ((rs->sc_flags & RAIDF_INITED) != 0)) {
  673                 /*
  674                  * First one...  Mark things as dirty...  Note that we *MUST*
  675                  * have done a configure before this.  I DO NOT WANT TO BE
  676                  * SCRIBBLING TO RANDOM COMPONENTS UNTIL IT'S BEEN DETERMINED
  677                  * THAT THEY BELONG TOGETHER!!!!!
  678                  */
  679                 /*
  680                  * XXX should check to see if we're only open for reading
  681                  * here...  If so, we needn't do this, but then need some
  682                  * other way of keeping track of what's happened...
  683                  */
rf_markalldirty( raidPtrs[unit] );
  686         }
rs->sc_dkdev.dk_openmask =
rs->sc_dkdev.dk_copenmask | rs->sc_dkdev.dk_bopenmask;
raidunlock(rs);
  693         return (error);
  694 }
  696 /* ARGSUSED */
  697 int
raidclose(dev_t dev, int flags, int fmt, struct proc *p)
  699 {
  700         int unit = DISKUNIT(dev);
  701         struct raid_softc *rs;
  702         int error = 0;
  703         int part;
  705         if (unit >= numraid)
  706                 return (ENXIO);
rs = &raid_softc[unit];
  709         if ((error = raidlock(rs)) != 0)
  710                 return (error);
part = DISKPART(dev);
  714         /* ...that much closer to allowing unconfiguration... */
  715         switch (fmt) {
  716         case S_IFCHR:
rs->sc_dkdev.dk_copenmask &= ~(1 << part);
  718                 break;
  720         case S_IFBLK:
rs->sc_dkdev.dk_bopenmask &= ~(1 << part);
  722                 break;
  723         }
rs->sc_dkdev.dk_openmask =
rs->sc_dkdev.dk_copenmask | rs->sc_dkdev.dk_bopenmask;
  727         if ((rs->sc_dkdev.dk_openmask == 0) &&
  728             ((rs->sc_flags & RAIDF_INITED) != 0)) {
  729                 /*
  730                  * Last one...  Device is not unconfigured yet.
  731                  * Device shutdown has taken care of setting the
  732                  * clean bits if RAIDF_INITED is not set.
  733                  * Mark things as clean...
  734                  */
db1_printf(("Last one on raid%d.  Updating status.\n",unit));
rf_update_component_labels(raidPtrs[unit],
RF_FINAL_COMPONENT_UPDATE);
  738         }
raidunlock(rs);
  741         return (0);
  742 }
  744 void
raidstrategy(struct buf *bp)
  746 {
  747         int s;
  749         unsigned int raidID = DISKUNIT(bp->b_dev);
RF_Raid_t *raidPtr;
  751         struct raid_softc *rs = &raid_softc[raidID];
  752         struct disklabel *lp;
  753         int wlabel;
s = splbio();
  757         if ((rs->sc_flags & RAIDF_INITED) ==0) {
bp->b_error = ENXIO;
bp->b_flags |= B_ERROR;
bp->b_resid = bp->b_bcount;
biodone(bp);
  762                 goto raidstrategy_end;
  763         }
  764         if (raidID >= numraid || !raidPtrs[raidID]) {
bp->b_error = ENODEV;
bp->b_flags |= B_ERROR;
bp->b_resid = bp->b_bcount;
biodone(bp);
  769                 goto raidstrategy_end;
  770         }
raidPtr = raidPtrs[raidID];
  772         if (!raidPtr->valid) {
bp->b_error = ENODEV;
bp->b_flags |= B_ERROR;
bp->b_resid = bp->b_bcount;
biodone(bp);
  777                 goto raidstrategy_end;
  778         }
  779         if (bp->b_bcount == 0) {
db1_printf(("b_bcount is zero..\n"));
biodone(bp);
  782                 goto raidstrategy_end;
  783         }
lp = rs->sc_dkdev.dk_label;
  786         /*
  787          * Do bounds checking and adjust transfer.  If there's an
  788          * error, the bounds check will flag that for us.
  789          */
wlabel = rs->sc_flags & (RAIDF_WLABEL | RAIDF_LABELLING);
  791         if (DISKPART(bp->b_dev) != RAW_PART)
  792                 if (bounds_check_with_label(bp, lp, wlabel) <= 0) {
db1_printf(("Bounds check failed!!:%d %d\n",
  794                             (int)bp->b_blkno, (int)wlabel));
biodone(bp);
  796                         goto raidstrategy_end;
  797                 }
bp->b_resid = 0;
bp->b_actf = rs->sc_q.b_actf;
rs->sc_q.b_actf = bp;
rs->sc_q.b_active++;
raidstart(raidPtrs[raidID]);
raidstrategy_end:
splx(s);
  809 }
  811 /* ARGSUSED */
  812 int
raidread(dev_t dev, struct uio *uio, int flags)
  814 {
  815         int unit = DISKUNIT(dev);
  816         struct raid_softc *rs;
  817         int part;
  819         if (unit >= numraid)
  820                 return (ENXIO);
rs = &raid_softc[unit];
  823         if ((rs->sc_flags & RAIDF_INITED) == 0)
  824                 return (ENXIO);
part = DISKPART(dev);
db1_printf(("raidread: unit: %d partition: %d\n", unit, part));
  829         return (physio(raidstrategy, NULL, dev, B_READ, minphys, uio));
  830 }
  832 /* ARGSUSED */
  833 int
raidwrite(dev_t dev, struct uio *uio, int flags)
  835 {
  836         int unit = DISKUNIT(dev);
  837         struct raid_softc *rs;
  839         if (unit >= numraid)
  840                 return (ENXIO);
rs = &raid_softc[unit];
  843         if ((rs->sc_flags & RAIDF_INITED) == 0)
  844                 return (ENXIO);
db1_printf(("raidwrite\n"));
  846         return (physio(raidstrategy, NULL, dev, B_WRITE, minphys, uio));
  847 }
  849 int
raidioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
  851 {
  852         int unit = DISKUNIT(dev);
  853         int error = 0;
  854         int part, pmask;
  855         struct raid_softc *rs;
RF_Config_t *k_cfg, *u_cfg;
RF_Raid_t *raidPtr;
RF_RaidDisk_t *diskPtr;
RF_AccTotals_t *totals;
RF_DeviceConfig_t *d_cfg, **ucfgp;
u_char *specific_buf;
  862         int retcode = 0;
  863         int row;
  864         int column;
  865         struct rf_recon_req *rrcopy, *rr;
RF_ComponentLabel_t *clabel;
RF_ComponentLabel_t ci_label;
RF_ComponentLabel_t **clabel_ptr;
RF_SingleComponent_t *sparePtr,*componentPtr;
RF_SingleComponent_t hot_spare;
RF_SingleComponent_t component;
RF_ProgressInfo_t progressInfo, **progressInfoPtr;
  873         int i, j, d;
  875         if (unit >= numraid)
  876                 return (ENXIO);
rs = &raid_softc[unit];
raidPtr = raidPtrs[unit];
db1_printf(("raidioctl: %d %d %d %d\n", (int)dev, (int)DISKPART(dev),
  881             (int)unit, (int)cmd));
  883         /* Must be open for writes for these commands... */
  884         switch (cmd) {
  885         case DIOCSDINFO:
  886         case DIOCWDINFO:
  887         case DIOCWLABEL:
  888                 if ((flag & FWRITE) == 0)
  889                         return (EBADF);
  890         }
  892         /* Must be initialized for these... */
  893         switch (cmd) {
  894         case DIOCGDINFO:
  895         case DIOCSDINFO:
  896         case DIOCWDINFO:
  897         case DIOCGPART:
  898         case DIOCWLABEL:
  899         case DIOCGPDINFO:
  900         case RAIDFRAME_SHUTDOWN:
  901         case RAIDFRAME_REWRITEPARITY:
  902         case RAIDFRAME_GET_INFO:
  903         case RAIDFRAME_RESET_ACCTOTALS:
  904         case RAIDFRAME_GET_ACCTOTALS:
  905         case RAIDFRAME_KEEP_ACCTOTALS:
  906         case RAIDFRAME_GET_SIZE:
  907         case RAIDFRAME_FAIL_DISK:
  908         case RAIDFRAME_COPYBACK:
  909         case RAIDFRAME_CHECK_RECON_STATUS:
  910         case RAIDFRAME_CHECK_RECON_STATUS_EXT:
  911         case RAIDFRAME_GET_COMPONENT_LABEL:
  912         case RAIDFRAME_SET_COMPONENT_LABEL:
  913         case RAIDFRAME_ADD_HOT_SPARE:
  914         case RAIDFRAME_REMOVE_HOT_SPARE:
  915         case RAIDFRAME_INIT_LABELS:
  916         case RAIDFRAME_REBUILD_IN_PLACE:
  917         case RAIDFRAME_CHECK_PARITY:
  918         case RAIDFRAME_CHECK_PARITYREWRITE_STATUS:
  919         case RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT:
  920         case RAIDFRAME_CHECK_COPYBACK_STATUS:
  921         case RAIDFRAME_CHECK_COPYBACK_STATUS_EXT:
  922         case RAIDFRAME_SET_AUTOCONFIG:
  923         case RAIDFRAME_SET_ROOT:
  924         case RAIDFRAME_DELETE_COMPONENT:
  925         case RAIDFRAME_INCORPORATE_HOT_SPARE:
  926                 if ((rs->sc_flags & RAIDF_INITED) == 0)
  927                         return (ENXIO);
  928         }
  930         switch (cmd) {
  931                 /* Configure the system. */
  932         case RAIDFRAME_CONFIGURE:
  934                 if (raidPtr->valid) {
  935                         /* There is a valid RAID set running on this unit ! */
printf("raid%d: Device already configured!\n",unit);
  937                         return(EINVAL);
  938                 }
  940                 /*
  941                  * Copy-in the configuration information.
  942                  * data points to a pointer to the configuration structure.
  943                  */
u_cfg = *((RF_Config_t **)data);
RF_Malloc(k_cfg, sizeof (RF_Config_t), (RF_Config_t *));
  946                 if (k_cfg == NULL) {
  947                         return (ENOMEM);
  948                 }
retcode = copyin((caddr_t)u_cfg, (caddr_t)k_cfg,
  950                     sizeof (RF_Config_t));
  951                 if (retcode) {
RF_Free(k_cfg, sizeof(RF_Config_t));
  953                         return (retcode);
  954                 }
  956                 /*
  957                  * Allocate a buffer for the layout-specific data,
  958                  * and copy it in.
  959                  */
  960                 if (k_cfg->layoutSpecificSize) {
  961                         if (k_cfg->layoutSpecificSize > 10000) {
  962                                 /* Sanity check. */
RF_Free(k_cfg, sizeof(RF_Config_t));
  964                                 return (EINVAL);
  965                         }
RF_Malloc(specific_buf, k_cfg->layoutSpecificSize,
  967                             (u_char *));
  968                         if (specific_buf == NULL) {
RF_Free(k_cfg, sizeof (RF_Config_t));
  970                                 return (ENOMEM);
  971                         }
retcode = copyin(k_cfg->layoutSpecific,
  973                             (caddr_t)specific_buf, k_cfg->layoutSpecificSize);
  974                         if (retcode) {
RF_Free(k_cfg, sizeof(RF_Config_t));
RF_Free(specific_buf,
k_cfg->layoutSpecificSize);
  978                                 return (retcode);
  979                         }
  980                 } else
specific_buf = NULL;
k_cfg->layoutSpecific = specific_buf;
  984                 /*
  985                  * We should do some kind of sanity check on the
  986                  * configuration.
  987                  * Store the sum of all the bytes in the last byte ?
  988                  */
  990                 /*
  991                  * Clear the entire RAID descriptor, just to make sure
  992                  *  there is no stale data left in the case of a
  993                  *  reconfiguration.
  994                  */
bzero((char *) raidPtr, sizeof(RF_Raid_t));
  997                 /* Configure the system. */
raidPtr->raidid = unit;
retcode = rf_Configure(raidPtr, k_cfg, NULL);
 1002                 if (retcode == 0) {
 1004                         /*
 1005                          * Allow this many simultaneous IO's to
 1006                          * this RAID device.
 1007                          */
raidPtr->openings = RAIDOUTSTANDING;
raidinit(raidPtr);
rf_markalldirty(raidPtr);
 1012                 }
 1014                 /* Free the buffers.  No return code here. */
 1015                 if (k_cfg->layoutSpecificSize) {
RF_Free(specific_buf, k_cfg->layoutSpecificSize);
 1017                 }
RF_Free(k_cfg, sizeof (RF_Config_t));
 1020                 return (retcode);
 1022         case RAIDFRAME_SHUTDOWN:
 1023                 /* Shutdown the system. */
 1025                 if ((error = raidlock(rs)) != 0)
 1026                         return (error);
 1028                 /*
 1029                  * If somebody has a partition mounted, we shouldn't
 1030                  * shutdown.
 1031                  */
part = DISKPART(dev);
pmask = (1 << part);
 1035                 if ((rs->sc_dkdev.dk_openmask & ~pmask) ||
 1036                     ((rs->sc_dkdev.dk_bopenmask & pmask) &&
 1037                     (rs->sc_dkdev.dk_copenmask & pmask))) {
raidunlock(rs);
 1039                         return (EBUSY);
 1040                 }
 1042                 if ((retcode = rf_Shutdown(raidPtr)) == 0) {
pool_destroy(&rs->sc_cbufpool);
 1046                         /* It's no longer initialized... */
rs->sc_flags &= ~RAIDF_INITED;
 1049                         /* config_detach the device. */
config_detach(device_lookup(&raid_cd, unit), 0);
 1052                         /* Detach the disk. */
disk_detach(&rs->sc_dkdev);
 1054                 }
raidunlock(rs);
 1058                 return (retcode);
 1060         case RAIDFRAME_GET_COMPONENT_LABEL:
clabel_ptr = (RF_ComponentLabel_t **) data;
 1062                 /*
 1063                  * We need to read the component label for the disk indicated
 1064                  * by row,column in clabel.
 1065                  */
 1067                 /*
 1068                  * For practice, let's get it directly from disk, rather
 1069                  * than from the in-core copy.
 1070                  */
RF_Malloc( clabel, sizeof( RF_ComponentLabel_t ),
 1072                            (RF_ComponentLabel_t *));
 1073                 if (clabel == NULL)
 1074                         return (ENOMEM);
bzero((char *) clabel, sizeof(RF_ComponentLabel_t));
retcode = copyin( *clabel_ptr, clabel,
 1079                                   sizeof(RF_ComponentLabel_t));
 1081                 if (retcode) {
RF_Free( clabel, sizeof(RF_ComponentLabel_t));
 1083                         return(retcode);
 1084                 }
row = clabel->row;
column = clabel->column;
 1089                 if ((row < 0) || (row >= raidPtr->numRow) ||
 1090                     (column < 0) || (column >= raidPtr->numCol)) {
RF_Free( clabel, sizeof(RF_ComponentLabel_t));
 1092                         return(EINVAL);
 1093                 }
raidread_component_label(raidPtr->Disks[row][column].dev,
raidPtr->raid_cinfo[row][column].ci_vp, clabel );
retcode = copyout((caddr_t) clabel,
 1099                                   (caddr_t) *clabel_ptr,
 1100                                   sizeof(RF_ComponentLabel_t));
RF_Free( clabel, sizeof(RF_ComponentLabel_t));
 1102                 return (retcode);
 1104         case RAIDFRAME_SET_COMPONENT_LABEL:
clabel = (RF_ComponentLabel_t *) data;
 1107                 /* XXX check the label for valid stuff... */
 1108                 /*
 1109                  * Note that some things *should not* get modified --
 1110                  * the user should be re-initing the labels instead of
 1111                  * trying to patch things.
 1112                  */
 1114 #ifdef  RAIDDEBUG
printf("Got component label:\n");
printf("Version: %d\n",clabel->version);
printf("Serial Number: %d\n",clabel->serial_number);
printf("Mod counter: %d\n",clabel->mod_counter);
printf("Row: %d\n", clabel->row);
printf("Column: %d\n", clabel->column);
printf("Num Rows: %d\n", clabel->num_rows);
printf("Num Columns: %d\n", clabel->num_columns);
printf("Clean: %d\n", clabel->clean);
printf("Status: %d\n", clabel->status);
 1125 #endif  /* RAIDDEBUG */
row = clabel->row;
column = clabel->column;
 1130                 if ((row < 0) || (row >= raidPtr->numRow) ||
 1131                     (column < 0) || (column >= raidPtr->numCol)) {
 1132                         return(EINVAL);
 1133                 }
 1135                 /* XXX this isn't allowed to do anything for now :-) */
 1136 #if 0
raidwrite_component_label(raidPtr->Disks[row][column].dev,
raidPtr->raid_cinfo[row][column].ci_vp, clabel );
 1139 #endif
 1140                 return (0);
 1142         case RAIDFRAME_INIT_LABELS:
clabel = (RF_ComponentLabel_t *) data;
 1144                 /*
 1145                  * We only want the serial number from the above.
 1146                  * We get all the rest of the information from
 1147                  * the config that was used to create this RAID
 1148                  * set.
 1149                  */
raidPtr->serial_number = clabel->serial_number;
raid_init_component_label(raidPtr, &ci_label);
ci_label.serial_number = clabel->serial_number;
 1156                 for(row=0;row<raidPtr->numRow;row++) {
ci_label.row = row;
 1158                         for(column=0;column<raidPtr->numCol;column++) {
diskPtr = &raidPtr->Disks[row][column];
 1160                                 if (!RF_DEAD_DISK(diskPtr->status)) {
ci_label.partitionSize =
diskPtr->partitionSize;
ci_label.column = column;
raidwrite_component_label(
raidPtr->Disks[row][column].dev,
raidPtr->raid_cinfo[row][column].ci_vp,
 1167                                             &ci_label );
 1168                                 }
 1169                         }
 1170                 }
 1172                 return (retcode);
 1174         case RAIDFRAME_REWRITEPARITY:
 1176                 if (raidPtr->Layout.map->faultsTolerated == 0) {
 1177                         /* Parity for RAID 0 is trivially correct. */
raidPtr->parity_good = RF_RAID_CLEAN;
 1179                         return(0);
 1180                 }
 1183                 if (raidPtr->parity_rewrite_in_progress == 1) {
 1184                         /* Re-write is already in progress ! */
 1185                         return(EINVAL);
 1186                 }
retcode = RF_CREATE_THREAD(raidPtr->parity_rewrite_thread,
rf_RewriteParityThread,
raidPtr,"raid_parity");
 1192                 return (retcode);
 1194         case RAIDFRAME_SET_AUTOCONFIG:
d = rf_set_autoconfig(raidPtr, *(int *) data);
db1_printf(("New autoconfig value is: %d\n", d));
 1197                 *(int *) data = d;
 1198                 return (retcode);
 1200         case RAIDFRAME_SET_ROOT:
d = rf_set_rootpartition(raidPtr, *(int *) data);
db1_printf(("New rootpartition value is: %d\n", d));
 1203                 *(int *) data = d;
 1204                 return (retcode);
 1207         case RAIDFRAME_ADD_HOT_SPARE:
sparePtr = (RF_SingleComponent_t *) data;
memcpy( &hot_spare, sparePtr, sizeof(RF_SingleComponent_t));
retcode = rf_add_hot_spare(raidPtr, &hot_spare);
 1211                 return(retcode);
 1213         case RAIDFRAME_REMOVE_HOT_SPARE:
 1214                 return(retcode);
 1216         case RAIDFRAME_DELETE_COMPONENT:
componentPtr = (RF_SingleComponent_t *)data;
memcpy( &component, componentPtr,
 1219                         sizeof(RF_SingleComponent_t));
retcode = rf_delete_component(raidPtr, &component);
 1221                 return(retcode);
 1223         case RAIDFRAME_INCORPORATE_HOT_SPARE:
componentPtr = (RF_SingleComponent_t *)data;
memcpy( &component, componentPtr,
 1226                         sizeof(RF_SingleComponent_t));
retcode = rf_incorporate_hot_spare(raidPtr, &component);
 1228                 return(retcode);
 1230         case RAIDFRAME_REBUILD_IN_PLACE:
 1232                 if (raidPtr->Layout.map->faultsTolerated == 0) {
 1233                         /* Can't do this on a RAID 0 !! */
 1234                         return(EINVAL);
 1235                 }
 1237                 if (raidPtr->recon_in_progress == 1) {
 1238                         /* A reconstruct is already in progress ! */
 1239                         return(EINVAL);
 1240                 }
componentPtr = (RF_SingleComponent_t *) data;
memcpy( &component, componentPtr,
 1244                         sizeof(RF_SingleComponent_t));
row = component.row;
column = component.column;
db1_printf(("Rebuild: %d %d\n",row, column));
 1248                 if ((row < 0) || (row >= raidPtr->numRow) ||
 1249                     (column < 0) || (column >= raidPtr->numCol)) {
 1250                         return(EINVAL);
 1251                 }
RF_Malloc(rrcopy, sizeof(*rrcopy), (struct rf_recon_req *));
 1254                 if (rrcopy == NULL)
 1255                         return(ENOMEM);
rrcopy->raidPtr = (void *) raidPtr;
rrcopy->row = row;
rrcopy->col = column;
retcode = RF_CREATE_THREAD(raidPtr->recon_thread,
rf_ReconstructInPlaceThread,
rrcopy,"raid_reconip");
 1265                 return (retcode);
 1267         case RAIDFRAME_GET_INFO:
 1268                 if (!raidPtr->valid)
 1269                         return (ENODEV);
ucfgp = (RF_DeviceConfig_t **) data;
RF_Malloc(d_cfg, sizeof(RF_DeviceConfig_t),
 1272                           (RF_DeviceConfig_t *));
 1273                 if (d_cfg == NULL)
 1274                         return (ENOMEM);
bzero((char *) d_cfg, sizeof(RF_DeviceConfig_t));
d_cfg->rows = raidPtr->numRow;
d_cfg->cols = raidPtr->numCol;
d_cfg->ndevs = raidPtr->numRow * raidPtr->numCol;
 1279                 if (d_cfg->ndevs >= RF_MAX_DISKS) {
RF_Free(d_cfg, sizeof(RF_DeviceConfig_t));
 1281                         return (ENOMEM);
 1282                 }
d_cfg->nspares = raidPtr->numSpare;
 1284                 if (d_cfg->nspares >= RF_MAX_DISKS) {
RF_Free(d_cfg, sizeof(RF_DeviceConfig_t));
 1286                         return (ENOMEM);
 1287                 }
d_cfg->maxqdepth = raidPtr->maxQueueDepth;
d = 0;
 1290                 for (i = 0; i < d_cfg->rows; i++) {
 1291                         for (j = 0; j < d_cfg->cols; j++) {
d_cfg->devs[d] = raidPtr->Disks[i][j];
d++;
 1294                         }
 1295                 }
 1296                 for (j = d_cfg->cols, i = 0; i < d_cfg->nspares; i++, j++) {
d_cfg->spares[i] = raidPtr->Disks[0][j];
 1298                 }
retcode = copyout((caddr_t) d_cfg, (caddr_t) * ucfgp,
 1300                                   sizeof(RF_DeviceConfig_t));
RF_Free(d_cfg, sizeof(RF_DeviceConfig_t));
 1303                 return (retcode);
 1305         case RAIDFRAME_CHECK_PARITY:
 1306                 *(int *) data = raidPtr->parity_good;
 1307                 return (0);
 1309         case RAIDFRAME_RESET_ACCTOTALS:
bzero(&raidPtr->acc_totals, sizeof(raidPtr->acc_totals));
 1311                 return (0);
 1313         case RAIDFRAME_GET_ACCTOTALS:
totals = (RF_AccTotals_t *) data;
 1315                 *totals = raidPtr->acc_totals;
 1316                 return (0);
 1318         case RAIDFRAME_KEEP_ACCTOTALS:
raidPtr->keep_acc_totals = *(int *)data;
 1320                 return (0);
 1322         case RAIDFRAME_GET_SIZE:
 1323                 *(int *) data = raidPtr->totalSectors;
 1324                 return (0);
 1326         /* Fail a disk & optionally start reconstruction. */
 1327         case RAIDFRAME_FAIL_DISK:
rr = (struct rf_recon_req *)data;
 1330                 if (rr->row < 0 || rr->row >= raidPtr->numRow ||
rr->col < 0 || rr->col >= raidPtr->numCol)
 1332                         return (EINVAL);
db1_printf(("raid%d: Failing the disk: row: %d col: %d\n",
unit, rr->row, rr->col));
 1337                 /*
 1338                  * Make a copy of the recon request so that we don't
 1339                  * rely on the user's buffer.
 1340                  */
RF_Malloc(rrcopy, sizeof(*rrcopy), (struct rf_recon_req *));
 1342                 if (rrcopy == NULL)
 1343                         return(ENOMEM);
bcopy(rr, rrcopy, sizeof(*rr));
rrcopy->raidPtr = (void *)raidPtr;
retcode = RF_CREATE_THREAD(raidPtr->recon_thread,
rf_ReconThread,
rrcopy,"raid_recon");
 1350                 return (0);
 1352         /*
 1353          * Invoke a copyback operation after recon on whatever
 1354          * disk needs it, if any.
 1355          */
 1356         case RAIDFRAME_COPYBACK:
 1357                 if (raidPtr->Layout.map->faultsTolerated == 0) {
 1358                         /* This makes no sense on a RAID 0 !! */
 1359                         return(EINVAL);
 1360                 }
 1362                 if (raidPtr->copyback_in_progress == 1) {
 1363                         /* Copyback is already in progress ! */
 1364                         return(EINVAL);
 1365                 }
retcode = RF_CREATE_THREAD(raidPtr->copyback_thread,
rf_CopybackThread,
raidPtr,"raid_copyback");
 1370                 return (retcode);
 1372         /* Return the percentage completion of reconstruction. */
 1373         case RAIDFRAME_CHECK_RECON_STATUS:
 1374                 if (raidPtr->Layout.map->faultsTolerated == 0) {
 1375                         /*
 1376                          * This makes no sense on a RAID 0, so tell the
 1377                          * user it's done.
 1378                          */
 1379                         *(int *) data = 100;
 1380                         return(0);
 1381                 }
row = 0; /* XXX we only consider a single row... */
 1383                 if (raidPtr->status[row] != rf_rs_reconstructing)
 1384                         *(int *)data = 100;
 1385                 else
 1386                         *(int *)data =
raidPtr->reconControl[row]->percentComplete;
 1388                 return (0);
 1390         case RAIDFRAME_CHECK_RECON_STATUS_EXT:
progressInfoPtr = (RF_ProgressInfo_t **) data;
row = 0; /* XXX we only consider a single row... */
 1393                 if (raidPtr->status[row] != rf_rs_reconstructing) {
progressInfo.remaining = 0;
progressInfo.completed = 100;
progressInfo.total = 100;
 1397                 } else {
progressInfo.total =
raidPtr->reconControl[row]->numRUsTotal;
progressInfo.completed =
raidPtr->reconControl[row]->numRUsComplete;
progressInfo.remaining = progressInfo.total -
progressInfo.completed;
 1404                 }
retcode = copyout((caddr_t) &progressInfo,
 1406                                   (caddr_t) *progressInfoPtr,
 1407                                   sizeof(RF_ProgressInfo_t));
 1408                 return (retcode);
 1410         case RAIDFRAME_CHECK_PARITYREWRITE_STATUS:
 1411                 if (raidPtr->Layout.map->faultsTolerated == 0) {
 1412                         /*
 1413                          * This makes no sense on a RAID 0, so tell the
 1414                          * user it's done.
 1415                          */
 1416                         *(int *) data = 100;
 1417                         return(0);
 1418                 }
 1419                 if (raidPtr->parity_rewrite_in_progress == 1) {
 1420                         *(int *) data = 100 *
raidPtr->parity_rewrite_stripes_done /
raidPtr->Layout.numStripe;
 1423                 } else {
 1424                         *(int *) data = 100;
 1425                 }
 1426                 return (0);
 1428         case RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT:
progressInfoPtr = (RF_ProgressInfo_t **) data;
 1430                 if (raidPtr->parity_rewrite_in_progress == 1) {
progressInfo.total = raidPtr->Layout.numStripe;
progressInfo.completed =
raidPtr->parity_rewrite_stripes_done;
progressInfo.remaining = progressInfo.total -
progressInfo.completed;
 1436                 } else {
progressInfo.remaining = 0;
progressInfo.completed = 100;
progressInfo.total = 100;
 1440                 }
retcode = copyout((caddr_t) &progressInfo,
 1442                                   (caddr_t) *progressInfoPtr,
 1443                                   sizeof(RF_ProgressInfo_t));
 1444                 return (retcode);
 1446         case RAIDFRAME_CHECK_COPYBACK_STATUS:
 1447                 if (raidPtr->Layout.map->faultsTolerated == 0) {
 1448                         /* This makes no sense on a RAID 0 !! */
 1449                         *(int *) data = 100;
 1450                         return(0);
 1451                 }
 1452                 if (raidPtr->copyback_in_progress == 1) {
 1453                         *(int *) data = 100 * raidPtr->copyback_stripes_done /
raidPtr->Layout.numStripe;
 1455                 } else {
 1456                         *(int *) data = 100;
 1457                 }
 1458                 return (0);
 1460         case RAIDFRAME_CHECK_COPYBACK_STATUS_EXT:
progressInfoPtr = (RF_ProgressInfo_t **) data;
 1462                 if (raidPtr->copyback_in_progress == 1) {
progressInfo.total = raidPtr->Layout.numStripe;
progressInfo.completed =
raidPtr->copyback_stripes_done;
progressInfo.remaining = progressInfo.total -
progressInfo.completed;
 1468                 } else {
progressInfo.remaining = 0;
progressInfo.completed = 100;
progressInfo.total = 100;
 1472                 }
retcode = copyout((caddr_t) &progressInfo,
 1474                                   (caddr_t) *progressInfoPtr,
 1475                                   sizeof(RF_ProgressInfo_t));
 1476                 return (retcode);
 1478 #if 0
 1479         case RAIDFRAME_SPARET_WAIT:
 1480                 /*
 1481                  * The sparetable daemon calls this to wait for the
 1482                  * kernel to need a spare table.
 1483                  * This ioctl does not return until a spare table is needed.
 1484                  * XXX -- Calling mpsleep here in the ioctl code is almost
 1485                  * certainly wrong and evil. -- XXX
 1486                  * XXX -- I should either compute the spare table in the
 1487                  * kernel, or have a different. -- XXX
 1488                  * XXX -- Interface (a different character device) for
 1489                  * delivering the table. -- XXX
 1490                  */
RF_LOCK_MUTEX(rf_sparet_wait_mutex);
 1492                 while (!rf_sparet_wait_queue)
mpsleep(&rf_sparet_wait_queue, (PZERO + 1) | PCATCH,
 1494                             "sparet wait", 0,
 1495                             (void *)simple_lock_addr(rf_sparet_wait_mutex),
MS_LOCK_SIMPLE);
waitreq = rf_sparet_wait_queue;
rf_sparet_wait_queue = rf_sparet_wait_queue->next;
RF_UNLOCK_MUTEX(rf_sparet_wait_mutex);
 1501                 *((RF_SparetWait_t *)data) = *waitreq;
RF_Free(waitreq, sizeof *waitreq);
 1504                 return (0);
 1506         case RAIDFRAME_ABORT_SPARET_WAIT:
 1507                 /*
 1508                  * Wakes up a process waiting on SPARET_WAIT and puts an
 1509                  * error code in it that will cause the dameon to exit.
 1510                  */
RF_Malloc(waitreq, sizeof (*waitreq), (RF_SparetWait_t *));
waitreq->fcol = -1;
RF_LOCK_MUTEX(rf_sparet_wait_mutex);
waitreq->next = rf_sparet_wait_queue;
rf_sparet_wait_queue = waitreq;
RF_UNLOCK_MUTEX(rf_sparet_wait_mutex);
wakeup(&rf_sparet_wait_queue);
 1518                 return (0);
 1520         case RAIDFRAME_SEND_SPARET:
 1521                 /*
 1522                  * Used by the spare table daemon to deliver a spare table
 1523                  * into the kernel.
 1524                  */
 1526                 /* Install the spare table. */
retcode = rf_SetSpareTable(raidPtr,*(void **)data);
 1529                 /*
 1530                  * Respond to the requestor.  The return status of the
 1531                  * spare table installation is passed in the "fcol" field.
 1532                  */
RF_Malloc(waitreq, sizeof *waitreq, (RF_SparetWait_t *));
waitreq->fcol = retcode;
RF_LOCK_MUTEX(rf_sparet_wait_mutex);
waitreq->next = rf_sparet_resp_queue;
rf_sparet_resp_queue = waitreq;
wakeup(&rf_sparet_resp_queue);
RF_UNLOCK_MUTEX(rf_sparet_wait_mutex);
 1541                 return (retcode);
 1542 #endif
 1543         /* Fall through to the os-specific code below. */
 1544         default:
 1545                 break;
 1546         }
 1548         if (!raidPtr->valid)
 1549                 return (EINVAL);
 1551         /*
 1552          * Add support for "regular" device ioctls here.
 1553          */
 1554         switch (cmd) {
 1555         case DIOCGDINFO:
 1556                 *(struct disklabel *)data = *(rs->sc_dkdev.dk_label);
 1557                 break;
 1559         case DIOCGPART:
 1560                 ((struct partinfo *)data)->disklab = rs->sc_dkdev.dk_label;
 1561                 ((struct partinfo *)data)->part =
 1562                     &rs->sc_dkdev.dk_label->d_partitions[DISKPART(dev)];
 1563                 break;
 1565         case DIOCWDINFO:
 1566         case DIOCSDINFO:
 1567         {
 1568                 struct disklabel *lp;
lp = (struct disklabel *)data;
 1571                 if ((error = raidlock(rs)) != 0)
 1572                         return (error);
rs->sc_flags |= RAIDF_LABELLING;
error = setdisklabel(rs->sc_dkdev.dk_label, lp, 0);
 1577                 if (error == 0) {
 1578                         if (cmd == DIOCWDINFO)
error = writedisklabel(DISKLABELDEV(dev),
raidstrategy, rs->sc_dkdev.dk_label);
 1581                 }
rs->sc_flags &= ~RAIDF_LABELLING;
raidunlock(rs);
 1587                 if (error)
 1588                         return (error);
 1589                 break;
 1590         }
 1592         case DIOCWLABEL:
 1593                 if (*(int *)data != 0)
rs->sc_flags |= RAIDF_WLABEL;
 1595                 else
rs->sc_flags &= ~RAIDF_WLABEL;
 1597                 break;
 1599         case DIOCGPDINFO:
raidgetdisklabel(dev, (struct disklabel *)data, 1);
 1601                 break;
 1603         default:
retcode = ENOTTY;
 1605         }
 1607         return (retcode);
 1608 }
 1610 /*
 1611  * raidinit -- Complete the rest of the initialization for the
 1612  * RAIDframe device.
 1613  */
 1614 void
raidinit(RF_Raid_t *raidPtr)
 1616 {
 1617         struct raid_softc *rs;
 1618         struct cfdata   *cf;
 1619         int unit;
unit = raidPtr->raidid;
rs = &raid_softc[unit];
pool_init(&rs->sc_cbufpool, sizeof(struct raidbuf), 0,
 1625                 0, 0, "raidpl", NULL);
 1627         /* XXX should check return code first... */
rs->sc_flags |= RAIDF_INITED;
 1630         /* XXX doesn't check bounds. */
snprintf(rs->sc_xname, sizeof rs->sc_xname, "raid%d", unit);
rs->sc_dkdev.dk_name = rs->sc_xname;
 1635         /*
 1636          * disk_attach actually creates space for the CPU disklabel, among
 1637          * other things, so it's critical to call this *BEFORE* we try
 1638          * putzing with disklabels.
 1639          */
disk_attach(&rs->sc_dkdev);
 1642         /*
 1643          * XXX There may be a weird interaction here between this, and
 1644          * protectedSectors, as used in RAIDframe.
 1645          */
rs->sc_size = raidPtr->totalSectors;
 1648         /*
 1649          * config_attach the raid device into the device tree.
 1650          * For autoconf rootdev selection...
 1651          */
cf = malloc(sizeof(struct cfdata), M_RAIDFRAME, M_NOWAIT);
 1653         if (cf == NULL) {
printf("WARNING: no memory for cfdata struct\n");
 1655                 return;
 1656         }
bzero(cf, sizeof(struct cfdata));
cf->cf_attach = &raid_ca;
cf->cf_driver = &raid_cd;
cf->cf_unit   = unit;
config_attach(NULL, cf, NULL, NULL);
 1664 }
 1666 /*
 1667  * Wake up the daemon & tell it to get us a spare table.
 1668  * XXX
 1669  * The entries in the queues should be tagged with the raidPtr so that
 1670  * in the extremely rare case that two recons happen at once, we know
 1671  * which devices were requesting a spare table.
 1672  * XXX
 1673  *
 1674  * XXX This code is not currently used. GO
 1675  */
 1676 int
rf_GetSpareTableFromDaemon(RF_SparetWait_t *req)
 1678 {
 1679         int retcode;
RF_LOCK_MUTEX(rf_sparet_wait_mutex);
req->next = rf_sparet_wait_queue;
rf_sparet_wait_queue = req;
wakeup(&rf_sparet_wait_queue);
 1686         /* mpsleep unlocks the mutex. */
 1687         while (!rf_sparet_resp_queue) {
tsleep(&rf_sparet_resp_queue, PRIBIO,
 1689                     "RAIDframe getsparetable", 0);
 1690         }
req = rf_sparet_resp_queue;
rf_sparet_resp_queue = req->next;
RF_UNLOCK_MUTEX(rf_sparet_wait_mutex);
retcode = req->fcol;
 1696         /* This is not the same req as we alloc'd. */
RF_Free(req, sizeof *req);
 1698         return (retcode);
 1699 }
 1701 /*
 1702  * A wrapper around rf_DoAccess that extracts appropriate info from the
 1703  * bp and passes it down.
 1704  * Any calls originating in the kernel must use non-blocking I/O.
 1705  * Do some extra sanity checking to return "appropriate" error values for
 1706  * certain conditions (to make some standard utilities work).
 1707  *
 1708  * Formerly known as: rf_DoAccessKernel
 1709  */
 1710 void
raidstart(RF_Raid_t *raidPtr)
 1712 {
RF_SectorCount_t num_blocks, pb, sum;
RF_RaidAddr_t raid_addr;
 1715         int retcode;
 1716         struct partition *pp;
daddr64_t blocknum;
 1718         int unit;
 1719         struct raid_softc *rs;
 1720         int     do_async;
 1721         struct buf *bp;
unit = raidPtr->raidid;
rs = &raid_softc[unit];
 1726         /* Quick check to see if anything has died recently. */
RF_LOCK_MUTEX(raidPtr->mutex);
 1728         if (raidPtr->numNewFailures > 0) {
rf_update_component_labels(raidPtr,
RF_NORMAL_COMPONENT_UPDATE);
raidPtr->numNewFailures--;
 1732         }
RF_UNLOCK_MUTEX(raidPtr->mutex);
 1735         /* Check to see if we're at the limit... */
RF_LOCK_MUTEX(raidPtr->mutex);
 1737         while (raidPtr->openings > 0) {
RF_UNLOCK_MUTEX(raidPtr->mutex);
bp = rs->sc_q.b_actf;
 1741                 if (bp == NULL) {
 1742                         /* Nothing more to do. */
 1743                         return;
 1744                 }
rs->sc_q.b_actf = bp->b_actf;
 1747                 /*
 1748                  * Ok, for the bp we have here, bp->b_blkno is relative to the
 1749                  * partition... We need to make it absolute to the underlying
 1750                  * device...
 1751                  */
blocknum = bp->b_blkno;
 1754                 if (DISKPART(bp->b_dev) != RAW_PART) {
pp = &rs->sc_dkdev.dk_label->d_partitions[DISKPART(bp->b_dev)];
blocknum += DL_GETPOFFSET(pp);
 1757                 }
db1_printf(("Blocks: %d, %lld\n", (int) bp->b_blkno,
blocknum));
db1_printf(("bp->b_bcount = %d\n", (int) bp->b_bcount));
db1_printf(("bp->b_resid = %d\n", (int) bp->b_resid));
 1765                 /*
 1766                  * *THIS* is where we adjust what block we're going to...
 1767                  * But DO NOT TOUCH bp->b_blkno !!!
 1768                  */
raid_addr = blocknum;
num_blocks = bp->b_bcount >> raidPtr->logBytesPerSector;
pb = (bp->b_bcount & raidPtr->sectorMask) ? 1 : 0;
sum = raid_addr + num_blocks + pb;
 1774                 if (1 || rf_debugKernelAccess) {
db1_printf(("raid_addr=%d sum=%d num_blocks=%d(+%d)"
 1776                             " (%d)\n", (int)raid_addr, (int)sum,
 1777                             (int)num_blocks, (int)pb, (int)bp->b_resid));
 1778                 }
 1779                 if ((sum > raidPtr->totalSectors) || (sum < raid_addr)
 1780                     || (sum < num_blocks) || (sum < pb)) {
bp->b_error = ENOSPC;
bp->b_flags |= B_ERROR;
bp->b_resid = bp->b_bcount;
 1784                         /* db1_printf(("%s: Calling biodone on 0x%x\n",
 1785                             __func__, bp)); */
splassert(IPL_BIO);
biodone(bp);
RF_LOCK_MUTEX(raidPtr->mutex);
 1789                         continue;
 1790                 }
 1791                 /*
 1792                  * XXX rf_DoAccess() should do this, not just DoAccessKernel().
 1793                  */
 1795                 if (bp->b_bcount & raidPtr->sectorMask) {
bp->b_error = EINVAL;
bp->b_flags |= B_ERROR;
bp->b_resid = bp->b_bcount;
 1799                         /* db1_printf(("%s: Calling biodone on 0x%x\n",
 1800                             __func__, bp)); */
splassert(IPL_BIO);
biodone(bp);
RF_LOCK_MUTEX(raidPtr->mutex);
 1804                         continue;
 1806                 }
db1_printf(("Calling DoAccess..\n"));
RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr->openings--;
RF_UNLOCK_MUTEX(raidPtr->mutex);
 1814                 /*
 1815                  * Everything is async.
 1816                  */
do_async = 1;
disk_busy(&rs->sc_dkdev);
 1821                 /*
 1822                  * XXX we're still at splbio() here...  Do we *really*
 1823                  * need to be ?
 1824                  */
 1826                 /*
 1827                  * Don't ever condition on bp->b_flags & B_WRITE.
 1828                  * Always condition on B_READ instead.
 1829                  */
retcode = rf_DoAccess(raidPtr, (bp->b_flags & B_READ) ?
RF_IO_TYPE_READ : RF_IO_TYPE_WRITE,
do_async, raid_addr, num_blocks,
bp->b_data, bp, NULL, NULL,
RF_DAG_NONBLOCKING_IO, NULL, NULL, NULL);
RF_LOCK_MUTEX(raidPtr->mutex);
 1838         }
RF_UNLOCK_MUTEX(raidPtr->mutex);
 1840 }
 1842 /* Invoke an I/O from kernel mode.  Disk queue should be locked upon entry. */
 1844 int
rf_DispatchKernelIO(RF_DiskQueue_t *queue, RF_DiskQueueData_t *req)
 1846 {
 1847         int op = (req->type == RF_IO_TYPE_READ) ? B_READ : B_WRITE;
 1848         struct buf *bp;
 1849         struct raidbuf *raidbp = NULL;
 1850         struct raid_softc *rs;
 1851         int unit;
 1852         /*int s = splbio();*/   /* Want to test this. */
 1854         /*
 1855          * XXX along with the vnode, we also need the softc associated with
 1856          * this device...
 1857          */
req->queue = queue;
unit = queue->raidPtr->raidid;
db1_printf(("DispatchKernelIO unit: %d\n", unit));
 1864         if (unit >= numraid) {
printf("Invalid unit number: %d %d\n", unit, numraid);
panic("Invalid Unit number in rf_DispatchKernelIO");
 1867         }
rs = &raid_softc[unit];
bp = req->bp;
 1873 #if 1
 1874         /*
 1875          * XXX When there is a physical disk failure, someone is passing
 1876          * us a buffer that contains old stuff !!  Attempt to deal with
 1877          * this problem without taking a performance hit...
 1878          * (not sure where the real bug is; it's buried in RAIDframe
 1879          * somewhere) :-( GO )
 1880          */
 1881         if (bp->b_flags & B_ERROR) {
bp->b_flags &= ~B_ERROR;
 1883         }
 1884         if (bp->b_error!=0) {
bp->b_error = 0;
 1886         }
 1887 #endif
raidbp = RAIDGETBUF(rs);
raidbp->rf_flags = 0;   /* XXX not really used anywhere... */
 1893         /*
 1894          * Context for raidiodone.
 1895          */
raidbp->rf_obp = bp;
raidbp->req = req;
LIST_INIT(&raidbp->rf_buf.b_dep);
 1901         switch (req->type) {
 1902         case RF_IO_TYPE_NOP:
 1903                 /* Used primarily to unlock a locked queue. */
db1_printf(("rf_DispatchKernelIO: NOP to r %d c %d\n",
queue->row, queue->col));
 1908                 /* XXX need to do something extra here... */
 1910                 /*
 1911                  * I'm leaving this in, as I've never actually seen it
 1912                  * used, and I'd like folks to report it... GO
 1913                  */
db1_printf(("WAKEUP CALLED\n"));
queue->numOutstanding++;
 1917                 /* XXX need to glue the original buffer into this ?? */
rf_KernelWakeupFunc(&raidbp->rf_buf);
 1920                 break;
 1922         case RF_IO_TYPE_READ:
 1923         case RF_IO_TYPE_WRITE:
 1924                 if (req->tracerec) {
RF_ETIMER_START(req->tracerec->timer);
 1926                 }
rf_InitBP(&raidbp->rf_buf, queue->rf_cinfo->ci_vp,
op | bp->b_flags, queue->rf_cinfo->ci_dev,
req->sectorOffset, req->numSector,
req->buf, rf_KernelWakeupFunc, (void *)req,
queue->raidPtr->logBytesPerSector, req->b_proc);
 1934                 if (rf_debugKernelAccess) {
db1_printf(("dispatch: bp->b_blkno = %ld\n",
 1936                             (long)bp->b_blkno));
 1937                 }
queue->numOutstanding++;
queue->last_deq_sector = req->sectorOffset;
 1941                 /*
 1942                  * Acc wouldn't have been let in if there were any
 1943                  * pending reqs at any other priority.
 1944                  */
queue->curPriority = req->priority;
db1_printf(("Going for %c to unit %d row %d col %d\n",
req->type, unit, queue->row, queue->col));
db1_printf(("sector %d count %d (%d bytes) %d\n",
 1950                     (int)req->sectorOffset, (int)req->numSector,
 1951                     (int)(req->numSector << queue->raidPtr->logBytesPerSector),
 1952                     (int)queue->raidPtr->logBytesPerSector));
 1953                 if ((raidbp->rf_buf.b_flags & B_READ) == 0) {
raidbp->rf_buf.b_vp->v_numoutput++;
 1955                 }
VOP_STRATEGY(&raidbp->rf_buf);
 1958                 break;
 1960         default:
panic("bad req->type in rf_DispatchKernelIO");
 1962         }
db1_printf(("Exiting from DispatchKernelIO\n"));
 1964         /*splx(s);*/    /* want to test this */
 1965         return (0);
 1966 }
 1968 /*
 1969  * This is the callback function associated with a I/O invoked from
 1970  * kernel code.
 1971  */
 1972 void
rf_KernelWakeupFunc(struct buf *vbp)
 1974 {
RF_DiskQueueData_t *req = NULL;
RF_DiskQueue_t *queue;
 1977         struct raidbuf *raidbp = (struct raidbuf *)vbp;
 1978         struct buf *bp;
 1979         struct raid_softc *rs;
 1980         int unit;
 1981         int s;
s = splbio();
db1_printf(("recovering the request queue:\n"));
req = raidbp->req;
bp = raidbp->rf_obp;
queue = (RF_DiskQueue_t *)req->queue;
 1991         if (raidbp->rf_buf.b_flags & B_ERROR) {
bp->b_flags |= B_ERROR;
bp->b_error =
raidbp->rf_buf.b_error ? raidbp->rf_buf.b_error : EIO;
 1995         }
 1997 #if 1
 1998         /* XXX Methinks this could be wrong... */
bp->b_resid = raidbp->rf_buf.b_resid;
 2000 #endif
 2002         if (req->tracerec) {
RF_ETIMER_STOP(req->tracerec->timer);
RF_ETIMER_EVAL(req->tracerec->timer);
RF_LOCK_MUTEX(rf_tracing_mutex);
req->tracerec->diskwait_us +=
RF_ETIMER_VAL_US(req->tracerec->timer);
req->tracerec->phys_io_us +=
RF_ETIMER_VAL_US(req->tracerec->timer);
req->tracerec->num_phys_ios++;
RF_UNLOCK_MUTEX(rf_tracing_mutex);
 2012         }
bp->b_bcount = raidbp->rf_buf.b_bcount; /* XXXX ?? */
unit = queue->raidPtr->raidid;  /* *Much* simpler :-> */
 2018         /*
 2019          * XXX Ok, let's get aggressive...  If B_ERROR is set, let's go
 2020          * ballistic, and mark the component as hosed...
 2021          */
 2022         if (bp->b_flags & B_ERROR) {
 2023                 /* Mark the disk as dead but only mark it once... */
 2024                 if (queue->raidPtr->Disks[queue->row][queue->col].status ==
rf_ds_optimal) {
printf("raid%d: IO Error.  Marking %s as failed.\n",
unit,
queue->raidPtr->
Disks[queue->row][queue->col].devname);
queue->raidPtr->Disks[queue->row][queue->col].status =
rf_ds_failed;
queue->raidPtr->status[queue->row] = rf_rs_degraded;
queue->raidPtr->numFailures++;
queue->raidPtr->numNewFailures++;
 2035                 } else {
 2036                         /* Disk is already dead... */
 2037                         /* printf("Disk already marked as dead!\n"); */
 2038                 }
 2039         }
rs = &raid_softc[unit];
RAIDPUTBUF(rs, raidbp);
rf_DiskIOComplete(queue, req, (bp->b_flags & B_ERROR) ? 1 : 0);
 2045         (req->CompleteFunc)(req->argument, (bp->b_flags & B_ERROR) ? 1 : 0);
splx(s);
 2048 }
 2050 /*
 2051  * Initialize a buf structure for doing an I/O in the kernel.
 2052  */
 2053 void
rf_InitBP(
 2055         struct buf       *bp,
 2056         struct vnode     *b_vp,
 2057         unsigned          rw_flag,
dev_t             dev,
RF_SectorNum_t    startSect,
RF_SectorCount_t  numSect,
caddr_t           buf,
 2062         void            (*cbFunc)(struct buf *),
 2063         void             *cbArg,
 2064         int               logBytesPerSector,
 2065         struct proc      *b_proc
 2066 )
 2067 {
 2068         /*bp->b_flags = B_PHYS | rw_flag;*/
bp->b_flags = B_CALL | rw_flag; /* XXX need B_PHYS here too ??? */
bp->b_bcount = numSect << logBytesPerSector;
bp->b_bufsize = bp->b_bcount;
bp->b_error = 0;
bp->b_dev = dev;
bp->b_data = buf;
bp->b_blkno = startSect;
bp->b_resid = bp->b_bcount;     /* XXX is this right !??!?!! */
 2077         if (bp->b_bcount == 0) {
panic("bp->b_bcount is zero in rf_InitBP!!");
 2079         }
bp->b_proc = b_proc;
bp->b_iodone = cbFunc;
bp->b_vp = b_vp;
LIST_INIT(&bp->b_dep);
 2084 }
 2086 void
raidgetdefaultlabel(RF_Raid_t *raidPtr, struct raid_softc *rs,
 2088     struct disklabel *lp)
 2089 {
db1_printf(("Building a default label...\n"));
bzero(lp, sizeof(*lp));
 2093         /* Fabricate a label... */
DL_SETDSIZE(lp, raidPtr->totalSectors);
lp->d_secsize = raidPtr->bytesPerSector;
lp->d_nsectors = raidPtr->Layout.dataSectorsPerStripe;
lp->d_ntracks = 4 * raidPtr->numCol;
lp->d_ncylinders = raidPtr->totalSectors /
 2099             (lp->d_nsectors * lp->d_ntracks);
lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
strncpy(lp->d_typename, "raid", sizeof(lp->d_typename));
lp->d_type = DTYPE_RAID;
strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname));
lp->d_rpm = 3600;
lp->d_flags = 0;
lp->d_interleave = 1;
lp->d_version = 1;
DL_SETPOFFSET(&lp->d_partitions[RAW_PART], 0);
DL_SETPSIZE(&lp->d_partitions[RAW_PART], raidPtr->totalSectors);
lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED;
lp->d_npartitions = RAW_PART + 1;
lp->d_magic = DISKMAGIC;
lp->d_magic2 = DISKMAGIC;
lp->d_checksum = dkcksum(rs->sc_dkdev.dk_label);
 2118 }
 2120 /*
 2121  * Read the disklabel from the raid device.
 2122  * If one is not present, fake one up.
 2123  */
 2124 void
raidgetdisklabel(dev_t dev, struct disklabel *lp, int spoofonly)
 2126 {
 2127         int unit = DISKUNIT(dev);
 2128         struct raid_softc *rs = &raid_softc[unit];
 2129         char *errstring;
RF_Raid_t *raidPtr;
 2131         int i;
 2132         struct partition *pp;
db1_printf(("Getting the disklabel...\n"));
bzero(lp, sizeof(*lp));
raidPtr = raidPtrs[unit];
raidgetdefaultlabel(raidPtr, rs, lp);
 2142         /*
 2143          * Call the generic disklabel extraction routine.
 2144          */
errstring = readdisklabel(DISKLABELDEV(dev), raidstrategy, lp,
spoofonly);
 2147         if (errstring) {
 2148                 /*printf("%s: %s\n", rs->sc_xname, errstring);*/
 2149                 return;
 2150         }
 2152         /*
 2153          * Sanity check whether the found disklabel is valid.
 2154          *
 2155          * This is necessary since total size of the raid device
 2156          * may vary when an interleave is changed even though exactly
 2157          * same componets are used, and old disklabel may used
 2158          * if that is found.
 2159          */
 2160 #ifdef  RAIDDEBUG
 2161         if (DL_GETDSIZE(lp) != rs->sc_size)
printf("WARNING: %s: "
 2163                     "total sector size in disklabel (%d) != "
 2164                     "the size of raid (%ld)\n", rs->sc_xname,
DL_GETDSIZE(lp), (long) rs->sc_size);
 2166 #endif  /* RAIDDEBUG */
 2167         for (i = 0; i < lp->d_npartitions; i++) {
pp = &lp->d_partitions[i];
 2169                 if (DL_GETPOFFSET(pp) + DL_GETPSIZE(pp) > rs->sc_size)
printf("WARNING: %s: end of partition `%c' "
 2171                             "exceeds the size of raid (%ld)\n",
rs->sc_xname, 'a' + i, (long) rs->sc_size);
 2173         }
 2174 }
 2176 /*
 2177  * Lookup the provided name in the filesystem.  If the file exists,
 2178  * is a valid block device, and isn't being used by anyone else,
 2179  * set *vpp to the file's vnode.
 2180  * You'll find the original of this in ccd.c
 2181  */
 2182 int
raidlookup(char *path, struct proc *p, struct vnode **vpp /* result */)
 2184 {
 2185         struct nameidata nd;
 2186         struct vnode *vp;
 2187         struct vattr va;
 2188         int error;
NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, path, p);
 2191         if ((error = vn_open(&nd, FREAD|FWRITE, 0)) != 0) {
 2192 #ifdef  RAIDDEBUG
printf("RAIDframe: vn_open returned %d\n", error);
 2194 #endif  /* RAIDDEBUG */
 2195                 return (error);
 2196         }
vp = nd.ni_vp;
 2198         if (vp->v_usecount > 1) {
VOP_UNLOCK(vp, 0, p);
 2200                 (void)vn_close(vp, FREAD|FWRITE, p->p_ucred, p);
 2201                 return (EBUSY);
 2202         }
 2203         if ((error = VOP_GETATTR(vp, &va, p->p_ucred, p)) != 0) {
VOP_UNLOCK(vp, 0, p);
 2205                 (void)vn_close(vp, FREAD|FWRITE, p->p_ucred, p);
 2206                 return (error);
 2207         }
 2208         /* XXX: eventually we should handle VREG, too. */
 2209         if (va.va_type != VBLK) {
VOP_UNLOCK(vp, 0, p);
 2211                 (void)vn_close(vp, FREAD|FWRITE, p->p_ucred, p);
 2212                 return (ENOTBLK);
 2213         }
VOP_UNLOCK(vp, 0, p);
 2215         *vpp = vp;
 2216         return (0);
 2217 }
 2219 /*
 2220  * Wait interruptibly for an exclusive lock.
 2221  *
 2222  * XXX
 2223  * Several drivers do this; it should be abstracted and made MP-safe.
 2224  * (Hmm... where have we seen this warning before :->  GO )
 2225  */
 2226 int
raidlock(struct raid_softc *rs)
 2228 {
 2229         int error;
 2231         while ((rs->sc_flags & RAIDF_LOCKED) != 0) {
rs->sc_flags |= RAIDF_WANTED;
 2233                 if ((error = tsleep(rs, PRIBIO | PCATCH, "raidlck", 0)) != 0)
 2234                         return (error);
 2235         }
rs->sc_flags |= RAIDF_LOCKED;
 2237         return (0);
 2238 }
 2240 /*
 2241  * Unlock and wake up any waiters.
 2242  */
 2243 void
raidunlock(struct raid_softc *rs)
 2245 {
rs->sc_flags &= ~RAIDF_LOCKED;
 2247         if ((rs->sc_flags & RAIDF_WANTED) != 0) {
rs->sc_flags &= ~RAIDF_WANTED;
wakeup(rs);
 2250         }
 2251 }
 2254 #define RF_COMPONENT_INFO_OFFSET        16384   /* bytes */
 2255 #define RF_COMPONENT_INFO_SIZE           1024   /* bytes */
 2257 int
raidmarkclean(dev_t dev, struct vnode *b_vp, int mod_counter)
 2259 {
RF_ComponentLabel_t clabel;
raidread_component_label(dev, b_vp, &clabel);
clabel.mod_counter = mod_counter;
clabel.clean = RF_RAID_CLEAN;
raidwrite_component_label(dev, b_vp, &clabel);
 2265         return(0);
 2266 }
 2269 int
raidmarkdirty(dev_t dev, struct vnode *b_vp, int mod_counter)
 2271 {
RF_ComponentLabel_t clabel;
raidread_component_label(dev, b_vp, &clabel);
clabel.mod_counter = mod_counter;
clabel.clean = RF_RAID_DIRTY;
raidwrite_component_label(dev, b_vp, &clabel);
 2277         return(0);
 2278 }
 2280 /* ARGSUSED */
 2281 int
raidread_component_label(dev_t dev, struct vnode *b_vp,
RF_ComponentLabel_t *clabel)
 2284 {
 2285         struct buf *bp;
 2286         int error;
 2288         /*
 2289          * XXX should probably ensure that we don't try to do this if
 2290          * someone has changed rf_protected_sectors.
 2291          */
 2293         if (b_vp == NULL) {
 2294                 /*
 2295                  * For whatever reason, this component is not valid.
 2296                  * Don't try to read a component label from it.
 2297                  */
 2298                 return(EINVAL);
 2299         }
 2301         /* Get a block of the appropriate size... */
bp = geteblk((int)RF_COMPONENT_INFO_SIZE);
bp->b_dev = dev;
 2305         /* Get our ducks in a row for the read. */
bp->b_blkno = RF_COMPONENT_INFO_OFFSET / DEV_BSIZE;
bp->b_bcount = RF_COMPONENT_INFO_SIZE;
bp->b_flags |= B_READ;
bp->b_resid = RF_COMPONENT_INFO_SIZE / DEV_BSIZE;
 2311         (*bdevsw[major(bp->b_dev)].d_strategy)(bp);
error = biowait(bp);
 2315         if (!error) {
memcpy(clabel, bp->b_data, sizeof(RF_ComponentLabel_t));
 2317 #if 0
rf_print_component_label( clabel );
 2319 #endif
 2320         } else {
db1_printf(("Failed to read RAID component label!\n"));
 2322         }
brelse(bp);
 2325         return(error);
 2326 }
 2328 /* ARGSUSED */
 2329 int
raidwrite_component_label(dev_t dev, struct vnode *b_vp,
RF_ComponentLabel_t *clabel)
 2332 {
 2333         struct buf *bp;
 2334         int error;
 2336         /* Get a block of the appropriate size... */
bp = geteblk((int)RF_COMPONENT_INFO_SIZE);
bp->b_dev = dev;
 2340         /* Get our ducks in a row for the write. */
bp->b_blkno = RF_COMPONENT_INFO_OFFSET / DEV_BSIZE;
bp->b_bcount = RF_COMPONENT_INFO_SIZE;
bp->b_flags |= B_WRITE;
bp->b_resid = RF_COMPONENT_INFO_SIZE / DEV_BSIZE;
memset(bp->b_data, 0, RF_COMPONENT_INFO_SIZE );
memcpy(bp->b_data, clabel, sizeof(RF_ComponentLabel_t));
 2350         (*bdevsw[major(bp->b_dev)].d_strategy)(bp);
error = biowait(bp);
brelse(bp);
 2353         if (error) {
printf("Failed to write RAID component info!\n");
 2355         }
 2357         return(error);
 2358 }
 2360 void
rf_markalldirty(RF_Raid_t *raidPtr)
 2362 {
RF_ComponentLabel_t clabel;
 2364         int r,c;
raidPtr->mod_counter++;
 2367         for (r = 0; r < raidPtr->numRow; r++) {
 2368                 for (c = 0; c < raidPtr->numCol; c++) {
 2369                         /*
 2370                          * We don't want to touch (at all) a disk that has
 2371                          * failed.
 2372                          */
 2373                         if (!RF_DEAD_DISK(raidPtr->Disks[r][c].status)) {
raidread_component_label(
raidPtr->Disks[r][c].dev,
raidPtr->raid_cinfo[r][c].ci_vp, &clabel);
 2377                                 if (clabel.status == rf_ds_spared) {
 2378                                         /*
 2379                                          * XXX do something special...
 2380                                          * But whatever you do, don't
 2381                                          * try to access it !!!
 2382                                          */
 2383                                 } else {
 2384 #if 0
clabel.status =
raidPtr->Disks[r][c].status;
raidwrite_component_label(
raidPtr->Disks[r][c].dev,
raidPtr->raid_cinfo[r][c].ci_vp,
 2390                                             &clabel);
 2391 #endif
raidmarkdirty(
raidPtr->Disks[r][c].dev,
raidPtr->raid_cinfo[r][c].ci_vp,
raidPtr->mod_counter);
 2396                                 }
 2397                         }
 2398                 }
 2399         }
 2400         /*printf("Component labels marked dirty.\n");*/
 2401 #if 0
 2402         for( c = 0; c < raidPtr->numSpare ; c++) {
sparecol = raidPtr->numCol + c;
 2404                 if (raidPtr->Disks[r][sparecol].status == rf_ds_used_spare) {
 2405                         /*
 2406                          * XXX This is where we get fancy and map this spare
 2407                          * into it's correct spot in the array.
 2408                          */
 2409                         /*
 2410                          * We claim this disk is "optimal" if it's
 2411                          * rf_ds_used_spare, as that means it should be
 2412                          * directly substitutable for the disk it replaced.
 2413                          * We note that too...
 2414                          */
 2416                         for(i=0;i<raidPtr->numRow;i++) {
 2417                                 for(j=0;j<raidPtr->numCol;j++) {
 2418                                         if ((raidPtr->Disks[i][j].spareRow ==
r) &&
 2420                                             (raidPtr->Disks[i][j].spareCol ==
sparecol)) {
srow = r;
scol = sparecol;
 2424                                                 break;
 2425                                         }
 2426                                 }
 2427                         }
raidread_component_label(
raidPtr->Disks[r][sparecol].dev,
raidPtr->raid_cinfo[r][sparecol].ci_vp, &clabel);
 2432                         /* Make sure status is noted. */
clabel.version = RF_COMPONENT_LABEL_VERSION;
clabel.mod_counter = raidPtr->mod_counter;
clabel.serial_number = raidPtr->serial_number;
clabel.row = srow;
clabel.column = scol;
clabel.num_rows = raidPtr->numRow;
clabel.num_columns = raidPtr->numCol;
clabel.clean = RF_RAID_DIRTY;   /* Changed in a bit. */
clabel.status = rf_ds_optimal;
raidwrite_component_label(
raidPtr->Disks[r][sparecol].dev,
raidPtr->raid_cinfo[r][sparecol].ci_vp, &clabel);
raidmarkclean( raidPtr->Disks[r][sparecol].dev,
raidPtr->raid_cinfo[r][sparecol].ci_vp);
 2447                 }
 2448         }
 2450 #endif
 2451 }
 2454 void
rf_update_component_labels(RF_Raid_t *raidPtr, int final)
 2456 {
RF_ComponentLabel_t clabel;
 2458         int sparecol;
 2459         int r,c;
 2460         int i,j;
 2461         int srow, scol;
srow = -1;
scol = -1;
 2466         /*
 2467          * XXX should do extra checks to make sure things really are clean,
 2468          * rather than blindly setting the clean bit...
 2469          */
raidPtr->mod_counter++;
 2473         for (r = 0; r < raidPtr->numRow; r++) {
 2474                 for (c = 0; c < raidPtr->numCol; c++) {
 2475                         if (raidPtr->Disks[r][c].status == rf_ds_optimal) {
raidread_component_label(
raidPtr->Disks[r][c].dev,
raidPtr->raid_cinfo[r][c].ci_vp,
 2479                                         &clabel);
 2480                                 /* Make sure status is noted. */
clabel.status = rf_ds_optimal;
 2482                                 /* Bump the counter. */
clabel.mod_counter = raidPtr->mod_counter;
raidwrite_component_label(
raidPtr->Disks[r][c].dev,
raidPtr->raid_cinfo[r][c].ci_vp,
 2488                                         &clabel);
 2489                                 if (final == RF_FINAL_COMPONENT_UPDATE) {
 2490                                         if (raidPtr->parity_good ==
RF_RAID_CLEAN) {
raidmarkclean(
raidPtr->Disks[r][c].dev,
raidPtr->
raid_cinfo[r][c].ci_vp,
raidPtr->mod_counter);
 2497                                         }
 2498                                 }
 2499                         }
 2500                         /* Else we don't touch it... */
 2501                 }
 2502         }
 2504         for( c = 0; c < raidPtr->numSpare ; c++) {
sparecol = raidPtr->numCol + c;
 2506                 if (raidPtr->Disks[0][sparecol].status == rf_ds_used_spare) {
 2507                         /*
 2508                          * We claim this disk is "optimal" if it's
 2509                          * rf_ds_used_spare, as that means it should be
 2510                          * directly substitutable for the disk it replaced.
 2511                          * We note that too...
 2512                          */
 2514                         for(i=0;i<raidPtr->numRow;i++) {
 2515                                 for(j=0;j<raidPtr->numCol;j++) {
 2516                                         if ((raidPtr->Disks[i][j].spareRow ==
 2517                                              0) &&
 2518                                             (raidPtr->Disks[i][j].spareCol ==
sparecol)) {
srow = i;
scol = j;
 2522                                                 break;
 2523                                         }
 2524                                 }
 2525                         }
 2527                         /* XXX Shouldn't *really* need this... */
raidread_component_label(
raidPtr->Disks[0][sparecol].dev,
raidPtr->raid_cinfo[0][sparecol].ci_vp, &clabel);
 2531                         /* Make sure status is noted. */
raid_init_component_label(raidPtr, &clabel);
clabel.mod_counter = raidPtr->mod_counter;
clabel.row = srow;
clabel.column = scol;
clabel.status = rf_ds_optimal;
raidwrite_component_label(
raidPtr->Disks[0][sparecol].dev,
raidPtr->raid_cinfo[0][sparecol].ci_vp, &clabel);
 2543                         if (final == RF_FINAL_COMPONENT_UPDATE) {
 2544                                 if (raidPtr->parity_good == RF_RAID_CLEAN) {
raidmarkclean(raidPtr->
Disks[0][sparecol].dev,
raidPtr->
raid_cinfo[0][sparecol].ci_vp,
raidPtr->mod_counter);
 2550                                 }
 2551                         }
 2552                 }
 2553         }
 2554         /*printf("Component labels updated\n");*/
 2555 }
 2557 void
rf_close_component(RF_Raid_t *raidPtr, struct vnode *vp, int auto_configured)
 2559 {
 2560         struct proc *p = curproc;
 2562         if (vp != NULL) {
 2563                 if (auto_configured == 1) {
 2564                         /* component was opened by rf_find_raid_components() */
VOP_CLOSE(vp, FREAD | FWRITE, NOCRED, p);
vrele(vp);
 2567                 } else {
 2568                         /* component was opened by raidlookup() */
 2569                         (void) vn_close(vp, FREAD | FWRITE, p->p_ucred, p);
 2570                 }
 2571         } else {
printf("vnode was NULL\n");
 2573         }
 2574 }
 2576 void
rf_UnconfigureVnodes(RF_Raid_t *raidPtr)
 2578 {
 2579         int r,c;
 2580         struct vnode *vp;
 2581         int acd;
 2584         /* We take this opportunity to close the vnodes like we should... */
 2586         for (r = 0; r < raidPtr->numRow; r++) {
 2587                 for (c = 0; c < raidPtr->numCol; c++) {
db1_printf(("Closing vnode for row: %d col: %d\n",
r, c));
vp = raidPtr->raid_cinfo[r][c].ci_vp;
acd = raidPtr->Disks[r][c].auto_configured;
rf_close_component(raidPtr, vp, acd);
raidPtr->raid_cinfo[r][c].ci_vp = NULL;
raidPtr->Disks[r][c].auto_configured = 0;
 2595                 }
 2596         }
 2597         for (r = 0; r < raidPtr->numSpare; r++) {
db1_printf(("Closing vnode for spare: %d\n", r));
vp = raidPtr->raid_cinfo[0][raidPtr->numCol + r].ci_vp;
acd = raidPtr->Disks[0][raidPtr->numCol + r].auto_configured;
rf_close_component(raidPtr, vp, acd);
raidPtr->raid_cinfo[0][raidPtr->numCol + r].ci_vp = NULL;
raidPtr->Disks[0][raidPtr->numCol + r].auto_configured = 0;
 2604         }
 2605 }
 2608 void
rf_ReconThread(struct rf_recon_req *req)
 2610 {
 2611         int s;
RF_Raid_t *raidPtr;
s = splbio();
raidPtr = (RF_Raid_t *) req->raidPtr;
raidPtr->recon_in_progress = 1;
rf_FailDisk((RF_Raid_t *) req->raidPtr, req->row, req->col,
 2619                     ((req->flags & RF_FDFLAGS_RECON) ? 1 : 0));
 2621         /* XXX Get rid of this! we don't need it at all... */
RF_Free(req, sizeof(*req));
raidPtr->recon_in_progress = 0;
splx(s);
 2627         /* That's all... */
kthread_exit(0);        /* Does not return. */
 2629 }
 2631 void
rf_RewriteParityThread(RF_Raid_t *raidPtr)
 2633 {
 2634         int retcode;
 2635         int s;
s = splbio();
raidPtr->parity_rewrite_in_progress = 1;
retcode = rf_RewriteParity(raidPtr);
 2640         if (retcode) {
printf("raid%d: Error re-writing parity!\n",raidPtr->raidid);
 2642         } else {
 2643                 /*
 2644                  * Set the clean bit !  If we shutdown correctly,
 2645                  * the clean bit on each component label will get
 2646                  * set.
 2647                  */
raidPtr->parity_good = RF_RAID_CLEAN;
 2649         }
raidPtr->parity_rewrite_in_progress = 0;
splx(s);
 2653         /* Anyone waiting for us to stop ?  If so, inform them... */
 2654         if (raidPtr->waitShutdown) {
wakeup(&raidPtr->parity_rewrite_in_progress);
 2656         }
 2658         /* That's all... */
kthread_exit(0);        /* Does not return. */
 2660 }
 2663 void
rf_CopybackThread(RF_Raid_t *raidPtr)
 2665 {
 2666         int s;
s = splbio();
raidPtr->copyback_in_progress = 1;
rf_CopybackReconstructedData(raidPtr);
raidPtr->copyback_in_progress = 0;
splx(s);
 2674         /* That's all... */
kthread_exit(0);        /* Does not return. */
 2676 }
 2679 void
rf_ReconstructInPlaceThread(struct rf_recon_req *req)
 2681 {
 2682         int retcode;
 2683         int s;
RF_Raid_t *raidPtr;
s = splbio();
raidPtr = req->raidPtr;
raidPtr->recon_in_progress = 1;
retcode = rf_ReconstructInPlace(raidPtr, req->row, req->col);
RF_Free(req, sizeof(*req));
raidPtr->recon_in_progress = 0;
splx(s);
 2694         /* That's all... */
kthread_exit(0);        /* Does not return. */
 2696 }
RF_AutoConfig_t *
rf_find_raid_components(void)
 2701 {
 2702 #ifdef  RAID_AUTOCONFIG
 2703         int major;
 2704         struct vnode *vp;
 2705         struct disklabel label;
 2706         struct device *dv;
dev_t dev;
 2708         int error;
 2709         int i;
 2710         int good_one;
RF_ComponentLabel_t *clabel;
RF_AutoConfig_t *ac;
 2713 #endif  /* RAID_AUTOCONFIG */
RF_AutoConfig_t *ac_list;
 2717         /* Initialize the AutoConfig list. */
ac_list = NULL;
 2720 #ifdef  RAID_AUTOCONFIG
 2721         /* We begin by trolling through *all* the devices on the system. */
TAILQ_FOREACH(dv, &alldevs, dv_list) {
 2725                 /* We are only interested in disks... */
 2726                 if (dv->dv_class != DV_DISK)
 2727                         continue;
 2729                 /* We don't care about floppies... */
 2730                 if (!strcmp(dv->dv_cfdata->cf_driver->cd_name,"fd")) {
 2731                         continue;
 2732                 }
 2734                 /*
 2735                  * We need to find the device_name_to_block_device_major
 2736                  * stuff.
 2737                  */
major = findblkmajor(dv);
 2740                 /* Get a vnode for the raw partition of this disk. */
dev = MAKEDISKDEV(major, dv->dv_unit, RAW_PART);
 2743                 if (bdevvp(dev, &vp))
panic("RAID can't alloc vnode");
error = VOP_OPEN(vp, FREAD, NOCRED, 0);
 2748                 if (error) {
 2749                         /*
 2750                          * "Who cares."  Continue looking
 2751                          * for something that exists.
 2752                          */
vput(vp);
 2754                         continue;
 2755                 }
 2757                 /* Ok, the disk exists.  Go get the disklabel. */
error = VOP_IOCTL(vp, DIOCGDINFO, (caddr_t)&label,
FREAD, NOCRED, 0);
 2760                 if (error) {
 2761                         /*
 2762                          * XXX can't happen - open() would
 2763                          * have errored out (or faked up one).
 2764                          */
printf("can't get label for dev %s%c (%d)!?!?\n",
dv->dv_xname, 'a' + RAW_PART, error);
 2767                 }
 2769                 /*
 2770                  * We don't need this any more.  We'll allocate it again
 2771                  * a little later if we really do...
 2772                  */
VOP_CLOSE(vp, FREAD | FWRITE, NOCRED, 0);
vrele(vp);
 2776                 for (i=0; i < label.d_npartitions; i++) {
 2777                         /*
 2778                          * We only support partitions marked as RAID.
 2779                          * Except on sparc/sparc64 where FS_RAID doesn't
 2780                          * fit in the SUN disklabel and we need to look
 2781                          * into each and every partition !!!
 2782                          */
 2783 #if !defined(__sparc__) && !defined(__sparc64__) && !defined(__sun3__)
 2784                         if (label.d_partitions[i].p_fstype != FS_RAID)
 2785                                 continue;
 2786 #else /* !__sparc__ && !__sparc64__ && !__sun3__ */
 2787                         if (label.d_partitions[i].p_fstype == FS_SWAP ||
label.d_partitions[i].p_fstype == FS_UNUSED)
 2789                                 continue;
 2790 #endif /* __sparc__ || __sparc64__ || __sun3__ */
dev = MAKEDISKDEV(major, dv->dv_unit, i);
 2793                         if (bdevvp(dev, &vp))
panic("RAID can't alloc vnode");
error = VOP_OPEN(vp, FREAD, NOCRED, 0);
 2797                         if (error) {
 2798                                 /* Whatever... */
vput(vp);
 2800                                 continue;
 2801                         }
good_one = 0;
clabel = (RF_ComponentLabel_t *)
malloc(sizeof(RF_ComponentLabel_t), M_RAIDFRAME,
M_NOWAIT);
 2808                         if (clabel == NULL) {
 2809                                 /* XXX CLEANUP HERE. */
printf("RAID auto config: out of memory!\n");
 2811                                 return(NULL); /* XXX probably should panic ? */
 2812                         }
 2814                         if (!raidread_component_label(dev, vp, clabel)) {
 2815                                 /* Got the label.  Does it look reasonable ? */
 2816                                 if (rf_reasonable_label(clabel) &&
 2817                                     (clabel->partitionSize <=
DL_GETPSIZE(&label.d_partitions[i]))) {
 2819 #ifdef  RAIDDEBUG
printf("Component on: %s%c: %d\n",
dv->dv_xname, 'a'+i,
DL_GETPSIZE(&label.d_partitions[i]));
rf_print_component_label(clabel);
 2824 #endif  /* RAIDDEBUG */
 2825                                         /*
 2826                                          * If it's reasonable, add it,
 2827                                          * else ignore it.
 2828                                          */
ac = (RF_AutoConfig_t *)
malloc(sizeof(RF_AutoConfig_t),
M_RAIDFRAME, M_NOWAIT);
 2832                                         if (ac == NULL) {
 2833                                                 /* XXX should panic ??? */
 2834                                                 return(NULL);
 2835                                         }
snprintf(ac->devname,
 2838                                                  sizeof ac->devname, "%s%c",
dv->dv_xname, 'a'+i);
ac->dev = dev;
ac->vp = vp;
ac->clabel = clabel;
ac->next = ac_list;
ac_list = ac;
good_one = 1;
 2846                                 }
 2847                         }
 2848                         if (!good_one) {
 2849                                 /* Cleanup. */
free(clabel, M_RAIDFRAME);
VOP_CLOSE(vp, FREAD | FWRITE, NOCRED, 0);
vrele(vp);
 2853                         }
 2854                 }
 2855         }
 2856 #endif  /* RAID_AUTOCONFIG */
 2857         return(ac_list);
 2858 }
 2860 #ifdef  RAID_AUTOCONFIG
 2861 int
rf_reasonable_label(RF_ComponentLabel_t *clabel)
 2863 {
 2865         if (((clabel->version==RF_COMPONENT_LABEL_VERSION_1) ||
 2866              (clabel->version==RF_COMPONENT_LABEL_VERSION)) &&
 2867             ((clabel->clean == RF_RAID_CLEAN) ||
 2868              (clabel->clean == RF_RAID_DIRTY)) &&
clabel->row >=0 &&
clabel->column >= 0 &&
clabel->num_rows > 0 &&
clabel->num_columns > 0 &&
clabel->row < clabel->num_rows &&
clabel->column < clabel->num_columns &&
clabel->blockSize > 0 &&
clabel->numBlocks > 0) {
 2877                 /* Label looks reasonable enough... */
 2878                 return(1);
 2879         }
 2880         return(0);
 2881 }
 2882 #endif  /* RAID_AUTOCONFIG */
 2884 void
rf_print_component_label(RF_ComponentLabel_t *clabel)
 2886 {
printf("   Row: %d Column: %d Num Rows: %d Num Columns: %d\n",
clabel->row, clabel->column, clabel->num_rows, clabel->num_columns);
printf("   Version: %d Serial Number: %d Mod Counter: %d\n",
clabel->version, clabel->serial_number, clabel->mod_counter);
printf("   Clean: %s Status: %d\n", clabel->clean ? "Yes" : "No",
clabel->status );
printf("   sectPerSU: %d SUsPerPU: %d SUsPerRU: %d\n",
clabel->sectPerSU, clabel->SUsPerPU, clabel->SUsPerRU);
printf("   RAID Level: %c  blocksize: %d numBlocks: %d\n",
 2896             (char) clabel->parityConfig, clabel->blockSize, clabel->numBlocks);
printf("   Autoconfig: %s\n", clabel->autoconfigure ? "Yes" : "No" );
printf("   Contains root partition: %s\n", clabel->root_partition ?
 2899             "Yes" : "No" );
printf("   Last configured as: raid%d\n", clabel->last_unit );
 2901 #if 0
printf("   Config order: %d\n", clabel->config_order);
 2903 #endif
 2904 }
RF_ConfigSet_t *
rf_create_auto_sets(RF_AutoConfig_t *ac_list)
 2908 {
RF_AutoConfig_t *ac;
RF_ConfigSet_t *config_sets;
RF_ConfigSet_t *cset;
RF_AutoConfig_t *ac_next;
config_sets = NULL;
 2917         /*
 2918          * Go through the AutoConfig list, and figure out which components
 2919          * belong to what sets.
 2920          */
ac = ac_list;
 2922         while(ac!=NULL) {
 2923                 /*
 2924                  * We're going to putz with ac->next, so save it here
 2925                  * for use at the end of the loop.
 2926                  */
ac_next = ac->next;
 2929                 if (config_sets == NULL) {
 2930                         /* We will need at least this one... */
config_sets = (RF_ConfigSet_t *)
malloc(sizeof(RF_ConfigSet_t), M_RAIDFRAME,
M_NOWAIT);
 2934                         if (config_sets == NULL) {
panic("rf_create_auto_sets: No memory!");
 2936                         }
 2937                         /* This one is easy :) */
config_sets->ac = ac;
config_sets->next = NULL;
config_sets->rootable = 0;
ac->next = NULL;
 2942                 } else {
 2943                         /* Which set does this component fit into ? */
cset = config_sets;
 2945                         while(cset!=NULL) {
 2946                                 if (rf_does_it_fit(cset, ac)) {
 2947                                         /* Looks like it matches... */
ac->next = cset->ac;
cset->ac = ac;
 2950                                         break;
 2951                                 }
cset = cset->next;
 2953                         }
 2954                         if (cset==NULL) {
 2955                                 /* Didn't find a match above... new set... */
cset = (RF_ConfigSet_t *)
malloc(sizeof(RF_ConfigSet_t),
M_RAIDFRAME, M_NOWAIT);
 2959                                 if (cset == NULL) {
panic("rf_create_auto_sets: No memory!");
 2961                                 }
cset->ac = ac;
ac->next = NULL;
cset->next = config_sets;
cset->rootable = 0;
config_sets = cset;
 2967                         }
 2968                 }
ac = ac_next;
 2970         }
 2973         return(config_sets);
 2974 }
 2976 int
rf_does_it_fit(RF_ConfigSet_t *cset, RF_AutoConfig_t *ac)
 2978 {
RF_ComponentLabel_t *clabel1, *clabel2;
 2981         /*
 2982          * If this one matches the *first* one in the set, that's good
 2983          * enough, since the other members of the set would have been
 2984          * through here too...
 2985          */
 2986         /*
 2987          * Note that we are not checking partitionSize here...
 2988          *
 2989          * Note that we are also not checking the mod_counters here.
 2990          * If everything else matches except the mod_counter, that's
 2991          * good enough for this test.  We will deal with the mod_counters
 2992          * a little later in the autoconfiguration process.
 2993          *
 2994          *  (clabel1->mod_counter == clabel2->mod_counter) &&
 2995          *
 2996          * The reason we don't check for this is that failed disks
 2997          * will have lower modification counts.  If those disks are
 2998          * not added to the set they used to belong to, then they will
 2999          * form their own set, which may result in 2 different sets,
 3000          * for example, competing to be configured at raid0, and
 3001          * perhaps competing to be the root filesystem set.  If the
 3002          * wrong ones get configured, or both attempt to become /,
 3003          * weird behaviour and or serious lossage will occur.  Thus we
 3004          * need to bring them into the fold here, and kick them out at
 3005          * a later point.
 3006          */
clabel1 = cset->ac->clabel;
clabel2 = ac->clabel;
 3010         if ((clabel1->version == clabel2->version) &&
 3011             (clabel1->serial_number == clabel2->serial_number) &&
 3012             (clabel1->num_rows == clabel2->num_rows) &&
 3013             (clabel1->num_columns == clabel2->num_columns) &&
 3014             (clabel1->sectPerSU == clabel2->sectPerSU) &&
 3015             (clabel1->SUsPerPU == clabel2->SUsPerPU) &&
 3016             (clabel1->SUsPerRU == clabel2->SUsPerRU) &&
 3017             (clabel1->parityConfig == clabel2->parityConfig) &&
 3018             (clabel1->maxOutstanding == clabel2->maxOutstanding) &&
 3019             (clabel1->blockSize == clabel2->blockSize) &&
 3020             (clabel1->numBlocks == clabel2->numBlocks) &&
 3021             (clabel1->autoconfigure == clabel2->autoconfigure) &&
 3022             (clabel1->root_partition == clabel2->root_partition) &&
 3023             (clabel1->last_unit == clabel2->last_unit) &&
 3024             (clabel1->config_order == clabel2->config_order)) {
 3025                 /* If it get's here, it almost *has* to be a match. */
 3026         } else {
 3027                 /* It's not consistent with somebody in the set...  Punt. */
 3028                 return(0);
 3029         }
 3030         /* All was fine.. It must fit... */
 3031         return(1);
 3032 }
 3034 int
rf_have_enough_components(RF_ConfigSet_t *cset)
 3036 {
RF_AutoConfig_t *ac;
RF_AutoConfig_t *auto_config;
RF_ComponentLabel_t *clabel;
 3040         int r,c;
 3041         int num_rows;
 3042         int num_cols;
 3043         int num_missing;
 3044         int mod_counter;
 3045         int mod_counter_found;
 3046         int even_pair_failed;
 3047         char parity_type;
 3050         /*
 3051          * Check to see that we have enough 'live' components
 3052          * of this set.  If so, we can configure it if necessary.
 3053          */
num_rows = cset->ac->clabel->num_rows;
num_cols = cset->ac->clabel->num_columns;
parity_type = cset->ac->clabel->parityConfig;
 3059         /* XXX Check for duplicate components !?!?!? */
 3061         /* Determine what the mod_counter is supposed to be for this set. */
mod_counter_found = 0;
mod_counter = 0;
ac = cset->ac;
 3066         while(ac!=NULL) {
 3067                 if (mod_counter_found==0) {
mod_counter = ac->clabel->mod_counter;
mod_counter_found = 1;
 3070                 } else {
 3071                         if (ac->clabel->mod_counter > mod_counter) {
mod_counter = ac->clabel->mod_counter;
 3073                         }
 3074                 }
ac = ac->next;
 3076         }
num_missing = 0;
auto_config = cset->ac;
 3081         for(r=0; r<num_rows; r++) {
even_pair_failed = 0;
 3083                 for(c=0; c<num_cols; c++) {
ac = auto_config;
 3085                         while(ac!=NULL) {
 3086                                 if ((ac->clabel->row == r) &&
 3087                                     (ac->clabel->column == c) &&
 3088                                     (ac->clabel->mod_counter == mod_counter)) {
 3089                                         /* It's this one... */
 3090 #ifdef  RAIDDEBUG
printf("Found: %s at %d,%d\n",
ac->devname,r,c);
 3093 #endif  /* RAIDDEBUG */
 3094                                         break;
 3095                                 }
ac=ac->next;
 3097                         }
 3098                         if (ac==NULL) {
 3099                                 /* Didn't find one here! */
 3100                                 /*
 3101                                  * Special case for RAID 1, especially
 3102                                  * where there are more than 2
 3103                                  * components (where RAIDframe treats
 3104                                  * things a little differently :( )
 3105                                  */
 3106                                 if (parity_type == '1') {
 3107                                         if (c%2 == 0) { /* Even component. */
even_pair_failed = 1;
 3109                                         } else {        /*
 3110                                                          * Odd component.
 3111                                                          * If we're failed,
 3112                                                          * and so is the even
 3113                                                          * component, it's
 3114                                                          * "Good Night, Charlie"
 3115                                                          */
 3116                                                 if (even_pair_failed == 1) {
 3117                                                         return(0);
 3118                                                 }
 3119                                         }
 3120                                 } else {
 3121                                         /* Normal accounting. */
num_missing++;
 3123                                 }
 3124                         }
 3125                         if ((parity_type == '1') && (c%2 == 1)) {
 3126                                 /*
 3127                                  * Just did an even component, and we didn't
 3128                                  * bail... Reset the even_pair_failed flag,
 3129                                  * and go on to the next component...
 3130                                  */
even_pair_failed = 0;
 3132                         }
 3133                 }
 3134         }
clabel = cset->ac->clabel;
 3138         if (((clabel->parityConfig == '0') && (num_missing > 0)) ||
 3139             ((clabel->parityConfig == '4') && (num_missing > 1)) ||
 3140             ((clabel->parityConfig == '5') && (num_missing > 1))) {
 3141                 /* XXX This needs to be made *much* more general. */
 3142                 /* Too many failures. */
 3143                 return(0);
 3144         }
 3145         /*
 3146          * Otherwise, all is well, and we've got enough to take a kick
 3147          * at autoconfiguring this set.
 3148          */
 3149         return(1);
 3150 }
 3152 void
rf_create_configuration(RF_AutoConfig_t *ac, RF_Config_t *config,
RF_Raid_t *raidPtr)
 3155 {
RF_ComponentLabel_t *clabel;
 3157         int i;
clabel = ac->clabel;
 3161         /* 1. Fill in the common stuff. */
config->numRow = clabel->num_rows;
config->numCol = clabel->num_columns;
config->numSpare = 0;   /* XXX Should this be set here ? */
config->sectPerSU = clabel->sectPerSU;
config->SUsPerPU = clabel->SUsPerPU;
config->SUsPerRU = clabel->SUsPerRU;
config->parityConfig = clabel->parityConfig;
 3169         /* XXX... */
strlcpy(config->diskQueueType,"fifo", sizeof config->diskQueueType);
config->maxOutstandingDiskReqs = clabel->maxOutstanding;
config->layoutSpecificSize = 0; /* XXX ?? */
 3174         while(ac!=NULL) {
 3175                 /*
 3176                  * row/col values will be in range due to the checks
 3177                  * in reasonable_label().
 3178                  */
strlcpy(config->devnames[ac->clabel->row][ac->clabel->column],
ac->devname,
 3181                     sizeof config->devnames[ac->clabel->row][ac->clabel->column]);
ac = ac->next;
 3183         }
 3185         for(i=0;i<RF_MAXDBGV;i++) {
config->debugVars[i][0] = NULL;
 3187         }
 3189 #ifdef  RAID_DEBUG_ALL
 3191 #ifdef  RF_DBG_OPTION
 3192 #undef  RF_DBG_OPTION
 3193 #endif  /* RF_DBG_OPTION */
 3195 #ifdef  __STDC__
 3196 #define RF_DBG_OPTION(_option_,_val_)   do {                            \
snprintf(&(config->debugVars[i++][0]), 50, "%s %ld",            \
 3198             #_option_, _val_);                                          \
 3199 } while (0)
 3200 #else   /* __STDC__ */
 3201 #define RF_DBG_OPTION(_option_,_val_)   do {                            \
snprintf(&(config->debugVars[i++][0]), 50, "%s %ld",            \
 3203             "/**/_option_/**/", _val_);                                 \
 3204 } while (0)
 3205 #endif  /* __STDC__ */
i = 0;
 3209 /*      RF_DBG_OPTION(accessDebug, 0);                                  */
 3210 /*      RF_DBG_OPTION(accessTraceBufSize, 0);                           */
RF_DBG_OPTION(cscanDebug, 1);           /* Debug CSCAN sorting. */
RF_DBG_OPTION(dagDebug, 1);
 3213 /*      RF_DBG_OPTION(debugPrintUseBuffer, 0);                          */
RF_DBG_OPTION(degDagDebug, 1);
RF_DBG_OPTION(disableAsyncAccs, 1);
RF_DBG_OPTION(diskDebug, 1);
RF_DBG_OPTION(enableAtomicRMW, 0);
 3218                 /*
 3219                  * This debug variable enables locking of the
 3220                  * disk arm during small-write operations.
 3221                  * Setting this variable to anything other than
 3222                  * 0 will result in deadlock.  (wvcii)
 3223                  */
RF_DBG_OPTION(engineDebug, 1);
RF_DBG_OPTION(fifoDebug, 1);            /* Debug fifo queueing. */
 3226 /*      RF_DBG_OPTION(floatingRbufDebug, 1);                            */
 3227 /*      RF_DBG_OPTION(forceHeadSepLimit, -1);                           */
 3228 /*      RF_DBG_OPTION(forceNumFloatingReconBufs, -1);                   */
 3229                 /*
 3230                  * Wire down the number of extra recon buffers
 3231                  * to use.
 3232                  */
 3233 /*      RF_DBG_OPTION(keepAccTotals, 1);                                */
 3234                 /* Turn on keep_acc_totals. */
RF_DBG_OPTION(lockTableSize, RF_DEFAULT_LOCK_TABLE_SIZE);
RF_DBG_OPTION(mapDebug, 1);
RF_DBG_OPTION(maxNumTraces, -1);
 3239 /*      RF_DBG_OPTION(memChunkDebug, 1);                                */
 3240 /*      RF_DBG_OPTION(memDebug, 1);                                     */
 3241 /*      RF_DBG_OPTION(memDebugAddress, 1);                              */
 3242 /*      RF_DBG_OPTION(numBufsToAccumulate, 1);                          */
 3243                 /*
 3244                  * Number of buffers to accumulate before
 3245                  * doing XOR.
 3246                  */
RF_DBG_OPTION(prReconSched, 0);
RF_DBG_OPTION(printDAGsDebug, 1);
RF_DBG_OPTION(printStatesDebug, 1);
RF_DBG_OPTION(protectedSectors, 64L);
 3251                 /*
 3252                  * Number of sectors at start of disk to exclude
 3253                  * from RAID address space.
 3254                  */
RF_DBG_OPTION(pssDebug, 1);
RF_DBG_OPTION(queueDebug, 1);
RF_DBG_OPTION(quiesceDebug, 1);
RF_DBG_OPTION(raidSectorOffset, 0);
 3259                 /*
 3260                  * Value added to all incoming sectors to debug
 3261                  * alignment problems.
 3262                  */
RF_DBG_OPTION(reconDebug, 1);
RF_DBG_OPTION(reconbufferDebug, 1);
RF_DBG_OPTION(scanDebug, 1);            /* Debug SCAN sorting.  */
RF_DBG_OPTION(showXorCallCounts, 0);
 3267                 /* Show n-way Xor call counts. */
RF_DBG_OPTION(shutdownDebug, 1);        /* Show shutdown calls. */
RF_DBG_OPTION(sizePercentage, 100);
RF_DBG_OPTION(sstfDebug, 1);
 3271                 /* Turn on debugging info for sstf queueing. */
RF_DBG_OPTION(stripeLockDebug, 1);
RF_DBG_OPTION(suppressLocksAndLargeWrites, 0);
RF_DBG_OPTION(suppressTraceDelays, 0);
RF_DBG_OPTION(useMemChunks, 1);
RF_DBG_OPTION(validateDAGDebug, 1);
RF_DBG_OPTION(validateVisitedDebug, 1);
 3278                 /* XXX turn to zero by default ? */
RF_DBG_OPTION(verifyParityDebug, 1);
RF_DBG_OPTION(debugKernelAccess, 1);
 3281                 /* DoAccessKernel debugging. */
 3283 #if RF_INCLUDE_PARITYLOGGING > 0
RF_DBG_OPTION(forceParityLogReint, 0);
RF_DBG_OPTION(numParityRegions, 0);
 3286                 /* Number of regions in the array. */
RF_DBG_OPTION(numReintegrationThreads, 1);
RF_DBG_OPTION(parityLogDebug, 1);
 3289                 /* If nonzero, enables debugging of parity logging. */
RF_DBG_OPTION(totalInCoreLogCapacity, 1024 * 1024);
 3291                 /* Target bytes available for in-core logs. */
 3292 #endif  /* RF_INCLUDE_PARITYLOGGING > 0 */
 3294 #endif  /* RAID_DEBUG_ALL */
 3295 }
 3297 int
rf_set_autoconfig(RF_Raid_t *raidPtr, int new_value)
 3299 {
RF_ComponentLabel_t clabel;
 3301         struct vnode *vp;
dev_t dev;
 3303         int row, column;
raidPtr->autoconfigure = new_value;
 3306         for(row=0; row<raidPtr->numRow; row++) {
 3307                 for(column=0; column<raidPtr->numCol; column++) {
 3308                         if (raidPtr->Disks[row][column].status ==
rf_ds_optimal) {
dev = raidPtr->Disks[row][column].dev;
vp = raidPtr->raid_cinfo[row][column].ci_vp;
raidread_component_label(dev, vp, &clabel);
clabel.autoconfigure = new_value;
raidwrite_component_label(dev, vp, &clabel);
 3315                         }
 3316                 }
 3317         }
 3318         return(new_value);
 3319 }
 3321 int
rf_set_rootpartition(RF_Raid_t *raidPtr, int new_value)
 3323 {
RF_ComponentLabel_t clabel;
 3325         struct vnode *vp;
dev_t dev;
 3327         int row, column;
raidPtr->root_partition = new_value;
 3330         for(row=0; row<raidPtr->numRow; row++) {
 3331                 for(column=0; column<raidPtr->numCol; column++) {
 3332                         if (raidPtr->Disks[row][column].status ==
rf_ds_optimal) {
dev = raidPtr->Disks[row][column].dev;
vp = raidPtr->raid_cinfo[row][column].ci_vp;
raidread_component_label(dev, vp, &clabel);
clabel.root_partition = new_value;
raidwrite_component_label(dev, vp, &clabel);
 3339                         }
 3340                 }
 3341         }
 3342         return(new_value);
 3343 }
 3345 void
rf_release_all_vps(RF_ConfigSet_t *cset)
 3347 {
RF_AutoConfig_t *ac;
ac = cset->ac;
 3351         while(ac!=NULL) {
 3352                 /* Close the vp, and give it back. */
 3353                 if (ac->vp) {
VOP_CLOSE(ac->vp, FREAD, NOCRED, 0);
vrele(ac->vp);
ac->vp = NULL;
 3357                 }
ac = ac->next;
 3359         }
 3360 }
 3363 void
rf_cleanup_config_set(RF_ConfigSet_t *cset)
 3365 {
RF_AutoConfig_t *ac;
RF_AutoConfig_t *next_ac;
ac = cset->ac;
 3370         while(ac!=NULL) {
next_ac = ac->next;
 3372                 /* Nuke the label. */
free(ac->clabel, M_RAIDFRAME);
 3374                 /* Cleanup the config structure. */
free(ac, M_RAIDFRAME);
 3376                 /* "next..." */
ac = next_ac;
 3378         }
 3379         /* And, finally, nuke the config set. */
free(cset, M_RAIDFRAME);
 3381 }
 3384 void
raid_init_component_label(RF_Raid_t *raidPtr, RF_ComponentLabel_t *clabel)
 3386 {
 3387         /* Current version number. */
clabel->version = RF_COMPONENT_LABEL_VERSION;
clabel->serial_number = raidPtr->serial_number;
clabel->mod_counter = raidPtr->mod_counter;
clabel->num_rows = raidPtr->numRow;
clabel->num_columns = raidPtr->numCol;
clabel->clean = RF_RAID_DIRTY;  /* Not clean. */
clabel->status = rf_ds_optimal; /* "It's good !" */
clabel->sectPerSU = raidPtr->Layout.sectorsPerStripeUnit;
clabel->SUsPerPU = raidPtr->Layout.SUsPerPU;
clabel->SUsPerRU = raidPtr->Layout.SUsPerRU;
clabel->blockSize = raidPtr->bytesPerSector;
clabel->numBlocks = raidPtr->sectorsPerDisk;
 3403         /* XXX Not portable. */
clabel->parityConfig = raidPtr->Layout.map->parityConfig;
clabel->maxOutstanding = raidPtr->maxOutstanding;
clabel->autoconfigure = raidPtr->autoconfigure;
clabel->root_partition = raidPtr->root_partition;
clabel->last_unit = raidPtr->raidid;
clabel->config_order = raidPtr->config_order;
 3410 }
 3412 int
rf_auto_config_set(RF_ConfigSet_t *cset, int *unit)
 3414 {
RF_Raid_t *raidPtr;
RF_Config_t *config;
 3417         int raidID;
 3418         int retcode;
db1_printf(("RAID autoconfigure\n"));
retcode = 0;
 3423         *unit = -1;
 3425         /* 1. Create a config structure. */
config = (RF_Config_t *)malloc(sizeof(RF_Config_t), M_RAIDFRAME,
M_NOWAIT);
 3429         if (config==NULL) {
printf("Out of mem!?!?\n");
 3431                                 /* XXX Do something more intelligent here. */
 3432                 return(1);
 3433         }
memset(config, 0, sizeof(RF_Config_t));
 3437         /* XXX raidID needs to be set correctly... */
 3439         /*
 3440          * 2. Figure out what RAID ID this one is supposed to live at.
 3441          * See if we can get the same RAID dev that it was configured
 3442          * on last time...
 3443          */
raidID = cset->ac->clabel->last_unit;
 3446         if ((raidID < 0) || (raidID >= numraid)) {
 3447                 /* Let's not wander off into lala land. */
raidID = numraid - 1;
 3449         }
 3450         if (raidPtrs[raidID]->valid != 0) {
 3452                 /*
 3453                  * Nope...  Go looking for an alternative...
 3454                  * Start high so we don't immediately use raid0 if that's
 3455                  * not taken.
 3456                  */
 3458                 for(raidID = numraid - 1; raidID >= 0; raidID--) {
 3459                         if (raidPtrs[raidID]->valid == 0) {
 3460                                 /* We can use this one ! */
 3461                                 break;
 3462                         }
 3463                 }
 3464         }
 3466         if (raidID < 0) {
 3467                 /* Punt... */
printf("Unable to auto configure this set!\n");
printf("(Out of RAID devs!)\n");
 3470                 return(1);
 3471         }
raidPtr = raidPtrs[raidID];
 3474         /* XXX All this stuff should be done SOMEWHERE ELSE ! */
raidPtr->raidid = raidID;
raidPtr->openings = RAIDOUTSTANDING;
 3478         /* 3. Build the configuration structure. */
rf_create_configuration(cset->ac, config, raidPtr);
 3481         /* 4. Do the configuration. */
retcode = rf_Configure(raidPtr, config, cset->ac);
 3484         if (retcode == 0) {
raidinit(raidPtrs[raidID]);
rf_markalldirty(raidPtrs[raidID]);
raidPtrs[raidID]->autoconfigure = 1; /* XXX Do this here ? */
 3490                 if (cset->ac->clabel->root_partition==1) {
 3491                         /*
 3492                          * Everything configured just fine.  Make a note
 3493                          * that this set is eligible to be root.
 3494                          */
cset->rootable = 1;
 3496                         /* XXX Do this here ? */
raidPtrs[raidID]->root_partition = 1;
 3498                 }
 3499         }
printf(": (%s) total number of sectors is %lu (%lu MB)%s\n",
 3502             (raidPtrs[raidID]->Layout).map->configName,
 3503             (unsigned long) raidPtrs[raidID]->totalSectors,
 3504             (unsigned long) (raidPtrs[raidID]->totalSectors / 1024 *
 3505             (1 << raidPtrs[raidID]->logBytesPerSector) / 1024),
raidPtrs[raidID]->root_partition ? " as root" : "");
 3508         /* 5. Cleanup. */
free(config, M_RAIDFRAME);
 3511         *unit = raidID;
 3512         return(retcode);
 3513 }
 3515 void
rf_disk_unbusy(RF_RaidAccessDesc_t *desc)
 3517 {
 3518         struct buf *bp;
bp = (struct buf *)desc->bp;
disk_unbusy(&raid_softc[desc->raidPtr->raidid].sc_dkdev,
 3522                             (bp->b_bcount - bp->b_resid),
 3523                             (bp->b_flags & B_READ));
 3524 }