	@@ -1,14 +1,14 @@		@@ -1,14 +1,14 @@
1	/* $NetBSD: rf_alloclist.c,v 1.25 2006/11/16 01:33:23 christos Exp $ */	1	/* $NetBSD: rf_alloclist.c,v 1.26 2009/03/15 17:17:23 cegger Exp $ */
2	/*	2	/*
3	* Copyright (c) 1995 Carnegie-Mellon University.	3	* Copyright (c) 1995 Carnegie-Mellon University.
4	* All rights reserved.	4	* All rights reserved.
5	*	5	*
6	* Author: Mark Holland	6	* Author: Mark Holland
7	*	7	*
8	* Permission to use, copy, modify and distribute this software and	8	* Permission to use, copy, modify and distribute this software and
9	* its documentation is hereby granted, provided that both the copyright	9	* its documentation is hereby granted, provided that both the copyright
10	* notice and this permission notice appear in all copies of the	10	* notice and this permission notice appear in all copies of the
11	* software, derivative works or modified versions, and any portions	11	* software, derivative works or modified versions, and any portions
12	* thereof, and that both notices appear in supporting documentation.	12	* thereof, and that both notices appear in supporting documentation.
13	*	13	*
14	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"	14	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
	@@ -27,27 +27,27 @@		@@ -27,27 +27,27 @@
27	*/	27	*/
28		28
29	/****************************************************************************	29	/****************************************************************************
30	*	30	*
31	* Alloclist.c -- code to manipulate allocation lists	31	* Alloclist.c -- code to manipulate allocation lists
32	*	32	*
33	* an allocation list is just a list of AllocListElem structures. Each	33	* an allocation list is just a list of AllocListElem structures. Each
34	* such structure contains a fixed-size array of pointers. Calling	34	* such structure contains a fixed-size array of pointers. Calling
35	* FreeAList() causes each pointer to be freed.	35	* FreeAList() causes each pointer to be freed.
36	*	36	*
37	***************************************************************************/	37	***************************************************************************/
38		38
39	#include <sys/cdefs.h>	39	#include <sys/cdefs.h>
40	__KERNEL_RCSID(0, "$NetBSD: rf_alloclist.c,v 1.25 2006/11/16 01:33:23 christos Exp $");	40	__KERNEL_RCSID(0, "$NetBSD: rf_alloclist.c,v 1.26 2009/03/15 17:17:23 cegger Exp $");
41		41
42	#include <dev/raidframe/raidframevar.h>	42	#include <dev/raidframe/raidframevar.h>
43		43
44	#include "rf_options.h"	44	#include "rf_options.h"
45	#include "rf_threadstuff.h"	45	#include "rf_threadstuff.h"
46	#include "rf_alloclist.h"	46	#include "rf_alloclist.h"
47	#include "rf_debugMem.h"	47	#include "rf_debugMem.h"
48	#include "rf_etimer.h"	48	#include "rf_etimer.h"
49	#include "rf_general.h"	49	#include "rf_general.h"
50	#include "rf_shutdown.h"	50	#include "rf_shutdown.h"
51	#include "rf_netbsd.h"	51	#include "rf_netbsd.h"
52		52
53	#include <sys/pool.h>	53	#include <sys/pool.h>
	@@ -110,21 +110,21 @@ rf_FreeAllocList(RF_AllocListElem_t *l)		@@ -110,21 +110,21 @@ rf_FreeAllocList(RF_AllocListElem_t *l)
110	for (i = 0; i < p->numPointers; i++) {	110	for (i = 0; i < p->numPointers; i++) {
111	RF_ASSERT(p->pointers[i]);	111	RF_ASSERT(p->pointers[i]);
112	RF_Free(p->pointers[i], p->sizes[i]);	112	RF_Free(p->pointers[i], p->sizes[i]);
113	}	113	}
114	}	114	}
115	while (l) {	115	while (l) {
116	temp = l;	116	temp = l;
117	l = l->next;	117	l = l->next;
118	pool_put(&rf_pools.alloclist, temp);	118	pool_put(&rf_pools.alloclist, temp);
119	}	119	}
120	}	120	}
121		121
122	RF_AllocListElem_t *	122	RF_AllocListElem_t *
123	rf_real_MakeAllocList()	123	rf_real_MakeAllocList(void)
124	{	124	{
125	RF_AllocListElem_t *p;	125	RF_AllocListElem_t *p;
126		126
127	p = pool_get(&rf_pools.alloclist, PR_WAITOK);	127	p = pool_get(&rf_pools.alloclist, PR_WAITOK);
128	memset((char *) p, 0, sizeof(RF_AllocListElem_t));	128	memset((char *) p, 0, sizeof(RF_AllocListElem_t));
129	return (p);	129	return (p);
130	}	130	}

	@@ -1,14 +1,14 @@		@@ -1,14 +1,14 @@
