diff options
Diffstat (limited to 'sys/dev/raidframe/rf_netbsdkintf.c')
| -rw-r--r-- | sys/dev/raidframe/rf_netbsdkintf.c | 1487 |
1 files changed, 638 insertions, 849 deletions
diff --git a/sys/dev/raidframe/rf_netbsdkintf.c b/sys/dev/raidframe/rf_netbsdkintf.c index ad6673541cc..e0ca8caa0f1 100644 --- a/sys/dev/raidframe/rf_netbsdkintf.c +++ b/sys/dev/raidframe/rf_netbsdkintf.c @@ -1,5 +1,5 @@ -/* $OpenBSD: rf_netbsdkintf.c,v 1.1 1999/01/11 14:29:30 niklas Exp $ */ -/* $NetBSD: rf_netbsdkintf.c,v 1.5 1998/12/22 20:03:14 oster Exp $ */ +/* $OpenBSD: rf_netbsdkintf.c,v 1.2 1999/02/16 00:02:59 niklas Exp $ */ +/* $NetBSD: rf_netbsdkintf.c,v 1.10 1999/02/11 01:23:32 oster Exp $ */ /*- * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc. * All rights reserved. @@ -113,189 +113,8 @@ * rf_kintf.c -- the kernel interface routines for RAIDframe * ***********************************************************/ -/* - * : - * Log: rf_kintf.c,v - * Revision 1.57 1996/07/19 16:12:20 jimz - * remove addition of protectedSectors in InitBP- it's already - * done in the diskqueue code - * - * Revision 1.56 1996/07/17 21:00:58 jimz - * clean up timer interface, tracing - * - * Revision 1.55 1996/06/17 03:00:54 jimz - * Change RAIDFRAME_GET_INFO interface to do its own copyout() - * (because size of device config structure now exceeds 8k) - * - * Revision 1.54 1996/06/09 02:36:46 jimz - * lots of little crufty cleanup- fixup whitespace - * issues, comment #ifdefs, improve typing in some - * places (esp size-related) - * - * Revision 1.53 1996/06/07 21:33:04 jimz - * begin using consistent types for sector numbers, - * stripe numbers, row+col numbers, recon unit numbers - * - * Revision 1.52 1996/06/06 17:28:08 jimz - * track sector number of last I/O dequeued - * - * Revision 1.51 1996/06/05 18:06:02 jimz - * Major code cleanup. The Great Renaming is now done. - * Better modularity. Better typing. Fixed a bunch of - * synchronization bugs. Made a lot of global stuff - * per-desc or per-array. Removed dead code. - * - * Revision 1.50 1996/06/03 23:28:26 jimz - * more bugfixes - * check in tree to sync for IPDS runs with current bugfixes - * there still may be a problem with threads in the script test - * getting I/Os stuck- not trivially reproducible (runs ~50 times - * in a row without getting stuck) - * - * Revision 1.49 1996/06/02 17:31:48 jimz - * Moved a lot of global stuff into array structure, where it belongs. - * Fixed up paritylogging, pss modules in this manner. Some general - * code cleanup. Removed lots of dead code, some dead files. - * - * Revision 1.48 1996/05/31 22:26:54 jimz - * fix a lot of mapping problems, memory allocation problems - * found some weird lock issues, fixed 'em - * more code cleanup - * - * Revision 1.47 1996/05/30 12:59:18 jimz - * make etimer happier, more portable - * - * Revision 1.46 1996/05/30 11:29:41 jimz - * Numerous bug fixes. Stripe lock release code disagreed with the taking code - * about when stripes should be locked (I made it consistent: no parity, no lock) - * There was a lot of extra serialization of I/Os which I've removed- a lot of - * it was to calculate values for the cache code, which is no longer with us. - * More types, function, macro cleanup. Added code to properly quiesce the array - * on shutdown. Made a lot of stuff array-specific which was (bogusly) general - * before. Fixed memory allocation, freeing bugs. - * - * Revision 1.45 1996/05/27 18:56:37 jimz - * more code cleanup - * better typing - * compiles in all 3 environments - * - * Revision 1.44 1996/05/24 22:17:04 jimz - * continue code + namespace cleanup - * typed a bunch of flags - * - * Revision 1.43 1996/05/24 01:59:45 jimz - * another checkpoint in code cleanup for release - * time to sync kernel tree - * - * Revision 1.42 1996/05/23 22:17:54 jimz - * fix sector size hardcoding problems - * - * Revision 1.41 1996/05/23 21:46:35 jimz - * checkpoint in code cleanup (release prep) - * lots of types, function names have been fixed - * - * Revision 1.40 1996/05/23 13:18:07 jimz - * tracing_mutex -> rf_tracing_mutex - * - * Revision 1.39 1996/05/23 00:33:23 jimz - * code cleanup: move all debug decls to rf_options.c, all extern - * debug decls to rf_options.h, all debug vars preceded by rf_ - * - * Revision 1.38 1996/05/20 16:15:32 jimz - * switch to rf_{mutex,cond}_{init,destroy} - * - * Revision 1.37 1996/05/10 16:23:47 jimz - * RF_offset -> RF_Offset - * - * Revision 1.36 1996/05/08 21:01:24 jimz - * fixed up enum type names that were conflicting with other - * enums and function names (ie, "panic") - * future naming trends will be towards RF_ and rf_ for - * everything raidframe-related - * - * Revision 1.35 1996/05/03 19:10:48 jimz - * change sanity checking for bogus I/Os to return more appropriate - * values (to make some user-level utilities happer with RAIDframe) - * - * Revision 1.34 1996/05/02 22:17:00 jimz - * When using DKUSAGE, send a bogus IO after configuring to let DKUSAGE know - * that we exist. This will let user-level programs doing group stats on the - * RF device function without error before RF gets its first IO - * - * Changed rf_device_config devs and spares fields to RF_RaidDisk_t - * - * Inc numOutstanding for the disk queue in rf_DispatchKernelIO if - * type is IO_TYPE_NOP. I'm not sure this is right, but it seems to be, - * because the disk IO completion routine wants to dec it, and doesn't - * care if there was no such IO. - * - * Revision 1.33 1996/05/02 15:05:44 jimz - * for now, rf_DoAccessKernel will reject non-sector-sized I/Os - * eventually, it should do something more clever... - * (and do it in DoAccess(), not just DoAccessKernel()) - * - * Revision 1.32 1996/05/01 16:28:39 jimz - * get rid of uses of ccmn_ functions - * - * Revision 1.31 1996/05/01 15:42:17 jimz - * ccmn_* memory management is on the way out. This is an archival checkpoint- - * both the old and new code are in place (all the ccmn_ calls are #if 0). After - * this, the ccmn_ code will no longer appear. - * - * Revision 1.30 1996/04/22 15:53:13 jimz - * MAX_RAIDS -> NRAIDFRAME - * - * Revision 1.29 1995/12/12 18:10:06 jimz - * MIN -> RF_MIN, MAX -> RF_MAX, ASSERT -> RF_ASSERT - * fix 80-column brain damage in comments - * - * Revision 1.28 1995/12/01 19:11:01 root - * added copyright info - * - * Revision 1.27 1995/11/28 18:56:40 wvcii - * disabled buffer copy in rf_write - * - * Revision 1.26 1995/10/06 16:37:08 jimz - * get struct bufs from ubc, not cam - * copy all write data, and operate on copy - * (temporary hack to get around dags in PQ that want - * to Xor into user write buffers) - * - * Revision 1.25 1995/09/30 22:23:08 jimz - * do not require raid to be active to perform ACCTOTAL ioctl - * - * Revision 1.24 1995/09/30 20:39:08 jimz - * added new ioctls: - * RAIDFRAME_RESET_ACCTOTALS - * RAIDFRAME_GET_ACCTOTALS - * RAIDFRAME_KEEP_ACCTOTALS - * - * Revision 1.23 1995/09/20 21:11:59 jimz - * include dfstrace.h in KERNEL block - * (even though it's a kernel-only file, this makes the depend process - * at user-level happy. Why the user-level Makefile wants to depend - * kintf.c is less clear, but this is a workaround). - * - * Revision 1.22 1995/09/19 23:19:03 jimz - * added DKUSAGE support - * - */ - - - - -#ifdef _KERNEL -#define KERNEL -#endif - - - -#ifdef KERNEL #include <sys/errno.h> - -#ifdef __NetBSD__ -#include "raid.h" #include <sys/param.h> #include <sys/pool.h> #include <sys/queue.h> @@ -307,25 +126,16 @@ #include <sys/systm.h> #include <sys/namei.h> #include <sys/vnode.h> -#endif - #include <sys/param.h> #include <sys/types.h> - #include <machine/types.h> - #include <sys/disklabel.h> - #include <sys/conf.h> - - -#ifdef __NetBSD__ #include <sys/lock.h> -#endif /* __NetBSD__ */ - - #include <sys/buf.h> #include <sys/user.h> + +#include "raid.h" #include "rf_raid.h" #include "rf_raidframe.h" #include "rf_dag.h" @@ -342,7 +152,7 @@ #include "rf_debugprint.h" #include "rf_threadstuff.h" -int rf_kdebug_level = 0; +int rf_kdebug_level = 0; #define RFK_BOOT_NONE 0 #define RFK_BOOT_GOOD 1 @@ -357,40 +167,43 @@ static int rf_kbooted = RFK_BOOT_NONE; #define db3_printf(a) if (rf_kdebug_level > 2) printf a #define db4_printf(a) if (rf_kdebug_level > 3) printf a #define db5_printf(a) if (rf_kdebug_level > 4) printf a -#else /* DEBUG */ +#else /* DEBUG */ #define db0_printf(a) printf a #define db1_printf(a) { } #define db2_printf(a) { } #define db3_printf(a) { } #define db4_printf(a) { } #define db5_printf(a) { } -#endif /* DEBUG */ +#endif /* DEBUG */ -static RF_Raid_t **raidPtrs; /* global raid device descriptors */ +static RF_Raid_t **raidPtrs; /* global raid device descriptors */ static int rf_pending_testaccs; RF_DECLARE_STATIC_MUTEX(rf_sparet_wait_mutex) RF_DECLARE_STATIC_MUTEX(rf_async_done_q_mutex) -static RF_SparetWait_t *rf_sparet_wait_queue; /* requests to install a spare table */ -static RF_SparetWait_t *rf_sparet_resp_queue; /* responses from installation process */ -static struct rf_test_acc *rf_async_done_qh, *rf_async_done_qt; - -static struct rf_recon_req *recon_queue = NULL; /* used to communicate reconstruction requests */ - +static RF_SparetWait_t *rf_sparet_wait_queue; /* requests to install a + * spare table */ +static RF_SparetWait_t *rf_sparet_resp_queue; /* responses from + * installation process */ +static struct rf_test_acc *rf_async_done_qh, *rf_async_done_qt; -decl_simple_lock_data(,recon_queue_mutex) +static struct rf_recon_req *recon_queue = NULL; /* used to communicate + * reconstruction + * requests */ +decl_simple_lock_data(, recon_queue_mutex) #define LOCK_RECON_Q_MUTEX() simple_lock(&recon_queue_mutex) #define UNLOCK_RECON_Q_MUTEX() simple_unlock(&recon_queue_mutex) /* prototypes */ -static void KernelWakeupFunc(struct buf *bp); -static void InitBP(struct buf *bp, struct vnode *, unsigned rw_flag, dev_t dev, - RF_SectorNum_t startSect, RF_SectorCount_t numSect, caddr_t buf, - void (*cbFunc)(struct buf *), void *cbArg, int logBytesPerSector, - struct proc *b_proc); +static void KernelWakeupFunc(struct buf * bp); +static void InitBP(struct buf * bp, struct vnode *, unsigned rw_flag, + dev_t dev, RF_SectorNum_t startSect, + RF_SectorCount_t numSect, caddr_t buf, + void (*cbFunc) (struct buf *), void *cbArg, + int logBytesPerSector, struct proc * b_proc); #define Dprintf0(s) if (rf_queueDebug) rf_debug_printf(s,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL) #define Dprintf1(s,a) if (rf_queueDebug) rf_debug_printf(s,a,NULL,NULL,NULL,NULL,NULL,NULL,NULL) @@ -401,52 +214,52 @@ static void InitBP(struct buf *bp, struct vnode *, unsigned rw_flag, dev_t dev, /* this is so that we can compile under 2.0 as well as 3.2 */ #ifndef proc_to_task #define proc_to_task(x) ((x)->task) -#endif /* !proc_to_task */ +#endif /* !proc_to_task */ -void raidattach __P((int)); -int raidsize __P((dev_t)); +void raidattach __P((int)); +int raidsize __P((dev_t)); -void rf_DiskIOComplete(RF_DiskQueue_t *, RF_DiskQueueData_t *, int); -void rf_CopybackReconstructedData(RF_Raid_t *raidPtr); -static int raidinit __P((dev_t,RF_Raid_t *,int)); +void rf_DiskIOComplete(RF_DiskQueue_t *, RF_DiskQueueData_t *, int); +void rf_CopybackReconstructedData(RF_Raid_t * raidPtr); +static int raidinit __P((dev_t, RF_Raid_t *, int)); -int raidopen __P((dev_t, int, int, struct proc *)); -int raidclose __P((dev_t, int, int, struct proc *)); -int raidioctl __P((dev_t, u_long, caddr_t, int, struct proc *)); -int raidwrite __P((dev_t, struct uio *, int)); -int raidread __P((dev_t, struct uio *, int)); -void raidstrategy __P((struct buf *)); -int raiddump __P((dev_t, daddr_t, caddr_t, size_t)); +int raidopen __P((dev_t, int, int, struct proc *)); +int raidclose __P((dev_t, int, int, struct proc *)); +int raidioctl __P((dev_t, u_long, caddr_t, int, struct proc *)); +int raidwrite __P((dev_t, struct uio *, int)); +int raidread __P((dev_t, struct uio *, int)); +void raidstrategy __P((struct buf *)); +int raiddump __P((dev_t, daddr_t, caddr_t, size_t)); /* * Pilfered from ccd.c */ struct raidbuf { - struct buf rf_buf; /* new I/O buf. MUST BE FIRST!!! */ - struct buf *rf_obp; /* ptr. to original I/O buf */ - int rf_flags; /* misc. flags */ - RF_DiskQueueData_t *req; /* the request that this was part of.. */ + struct buf rf_buf; /* new I/O buf. MUST BE FIRST!!! */ + struct buf *rf_obp; /* ptr. to original I/O buf */ + int rf_flags; /* misc. flags */ + RF_DiskQueueData_t *req; /* the request that this was + * part of.. */ }; #define RAIDGETBUF(rs) pool_get(&(rs)->sc_cbufpool, PR_NOWAIT) #define RAIDPUTBUF(rs, cbp) pool_put(&(rs)->sc_cbufpool, cbp) -/* XXX Not sure if the following should be replacing the raidPtrs above, -or if it should be used in conjunction with that... */ +/* XXX Not sure if the following should be replacing the raidPtrs above, + or if it should be used in conjunction with that... */ struct raid_softc { - int sc_unit; /* logical unit number */ - int sc_flags; /* flags */ - int sc_cflags; /* configuration flags */ - size_t sc_size; /* size of the raid device */ - dev_t sc_dev; /* our device..*/ - char sc_xname[20]; /* XXX external name */ - struct disk sc_dkdev; /* generic disk device info */ - struct pool sc_cbufpool; /* component buffer pool */ + int sc_unit;/* logical unit number */ + int sc_flags; /* flags */ + int sc_cflags; /* configuration flags */ + size_t sc_size;/* size of the raid device */ + dev_t sc_dev; /* our device.. */ + char sc_xname[20]; /* XXX external name */ + struct disk sc_dkdev; /* generic disk device info */ + struct pool sc_cbufpool; /* component buffer pool */ }; - /* sc_flags */ #define RAIDF_INITED 0x01 /* unit has been initialized */ #define RAIDF_WLABEL 0x02 /* label area is writable */ @@ -455,7 +268,7 @@ struct raid_softc { #define RAIDF_LOCKED 0x80 /* unit is locked */ #define raidunit(x) DISKUNIT(x) -static int numraid=0; +static int numraid = 0; #define RAIDLABELDEV(dev) \ (MAKEDISKDEV(major((dev)), raidunit((dev)), RAW_PART)) @@ -463,23 +276,24 @@ static int numraid=0; /* declared here, and made public, for the benefit of KVM stuff.. */ struct raid_softc *raid_softc; -static void raidgetdefaultlabel __P((RF_Raid_t *, struct raid_softc *, struct disklabel *)); -static void raidgetdisklabel __P((dev_t)); -static void raidmakedisklabel __P((struct raid_softc *)); +static void raidgetdefaultlabel __P((RF_Raid_t *, struct raid_softc *, + struct disklabel *)); +static void raidgetdisklabel __P((dev_t)); +static void raidmakedisklabel __P((struct raid_softc *)); -static int raidlock __P((struct raid_softc *)); -static void raidunlock __P((struct raid_softc *)); -int raidlookup __P((char *, struct proc *p, struct vnode **)); +static int raidlock __P((struct raid_softc *)); +static void raidunlock __P((struct raid_softc *)); +int raidlookup __P((char *, struct proc * p, struct vnode **)); void raidattach(num) - int num; + int num; { - int raidID; + int raidID; #ifdef DEBUG - printf("raidattach: Asked for %d units\n",num); + printf("raidattach: Asked for %d units\n", num); #endif if (num <= 0) { @@ -488,9 +302,7 @@ raidattach(num) #endif return; } - /* - This is where all the initialization stuff gets done. - */ + /* This is where all the initialization stuff gets done. */ /* Make some space for requested number of units... */ @@ -498,24 +310,18 @@ raidattach(num) if (raidPtrs == NULL) { panic("raidPtrs is NULL!!\n"); } - - - rf_kbooted = rf_boot(); if (rf_kbooted) { panic("Serious error booting RAID!!\n"); } - - rf_kbooted = RFK_BOOT_GOOD; - - /* - put together some datastructures like the CCD device does.. - This lets us lock the device and what-not when it gets opened. - */ - + rf_kbooted = RFK_BOOT_GOOD; + + /* put together some datastructures like the CCD device does.. This + * lets us lock the device and what-not when it gets opened. */ + raid_softc = (struct raid_softc *) - malloc(num * sizeof(struct raid_softc), - M_DEVBUF, M_NOWAIT); + malloc(num * sizeof(struct raid_softc), + M_RAIDFRAME, M_NOWAIT); if (raid_softc == NULL) { printf("WARNING: no memory for RAIDframe driver\n"); return; @@ -523,11 +329,11 @@ raidattach(num) numraid = num; bzero(raid_softc, num * sizeof(struct raid_softc)); - for(raidID=0;raidID < num;raidID++) { - RF_Calloc(raidPtrs[raidID], 1, sizeof(RF_Raid_t), - (RF_Raid_t *)); - if (raidPtrs[raidID]==NULL) { - printf("raidPtrs[%d] is NULL\n",raidID); + for (raidID = 0; raidID < num; raidID++) { + RF_Calloc(raidPtrs[raidID], 1, sizeof(RF_Raid_t), + (RF_Raid_t *)); + if (raidPtrs[raidID] == NULL) { + printf("raidPtrs[%d] is NULL\n", raidID); } } } @@ -535,11 +341,11 @@ raidattach(num) int raidsize(dev) - dev_t dev; + dev_t dev; { struct raid_softc *rs; struct disklabel *lp; - int part, unit, omask, size; + int part, unit, omask, size; unit = raidunit(dev); if (unit >= numraid) @@ -571,50 +377,48 @@ raidsize(dev) int raiddump(dev, blkno, va, size) - dev_t dev; + dev_t dev; daddr_t blkno; caddr_t va; - size_t size; + size_t size; { /* Not implemented. */ return ENXIO; } - /* ARGSUSED */ int raidopen(dev, flags, fmt, p) - dev_t dev; - int flags, fmt; + dev_t dev; + int flags, fmt; struct proc *p; { - int unit = raidunit(dev); + int unit = raidunit(dev); struct raid_softc *rs; struct disklabel *lp; - int part,pmask; + int part, pmask; unsigned int raidID; - int rc; - int error = 0; - - /* This whole next chunk of code is somewhat suspect... Not sure - it's needed here at all... XXX */ + int rc; + int error = 0; + + /* This whole next chunk of code is somewhat suspect... Not sure it's + * needed here at all... XXX */ - if (rf_kbooted == RFK_BOOT_NONE) { + if (rf_kbooted == RFK_BOOT_NONE) { printf("Doing restart on raidopen.\n"); rf_kbooted = RFK_BOOT_GOOD; rc = rf_boot(); if (rc) { rf_kbooted = RFK_BOOT_BAD; printf("Someone is unhappy...\n"); - return(rc); + return (rc); } } - if (unit >= numraid) return (ENXIO); rs = &raid_softc[unit]; if ((error = raidlock(rs)) != 0) - return(error); + return (error); lp = rs->sc_dkdev.dk_label; raidID = raidunit(dev); @@ -623,12 +427,12 @@ raidopen(dev, flags, fmt, p) pmask = (1 << part); db1_printf(("Opening raid device number: %d partition: %d\n", - raidID,part)); + raidID, part)); if ((rs->sc_flags & RAIDF_INITED) && (rs->sc_dkdev.dk_openmask == 0)) - raidgetdisklabel(dev); + raidgetdisklabel(dev); /* make sure that this partition exists */ @@ -636,14 +440,13 @@ raidopen(dev, flags, fmt, p) db1_printf(("Not a raw partition..\n")); if (((rs->sc_flags & RAIDF_INITED) == 0) || ((part >= lp->d_npartitions) || - (lp->d_partitions[part].p_fstype == FS_UNUSED))) { + (lp->d_partitions[part].p_fstype == FS_UNUSED))) { error = ENXIO; raidunlock(rs); db1_printf(("Bailing out...\n")); - return(error); + return (error); } } - /* Prevent this unit from being unconfigured while open. */ switch (fmt) { case S_IFCHR: @@ -659,22 +462,21 @@ raidopen(dev, flags, fmt, p) raidunlock(rs); - return(error); + return (error); } - /* ARGSUSED */ int raidclose(dev, flags, fmt, p) - dev_t dev; - int flags, fmt; + dev_t dev; + int flags, fmt; struct proc *p; { - int unit = raidunit(dev); + int unit = raidunit(dev); struct raid_softc *rs; - int error = 0; - int part; + int error = 0; + int part; if (unit >= numraid) return (ENXIO); @@ -713,16 +515,16 @@ raidstrategy(bp) RF_Raid_t *raidPtr; struct raid_softc *rs = &raid_softc[raidID]; struct disklabel *lp; - int wlabel; + int wlabel; #if 0 - db1_printf(("Strategy: 0x%x 0x%x\n",bp,bp->b_data)); - db1_printf(("Strategy(2): bp->b_bufsize%d\n", (int)bp->b_bufsize)); - db1_printf(("bp->b_count=%d\n",(int)bp->b_bcount)); - db1_printf(("bp->b_resid=%d\n",(int)bp->b_resid)); - db1_printf(("bp->b_blkno=%d\n",(int)bp->b_blkno)); + db1_printf(("Strategy: 0x%x 0x%x\n", bp, bp->b_data)); + db1_printf(("Strategy(2): bp->b_bufsize%d\n", (int) bp->b_bufsize)); + db1_printf(("bp->b_count=%d\n", (int) bp->b_bcount)); + db1_printf(("bp->b_resid=%d\n", (int) bp->b_resid)); + db1_printf(("bp->b_blkno=%d\n", (int) bp->b_blkno)); - if (bp->b_flags&B_READ) + if (bp->b_flags & B_READ) db1_printf(("READ\n")); else db1_printf(("WRITE\n")); @@ -756,45 +558,43 @@ raidstrategy(bp) * error, the bounds check will flag that for us. */ - wlabel = rs->sc_flags & (RAIDF_WLABEL|RAIDF_LABELLING); + wlabel = rs->sc_flags & (RAIDF_WLABEL | RAIDF_LABELLING); if (DISKPART(bp->b_dev) != RAW_PART) if (bounds_check_with_label(bp, lp, wlabel) <= 0) { db1_printf(("Bounds check failed!!:%d %d\n", - (int)bp->b_blkno,(int)wlabel)); + (int) bp->b_blkno, (int) wlabel)); biodone(bp); return; } - - s = splbio(); /* XXX Needed? */ + s = splbio(); /* XXX Needed? */ db1_printf(("Beginning strategy...\n")); - + bp->b_resid = 0; - bp->b_error = rf_DoAccessKernel(raidPtrs[raidID], bp, - NULL, NULL, NULL); + bp->b_error = rf_DoAccessKernel(raidPtrs[raidID], bp, + NULL, NULL, NULL); if (bp->b_error) { bp->b_flags |= B_ERROR; db1_printf(("bp->b_flags HAS B_ERROR SET!!!: %d\n", - bp->b_error)); + bp->b_error)); } splx(s); #if 0 db1_printf(("Strategy exiting: 0x%x 0x%x %d %d\n", - bp,bp->b_data, - (int)bp->b_bcount,(int)bp->b_resid)); + bp, bp->b_data, + (int) bp->b_bcount, (int) bp->b_resid)); #endif } - /* ARGSUSED */ int raidread(dev, uio, flags) - dev_t dev; + dev_t dev; struct uio *uio; - int flags; + int flags; { - int unit = raidunit(dev); + int unit = raidunit(dev); struct raid_softc *rs; - int result; - int part; + int result; + int part; if (unit >= numraid) return (ENXIO); @@ -804,26 +604,25 @@ raidread(dev, uio, flags) return (ENXIO); part = DISKPART(dev); - db1_printf(("raidread: unit: %d partition: %d\n",unit,part)); + db1_printf(("raidread: unit: %d partition: %d\n", unit, part)); #if 0 return (physio(raidstrategy, NULL, dev, B_READ, minphys, uio)); #endif - result=physio(raidstrategy, NULL, dev, B_READ, minphys, uio); + result = physio(raidstrategy, NULL, dev, B_READ, minphys, uio); db1_printf(("raidread done. Result is %d %d\n", - result,uio->uio_resid)); - return(result); + result, uio->uio_resid)); + return (result); } - /* ARGSUSED */ int raidwrite(dev, uio, flags) - dev_t dev; + dev_t dev; struct uio *uio; - int flags; + int flags; { - int unit = raidunit(dev); + int unit = raidunit(dev); struct raid_softc *rs; if (unit >= numraid) @@ -840,31 +639,31 @@ raidwrite(dev, uio, flags) int raidioctl(dev, cmd, data, flag, p) - dev_t dev; - u_long cmd; + dev_t dev; + u_long cmd; caddr_t data; - int flag; + int flag; struct proc *p; { - int unit = raidunit(dev); - int error = 0; - int part, pmask; + int unit = raidunit(dev); + int error = 0; + int part, pmask; struct raid_softc *rs; #if 0 - int r,c; + int r, c; #endif - /* struct raid_ioctl *ccio = (struct ccd_ioctl *)data; */ + /* struct raid_ioctl *ccio = (struct ccd_ioctl *)data; */ - /* struct ccdbuf *cbp; */ - /* struct raidbuf *raidbp; */ + /* struct ccdbuf *cbp; */ + /* struct raidbuf *raidbp; */ RF_Config_t *k_cfg, *u_cfg; u_char *specific_buf; - int retcode = 0; + int retcode = 0; - int row; + int row; struct rf_recon_req *rrcopy, *rr; #if 0 - int nbytes, spl, rw, row; + int nbytes, spl, rw, row; struct rf_test_acc *ta; struct buf *bp; RF_SparetWait_t *waitreq; @@ -875,8 +674,8 @@ raidioctl(dev, cmd, data, flag, p) return (ENXIO); rs = &raid_softc[unit]; - db1_printf(("raidioctl: %d %d %d %d\n",(int)dev, - (int)DISKPART(dev),(int)unit,(int)cmd)); + db1_printf(("raidioctl: %d %d %d %d\n", (int) dev, + (int) DISKPART(dev), (int) unit, (int) cmd)); /* Must be open for writes for these commands... */ switch (cmd) { @@ -908,7 +707,7 @@ raidioctl(dev, cmd, data, flag, p) if ((rs->sc_flags & RAIDF_INITED) == 0) return (ENXIO); } - + switch (cmd) { @@ -918,57 +717,56 @@ raidioctl(dev, cmd, data, flag, p) db3_printf(("rf_ioctl: RAIDFRAME_CONFIGURE\n")); /* copy-in the configuration information */ /* data points to a pointer to the configuration structure */ - u_cfg = *((RF_Config_t **) data); - RF_Malloc(k_cfg,sizeof(RF_Config_t),(RF_Config_t *)); + u_cfg = *((RF_Config_t **) data); + RF_Malloc(k_cfg, sizeof(RF_Config_t), (RF_Config_t *)); if (k_cfg == NULL) { db3_printf(("rf_ioctl: ENOMEM for config. Code is %d\n", retcode)); - return(ENOMEM); + return (ENOMEM); } - retcode = copyin((caddr_t) u_cfg, (caddr_t) k_cfg, - sizeof(RF_Config_t)); + retcode = copyin((caddr_t) u_cfg, (caddr_t) k_cfg, + sizeof(RF_Config_t)); if (retcode) { - db3_printf(("rf_ioctl: retcode=%d copyin.1\n", - retcode)); - return(retcode); + db3_printf(("rf_ioctl: retcode=%d copyin.1\n", + retcode)); + return (retcode); } - - /* allocate a buffer for the layout-specific data, - and copy it in */ + /* allocate a buffer for the layout-specific data, and copy it + * in */ if (k_cfg->layoutSpecificSize) { - if (k_cfg->layoutSpecificSize > 10000) { + if (k_cfg->layoutSpecificSize > 10000) { /* sanity check */ db3_printf(("rf_ioctl: EINVAL %d\n", retcode)); - return(EINVAL); + return (EINVAL); } - RF_Malloc(specific_buf,k_cfg->layoutSpecificSize, - (u_char *)); + RF_Malloc(specific_buf, k_cfg->layoutSpecificSize, + (u_char *)); if (specific_buf == NULL) { - RF_Free(k_cfg,sizeof(RF_Config_t)); + RF_Free(k_cfg, sizeof(RF_Config_t)); db3_printf(("rf_ioctl: ENOMEM %d\n", retcode)); - return(ENOMEM); + return (ENOMEM); } - retcode = copyin(k_cfg->layoutSpecific, - (caddr_t) specific_buf, - k_cfg->layoutSpecificSize); + retcode = copyin(k_cfg->layoutSpecific, + (caddr_t) specific_buf, + k_cfg->layoutSpecificSize); if (retcode) { db3_printf(("rf_ioctl: retcode=%d copyin.2\n", - retcode)); - return(retcode); + retcode)); + return (retcode); } - } else specific_buf = NULL; + } else + specific_buf = NULL; k_cfg->layoutSpecific = specific_buf; - - /* should do some kind of sanity check on the configuration. - Store the sum of all the bytes in the last byte? - */ + + /* should do some kind of sanity check on the configuration. + * Store the sum of all the bytes in the last byte? */ #if 0 db1_printf(("Considering configuring the system.:%d 0x%x\n", - unit,p)); + unit, p)); #endif - /* We need the pointer to this a little deeper, so - stash it here... */ + /* We need the pointer to this a little deeper, so stash it + * here... */ raidPtrs[unit]->proc = p; @@ -979,26 +777,25 @@ raidioctl(dev, cmd, data, flag, p) raidPtrs[unit]->raidid = unit; retcode = rf_Configure(raidPtrs[unit], k_cfg); - - if (retcode == 0) { - retcode = raidinit(dev, raidPtrs[unit],unit); - } + if (retcode == 0) { + retcode = raidinit(dev, raidPtrs[unit], unit); + } /* free the buffers. No return code here. */ if (k_cfg->layoutSpecificSize) { - RF_Free(specific_buf,k_cfg->layoutSpecificSize); + RF_Free(specific_buf, k_cfg->layoutSpecificSize); } - RF_Free(k_cfg,sizeof(RF_Config_t)); - - db3_printf(("rf_ioctl: retcode=%d RAIDFRAME_CONFIGURE\n", - retcode)); - return(retcode); - - /* shutdown the system */ + RF_Free(k_cfg, sizeof(RF_Config_t)); + + db3_printf(("rf_ioctl: retcode=%d RAIDFRAME_CONFIGURE\n", + retcode)); + return (retcode); + + /* shutdown the system */ case RAIDFRAME_SHUTDOWN: - - if ((error = raidlock(rs)) != 0) - return(error); + + if ((error = raidlock(rs)) != 0) + return (error); /* * If somebody has a partition mounted, we shouldn't @@ -1007,26 +804,24 @@ raidioctl(dev, cmd, data, flag, p) part = DISKPART(dev); pmask = (1 << part); - if ((rs->sc_dkdev.dk_openmask & ~pmask) || - ((rs->sc_dkdev.dk_bopenmask & pmask) && - (rs->sc_dkdev.dk_copenmask & pmask))) { - raidunlock(rs); - return (EBUSY); - } - + if ((rs->sc_dkdev.dk_openmask & ~pmask) || + ((rs->sc_dkdev.dk_bopenmask & pmask) && + (rs->sc_dkdev.dk_copenmask & pmask))) { + raidunlock(rs); + return (EBUSY); + } /* the intention here was to disallow shutdowns while - raidframe is mounted, but it doesn't work because the - shutdown ioctl calls rf_open - */ + * raidframe is mounted, but it doesn't work because the + * shutdown ioctl calls rf_open */ if (rf_pending_testaccs > 0) { printf("RAIDFRAME: Can't shutdown because there are %d pending test accs\n", - rf_pending_testaccs); - return(EINVAL); + rf_pending_testaccs); + return (EINVAL); } if (rf_debugKernelAccess) { printf("call shutdown\n"); } - raidPtrs[unit]->proc = p; /* XXX necessary evil */ + raidPtrs[unit]->proc = p; /* XXX necessary evil */ retcode = rf_Shutdown(raidPtrs[unit]); db1_printf(("Done main shutdown\n")); @@ -1037,112 +832,112 @@ raidioctl(dev, cmd, data, flag, p) /* It's no longer initialized... */ rs->sc_flags &= ~RAIDF_INITED; - /* Detach the disk. */ - disk_detach(&rs->sc_dkdev); + /* Detach the disk. */ + disk_detach(&rs->sc_dkdev); raidunlock(rs); - return(retcode); - + return (retcode); + /* initialize all parity */ case RAIDFRAME_REWRITEPARITY: - if (raidPtrs[unit]->Layout.map->faultsTolerated == 0) - return(EINVAL); + if (raidPtrs[unit]->Layout.map->faultsTolerated == 0) + return (EINVAL); /* borrow the thread of the requesting process */ - raidPtrs[unit]->proc = p; /* Blah... :-p GO */ + raidPtrs[unit]->proc = p; /* Blah... :-p GO */ retcode = rf_RewriteParity(raidPtrs[unit]); - /* return I/O Error if the parity rewrite fails */ + /* return I/O Error if the parity rewrite fails */ - if (retcode) - retcode = EIO; - return(retcode); + if (retcode) + retcode = EIO; + return (retcode); - /* issue a test-unit-ready through raidframe to the - indicated device */ -#if 0 /* XXX not supported yet (ever?) */ + /* issue a test-unit-ready through raidframe to the indicated + * device */ +#if 0 /* XXX not supported yet (ever?) */ case RAIDFRAME_TUR: /* debug only */ - retcode = rf_SCSI_DoTUR(0, 0, 0, 0, *(dev_t *) data); - return(retcode); + retcode = rf_SCSI_DoTUR(0, 0, 0, 0, *(dev_t *) data); + return (retcode); #endif case RAIDFRAME_GET_INFO: { RF_Raid_t *raid = raidPtrs[unit]; RF_DeviceConfig_t *cfg, **ucfgp; - int i, j, d; - + int i, j, d; + if (!raid->valid) - return(ENODEV); - ucfgp = (RF_DeviceConfig_t **)data; - RF_Malloc(cfg,sizeof(RF_DeviceConfig_t), - (RF_DeviceConfig_t *)); + return (ENODEV); + ucfgp = (RF_DeviceConfig_t **) data; + RF_Malloc(cfg, sizeof(RF_DeviceConfig_t), + (RF_DeviceConfig_t *)); if (cfg == NULL) - return(ENOMEM); - bzero((char *)cfg, sizeof(RF_DeviceConfig_t)); + return (ENOMEM); + bzero((char *) cfg, sizeof(RF_DeviceConfig_t)); cfg->rows = raid->numRow; cfg->cols = raid->numCol; cfg->ndevs = raid->numRow * raid->numCol; if (cfg->ndevs >= RF_MAX_DISKS) { cfg->ndevs = 0; - return(ENOMEM); + return (ENOMEM); } cfg->nspares = raid->numSpare; if (cfg->nspares >= RF_MAX_DISKS) { cfg->nspares = 0; - return(ENOMEM); + return (ENOMEM); } cfg->maxqdepth = raid->maxQueueDepth; d = 0; - for(i=0;i<cfg->rows;i++) { - for(j=0;j<cfg->cols;j++) { + for (i = 0; i < cfg->rows; i++) { + for (j = 0; j < cfg->cols; j++) { cfg->devs[d] = raid->Disks[i][j]; d++; } } - for(j=cfg->cols,i=0;i<cfg->nspares;i++,j++) { + for (j = cfg->cols, i = 0; i < cfg->nspares; i++, j++) { cfg->spares[i] = raid->Disks[0][j]; } - retcode = copyout((caddr_t)cfg, (caddr_t)*ucfgp, - sizeof(RF_DeviceConfig_t)); - RF_Free(cfg,sizeof(RF_DeviceConfig_t)); - - return(retcode); + retcode = copyout((caddr_t) cfg, (caddr_t) * ucfgp, + sizeof(RF_DeviceConfig_t)); + RF_Free(cfg, sizeof(RF_DeviceConfig_t)); + + return (retcode); } - break; - + break; + case RAIDFRAME_RESET_ACCTOTALS: { RF_Raid_t *raid = raidPtrs[unit]; - + bzero(&raid->acc_totals, sizeof(raid->acc_totals)); - return(0); + return (0); } - break; - + break; + case RAIDFRAME_GET_ACCTOTALS: { - RF_AccTotals_t *totals = (RF_AccTotals_t *)data; + RF_AccTotals_t *totals = (RF_AccTotals_t *) data; RF_Raid_t *raid = raidPtrs[unit]; - + *totals = raid->acc_totals; - return(0); + return (0); } - break; - + break; + case RAIDFRAME_KEEP_ACCTOTALS: { RF_Raid_t *raid = raidPtrs[unit]; - int *keep = (int *)data; - + int *keep = (int *) data; + raid->keep_acc_totals = *keep; - return(0); + return (0); } - break; - + break; + case RAIDFRAME_GET_SIZE: *(int *) data = raidPtrs[unit]->totalSectors; - return(0); + return (0); #define RAIDFRAME_RECON 1 /* XXX The above should probably be set somewhere else!! GO */ @@ -1151,15 +946,15 @@ raidioctl(dev, cmd, data, flag, p) /* fail a disk & optionally start reconstruction */ case RAIDFRAME_FAIL_DISK: rr = (struct rf_recon_req *) data; - - if (rr->row < 0 || rr->row >= raidPtrs[unit]->numRow + + if (rr->row < 0 || rr->row >= raidPtrs[unit]->numRow || rr->col < 0 || rr->col >= raidPtrs[unit]->numCol) - return(EINVAL); + return (EINVAL); + + printf("Failing the disk: row: %d col: %d\n", rr->row, rr->col); - printf("Failing the disk: row: %d col: %d\n",rr->row,rr->col); - - /* make a copy of the recon request so that we don't - rely on the user's buffer */ + /* make a copy of the recon request so that we don't rely on + * the user's buffer */ RF_Malloc(rrcopy, sizeof(*rrcopy), (struct rf_recon_req *)); bcopy(rr, rrcopy, sizeof(*rr)); rrcopy->raidPtr = (void *) raidPtrs[unit]; @@ -1169,54 +964,52 @@ raidioctl(dev, cmd, data, flag, p) recon_queue = rrcopy; wakeup(&recon_queue); UNLOCK_RECON_Q_MUTEX(); - - return(0); - - /* invoke a copyback operation after recon on whatever - disk needs it, if any */ - case RAIDFRAME_COPYBACK: + + return (0); + + /* invoke a copyback operation after recon on whatever disk + * needs it, if any */ + case RAIDFRAME_COPYBACK: /* borrow the current thread to get this done */ - raidPtrs[unit]->proc = p; /* ICK.. but needed :-p GO */ + raidPtrs[unit]->proc = p; /* ICK.. but needed :-p GO */ rf_CopybackReconstructedData(raidPtrs[unit]); - return(0); - + return (0); + /* return the percentage completion of reconstruction */ case RAIDFRAME_CHECKRECON: row = *(int *) data; if (row < 0 || row >= raidPtrs[unit]->numRow) - return(EINVAL); - if (raidPtrs[unit]->status[row] != rf_rs_reconstructing) + return (EINVAL); + if (raidPtrs[unit]->status[row] != rf_rs_reconstructing) *(int *) data = 100; - else + else *(int *) data = raidPtrs[unit]->reconControl[row]->percentComplete; - return(0); - - /* the sparetable daemon calls this to wait for the - kernel to need a spare table. - * this ioctl does not return until a spare table is needed. - * XXX -- calling mpsleep here in the ioctl code is almost - certainly wrong and evil. -- XXX - * XXX -- I should either compute the spare table in the - kernel, or have a different -- XXX - * XXX -- interface (a different character device) for - delivering the table -- XXX - */ + return (0); + + /* the sparetable daemon calls this to wait for the kernel to + * need a spare table. this ioctl does not return until a + * spare table is needed. XXX -- calling mpsleep here in the + * ioctl code is almost certainly wrong and evil. -- XXX XXX + * -- I should either compute the spare table in the kernel, + * or have a different -- XXX XXX -- interface (a different + * character device) for delivering the table -- XXX */ #if 0 case RAIDFRAME_SPARET_WAIT: RF_LOCK_MUTEX(rf_sparet_wait_mutex); - while (!rf_sparet_wait_queue) mpsleep(&rf_sparet_wait_queue, (PZERO+1)|PCATCH, "sparet wait", 0, (void *) simple_lock_addr(rf_sparet_wait_mutex), MS_LOCK_SIMPLE); + while (!rf_sparet_wait_queue) + mpsleep(&rf_sparet_wait_queue, (PZERO + 1) | PCATCH, "sparet wait", 0, (void *) simple_lock_addr(rf_sparet_wait_mutex), MS_LOCK_SIMPLE); waitreq = rf_sparet_wait_queue; rf_sparet_wait_queue = rf_sparet_wait_queue->next; RF_UNLOCK_MUTEX(rf_sparet_wait_mutex); - - *((RF_SparetWait_t *) data) = *waitreq; /* structure assignment */ - + + *((RF_SparetWait_t *) data) = *waitreq; /* structure assignment */ + RF_Free(waitreq, sizeof(*waitreq)); - return(0); - - - /* wakes up a process waiting on SPARET_WAIT and puts an - error code in it that will cause the dameon to exit */ + return (0); + + + /* wakes up a process waiting on SPARET_WAIT and puts an error + * code in it that will cause the dameon to exit */ case RAIDFRAME_ABORT_SPARET_WAIT: RF_Malloc(waitreq, sizeof(*waitreq), (RF_SparetWait_t *)); waitreq->fcol = -1; @@ -1225,17 +1018,17 @@ raidioctl(dev, cmd, data, flag, p) rf_sparet_wait_queue = waitreq; RF_UNLOCK_MUTEX(rf_sparet_wait_mutex); wakeup(&rf_sparet_wait_queue); - return(0); + return (0); - /* used by the spare table daemon to deliver a spare table - into the kernel */ + /* used by the spare table daemon to deliver a spare table + * into the kernel */ case RAIDFRAME_SEND_SPARET: - + /* install the spare table */ - retcode = rf_SetSpareTable(raidPtrs[unit],*(void **) data); - - /* respond to the requestor. the return status of the - spare table installation is passed in the "fcol" field */ + retcode = rf_SetSpareTable(raidPtrs[unit], *(void **) data); + + /* respond to the requestor. the return status of the spare + * table installation is passed in the "fcol" field */ RF_Malloc(waitreq, sizeof(*waitreq), (RF_SparetWait_t *)); waitreq->fcol = retcode; RF_LOCK_MUTEX(rf_sparet_wait_mutex); @@ -1243,34 +1036,35 @@ raidioctl(dev, cmd, data, flag, p) rf_sparet_resp_queue = waitreq; wakeup(&rf_sparet_resp_queue); RF_UNLOCK_MUTEX(rf_sparet_wait_mutex); - - return(retcode); + + return (retcode); #endif -#endif /* RAIDFRAME_RECON > 0 */ +#endif /* RAIDFRAME_RECON > 0 */ + + default: + break; /* fall through to the os-specific code below */ - default: break; /* fall through to the os-specific code below */ - } - + if (!raidPtrs[unit]->valid) - return(EINVAL); - + return (EINVAL); + /* * Add support for "regular" device ioctls here. */ - + switch (cmd) { case DIOCGDINFO: - db1_printf(("DIOCGDINFO %d %d\n",(int)dev,(int)DISKPART(dev))); - *(struct disklabel *)data = *(rs->sc_dkdev.dk_label); + db1_printf(("DIOCGDINFO %d %d\n", (int) dev, (int) DISKPART(dev))); + *(struct disklabel *) data = *(rs->sc_dkdev.dk_label); break; case DIOCGPART: - db1_printf(("DIOCGPART: %d %d\n",(int)dev,(int)DISKPART(dev))); - ((struct partinfo *)data)->disklab = rs->sc_dkdev.dk_label; - ((struct partinfo *)data)->part = + db1_printf(("DIOCGPART: %d %d\n", (int) dev, (int) DISKPART(dev))); + ((struct partinfo *) data)->disklab = rs->sc_dkdev.dk_label; + ((struct partinfo *) data)->part = &rs->sc_dkdev.dk_label->d_partitions[DISKPART(dev)]; break; @@ -1284,14 +1078,13 @@ raidioctl(dev, cmd, data, flag, p) rs->sc_flags |= RAIDF_LABELLING; error = setdisklabel(rs->sc_dkdev.dk_label, - (struct disklabel *)data, 0, rs->sc_dkdev.dk_cpulabel); + (struct disklabel *) data, 0, rs->sc_dkdev.dk_cpulabel); if (error == 0) { if (cmd == DIOCWDINFO) error = writedisklabel(RAIDLABELDEV(dev), raidstrategy, rs->sc_dkdev.dk_label, rs->sc_dkdev.dk_cpulabel); } - rs->sc_flags &= ~RAIDF_LABELLING; raidunlock(rs); @@ -1302,7 +1095,7 @@ raidioctl(dev, cmd, data, flag, p) case DIOCWLABEL: db1_printf(("DIOCWLABEL\n")); - if (*(int *)data != 0) + if (*(int *) data != 0) rs->sc_flags |= RAIDF_WLABEL; else rs->sc_flags &= ~RAIDF_WLABEL; @@ -1311,55 +1104,55 @@ raidioctl(dev, cmd, data, flag, p) case DIOCGDEFLABEL: db1_printf(("DIOCGDEFLABEL\n")); raidgetdefaultlabel(raidPtrs[unit], rs, - (struct disklabel *)data); + (struct disklabel *) data); break; default: - retcode = ENOTTY; /* XXXX ?? OR EINVAL ? */ + retcode = ENOTTY; /* XXXX ?? OR EINVAL ? */ } - return(retcode); + return (retcode); } -/* raidinit -- complete the rest of the initialization for the +/* raidinit -- complete the rest of the initialization for the RAIDframe device. */ static int -raidinit(dev, raidPtr,unit) - dev_t dev; +raidinit(dev, raidPtr, unit) + dev_t dev; RF_Raid_t *raidPtr; - int unit; + int unit; { - int retcode; - /* int ix; */ - /* struct raidbuf *raidbp; */ + int retcode; + /* int ix; */ + /* struct raidbuf *raidbp; */ struct raid_softc *rs; retcode = 0; rs = &raid_softc[unit]; pool_init(&rs->sc_cbufpool, sizeof(struct raidbuf), 0, - 0, 0, "raidpl", 0, NULL, NULL, M_DEVBUF); + 0, 0, "raidpl", 0, NULL, NULL, M_RAIDFRAME); + - /* XXX should check return code first... */ rs->sc_flags |= RAIDF_INITED; - sprintf(rs->sc_xname, "raid%d", unit); /* XXX doesn't check bounds.*/ + sprintf(rs->sc_xname, "raid%d", unit); /* XXX doesn't check bounds. */ - rs->sc_dkdev.dk_name = rs->sc_xname; + rs->sc_dkdev.dk_name = rs->sc_xname; /* disk_attach actually creates space for the CPU disklabel, among - other things, so it's critical to call this *BEFORE* we - try putzing with disklabels. */ + * other things, so it's critical to call this *BEFORE* we try putzing + * with disklabels. */ disk_attach(&rs->sc_dkdev); /* XXX There may be a weird interaction here between this, and - protectedSectors, as used in RAIDframe. */ - rs->sc_size = raidPtr->totalSectors; + * protectedSectors, as used in RAIDframe. */ + rs->sc_size = raidPtr->totalSectors; rs->sc_dev = dev; - return(retcode); + return (retcode); } @@ -1368,118 +1161,123 @@ raidinit(dev, raidPtr,unit) * initialization code called at boot time (startup.c) * ********************************************************/ -int rf_boot() +int +rf_boot() { - int i, rc; - - rc = rf_mutex_init(&rf_sparet_wait_mutex); - if (rc) { - RF_PANIC(); - } - rc = rf_mutex_init(&rf_async_done_q_mutex); - if (rc) { - RF_PANIC(); - } - rf_sparet_wait_queue = rf_sparet_resp_queue = NULL; - recon_queue = NULL; - rf_async_done_qh = rf_async_done_qt = NULL; - for (i=0; i<numraid; i++) - raidPtrs[i] = NULL; - rc = rf_BootRaidframe(); - if (rc == 0) - printf("Kernelized RAIDframe activated\n"); - else - rf_kbooted = RFK_BOOT_BAD; - return(rc); -} + int i, rc; + rc = rf_mutex_init(&rf_sparet_wait_mutex); + if (rc) { + RF_PANIC(); + } + rc = rf_mutex_init(&rf_async_done_q_mutex); + if (rc) { + RF_PANIC(); + } + rf_sparet_wait_queue = rf_sparet_resp_queue = NULL; + recon_queue = NULL; + rf_async_done_qh = rf_async_done_qt = NULL; + for (i = 0; i < numraid; i++) + raidPtrs[i] = NULL; + rc = rf_BootRaidframe(); + if (rc == 0) + printf("Kernelized RAIDframe activated\n"); + else + rf_kbooted = RFK_BOOT_BAD; + return (rc); +} /* * This kernel thread never exits. It is created once, and persists * until the system reboots. */ -void rf_ReconKernelThread() +void +rf_ReconKernelThread() { - struct rf_recon_req *req; - int s; - - /* XXX not sure what spl() level we should be at here... probably splbio() */ - s=splbio(); - - while (1) { - /* grab the next reconstruction request from the queue */ - LOCK_RECON_Q_MUTEX(); - while (!recon_queue) { - UNLOCK_RECON_Q_MUTEX(); - tsleep(&recon_queue, PRIBIO | PCATCH, "raidframe recon", 0); - LOCK_RECON_Q_MUTEX(); - } - req = recon_queue; - recon_queue = recon_queue->next; - UNLOCK_RECON_Q_MUTEX(); - - /* - * If flags specifies that we should start recon, this call - * will not return until reconstruction completes, fails, or is aborted. - */ - rf_FailDisk((RF_Raid_t *) req->raidPtr, req->row, req->col, - ((req->flags&RF_FDFLAGS_RECON) ? 1 : 0)); - - RF_Free(req, sizeof(*req)); - } + struct rf_recon_req *req; + int s; + + /* XXX not sure what spl() level we should be at here... probably + * splbio() */ + s = splbio(); + + while (1) { + /* grab the next reconstruction request from the queue */ + LOCK_RECON_Q_MUTEX(); + while (!recon_queue) { + UNLOCK_RECON_Q_MUTEX(); + tsleep(&recon_queue, PRIBIO | PCATCH, "raidframe recon", 0); + LOCK_RECON_Q_MUTEX(); + } + req = recon_queue; + recon_queue = recon_queue->next; + UNLOCK_RECON_Q_MUTEX(); + + /* + * If flags specifies that we should start recon, this call + * will not return until reconstruction completes, fails, or is aborted. + */ + rf_FailDisk((RF_Raid_t *) req->raidPtr, req->row, req->col, + ((req->flags & RF_FDFLAGS_RECON) ? 1 : 0)); + + RF_Free(req, sizeof(*req)); + } } /* wake up the daemon & tell it to get us a spare table * XXX - * the entries in the queues should be tagged with the raidPtr + * the entries in the queues should be tagged with the raidPtr * so that in the extremely rare case that two recons happen at once, we know for * which device were requesting a spare table * XXX */ -int rf_GetSpareTableFromDaemon(req) - RF_SparetWait_t *req; +int +rf_GetSpareTableFromDaemon(req) + RF_SparetWait_t *req; { - int retcode; + 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); + RF_LOCK_MUTEX(rf_sparet_wait_mutex); + req->next = rf_sparet_wait_queue; + rf_sparet_wait_queue = req; + wakeup(&rf_sparet_wait_queue); - /* mpsleep unlocks the mutex */ - while (!rf_sparet_resp_queue) { - tsleep(&rf_sparet_resp_queue, PRIBIO | PCATCH, - "raidframe getsparetable", 0); + /* mpsleep unlocks the mutex */ + while (!rf_sparet_resp_queue) { + tsleep(&rf_sparet_resp_queue, PRIBIO | PCATCH, + "raidframe getsparetable", 0); #if 0 - mpsleep(&rf_sparet_resp_queue, PZERO, "sparet resp", 0, (void *) simple_lock_addr(rf_sparet_wait_mutex), MS_LOCK_SIMPLE); + mpsleep(&rf_sparet_resp_queue, PZERO, "sparet resp", 0, (void *) simple_lock_addr(rf_sparet_wait_mutex), MS_LOCK_SIMPLE); #endif - } - req = rf_sparet_resp_queue; - rf_sparet_resp_queue = req->next; - RF_UNLOCK_MUTEX(rf_sparet_wait_mutex); - - retcode = req->fcol; - RF_Free(req, sizeof(*req)); /* this is not the same req as we alloc'd */ - return(retcode); + } + req = rf_sparet_resp_queue; + rf_sparet_resp_queue = req->next; + RF_UNLOCK_MUTEX(rf_sparet_wait_mutex); + + retcode = req->fcol; + RF_Free(req, sizeof(*req)); /* this is not the same req as we + * alloc'd */ + return (retcode); } - /* a wrapper around rf_DoAccess that extracts appropriate info from the bp & passes it down. * any calls originating in the kernel must use non-blocking I/O * do some extra sanity checking to return "appropriate" error values for * certain conditions (to make some standard utilities work) */ -int rf_DoAccessKernel(raidPtr, bp, flags, cbFunc, cbArg) - RF_Raid_t *raidPtr; - struct buf *bp; - RF_RaidAccessFlags_t flags; - void (*cbFunc)(struct buf *); - void *cbArg; +int +rf_DoAccessKernel(raidPtr, bp, flags, cbFunc, cbArg) + RF_Raid_t *raidPtr; + struct buf *bp; + RF_RaidAccessFlags_t flags; + void (*cbFunc) (struct buf *); + void *cbArg; { RF_SectorCount_t num_blocks, pb, sum; RF_RaidAddr_t raid_addr; - int retcode; + int retcode; struct partition *pp; - daddr_t blocknum; - int unit; + daddr_t blocknum; + int unit; struct raid_softc *rs; + int do_async; /* XXX The dev_t used here should be for /dev/[r]raid* !!! */ @@ -1487,47 +1285,42 @@ int rf_DoAccessKernel(raidPtr, bp, flags, cbFunc, cbArg) rs = &raid_softc[unit]; /* Ok, for the bp we have here, bp->b_blkno is relative to the - partition.. Need to make it absolute to the underlying - device.. */ + * partition.. Need to make it absolute to the underlying device.. */ blocknum = bp->b_blkno; if (DISKPART(bp->b_dev) != RAW_PART) { pp = &rs->sc_dkdev.dk_label->d_partitions[DISKPART(bp->b_dev)]; blocknum += pp->p_offset; - db1_printf(("updated: %d %d\n",DISKPART(bp->b_dev), - pp->p_offset)); + db1_printf(("updated: %d %d\n", DISKPART(bp->b_dev), + pp->p_offset)); } else { db1_printf(("Is raw..\n")); } db1_printf(("Blocks: %d, %d\n", (int) bp->b_blkno, (int) blocknum)); - db1_printf(("bp->b_bcount = %d\n",(int)bp->b_bcount)); - db1_printf(("bp->b_resid = %d\n",(int)bp->b_resid)); + db1_printf(("bp->b_bcount = %d\n", (int) bp->b_bcount)); + db1_printf(("bp->b_resid = %d\n", (int) bp->b_resid)); - /* *THIS* is where we adjust what block we're going to... but - DO NOT TOUCH bp->b_blkno!!! */ + /* *THIS* is where we adjust what block we're going to... but DO NOT + * TOUCH bp->b_blkno!!! */ raid_addr = blocknum; - + num_blocks = bp->b_bcount >> raidPtr->logBytesPerSector; - pb = (bp->b_bcount&raidPtr->sectorMask) ? 1 : 0; + pb = (bp->b_bcount & raidPtr->sectorMask) ? 1 : 0; sum = raid_addr + num_blocks + pb; if (1 || rf_debugKernelAccess) { - db1_printf(("raid_addr=%d sum=%d num_blocks=%d(+%d) (%d)\n", - (int)raid_addr, (int)sum,(int)num_blocks, - (int)pb,(int)bp->b_resid)); + db1_printf(("raid_addr=%d sum=%d num_blocks=%d(+%d) (%d)\n", + (int) raid_addr, (int) sum, (int) num_blocks, + (int) pb, (int) bp->b_resid)); } - - if ((sum > raidPtr->totalSectors) || (sum < raid_addr) - || (sum < num_blocks) || (sum < pb)) - { + || (sum < num_blocks) || (sum < pb)) { bp->b_error = ENOSPC; bp->b_flags |= B_ERROR; bp->b_resid = bp->b_bcount; biodone(bp); - return(bp->b_error); + return (bp->b_error); } - /* * XXX rf_DoAccess() should do this, not just DoAccessKernel() */ @@ -1537,75 +1330,85 @@ int rf_DoAccessKernel(raidPtr, bp, flags, cbFunc, cbArg) bp->b_flags |= B_ERROR; bp->b_resid = bp->b_bcount; biodone(bp); - return(bp->b_error); + return (bp->b_error); } db1_printf(("Calling DoAccess..\n")); - /* don't ever condition on bp->b_flags & B_WRITE. - always condition on B_READ instead */ - retcode = rf_DoAccess(raidPtr, (bp->b_flags & B_READ) ? - RF_IO_TYPE_READ : RF_IO_TYPE_WRITE, - 0, raid_addr, num_blocks, bp->b_un.b_addr, - bp, NULL, NULL, RF_DAG_NONBLOCKING_IO|flags, - NULL, cbFunc, cbArg); + /* + * XXX For now, all writes are sync + */ + do_async = 1; + if ((bp->b_flags & B_READ) == 0) + do_async = 0; + + /* don't ever condition on bp->b_flags & B_WRITE. always condition on + * B_READ instead */ + 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_un.b_addr, + bp, NULL, NULL, RF_DAG_NONBLOCKING_IO | flags, + NULL, cbFunc, cbArg); #if 0 - db1_printf(("After call to DoAccess: 0x%x 0x%x %d\n",bp, - bp->b_data,(int)bp->b_resid)); + db1_printf(("After call to DoAccess: 0x%x 0x%x %d\n", bp, + bp->b_data, (int) bp->b_resid)); #endif - return(retcode); -} + /* + * If we requested sync I/O, sleep here. + */ + if ((retcode == 0) && (do_async == 0)) + tsleep(bp, PRIBIO, "raidsyncio", 0); + + return (retcode); +} /* invoke an I/O from kernel mode. Disk queue should be locked upon entry */ -int rf_DispatchKernelIO(queue, req) - RF_DiskQueue_t *queue; - RF_DiskQueueData_t *req; +int +rf_DispatchKernelIO(queue, req) + RF_DiskQueue_t *queue; + RF_DiskQueueData_t *req; { - int op = (req->type == RF_IO_TYPE_READ) ? B_READ : B_WRITE; + int op = (req->type == RF_IO_TYPE_READ) ? B_READ : B_WRITE; struct buf *bp; - struct raidbuf *raidbp=NULL; + struct raidbuf *raidbp = NULL; struct raid_softc *rs; - int unit; - + int unit; + /* XXX along with the vnode, we also need the softc associated with - this device.. */ - + * this device.. */ + req->queue = queue; - + unit = queue->raidPtr->raidid; - db1_printf(("DispatchKernelIO unit: %d\n",unit)); + db1_printf(("DispatchKernelIO unit: %d\n", unit)); - if (unit >= numraid) { - printf("Invalid unit number: %d %d\n",unit,numraid); + if (unit >= numraid) { + printf("Invalid unit number: %d %d\n", unit, numraid); panic("Invalid Unit number in rf_DispatchKernelIO\n"); } - rs = &raid_softc[unit]; /* XXX is this the right place? */ - disk_busy(&rs->sc_dkdev); + disk_busy(&rs->sc_dkdev); bp = req->bp; - /* - XXX when there is a physical disk failure, someone is passing - us a buffer that contains old stuff!! Attempt to deal with - this problem without taking a performance hit... - (not sure where the real bug is. It's buried in RAIDframe - somewhere) :-( GO ) - */ + /* XXX when there is a physical disk failure, someone is passing us a + * buffer that contains old stuff!! Attempt to deal with this problem + * without taking a performance hit... (not sure where the real bug + * is. It's buried in RAIDframe somewhere) :-( GO ) */ if (bp->b_flags & B_ERROR) { bp->b_flags &= ~B_ERROR; } - if (bp->b_error!=0) { + if (bp->b_error != 0) { bp->b_error = 0; } - raidbp = RAIDGETBUF(rs); - raidbp->rf_flags = 0; /* XXX not really used anywhere... */ + raidbp->rf_flags = 0; /* XXX not really used anywhere... */ /* * context for raidiodone @@ -1614,14 +1417,12 @@ int rf_DispatchKernelIO(queue, req) raidbp->req = req; switch (req->type) { - case RF_IO_TYPE_NOP: /* used primarily to unlock a locked queue */ - /* - Dprintf2("rf_DispatchKernelIO: NOP to r %d c %d\n", - queue->row, queue->col); - */ + case RF_IO_TYPE_NOP: /* used primarily to unlock a locked queue */ + /* Dprintf2("rf_DispatchKernelIO: NOP to r %d c %d\n", + * queue->row, queue->col); */ /* XXX need to do something extra here.. */ - /* I'm leaving this in, as I've never actually seen it - used, and I'd like folks to report it... GO */ + /* I'm leaving this in, as I've never actually seen it used, + * and I'd like folks to report it... GO */ printf(("WAKEUP CALLED\n")); queue->numOutstanding++; @@ -1629,157 +1430,150 @@ int rf_DispatchKernelIO(queue, req) KernelWakeupFunc(&raidbp->rf_buf); break; - + case RF_IO_TYPE_READ: case RF_IO_TYPE_WRITE: - + if (req->tracerec) { RF_ETIMER_START(req->tracerec->timer); } - - - InitBP(&raidbp->rf_buf, queue->rf_cinfo->ci_vp, - op | bp->b_flags, queue->rf_cinfo->ci_dev, - req->sectorOffset, req->numSector, - req->buf, KernelWakeupFunc, (void *) req, - queue->raidPtr->logBytesPerSector, req->b_proc); + InitBP(&raidbp->rf_buf, queue->rf_cinfo->ci_vp, + op | bp->b_flags, queue->rf_cinfo->ci_dev, + req->sectorOffset, req->numSector, + req->buf, KernelWakeupFunc, (void *) req, + queue->raidPtr->logBytesPerSector, req->b_proc); if (rf_debugKernelAccess) { - db1_printf(("dispatch: bp->b_blkno = %ld\n", - (long) bp->b_blkno)); + db1_printf(("dispatch: bp->b_blkno = %ld\n", + (long) bp->b_blkno)); } queue->numOutstanding++; queue->last_deq_sector = req->sectorOffset; - /* acc wouldn't have been let in if there were any - pending reqs at any other priority */ + /* acc wouldn't have been let in if there were any pending + * reqs at any other priority */ queue->curPriority = req->priority; - /* - Dprintf3("rf_DispatchKernelIO: %c to row %d col %d\n", - req->type, queue->row, queue->col); - */ + /* Dprintf3("rf_DispatchKernelIO: %c to row %d col %d\n", + * req->type, queue->row, queue->col); */ db1_printf(("Going for %c to unit %d row %d col %d\n", - req->type, unit, queue->row, queue->col)); + req->type, unit, queue->row, queue->col)); db1_printf(("sector %d count %d (%d bytes) %d\n", - (int) req->sectorOffset, (int) req->numSector, - (int) (req->numSector << - queue->raidPtr->logBytesPerSector), - (int) queue->raidPtr->logBytesPerSector)); + (int) req->sectorOffset, (int) req->numSector, + (int) (req->numSector << + queue->raidPtr->logBytesPerSector), + (int) queue->raidPtr->logBytesPerSector)); if ((raidbp->rf_buf.b_flags & B_READ) == 0) { raidbp->rf_buf.b_vp->v_numoutput++; } - VOP_STRATEGY(&raidbp->rf_buf); - + break; - + default: panic("bad req->type in rf_DispatchKernelIO"); } db1_printf(("Exiting from DispatchKernelIO\n")); - return(0); + return (0); } - -/* this is the callback function associated with a I/O invoked from +/* this is the callback function associated with a I/O invoked from kernel code. */ -static void KernelWakeupFunc(vbp) - struct buf *vbp; +static void +KernelWakeupFunc(vbp) + struct buf *vbp; { - RF_DiskQueueData_t *req = NULL; - RF_DiskQueue_t *queue; - struct raidbuf *raidbp = (struct raidbuf *)vbp; - struct buf *bp; - struct raid_softc *rs; - int unit; - register int s; - - s=splbio(); /* XXX */ - db1_printf(("recovering the request queue:\n")); - req = raidbp->req; - - bp = raidbp->rf_obp; + RF_DiskQueueData_t *req = NULL; + RF_DiskQueue_t *queue; + struct raidbuf *raidbp = (struct raidbuf *) vbp; + struct buf *bp; + struct raid_softc *rs; + int unit; + register int s; + + s = splbio(); /* XXX */ + db1_printf(("recovering the request queue:\n")); + req = raidbp->req; + + bp = raidbp->rf_obp; #if 0 - db1_printf(("bp=0x%x\n",bp)); + db1_printf(("bp=0x%x\n", bp)); #endif - queue = (RF_DiskQueue_t *) req->queue; + queue = (RF_DiskQueue_t *) req->queue; - if (raidbp->rf_buf.b_flags & B_ERROR) { + if (raidbp->rf_buf.b_flags & B_ERROR) { #if 0 - printf("Setting bp->b_flags!!! %d\n",raidbp->rf_buf.b_error); + printf("Setting bp->b_flags!!! %d\n", raidbp->rf_buf.b_error); #endif - bp->b_flags |= B_ERROR; - bp->b_error = raidbp->rf_buf.b_error ? - raidbp->rf_buf.b_error : EIO; - } - + bp->b_flags |= B_ERROR; + bp->b_error = raidbp->rf_buf.b_error ? + raidbp->rf_buf.b_error : EIO; + } #if 0 - db1_printf(("raidbp->rf_buf.b_bcount=%d\n",(int)raidbp->rf_buf.b_bcount)); - db1_printf(("raidbp->rf_buf.b_bufsize=%d\n",(int)raidbp->rf_buf.b_bufsize)); - db1_printf(("raidbp->rf_buf.b_resid=%d\n",(int)raidbp->rf_buf.b_resid)); - db1_printf(("raidbp->rf_buf.b_data=0x%x\n",raidbp->rf_buf.b_data)); + db1_printf(("raidbp->rf_buf.b_bcount=%d\n", (int) raidbp->rf_buf.b_bcount)); + db1_printf(("raidbp->rf_buf.b_bufsize=%d\n", (int) raidbp->rf_buf.b_bufsize)); + db1_printf(("raidbp->rf_buf.b_resid=%d\n", (int) raidbp->rf_buf.b_resid)); + db1_printf(("raidbp->rf_buf.b_data=0x%x\n", raidbp->rf_buf.b_data)); #endif - /* XXX methinks this could be wrong... */ + /* XXX methinks this could be wrong... */ #if 1 - bp->b_resid = raidbp->rf_buf.b_resid; + bp->b_resid = raidbp->rf_buf.b_resid; #endif - if (req->tracerec) { - RF_ETIMER_STOP(req->tracerec->timer); - RF_ETIMER_EVAL(req->tracerec->timer); - RF_LOCK_MUTEX(rf_tracing_mutex); - req->tracerec->diskwait_us += RF_ETIMER_VAL_US(req->tracerec->timer); - req->tracerec->phys_io_us += RF_ETIMER_VAL_US(req->tracerec->timer); - req->tracerec->num_phys_ios++; - RF_UNLOCK_MUTEX(rf_tracing_mutex); - } - - bp->b_bcount = raidbp->rf_buf.b_bcount;/* XXXX ?? */ + if (req->tracerec) { + RF_ETIMER_STOP(req->tracerec->timer); + RF_ETIMER_EVAL(req->tracerec->timer); + RF_LOCK_MUTEX(rf_tracing_mutex); + req->tracerec->diskwait_us += RF_ETIMER_VAL_US(req->tracerec->timer); + req->tracerec->phys_io_us += RF_ETIMER_VAL_US(req->tracerec->timer); + req->tracerec->num_phys_ios++; + RF_UNLOCK_MUTEX(rf_tracing_mutex); + } + bp->b_bcount = raidbp->rf_buf.b_bcount; /* XXXX ?? */ - unit = queue->raidPtr->raidid; /* *Much* simpler :-> */ + unit = queue->raidPtr->raidid; /* *Much* simpler :-> */ - /* XXX Ok, let's get aggressive... If B_ERROR is set, let's go ballistic, - and mark the component as hosed... */ + /* XXX Ok, let's get aggressive... If B_ERROR is set, let's go + * ballistic, and mark the component as hosed... */ #if 1 - if (bp->b_flags&B_ERROR) { - /* Mark the disk as dead */ - /* but only mark it once... */ - 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++; - } else { /* Disk is already dead... */ - /* printf("Disk already marked as dead!\n"); */ - } - - } + if (bp->b_flags & B_ERROR) { + /* Mark the disk as dead */ + /* but only mark it once... */ + 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++; + } else { /* Disk is already dead... */ + /* printf("Disk already marked as dead!\n"); */ + } + + } #endif - rs = &raid_softc[unit]; - RAIDPUTBUF(rs,raidbp); + rs = &raid_softc[unit]; + RAIDPUTBUF(rs, raidbp); - if (bp->b_resid==0) { - db1_printf(("Disk is no longer busy for this buffer... %d %ld %ld\n", - unit, bp->b_resid, bp->b_bcount)); - /* XXX is this the right place for a disk_unbusy()??!??!?!? */ - disk_unbusy(&rs->sc_dkdev, (bp->b_bcount - bp->b_resid)); - } else { - db1_printf(("b_resid is still %ld\n",bp->b_resid)); - } + if (bp->b_resid == 0) { + db1_printf(("Disk is no longer busy for this buffer... %d %ld %ld\n", + unit, bp->b_resid, bp->b_bcount)); + /* XXX is this the right place for a disk_unbusy()??!??!?!? */ + disk_unbusy(&rs->sc_dkdev, (bp->b_bcount - bp->b_resid)); + } else { + db1_printf(("b_resid is still %ld\n", bp->b_resid)); + } - rf_DiskIOComplete(queue, req, (bp->b_flags & B_ERROR) ? 1 : 0); - (req->CompleteFunc)(req->argument, (bp->b_flags & B_ERROR) ? 1 : 0); - /* printf("Exiting KernelWakeupFunc\n"); */ + rf_DiskIOComplete(queue, req, (bp->b_flags & B_ERROR) ? 1 : 0); + (req->CompleteFunc) (req->argument, (bp->b_flags & B_ERROR) ? 1 : 0); + /* printf("Exiting KernelWakeupFunc\n"); */ - splx(s); /* XXX */ + splx(s); /* XXX */ } @@ -1787,62 +1581,62 @@ static void KernelWakeupFunc(vbp) /* * initialize a buf structure for doing an I/O in the kernel. */ -static void InitBP( - struct buf *bp, - struct vnode *b_vp, - unsigned rw_flag, - dev_t dev, - RF_SectorNum_t startSect, - RF_SectorCount_t numSect, - caddr_t buf, - void (*cbFunc)(struct buf *), - void *cbArg, - int logBytesPerSector, - struct proc *b_proc) +static void +InitBP( + struct buf * bp, + struct vnode * b_vp, + unsigned rw_flag, + dev_t dev, + RF_SectorNum_t startSect, + RF_SectorCount_t numSect, + caddr_t buf, + void (*cbFunc) (struct buf *), + void *cbArg, + int logBytesPerSector, + struct proc * b_proc) { - /* 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_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; db1_printf(("bp->b_dev is %d\n", dev)); - bp->b_un.b_addr = buf; + bp->b_un.b_addr = buf; #if 0 - db1_printf(("bp->b_data=0x%x\n",bp->b_data)); + db1_printf(("bp->b_data=0x%x\n", bp->b_data)); #endif - bp->b_blkno = startSect; - bp->b_resid = bp->b_bcount; /* XXX is this right!??!?!! */ - db1_printf(("b_bcount is: %d\n",(int)bp->b_bcount)); + bp->b_blkno = startSect; + bp->b_resid = bp->b_bcount; /* XXX is this right!??!?!! */ + db1_printf(("b_bcount is: %d\n", (int) bp->b_bcount)); if (bp->b_bcount == 0) { panic("bp->b_bcount is zero in InitBP!!\n"); } - bp->b_proc = b_proc; - bp->b_iodone = cbFunc; - bp->b_vp = b_vp; - -} -#endif /* KERNEL */ + bp->b_proc = b_proc; + bp->b_iodone = cbFunc; + bp->b_vp = b_vp; +} /* Extras... */ -unsigned int rpcc() +unsigned int +rpcc() { - /* XXX no clue what this is supposed to do.. my guess is - that it's supposed to read the CPU cycle counter... */ - /* db1_printf("this is supposed to do something useful too!??\n"); */ - return(0); + /* XXX no clue what this is supposed to do.. my guess is that it's + * supposed to read the CPU cycle counter... */ + /* db1_printf("this is supposed to do something useful too!??\n"); */ + return (0); } - #if 0 -int rf_GetSpareTableFromDaemon(req) - RF_SparetWait_t *req; +int +rf_GetSpareTableFromDaemon(req) + RF_SparetWait_t *req; { - int retcode=1; - printf("This is supposed to do something useful!!\n"); /* XXX */ - - return(retcode); + int retcode = 1; + printf("This is supposed to do something useful!!\n"); /* XXX */ + + return (retcode); } #endif @@ -1865,7 +1659,7 @@ raidgetdefaultlabel(raidPtr, rs, lp) lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors; strncpy(lp->d_typename, "raid", sizeof(lp->d_typename)); - lp->d_type = DTYPE_RAID; + lp->d_type = DTYPE_RAID; strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname)); lp->d_rpm = 3600; lp->d_interleave = 1; @@ -1881,18 +1675,17 @@ raidgetdefaultlabel(raidPtr, rs, lp) lp->d_checksum = dkcksum(rs->sc_dkdev.dk_label); } - /* * Read the disklabel from the raid device. If one is not present, fake one * up. */ static void raidgetdisklabel(dev) - dev_t dev; + dev_t dev; { - int unit = raidunit(dev); + int unit = raidunit(dev); struct raid_softc *rs = &raid_softc[unit]; - char *errstring; + char *errstring; struct disklabel *lp = rs->sc_dkdev.dk_label; struct cpu_disklabel *clp = rs->sc_dkdev.dk_cpulabel; RF_Raid_t *raidPtr; @@ -1910,10 +1703,10 @@ raidgetdisklabel(dev) */ errstring = readdisklabel(RAIDLABELDEV(dev), raidstrategy, rs->sc_dkdev.dk_label, rs->sc_dkdev.dk_cpulabel); - if (errstring) + if (errstring) raidmakedisklabel(rs); else { - int i; + int i; struct partition *pp; /* @@ -1939,7 +1732,6 @@ raidgetdisklabel(dev) } } - /* * Take care of things one might want to take care of in the event * that a disklabel isn't present. @@ -1962,53 +1754,51 @@ raidmakedisklabel(rs) lp->d_checksum = dkcksum(lp); } - /* * Lookup the provided name in the filesystem. If the file exists, * is a valid block device, and isn't being used by anyone else, * set *vpp to the file's vnode. - * You'll find the original of this in ccd.c + * You'll find the original of this in ccd.c */ int raidlookup(path, p, vpp) - char *path; + char *path; struct proc *p; struct vnode **vpp; /* result */ { struct nameidata nd; struct vnode *vp; struct vattr va; - int error; + int error; NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, path, p); - if ((error = vn_open(&nd, FREAD|FWRITE, 0)) != 0) { + if ((error = vn_open(&nd, FREAD | FWRITE, 0)) != 0) { #ifdef DEBUG - printf("RAIDframe: vn_open returned %d\n",error); + printf("RAIDframe: vn_open returned %d\n", error); #endif return (error); } vp = nd.ni_vp; if (vp->v_usecount > 1) { VOP_UNLOCK(vp, 0); - (void)vn_close(vp, FREAD|FWRITE, p->p_ucred, p); + (void) vn_close(vp, FREAD | FWRITE, p->p_ucred, p); return (EBUSY); } if ((error = VOP_GETATTR(vp, &va, p->p_ucred, p)) != 0) { VOP_UNLOCK(vp, 0); - (void)vn_close(vp, FREAD|FWRITE, p->p_ucred, p); + (void) vn_close(vp, FREAD | FWRITE, p->p_ucred, p); return (error); } /* XXX: eventually we should handle VREG, too. */ if (va.va_type != VBLK) { VOP_UNLOCK(vp, 0); - (void)vn_close(vp, FREAD|FWRITE, p->p_ucred, p); + (void) vn_close(vp, FREAD | FWRITE, p->p_ucred, p); return (ENOTBLK); } VOP_UNLOCK(vp, 0); *vpp = vp; return (0); } - /* * Wait interruptibly for an exclusive lock. * @@ -2020,18 +1810,17 @@ static int raidlock(rs) struct raid_softc *rs; { - int error; + int error; while ((rs->sc_flags & RAIDF_LOCKED) != 0) { rs->sc_flags |= RAIDF_WANTED; - if ((error = - tsleep(rs, PRIBIO | PCATCH, "raidlck", 0)) != 0) + if ((error = + tsleep(rs, PRIBIO | PCATCH, "raidlck", 0)) != 0) return (error); } rs->sc_flags |= RAIDF_LOCKED; return (0); } - /* * Unlock and wake up any waiters. */ |