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