1	/* $NetBSD: rf_callback.c,v 1.21 2009/03/14 15:36:20 dsl Exp $ */	1	/* $NetBSD: rf_callback.c,v 1.22 2009/03/15 17:17:23 cegger Exp $ */
2	/*	2	/*
3	* Copyright (c) 1995 Carnegie-Mellon University.	3	* Copyright (c) 1995 Carnegie-Mellon University.
4	* All rights reserved.	4	* All rights reserved.
5	*	5	*
6	* Author: Jim Zelenka	6	* Author: Jim Zelenka
7	*	7	*
8	* Permission to use, copy, modify and distribute this software and	8	* Permission to use, copy, modify and distribute this software and
9	* its documentation is hereby granted, provided that both the copyright	9	* its documentation is hereby granted, provided that both the copyright
10	* notice and this permission notice appear in all copies of the	10	* notice and this permission notice appear in all copies of the
11	* software, derivative works or modified versions, and any portions	11	* software, derivative works or modified versions, and any portions
12	* thereof, and that both notices appear in supporting documentation.	12	* thereof, and that both notices appear in supporting documentation.
13	*	13	*
14	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"	14	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
	@@ -24,27 +24,27 @@		@@ -24,27 +24,27 @@
24	*	24	*
25	* any improvements or extensions that they make and grant Carnegie the	25	* any improvements or extensions that they make and grant Carnegie the
26	* rights to redistribute these changes.	26	* rights to redistribute these changes.
27	*/	27	*/
28		28
29	/*****************************************************************************	29	/*****************************************************************************
30	*	30	*
31	* callback.c -- code to manipulate callback descriptor	31	* callback.c -- code to manipulate callback descriptor
32	*	32	*
33	****************************************************************************/	33	****************************************************************************/
34		34
35		35
36	#include <sys/cdefs.h>	36	#include <sys/cdefs.h>
37	__KERNEL_RCSID(0, "$NetBSD: rf_callback.c,v 1.21 2009/03/14 15:36:20 dsl Exp $");	37	__KERNEL_RCSID(0, "$NetBSD: rf_callback.c,v 1.22 2009/03/15 17:17:23 cegger Exp $");
38		38
39	#include <dev/raidframe/raidframevar.h>	39	#include <dev/raidframe/raidframevar.h>
40	#include <sys/pool.h>	40	#include <sys/pool.h>
41		41
42	#include "rf_archs.h"	42	#include "rf_archs.h"
43	#include "rf_threadstuff.h"	43	#include "rf_threadstuff.h"
44	#include "rf_callback.h"	44	#include "rf_callback.h"
45	#include "rf_debugMem.h"	45	#include "rf_debugMem.h"
46	#include "rf_general.h"	46	#include "rf_general.h"
47	#include "rf_shutdown.h"	47	#include "rf_shutdown.h"
48	#include "rf_netbsd.h"	48	#include "rf_netbsd.h"
49		49
50	#define RF_MAX_FREE_CALLBACK 64	50	#define RF_MAX_FREE_CALLBACK 64
	@@ -59,26 +59,26 @@ rf_ShutdownCallback(void *ignored)		@@ -59,26 +59,26 @@ rf_ShutdownCallback(void *ignored)
59		59
60	int	60	int
61	rf_ConfigureCallback(RF_ShutdownList_t **listp)	61	rf_ConfigureCallback(RF_ShutdownList_t **listp)
62	{	62	{
63		63
64	rf_pool_init(&rf_pools.callback, sizeof(RF_CallbackDesc_t),	64	rf_pool_init(&rf_pools.callback, sizeof(RF_CallbackDesc_t),
65	"rf_callbackpl", RF_MIN_FREE_CALLBACK, RF_MAX_FREE_CALLBACK);	65	"rf_callbackpl", RF_MIN_FREE_CALLBACK, RF_MAX_FREE_CALLBACK);
66	rf_ShutdownCreate(listp, rf_ShutdownCallback, NULL);	66	rf_ShutdownCreate(listp, rf_ShutdownCallback, NULL);
67		67
68	return (0);	68	return (0);
69	}	69	}
70		70
71	RF_CallbackDesc_t *	71	RF_CallbackDesc_t *
72	rf_AllocCallbackDesc()	72	rf_AllocCallbackDesc(void)
73	{	73	{
74	RF_CallbackDesc_t *p;	74	RF_CallbackDesc_t *p;
75		75
76	p = pool_get(&rf_pools.callback, PR_WAITOK);	76	p = pool_get(&rf_pools.callback, PR_WAITOK);
77	return (p);	77	return (p);
78	}	78	}
79		79
80	void	80	void
81	rf_FreeCallbackDesc(RF_CallbackDesc_t *p)	81	rf_FreeCallbackDesc(RF_CallbackDesc_t *p)
82	{	82	{
83	pool_put(&rf_pools.callback, p);	83	pool_put(&rf_pools.callback, p);
84	}	84	}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_mcpair.c,v 1.21 2006/11/16 01:33:23 christos Exp $	*/
+/*	$NetBSD: rf_mcpair.c,v 1.22 2009/03/15 17:17:23 cegger Exp $	*/
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
+ *
  * Author: Jim Zelenka
+ *
  * Permission to use, copy, modify and distribute this software and
  * its documentation is hereby granted, provided that both the copyright
  * notice and this permission notice appear in all copies of the
  * software, derivative works or modified versions, and any portions
  * thereof, and that both notices appear in supporting documentation.
+ *
  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 @@ -22,27 +22,27 @@
  *  Carnegie Mellon University
  *  Pittsburgh PA 15213-3890
+ *
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
 /* rf_mcpair.c
  * an mcpair is a structure containing a mutex and a condition variable.
  * it's used to block the current thread until some event occurs.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_mcpair.c,v 1.21 2006/11/16 01:33:23 christos Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_mcpair.c,v 1.22 2009/03/15 17:17:23 cegger Exp $");
 #include <dev/raidframe/raidframevar.h>
 #include "rf_archs.h"
 #include "rf_threadstuff.h"
 #include "rf_mcpair.h"
 #include "rf_debugMem.h"
 #include "rf_general.h"
 #include "rf_shutdown.h"
 #include "rf_netbsd.h"
 #include <sys/pool.h>
 #include <sys/proc.h>
 @@ -60,27 +60,27 @@ rf_ShutdownMCPair(void *ignored)
 int
 rf_ConfigureMCPair(RF_ShutdownList_t **listp)
+{
 	rf_pool_init(&rf_pools.mcpair, sizeof(RF_MCPair_t),
 		     "rf_mcpair_pl", RF_MIN_FREE_MCPAIR, RF_MAX_FREE_MCPAIR);
 	rf_ShutdownCreate(listp, rf_ShutdownMCPair, NULL);
 	return (0);
+}
 RF_MCPair_t *
-rf_AllocMCPair()
+rf_AllocMCPair(void)
+{
 	RF_MCPair_t *t;
 	t = pool_get(&rf_pools.mcpair, PR_WAITOK);
 	simple_lock_init(&t->mutex);
 	t->cond = 0;
 	t->flag = 0;
 	return (t);
+}
 void
 rf_FreeMCPair(RF_MCPair_t *t)

	@@ -1,14 +1,14 @@		@@ -1,14 +1,14 @@
1	/* $NetBSD: rf_dagutils.c,v 1.51 2007/03/04 06:02:36 christos Exp $ */	1	/* $NetBSD: rf_dagutils.c,v 1.52 2009/03/15 17:17:23 cegger Exp $ */
2	/*	2	/*
3	* Copyright (c) 1995 Carnegie-Mellon University.	3	* Copyright (c) 1995 Carnegie-Mellon University.
4	* All rights reserved.	4	* All rights reserved.
5	*	5	*
6	* Authors: Mark Holland, William V. Courtright II, Jim Zelenka	6	* Authors: Mark Holland, William V. Courtright II, Jim Zelenka
7	*	7	*
8	* Permission to use, copy, modify and distribute this software and	8	* Permission to use, copy, modify and distribute this software and
9	* its documentation is hereby granted, provided that both the copyright	9	* its documentation is hereby granted, provided that both the copyright
10	* notice and this permission notice appear in all copies of the	10	* notice and this permission notice appear in all copies of the
11	* software, derivative works or modified versions, and any portions	11	* software, derivative works or modified versions, and any portions
12	* thereof, and that both notices appear in supporting documentation.	12	* thereof, and that both notices appear in supporting documentation.
13	*	13	*
14	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"	14	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
	@@ -23,27 +23,27 @@		@@ -23,27 +23,27 @@
23	* Pittsburgh PA 15213-3890	23	* Pittsburgh PA 15213-3890
24	*	24	*
25	* any improvements or extensions that they make and grant Carnegie the	25	* any improvements or extensions that they make and grant Carnegie the
26	* rights to redistribute these changes.	26	* rights to redistribute these changes.
27	*/	27	*/
28		28
29	/******************************************************************************	29	/******************************************************************************
30	*	30	*
31	* rf_dagutils.c -- utility routines for manipulating dags	31	* rf_dagutils.c -- utility routines for manipulating dags
32	*	32	*
33	*****************************************************************************/	33	*****************************************************************************/
34		34
35	#include <sys/cdefs.h>	35	#include <sys/cdefs.h>
36	__KERNEL_RCSID(0, "$NetBSD: rf_dagutils.c,v 1.51 2007/03/04 06:02:36 christos Exp $");	36	__KERNEL_RCSID(0, "$NetBSD: rf_dagutils.c,v 1.52 2009/03/15 17:17:23 cegger Exp $");
37		37
38	#include <dev/raidframe/raidframevar.h>	38	#include <dev/raidframe/raidframevar.h>
39		39
40	#include "rf_archs.h"	40	#include "rf_archs.h"
41	#include "rf_threadstuff.h"	41	#include "rf_threadstuff.h"
42	#include "rf_raid.h"	42	#include "rf_raid.h"
43	#include "rf_dag.h"	43	#include "rf_dag.h"
44	#include "rf_dagutils.h"	44	#include "rf_dagutils.h"
45	#include "rf_dagfuncs.h"	45	#include "rf_dagfuncs.h"
46	#include "rf_general.h"	46	#include "rf_general.h"
47	#include "rf_map.h"	47	#include "rf_map.h"
48	#include "rf_shutdown.h"	48	#include "rf_shutdown.h"
49		49
	@@ -244,98 +244,98 @@ rf_ConfigureDAGs(RF_ShutdownList_t **lis		@@ -244,98 +244,98 @@ rf_ConfigureDAGs(RF_ShutdownList_t **lis
244	"rf_dagh_pl", RF_MIN_FREE_DAGH, RF_MAX_FREE_DAGH);	244	"rf_dagh_pl", RF_MIN_FREE_DAGH, RF_MAX_FREE_DAGH);
245	rf_pool_init(&rf_pools.daglist, sizeof(RF_DagList_t),	245	rf_pool_init(&rf_pools.daglist, sizeof(RF_DagList_t),
246	"rf_daglist_pl", RF_MIN_FREE_DAGLIST, RF_MAX_FREE_DAGLIST);	246	"rf_daglist_pl", RF_MIN_FREE_DAGLIST, RF_MAX_FREE_DAGLIST);
247	rf_pool_init(&rf_pools.dagpcache, RF_DAGPCACHE_SIZE,	247	rf_pool_init(&rf_pools.dagpcache, RF_DAGPCACHE_SIZE,
248	"rf_dagpcache_pl", RF_MIN_FREE_DAGPCACHE, RF_MAX_FREE_DAGPCACHE);	248	"rf_dagpcache_pl", RF_MIN_FREE_DAGPCACHE, RF_MAX_FREE_DAGPCACHE);
249	rf_pool_init(&rf_pools.funclist, sizeof(RF_FuncList_t),	249	rf_pool_init(&rf_pools.funclist, sizeof(RF_FuncList_t),
250	"rf_funclist_pl", RF_MIN_FREE_FUNCLIST, RF_MAX_FREE_FUNCLIST);	250	"rf_funclist_pl", RF_MIN_FREE_FUNCLIST, RF_MAX_FREE_FUNCLIST);
251	rf_ShutdownCreate(listp, rf_ShutdownDAGs, NULL);	251	rf_ShutdownCreate(listp, rf_ShutdownDAGs, NULL);
252		252
253	return (0);	253	return (0);
254	}	254	}
255		255
256	RF_DagHeader_t *	256	RF_DagHeader_t *
257	rf_AllocDAGHeader()	257	rf_AllocDAGHeader(void)
258	{	258	{
259	RF_DagHeader_t *dh;	259	RF_DagHeader_t *dh;
260		260
261	dh = pool_get(&rf_pools.dagh, PR_WAITOK);	261	dh = pool_get(&rf_pools.dagh, PR_WAITOK);
262	memset((char *) dh, 0, sizeof(RF_DagHeader_t));	262	memset((char *) dh, 0, sizeof(RF_DagHeader_t));
263	return (dh);	263	return (dh);
264	}	264	}
265		265
266	void	266	void
267	rf_FreeDAGHeader(RF_DagHeader_t * dh)	267	rf_FreeDAGHeader(RF_DagHeader_t * dh)
268	{	268	{
269	pool_put(&rf_pools.dagh, dh);	269	pool_put(&rf_pools.dagh, dh);
270	}	270	}
271		271
272	RF_DagNode_t *	272	RF_DagNode_t *
273	rf_AllocDAGNode()	273	rf_AllocDAGNode(void)
274	{	274	{
275	RF_DagNode_t *node;	275	RF_DagNode_t *node;
276		276
277	node = pool_get(&rf_pools.dagnode, PR_WAITOK);	277	node = pool_get(&rf_pools.dagnode, PR_WAITOK);
278	memset(node, 0, sizeof(RF_DagNode_t));	278	memset(node, 0, sizeof(RF_DagNode_t));
279	return (node);	279	return (node);
280	}	280	}
281		281
282	void	282	void
283	rf_FreeDAGNode(RF_DagNode_t *node)	283	rf_FreeDAGNode(RF_DagNode_t *node)
284	{	284	{
285	if (node->big_dag_ptrs) {	285	if (node->big_dag_ptrs) {
286	rf_FreeDAGPCache(node->big_dag_ptrs);	286	rf_FreeDAGPCache(node->big_dag_ptrs);
287	}	287	}
288	if (node->big_dag_params) {	288	if (node->big_dag_params) {
289	rf_FreeDAGPCache(node->big_dag_params);	289	rf_FreeDAGPCache(node->big_dag_params);
290	}	290	}
291	pool_put(&rf_pools.dagnode, node);	291	pool_put(&rf_pools.dagnode, node);
292	}	292	}
293		293
294	RF_DagList_t *	294	RF_DagList_t *
295	rf_AllocDAGList()	295	rf_AllocDAGList(void)
296	{	296	{
297	RF_DagList_t *dagList;	297	RF_DagList_t *dagList;
298		298
299	dagList = pool_get(&rf_pools.daglist, PR_WAITOK);	299	dagList = pool_get(&rf_pools.daglist, PR_WAITOK);
300	memset(dagList, 0, sizeof(RF_DagList_t));	300	memset(dagList, 0, sizeof(RF_DagList_t));
301		301
302	return (dagList);	302	return (dagList);
303	}	303	}
304		304
305	void	305	void
306	rf_FreeDAGList(RF_DagList_t *dagList)	306	rf_FreeDAGList(RF_DagList_t *dagList)
307	{	307	{
308	pool_put(&rf_pools.daglist, dagList);	308	pool_put(&rf_pools.daglist, dagList);
309	}	309	}
310		310
311	void *	311	void *
312	rf_AllocDAGPCache()	312	rf_AllocDAGPCache(void)
313	{	313	{
314	void *p;	314	void *p;
315	p = pool_get(&rf_pools.dagpcache, PR_WAITOK);	315	p = pool_get(&rf_pools.dagpcache, PR_WAITOK);
316	memset(p, 0, RF_DAGPCACHE_SIZE);	316	memset(p, 0, RF_DAGPCACHE_SIZE);
317		317
318	return (p);	318	return (p);
319	}	319	}
320		320
321	void	321	void
322	rf_FreeDAGPCache(void *p)	322	rf_FreeDAGPCache(void *p)
323	{	323	{
324	pool_put(&rf_pools.dagpcache, p);	324	pool_put(&rf_pools.dagpcache, p);
325	}	325	}
326		326
327	RF_FuncList_t *	327	RF_FuncList_t *
328	rf_AllocFuncList()	328	rf_AllocFuncList(void)
329	{	329	{
330	RF_FuncList_t *funcList;	330	RF_FuncList_t *funcList;
331		331
332	funcList = pool_get(&rf_pools.funclist, PR_WAITOK);	332	funcList = pool_get(&rf_pools.funclist, PR_WAITOK);
333	memset(funcList, 0, sizeof(RF_FuncList_t));	333	memset(funcList, 0, sizeof(RF_FuncList_t));
334		334
335	return (funcList);	335	return (funcList);
336	}	336	}
337		337
338	void	338	void
339	rf_FreeFuncList(RF_FuncList_t *funcList)	339	rf_FreeFuncList(RF_FuncList_t *funcList)
340	{	340	{
341	pool_put(&rf_pools.funclist, funcList);	341	pool_put(&rf_pools.funclist, funcList);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_driver.c,v 1.120 2008/12/20 17:04:51 oster Exp $	*/
+/*	$NetBSD: rf_driver.c,v 1.121 2009/03/15 17:17:23 cegger Exp $	*/
 /*-
  * Copyright (c) 1999 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Greg Oster
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
 @@ -56,27 +56,27 @@
  * rights to redistribute these changes.
  */
 /******************************************************************************
+ *
  * rf_driver.c -- main setup, teardown, and access routines for the RAID driver
+ *
  * all routines are prefixed with rf_ (raidframe), to avoid conficts.
+ *
  ******************************************************************************/
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_driver.c,v 1.120 2008/12/20 17:04:51 oster Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_driver.c,v 1.121 2009/03/15 17:17:23 cegger Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_raid_diagnostic.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/ioctl.h>
 #include <sys/fcntl.h>
 #include <sys/vnode.h>
 #include "rf_archs.h"
 @@ -145,44 +145,44 @@ static int configureCount = 0;	/* number
 static int isconfigged = 0;	/* is basic raidframe (non per-array)
 				 * stuff configured */
 RF_DECLARE_LKMGR_STATIC_MUTEX(configureMutex)	/* used to lock the configuration
 					 * stuff */
 static RF_ShutdownList_t *globalShutdown;	/* non array-specific
 						 * stuff */
 static int rf_ConfigureRDFreeList(RF_ShutdownList_t ** listp);
 static int rf_AllocEmergBuffers(RF_Raid_t *);
 static void rf_FreeEmergBuffers(RF_Raid_t *);
 /* called at system boot time */
 int
-rf_BootRaidframe()
+rf_BootRaidframe(void)
+{
 	if (raidframe_booted)
 		return (EBUSY);
 	raidframe_booted = 1;
 	mutex_init(&configureMutex, MUTEX_DEFAULT, IPL_NONE);
  	configureCount = 0;
 	isconfigged = 0;
 	globalShutdown = NULL;
 	return (0);
+}
 /*
  * Called whenever an array is shutdown
  */
 static void
-rf_UnconfigureArray()
+rf_UnconfigureArray(void)
+{
 	RF_LOCK_LKMGR_MUTEX(configureMutex);
 	if (--configureCount == 0) {	/* if no active configurations, shut
 					 * everything down */
 		isconfigged = 0;
 		rf_ShutdownList(&globalShutdown);
 		/*
 	         * We must wait until now, because the AllocList module
 	         * uses the DebugMem module.
 	         */
 #if RF_DEBUG_MEM

	@@ -1,14 +1,14 @@		@@ -1,14 +1,14 @@
1	/* $NetBSD: rf_map.c,v 1.43 2007/03/04 06:02:38 christos Exp $ */	1	/* $NetBSD: rf_map.c,v 1.44 2009/03/15 17:17:23 cegger Exp $ */
2	/*	2	/*
3	* Copyright (c) 1995 Carnegie-Mellon University.	3	* Copyright (c) 1995 Carnegie-Mellon University.
4	* All rights reserved.	4	* All rights reserved.
5	*	5	*
6	* Author: Mark Holland	6	* Author: Mark Holland
7	*	7	*
8	* Permission to use, copy, modify and distribute this software and	8	* Permission to use, copy, modify and distribute this software and
9	* its documentation is hereby granted, provided that both the copyright	9	* its documentation is hereby granted, provided that both the copyright
10	* notice and this permission notice appear in all copies of the	10	* notice and this permission notice appear in all copies of the
11	* software, derivative works or modified versions, and any portions	11	* software, derivative works or modified versions, and any portions
12	* thereof, and that both notices appear in supporting documentation.	12	* thereof, and that both notices appear in supporting documentation.
13	*	13	*
14	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"	14	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
	@@ -23,27 +23,27 @@		@@ -23,27 +23,27 @@
23	* Pittsburgh PA 15213-3890	23	* Pittsburgh PA 15213-3890
24	*	24	*
25	* any improvements or extensions that they make and grant Carnegie the	25	* any improvements or extensions that they make and grant Carnegie the
26	* rights to redistribute these changes.	26	* rights to redistribute these changes.
27	*/	27	*/
28		28
29	/**************************************************************************	29	/**************************************************************************
30	*	30	*
31	* map.c -- main code for mapping RAID addresses to physical disk addresses	31	* map.c -- main code for mapping RAID addresses to physical disk addresses
32	*	32	*
33	**************************************************************************/	33	**************************************************************************/
34		34
35	#include <sys/cdefs.h>	35	#include <sys/cdefs.h>
36	__KERNEL_RCSID(0, "$NetBSD: rf_map.c,v 1.43 2007/03/04 06:02:38 christos Exp $");	36	__KERNEL_RCSID(0, "$NetBSD: rf_map.c,v 1.44 2009/03/15 17:17:23 cegger Exp $");
37		37
38	#include <dev/raidframe/raidframevar.h>	38	#include <dev/raidframe/raidframevar.h>
39		39
40	#include "rf_threadstuff.h"	40	#include "rf_threadstuff.h"
41	#include "rf_raid.h"	41	#include "rf_raid.h"
42	#include "rf_general.h"	42	#include "rf_general.h"
43	#include "rf_map.h"	43	#include "rf_map.h"
44	#include "rf_shutdown.h"	44	#include "rf_shutdown.h"
45		45
46	static void rf_FreePDAList(RF_PhysDiskAddr_t *pda_list);	46	static void rf_FreePDAList(RF_PhysDiskAddr_t *pda_list);
47	static void rf_FreeASMList(RF_AccessStripeMap_t *asm_list);	47	static void rf_FreeASMList(RF_AccessStripeMap_t *asm_list);
48		48
49	/***************************************************************************	49	/***************************************************************************
	@@ -364,121 +364,121 @@ rf_ConfigureMapModule(RF_ShutdownList_t		@@ -364,121 +364,121 @@ rf_ConfigureMapModule(RF_ShutdownList_t
364	"rf_pda_pl", RF_MIN_FREE_PDA, RF_MAX_FREE_PDA);	364	"rf_pda_pl", RF_MIN_FREE_PDA, RF_MAX_FREE_PDA);
365	rf_pool_init(&rf_pools.fss, sizeof(RF_FailedStripe_t),	365	rf_pool_init(&rf_pools.fss, sizeof(RF_FailedStripe_t),
366	"rf_fss_pl", RF_MIN_FREE_FSS, RF_MAX_FREE_FSS);	366	"rf_fss_pl", RF_MIN_FREE_FSS, RF_MAX_FREE_FSS);
367	rf_pool_init(&rf_pools.vfple, sizeof(RF_VoidFunctionPointerListElem_t),	367	rf_pool_init(&rf_pools.vfple, sizeof(RF_VoidFunctionPointerListElem_t),
368	"rf_vfple_pl", RF_MIN_FREE_VFPLE, RF_MAX_FREE_VFPLE);	368	"rf_vfple_pl", RF_MIN_FREE_VFPLE, RF_MAX_FREE_VFPLE);
369	rf_pool_init(&rf_pools.vple, sizeof(RF_VoidPointerListElem_t),	369	rf_pool_init(&rf_pools.vple, sizeof(RF_VoidPointerListElem_t),
370	"rf_vple_pl", RF_MIN_FREE_VPLE, RF_MAX_FREE_VPLE);	370	"rf_vple_pl", RF_MIN_FREE_VPLE, RF_MAX_FREE_VPLE);
371	rf_ShutdownCreate(listp, rf_ShutdownMapModule, NULL);	371	rf_ShutdownCreate(listp, rf_ShutdownMapModule, NULL);
372		372
373	return (0);	373	return (0);
374	}	374	}
375		375
376	RF_AccessStripeMapHeader_t *	376	RF_AccessStripeMapHeader_t *
377	rf_AllocAccessStripeMapHeader()	377	rf_AllocAccessStripeMapHeader(void)
378	{	378	{
379	RF_AccessStripeMapHeader_t *p;	379	RF_AccessStripeMapHeader_t *p;
380		380
381	p = pool_get(&rf_pools.asm_hdr, PR_WAITOK);	381	p = pool_get(&rf_pools.asm_hdr, PR_WAITOK);
382	memset((char *) p, 0, sizeof(RF_AccessStripeMapHeader_t));	382	memset((char *) p, 0, sizeof(RF_AccessStripeMapHeader_t));
383		383
384	return (p);	384	return (p);
385	}	385	}
386		386
387	void	387	void
388	rf_FreeAccessStripeMapHeader(RF_AccessStripeMapHeader_t *p)	388	rf_FreeAccessStripeMapHeader(RF_AccessStripeMapHeader_t *p)
389	{	389	{
390	pool_put(&rf_pools.asm_hdr, p);	390	pool_put(&rf_pools.asm_hdr, p);
391	}	391	}
392		392
393		393
394	RF_VoidFunctionPointerListElem_t *	394	RF_VoidFunctionPointerListElem_t *
395	rf_AllocVFPListElem()	395	rf_AllocVFPListElem(void)
396	{	396	{
397	RF_VoidFunctionPointerListElem_t *p;	397	RF_VoidFunctionPointerListElem_t *p;
398		398
399	p = pool_get(&rf_pools.vfple, PR_WAITOK);	399	p = pool_get(&rf_pools.vfple, PR_WAITOK);
400	memset((char *) p, 0, sizeof(RF_VoidFunctionPointerListElem_t));	400	memset((char *) p, 0, sizeof(RF_VoidFunctionPointerListElem_t));
401		401
402	return (p);	402	return (p);
403	}	403	}
404		404
405	void	405	void
406	rf_FreeVFPListElem(RF_VoidFunctionPointerListElem_t *p)	406	rf_FreeVFPListElem(RF_VoidFunctionPointerListElem_t *p)
407	{	407	{
408		408
409	pool_put(&rf_pools.vfple, p);	409	pool_put(&rf_pools.vfple, p);
410	}	410	}
411		411
412		412
413	RF_VoidPointerListElem_t *	413	RF_VoidPointerListElem_t *
414	rf_AllocVPListElem()	414	rf_AllocVPListElem(void)
415	{	415	{
416	RF_VoidPointerListElem_t *p;	416	RF_VoidPointerListElem_t *p;
417		417
418	p = pool_get(&rf_pools.vple, PR_WAITOK);	418	p = pool_get(&rf_pools.vple, PR_WAITOK);
419	memset((char *) p, 0, sizeof(RF_VoidPointerListElem_t));	419	memset((char *) p, 0, sizeof(RF_VoidPointerListElem_t));
420		420
421	return (p);	421	return (p);
422	}	422	}
423		423
424	void	424	void
425	rf_FreeVPListElem(RF_VoidPointerListElem_t *p)	425	rf_FreeVPListElem(RF_VoidPointerListElem_t *p)
426	{	426	{
427		427
428	pool_put(&rf_pools.vple, p);	428	pool_put(&rf_pools.vple, p);
429	}	429	}
430		430
431	RF_ASMHeaderListElem_t *	431	RF_ASMHeaderListElem_t *
432	rf_AllocASMHeaderListElem()	432	rf_AllocASMHeaderListElem(void)
433	{	433	{
434	RF_ASMHeaderListElem_t *p;	434	RF_ASMHeaderListElem_t *p;
435		435
436	p = pool_get(&rf_pools.asmhle, PR_WAITOK);	436	p = pool_get(&rf_pools.asmhle, PR_WAITOK);
437	memset((char *) p, 0, sizeof(RF_ASMHeaderListElem_t));	437	memset((char *) p, 0, sizeof(RF_ASMHeaderListElem_t));
438		438
439	return (p);	439	return (p);
440	}	440	}
441		441
442	void	442	void
443	rf_FreeASMHeaderListElem(RF_ASMHeaderListElem_t *p)	443	rf_FreeASMHeaderListElem(RF_ASMHeaderListElem_t *p)
444	{	444	{
445		445
446	pool_put(&rf_pools.asmhle, p);	446	pool_put(&rf_pools.asmhle, p);
447	}	447	}
448		448
449	RF_FailedStripe_t *	449	RF_FailedStripe_t *
450	rf_AllocFailedStripeStruct()	450	rf_AllocFailedStripeStruct(void)
451	{	451	{
452	RF_FailedStripe_t *p;	452	RF_FailedStripe_t *p;
453		453
454	p = pool_get(&rf_pools.fss, PR_WAITOK);	454	p = pool_get(&rf_pools.fss, PR_WAITOK);
455	memset((char *) p, 0, sizeof(RF_FailedStripe_t));	455	memset((char *) p, 0, sizeof(RF_FailedStripe_t));
456		456
457	return (p);	457	return (p);
458	}	458	}
459		459
460	void	460	void
461	rf_FreeFailedStripeStruct(RF_FailedStripe_t *p)	461	rf_FreeFailedStripeStruct(RF_FailedStripe_t *p)
462	{	462	{
463	pool_put(&rf_pools.fss, p);	463	pool_put(&rf_pools.fss, p);
464	}	464	}
465		465
466		466
467		467
468		468
469		469
470	RF_PhysDiskAddr_t *	470	RF_PhysDiskAddr_t *
471	rf_AllocPhysDiskAddr()	471	rf_AllocPhysDiskAddr(void)
472	{	472	{
473	RF_PhysDiskAddr_t *p;	473	RF_PhysDiskAddr_t *p;
474		474
475	p = pool_get(&rf_pools.pda, PR_WAITOK);	475	p = pool_get(&rf_pools.pda, PR_WAITOK);
476	memset((char *) p, 0, sizeof(RF_PhysDiskAddr_t));	476	memset((char *) p, 0, sizeof(RF_PhysDiskAddr_t));
477		477
478	return (p);	478	return (p);
479	}	479	}
480	/* allocates a list of PDAs, locking the free list only once when we	480	/* allocates a list of PDAs, locking the free list only once when we
481	* have to call calloc, we do it one component at a time to simplify	481	* have to call calloc, we do it one component at a time to simplify
482	* the process of freeing the list at program shutdown. This should	482	* the process of freeing the list at program shutdown. This should
483	* not be much of a performance hit, because it should be very	483	* not be much of a performance hit, because it should be very
484	* infrequently executed. */	484	* infrequently executed. */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_netbsdkintf.c,v 1.258 2009/03/14 11:08:28 ad Exp $	*/
+/*	$NetBSD: rf_netbsdkintf.c,v 1.259 2009/03/15 17:17:23 cegger Exp $	*/
 /*-
  * Copyright (c) 1996, 1997, 1998, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Greg Oster; Jason R. Thorpe.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
 @@ -129,27 +129,27 @@
  *  Pittsburgh PA 15213-3890
+ *
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
 /***********************************************************
+ *
  * rf_kintf.c -- the kernel interface routines for RAIDframe
+ *
  ***********************************************************/
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_netbsdkintf.c,v 1.258 2009/03/14 11:08:28 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_netbsdkintf.c,v 1.259 2009/03/15 17:17:23 cegger Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_compat_netbsd.h"
 #include "opt_raid_autoconfig.h"
 #include "raid.h"
 #endif
 #include <sys/param.h>
 #include <sys/errno.h>
 #include <sys/pool.h>
 #include <sys/proc.h>
 #include <sys/queue.h>
 #include <sys/disk.h>
 @@ -2833,27 +2833,27 @@ oomem:
+		    }
+	}
 	if (!good_one) {
 		/* cleanup */
 		free(clabel, M_RAIDFRAME);
 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 		VOP_CLOSE(vp, FREAD | FWRITE, NOCRED);
 		vput(vp);
+	}
 	return ac_list;
+}
 RF_AutoConfig_t *
-rf_find_raid_components()
+rf_find_raid_components(void)
+{
 	struct vnode *vp;
 	struct disklabel label;
 	struct device *dv;
 	dev_t dev;
 	int bmajor, bminor, wedge;
 	int error;
 	int i;
 	RF_AutoConfig_t *ac_list;
 	/* initialize the AutoConfig list */
 	ac_list = NULL;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_options.c,v 1.7 2005/12/11 12:23:37 christos Exp $	*/
+/*	$NetBSD: rf_options.c,v 1.8 2009/03/15 17:17:23 cegger Exp $	*/
 /*
  * rf_options.c
  */
 /*
  * Copyright (c) 1996 Carnegie-Mellon University.
  * All rights reserved.
+ *
  * Author: Jim Zelenka
+ *
  * Permission to use, copy, modify and distribute this software and
  * its documentation is hereby granted, provided that both the copyright
  * notice and this permission notice appear in all copies of the
  * software, derivative works or modified versions, and any portions
 @@ -20,27 +20,27 @@
+ *
  * Carnegie Mellon requests users of this software to return to
+ *
  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  *  School of Computer Science
  *  Carnegie Mellon University
  *  Pittsburgh PA 15213-3890
+ *
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_options.c,v 1.7 2005/12/11 12:23:37 christos Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_options.c,v 1.8 2009/03/15 17:17:23 cegger Exp $");
 #include <dev/raidframe/raidframevar.h>
 #include "rf_threadstuff.h"
 #include "rf_archs.h"
 #include "rf_general.h"
 #include "rf_options.h"
 #ifdef RF_DBG_OPTION
 #undef RF_DBG_OPTION
 #endif				/* RF_DBG_OPTION */
 #ifdef __STDC__
 @@ -62,17 +62,17 @@ __KERNEL_RCSID(0, "$NetBSD: rf_options.c
 RF_DebugName_t rf_debugNames[] = {
 #include "rf_optnames.h"
 	{NULL, NULL}
 };
 #undef RF_DBG_OPTION
 #ifdef __STDC__
 #define RF_DBG_OPTION(_option_,_defval_) rf_##_option_  = _defval_ ;
 #else				/* __STDC__ */
 #define RF_DBG_OPTION(_option_,_defval_) rf_/**/_option_ = _defval_ ;
 #endif				/* __STDC__ */
 void
-rf_ResetDebugOptions()
+rf_ResetDebugOptions(void)
+{
 #include "rf_optnames.h"
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_stripelocks.c,v 1.29 2006/11/16 01:33:23 christos Exp $	*/
+/*	$NetBSD: rf_stripelocks.c,v 1.30 2009/03/15 17:17:23 cegger Exp $	*/
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
+ *
  * Authors: Mark Holland, Jim Zelenka
+ *
  * Permission to use, copy, modify and distribute this software and
  * its documentation is hereby granted, provided that both the copyright
  * notice and this permission notice appear in all copies of the
  * software, derivative works or modified versions, and any portions
  * thereof, and that both notices appear in supporting documentation.
+ *
  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 @@ -47,27 +47,27 @@
  * of the stripe. The "addresses" that you lock are abstract in that you
  * can pass in anything you like.  The expectation is that you'll pass in
  * the range of physical disk offsets of the parity bits you're planning
  * to update. The idea behind this, of course, is to allow sub-stripe
  * locking. The implementation is perhaps not the best imaginable; in the
  * worst case a lock release is O(n^2) in the total number of outstanding
  * requests to a given stripe.  Note that if you're striping with a
  * stripe unit size equal to an entire disk (i.e. not striping), there will
  * be only one stripe and you may spend some significant number of cycles
  * searching through stripe lock descriptors.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_stripelocks.c,v 1.29 2006/11/16 01:33:23 christos Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_stripelocks.c,v 1.30 2009/03/15 17:17:23 cegger Exp $");
 #include <dev/raidframe/raidframevar.h>
 #include "rf_raid.h"
 #include "rf_stripelocks.h"
 #include "rf_alloclist.h"
 #include "rf_debugprint.h"
 #include "rf_general.h"
 #include "rf_driver.h"
 #include "rf_shutdown.h"
 #ifdef DEBUG
 @@ -173,27 +173,27 @@ rf_ConfigureStripeLockFreeList(RF_Shutdo
 	rf_ShutdownCreate(listp, rf_ShutdownStripeLockFreeList, NULL);
 	for (mask = 0x1; mask; mask <<= 1)
 		if (rf_lockTableSize == mask)
 			break;
 	if (!mask) {
 		printf("[WARNING:  lock table size must be a power of two.  Setting to %d.]\n", RF_DEFAULT_LOCK_TABLE_SIZE);
 		rf_lockTableSize = RF_DEFAULT_LOCK_TABLE_SIZE;
+	}
 	return (0);
+}
 static RF_LockTableEntry_t *
-rf_MakeLockTable()
+rf_MakeLockTable(void)
+{
 	RF_LockTableEntry_t *lockTable;
 	int     i;
 	RF_Malloc(lockTable,
 		  ((int) rf_lockTableSize) * sizeof(RF_LockTableEntry_t),
 		  (RF_LockTableEntry_t *));
 	if (lockTable == NULL)
 		return (NULL);
 	for (i = 0; i < rf_lockTableSize; i++) {
 		rf_mutex_init(&lockTable[i].mutex);
+	}
 	return (lockTable);