rf_netbsdkintf.c revision 1.410 1 1.410 oster /* $NetBSD: rf_netbsdkintf.c,v 1.410 2022/08/28 00:37:41 oster Exp $ */
2 1.281 rmind
3 1.1 oster /*-
4 1.295 erh * Copyright (c) 1996, 1997, 1998, 2008-2011 The NetBSD Foundation, Inc.
5 1.1 oster * All rights reserved.
6 1.1 oster *
7 1.1 oster * This code is derived from software contributed to The NetBSD Foundation
8 1.1 oster * by Greg Oster; Jason R. Thorpe.
9 1.1 oster *
10 1.1 oster * Redistribution and use in source and binary forms, with or without
11 1.1 oster * modification, are permitted provided that the following conditions
12 1.1 oster * are met:
13 1.1 oster * 1. Redistributions of source code must retain the above copyright
14 1.1 oster * notice, this list of conditions and the following disclaimer.
15 1.1 oster * 2. Redistributions in binary form must reproduce the above copyright
16 1.1 oster * notice, this list of conditions and the following disclaimer in the
17 1.1 oster * documentation and/or other materials provided with the distribution.
18 1.1 oster *
19 1.1 oster * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 1.1 oster * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 1.1 oster * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 1.1 oster * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 1.1 oster * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 1.1 oster * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 1.1 oster * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 1.1 oster * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 1.1 oster * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 1.1 oster * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 1.1 oster * POSSIBILITY OF SUCH DAMAGE.
30 1.1 oster */
31 1.1 oster
32 1.1 oster /*
33 1.281 rmind * Copyright (c) 1988 University of Utah.
34 1.1 oster * Copyright (c) 1990, 1993
35 1.1 oster * The Regents of the University of California. All rights reserved.
36 1.1 oster *
37 1.1 oster * This code is derived from software contributed to Berkeley by
38 1.1 oster * the Systems Programming Group of the University of Utah Computer
39 1.1 oster * Science Department.
40 1.1 oster *
41 1.1 oster * Redistribution and use in source and binary forms, with or without
42 1.1 oster * modification, are permitted provided that the following conditions
43 1.1 oster * are met:
44 1.1 oster * 1. Redistributions of source code must retain the above copyright
45 1.1 oster * notice, this list of conditions and the following disclaimer.
46 1.1 oster * 2. Redistributions in binary form must reproduce the above copyright
47 1.1 oster * notice, this list of conditions and the following disclaimer in the
48 1.1 oster * documentation and/or other materials provided with the distribution.
49 1.162 agc * 3. Neither the name of the University nor the names of its contributors
50 1.162 agc * may be used to endorse or promote products derived from this software
51 1.162 agc * without specific prior written permission.
52 1.162 agc *
53 1.162 agc * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
54 1.162 agc * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
55 1.162 agc * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
56 1.162 agc * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
57 1.162 agc * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
58 1.162 agc * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
59 1.162 agc * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
60 1.162 agc * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
61 1.162 agc * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
62 1.162 agc * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
63 1.162 agc * SUCH DAMAGE.
64 1.162 agc *
65 1.405 wiz * from: Utah $Hdr: cd.c 1.6 90/11/28$
66 1.162 agc *
67 1.162 agc * @(#)cd.c 8.2 (Berkeley) 11/16/93
68 1.162 agc */
69 1.162 agc
70 1.162 agc /*
71 1.1 oster * Copyright (c) 1995 Carnegie-Mellon University.
72 1.1 oster * All rights reserved.
73 1.1 oster *
74 1.1 oster * Authors: Mark Holland, Jim Zelenka
75 1.1 oster *
76 1.1 oster * Permission to use, copy, modify and distribute this software and
77 1.1 oster * its documentation is hereby granted, provided that both the copyright
78 1.1 oster * notice and this permission notice appear in all copies of the
79 1.1 oster * software, derivative works or modified versions, and any portions
80 1.1 oster * thereof, and that both notices appear in supporting documentation.
81 1.1 oster *
82 1.1 oster * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
83 1.1 oster * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
84 1.1 oster * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
85 1.1 oster *
86 1.1 oster * Carnegie Mellon requests users of this software to return to
87 1.1 oster *
88 1.1 oster * Software Distribution Coordinator or Software.Distribution (at) CS.CMU.EDU
89 1.1 oster * School of Computer Science
90 1.1 oster * Carnegie Mellon University
91 1.1 oster * Pittsburgh PA 15213-3890
92 1.1 oster *
93 1.1 oster * any improvements or extensions that they make and grant Carnegie the
94 1.1 oster * rights to redistribute these changes.
95 1.1 oster */
96 1.1 oster
97 1.1 oster /***********************************************************
98 1.1 oster *
99 1.1 oster * rf_kintf.c -- the kernel interface routines for RAIDframe
100 1.1 oster *
101 1.1 oster ***********************************************************/
102 1.112 lukem
103 1.112 lukem #include <sys/cdefs.h>
104 1.410 oster __KERNEL_RCSID(0, "$NetBSD: rf_netbsdkintf.c,v 1.410 2022/08/28 00:37:41 oster Exp $");
105 1.251 ad
106 1.251 ad #ifdef _KERNEL_OPT
107 1.251 ad #include "opt_raid_autoconfig.h"
108 1.363 mrg #include "opt_compat_netbsd32.h"
109 1.251 ad #endif
110 1.1 oster
111 1.113 lukem #include <sys/param.h>
112 1.1 oster #include <sys/errno.h>
113 1.1 oster #include <sys/pool.h>
114 1.152 thorpej #include <sys/proc.h>
115 1.1 oster #include <sys/queue.h>
116 1.1 oster #include <sys/disk.h>
117 1.1 oster #include <sys/device.h>
118 1.1 oster #include <sys/stat.h>
119 1.1 oster #include <sys/ioctl.h>
120 1.1 oster #include <sys/fcntl.h>
121 1.1 oster #include <sys/systm.h>
122 1.1 oster #include <sys/vnode.h>
123 1.1 oster #include <sys/disklabel.h>
124 1.1 oster #include <sys/conf.h>
125 1.1 oster #include <sys/buf.h>
126 1.182 yamt #include <sys/bufq.h>
127 1.65 oster #include <sys/reboot.h>
128 1.208 elad #include <sys/kauth.h>
129 1.327 pgoyette #include <sys/module.h>
130 1.358 pgoyette #include <sys/compat_stub.h>
131 1.8 oster
132 1.234 oster #include <prop/proplib.h>
133 1.234 oster
134 1.110 oster #include <dev/raidframe/raidframevar.h>
135 1.110 oster #include <dev/raidframe/raidframeio.h>
136 1.269 jld #include <dev/raidframe/rf_paritymap.h>
137 1.251 ad
138 1.1 oster #include "rf_raid.h"
139 1.44 oster #include "rf_copyback.h"
140 1.1 oster #include "rf_dag.h"
141 1.1 oster #include "rf_dagflags.h"
142 1.99 oster #include "rf_desc.h"
143 1.1 oster #include "rf_diskqueue.h"
144 1.1 oster #include "rf_etimer.h"
145 1.1 oster #include "rf_general.h"
146 1.1 oster #include "rf_kintf.h"
147 1.1 oster #include "rf_options.h"
148 1.1 oster #include "rf_driver.h"
149 1.1 oster #include "rf_parityscan.h"
150 1.1 oster #include "rf_threadstuff.h"
151 1.1 oster
152 1.325 christos #include "ioconf.h"
153 1.325 christos
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.249 oster #if (RF_INCLUDE_PARITY_DECLUSTERING_DS > 0)
162 1.289 mrg static rf_declare_mutex2(rf_sparet_wait_mutex);
163 1.287 mrg static rf_declare_cond2(rf_sparet_wait_cv);
164 1.287 mrg static rf_declare_cond2(rf_sparet_resp_cv);
165 1.1 oster
166 1.10 oster static RF_SparetWait_t *rf_sparet_wait_queue; /* requests to install a
167 1.10 oster * spare table */
168 1.10 oster static RF_SparetWait_t *rf_sparet_resp_queue; /* responses from
169 1.10 oster * installation process */
170 1.249 oster #endif
171 1.153 thorpej
172 1.384 jdolecek const int rf_b_pass = (B_PHYS|B_RAW|B_MEDIA_FLAGS);
173 1.384 jdolecek
174 1.153 thorpej MALLOC_DEFINE(M_RAIDFRAME, "RAIDframe", "RAIDframe structures");
175 1.10 oster
176 1.1 oster /* prototypes */
177 1.187 christos static void KernelWakeupFunc(struct buf *);
178 1.187 christos static void InitBP(struct buf *, struct vnode *, unsigned,
179 1.225 christos dev_t, RF_SectorNum_t, RF_SectorCount_t, void *, void (*) (struct buf *),
180 1.384 jdolecek void *, int);
181 1.300 christos static void raidinit(struct raid_softc *);
182 1.335 mlelstv static int raiddoaccess(RF_Raid_t *raidPtr, struct buf *bp);
183 1.348 jdolecek static int rf_get_component_caches(RF_Raid_t *raidPtr, int *);
184 1.1 oster
185 1.261 dyoung static int raid_match(device_t, cfdata_t, void *);
186 1.261 dyoung static void raid_attach(device_t, device_t, void *);
187 1.261 dyoung static int raid_detach(device_t, int);
188 1.130 gehenna
189 1.385 riastrad static int raidread_component_area(dev_t, struct vnode *, void *, size_t,
190 1.269 jld daddr_t, daddr_t);
191 1.269 jld static int raidwrite_component_area(dev_t, struct vnode *, void *, size_t,
192 1.269 jld daddr_t, daddr_t, int);
193 1.269 jld
194 1.276 mrg static int raidwrite_component_label(unsigned,
195 1.276 mrg dev_t, struct vnode *, RF_ComponentLabel_t *);
196 1.276 mrg static int raidread_component_label(unsigned,
197 1.276 mrg dev_t, struct vnode *, RF_ComponentLabel_t *);
198 1.269 jld
199 1.335 mlelstv static int raid_diskstart(device_t, struct buf *bp);
200 1.335 mlelstv static int raid_dumpblocks(device_t, void *, daddr_t, int);
201 1.335 mlelstv static int raid_lastclose(device_t);
202 1.269 jld
203 1.324 mrg static dev_type_open(raidopen);
204 1.324 mrg static dev_type_close(raidclose);
205 1.324 mrg static dev_type_read(raidread);
206 1.324 mrg static dev_type_write(raidwrite);
207 1.324 mrg static dev_type_ioctl(raidioctl);
208 1.324 mrg static dev_type_strategy(raidstrategy);
209 1.324 mrg static dev_type_dump(raiddump);
210 1.324 mrg static dev_type_size(raidsize);
211 1.130 gehenna
212 1.130 gehenna const struct bdevsw raid_bdevsw = {
213 1.305 dholland .d_open = raidopen,
214 1.305 dholland .d_close = raidclose,
215 1.305 dholland .d_strategy = raidstrategy,
216 1.305 dholland .d_ioctl = raidioctl,
217 1.305 dholland .d_dump = raiddump,
218 1.305 dholland .d_psize = raidsize,
219 1.311 dholland .d_discard = nodiscard,
220 1.305 dholland .d_flag = D_DISK
221 1.130 gehenna };
222 1.130 gehenna
223 1.130 gehenna const struct cdevsw raid_cdevsw = {
224 1.305 dholland .d_open = raidopen,
225 1.305 dholland .d_close = raidclose,
226 1.305 dholland .d_read = raidread,
227 1.305 dholland .d_write = raidwrite,
228 1.305 dholland .d_ioctl = raidioctl,
229 1.305 dholland .d_stop = nostop,
230 1.305 dholland .d_tty = notty,
231 1.305 dholland .d_poll = nopoll,
232 1.305 dholland .d_mmap = nommap,
233 1.305 dholland .d_kqfilter = nokqfilter,
234 1.312 dholland .d_discard = nodiscard,
235 1.305 dholland .d_flag = D_DISK
236 1.130 gehenna };
237 1.1 oster
238 1.323 mlelstv static struct dkdriver rf_dkdriver = {
239 1.335 mlelstv .d_open = raidopen,
240 1.335 mlelstv .d_close = raidclose,
241 1.323 mlelstv .d_strategy = raidstrategy,
242 1.335 mlelstv .d_diskstart = raid_diskstart,
243 1.335 mlelstv .d_dumpblocks = raid_dumpblocks,
244 1.335 mlelstv .d_lastclose = raid_lastclose,
245 1.323 mlelstv .d_minphys = minphys
246 1.323 mlelstv };
247 1.235 oster
248 1.1 oster #define raidunit(x) DISKUNIT(x)
249 1.335 mlelstv #define raidsoftc(dev) (((struct raid_softc *)device_private(dev))->sc_r.softc)
250 1.1 oster
251 1.202 oster extern struct cfdriver raid_cd;
252 1.266 dyoung CFATTACH_DECL3_NEW(raid, sizeof(struct raid_softc),
253 1.266 dyoung raid_match, raid_attach, raid_detach, NULL, NULL, NULL,
254 1.266 dyoung DVF_DETACH_SHUTDOWN);
255 1.202 oster
256 1.353 mrg /* Internal representation of a rf_recon_req */
257 1.353 mrg struct rf_recon_req_internal {
258 1.353 mrg RF_RowCol_t col;
259 1.353 mrg RF_ReconReqFlags_t flags;
260 1.353 mrg void *raidPtr;
261 1.353 mrg };
262 1.353 mrg
263 1.186 perry /*
264 1.186 perry * Allow RAIDOUTSTANDING number of simultaneous IO's to this RAID device.
265 1.186 perry * Be aware that large numbers can allow the driver to consume a lot of
266 1.28 oster * kernel memory, especially on writes, and in degraded mode reads.
267 1.186 perry *
268 1.186 perry * For example: with a stripe width of 64 blocks (32k) and 5 disks,
269 1.186 perry * a single 64K write will typically require 64K for the old data,
270 1.186 perry * 64K for the old parity, and 64K for the new parity, for a total
271 1.28 oster * of 192K (if the parity buffer is not re-used immediately).
272 1.110 oster * Even it if is used immediately, that's still 128K, which when multiplied
273 1.28 oster * by say 10 requests, is 1280K, *on top* of the 640K of incoming data.
274 1.186 perry *
275 1.28 oster * Now in degraded mode, for example, a 64K read on the above setup may
276 1.186 perry * require data reconstruction, which will require *all* of the 4 remaining
277 1.28 oster * disks to participate -- 4 * 32K/disk == 128K again.
278 1.20 oster */
279 1.20 oster
280 1.20 oster #ifndef RAIDOUTSTANDING
281 1.28 oster #define RAIDOUTSTANDING 6
282 1.20 oster #endif
283 1.20 oster
284 1.1 oster #define RAIDLABELDEV(dev) \
285 1.1 oster (MAKEDISKDEV(major((dev)), raidunit((dev)), RAW_PART))
286 1.1 oster
287 1.1 oster /* declared here, and made public, for the benefit of KVM stuff.. */
288 1.9 oster
289 1.104 oster static int raidlock(struct raid_softc *);
290 1.104 oster static void raidunlock(struct raid_softc *);
291 1.1 oster
292 1.266 dyoung static int raid_detach_unlocked(struct raid_softc *);
293 1.266 dyoung
294 1.104 oster static void rf_markalldirty(RF_Raid_t *);
295 1.304 christos static void rf_set_geometry(struct raid_softc *, RF_Raid_t *);
296 1.48 oster
297 1.393 mrg static void rf_ReconThread(struct rf_recon_req_internal *);
298 1.393 mrg static void rf_RewriteParityThread(RF_Raid_t *raidPtr);
299 1.393 mrg static void rf_CopybackThread(RF_Raid_t *raidPtr);
300 1.393 mrg static void rf_ReconstructInPlaceThread(struct rf_recon_req_internal *);
301 1.393 mrg static int rf_autoconfig(device_t);
302 1.398 oster static int rf_rescan(void);
303 1.393 mrg static void rf_buildroothack(RF_ConfigSet_t *);
304 1.104 oster
305 1.393 mrg static RF_AutoConfig_t *rf_find_raid_components(void);
306 1.393 mrg static RF_ConfigSet_t *rf_create_auto_sets(RF_AutoConfig_t *);
307 1.104 oster static int rf_does_it_fit(RF_ConfigSet_t *,RF_AutoConfig_t *);
308 1.393 mrg static void rf_create_configuration(RF_AutoConfig_t *,RF_Config_t *, RF_Raid_t *);
309 1.393 mrg static int rf_set_autoconfig(RF_Raid_t *, int);
310 1.393 mrg static int rf_set_rootpartition(RF_Raid_t *, int);
311 1.393 mrg static void rf_release_all_vps(RF_ConfigSet_t *);
312 1.393 mrg static void rf_cleanup_config_set(RF_ConfigSet_t *);
313 1.393 mrg static int rf_have_enough_components(RF_ConfigSet_t *);
314 1.393 mrg static struct raid_softc *rf_auto_config_set(RF_ConfigSet_t *);
315 1.278 mrg static void rf_fix_old_label_size(RF_ComponentLabel_t *, uint64_t);
316 1.48 oster
317 1.295 erh /*
318 1.295 erh * Debugging, mostly. Set to 0 to not allow autoconfig to take place.
319 1.295 erh * Note that this is overridden by having RAID_AUTOCONFIG as an option
320 1.295 erh * in the kernel config file.
321 1.295 erh */
322 1.295 erh #ifdef RAID_AUTOCONFIG
323 1.295 erh int raidautoconfig = 1;
324 1.295 erh #else
325 1.295 erh int raidautoconfig = 0;
326 1.295 erh #endif
327 1.295 erh static bool raidautoconfigdone = false;
328 1.37 oster
329 1.395 oster struct pool rf_alloclist_pool; /* AllocList */
330 1.177 oster
331 1.300 christos static LIST_HEAD(, raid_softc) raids = LIST_HEAD_INITIALIZER(raids);
332 1.300 christos static kmutex_t raid_lock;
333 1.1 oster
334 1.300 christos static struct raid_softc *
335 1.300 christos raidcreate(int unit) {
336 1.300 christos struct raid_softc *sc = kmem_zalloc(sizeof(*sc), KM_SLEEP);
337 1.300 christos sc->sc_unit = unit;
338 1.327 pgoyette cv_init(&sc->sc_cv, "raidunit");
339 1.327 pgoyette mutex_init(&sc->sc_mutex, MUTEX_DEFAULT, IPL_NONE);
340 1.300 christos return sc;
341 1.300 christos }
342 1.1 oster
343 1.300 christos static void
344 1.300 christos raiddestroy(struct raid_softc *sc) {
345 1.327 pgoyette cv_destroy(&sc->sc_cv);
346 1.327 pgoyette mutex_destroy(&sc->sc_mutex);
347 1.300 christos kmem_free(sc, sizeof(*sc));
348 1.300 christos }
349 1.50 oster
350 1.300 christos static struct raid_softc *
351 1.327 pgoyette raidget(int unit, bool create) {
352 1.300 christos struct raid_softc *sc;
353 1.300 christos if (unit < 0) {
354 1.300 christos #ifdef DIAGNOSTIC
355 1.300 christos panic("%s: unit %d!", __func__, unit);
356 1.300 christos #endif
357 1.300 christos return NULL;
358 1.300 christos }
359 1.300 christos mutex_enter(&raid_lock);
360 1.300 christos LIST_FOREACH(sc, &raids, sc_link) {
361 1.300 christos if (sc->sc_unit == unit) {
362 1.300 christos mutex_exit(&raid_lock);
363 1.300 christos return sc;
364 1.300 christos }
365 1.300 christos }
366 1.300 christos mutex_exit(&raid_lock);
367 1.327 pgoyette if (!create)
368 1.327 pgoyette return NULL;
369 1.379 chs sc = raidcreate(unit);
370 1.300 christos mutex_enter(&raid_lock);
371 1.300 christos LIST_INSERT_HEAD(&raids, sc, sc_link);
372 1.300 christos mutex_exit(&raid_lock);
373 1.300 christos return sc;
374 1.300 christos }
375 1.300 christos
376 1.385 riastrad static void
377 1.300 christos raidput(struct raid_softc *sc) {
378 1.300 christos mutex_enter(&raid_lock);
379 1.300 christos LIST_REMOVE(sc, sc_link);
380 1.300 christos mutex_exit(&raid_lock);
381 1.300 christos raiddestroy(sc);
382 1.300 christos }
383 1.1 oster
384 1.300 christos void
385 1.300 christos raidattach(int num)
386 1.300 christos {
387 1.62 oster
388 1.142 thorpej /*
389 1.327 pgoyette * Device attachment and associated initialization now occurs
390 1.327 pgoyette * as part of the module initialization.
391 1.142 thorpej */
392 1.142 thorpej }
393 1.142 thorpej
394 1.393 mrg static int
395 1.261 dyoung rf_autoconfig(device_t self)
396 1.142 thorpej {
397 1.142 thorpej RF_AutoConfig_t *ac_list;
398 1.142 thorpej RF_ConfigSet_t *config_sets;
399 1.142 thorpej
400 1.295 erh if (!raidautoconfig || raidautoconfigdone == true)
401 1.389 skrll return 0;
402 1.142 thorpej
403 1.142 thorpej /* XXX This code can only be run once. */
404 1.295 erh raidautoconfigdone = true;
405 1.142 thorpej
406 1.307 christos #ifdef __HAVE_CPU_BOOTCONF
407 1.307 christos /*
408 1.307 christos * 0. find the boot device if needed first so we can use it later
409 1.307 christos * this needs to be done before we autoconfigure any raid sets,
410 1.307 christos * because if we use wedges we are not going to be able to open
411 1.307 christos * the boot device later
412 1.307 christos */
413 1.307 christos if (booted_device == NULL)
414 1.307 christos cpu_bootconf();
415 1.307 christos #endif
416 1.48 oster /* 1. locate all RAID components on the system */
417 1.258 ad aprint_debug("Searching for RAID components...\n");
418 1.48 oster ac_list = rf_find_raid_components();
419 1.48 oster
420 1.142 thorpej /* 2. Sort them into their respective sets. */
421 1.48 oster config_sets = rf_create_auto_sets(ac_list);
422 1.48 oster
423 1.142 thorpej /*
424 1.299 oster * 3. Evaluate each set and configure the valid ones.
425 1.142 thorpej * This gets done in rf_buildroothack().
426 1.142 thorpej */
427 1.142 thorpej rf_buildroothack(config_sets);
428 1.48 oster
429 1.213 christos return 1;
430 1.48 oster }
431 1.48 oster
432 1.367 christos int
433 1.367 christos rf_inited(const struct raid_softc *rs) {
434 1.367 christos return (rs->sc_flags & RAIDF_INITED) != 0;
435 1.367 christos }
436 1.367 christos
437 1.368 oster RF_Raid_t *
438 1.368 oster rf_get_raid(struct raid_softc *rs) {
439 1.368 oster return &rs->sc_r;
440 1.368 oster }
441 1.368 oster
442 1.367 christos int
443 1.367 christos rf_get_unit(const struct raid_softc *rs) {
444 1.367 christos return rs->sc_unit;
445 1.367 christos }
446 1.367 christos
447 1.306 christos static int
448 1.307 christos rf_containsboot(RF_Raid_t *r, device_t bdv) {
449 1.359 bad const char *bootname;
450 1.359 bad size_t len;
451 1.359 bad
452 1.359 bad /* if bdv is NULL, the set can't contain it. exit early. */
453 1.359 bad if (bdv == NULL)
454 1.359 bad return 0;
455 1.359 bad
456 1.359 bad bootname = device_xname(bdv);
457 1.359 bad len = strlen(bootname);
458 1.306 christos
459 1.306 christos for (int col = 0; col < r->numCol; col++) {
460 1.307 christos const char *devname = r->Disks[col].devname;
461 1.306 christos devname += sizeof("/dev/") - 1;
462 1.307 christos if (strncmp(devname, "dk", 2) == 0) {
463 1.307 christos const char *parent =
464 1.307 christos dkwedge_get_parent_name(r->Disks[col].dev);
465 1.307 christos if (parent != NULL)
466 1.307 christos devname = parent;
467 1.307 christos }
468 1.306 christos if (strncmp(devname, bootname, len) == 0) {
469 1.306 christos struct raid_softc *sc = r->softc;
470 1.306 christos aprint_debug("raid%d includes boot device %s\n",
471 1.306 christos sc->sc_unit, devname);
472 1.306 christos return 1;
473 1.306 christos }
474 1.306 christos }
475 1.306 christos return 0;
476 1.306 christos }
477 1.306 christos
478 1.398 oster static int
479 1.398 oster rf_rescan(void)
480 1.398 oster {
481 1.398 oster RF_AutoConfig_t *ac_list;
482 1.398 oster RF_ConfigSet_t *config_sets, *cset, *next_cset;
483 1.398 oster struct raid_softc *sc;
484 1.398 oster int raid_added;
485 1.398 oster
486 1.398 oster ac_list = rf_find_raid_components();
487 1.398 oster config_sets = rf_create_auto_sets(ac_list);
488 1.398 oster
489 1.398 oster raid_added = 1;
490 1.398 oster while (raid_added > 0) {
491 1.398 oster raid_added = 0;
492 1.398 oster cset = config_sets;
493 1.398 oster while (cset != NULL) {
494 1.398 oster next_cset = cset->next;
495 1.398 oster if (rf_have_enough_components(cset) &&
496 1.398 oster cset->ac->clabel->autoconfigure == 1) {
497 1.398 oster sc = rf_auto_config_set(cset);
498 1.398 oster if (sc != NULL) {
499 1.398 oster aprint_debug("raid%d: configured ok, rootable %d\n",
500 1.398 oster sc->sc_unit, cset->rootable);
501 1.398 oster /* We added one RAID set */
502 1.398 oster raid_added++;
503 1.398 oster } else {
504 1.398 oster /* The autoconfig didn't work :( */
505 1.398 oster aprint_debug("Autoconfig failed\n");
506 1.398 oster rf_release_all_vps(cset);
507 1.398 oster }
508 1.398 oster } else {
509 1.398 oster /* we're not autoconfiguring this set...
510 1.398 oster release the associated resources */
511 1.398 oster rf_release_all_vps(cset);
512 1.398 oster }
513 1.398 oster /* cleanup */
514 1.398 oster rf_cleanup_config_set(cset);
515 1.398 oster cset = next_cset;
516 1.398 oster }
517 1.398 oster if (raid_added > 0) {
518 1.398 oster /* We added at least one RAID set, so re-scan for recursive RAID */
519 1.398 oster ac_list = rf_find_raid_components();
520 1.398 oster config_sets = rf_create_auto_sets(ac_list);
521 1.398 oster }
522 1.398 oster }
523 1.398 oster
524 1.398 oster return 0;
525 1.398 oster }
526 1.398 oster
527 1.398 oster
528 1.393 mrg static void
529 1.142 thorpej rf_buildroothack(RF_ConfigSet_t *config_sets)
530 1.48 oster {
531 1.397 oster RF_AutoConfig_t *ac_list;
532 1.48 oster RF_ConfigSet_t *cset;
533 1.48 oster RF_ConfigSet_t *next_cset;
534 1.51 oster int num_root;
535 1.397 oster int raid_added;
536 1.300 christos struct raid_softc *sc, *rsc;
537 1.378 martin struct dk_softc *dksc = NULL; /* XXX gcc -Os: may be used uninit. */
538 1.48 oster
539 1.300 christos sc = rsc = NULL;
540 1.51 oster num_root = 0;
541 1.397 oster
542 1.397 oster raid_added = 1;
543 1.397 oster while (raid_added > 0) {
544 1.397 oster raid_added = 0;
545 1.397 oster cset = config_sets;
546 1.397 oster while (cset != NULL) {
547 1.397 oster next_cset = cset->next;
548 1.397 oster if (rf_have_enough_components(cset) &&
549 1.397 oster cset->ac->clabel->autoconfigure == 1) {
550 1.397 oster sc = rf_auto_config_set(cset);
551 1.397 oster if (sc != NULL) {
552 1.397 oster aprint_debug("raid%d: configured ok, rootable %d\n",
553 1.397 oster sc->sc_unit, cset->rootable);
554 1.397 oster /* We added one RAID set */
555 1.397 oster raid_added++;
556 1.397 oster if (cset->rootable) {
557 1.397 oster rsc = sc;
558 1.397 oster num_root++;
559 1.397 oster }
560 1.397 oster } else {
561 1.397 oster /* The autoconfig didn't work :( */
562 1.397 oster aprint_debug("Autoconfig failed\n");
563 1.397 oster rf_release_all_vps(cset);
564 1.51 oster }
565 1.51 oster } else {
566 1.397 oster /* we're not autoconfiguring this set...
567 1.397 oster release the associated resources */
568 1.51 oster rf_release_all_vps(cset);
569 1.48 oster }
570 1.397 oster /* cleanup */
571 1.397 oster rf_cleanup_config_set(cset);
572 1.397 oster cset = next_cset;
573 1.397 oster }
574 1.397 oster if (raid_added > 0) {
575 1.397 oster /* We added at least one RAID set, so re-scan for recursive RAID */
576 1.397 oster ac_list = rf_find_raid_components();
577 1.397 oster config_sets = rf_create_auto_sets(ac_list);
578 1.48 oster }
579 1.48 oster }
580 1.397 oster
581 1.223 oster /* if the user has specified what the root device should be
582 1.223 oster then we don't touch booted_device or boothowto... */
583 1.223 oster
584 1.359 bad if (rootspec != NULL) {
585 1.403 mrg aprint_debug("%s: rootspec %s\n", __func__, rootspec);
586 1.223 oster return;
587 1.359 bad }
588 1.223 oster
589 1.122 oster /* we found something bootable... */
590 1.122 oster
591 1.310 christos /*
592 1.310 christos * XXX: The following code assumes that the root raid
593 1.310 christos * is the first ('a') partition. This is about the best
594 1.310 christos * we can do with a BSD disklabel, but we might be able
595 1.310 christos * to do better with a GPT label, by setting a specified
596 1.310 christos * attribute to indicate the root partition. We can then
597 1.310 christos * stash the partition number in the r->root_partition
598 1.310 christos * high bits (the bottom 2 bits are already used). For
599 1.310 christos * now we just set booted_partition to 0 when we override
600 1.310 christos * root.
601 1.310 christos */
602 1.122 oster if (num_root == 1) {
603 1.306 christos device_t candidate_root;
604 1.377 maxv dksc = &rsc->sc_dksc;
605 1.335 mlelstv if (dksc->sc_dkdev.dk_nwedges != 0) {
606 1.297 christos char cname[sizeof(cset->ac->devname)];
607 1.344 christos /* XXX: assume partition 'a' first */
608 1.297 christos snprintf(cname, sizeof(cname), "%s%c",
609 1.335 mlelstv device_xname(dksc->sc_dev), 'a');
610 1.306 christos candidate_root = dkwedge_find_by_wname(cname);
611 1.403 mrg aprint_debug("%s: candidate wedge root=%s\n", __func__,
612 1.344 christos cname);
613 1.344 christos if (candidate_root == NULL) {
614 1.344 christos /*
615 1.344 christos * If that is not found, because we don't use
616 1.344 christos * disklabel, return the first dk child
617 1.344 christos * XXX: we can skip the 'a' check above
618 1.344 christos * and always do this...
619 1.344 christos */
620 1.344 christos size_t i = 0;
621 1.344 christos candidate_root = dkwedge_find_by_parent(
622 1.344 christos device_xname(dksc->sc_dev), &i);
623 1.344 christos }
624 1.403 mrg aprint_debug("%s: candidate wedge root=%p\n", __func__,
625 1.344 christos candidate_root);
626 1.297 christos } else
627 1.335 mlelstv candidate_root = dksc->sc_dev;
628 1.403 mrg aprint_debug("%s: candidate root=%p booted_device=%p "
629 1.403 mrg "root_partition=%d contains_boot=%d\n",
630 1.402 mrg __func__, candidate_root, booted_device,
631 1.402 mrg rsc->sc_r.root_partition,
632 1.402 mrg rf_containsboot(&rsc->sc_r, booted_device));
633 1.359 bad /* XXX the check for booted_device == NULL can probably be
634 1.359 bad * dropped, now that rf_containsboot handles that case.
635 1.359 bad */
636 1.308 christos if (booted_device == NULL ||
637 1.308 christos rsc->sc_r.root_partition == 1 ||
638 1.310 christos rf_containsboot(&rsc->sc_r, booted_device)) {
639 1.308 christos booted_device = candidate_root;
640 1.351 christos booted_method = "raidframe/single";
641 1.310 christos booted_partition = 0; /* XXX assume 'a' */
642 1.403 mrg aprint_debug("%s: set booted_device=%s(%p)\n", __func__,
643 1.392 mrg device_xname(booted_device), booted_device);
644 1.310 christos }
645 1.122 oster } else if (num_root > 1) {
646 1.403 mrg aprint_debug("%s: many roots=%d, %p\n", __func__, num_root,
647 1.344 christos booted_device);
648 1.226 oster
649 1.385 riastrad /*
650 1.226 oster * Maybe the MD code can help. If it cannot, then
651 1.226 oster * setroot() will discover that we have no
652 1.226 oster * booted_device and will ask the user if nothing was
653 1.385 riastrad * hardwired in the kernel config file
654 1.226 oster */
655 1.385 riastrad if (booted_device == NULL)
656 1.226 oster return;
657 1.226 oster
658 1.226 oster num_root = 0;
659 1.300 christos mutex_enter(&raid_lock);
660 1.300 christos LIST_FOREACH(sc, &raids, sc_link) {
661 1.300 christos RF_Raid_t *r = &sc->sc_r;
662 1.300 christos if (r->valid == 0)
663 1.226 oster continue;
664 1.226 oster
665 1.300 christos if (r->root_partition == 0)
666 1.226 oster continue;
667 1.226 oster
668 1.306 christos if (rf_containsboot(r, booted_device)) {
669 1.226 oster num_root++;
670 1.300 christos rsc = sc;
671 1.335 mlelstv dksc = &rsc->sc_dksc;
672 1.226 oster }
673 1.226 oster }
674 1.300 christos mutex_exit(&raid_lock);
675 1.295 erh
676 1.226 oster if (num_root == 1) {
677 1.335 mlelstv booted_device = dksc->sc_dev;
678 1.351 christos booted_method = "raidframe/multi";
679 1.310 christos booted_partition = 0; /* XXX assume 'a' */
680 1.226 oster } else {
681 1.226 oster /* we can't guess.. require the user to answer... */
682 1.226 oster boothowto |= RB_ASKNAME;
683 1.226 oster }
684 1.51 oster }
685 1.1 oster }
686 1.1 oster
687 1.324 mrg static int
688 1.169 oster raidsize(dev_t dev)
689 1.1 oster {
690 1.1 oster struct raid_softc *rs;
691 1.335 mlelstv struct dk_softc *dksc;
692 1.335 mlelstv unsigned int unit;
693 1.1 oster
694 1.1 oster unit = raidunit(dev);
695 1.327 pgoyette if ((rs = raidget(unit, false)) == NULL)
696 1.336 mlelstv return -1;
697 1.335 mlelstv dksc = &rs->sc_dksc;
698 1.335 mlelstv
699 1.1 oster if ((rs->sc_flags & RAIDF_INITED) == 0)
700 1.336 mlelstv return -1;
701 1.1 oster
702 1.335 mlelstv return dk_size(dksc, dev);
703 1.335 mlelstv }
704 1.1 oster
705 1.335 mlelstv static int
706 1.335 mlelstv raiddump(dev_t dev, daddr_t blkno, void *va, size_t size)
707 1.335 mlelstv {
708 1.335 mlelstv unsigned int unit;
709 1.335 mlelstv struct raid_softc *rs;
710 1.335 mlelstv struct dk_softc *dksc;
711 1.1 oster
712 1.335 mlelstv unit = raidunit(dev);
713 1.335 mlelstv if ((rs = raidget(unit, false)) == NULL)
714 1.335 mlelstv return ENXIO;
715 1.335 mlelstv dksc = &rs->sc_dksc;
716 1.1 oster
717 1.335 mlelstv if ((rs->sc_flags & RAIDF_INITED) == 0)
718 1.335 mlelstv return ENODEV;
719 1.1 oster
720 1.336 mlelstv /*
721 1.336 mlelstv Note that blkno is relative to this particular partition.
722 1.336 mlelstv By adding adding RF_PROTECTED_SECTORS, we get a value that
723 1.336 mlelstv is relative to the partition used for the underlying component.
724 1.336 mlelstv */
725 1.336 mlelstv blkno += RF_PROTECTED_SECTORS;
726 1.336 mlelstv
727 1.380 riastrad return dk_dump(dksc, dev, blkno, va, size, DK_DUMP_RECURSIVE);
728 1.1 oster }
729 1.1 oster
730 1.324 mrg static int
731 1.335 mlelstv raid_dumpblocks(device_t dev, void *va, daddr_t blkno, int nblk)
732 1.1 oster {
733 1.335 mlelstv struct raid_softc *rs = raidsoftc(dev);
734 1.231 oster const struct bdevsw *bdev;
735 1.231 oster RF_Raid_t *raidPtr;
736 1.335 mlelstv int c, sparecol, j, scol, dumpto;
737 1.231 oster int error = 0;
738 1.231 oster
739 1.300 christos raidPtr = &rs->sc_r;
740 1.231 oster
741 1.231 oster /* we only support dumping to RAID 1 sets */
742 1.385 riastrad if (raidPtr->Layout.numDataCol != 1 ||
743 1.231 oster raidPtr->Layout.numParityCol != 1)
744 1.231 oster return EINVAL;
745 1.231 oster
746 1.231 oster if ((error = raidlock(rs)) != 0)
747 1.231 oster return error;
748 1.231 oster
749 1.231 oster /* figure out what device is alive.. */
750 1.231 oster
751 1.385 riastrad /*
752 1.231 oster Look for a component to dump to. The preference for the
753 1.231 oster component to dump to is as follows:
754 1.383 oster 1) the first component
755 1.383 oster 2) a used_spare of the first component
756 1.383 oster 3) the second component
757 1.383 oster 4) a used_spare of the second component
758 1.231 oster */
759 1.231 oster
760 1.231 oster dumpto = -1;
761 1.231 oster for (c = 0; c < raidPtr->numCol; c++) {
762 1.231 oster if (raidPtr->Disks[c].status == rf_ds_optimal) {
763 1.231 oster /* this might be the one */
764 1.231 oster dumpto = c;
765 1.231 oster break;
766 1.231 oster }
767 1.231 oster }
768 1.385 riastrad
769 1.385 riastrad /*
770 1.383 oster At this point we have possibly selected a live component.
771 1.383 oster If we didn't find a live ocmponent, we now check to see
772 1.383 oster if there is a relevant spared component.
773 1.231 oster */
774 1.231 oster
775 1.231 oster for (c = 0; c < raidPtr->numSpare; c++) {
776 1.231 oster sparecol = raidPtr->numCol + c;
777 1.231 oster if (raidPtr->Disks[sparecol].status == rf_ds_used_spare) {
778 1.231 oster /* How about this one? */
779 1.231 oster scol = -1;
780 1.231 oster for(j=0;j<raidPtr->numCol;j++) {
781 1.231 oster if (raidPtr->Disks[j].spareCol == sparecol) {
782 1.231 oster scol = j;
783 1.231 oster break;
784 1.231 oster }
785 1.231 oster }
786 1.231 oster if (scol == 0) {
787 1.385 riastrad /*
788 1.383 oster We must have found a spared first
789 1.383 oster component! We'll take that over
790 1.383 oster anything else found so far. (We
791 1.383 oster couldn't have found a real first
792 1.383 oster component before, since this is a
793 1.383 oster used spare, and it's saying that
794 1.383 oster it's replacing the first
795 1.383 oster component.) On reboot (with
796 1.231 oster autoconfiguration turned on)
797 1.383 oster sparecol will become the first
798 1.383 oster component (component0) of this set.
799 1.231 oster */
800 1.231 oster dumpto = sparecol;
801 1.231 oster break;
802 1.231 oster } else if (scol != -1) {
803 1.385 riastrad /*
804 1.385 riastrad Must be a spared second component.
805 1.385 riastrad We'll dump to that if we havn't found
806 1.385 riastrad anything else so far.
807 1.231 oster */
808 1.231 oster if (dumpto == -1)
809 1.231 oster dumpto = sparecol;
810 1.231 oster }
811 1.231 oster }
812 1.231 oster }
813 1.385 riastrad
814 1.231 oster if (dumpto == -1) {
815 1.231 oster /* we couldn't find any live components to dump to!?!?
816 1.231 oster */
817 1.231 oster error = EINVAL;
818 1.231 oster goto out;
819 1.231 oster }
820 1.231 oster
821 1.231 oster bdev = bdevsw_lookup(raidPtr->Disks[dumpto].dev);
822 1.342 mlelstv if (bdev == NULL) {
823 1.342 mlelstv error = ENXIO;
824 1.342 mlelstv goto out;
825 1.342 mlelstv }
826 1.231 oster
827 1.385 riastrad error = (*bdev->d_dump)(raidPtr->Disks[dumpto].dev,
828 1.336 mlelstv blkno, va, nblk * raidPtr->bytesPerSector);
829 1.385 riastrad
830 1.231 oster out:
831 1.231 oster raidunlock(rs);
832 1.385 riastrad
833 1.231 oster return error;
834 1.1 oster }
835 1.324 mrg
836 1.1 oster /* ARGSUSED */
837 1.324 mrg static int
838 1.222 christos raidopen(dev_t dev, int flags, int fmt,
839 1.222 christos struct lwp *l)
840 1.1 oster {
841 1.9 oster int unit = raidunit(dev);
842 1.1 oster struct raid_softc *rs;
843 1.335 mlelstv struct dk_softc *dksc;
844 1.335 mlelstv int error = 0;
845 1.9 oster int part, pmask;
846 1.9 oster
847 1.327 pgoyette if ((rs = raidget(unit, true)) == NULL)
848 1.300 christos return ENXIO;
849 1.1 oster if ((error = raidlock(rs)) != 0)
850 1.389 skrll return error;
851 1.266 dyoung
852 1.266 dyoung if ((rs->sc_flags & RAIDF_SHUTDOWN) != 0) {
853 1.266 dyoung error = EBUSY;
854 1.266 dyoung goto bad;
855 1.266 dyoung }
856 1.266 dyoung
857 1.335 mlelstv dksc = &rs->sc_dksc;
858 1.1 oster
859 1.1 oster part = DISKPART(dev);
860 1.1 oster pmask = (1 << part);
861 1.1 oster
862 1.335 mlelstv if (!DK_BUSY(dksc, pmask) &&
863 1.13 oster ((rs->sc_flags & RAIDF_INITED) != 0)) {
864 1.13 oster /* First one... mark things as dirty... Note that we *MUST*
865 1.13 oster have done a configure before this. I DO NOT WANT TO BE
866 1.13 oster SCRIBBLING TO RANDOM COMPONENTS UNTIL IT'S BEEN DETERMINED
867 1.13 oster THAT THEY BELONG TOGETHER!!!!! */
868 1.13 oster /* XXX should check to see if we're only open for reading
869 1.13 oster here... If so, we needn't do this, but then need some
870 1.13 oster other way of keeping track of what's happened.. */
871 1.13 oster
872 1.300 christos rf_markalldirty(&rs->sc_r);
873 1.13 oster }
874 1.13 oster
875 1.335 mlelstv if ((rs->sc_flags & RAIDF_INITED) != 0)
876 1.335 mlelstv error = dk_open(dksc, dev, flags, fmt, l);
877 1.1 oster
878 1.213 christos bad:
879 1.1 oster raidunlock(rs);
880 1.1 oster
881 1.389 skrll return error;
882 1.1 oster
883 1.1 oster
884 1.1 oster }
885 1.324 mrg
886 1.335 mlelstv static int
887 1.335 mlelstv raid_lastclose(device_t self)
888 1.335 mlelstv {
889 1.335 mlelstv struct raid_softc *rs = raidsoftc(self);
890 1.335 mlelstv
891 1.335 mlelstv /* Last one... device is not unconfigured yet.
892 1.335 mlelstv Device shutdown has taken care of setting the
893 1.335 mlelstv clean bits if RAIDF_INITED is not set
894 1.335 mlelstv mark things as clean... */
895 1.335 mlelstv
896 1.335 mlelstv rf_update_component_labels(&rs->sc_r,
897 1.335 mlelstv RF_FINAL_COMPONENT_UPDATE);
898 1.335 mlelstv
899 1.335 mlelstv /* pass to unlocked code */
900 1.335 mlelstv if ((rs->sc_flags & RAIDF_SHUTDOWN) != 0)
901 1.335 mlelstv rs->sc_flags |= RAIDF_DETACH;
902 1.335 mlelstv
903 1.335 mlelstv return 0;
904 1.335 mlelstv }
905 1.335 mlelstv
906 1.1 oster /* ARGSUSED */
907 1.324 mrg static int
908 1.222 christos raidclose(dev_t dev, int flags, int fmt, struct lwp *l)
909 1.1 oster {
910 1.9 oster int unit = raidunit(dev);
911 1.1 oster struct raid_softc *rs;
912 1.335 mlelstv struct dk_softc *dksc;
913 1.335 mlelstv cfdata_t cf;
914 1.335 mlelstv int error = 0, do_detach = 0, do_put = 0;
915 1.1 oster
916 1.327 pgoyette if ((rs = raidget(unit, false)) == NULL)
917 1.300 christos return ENXIO;
918 1.335 mlelstv dksc = &rs->sc_dksc;
919 1.1 oster
920 1.1 oster if ((error = raidlock(rs)) != 0)
921 1.389 skrll return error;
922 1.1 oster
923 1.335 mlelstv if ((rs->sc_flags & RAIDF_INITED) != 0) {
924 1.335 mlelstv error = dk_close(dksc, dev, flags, fmt, l);
925 1.335 mlelstv if ((rs->sc_flags & RAIDF_DETACH) != 0)
926 1.335 mlelstv do_detach = 1;
927 1.335 mlelstv } else if ((rs->sc_flags & RAIDF_SHUTDOWN) != 0)
928 1.335 mlelstv do_put = 1;
929 1.1 oster
930 1.335 mlelstv raidunlock(rs);
931 1.1 oster
932 1.335 mlelstv if (do_detach) {
933 1.335 mlelstv /* free the pseudo device attach bits */
934 1.335 mlelstv cf = device_cfdata(dksc->sc_dev);
935 1.335 mlelstv error = config_detach(dksc->sc_dev, 0);
936 1.385 riastrad if (error == 0)
937 1.335 mlelstv free(cf, M_RAIDFRAME);
938 1.335 mlelstv } else if (do_put) {
939 1.335 mlelstv raidput(rs);
940 1.1 oster }
941 1.186 perry
942 1.389 skrll return error;
943 1.147 oster
944 1.335 mlelstv }
945 1.327 pgoyette
946 1.335 mlelstv static void
947 1.335 mlelstv raid_wakeup(RF_Raid_t *raidPtr)
948 1.335 mlelstv {
949 1.335 mlelstv rf_lock_mutex2(raidPtr->iodone_lock);
950 1.335 mlelstv rf_signal_cond2(raidPtr->iodone_cv);
951 1.335 mlelstv rf_unlock_mutex2(raidPtr->iodone_lock);
952 1.1 oster }
953 1.1 oster
954 1.324 mrg static void
955 1.169 oster raidstrategy(struct buf *bp)
956 1.1 oster {
957 1.335 mlelstv unsigned int unit;
958 1.335 mlelstv struct raid_softc *rs;
959 1.335 mlelstv struct dk_softc *dksc;
960 1.1 oster RF_Raid_t *raidPtr;
961 1.1 oster
962 1.335 mlelstv unit = raidunit(bp->b_dev);
963 1.327 pgoyette if ((rs = raidget(unit, false)) == NULL) {
964 1.30 oster bp->b_error = ENXIO;
965 1.335 mlelstv goto fail;
966 1.30 oster }
967 1.300 christos if ((rs->sc_flags & RAIDF_INITED) == 0) {
968 1.300 christos bp->b_error = ENXIO;
969 1.335 mlelstv goto fail;
970 1.1 oster }
971 1.335 mlelstv dksc = &rs->sc_dksc;
972 1.300 christos raidPtr = &rs->sc_r;
973 1.335 mlelstv
974 1.335 mlelstv /* Queue IO only */
975 1.335 mlelstv if (dk_strategy_defer(dksc, bp))
976 1.196 yamt goto done;
977 1.1 oster
978 1.335 mlelstv /* schedule the IO to happen at the next convenient time */
979 1.335 mlelstv raid_wakeup(raidPtr);
980 1.335 mlelstv
981 1.335 mlelstv done:
982 1.335 mlelstv return;
983 1.335 mlelstv
984 1.335 mlelstv fail:
985 1.335 mlelstv bp->b_resid = bp->b_bcount;
986 1.335 mlelstv biodone(bp);
987 1.335 mlelstv }
988 1.335 mlelstv
989 1.335 mlelstv static int
990 1.335 mlelstv raid_diskstart(device_t dev, struct buf *bp)
991 1.335 mlelstv {
992 1.335 mlelstv struct raid_softc *rs = raidsoftc(dev);
993 1.335 mlelstv RF_Raid_t *raidPtr;
994 1.1 oster
995 1.335 mlelstv raidPtr = &rs->sc_r;
996 1.335 mlelstv if (!raidPtr->valid) {
997 1.335 mlelstv db1_printf(("raid is not valid..\n"));
998 1.335 mlelstv return ENODEV;
999 1.196 yamt }
1000 1.285 mrg
1001 1.335 mlelstv /* XXX */
1002 1.335 mlelstv bp->b_resid = 0;
1003 1.335 mlelstv
1004 1.335 mlelstv return raiddoaccess(raidPtr, bp);
1005 1.335 mlelstv }
1006 1.1 oster
1007 1.335 mlelstv void
1008 1.335 mlelstv raiddone(RF_Raid_t *raidPtr, struct buf *bp)
1009 1.335 mlelstv {
1010 1.335 mlelstv struct raid_softc *rs;
1011 1.335 mlelstv struct dk_softc *dksc;
1012 1.34 oster
1013 1.335 mlelstv rs = raidPtr->softc;
1014 1.335 mlelstv dksc = &rs->sc_dksc;
1015 1.34 oster
1016 1.335 mlelstv dk_done(dksc, bp);
1017 1.34 oster
1018 1.335 mlelstv rf_lock_mutex2(raidPtr->mutex);
1019 1.335 mlelstv raidPtr->openings++;
1020 1.335 mlelstv rf_unlock_mutex2(raidPtr->mutex);
1021 1.196 yamt
1022 1.335 mlelstv /* schedule more IO */
1023 1.335 mlelstv raid_wakeup(raidPtr);
1024 1.1 oster }
1025 1.324 mrg
1026 1.1 oster /* ARGSUSED */
1027 1.324 mrg static int
1028 1.222 christos raidread(dev_t dev, struct uio *uio, int flags)
1029 1.1 oster {
1030 1.9 oster int unit = raidunit(dev);
1031 1.1 oster struct raid_softc *rs;
1032 1.1 oster
1033 1.327 pgoyette if ((rs = raidget(unit, false)) == NULL)
1034 1.300 christos return ENXIO;
1035 1.1 oster
1036 1.1 oster if ((rs->sc_flags & RAIDF_INITED) == 0)
1037 1.389 skrll return ENXIO;
1038 1.1 oster
1039 1.389 skrll return physio(raidstrategy, NULL, dev, B_READ, minphys, uio);
1040 1.1 oster
1041 1.1 oster }
1042 1.324 mrg
1043 1.1 oster /* ARGSUSED */
1044 1.324 mrg static int
1045 1.222 christos raidwrite(dev_t dev, struct uio *uio, int flags)
1046 1.1 oster {
1047 1.9 oster int unit = raidunit(dev);
1048 1.1 oster struct raid_softc *rs;
1049 1.1 oster
1050 1.327 pgoyette if ((rs = raidget(unit, false)) == NULL)
1051 1.300 christos return ENXIO;
1052 1.1 oster
1053 1.1 oster if ((rs->sc_flags & RAIDF_INITED) == 0)
1054 1.389 skrll return ENXIO;
1055 1.147 oster
1056 1.389 skrll return physio(raidstrategy, NULL, dev, B_WRITE, minphys, uio);
1057 1.1 oster
1058 1.1 oster }
1059 1.1 oster
1060 1.266 dyoung static int
1061 1.266 dyoung raid_detach_unlocked(struct raid_softc *rs)
1062 1.266 dyoung {
1063 1.335 mlelstv struct dk_softc *dksc = &rs->sc_dksc;
1064 1.335 mlelstv RF_Raid_t *raidPtr;
1065 1.266 dyoung int error;
1066 1.266 dyoung
1067 1.300 christos raidPtr = &rs->sc_r;
1068 1.266 dyoung
1069 1.337 mlelstv if (DK_BUSY(dksc, 0) ||
1070 1.337 mlelstv raidPtr->recon_in_progress != 0 ||
1071 1.337 mlelstv raidPtr->parity_rewrite_in_progress != 0 ||
1072 1.337 mlelstv raidPtr->copyback_in_progress != 0)
1073 1.266 dyoung return EBUSY;
1074 1.266 dyoung
1075 1.266 dyoung if ((rs->sc_flags & RAIDF_INITED) == 0)
1076 1.333 mlelstv return 0;
1077 1.333 mlelstv
1078 1.333 mlelstv rs->sc_flags &= ~RAIDF_SHUTDOWN;
1079 1.333 mlelstv
1080 1.333 mlelstv if ((error = rf_Shutdown(raidPtr)) != 0)
1081 1.266 dyoung return error;
1082 1.266 dyoung
1083 1.335 mlelstv rs->sc_flags &= ~RAIDF_INITED;
1084 1.335 mlelstv
1085 1.335 mlelstv /* Kill off any queued buffers */
1086 1.335 mlelstv dk_drain(dksc);
1087 1.335 mlelstv bufq_free(dksc->sc_bufq);
1088 1.335 mlelstv
1089 1.266 dyoung /* Detach the disk. */
1090 1.335 mlelstv dkwedge_delall(&dksc->sc_dkdev);
1091 1.335 mlelstv disk_detach(&dksc->sc_dkdev);
1092 1.335 mlelstv disk_destroy(&dksc->sc_dkdev);
1093 1.335 mlelstv dk_detach(dksc);
1094 1.333 mlelstv
1095 1.266 dyoung return 0;
1096 1.266 dyoung }
1097 1.266 dyoung
1098 1.366 christos int
1099 1.366 christos rf_fail_disk(RF_Raid_t *raidPtr, struct rf_recon_req *rr)
1100 1.366 christos {
1101 1.366 christos struct rf_recon_req_internal *rrint;
1102 1.366 christos
1103 1.366 christos if (raidPtr->Layout.map->faultsTolerated == 0) {
1104 1.366 christos /* Can't do this on a RAID 0!! */
1105 1.366 christos return EINVAL;
1106 1.366 christos }
1107 1.366 christos
1108 1.366 christos if (rr->col < 0 || rr->col >= raidPtr->numCol) {
1109 1.366 christos /* bad column */
1110 1.366 christos return EINVAL;
1111 1.366 christos }
1112 1.366 christos
1113 1.366 christos rf_lock_mutex2(raidPtr->mutex);
1114 1.366 christos if (raidPtr->status == rf_rs_reconstructing) {
1115 1.366 christos /* you can't fail a disk while we're reconstructing! */
1116 1.366 christos /* XXX wrong for RAID6 */
1117 1.366 christos goto out;
1118 1.366 christos }
1119 1.366 christos if ((raidPtr->Disks[rr->col].status == rf_ds_optimal) &&
1120 1.366 christos (raidPtr->numFailures > 0)) {
1121 1.366 christos /* some other component has failed. Let's not make
1122 1.366 christos things worse. XXX wrong for RAID6 */
1123 1.366 christos goto out;
1124 1.366 christos }
1125 1.366 christos if (raidPtr->Disks[rr->col].status == rf_ds_spared) {
1126 1.366 christos /* Can't fail a spared disk! */
1127 1.366 christos goto out;
1128 1.366 christos }
1129 1.366 christos rf_unlock_mutex2(raidPtr->mutex);
1130 1.366 christos
1131 1.366 christos /* make a copy of the recon request so that we don't rely on
1132 1.366 christos * the user's buffer */
1133 1.374 christos rrint = RF_Malloc(sizeof(*rrint));
1134 1.366 christos if (rrint == NULL)
1135 1.366 christos return(ENOMEM);
1136 1.366 christos rrint->col = rr->col;
1137 1.366 christos rrint->flags = rr->flags;
1138 1.366 christos rrint->raidPtr = raidPtr;
1139 1.366 christos
1140 1.366 christos return RF_CREATE_THREAD(raidPtr->recon_thread, rf_ReconThread,
1141 1.366 christos rrint, "raid_recon");
1142 1.366 christos out:
1143 1.366 christos rf_unlock_mutex2(raidPtr->mutex);
1144 1.366 christos return EINVAL;
1145 1.366 christos }
1146 1.366 christos
1147 1.324 mrg static int
1148 1.367 christos rf_copyinspecificbuf(RF_Config_t *k_cfg)
1149 1.367 christos {
1150 1.367 christos /* allocate a buffer for the layout-specific data, and copy it in */
1151 1.367 christos if (k_cfg->layoutSpecificSize == 0)
1152 1.367 christos return 0;
1153 1.367 christos
1154 1.367 christos if (k_cfg->layoutSpecificSize > 10000) {
1155 1.367 christos /* sanity check */
1156 1.367 christos return EINVAL;
1157 1.367 christos }
1158 1.367 christos
1159 1.367 christos u_char *specific_buf;
1160 1.374 christos specific_buf = RF_Malloc(k_cfg->layoutSpecificSize);
1161 1.367 christos if (specific_buf == NULL)
1162 1.367 christos return ENOMEM;
1163 1.367 christos
1164 1.367 christos int retcode = copyin(k_cfg->layoutSpecific, specific_buf,
1165 1.367 christos k_cfg->layoutSpecificSize);
1166 1.367 christos if (retcode) {
1167 1.367 christos RF_Free(specific_buf, k_cfg->layoutSpecificSize);
1168 1.367 christos db1_printf(("%s: retcode=%d copyin.2\n", __func__, retcode));
1169 1.367 christos return retcode;
1170 1.367 christos }
1171 1.367 christos
1172 1.367 christos k_cfg->layoutSpecific = specific_buf;
1173 1.367 christos return 0;
1174 1.367 christos }
1175 1.367 christos
1176 1.367 christos static int
1177 1.367 christos rf_getConfiguration(struct raid_softc *rs, void *data, RF_Config_t **k_cfg)
1178 1.367 christos {
1179 1.372 christos RF_Config_t *u_cfg = *((RF_Config_t **) data);
1180 1.372 christos
1181 1.367 christos if (rs->sc_r.valid) {
1182 1.367 christos /* There is a valid RAID set running on this unit! */
1183 1.367 christos printf("raid%d: Device already configured!\n", rs->sc_unit);
1184 1.367 christos return EINVAL;
1185 1.367 christos }
1186 1.367 christos
1187 1.367 christos /* copy-in the configuration information */
1188 1.367 christos /* data points to a pointer to the configuration structure */
1189 1.374 christos *k_cfg = RF_Malloc(sizeof(**k_cfg));
1190 1.367 christos if (*k_cfg == NULL) {
1191 1.367 christos return ENOMEM;
1192 1.367 christos }
1193 1.373 christos int retcode = copyin(u_cfg, *k_cfg, sizeof(RF_Config_t));
1194 1.367 christos if (retcode == 0)
1195 1.367 christos return 0;
1196 1.367 christos RF_Free(*k_cfg, sizeof(RF_Config_t));
1197 1.367 christos db1_printf(("%s: retcode=%d copyin.1\n", __func__, retcode));
1198 1.367 christos rs->sc_flags |= RAIDF_SHUTDOWN;
1199 1.367 christos return retcode;
1200 1.367 christos }
1201 1.367 christos
1202 1.367 christos int
1203 1.367 christos rf_construct(struct raid_softc *rs, RF_Config_t *k_cfg)
1204 1.367 christos {
1205 1.408 mrg int retcode, i;
1206 1.367 christos RF_Raid_t *raidPtr = &rs->sc_r;
1207 1.367 christos
1208 1.367 christos rs->sc_flags &= ~RAIDF_SHUTDOWN;
1209 1.367 christos
1210 1.367 christos if ((retcode = rf_copyinspecificbuf(k_cfg)) != 0)
1211 1.367 christos goto out;
1212 1.367 christos
1213 1.367 christos /* should do some kind of sanity check on the configuration.
1214 1.367 christos * Store the sum of all the bytes in the last byte? */
1215 1.367 christos
1216 1.408 mrg /* Force nul-termination on all strings. */
1217 1.408 mrg #define ZERO_FINAL(s) do { s[sizeof(s) - 1] = '\0'; } while (0)
1218 1.408 mrg for (i = 0; i < RF_MAXCOL; i++) {
1219 1.408 mrg ZERO_FINAL(k_cfg->devnames[0][i]);
1220 1.408 mrg }
1221 1.408 mrg for (i = 0; i < RF_MAXSPARE; i++) {
1222 1.408 mrg ZERO_FINAL(k_cfg->spare_names[i]);
1223 1.408 mrg }
1224 1.408 mrg for (i = 0; i < RF_MAXDBGV; i++) {
1225 1.408 mrg ZERO_FINAL(k_cfg->debugVars[i]);
1226 1.408 mrg }
1227 1.408 mrg #undef ZERO_FINAL
1228 1.408 mrg
1229 1.408 mrg /* Check some basic limits. */
1230 1.408 mrg if (k_cfg->numCol >= RF_MAXCOL || k_cfg->numCol < 0) {
1231 1.408 mrg retcode = EINVAL;
1232 1.408 mrg goto out;
1233 1.408 mrg }
1234 1.408 mrg if (k_cfg->numSpare >= RF_MAXSPARE || k_cfg->numSpare < 0) {
1235 1.408 mrg retcode = EINVAL;
1236 1.408 mrg goto out;
1237 1.408 mrg }
1238 1.408 mrg
1239 1.367 christos /* configure the system */
1240 1.367 christos
1241 1.367 christos /*
1242 1.367 christos * Clear the entire RAID descriptor, just to make sure
1243 1.367 christos * there is no stale data left in the case of a
1244 1.367 christos * reconfiguration
1245 1.367 christos */
1246 1.367 christos memset(raidPtr, 0, sizeof(*raidPtr));
1247 1.367 christos raidPtr->softc = rs;
1248 1.367 christos raidPtr->raidid = rs->sc_unit;
1249 1.367 christos
1250 1.367 christos retcode = rf_Configure(raidPtr, k_cfg, NULL);
1251 1.367 christos
1252 1.367 christos if (retcode == 0) {
1253 1.367 christos /* allow this many simultaneous IO's to
1254 1.367 christos this RAID device */
1255 1.367 christos raidPtr->openings = RAIDOUTSTANDING;
1256 1.367 christos
1257 1.367 christos raidinit(rs);
1258 1.367 christos raid_wakeup(raidPtr);
1259 1.367 christos rf_markalldirty(raidPtr);
1260 1.367 christos }
1261 1.367 christos
1262 1.367 christos /* free the buffers. No return code here. */
1263 1.367 christos if (k_cfg->layoutSpecificSize) {
1264 1.367 christos RF_Free(k_cfg->layoutSpecific, k_cfg->layoutSpecificSize);
1265 1.367 christos }
1266 1.367 christos out:
1267 1.367 christos RF_Free(k_cfg, sizeof(RF_Config_t));
1268 1.367 christos if (retcode) {
1269 1.367 christos /*
1270 1.367 christos * If configuration failed, set sc_flags so that we
1271 1.367 christos * will detach the device when we close it.
1272 1.367 christos */
1273 1.367 christos rs->sc_flags |= RAIDF_SHUTDOWN;
1274 1.367 christos }
1275 1.367 christos return retcode;
1276 1.367 christos }
1277 1.367 christos
1278 1.367 christos #if RF_DISABLED
1279 1.367 christos static int
1280 1.367 christos rf_set_component_label(RF_Raid_t *raidPtr, RF_ComponentLabel_t *clabel)
1281 1.367 christos {
1282 1.367 christos
1283 1.367 christos /* XXX check the label for valid stuff... */
1284 1.367 christos /* Note that some things *should not* get modified --
1285 1.367 christos the user should be re-initing the labels instead of
1286 1.367 christos trying to patch things.
1287 1.367 christos */
1288 1.367 christos #ifdef DEBUG
1289 1.367 christos int raidid = raidPtr->raidid;
1290 1.367 christos printf("raid%d: Got component label:\n", raidid);
1291 1.367 christos printf("raid%d: Version: %d\n", raidid, clabel->version);
1292 1.367 christos printf("raid%d: Serial Number: %d\n", raidid, clabel->serial_number);
1293 1.367 christos printf("raid%d: Mod counter: %d\n", raidid, clabel->mod_counter);
1294 1.367 christos printf("raid%d: Column: %d\n", raidid, clabel->column);
1295 1.367 christos printf("raid%d: Num Columns: %d\n", raidid, clabel->num_columns);
1296 1.367 christos printf("raid%d: Clean: %d\n", raidid, clabel->clean);
1297 1.367 christos printf("raid%d: Status: %d\n", raidid, clabel->status);
1298 1.367 christos #endif /* DEBUG */
1299 1.367 christos clabel->row = 0;
1300 1.367 christos int column = clabel->column;
1301 1.367 christos
1302 1.367 christos if ((column < 0) || (column >= raidPtr->numCol)) {
1303 1.367 christos return(EINVAL);
1304 1.367 christos }
1305 1.367 christos
1306 1.367 christos /* XXX this isn't allowed to do anything for now :-) */
1307 1.367 christos
1308 1.367 christos /* XXX and before it is, we need to fill in the rest
1309 1.367 christos of the fields!?!?!?! */
1310 1.367 christos memcpy(raidget_component_label(raidPtr, column),
1311 1.367 christos clabel, sizeof(*clabel));
1312 1.367 christos raidflush_component_label(raidPtr, column);
1313 1.367 christos return 0;
1314 1.367 christos }
1315 1.367 christos #endif
1316 1.367 christos
1317 1.367 christos static int
1318 1.367 christos rf_init_component_label(RF_Raid_t *raidPtr, RF_ComponentLabel_t *clabel)
1319 1.367 christos {
1320 1.367 christos /*
1321 1.367 christos we only want the serial number from
1322 1.367 christos the above. We get all the rest of the information
1323 1.367 christos from the config that was used to create this RAID
1324 1.367 christos set.
1325 1.367 christos */
1326 1.367 christos
1327 1.367 christos raidPtr->serial_number = clabel->serial_number;
1328 1.367 christos
1329 1.367 christos for (int column = 0; column < raidPtr->numCol; column++) {
1330 1.367 christos RF_RaidDisk_t *diskPtr = &raidPtr->Disks[column];
1331 1.367 christos if (RF_DEAD_DISK(diskPtr->status))
1332 1.367 christos continue;
1333 1.367 christos RF_ComponentLabel_t *ci_label = raidget_component_label(
1334 1.367 christos raidPtr, column);
1335 1.367 christos /* Zeroing this is important. */
1336 1.367 christos memset(ci_label, 0, sizeof(*ci_label));
1337 1.367 christos raid_init_component_label(raidPtr, ci_label);
1338 1.367 christos ci_label->serial_number = raidPtr->serial_number;
1339 1.367 christos ci_label->row = 0; /* we dont' pretend to support more */
1340 1.367 christos rf_component_label_set_partitionsize(ci_label,
1341 1.367 christos diskPtr->partitionSize);
1342 1.367 christos ci_label->column = column;
1343 1.367 christos raidflush_component_label(raidPtr, column);
1344 1.367 christos /* XXXjld what about the spares? */
1345 1.367 christos }
1346 1.385 riastrad
1347 1.367 christos return 0;
1348 1.367 christos }
1349 1.367 christos
1350 1.367 christos static int
1351 1.367 christos rf_rebuild_in_place(RF_Raid_t *raidPtr, RF_SingleComponent_t *componentPtr)
1352 1.367 christos {
1353 1.367 christos
1354 1.367 christos if (raidPtr->Layout.map->faultsTolerated == 0) {
1355 1.367 christos /* Can't do this on a RAID 0!! */
1356 1.367 christos return EINVAL;
1357 1.367 christos }
1358 1.367 christos
1359 1.367 christos if (raidPtr->recon_in_progress == 1) {
1360 1.367 christos /* a reconstruct is already in progress! */
1361 1.367 christos return EINVAL;
1362 1.367 christos }
1363 1.367 christos
1364 1.367 christos RF_SingleComponent_t component;
1365 1.367 christos memcpy(&component, componentPtr, sizeof(RF_SingleComponent_t));
1366 1.367 christos component.row = 0; /* we don't support any more */
1367 1.367 christos int column = component.column;
1368 1.367 christos
1369 1.367 christos if ((column < 0) || (column >= raidPtr->numCol)) {
1370 1.367 christos return EINVAL;
1371 1.367 christos }
1372 1.367 christos
1373 1.367 christos rf_lock_mutex2(raidPtr->mutex);
1374 1.367 christos if ((raidPtr->Disks[column].status == rf_ds_optimal) &&
1375 1.367 christos (raidPtr->numFailures > 0)) {
1376 1.367 christos /* XXX 0 above shouldn't be constant!!! */
1377 1.367 christos /* some component other than this has failed.
1378 1.367 christos Let's not make things worse than they already
1379 1.367 christos are... */
1380 1.367 christos printf("raid%d: Unable to reconstruct to disk at:\n",
1381 1.367 christos raidPtr->raidid);
1382 1.367 christos printf("raid%d: Col: %d Too many failures.\n",
1383 1.367 christos raidPtr->raidid, column);
1384 1.367 christos rf_unlock_mutex2(raidPtr->mutex);
1385 1.367 christos return EINVAL;
1386 1.367 christos }
1387 1.367 christos
1388 1.367 christos if (raidPtr->Disks[column].status == rf_ds_reconstructing) {
1389 1.367 christos printf("raid%d: Unable to reconstruct to disk at:\n",
1390 1.367 christos raidPtr->raidid);
1391 1.367 christos printf("raid%d: Col: %d "
1392 1.367 christos "Reconstruction already occurring!\n",
1393 1.367 christos raidPtr->raidid, column);
1394 1.367 christos
1395 1.367 christos rf_unlock_mutex2(raidPtr->mutex);
1396 1.367 christos return EINVAL;
1397 1.367 christos }
1398 1.367 christos
1399 1.367 christos if (raidPtr->Disks[column].status == rf_ds_spared) {
1400 1.367 christos rf_unlock_mutex2(raidPtr->mutex);
1401 1.367 christos return EINVAL;
1402 1.367 christos }
1403 1.367 christos
1404 1.367 christos rf_unlock_mutex2(raidPtr->mutex);
1405 1.367 christos
1406 1.367 christos struct rf_recon_req_internal *rrint;
1407 1.374 christos rrint = RF_Malloc(sizeof(*rrint));
1408 1.367 christos if (rrint == NULL)
1409 1.367 christos return ENOMEM;
1410 1.367 christos
1411 1.367 christos rrint->col = column;
1412 1.367 christos rrint->raidPtr = raidPtr;
1413 1.367 christos
1414 1.367 christos return RF_CREATE_THREAD(raidPtr->recon_thread,
1415 1.367 christos rf_ReconstructInPlaceThread, rrint, "raid_reconip");
1416 1.367 christos }
1417 1.367 christos
1418 1.367 christos static int
1419 1.367 christos rf_check_recon_status(RF_Raid_t *raidPtr, int *data)
1420 1.367 christos {
1421 1.367 christos /*
1422 1.367 christos * This makes no sense on a RAID 0, or if we are not reconstructing
1423 1.367 christos * so tell the user it's done.
1424 1.367 christos */
1425 1.367 christos if (raidPtr->Layout.map->faultsTolerated == 0 ||
1426 1.367 christos raidPtr->status != rf_rs_reconstructing) {
1427 1.367 christos *data = 100;
1428 1.367 christos return 0;
1429 1.367 christos }
1430 1.367 christos if (raidPtr->reconControl->numRUsTotal == 0) {
1431 1.367 christos *data = 0;
1432 1.367 christos return 0;
1433 1.367 christos }
1434 1.367 christos *data = (raidPtr->reconControl->numRUsComplete * 100
1435 1.367 christos / raidPtr->reconControl->numRUsTotal);
1436 1.367 christos return 0;
1437 1.367 christos }
1438 1.367 christos
1439 1.408 mrg /*
1440 1.408 mrg * Copy a RF_SingleComponent_t from 'data', ensuring nul-termination
1441 1.408 mrg * on the component_name[] array.
1442 1.408 mrg */
1443 1.408 mrg static void
1444 1.408 mrg rf_copy_single_component(RF_SingleComponent_t *component, void *data)
1445 1.408 mrg {
1446 1.408 mrg
1447 1.408 mrg memcpy(component, data, sizeof *component);
1448 1.408 mrg component->component_name[sizeof(component->component_name) - 1] = '\0';
1449 1.408 mrg }
1450 1.408 mrg
1451 1.367 christos static int
1452 1.225 christos raidioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
1453 1.1 oster {
1454 1.9 oster int unit = raidunit(dev);
1455 1.335 mlelstv int part, pmask;
1456 1.1 oster struct raid_softc *rs;
1457 1.335 mlelstv struct dk_softc *dksc;
1458 1.367 christos RF_Config_t *k_cfg;
1459 1.42 oster RF_Raid_t *raidPtr;
1460 1.41 oster RF_AccTotals_t *totals;
1461 1.367 christos RF_SingleComponent_t component;
1462 1.371 oster RF_DeviceConfig_t *d_cfg, *ucfgp;
1463 1.11 oster int retcode = 0;
1464 1.11 oster int column;
1465 1.48 oster RF_ComponentLabel_t *clabel;
1466 1.353 mrg int d;
1467 1.1 oster
1468 1.327 pgoyette if ((rs = raidget(unit, false)) == NULL)
1469 1.300 christos return ENXIO;
1470 1.366 christos
1471 1.335 mlelstv dksc = &rs->sc_dksc;
1472 1.300 christos raidPtr = &rs->sc_r;
1473 1.1 oster
1474 1.276 mrg db1_printf(("raidioctl: %d %d %d %lu\n", (int) dev,
1475 1.366 christos (int) DISKPART(dev), (int) unit, cmd));
1476 1.1 oster
1477 1.410 oster /* Only CONFIGURE and RESCAN can be done without the RAID being initialized. */
1478 1.410 oster switch (cmd) {
1479 1.410 oster case RAIDFRAME_CONFIGURE:
1480 1.410 oster case RAIDFRAME_RESCAN:
1481 1.410 oster break;
1482 1.410 oster default:
1483 1.410 oster if (!rf_inited(rs))
1484 1.410 oster return ENXIO;
1485 1.410 oster }
1486 1.9 oster
1487 1.358 pgoyette switch (cmd) {
1488 1.1 oster /* configure the system */
1489 1.1 oster case RAIDFRAME_CONFIGURE:
1490 1.367 christos if ((retcode = rf_getConfiguration(rs, data, &k_cfg)) != 0)
1491 1.367 christos return retcode;
1492 1.367 christos return rf_construct(rs, k_cfg);
1493 1.9 oster
1494 1.9 oster /* shutdown the system */
1495 1.1 oster case RAIDFRAME_SHUTDOWN:
1496 1.9 oster
1497 1.266 dyoung part = DISKPART(dev);
1498 1.266 dyoung pmask = (1 << part);
1499 1.266 dyoung
1500 1.367 christos if ((retcode = raidlock(rs)) != 0)
1501 1.367 christos return retcode;
1502 1.1 oster
1503 1.337 mlelstv if (DK_BUSY(dksc, pmask) ||
1504 1.337 mlelstv raidPtr->recon_in_progress != 0 ||
1505 1.337 mlelstv raidPtr->parity_rewrite_in_progress != 0 ||
1506 1.337 mlelstv raidPtr->copyback_in_progress != 0)
1507 1.266 dyoung retcode = EBUSY;
1508 1.266 dyoung else {
1509 1.335 mlelstv /* detach and free on close */
1510 1.266 dyoung rs->sc_flags |= RAIDF_SHUTDOWN;
1511 1.266 dyoung retcode = 0;
1512 1.9 oster }
1513 1.11 oster
1514 1.266 dyoung raidunlock(rs);
1515 1.1 oster
1516 1.367 christos return retcode;
1517 1.11 oster case RAIDFRAME_GET_COMPONENT_LABEL:
1518 1.353 mrg return rf_get_component_label(raidPtr, data);
1519 1.11 oster
1520 1.367 christos #if RF_DISABLED
1521 1.11 oster case RAIDFRAME_SET_COMPONENT_LABEL:
1522 1.367 christos return rf_set_component_label(raidPtr, data);
1523 1.367 christos #endif
1524 1.11 oster
1525 1.367 christos case RAIDFRAME_INIT_LABELS:
1526 1.367 christos return rf_init_component_label(raidPtr, data);
1527 1.12 oster
1528 1.48 oster case RAIDFRAME_SET_AUTOCONFIG:
1529 1.78 minoura d = rf_set_autoconfig(raidPtr, *(int *) data);
1530 1.186 perry printf("raid%d: New autoconfig value is: %d\n",
1531 1.123 oster raidPtr->raidid, d);
1532 1.78 minoura *(int *) data = d;
1533 1.367 christos return retcode;
1534 1.48 oster
1535 1.48 oster case RAIDFRAME_SET_ROOT:
1536 1.78 minoura d = rf_set_rootpartition(raidPtr, *(int *) data);
1537 1.186 perry printf("raid%d: New rootpartition value is: %d\n",
1538 1.123 oster raidPtr->raidid, d);
1539 1.78 minoura *(int *) data = d;
1540 1.367 christos return retcode;
1541 1.9 oster
1542 1.1 oster /* initialize all parity */
1543 1.1 oster case RAIDFRAME_REWRITEPARITY:
1544 1.1 oster
1545 1.42 oster if (raidPtr->Layout.map->faultsTolerated == 0) {
1546 1.17 oster /* Parity for RAID 0 is trivially correct */
1547 1.42 oster raidPtr->parity_good = RF_RAID_CLEAN;
1548 1.367 christos return 0;
1549 1.17 oster }
1550 1.186 perry
1551 1.42 oster if (raidPtr->parity_rewrite_in_progress == 1) {
1552 1.37 oster /* Re-write is already in progress! */
1553 1.367 christos return EINVAL;
1554 1.37 oster }
1555 1.27 oster
1556 1.367 christos return RF_CREATE_THREAD(raidPtr->parity_rewrite_thread,
1557 1.367 christos rf_RewriteParityThread, raidPtr,"raid_parity");
1558 1.11 oster
1559 1.11 oster case RAIDFRAME_ADD_HOT_SPARE:
1560 1.408 mrg rf_copy_single_component(&component, data);
1561 1.367 christos return rf_add_hot_spare(raidPtr, &component);
1562 1.11 oster
1563 1.11 oster case RAIDFRAME_REMOVE_HOT_SPARE:
1564 1.367 christos return retcode;
1565 1.73 oster
1566 1.73 oster case RAIDFRAME_DELETE_COMPONENT:
1567 1.408 mrg rf_copy_single_component(&component, data);
1568 1.367 christos return rf_delete_component(raidPtr, &component);
1569 1.73 oster
1570 1.73 oster case RAIDFRAME_INCORPORATE_HOT_SPARE:
1571 1.408 mrg rf_copy_single_component(&component, data);
1572 1.367 christos return rf_incorporate_hot_spare(raidPtr, &component);
1573 1.11 oster
1574 1.12 oster case RAIDFRAME_REBUILD_IN_PLACE:
1575 1.367 christos return rf_rebuild_in_place(raidPtr, data);
1576 1.398 oster
1577 1.366 christos case RAIDFRAME_GET_INFO:
1578 1.371 oster ucfgp = *(RF_DeviceConfig_t **)data;
1579 1.374 christos d_cfg = RF_Malloc(sizeof(*d_cfg));
1580 1.41 oster if (d_cfg == NULL)
1581 1.366 christos return ENOMEM;
1582 1.353 mrg retcode = rf_get_info(raidPtr, d_cfg);
1583 1.353 mrg if (retcode == 0) {
1584 1.371 oster retcode = copyout(d_cfg, ucfgp, sizeof(*d_cfg));
1585 1.41 oster }
1586 1.41 oster RF_Free(d_cfg, sizeof(RF_DeviceConfig_t));
1587 1.366 christos return retcode;
1588 1.9 oster
1589 1.22 oster case RAIDFRAME_CHECK_PARITY:
1590 1.42 oster *(int *) data = raidPtr->parity_good;
1591 1.367 christos return 0;
1592 1.41 oster
1593 1.269 jld case RAIDFRAME_PARITYMAP_STATUS:
1594 1.273 jld if (rf_paritymap_ineligible(raidPtr))
1595 1.273 jld return EINVAL;
1596 1.367 christos rf_paritymap_status(raidPtr->parity_map, data);
1597 1.269 jld return 0;
1598 1.269 jld
1599 1.269 jld case RAIDFRAME_PARITYMAP_SET_PARAMS:
1600 1.273 jld if (rf_paritymap_ineligible(raidPtr))
1601 1.273 jld return EINVAL;
1602 1.269 jld if (raidPtr->parity_map == NULL)
1603 1.269 jld return ENOENT; /* ??? */
1604 1.367 christos if (rf_paritymap_set_params(raidPtr->parity_map, data, 1) != 0)
1605 1.269 jld return EINVAL;
1606 1.269 jld return 0;
1607 1.269 jld
1608 1.269 jld case RAIDFRAME_PARITYMAP_GET_DISABLE:
1609 1.273 jld if (rf_paritymap_ineligible(raidPtr))
1610 1.273 jld return EINVAL;
1611 1.269 jld *(int *) data = rf_paritymap_get_disable(raidPtr);
1612 1.269 jld return 0;
1613 1.269 jld
1614 1.269 jld case RAIDFRAME_PARITYMAP_SET_DISABLE:
1615 1.273 jld if (rf_paritymap_ineligible(raidPtr))
1616 1.273 jld return EINVAL;
1617 1.269 jld rf_paritymap_set_disable(raidPtr, *(int *)data);
1618 1.269 jld /* XXX should errors be passed up? */
1619 1.269 jld return 0;
1620 1.269 jld
1621 1.398 oster case RAIDFRAME_RESCAN:
1622 1.398 oster return rf_rescan();
1623 1.398 oster
1624 1.1 oster case RAIDFRAME_RESET_ACCTOTALS:
1625 1.108 thorpej memset(&raidPtr->acc_totals, 0, sizeof(raidPtr->acc_totals));
1626 1.367 christos return 0;
1627 1.9 oster
1628 1.1 oster case RAIDFRAME_GET_ACCTOTALS:
1629 1.41 oster totals = (RF_AccTotals_t *) data;
1630 1.42 oster *totals = raidPtr->acc_totals;
1631 1.366 christos return 0;
1632 1.9 oster
1633 1.1 oster case RAIDFRAME_KEEP_ACCTOTALS:
1634 1.42 oster raidPtr->keep_acc_totals = *(int *)data;
1635 1.366 christos return 0;
1636 1.9 oster
1637 1.1 oster case RAIDFRAME_GET_SIZE:
1638 1.42 oster *(int *) data = raidPtr->totalSectors;
1639 1.366 christos return 0;
1640 1.1 oster
1641 1.1 oster case RAIDFRAME_FAIL_DISK:
1642 1.366 christos return rf_fail_disk(raidPtr, data);
1643 1.9 oster
1644 1.9 oster /* invoke a copyback operation after recon on whatever disk
1645 1.9 oster * needs it, if any */
1646 1.9 oster case RAIDFRAME_COPYBACK:
1647 1.24 oster
1648 1.42 oster if (raidPtr->Layout.map->faultsTolerated == 0) {
1649 1.24 oster /* This makes no sense on a RAID 0!! */
1650 1.367 christos return EINVAL;
1651 1.24 oster }
1652 1.24 oster
1653 1.42 oster if (raidPtr->copyback_in_progress == 1) {
1654 1.37 oster /* Copyback is already in progress! */
1655 1.367 christos return EINVAL;
1656 1.37 oster }
1657 1.27 oster
1658 1.367 christos return RF_CREATE_THREAD(raidPtr->copyback_thread,
1659 1.367 christos rf_CopybackThread, raidPtr, "raid_copyback");
1660 1.9 oster
1661 1.1 oster /* return the percentage completion of reconstruction */
1662 1.37 oster case RAIDFRAME_CHECK_RECON_STATUS:
1663 1.367 christos return rf_check_recon_status(raidPtr, data);
1664 1.367 christos
1665 1.83 oster case RAIDFRAME_CHECK_RECON_STATUS_EXT:
1666 1.353 mrg rf_check_recon_status_ext(raidPtr, data);
1667 1.367 christos return 0;
1668 1.9 oster
1669 1.37 oster case RAIDFRAME_CHECK_PARITYREWRITE_STATUS:
1670 1.42 oster if (raidPtr->Layout.map->faultsTolerated == 0) {
1671 1.80 oster /* This makes no sense on a RAID 0, so tell the
1672 1.80 oster user it's done. */
1673 1.80 oster *(int *) data = 100;
1674 1.367 christos return 0;
1675 1.37 oster }
1676 1.42 oster if (raidPtr->parity_rewrite_in_progress == 1) {
1677 1.186 perry *(int *) data = 100 *
1678 1.186 perry raidPtr->parity_rewrite_stripes_done /
1679 1.83 oster raidPtr->Layout.numStripe;
1680 1.37 oster } else {
1681 1.37 oster *(int *) data = 100;
1682 1.37 oster }
1683 1.367 christos return 0;
1684 1.37 oster
1685 1.83 oster case RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT:
1686 1.353 mrg rf_check_parityrewrite_status_ext(raidPtr, data);
1687 1.367 christos return 0;
1688 1.83 oster
1689 1.37 oster case RAIDFRAME_CHECK_COPYBACK_STATUS:
1690 1.42 oster if (raidPtr->Layout.map->faultsTolerated == 0) {
1691 1.37 oster /* This makes no sense on a RAID 0 */
1692 1.83 oster *(int *) data = 100;
1693 1.367 christos return 0;
1694 1.37 oster }
1695 1.42 oster if (raidPtr->copyback_in_progress == 1) {
1696 1.42 oster *(int *) data = 100 * raidPtr->copyback_stripes_done /
1697 1.42 oster raidPtr->Layout.numStripe;
1698 1.37 oster } else {
1699 1.37 oster *(int *) data = 100;
1700 1.37 oster }
1701 1.367 christos return 0;
1702 1.37 oster
1703 1.83 oster case RAIDFRAME_CHECK_COPYBACK_STATUS_EXT:
1704 1.353 mrg rf_check_copyback_status_ext(raidPtr, data);
1705 1.353 mrg return 0;
1706 1.37 oster
1707 1.341 christos case RAIDFRAME_SET_LAST_UNIT:
1708 1.341 christos for (column = 0; column < raidPtr->numCol; column++)
1709 1.341 christos if (raidPtr->Disks[column].status != rf_ds_optimal)
1710 1.341 christos return EBUSY;
1711 1.341 christos
1712 1.341 christos for (column = 0; column < raidPtr->numCol; column++) {
1713 1.341 christos clabel = raidget_component_label(raidPtr, column);
1714 1.341 christos clabel->last_unit = *(int *)data;
1715 1.341 christos raidflush_component_label(raidPtr, column);
1716 1.341 christos }
1717 1.341 christos rs->sc_cflags |= RAIDF_UNIT_CHANGED;
1718 1.341 christos return 0;
1719 1.341 christos
1720 1.9 oster /* the sparetable daemon calls this to wait for the kernel to
1721 1.9 oster * need a spare table. this ioctl does not return until a
1722 1.9 oster * spare table is needed. XXX -- calling mpsleep here in the
1723 1.9 oster * ioctl code is almost certainly wrong and evil. -- XXX XXX
1724 1.9 oster * -- I should either compute the spare table in the kernel,
1725 1.9 oster * or have a different -- XXX XXX -- interface (a different
1726 1.42 oster * character device) for delivering the table -- XXX */
1727 1.367 christos #if RF_DISABLED
1728 1.1 oster case RAIDFRAME_SPARET_WAIT:
1729 1.287 mrg rf_lock_mutex2(rf_sparet_wait_mutex);
1730 1.9 oster while (!rf_sparet_wait_queue)
1731 1.287 mrg rf_wait_cond2(rf_sparet_wait_cv, rf_sparet_wait_mutex);
1732 1.367 christos RF_SparetWait_t *waitreq = rf_sparet_wait_queue;
1733 1.1 oster rf_sparet_wait_queue = rf_sparet_wait_queue->next;
1734 1.287 mrg rf_unlock_mutex2(rf_sparet_wait_mutex);
1735 1.9 oster
1736 1.42 oster /* structure assignment */
1737 1.186 perry *((RF_SparetWait_t *) data) = *waitreq;
1738 1.9 oster
1739 1.1 oster RF_Free(waitreq, sizeof(*waitreq));
1740 1.367 christos return 0;
1741 1.9 oster
1742 1.9 oster /* wakes up a process waiting on SPARET_WAIT and puts an error
1743 1.9 oster * code in it that will cause the dameon to exit */
1744 1.1 oster case RAIDFRAME_ABORT_SPARET_WAIT:
1745 1.374 christos waitreq = RF_Malloc(sizeof(*waitreq));
1746 1.1 oster waitreq->fcol = -1;
1747 1.287 mrg rf_lock_mutex2(rf_sparet_wait_mutex);
1748 1.1 oster waitreq->next = rf_sparet_wait_queue;
1749 1.1 oster rf_sparet_wait_queue = waitreq;
1750 1.367 christos rf_broadcast_cond2(rf_sparet_wait_cv);
1751 1.287 mrg rf_unlock_mutex2(rf_sparet_wait_mutex);
1752 1.367 christos return 0;
1753 1.1 oster
1754 1.9 oster /* used by the spare table daemon to deliver a spare table
1755 1.9 oster * into the kernel */
1756 1.1 oster case RAIDFRAME_SEND_SPARET:
1757 1.9 oster
1758 1.1 oster /* install the spare table */
1759 1.42 oster retcode = rf_SetSpareTable(raidPtr, *(void **) data);
1760 1.9 oster
1761 1.9 oster /* respond to the requestor. the return status of the spare
1762 1.9 oster * table installation is passed in the "fcol" field */
1763 1.374 christos waitred = RF_Malloc(sizeof(*waitreq));
1764 1.1 oster waitreq->fcol = retcode;
1765 1.287 mrg rf_lock_mutex2(rf_sparet_wait_mutex);
1766 1.1 oster waitreq->next = rf_sparet_resp_queue;
1767 1.1 oster rf_sparet_resp_queue = waitreq;
1768 1.287 mrg rf_broadcast_cond2(rf_sparet_resp_cv);
1769 1.287 mrg rf_unlock_mutex2(rf_sparet_wait_mutex);
1770 1.9 oster
1771 1.367 christos return retcode;
1772 1.367 christos #endif
1773 1.367 christos default:
1774 1.372 christos /*
1775 1.372 christos * Don't bother trying to load compat modules
1776 1.372 christos * if it is not our ioctl. This is more efficient
1777 1.372 christos * and makes rump tests not depend on compat code
1778 1.372 christos */
1779 1.372 christos if (IOCGROUP(cmd) != 'r')
1780 1.372 christos break;
1781 1.367 christos #ifdef _LP64
1782 1.367 christos if ((l->l_proc->p_flag & PK_32) != 0) {
1783 1.367 christos module_autoload("compat_netbsd32_raid",
1784 1.367 christos MODULE_CLASS_EXEC);
1785 1.376 pgoyette MODULE_HOOK_CALL(raidframe_netbsd32_ioctl_hook,
1786 1.367 christos (rs, cmd, data), enosys(), retcode);
1787 1.367 christos if (retcode != EPASSTHROUGH)
1788 1.367 christos return retcode;
1789 1.367 christos }
1790 1.1 oster #endif
1791 1.367 christos module_autoload("compat_raid_80", MODULE_CLASS_EXEC);
1792 1.376 pgoyette MODULE_HOOK_CALL(raidframe_ioctl_80_hook,
1793 1.367 christos (rs, cmd, data), enosys(), retcode);
1794 1.367 christos if (retcode != EPASSTHROUGH)
1795 1.367 christos return retcode;
1796 1.1 oster
1797 1.367 christos module_autoload("compat_raid_50", MODULE_CLASS_EXEC);
1798 1.376 pgoyette MODULE_HOOK_CALL(raidframe_ioctl_50_hook,
1799 1.367 christos (rs, cmd, data), enosys(), retcode);
1800 1.367 christos if (retcode != EPASSTHROUGH)
1801 1.367 christos return retcode;
1802 1.36 oster break; /* fall through to the os-specific code below */
1803 1.1 oster
1804 1.1 oster }
1805 1.9 oster
1806 1.42 oster if (!raidPtr->valid)
1807 1.389 skrll return EINVAL;
1808 1.9 oster
1809 1.1 oster /*
1810 1.1 oster * Add support for "regular" device ioctls here.
1811 1.1 oster */
1812 1.385 riastrad
1813 1.1 oster switch (cmd) {
1814 1.348 jdolecek case DIOCGCACHE:
1815 1.348 jdolecek retcode = rf_get_component_caches(raidPtr, (int *)data);
1816 1.348 jdolecek break;
1817 1.348 jdolecek
1818 1.252 oster case DIOCCACHESYNC:
1819 1.390 christos retcode = rf_sync_component_caches(raidPtr, *(int *)data);
1820 1.347 jdolecek break;
1821 1.298 buhrow
1822 1.1 oster default:
1823 1.346 jdolecek retcode = dk_ioctl(dksc, dev, cmd, data, flag, l);
1824 1.347 jdolecek break;
1825 1.1 oster }
1826 1.346 jdolecek
1827 1.389 skrll return retcode;
1828 1.1 oster
1829 1.1 oster }
1830 1.1 oster
1831 1.1 oster
1832 1.9 oster /* raidinit -- complete the rest of the initialization for the
1833 1.1 oster RAIDframe device. */
1834 1.1 oster
1835 1.1 oster
1836 1.59 oster static void
1837 1.300 christos raidinit(struct raid_softc *rs)
1838 1.1 oster {
1839 1.262 cegger cfdata_t cf;
1840 1.335 mlelstv unsigned int unit;
1841 1.335 mlelstv struct dk_softc *dksc = &rs->sc_dksc;
1842 1.300 christos RF_Raid_t *raidPtr = &rs->sc_r;
1843 1.335 mlelstv device_t dev;
1844 1.1 oster
1845 1.59 oster unit = raidPtr->raidid;
1846 1.1 oster
1847 1.179 itojun /* XXX doesn't check bounds. */
1848 1.335 mlelstv snprintf(rs->sc_xname, sizeof(rs->sc_xname), "raid%u", unit);
1849 1.1 oster
1850 1.217 oster /* attach the pseudo device */
1851 1.217 oster cf = malloc(sizeof(*cf), M_RAIDFRAME, M_WAITOK);
1852 1.217 oster cf->cf_name = raid_cd.cd_name;
1853 1.217 oster cf->cf_atname = raid_cd.cd_name;
1854 1.217 oster cf->cf_unit = unit;
1855 1.217 oster cf->cf_fstate = FSTATE_STAR;
1856 1.217 oster
1857 1.335 mlelstv dev = config_attach_pseudo(cf);
1858 1.335 mlelstv if (dev == NULL) {
1859 1.217 oster printf("raid%d: config_attach_pseudo failed\n",
1860 1.270 christos raidPtr->raidid);
1861 1.265 pooka free(cf, M_RAIDFRAME);
1862 1.265 pooka return;
1863 1.217 oster }
1864 1.217 oster
1865 1.335 mlelstv /* provide a backpointer to the real softc */
1866 1.335 mlelstv raidsoftc(dev) = rs;
1867 1.335 mlelstv
1868 1.1 oster /* disk_attach actually creates space for the CPU disklabel, among
1869 1.9 oster * other things, so it's critical to call this *BEFORE* we try putzing
1870 1.9 oster * with disklabels. */
1871 1.335 mlelstv dk_init(dksc, dev, DKTYPE_RAID);
1872 1.335 mlelstv disk_init(&dksc->sc_dkdev, rs->sc_xname, &rf_dkdriver);
1873 1.1 oster
1874 1.1 oster /* XXX There may be a weird interaction here between this, and
1875 1.9 oster * protectedSectors, as used in RAIDframe. */
1876 1.11 oster
1877 1.9 oster rs->sc_size = raidPtr->totalSectors;
1878 1.234 oster
1879 1.335 mlelstv /* Attach dk and disk subsystems */
1880 1.335 mlelstv dk_attach(dksc);
1881 1.335 mlelstv disk_attach(&dksc->sc_dkdev);
1882 1.318 mlelstv rf_set_geometry(rs, raidPtr);
1883 1.318 mlelstv
1884 1.335 mlelstv bufq_alloc(&dksc->sc_bufq, "fcfs", BUFQ_SORT_RAWBLOCK);
1885 1.335 mlelstv
1886 1.335 mlelstv /* mark unit as usuable */
1887 1.335 mlelstv rs->sc_flags |= RAIDF_INITED;
1888 1.234 oster
1889 1.335 mlelstv dkwedge_discover(&dksc->sc_dkdev);
1890 1.1 oster }
1891 1.335 mlelstv
1892 1.150 oster #if (RF_INCLUDE_PARITY_DECLUSTERING_DS > 0)
1893 1.1 oster /* wake up the daemon & tell it to get us a spare table
1894 1.1 oster * XXX
1895 1.9 oster * the entries in the queues should be tagged with the raidPtr
1896 1.186 perry * so that in the extremely rare case that two recons happen at once,
1897 1.11 oster * we know for which device were requesting a spare table
1898 1.1 oster * XXX
1899 1.186 perry *
1900 1.39 oster * XXX This code is not currently used. GO
1901 1.1 oster */
1902 1.186 perry int
1903 1.169 oster rf_GetSpareTableFromDaemon(RF_SparetWait_t *req)
1904 1.9 oster {
1905 1.9 oster int retcode;
1906 1.9 oster
1907 1.287 mrg rf_lock_mutex2(rf_sparet_wait_mutex);
1908 1.9 oster req->next = rf_sparet_wait_queue;
1909 1.9 oster rf_sparet_wait_queue = req;
1910 1.289 mrg rf_broadcast_cond2(rf_sparet_wait_cv);
1911 1.9 oster
1912 1.9 oster /* mpsleep unlocks the mutex */
1913 1.9 oster while (!rf_sparet_resp_queue) {
1914 1.289 mrg rf_wait_cond2(rf_sparet_resp_cv, rf_sparet_wait_mutex);
1915 1.9 oster }
1916 1.9 oster req = rf_sparet_resp_queue;
1917 1.9 oster rf_sparet_resp_queue = req->next;
1918 1.287 mrg rf_unlock_mutex2(rf_sparet_wait_mutex);
1919 1.9 oster
1920 1.9 oster retcode = req->fcol;
1921 1.9 oster RF_Free(req, sizeof(*req)); /* this is not the same req as we
1922 1.9 oster * alloc'd */
1923 1.389 skrll return retcode;
1924 1.1 oster }
1925 1.150 oster #endif
1926 1.39 oster
1927 1.186 perry /* a wrapper around rf_DoAccess that extracts appropriate info from the
1928 1.11 oster * bp & passes it down.
1929 1.1 oster * any calls originating in the kernel must use non-blocking I/O
1930 1.1 oster * do some extra sanity checking to return "appropriate" error values for
1931 1.1 oster * certain conditions (to make some standard utilities work)
1932 1.186 perry *
1933 1.34 oster * Formerly known as: rf_DoAccessKernel
1934 1.1 oster */
1935 1.34 oster void
1936 1.169 oster raidstart(RF_Raid_t *raidPtr)
1937 1.1 oster {
1938 1.1 oster struct raid_softc *rs;
1939 1.335 mlelstv struct dk_softc *dksc;
1940 1.1 oster
1941 1.300 christos rs = raidPtr->softc;
1942 1.335 mlelstv dksc = &rs->sc_dksc;
1943 1.56 oster /* quick check to see if anything has died recently */
1944 1.291 mrg rf_lock_mutex2(raidPtr->mutex);
1945 1.56 oster if (raidPtr->numNewFailures > 0) {
1946 1.291 mrg rf_unlock_mutex2(raidPtr->mutex);
1947 1.186 perry rf_update_component_labels(raidPtr,
1948 1.91 oster RF_NORMAL_COMPONENT_UPDATE);
1949 1.291 mrg rf_lock_mutex2(raidPtr->mutex);
1950 1.56 oster raidPtr->numNewFailures--;
1951 1.56 oster }
1952 1.335 mlelstv rf_unlock_mutex2(raidPtr->mutex);
1953 1.56 oster
1954 1.335 mlelstv if ((rs->sc_flags & RAIDF_INITED) == 0) {
1955 1.335 mlelstv printf("raid%d: raidstart not ready\n", raidPtr->raidid);
1956 1.335 mlelstv return;
1957 1.335 mlelstv }
1958 1.34 oster
1959 1.335 mlelstv dk_start(dksc, NULL);
1960 1.335 mlelstv }
1961 1.34 oster
1962 1.335 mlelstv static int
1963 1.335 mlelstv raiddoaccess(RF_Raid_t *raidPtr, struct buf *bp)
1964 1.335 mlelstv {
1965 1.335 mlelstv RF_SectorCount_t num_blocks, pb, sum;
1966 1.335 mlelstv RF_RaidAddr_t raid_addr;
1967 1.335 mlelstv daddr_t blocknum;
1968 1.335 mlelstv int rc;
1969 1.186 perry
1970 1.335 mlelstv rf_lock_mutex2(raidPtr->mutex);
1971 1.335 mlelstv if (raidPtr->openings == 0) {
1972 1.335 mlelstv rf_unlock_mutex2(raidPtr->mutex);
1973 1.335 mlelstv return EAGAIN;
1974 1.335 mlelstv }
1975 1.335 mlelstv rf_unlock_mutex2(raidPtr->mutex);
1976 1.186 perry
1977 1.335 mlelstv blocknum = bp->b_rawblkno;
1978 1.186 perry
1979 1.335 mlelstv db1_printf(("Blocks: %d, %d\n", (int) bp->b_blkno,
1980 1.335 mlelstv (int) blocknum));
1981 1.1 oster
1982 1.335 mlelstv db1_printf(("bp->b_bcount = %d\n", (int) bp->b_bcount));
1983 1.335 mlelstv db1_printf(("bp->b_resid = %d\n", (int) bp->b_resid));
1984 1.1 oster
1985 1.335 mlelstv /* *THIS* is where we adjust what block we're going to...
1986 1.335 mlelstv * but DO NOT TOUCH bp->b_blkno!!! */
1987 1.335 mlelstv raid_addr = blocknum;
1988 1.335 mlelstv
1989 1.335 mlelstv num_blocks = bp->b_bcount >> raidPtr->logBytesPerSector;
1990 1.335 mlelstv pb = (bp->b_bcount & raidPtr->sectorMask) ? 1 : 0;
1991 1.335 mlelstv sum = raid_addr + num_blocks + pb;
1992 1.335 mlelstv if (1 || rf_debugKernelAccess) {
1993 1.335 mlelstv db1_printf(("raid_addr=%d sum=%d num_blocks=%d(+%d) (%d)\n",
1994 1.335 mlelstv (int) raid_addr, (int) sum, (int) num_blocks,
1995 1.335 mlelstv (int) pb, (int) bp->b_resid));
1996 1.335 mlelstv }
1997 1.335 mlelstv if ((sum > raidPtr->totalSectors) || (sum < raid_addr)
1998 1.335 mlelstv || (sum < num_blocks) || (sum < pb)) {
1999 1.335 mlelstv rc = ENOSPC;
2000 1.335 mlelstv goto done;
2001 1.335 mlelstv }
2002 1.335 mlelstv /*
2003 1.335 mlelstv * XXX rf_DoAccess() should do this, not just DoAccessKernel()
2004 1.335 mlelstv */
2005 1.186 perry
2006 1.335 mlelstv if (bp->b_bcount & raidPtr->sectorMask) {
2007 1.335 mlelstv rc = ENOSPC;
2008 1.335 mlelstv goto done;
2009 1.335 mlelstv }
2010 1.335 mlelstv db1_printf(("Calling DoAccess..\n"));
2011 1.99 oster
2012 1.20 oster
2013 1.335 mlelstv rf_lock_mutex2(raidPtr->mutex);
2014 1.335 mlelstv raidPtr->openings--;
2015 1.291 mrg rf_unlock_mutex2(raidPtr->mutex);
2016 1.20 oster
2017 1.335 mlelstv /* don't ever condition on bp->b_flags & B_WRITE.
2018 1.335 mlelstv * always condition on B_READ instead */
2019 1.7 explorer
2020 1.335 mlelstv rc = rf_DoAccess(raidPtr, (bp->b_flags & B_READ) ?
2021 1.335 mlelstv RF_IO_TYPE_READ : RF_IO_TYPE_WRITE,
2022 1.396 oster raid_addr, num_blocks,
2023 1.335 mlelstv bp->b_data, bp, RF_DAG_NONBLOCKING_IO);
2024 1.335 mlelstv
2025 1.335 mlelstv done:
2026 1.335 mlelstv return rc;
2027 1.335 mlelstv }
2028 1.7 explorer
2029 1.1 oster /* invoke an I/O from kernel mode. Disk queue should be locked upon entry */
2030 1.1 oster
2031 1.186 perry int
2032 1.169 oster rf_DispatchKernelIO(RF_DiskQueue_t *queue, RF_DiskQueueData_t *req)
2033 1.1 oster {
2034 1.9 oster int op = (req->type == RF_IO_TYPE_READ) ? B_READ : B_WRITE;
2035 1.1 oster struct buf *bp;
2036 1.9 oster
2037 1.1 oster req->queue = queue;
2038 1.1 oster bp = req->bp;
2039 1.1 oster
2040 1.1 oster switch (req->type) {
2041 1.9 oster case RF_IO_TYPE_NOP: /* used primarily to unlock a locked queue */
2042 1.1 oster /* XXX need to do something extra here.. */
2043 1.9 oster /* I'm leaving this in, as I've never actually seen it used,
2044 1.9 oster * and I'd like folks to report it... GO */
2045 1.391 mrg printf("%s: WAKEUP CALLED\n", __func__);
2046 1.1 oster queue->numOutstanding++;
2047 1.1 oster
2048 1.197 oster bp->b_flags = 0;
2049 1.207 simonb bp->b_private = req;
2050 1.1 oster
2051 1.194 oster KernelWakeupFunc(bp);
2052 1.1 oster break;
2053 1.9 oster
2054 1.1 oster case RF_IO_TYPE_READ:
2055 1.1 oster case RF_IO_TYPE_WRITE:
2056 1.175 oster #if RF_ACC_TRACE > 0
2057 1.1 oster if (req->tracerec) {
2058 1.1 oster RF_ETIMER_START(req->tracerec->timer);
2059 1.1 oster }
2060 1.175 oster #endif
2061 1.194 oster InitBP(bp, queue->rf_cinfo->ci_vp,
2062 1.197 oster op, queue->rf_cinfo->ci_dev,
2063 1.9 oster req->sectorOffset, req->numSector,
2064 1.9 oster req->buf, KernelWakeupFunc, (void *) req,
2065 1.384 jdolecek queue->raidPtr->logBytesPerSector);
2066 1.1 oster
2067 1.1 oster if (rf_debugKernelAccess) {
2068 1.9 oster db1_printf(("dispatch: bp->b_blkno = %ld\n",
2069 1.9 oster (long) bp->b_blkno));
2070 1.1 oster }
2071 1.1 oster queue->numOutstanding++;
2072 1.1 oster queue->last_deq_sector = req->sectorOffset;
2073 1.9 oster /* acc wouldn't have been let in if there were any pending
2074 1.9 oster * reqs at any other priority */
2075 1.1 oster queue->curPriority = req->priority;
2076 1.1 oster
2077 1.166 oster db1_printf(("Going for %c to unit %d col %d\n",
2078 1.186 perry req->type, queue->raidPtr->raidid,
2079 1.166 oster queue->col));
2080 1.1 oster db1_printf(("sector %d count %d (%d bytes) %d\n",
2081 1.9 oster (int) req->sectorOffset, (int) req->numSector,
2082 1.9 oster (int) (req->numSector <<
2083 1.9 oster queue->raidPtr->logBytesPerSector),
2084 1.9 oster (int) queue->raidPtr->logBytesPerSector));
2085 1.256 oster
2086 1.256 oster /*
2087 1.385 riastrad * XXX: drop lock here since this can block at
2088 1.256 oster * least with backing SCSI devices. Retake it
2089 1.256 oster * to minimize fuss with calling interfaces.
2090 1.256 oster */
2091 1.256 oster
2092 1.256 oster RF_UNLOCK_QUEUE_MUTEX(queue, "unusedparam");
2093 1.247 oster bdev_strategy(bp);
2094 1.256 oster RF_LOCK_QUEUE_MUTEX(queue, "unusedparam");
2095 1.1 oster break;
2096 1.9 oster
2097 1.1 oster default:
2098 1.1 oster panic("bad req->type in rf_DispatchKernelIO");
2099 1.1 oster }
2100 1.1 oster db1_printf(("Exiting from DispatchKernelIO\n"));
2101 1.134 oster
2102 1.389 skrll return 0;
2103 1.1 oster }
2104 1.9 oster /* this is the callback function associated with a I/O invoked from
2105 1.1 oster kernel code.
2106 1.1 oster */
2107 1.186 perry static void
2108 1.194 oster KernelWakeupFunc(struct buf *bp)
2109 1.9 oster {
2110 1.9 oster RF_DiskQueueData_t *req = NULL;
2111 1.9 oster RF_DiskQueue_t *queue;
2112 1.9 oster
2113 1.9 oster db1_printf(("recovering the request queue:\n"));
2114 1.285 mrg
2115 1.207 simonb req = bp->b_private;
2116 1.1 oster
2117 1.9 oster queue = (RF_DiskQueue_t *) req->queue;
2118 1.1 oster
2119 1.286 mrg rf_lock_mutex2(queue->raidPtr->iodone_lock);
2120 1.285 mrg
2121 1.175 oster #if RF_ACC_TRACE > 0
2122 1.9 oster if (req->tracerec) {
2123 1.9 oster RF_ETIMER_STOP(req->tracerec->timer);
2124 1.9 oster RF_ETIMER_EVAL(req->tracerec->timer);
2125 1.288 mrg rf_lock_mutex2(rf_tracing_mutex);
2126 1.9 oster req->tracerec->diskwait_us += RF_ETIMER_VAL_US(req->tracerec->timer);
2127 1.9 oster req->tracerec->phys_io_us += RF_ETIMER_VAL_US(req->tracerec->timer);
2128 1.9 oster req->tracerec->num_phys_ios++;
2129 1.288 mrg rf_unlock_mutex2(rf_tracing_mutex);
2130 1.9 oster }
2131 1.175 oster #endif
2132 1.1 oster
2133 1.230 ad /* XXX Ok, let's get aggressive... If b_error is set, let's go
2134 1.9 oster * ballistic, and mark the component as hosed... */
2135 1.36 oster
2136 1.230 ad if (bp->b_error != 0) {
2137 1.9 oster /* Mark the disk as dead */
2138 1.9 oster /* but only mark it once... */
2139 1.186 perry /* and only if it wouldn't leave this RAID set
2140 1.183 oster completely broken */
2141 1.193 oster if (((queue->raidPtr->Disks[queue->col].status ==
2142 1.193 oster rf_ds_optimal) ||
2143 1.193 oster (queue->raidPtr->Disks[queue->col].status ==
2144 1.385 riastrad rf_ds_used_spare)) &&
2145 1.193 oster (queue->raidPtr->numFailures <
2146 1.204 simonb queue->raidPtr->Layout.map->faultsTolerated)) {
2147 1.322 prlw1 printf("raid%d: IO Error (%d). Marking %s as failed.\n",
2148 1.136 oster queue->raidPtr->raidid,
2149 1.322 prlw1 bp->b_error,
2150 1.166 oster queue->raidPtr->Disks[queue->col].devname);
2151 1.166 oster queue->raidPtr->Disks[queue->col].status =
2152 1.9 oster rf_ds_failed;
2153 1.166 oster queue->raidPtr->status = rf_rs_degraded;
2154 1.9 oster queue->raidPtr->numFailures++;
2155 1.56 oster queue->raidPtr->numNewFailures++;
2156 1.9 oster } else { /* Disk is already dead... */
2157 1.9 oster /* printf("Disk already marked as dead!\n"); */
2158 1.9 oster }
2159 1.4 oster
2160 1.9 oster }
2161 1.4 oster
2162 1.143 oster /* Fill in the error value */
2163 1.230 ad req->error = bp->b_error;
2164 1.143 oster
2165 1.143 oster /* Drop this one on the "finished" queue... */
2166 1.143 oster TAILQ_INSERT_TAIL(&(queue->raidPtr->iodone), req, iodone_entries);
2167 1.143 oster
2168 1.143 oster /* Let the raidio thread know there is work to be done. */
2169 1.286 mrg rf_signal_cond2(queue->raidPtr->iodone_cv);
2170 1.143 oster
2171 1.286 mrg rf_unlock_mutex2(queue->raidPtr->iodone_lock);
2172 1.1 oster }
2173 1.1 oster
2174 1.1 oster
2175 1.1 oster /*
2176 1.1 oster * initialize a buf structure for doing an I/O in the kernel.
2177 1.1 oster */
2178 1.186 perry static void
2179 1.169 oster InitBP(struct buf *bp, struct vnode *b_vp, unsigned rw_flag, dev_t dev,
2180 1.225 christos RF_SectorNum_t startSect, RF_SectorCount_t numSect, void *bf,
2181 1.384 jdolecek void (*cbFunc) (struct buf *), void *cbArg, int logBytesPerSector)
2182 1.9 oster {
2183 1.384 jdolecek bp->b_flags = rw_flag | (bp->b_flags & rf_b_pass);
2184 1.242 ad bp->b_oflags = 0;
2185 1.242 ad bp->b_cflags = 0;
2186 1.9 oster bp->b_bcount = numSect << logBytesPerSector;
2187 1.9 oster bp->b_bufsize = bp->b_bcount;
2188 1.9 oster bp->b_error = 0;
2189 1.9 oster bp->b_dev = dev;
2190 1.187 christos bp->b_data = bf;
2191 1.275 mrg bp->b_blkno = startSect << logBytesPerSector >> DEV_BSHIFT;
2192 1.9 oster bp->b_resid = bp->b_bcount; /* XXX is this right!??!?!! */
2193 1.1 oster if (bp->b_bcount == 0) {
2194 1.141 provos panic("bp->b_bcount is zero in InitBP!!");
2195 1.1 oster }
2196 1.9 oster bp->b_iodone = cbFunc;
2197 1.207 simonb bp->b_private = cbArg;
2198 1.1 oster }
2199 1.1 oster
2200 1.1 oster /*
2201 1.1 oster * Wait interruptibly for an exclusive lock.
2202 1.1 oster *
2203 1.1 oster * XXX
2204 1.1 oster * Several drivers do this; it should be abstracted and made MP-safe.
2205 1.1 oster * (Hmm... where have we seen this warning before :-> GO )
2206 1.1 oster */
2207 1.1 oster static int
2208 1.169 oster raidlock(struct raid_softc *rs)
2209 1.1 oster {
2210 1.9 oster int error;
2211 1.1 oster
2212 1.335 mlelstv error = 0;
2213 1.327 pgoyette mutex_enter(&rs->sc_mutex);
2214 1.1 oster while ((rs->sc_flags & RAIDF_LOCKED) != 0) {
2215 1.1 oster rs->sc_flags |= RAIDF_WANTED;
2216 1.327 pgoyette error = cv_wait_sig(&rs->sc_cv, &rs->sc_mutex);
2217 1.327 pgoyette if (error != 0)
2218 1.335 mlelstv goto done;
2219 1.1 oster }
2220 1.1 oster rs->sc_flags |= RAIDF_LOCKED;
2221 1.335 mlelstv done:
2222 1.327 pgoyette mutex_exit(&rs->sc_mutex);
2223 1.389 skrll return error;
2224 1.1 oster }
2225 1.1 oster /*
2226 1.1 oster * Unlock and wake up any waiters.
2227 1.1 oster */
2228 1.1 oster static void
2229 1.169 oster raidunlock(struct raid_softc *rs)
2230 1.1 oster {
2231 1.1 oster
2232 1.327 pgoyette mutex_enter(&rs->sc_mutex);
2233 1.1 oster rs->sc_flags &= ~RAIDF_LOCKED;
2234 1.1 oster if ((rs->sc_flags & RAIDF_WANTED) != 0) {
2235 1.1 oster rs->sc_flags &= ~RAIDF_WANTED;
2236 1.327 pgoyette cv_broadcast(&rs->sc_cv);
2237 1.1 oster }
2238 1.327 pgoyette mutex_exit(&rs->sc_mutex);
2239 1.11 oster }
2240 1.186 perry
2241 1.11 oster
2242 1.11 oster #define RF_COMPONENT_INFO_OFFSET 16384 /* bytes */
2243 1.11 oster #define RF_COMPONENT_INFO_SIZE 1024 /* bytes */
2244 1.269 jld #define RF_PARITY_MAP_SIZE RF_PARITYMAP_NBYTE
2245 1.11 oster
2246 1.276 mrg static daddr_t
2247 1.276 mrg rf_component_info_offset(void)
2248 1.276 mrg {
2249 1.276 mrg
2250 1.276 mrg return RF_COMPONENT_INFO_OFFSET;
2251 1.276 mrg }
2252 1.276 mrg
2253 1.276 mrg static daddr_t
2254 1.276 mrg rf_component_info_size(unsigned secsize)
2255 1.276 mrg {
2256 1.276 mrg daddr_t info_size;
2257 1.276 mrg
2258 1.276 mrg KASSERT(secsize);
2259 1.276 mrg if (secsize > RF_COMPONENT_INFO_SIZE)
2260 1.276 mrg info_size = secsize;
2261 1.276 mrg else
2262 1.276 mrg info_size = RF_COMPONENT_INFO_SIZE;
2263 1.276 mrg
2264 1.276 mrg return info_size;
2265 1.276 mrg }
2266 1.276 mrg
2267 1.276 mrg static daddr_t
2268 1.276 mrg rf_parity_map_offset(RF_Raid_t *raidPtr)
2269 1.276 mrg {
2270 1.276 mrg daddr_t map_offset;
2271 1.276 mrg
2272 1.276 mrg KASSERT(raidPtr->bytesPerSector);
2273 1.276 mrg if (raidPtr->bytesPerSector > RF_COMPONENT_INFO_SIZE)
2274 1.276 mrg map_offset = raidPtr->bytesPerSector;
2275 1.276 mrg else
2276 1.276 mrg map_offset = RF_COMPONENT_INFO_SIZE;
2277 1.276 mrg map_offset += rf_component_info_offset();
2278 1.276 mrg
2279 1.276 mrg return map_offset;
2280 1.276 mrg }
2281 1.276 mrg
2282 1.276 mrg static daddr_t
2283 1.276 mrg rf_parity_map_size(RF_Raid_t *raidPtr)
2284 1.276 mrg {
2285 1.276 mrg daddr_t map_size;
2286 1.276 mrg
2287 1.276 mrg if (raidPtr->bytesPerSector > RF_PARITY_MAP_SIZE)
2288 1.276 mrg map_size = raidPtr->bytesPerSector;
2289 1.276 mrg else
2290 1.276 mrg map_size = RF_PARITY_MAP_SIZE;
2291 1.276 mrg
2292 1.276 mrg return map_size;
2293 1.276 mrg }
2294 1.276 mrg
2295 1.186 perry int
2296 1.269 jld raidmarkclean(RF_Raid_t *raidPtr, RF_RowCol_t col)
2297 1.12 oster {
2298 1.269 jld RF_ComponentLabel_t *clabel;
2299 1.269 jld
2300 1.269 jld clabel = raidget_component_label(raidPtr, col);
2301 1.269 jld clabel->clean = RF_RAID_CLEAN;
2302 1.269 jld raidflush_component_label(raidPtr, col);
2303 1.12 oster return(0);
2304 1.12 oster }
2305 1.12 oster
2306 1.12 oster
2307 1.186 perry int
2308 1.269 jld raidmarkdirty(RF_Raid_t *raidPtr, RF_RowCol_t col)
2309 1.11 oster {
2310 1.269 jld RF_ComponentLabel_t *clabel;
2311 1.269 jld
2312 1.269 jld clabel = raidget_component_label(raidPtr, col);
2313 1.269 jld clabel->clean = RF_RAID_DIRTY;
2314 1.269 jld raidflush_component_label(raidPtr, col);
2315 1.11 oster return(0);
2316 1.11 oster }
2317 1.11 oster
2318 1.11 oster int
2319 1.269 jld raidfetch_component_label(RF_Raid_t *raidPtr, RF_RowCol_t col)
2320 1.269 jld {
2321 1.276 mrg KASSERT(raidPtr->bytesPerSector);
2322 1.394 mrg
2323 1.276 mrg return raidread_component_label(raidPtr->bytesPerSector,
2324 1.276 mrg raidPtr->Disks[col].dev,
2325 1.385 riastrad raidPtr->raid_cinfo[col].ci_vp,
2326 1.269 jld &raidPtr->raid_cinfo[col].ci_label);
2327 1.269 jld }
2328 1.269 jld
2329 1.269 jld RF_ComponentLabel_t *
2330 1.269 jld raidget_component_label(RF_Raid_t *raidPtr, RF_RowCol_t col)
2331 1.269 jld {
2332 1.269 jld return &raidPtr->raid_cinfo[col].ci_label;
2333 1.269 jld }
2334 1.269 jld
2335 1.269 jld int
2336 1.269 jld raidflush_component_label(RF_Raid_t *raidPtr, RF_RowCol_t col)
2337 1.269 jld {
2338 1.269 jld RF_ComponentLabel_t *label;
2339 1.269 jld
2340 1.269 jld label = &raidPtr->raid_cinfo[col].ci_label;
2341 1.269 jld label->mod_counter = raidPtr->mod_counter;
2342 1.269 jld #ifndef RF_NO_PARITY_MAP
2343 1.269 jld label->parity_map_modcount = label->mod_counter;
2344 1.269 jld #endif
2345 1.276 mrg return raidwrite_component_label(raidPtr->bytesPerSector,
2346 1.276 mrg raidPtr->Disks[col].dev,
2347 1.269 jld raidPtr->raid_cinfo[col].ci_vp, label);
2348 1.269 jld }
2349 1.269 jld
2350 1.394 mrg /*
2351 1.394 mrg * Swap the label endianness.
2352 1.394 mrg *
2353 1.394 mrg * Everything in the component label is 4-byte-swapped except the version,
2354 1.394 mrg * which is kept in the byte-swapped version at all times, and indicates
2355 1.394 mrg * for the writer that a swap is necessary.
2356 1.394 mrg *
2357 1.394 mrg * For reads it is expected that out_label == clabel, but writes expect
2358 1.394 mrg * separate labels so only the re-swapped label is written out to disk,
2359 1.394 mrg * leaving the swapped-except-version internally.
2360 1.394 mrg *
2361 1.394 mrg * Only support swapping label version 2.
2362 1.394 mrg */
2363 1.394 mrg static void
2364 1.394 mrg rf_swap_label(RF_ComponentLabel_t *clabel, RF_ComponentLabel_t *out_label)
2365 1.394 mrg {
2366 1.394 mrg int *in, *out, *in_last;
2367 1.394 mrg
2368 1.394 mrg KASSERT(clabel->version == bswap32(RF_COMPONENT_LABEL_VERSION));
2369 1.394 mrg
2370 1.394 mrg /* Don't swap the label, but do copy it. */
2371 1.394 mrg out_label->version = clabel->version;
2372 1.394 mrg
2373 1.394 mrg in = &clabel->serial_number;
2374 1.394 mrg in_last = &clabel->future_use2[42];
2375 1.394 mrg out = &out_label->serial_number;
2376 1.394 mrg
2377 1.394 mrg for (; in < in_last; in++, out++)
2378 1.394 mrg *out = bswap32(*in);
2379 1.394 mrg }
2380 1.269 jld
2381 1.269 jld static int
2382 1.276 mrg raidread_component_label(unsigned secsize, dev_t dev, struct vnode *b_vp,
2383 1.269 jld RF_ComponentLabel_t *clabel)
2384 1.269 jld {
2385 1.394 mrg int error;
2386 1.394 mrg
2387 1.394 mrg error = raidread_component_area(dev, b_vp, clabel,
2388 1.269 jld sizeof(RF_ComponentLabel_t),
2389 1.276 mrg rf_component_info_offset(),
2390 1.276 mrg rf_component_info_size(secsize));
2391 1.394 mrg
2392 1.394 mrg if (error == 0 &&
2393 1.394 mrg clabel->version == bswap32(RF_COMPONENT_LABEL_VERSION)) {
2394 1.394 mrg rf_swap_label(clabel, clabel);
2395 1.394 mrg }
2396 1.394 mrg
2397 1.394 mrg return error;
2398 1.269 jld }
2399 1.269 jld
2400 1.269 jld /* ARGSUSED */
2401 1.269 jld static int
2402 1.269 jld raidread_component_area(dev_t dev, struct vnode *b_vp, void *data,
2403 1.269 jld size_t msize, daddr_t offset, daddr_t dsize)
2404 1.11 oster {
2405 1.11 oster struct buf *bp;
2406 1.11 oster int error;
2407 1.186 perry
2408 1.11 oster /* XXX should probably ensure that we don't try to do this if
2409 1.186 perry someone has changed rf_protected_sectors. */
2410 1.11 oster
2411 1.98 oster if (b_vp == NULL) {
2412 1.98 oster /* For whatever reason, this component is not valid.
2413 1.98 oster Don't try to read a component label from it. */
2414 1.98 oster return(EINVAL);
2415 1.98 oster }
2416 1.98 oster
2417 1.11 oster /* get a block of the appropriate size... */
2418 1.269 jld bp = geteblk((int)dsize);
2419 1.11 oster bp->b_dev = dev;
2420 1.11 oster
2421 1.11 oster /* get our ducks in a row for the read */
2422 1.269 jld bp->b_blkno = offset / DEV_BSIZE;
2423 1.269 jld bp->b_bcount = dsize;
2424 1.100 chs bp->b_flags |= B_READ;
2425 1.269 jld bp->b_resid = dsize;
2426 1.11 oster
2427 1.331 mlelstv bdev_strategy(bp);
2428 1.340 christos error = biowait(bp);
2429 1.11 oster
2430 1.11 oster if (!error) {
2431 1.269 jld memcpy(data, bp->b_data, msize);
2432 1.204 simonb }
2433 1.11 oster
2434 1.233 ad brelse(bp, 0);
2435 1.11 oster return(error);
2436 1.11 oster }
2437 1.269 jld
2438 1.269 jld static int
2439 1.276 mrg raidwrite_component_label(unsigned secsize, dev_t dev, struct vnode *b_vp,
2440 1.276 mrg RF_ComponentLabel_t *clabel)
2441 1.269 jld {
2442 1.394 mrg RF_ComponentLabel_t *clabel_write = clabel;
2443 1.394 mrg RF_ComponentLabel_t lclabel;
2444 1.394 mrg int error;
2445 1.394 mrg
2446 1.394 mrg if (clabel->version == bswap32(RF_COMPONENT_LABEL_VERSION)) {
2447 1.394 mrg clabel_write = &lclabel;
2448 1.394 mrg rf_swap_label(clabel, clabel_write);
2449 1.394 mrg }
2450 1.394 mrg error = raidwrite_component_area(dev, b_vp, clabel_write,
2451 1.269 jld sizeof(RF_ComponentLabel_t),
2452 1.276 mrg rf_component_info_offset(),
2453 1.276 mrg rf_component_info_size(secsize), 0);
2454 1.394 mrg
2455 1.394 mrg return error;
2456 1.269 jld }
2457 1.269 jld
2458 1.11 oster /* ARGSUSED */
2459 1.269 jld static int
2460 1.385 riastrad raidwrite_component_area(dev_t dev, struct vnode *b_vp, void *data,
2461 1.269 jld size_t msize, daddr_t offset, daddr_t dsize, int asyncp)
2462 1.11 oster {
2463 1.11 oster struct buf *bp;
2464 1.11 oster int error;
2465 1.11 oster
2466 1.11 oster /* get a block of the appropriate size... */
2467 1.269 jld bp = geteblk((int)dsize);
2468 1.11 oster bp->b_dev = dev;
2469 1.11 oster
2470 1.11 oster /* get our ducks in a row for the write */
2471 1.269 jld bp->b_blkno = offset / DEV_BSIZE;
2472 1.269 jld bp->b_bcount = dsize;
2473 1.269 jld bp->b_flags |= B_WRITE | (asyncp ? B_ASYNC : 0);
2474 1.269 jld bp->b_resid = dsize;
2475 1.11 oster
2476 1.269 jld memset(bp->b_data, 0, dsize);
2477 1.269 jld memcpy(bp->b_data, data, msize);
2478 1.11 oster
2479 1.331 mlelstv bdev_strategy(bp);
2480 1.269 jld if (asyncp)
2481 1.269 jld return 0;
2482 1.340 christos error = biowait(bp);
2483 1.233 ad brelse(bp, 0);
2484 1.11 oster if (error) {
2485 1.48 oster #if 1
2486 1.11 oster printf("Failed to write RAID component info!\n");
2487 1.48 oster #endif
2488 1.11 oster }
2489 1.11 oster
2490 1.11 oster return(error);
2491 1.1 oster }
2492 1.12 oster
2493 1.186 perry void
2494 1.269 jld rf_paritymap_kern_write(RF_Raid_t *raidPtr, struct rf_paritymap_ondisk *map)
2495 1.269 jld {
2496 1.269 jld int c;
2497 1.269 jld
2498 1.269 jld for (c = 0; c < raidPtr->numCol; c++) {
2499 1.269 jld /* Skip dead disks. */
2500 1.269 jld if (RF_DEAD_DISK(raidPtr->Disks[c].status))
2501 1.269 jld continue;
2502 1.269 jld /* XXXjld: what if an error occurs here? */
2503 1.269 jld raidwrite_component_area(raidPtr->Disks[c].dev,
2504 1.269 jld raidPtr->raid_cinfo[c].ci_vp, map,
2505 1.269 jld RF_PARITYMAP_NBYTE,
2506 1.276 mrg rf_parity_map_offset(raidPtr),
2507 1.276 mrg rf_parity_map_size(raidPtr), 0);
2508 1.269 jld }
2509 1.269 jld }
2510 1.269 jld
2511 1.269 jld void
2512 1.269 jld rf_paritymap_kern_read(RF_Raid_t *raidPtr, struct rf_paritymap_ondisk *map)
2513 1.269 jld {
2514 1.269 jld struct rf_paritymap_ondisk tmp;
2515 1.272 oster int c,first;
2516 1.269 jld
2517 1.272 oster first=1;
2518 1.269 jld for (c = 0; c < raidPtr->numCol; c++) {
2519 1.269 jld /* Skip dead disks. */
2520 1.269 jld if (RF_DEAD_DISK(raidPtr->Disks[c].status))
2521 1.269 jld continue;
2522 1.269 jld raidread_component_area(raidPtr->Disks[c].dev,
2523 1.269 jld raidPtr->raid_cinfo[c].ci_vp, &tmp,
2524 1.269 jld RF_PARITYMAP_NBYTE,
2525 1.276 mrg rf_parity_map_offset(raidPtr),
2526 1.276 mrg rf_parity_map_size(raidPtr));
2527 1.272 oster if (first) {
2528 1.269 jld memcpy(map, &tmp, sizeof(*map));
2529 1.272 oster first = 0;
2530 1.269 jld } else {
2531 1.269 jld rf_paritymap_merge(map, &tmp);
2532 1.269 jld }
2533 1.269 jld }
2534 1.269 jld }
2535 1.269 jld
2536 1.269 jld void
2537 1.169 oster rf_markalldirty(RF_Raid_t *raidPtr)
2538 1.12 oster {
2539 1.269 jld RF_ComponentLabel_t *clabel;
2540 1.146 oster int sparecol;
2541 1.166 oster int c;
2542 1.166 oster int j;
2543 1.166 oster int scol = -1;
2544 1.12 oster
2545 1.12 oster raidPtr->mod_counter++;
2546 1.166 oster for (c = 0; c < raidPtr->numCol; c++) {
2547 1.166 oster /* we don't want to touch (at all) a disk that has
2548 1.166 oster failed */
2549 1.166 oster if (!RF_DEAD_DISK(raidPtr->Disks[c].status)) {
2550 1.269 jld clabel = raidget_component_label(raidPtr, c);
2551 1.269 jld if (clabel->status == rf_ds_spared) {
2552 1.186 perry /* XXX do something special...
2553 1.186 perry but whatever you do, don't
2554 1.166 oster try to access it!! */
2555 1.166 oster } else {
2556 1.269 jld raidmarkdirty(raidPtr, c);
2557 1.12 oster }
2558 1.166 oster }
2559 1.186 perry }
2560 1.146 oster
2561 1.12 oster for( c = 0; c < raidPtr->numSpare ; c++) {
2562 1.12 oster sparecol = raidPtr->numCol + c;
2563 1.166 oster if (raidPtr->Disks[sparecol].status == rf_ds_used_spare) {
2564 1.186 perry /*
2565 1.186 perry
2566 1.186 perry we claim this disk is "optimal" if it's
2567 1.186 perry rf_ds_used_spare, as that means it should be
2568 1.186 perry directly substitutable for the disk it replaced.
2569 1.12 oster We note that too...
2570 1.12 oster
2571 1.12 oster */
2572 1.12 oster
2573 1.166 oster for(j=0;j<raidPtr->numCol;j++) {
2574 1.166 oster if (raidPtr->Disks[j].spareCol == sparecol) {
2575 1.166 oster scol = j;
2576 1.166 oster break;
2577 1.12 oster }
2578 1.12 oster }
2579 1.186 perry
2580 1.269 jld clabel = raidget_component_label(raidPtr, sparecol);
2581 1.12 oster /* make sure status is noted */
2582 1.146 oster
2583 1.269 jld raid_init_component_label(raidPtr, clabel);
2584 1.146 oster
2585 1.269 jld clabel->row = 0;
2586 1.269 jld clabel->column = scol;
2587 1.146 oster /* Note: we *don't* change status from rf_ds_used_spare
2588 1.146 oster to rf_ds_optimal */
2589 1.146 oster /* clabel.status = rf_ds_optimal; */
2590 1.186 perry
2591 1.269 jld raidmarkdirty(raidPtr, sparecol);
2592 1.12 oster }
2593 1.12 oster }
2594 1.12 oster }
2595 1.12 oster
2596 1.13 oster
2597 1.13 oster void
2598 1.169 oster rf_update_component_labels(RF_Raid_t *raidPtr, int final)
2599 1.13 oster {
2600 1.269 jld RF_ComponentLabel_t *clabel;
2601 1.13 oster int sparecol;
2602 1.166 oster int c;
2603 1.166 oster int j;
2604 1.166 oster int scol;
2605 1.341 christos struct raid_softc *rs = raidPtr->softc;
2606 1.13 oster
2607 1.13 oster scol = -1;
2608 1.13 oster
2609 1.186 perry /* XXX should do extra checks to make sure things really are clean,
2610 1.13 oster rather than blindly setting the clean bit... */
2611 1.13 oster
2612 1.13 oster raidPtr->mod_counter++;
2613 1.13 oster
2614 1.166 oster for (c = 0; c < raidPtr->numCol; c++) {
2615 1.166 oster if (raidPtr->Disks[c].status == rf_ds_optimal) {
2616 1.269 jld clabel = raidget_component_label(raidPtr, c);
2617 1.201 oster /* make sure status is noted */
2618 1.269 jld clabel->status = rf_ds_optimal;
2619 1.385 riastrad
2620 1.214 oster /* note what unit we are configured as */
2621 1.341 christos if ((rs->sc_cflags & RAIDF_UNIT_CHANGED) == 0)
2622 1.341 christos clabel->last_unit = raidPtr->raidid;
2623 1.214 oster
2624 1.269 jld raidflush_component_label(raidPtr, c);
2625 1.166 oster if (final == RF_FINAL_COMPONENT_UPDATE) {
2626 1.166 oster if (raidPtr->parity_good == RF_RAID_CLEAN) {
2627 1.269 jld raidmarkclean(raidPtr, c);
2628 1.91 oster }
2629 1.166 oster }
2630 1.186 perry }
2631 1.166 oster /* else we don't touch it.. */
2632 1.186 perry }
2633 1.63 oster
2634 1.63 oster for( c = 0; c < raidPtr->numSpare ; c++) {
2635 1.63 oster sparecol = raidPtr->numCol + c;
2636 1.110 oster /* Need to ensure that the reconstruct actually completed! */
2637 1.166 oster if (raidPtr->Disks[sparecol].status == rf_ds_used_spare) {
2638 1.186 perry /*
2639 1.186 perry
2640 1.186 perry we claim this disk is "optimal" if it's
2641 1.186 perry rf_ds_used_spare, as that means it should be
2642 1.186 perry directly substitutable for the disk it replaced.
2643 1.63 oster We note that too...
2644 1.63 oster
2645 1.63 oster */
2646 1.63 oster
2647 1.166 oster for(j=0;j<raidPtr->numCol;j++) {
2648 1.166 oster if (raidPtr->Disks[j].spareCol == sparecol) {
2649 1.166 oster scol = j;
2650 1.166 oster break;
2651 1.63 oster }
2652 1.63 oster }
2653 1.186 perry
2654 1.63 oster /* XXX shouldn't *really* need this... */
2655 1.269 jld clabel = raidget_component_label(raidPtr, sparecol);
2656 1.63 oster /* make sure status is noted */
2657 1.63 oster
2658 1.269 jld raid_init_component_label(raidPtr, clabel);
2659 1.269 jld
2660 1.269 jld clabel->column = scol;
2661 1.269 jld clabel->status = rf_ds_optimal;
2662 1.341 christos if ((rs->sc_cflags & RAIDF_UNIT_CHANGED) == 0)
2663 1.341 christos clabel->last_unit = raidPtr->raidid;
2664 1.63 oster
2665 1.269 jld raidflush_component_label(raidPtr, sparecol);
2666 1.91 oster if (final == RF_FINAL_COMPONENT_UPDATE) {
2667 1.13 oster if (raidPtr->parity_good == RF_RAID_CLEAN) {
2668 1.269 jld raidmarkclean(raidPtr, sparecol);
2669 1.13 oster }
2670 1.13 oster }
2671 1.13 oster }
2672 1.13 oster }
2673 1.68 oster }
2674 1.68 oster
2675 1.68 oster void
2676 1.169 oster rf_close_component(RF_Raid_t *raidPtr, struct vnode *vp, int auto_configured)
2677 1.69 oster {
2678 1.69 oster
2679 1.69 oster if (vp != NULL) {
2680 1.69 oster if (auto_configured == 1) {
2681 1.96 oster vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
2682 1.238 pooka VOP_CLOSE(vp, FREAD | FWRITE, NOCRED);
2683 1.69 oster vput(vp);
2684 1.186 perry
2685 1.186 perry } else {
2686 1.244 ad (void) vn_close(vp, FREAD | FWRITE, curlwp->l_cred);
2687 1.69 oster }
2688 1.186 perry }
2689 1.69 oster }
2690 1.69 oster
2691 1.69 oster
2692 1.69 oster void
2693 1.169 oster rf_UnconfigureVnodes(RF_Raid_t *raidPtr)
2694 1.68 oster {
2695 1.186 perry int r,c;
2696 1.69 oster struct vnode *vp;
2697 1.69 oster int acd;
2698 1.68 oster
2699 1.68 oster
2700 1.68 oster /* We take this opportunity to close the vnodes like we should.. */
2701 1.68 oster
2702 1.166 oster for (c = 0; c < raidPtr->numCol; c++) {
2703 1.166 oster vp = raidPtr->raid_cinfo[c].ci_vp;
2704 1.166 oster acd = raidPtr->Disks[c].auto_configured;
2705 1.166 oster rf_close_component(raidPtr, vp, acd);
2706 1.166 oster raidPtr->raid_cinfo[c].ci_vp = NULL;
2707 1.166 oster raidPtr->Disks[c].auto_configured = 0;
2708 1.68 oster }
2709 1.166 oster
2710 1.68 oster for (r = 0; r < raidPtr->numSpare; r++) {
2711 1.166 oster vp = raidPtr->raid_cinfo[raidPtr->numCol + r].ci_vp;
2712 1.166 oster acd = raidPtr->Disks[raidPtr->numCol + r].auto_configured;
2713 1.69 oster rf_close_component(raidPtr, vp, acd);
2714 1.166 oster raidPtr->raid_cinfo[raidPtr->numCol + r].ci_vp = NULL;
2715 1.166 oster raidPtr->Disks[raidPtr->numCol + r].auto_configured = 0;
2716 1.68 oster }
2717 1.37 oster }
2718 1.63 oster
2719 1.37 oster
2720 1.393 mrg static void
2721 1.353 mrg rf_ReconThread(struct rf_recon_req_internal *req)
2722 1.37 oster {
2723 1.37 oster int s;
2724 1.37 oster RF_Raid_t *raidPtr;
2725 1.37 oster
2726 1.37 oster s = splbio();
2727 1.37 oster raidPtr = (RF_Raid_t *) req->raidPtr;
2728 1.37 oster raidPtr->recon_in_progress = 1;
2729 1.37 oster
2730 1.398 oster if (req->flags & RF_FDFLAGS_RECON_FORCE) {
2731 1.398 oster raidPtr->forceRecon = 1;
2732 1.398 oster }
2733 1.398 oster
2734 1.166 oster rf_FailDisk((RF_Raid_t *) req->raidPtr, req->col,
2735 1.37 oster ((req->flags & RF_FDFLAGS_RECON) ? 1 : 0));
2736 1.37 oster
2737 1.398 oster if (req->flags & RF_FDFLAGS_RECON_FORCE) {
2738 1.398 oster raidPtr->forceRecon = 0;
2739 1.398 oster }
2740 1.398 oster
2741 1.37 oster RF_Free(req, sizeof(*req));
2742 1.37 oster
2743 1.37 oster raidPtr->recon_in_progress = 0;
2744 1.37 oster splx(s);
2745 1.37 oster
2746 1.37 oster /* That's all... */
2747 1.204 simonb kthread_exit(0); /* does not return */
2748 1.37 oster }
2749 1.37 oster
2750 1.393 mrg static void
2751 1.169 oster rf_RewriteParityThread(RF_Raid_t *raidPtr)
2752 1.37 oster {
2753 1.37 oster int retcode;
2754 1.37 oster int s;
2755 1.37 oster
2756 1.184 oster raidPtr->parity_rewrite_stripes_done = 0;
2757 1.37 oster raidPtr->parity_rewrite_in_progress = 1;
2758 1.37 oster s = splbio();
2759 1.37 oster retcode = rf_RewriteParity(raidPtr);
2760 1.37 oster splx(s);
2761 1.37 oster if (retcode) {
2762 1.279 christos printf("raid%d: Error re-writing parity (%d)!\n",
2763 1.279 christos raidPtr->raidid, retcode);
2764 1.37 oster } else {
2765 1.37 oster /* set the clean bit! If we shutdown correctly,
2766 1.37 oster the clean bit on each component label will get
2767 1.37 oster set */
2768 1.37 oster raidPtr->parity_good = RF_RAID_CLEAN;
2769 1.37 oster }
2770 1.37 oster raidPtr->parity_rewrite_in_progress = 0;
2771 1.85 oster
2772 1.85 oster /* Anyone waiting for us to stop? If so, inform them... */
2773 1.85 oster if (raidPtr->waitShutdown) {
2774 1.357 mrg rf_lock_mutex2(raidPtr->rad_lock);
2775 1.357 mrg cv_broadcast(&raidPtr->parity_rewrite_cv);
2776 1.357 mrg rf_unlock_mutex2(raidPtr->rad_lock);
2777 1.85 oster }
2778 1.37 oster
2779 1.37 oster /* That's all... */
2780 1.204 simonb kthread_exit(0); /* does not return */
2781 1.37 oster }
2782 1.37 oster
2783 1.37 oster
2784 1.393 mrg static void
2785 1.169 oster rf_CopybackThread(RF_Raid_t *raidPtr)
2786 1.37 oster {
2787 1.37 oster int s;
2788 1.37 oster
2789 1.37 oster raidPtr->copyback_in_progress = 1;
2790 1.37 oster s = splbio();
2791 1.37 oster rf_CopybackReconstructedData(raidPtr);
2792 1.37 oster splx(s);
2793 1.37 oster raidPtr->copyback_in_progress = 0;
2794 1.37 oster
2795 1.37 oster /* That's all... */
2796 1.204 simonb kthread_exit(0); /* does not return */
2797 1.37 oster }
2798 1.37 oster
2799 1.37 oster
2800 1.393 mrg static void
2801 1.353 mrg rf_ReconstructInPlaceThread(struct rf_recon_req_internal *req)
2802 1.37 oster {
2803 1.37 oster int s;
2804 1.37 oster RF_Raid_t *raidPtr;
2805 1.186 perry
2806 1.37 oster s = splbio();
2807 1.37 oster raidPtr = req->raidPtr;
2808 1.37 oster raidPtr->recon_in_progress = 1;
2809 1.398 oster
2810 1.398 oster if (req->flags & RF_FDFLAGS_RECON_FORCE) {
2811 1.398 oster raidPtr->forceRecon = 1;
2812 1.398 oster }
2813 1.398 oster
2814 1.166 oster rf_ReconstructInPlace(raidPtr, req->col);
2815 1.398 oster
2816 1.398 oster if (req->flags & RF_FDFLAGS_RECON_FORCE) {
2817 1.398 oster raidPtr->forceRecon = 0;
2818 1.398 oster }
2819 1.398 oster
2820 1.37 oster RF_Free(req, sizeof(*req));
2821 1.37 oster raidPtr->recon_in_progress = 0;
2822 1.37 oster splx(s);
2823 1.37 oster
2824 1.37 oster /* That's all... */
2825 1.204 simonb kthread_exit(0); /* does not return */
2826 1.48 oster }
2827 1.48 oster
2828 1.213 christos static RF_AutoConfig_t *
2829 1.213 christos rf_get_component(RF_AutoConfig_t *ac_list, dev_t dev, struct vnode *vp,
2830 1.276 mrg const char *cname, RF_SectorCount_t size, uint64_t numsecs,
2831 1.276 mrg unsigned secsize)
2832 1.213 christos {
2833 1.213 christos int good_one = 0;
2834 1.385 riastrad RF_ComponentLabel_t *clabel;
2835 1.213 christos RF_AutoConfig_t *ac;
2836 1.213 christos
2837 1.379 chs clabel = malloc(sizeof(RF_ComponentLabel_t), M_RAIDFRAME, M_WAITOK);
2838 1.213 christos
2839 1.276 mrg if (!raidread_component_label(secsize, dev, vp, clabel)) {
2840 1.276 mrg /* Got the label. Does it look reasonable? */
2841 1.385 riastrad if (rf_reasonable_label(clabel, numsecs) &&
2842 1.282 enami (rf_component_label_partitionsize(clabel) <= size)) {
2843 1.224 oster #ifdef DEBUG
2844 1.276 mrg printf("Component on: %s: %llu\n",
2845 1.213 christos cname, (unsigned long long)size);
2846 1.276 mrg rf_print_component_label(clabel);
2847 1.213 christos #endif
2848 1.276 mrg /* if it's reasonable, add it, else ignore it. */
2849 1.276 mrg ac = malloc(sizeof(RF_AutoConfig_t), M_RAIDFRAME,
2850 1.379 chs M_WAITOK);
2851 1.276 mrg strlcpy(ac->devname, cname, sizeof(ac->devname));
2852 1.276 mrg ac->dev = dev;
2853 1.276 mrg ac->vp = vp;
2854 1.276 mrg ac->clabel = clabel;
2855 1.276 mrg ac->next = ac_list;
2856 1.276 mrg ac_list = ac;
2857 1.276 mrg good_one = 1;
2858 1.276 mrg }
2859 1.213 christos }
2860 1.213 christos if (!good_one) {
2861 1.213 christos /* cleanup */
2862 1.213 christos free(clabel, M_RAIDFRAME);
2863 1.213 christos vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
2864 1.238 pooka VOP_CLOSE(vp, FREAD | FWRITE, NOCRED);
2865 1.213 christos vput(vp);
2866 1.213 christos }
2867 1.213 christos return ac_list;
2868 1.213 christos }
2869 1.213 christos
2870 1.393 mrg static RF_AutoConfig_t *
2871 1.259 cegger rf_find_raid_components(void)
2872 1.48 oster {
2873 1.48 oster struct vnode *vp;
2874 1.48 oster struct disklabel label;
2875 1.261 dyoung device_t dv;
2876 1.268 dyoung deviter_t di;
2877 1.48 oster dev_t dev;
2878 1.296 buhrow int bmajor, bminor, wedge, rf_part_found;
2879 1.48 oster int error;
2880 1.48 oster int i;
2881 1.48 oster RF_AutoConfig_t *ac_list;
2882 1.276 mrg uint64_t numsecs;
2883 1.276 mrg unsigned secsize;
2884 1.335 mlelstv int dowedges;
2885 1.48 oster
2886 1.48 oster /* initialize the AutoConfig list */
2887 1.48 oster ac_list = NULL;
2888 1.48 oster
2889 1.335 mlelstv /*
2890 1.335 mlelstv * we begin by trolling through *all* the devices on the system *twice*
2891 1.335 mlelstv * first we scan for wedges, second for other devices. This avoids
2892 1.335 mlelstv * using a raw partition instead of a wedge that covers the whole disk
2893 1.335 mlelstv */
2894 1.48 oster
2895 1.335 mlelstv for (dowedges=1; dowedges>=0; --dowedges) {
2896 1.335 mlelstv for (dv = deviter_first(&di, DEVITER_F_ROOT_FIRST); dv != NULL;
2897 1.335 mlelstv dv = deviter_next(&di)) {
2898 1.48 oster
2899 1.393 mrg /* we are only interested in disks */
2900 1.335 mlelstv if (device_class(dv) != DV_DISK)
2901 1.335 mlelstv continue;
2902 1.48 oster
2903 1.393 mrg /* we don't care about floppies */
2904 1.335 mlelstv if (device_is_a(dv, "fd")) {
2905 1.335 mlelstv continue;
2906 1.335 mlelstv }
2907 1.129 oster
2908 1.393 mrg /* we don't care about CDs. */
2909 1.335 mlelstv if (device_is_a(dv, "cd")) {
2910 1.335 mlelstv continue;
2911 1.335 mlelstv }
2912 1.129 oster
2913 1.393 mrg /* we don't care about md. */
2914 1.335 mlelstv if (device_is_a(dv, "md")) {
2915 1.335 mlelstv continue;
2916 1.335 mlelstv }
2917 1.248 oster
2918 1.335 mlelstv /* hdfd is the Atari/Hades floppy driver */
2919 1.335 mlelstv if (device_is_a(dv, "hdfd")) {
2920 1.335 mlelstv continue;
2921 1.335 mlelstv }
2922 1.206 thorpej
2923 1.335 mlelstv /* fdisa is the Atari/Milan floppy driver */
2924 1.335 mlelstv if (device_is_a(dv, "fdisa")) {
2925 1.335 mlelstv continue;
2926 1.335 mlelstv }
2927 1.186 perry
2928 1.393 mrg /* we don't care about spiflash */
2929 1.393 mrg if (device_is_a(dv, "spiflash")) {
2930 1.393 mrg continue;
2931 1.393 mrg }
2932 1.393 mrg
2933 1.335 mlelstv /* are we in the wedges pass ? */
2934 1.335 mlelstv wedge = device_is_a(dv, "dk");
2935 1.335 mlelstv if (wedge != dowedges) {
2936 1.335 mlelstv continue;
2937 1.335 mlelstv }
2938 1.48 oster
2939 1.335 mlelstv /* need to find the device_name_to_block_device_major stuff */
2940 1.335 mlelstv bmajor = devsw_name2blk(device_xname(dv), NULL, 0);
2941 1.296 buhrow
2942 1.335 mlelstv rf_part_found = 0; /*No raid partition as yet*/
2943 1.48 oster
2944 1.335 mlelstv /* get a vnode for the raw partition of this disk */
2945 1.335 mlelstv bminor = minor(device_unit(dv));
2946 1.335 mlelstv dev = wedge ? makedev(bmajor, bminor) :
2947 1.335 mlelstv MAKEDISKDEV(bmajor, bminor, RAW_PART);
2948 1.335 mlelstv if (bdevvp(dev, &vp))
2949 1.335 mlelstv panic("RAID can't alloc vnode");
2950 1.48 oster
2951 1.375 hannken vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
2952 1.335 mlelstv error = VOP_OPEN(vp, FREAD | FSILENT, NOCRED);
2953 1.48 oster
2954 1.335 mlelstv if (error) {
2955 1.335 mlelstv /* "Who cares." Continue looking
2956 1.335 mlelstv for something that exists*/
2957 1.335 mlelstv vput(vp);
2958 1.335 mlelstv continue;
2959 1.335 mlelstv }
2960 1.48 oster
2961 1.407 andvar VOP_UNLOCK(vp);
2962 1.335 mlelstv error = getdisksize(vp, &numsecs, &secsize);
2963 1.213 christos if (error) {
2964 1.339 mlelstv /*
2965 1.339 mlelstv * Pseudo devices like vnd and cgd can be
2966 1.339 mlelstv * opened but may still need some configuration.
2967 1.339 mlelstv * Ignore these quietly.
2968 1.339 mlelstv */
2969 1.339 mlelstv if (error != ENXIO)
2970 1.339 mlelstv printf("RAIDframe: can't get disk size"
2971 1.339 mlelstv " for dev %s (%d)\n",
2972 1.339 mlelstv device_xname(dv), error);
2973 1.406 hannken vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
2974 1.241 oster VOP_CLOSE(vp, FREAD | FWRITE, NOCRED);
2975 1.241 oster vput(vp);
2976 1.213 christos continue;
2977 1.213 christos }
2978 1.335 mlelstv if (wedge) {
2979 1.335 mlelstv struct dkwedge_info dkw;
2980 1.335 mlelstv error = VOP_IOCTL(vp, DIOCGWEDGEINFO, &dkw, FREAD,
2981 1.335 mlelstv NOCRED);
2982 1.335 mlelstv if (error) {
2983 1.335 mlelstv printf("RAIDframe: can't get wedge info for "
2984 1.335 mlelstv "dev %s (%d)\n", device_xname(dv), error);
2985 1.406 hannken vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
2986 1.335 mlelstv VOP_CLOSE(vp, FREAD | FWRITE, NOCRED);
2987 1.335 mlelstv vput(vp);
2988 1.335 mlelstv continue;
2989 1.335 mlelstv }
2990 1.213 christos
2991 1.335 mlelstv if (strcmp(dkw.dkw_ptype, DKW_PTYPE_RAIDFRAME) != 0) {
2992 1.406 hannken vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
2993 1.335 mlelstv VOP_CLOSE(vp, FREAD | FWRITE, NOCRED);
2994 1.335 mlelstv vput(vp);
2995 1.335 mlelstv continue;
2996 1.335 mlelstv }
2997 1.385 riastrad
2998 1.335 mlelstv ac_list = rf_get_component(ac_list, dev, vp,
2999 1.335 mlelstv device_xname(dv), dkw.dkw_size, numsecs, secsize);
3000 1.335 mlelstv rf_part_found = 1; /*There is a raid component on this disk*/
3001 1.228 christos continue;
3002 1.241 oster }
3003 1.213 christos
3004 1.335 mlelstv /* Ok, the disk exists. Go get the disklabel. */
3005 1.335 mlelstv error = VOP_IOCTL(vp, DIOCGDINFO, &label, FREAD, NOCRED);
3006 1.335 mlelstv if (error) {
3007 1.335 mlelstv /*
3008 1.335 mlelstv * XXX can't happen - open() would
3009 1.335 mlelstv * have errored out (or faked up one)
3010 1.335 mlelstv */
3011 1.335 mlelstv if (error != ENOTTY)
3012 1.335 mlelstv printf("RAIDframe: can't get label for dev "
3013 1.335 mlelstv "%s (%d)\n", device_xname(dv), error);
3014 1.335 mlelstv }
3015 1.48 oster
3016 1.335 mlelstv /* don't need this any more. We'll allocate it again
3017 1.335 mlelstv a little later if we really do... */
3018 1.406 hannken vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
3019 1.335 mlelstv VOP_CLOSE(vp, FREAD | FWRITE, NOCRED);
3020 1.335 mlelstv vput(vp);
3021 1.48 oster
3022 1.335 mlelstv if (error)
3023 1.48 oster continue;
3024 1.48 oster
3025 1.335 mlelstv rf_part_found = 0; /*No raid partitions yet*/
3026 1.335 mlelstv for (i = 0; i < label.d_npartitions; i++) {
3027 1.335 mlelstv char cname[sizeof(ac_list->devname)];
3028 1.335 mlelstv
3029 1.335 mlelstv /* We only support partitions marked as RAID */
3030 1.335 mlelstv if (label.d_partitions[i].p_fstype != FS_RAID)
3031 1.335 mlelstv continue;
3032 1.335 mlelstv
3033 1.335 mlelstv dev = MAKEDISKDEV(bmajor, device_unit(dv), i);
3034 1.335 mlelstv if (bdevvp(dev, &vp))
3035 1.335 mlelstv panic("RAID can't alloc vnode");
3036 1.335 mlelstv
3037 1.375 hannken vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
3038 1.335 mlelstv error = VOP_OPEN(vp, FREAD, NOCRED);
3039 1.335 mlelstv if (error) {
3040 1.400 oster /* Not quite a 'whatever'. In
3041 1.400 oster * this situation we know
3042 1.400 oster * there is a FS_RAID
3043 1.400 oster * partition, but we can't
3044 1.400 oster * open it. The most likely
3045 1.400 oster * reason is that the
3046 1.400 oster * partition is already in
3047 1.400 oster * use by another RAID set.
3048 1.400 oster * So note that we've already
3049 1.400 oster * found a partition on this
3050 1.400 oster * disk so we don't attempt
3051 1.400 oster * to use the raw disk later. */
3052 1.400 oster rf_part_found = 1;
3053 1.335 mlelstv vput(vp);
3054 1.335 mlelstv continue;
3055 1.335 mlelstv }
3056 1.375 hannken VOP_UNLOCK(vp);
3057 1.335 mlelstv snprintf(cname, sizeof(cname), "%s%c",
3058 1.335 mlelstv device_xname(dv), 'a' + i);
3059 1.335 mlelstv ac_list = rf_get_component(ac_list, dev, vp, cname,
3060 1.335 mlelstv label.d_partitions[i].p_size, numsecs, secsize);
3061 1.335 mlelstv rf_part_found = 1; /*There is at least one raid partition on this disk*/
3062 1.48 oster }
3063 1.296 buhrow
3064 1.335 mlelstv /*
3065 1.335 mlelstv *If there is no raid component on this disk, either in a
3066 1.335 mlelstv *disklabel or inside a wedge, check the raw partition as well,
3067 1.335 mlelstv *as it is possible to configure raid components on raw disk
3068 1.335 mlelstv *devices.
3069 1.335 mlelstv */
3070 1.296 buhrow
3071 1.335 mlelstv if (!rf_part_found) {
3072 1.335 mlelstv char cname[sizeof(ac_list->devname)];
3073 1.296 buhrow
3074 1.335 mlelstv dev = MAKEDISKDEV(bmajor, device_unit(dv), RAW_PART);
3075 1.335 mlelstv if (bdevvp(dev, &vp))
3076 1.335 mlelstv panic("RAID can't alloc vnode");
3077 1.335 mlelstv
3078 1.375 hannken vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
3079 1.375 hannken
3080 1.335 mlelstv error = VOP_OPEN(vp, FREAD, NOCRED);
3081 1.335 mlelstv if (error) {
3082 1.335 mlelstv /* Whatever... */
3083 1.335 mlelstv vput(vp);
3084 1.335 mlelstv continue;
3085 1.335 mlelstv }
3086 1.375 hannken VOP_UNLOCK(vp);
3087 1.335 mlelstv snprintf(cname, sizeof(cname), "%s%c",
3088 1.335 mlelstv device_xname(dv), 'a' + RAW_PART);
3089 1.335 mlelstv ac_list = rf_get_component(ac_list, dev, vp, cname,
3090 1.335 mlelstv label.d_partitions[RAW_PART].p_size, numsecs, secsize);
3091 1.296 buhrow }
3092 1.48 oster }
3093 1.335 mlelstv deviter_release(&di);
3094 1.48 oster }
3095 1.213 christos return ac_list;
3096 1.48 oster }
3097 1.186 perry
3098 1.292 oster int
3099 1.284 mrg rf_reasonable_label(RF_ComponentLabel_t *clabel, uint64_t numsecs)
3100 1.48 oster {
3101 1.186 perry
3102 1.393 mrg if ((clabel->version==RF_COMPONENT_LABEL_VERSION_1 ||
3103 1.394 mrg clabel->version==RF_COMPONENT_LABEL_VERSION ||
3104 1.394 mrg clabel->version == bswap32(RF_COMPONENT_LABEL_VERSION)) &&
3105 1.393 mrg (clabel->clean == RF_RAID_CLEAN ||
3106 1.393 mrg clabel->clean == RF_RAID_DIRTY) &&
3107 1.186 perry clabel->row >=0 &&
3108 1.186 perry clabel->column >= 0 &&
3109 1.48 oster clabel->num_rows > 0 &&
3110 1.48 oster clabel->num_columns > 0 &&
3111 1.186 perry clabel->row < clabel->num_rows &&
3112 1.48 oster clabel->column < clabel->num_columns &&
3113 1.48 oster clabel->blockSize > 0 &&
3114 1.282 enami /*
3115 1.282 enami * numBlocksHi may contain garbage, but it is ok since
3116 1.282 enami * the type is unsigned. If it is really garbage,
3117 1.282 enami * rf_fix_old_label_size() will fix it.
3118 1.282 enami */
3119 1.282 enami rf_component_label_numblocks(clabel) > 0) {
3120 1.284 mrg /*
3121 1.284 mrg * label looks reasonable enough...
3122 1.284 mrg * let's make sure it has no old garbage.
3123 1.284 mrg */
3124 1.292 oster if (numsecs)
3125 1.292 oster rf_fix_old_label_size(clabel, numsecs);
3126 1.48 oster return(1);
3127 1.48 oster }
3128 1.48 oster return(0);
3129 1.48 oster }
3130 1.48 oster
3131 1.48 oster
3132 1.278 mrg /*
3133 1.278 mrg * For reasons yet unknown, some old component labels have garbage in
3134 1.278 mrg * the newer numBlocksHi region, and this causes lossage. Since those
3135 1.278 mrg * disks will also have numsecs set to less than 32 bits of sectors,
3136 1.299 oster * we can determine when this corruption has occurred, and fix it.
3137 1.284 mrg *
3138 1.284 mrg * The exact same problem, with the same unknown reason, happens to
3139 1.284 mrg * the partitionSizeHi member as well.
3140 1.278 mrg */
3141 1.278 mrg static void
3142 1.278 mrg rf_fix_old_label_size(RF_ComponentLabel_t *clabel, uint64_t numsecs)
3143 1.278 mrg {
3144 1.278 mrg
3145 1.284 mrg if (numsecs < ((uint64_t)1 << 32)) {
3146 1.284 mrg if (clabel->numBlocksHi) {
3147 1.284 mrg printf("WARNING: total sectors < 32 bits, yet "
3148 1.284 mrg "numBlocksHi set\n"
3149 1.284 mrg "WARNING: resetting numBlocksHi to zero.\n");
3150 1.284 mrg clabel->numBlocksHi = 0;
3151 1.284 mrg }
3152 1.284 mrg
3153 1.284 mrg if (clabel->partitionSizeHi) {
3154 1.284 mrg printf("WARNING: total sectors < 32 bits, yet "
3155 1.284 mrg "partitionSizeHi set\n"
3156 1.284 mrg "WARNING: resetting partitionSizeHi to zero.\n");
3157 1.284 mrg clabel->partitionSizeHi = 0;
3158 1.284 mrg }
3159 1.278 mrg }
3160 1.278 mrg }
3161 1.278 mrg
3162 1.278 mrg
3163 1.224 oster #ifdef DEBUG
3164 1.48 oster void
3165 1.169 oster rf_print_component_label(RF_ComponentLabel_t *clabel)
3166 1.48 oster {
3167 1.282 enami uint64_t numBlocks;
3168 1.308 christos static const char *rp[] = {
3169 1.308 christos "No", "Force", "Soft", "*invalid*"
3170 1.308 christos };
3171 1.308 christos
3172 1.275 mrg
3173 1.282 enami numBlocks = rf_component_label_numblocks(clabel);
3174 1.275 mrg
3175 1.48 oster printf(" Row: %d Column: %d Num Rows: %d Num Columns: %d\n",
3176 1.186 perry clabel->row, clabel->column,
3177 1.48 oster clabel->num_rows, clabel->num_columns);
3178 1.48 oster printf(" Version: %d Serial Number: %d Mod Counter: %d\n",
3179 1.48 oster clabel->version, clabel->serial_number,
3180 1.48 oster clabel->mod_counter);
3181 1.48 oster printf(" Clean: %s Status: %d\n",
3182 1.271 dyoung clabel->clean ? "Yes" : "No", clabel->status);
3183 1.48 oster printf(" sectPerSU: %d SUsPerPU: %d SUsPerRU: %d\n",
3184 1.48 oster clabel->sectPerSU, clabel->SUsPerPU, clabel->SUsPerRU);
3185 1.275 mrg printf(" RAID Level: %c blocksize: %d numBlocks: %"PRIu64"\n",
3186 1.275 mrg (char) clabel->parityConfig, clabel->blockSize, numBlocks);
3187 1.271 dyoung printf(" Autoconfig: %s\n", clabel->autoconfigure ? "Yes" : "No");
3188 1.308 christos printf(" Root partition: %s\n", rp[clabel->root_partition & 3]);
3189 1.271 dyoung printf(" Last configured as: raid%d\n", clabel->last_unit);
3190 1.51 oster #if 0
3191 1.51 oster printf(" Config order: %d\n", clabel->config_order);
3192 1.51 oster #endif
3193 1.186 perry
3194 1.48 oster }
3195 1.133 oster #endif
3196 1.48 oster
3197 1.393 mrg static RF_ConfigSet_t *
3198 1.169 oster rf_create_auto_sets(RF_AutoConfig_t *ac_list)
3199 1.48 oster {
3200 1.48 oster RF_AutoConfig_t *ac;
3201 1.48 oster RF_ConfigSet_t *config_sets;
3202 1.48 oster RF_ConfigSet_t *cset;
3203 1.48 oster RF_AutoConfig_t *ac_next;
3204 1.48 oster
3205 1.48 oster
3206 1.48 oster config_sets = NULL;
3207 1.48 oster
3208 1.48 oster /* Go through the AutoConfig list, and figure out which components
3209 1.48 oster belong to what sets. */
3210 1.48 oster ac = ac_list;
3211 1.48 oster while(ac!=NULL) {
3212 1.48 oster /* we're going to putz with ac->next, so save it here
3213 1.48 oster for use at the end of the loop */
3214 1.48 oster ac_next = ac->next;
3215 1.48 oster
3216 1.48 oster if (config_sets == NULL) {
3217 1.48 oster /* will need at least this one... */
3218 1.379 chs config_sets = malloc(sizeof(RF_ConfigSet_t),
3219 1.379 chs M_RAIDFRAME, M_WAITOK);
3220 1.48 oster /* this one is easy :) */
3221 1.48 oster config_sets->ac = ac;
3222 1.48 oster config_sets->next = NULL;
3223 1.51 oster config_sets->rootable = 0;
3224 1.48 oster ac->next = NULL;
3225 1.48 oster } else {
3226 1.48 oster /* which set does this component fit into? */
3227 1.48 oster cset = config_sets;
3228 1.48 oster while(cset!=NULL) {
3229 1.49 oster if (rf_does_it_fit(cset, ac)) {
3230 1.86 oster /* looks like it matches... */
3231 1.86 oster ac->next = cset->ac;
3232 1.86 oster cset->ac = ac;
3233 1.48 oster break;
3234 1.48 oster }
3235 1.48 oster cset = cset->next;
3236 1.48 oster }
3237 1.48 oster if (cset==NULL) {
3238 1.48 oster /* didn't find a match above... new set..*/
3239 1.379 chs cset = malloc(sizeof(RF_ConfigSet_t),
3240 1.379 chs M_RAIDFRAME, M_WAITOK);
3241 1.48 oster cset->ac = ac;
3242 1.48 oster ac->next = NULL;
3243 1.48 oster cset->next = config_sets;
3244 1.51 oster cset->rootable = 0;
3245 1.48 oster config_sets = cset;
3246 1.48 oster }
3247 1.48 oster }
3248 1.48 oster ac = ac_next;
3249 1.48 oster }
3250 1.48 oster
3251 1.48 oster
3252 1.48 oster return(config_sets);
3253 1.48 oster }
3254 1.48 oster
3255 1.48 oster static int
3256 1.169 oster rf_does_it_fit(RF_ConfigSet_t *cset, RF_AutoConfig_t *ac)
3257 1.48 oster {
3258 1.48 oster RF_ComponentLabel_t *clabel1, *clabel2;
3259 1.48 oster
3260 1.48 oster /* If this one matches the *first* one in the set, that's good
3261 1.48 oster enough, since the other members of the set would have been
3262 1.48 oster through here too... */
3263 1.60 oster /* note that we are not checking partitionSize here..
3264 1.60 oster
3265 1.60 oster Note that we are also not checking the mod_counters here.
3266 1.299 oster If everything else matches except the mod_counter, that's
3267 1.60 oster good enough for this test. We will deal with the mod_counters
3268 1.186 perry a little later in the autoconfiguration process.
3269 1.60 oster
3270 1.60 oster (clabel1->mod_counter == clabel2->mod_counter) &&
3271 1.81 oster
3272 1.81 oster The reason we don't check for this is that failed disks
3273 1.81 oster will have lower modification counts. If those disks are
3274 1.81 oster not added to the set they used to belong to, then they will
3275 1.81 oster form their own set, which may result in 2 different sets,
3276 1.81 oster for example, competing to be configured at raid0, and
3277 1.81 oster perhaps competing to be the root filesystem set. If the
3278 1.81 oster wrong ones get configured, or both attempt to become /,
3279 1.81 oster weird behaviour and or serious lossage will occur. Thus we
3280 1.81 oster need to bring them into the fold here, and kick them out at
3281 1.81 oster a later point.
3282 1.60 oster
3283 1.60 oster */
3284 1.48 oster
3285 1.48 oster clabel1 = cset->ac->clabel;
3286 1.48 oster clabel2 = ac->clabel;
3287 1.48 oster if ((clabel1->version == clabel2->version) &&
3288 1.48 oster (clabel1->serial_number == clabel2->serial_number) &&
3289 1.48 oster (clabel1->num_rows == clabel2->num_rows) &&
3290 1.48 oster (clabel1->num_columns == clabel2->num_columns) &&
3291 1.48 oster (clabel1->sectPerSU == clabel2->sectPerSU) &&
3292 1.48 oster (clabel1->SUsPerPU == clabel2->SUsPerPU) &&
3293 1.48 oster (clabel1->SUsPerRU == clabel2->SUsPerRU) &&
3294 1.48 oster (clabel1->parityConfig == clabel2->parityConfig) &&
3295 1.48 oster (clabel1->maxOutstanding == clabel2->maxOutstanding) &&
3296 1.48 oster (clabel1->blockSize == clabel2->blockSize) &&
3297 1.282 enami rf_component_label_numblocks(clabel1) ==
3298 1.282 enami rf_component_label_numblocks(clabel2) &&
3299 1.48 oster (clabel1->autoconfigure == clabel2->autoconfigure) &&
3300 1.48 oster (clabel1->root_partition == clabel2->root_partition) &&
3301 1.48 oster (clabel1->last_unit == clabel2->last_unit) &&
3302 1.48 oster (clabel1->config_order == clabel2->config_order)) {
3303 1.48 oster /* if it get's here, it almost *has* to be a match */
3304 1.48 oster } else {
3305 1.186 perry /* it's not consistent with somebody in the set..
3306 1.48 oster punt */
3307 1.48 oster return(0);
3308 1.48 oster }
3309 1.48 oster /* all was fine.. it must fit... */
3310 1.48 oster return(1);
3311 1.48 oster }
3312 1.48 oster
3313 1.393 mrg static int
3314 1.169 oster rf_have_enough_components(RF_ConfigSet_t *cset)
3315 1.48 oster {
3316 1.51 oster RF_AutoConfig_t *ac;
3317 1.51 oster RF_AutoConfig_t *auto_config;
3318 1.51 oster RF_ComponentLabel_t *clabel;
3319 1.166 oster int c;
3320 1.51 oster int num_cols;
3321 1.51 oster int num_missing;
3322 1.86 oster int mod_counter;
3323 1.87 oster int mod_counter_found;
3324 1.88 oster int even_pair_failed;
3325 1.88 oster char parity_type;
3326 1.186 perry
3327 1.51 oster
3328 1.48 oster /* check to see that we have enough 'live' components
3329 1.48 oster of this set. If so, we can configure it if necessary */
3330 1.48 oster
3331 1.51 oster num_cols = cset->ac->clabel->num_columns;
3332 1.88 oster parity_type = cset->ac->clabel->parityConfig;
3333 1.51 oster
3334 1.51 oster /* XXX Check for duplicate components!?!?!? */
3335 1.51 oster
3336 1.86 oster /* Determine what the mod_counter is supposed to be for this set. */
3337 1.86 oster
3338 1.87 oster mod_counter_found = 0;
3339 1.101 oster mod_counter = 0;
3340 1.86 oster ac = cset->ac;
3341 1.86 oster while(ac!=NULL) {
3342 1.87 oster if (mod_counter_found==0) {
3343 1.86 oster mod_counter = ac->clabel->mod_counter;
3344 1.87 oster mod_counter_found = 1;
3345 1.87 oster } else {
3346 1.87 oster if (ac->clabel->mod_counter > mod_counter) {
3347 1.87 oster mod_counter = ac->clabel->mod_counter;
3348 1.87 oster }
3349 1.86 oster }
3350 1.86 oster ac = ac->next;
3351 1.86 oster }
3352 1.86 oster
3353 1.51 oster num_missing = 0;
3354 1.51 oster auto_config = cset->ac;
3355 1.51 oster
3356 1.166 oster even_pair_failed = 0;
3357 1.166 oster for(c=0; c<num_cols; c++) {
3358 1.166 oster ac = auto_config;
3359 1.166 oster while(ac!=NULL) {
3360 1.186 perry if ((ac->clabel->column == c) &&
3361 1.166 oster (ac->clabel->mod_counter == mod_counter)) {
3362 1.166 oster /* it's this one... */
3363 1.224 oster #ifdef DEBUG
3364 1.166 oster printf("Found: %s at %d\n",
3365 1.166 oster ac->devname,c);
3366 1.51 oster #endif
3367 1.166 oster break;
3368 1.51 oster }
3369 1.166 oster ac=ac->next;
3370 1.166 oster }
3371 1.166 oster if (ac==NULL) {
3372 1.51 oster /* Didn't find one here! */
3373 1.88 oster /* special case for RAID 1, especially
3374 1.88 oster where there are more than 2
3375 1.88 oster components (where RAIDframe treats
3376 1.88 oster things a little differently :( ) */
3377 1.166 oster if (parity_type == '1') {
3378 1.166 oster if (c%2 == 0) { /* even component */
3379 1.166 oster even_pair_failed = 1;
3380 1.166 oster } else { /* odd component. If
3381 1.166 oster we're failed, and
3382 1.166 oster so is the even
3383 1.166 oster component, it's
3384 1.166 oster "Good Night, Charlie" */
3385 1.166 oster if (even_pair_failed == 1) {
3386 1.166 oster return(0);
3387 1.88 oster }
3388 1.88 oster }
3389 1.166 oster } else {
3390 1.166 oster /* normal accounting */
3391 1.166 oster num_missing++;
3392 1.88 oster }
3393 1.166 oster }
3394 1.166 oster if ((parity_type == '1') && (c%2 == 1)) {
3395 1.88 oster /* Just did an even component, and we didn't
3396 1.186 perry bail.. reset the even_pair_failed flag,
3397 1.88 oster and go on to the next component.... */
3398 1.166 oster even_pair_failed = 0;
3399 1.51 oster }
3400 1.51 oster }
3401 1.51 oster
3402 1.51 oster clabel = cset->ac->clabel;
3403 1.51 oster
3404 1.51 oster if (((clabel->parityConfig == '0') && (num_missing > 0)) ||
3405 1.51 oster ((clabel->parityConfig == '4') && (num_missing > 1)) ||
3406 1.51 oster ((clabel->parityConfig == '5') && (num_missing > 1))) {
3407 1.51 oster /* XXX this needs to be made *much* more general */
3408 1.51 oster /* Too many failures */
3409 1.51 oster return(0);
3410 1.51 oster }
3411 1.51 oster /* otherwise, all is well, and we've got enough to take a kick
3412 1.51 oster at autoconfiguring this set */
3413 1.51 oster return(1);
3414 1.48 oster }
3415 1.48 oster
3416 1.393 mrg static void
3417 1.169 oster rf_create_configuration(RF_AutoConfig_t *ac, RF_Config_t *config,
3418 1.222 christos RF_Raid_t *raidPtr)
3419 1.48 oster {
3420 1.48 oster RF_ComponentLabel_t *clabel;
3421 1.77 oster int i;
3422 1.48 oster
3423 1.48 oster clabel = ac->clabel;
3424 1.48 oster
3425 1.48 oster /* 1. Fill in the common stuff */
3426 1.48 oster config->numCol = clabel->num_columns;
3427 1.48 oster config->numSpare = 0; /* XXX should this be set here? */
3428 1.48 oster config->sectPerSU = clabel->sectPerSU;
3429 1.48 oster config->SUsPerPU = clabel->SUsPerPU;
3430 1.48 oster config->SUsPerRU = clabel->SUsPerRU;
3431 1.48 oster config->parityConfig = clabel->parityConfig;
3432 1.48 oster /* XXX... */
3433 1.48 oster strcpy(config->diskQueueType,"fifo");
3434 1.48 oster config->maxOutstandingDiskReqs = clabel->maxOutstanding;
3435 1.48 oster config->layoutSpecificSize = 0; /* XXX ?? */
3436 1.48 oster
3437 1.48 oster while(ac!=NULL) {
3438 1.48 oster /* row/col values will be in range due to the checks
3439 1.48 oster in reasonable_label() */
3440 1.166 oster strcpy(config->devnames[0][ac->clabel->column],
3441 1.48 oster ac->devname);
3442 1.48 oster ac = ac->next;
3443 1.48 oster }
3444 1.48 oster
3445 1.77 oster for(i=0;i<RF_MAXDBGV;i++) {
3446 1.163 fvdl config->debugVars[i][0] = 0;
3447 1.77 oster }
3448 1.48 oster }
3449 1.48 oster
3450 1.393 mrg static int
3451 1.169 oster rf_set_autoconfig(RF_Raid_t *raidPtr, int new_value)
3452 1.48 oster {
3453 1.269 jld RF_ComponentLabel_t *clabel;
3454 1.166 oster int column;
3455 1.148 oster int sparecol;
3456 1.48 oster
3457 1.54 oster raidPtr->autoconfigure = new_value;
3458 1.166 oster
3459 1.166 oster for(column=0; column<raidPtr->numCol; column++) {
3460 1.166 oster if (raidPtr->Disks[column].status == rf_ds_optimal) {
3461 1.269 jld clabel = raidget_component_label(raidPtr, column);
3462 1.269 jld clabel->autoconfigure = new_value;
3463 1.269 jld raidflush_component_label(raidPtr, column);
3464 1.48 oster }
3465 1.48 oster }
3466 1.148 oster for(column = 0; column < raidPtr->numSpare ; column++) {
3467 1.148 oster sparecol = raidPtr->numCol + column;
3468 1.166 oster if (raidPtr->Disks[sparecol].status == rf_ds_used_spare) {
3469 1.269 jld clabel = raidget_component_label(raidPtr, sparecol);
3470 1.269 jld clabel->autoconfigure = new_value;
3471 1.269 jld raidflush_component_label(raidPtr, sparecol);
3472 1.148 oster }
3473 1.148 oster }
3474 1.48 oster return(new_value);
3475 1.48 oster }
3476 1.48 oster
3477 1.393 mrg static int
3478 1.169 oster rf_set_rootpartition(RF_Raid_t *raidPtr, int new_value)
3479 1.48 oster {
3480 1.269 jld RF_ComponentLabel_t *clabel;
3481 1.166 oster int column;
3482 1.148 oster int sparecol;
3483 1.48 oster
3484 1.54 oster raidPtr->root_partition = new_value;
3485 1.166 oster for(column=0; column<raidPtr->numCol; column++) {
3486 1.166 oster if (raidPtr->Disks[column].status == rf_ds_optimal) {
3487 1.269 jld clabel = raidget_component_label(raidPtr, column);
3488 1.269 jld clabel->root_partition = new_value;
3489 1.269 jld raidflush_component_label(raidPtr, column);
3490 1.148 oster }
3491 1.148 oster }
3492 1.148 oster for(column = 0; column < raidPtr->numSpare ; column++) {
3493 1.148 oster sparecol = raidPtr->numCol + column;
3494 1.166 oster if (raidPtr->Disks[sparecol].status == rf_ds_used_spare) {
3495 1.269 jld clabel = raidget_component_label(raidPtr, sparecol);
3496 1.269 jld clabel->root_partition = new_value;
3497 1.269 jld raidflush_component_label(raidPtr, sparecol);
3498 1.48 oster }
3499 1.48 oster }
3500 1.48 oster return(new_value);
3501 1.48 oster }
3502 1.48 oster
3503 1.393 mrg static void
3504 1.169 oster rf_release_all_vps(RF_ConfigSet_t *cset)
3505 1.48 oster {
3506 1.48 oster RF_AutoConfig_t *ac;
3507 1.186 perry
3508 1.48 oster ac = cset->ac;
3509 1.48 oster while(ac!=NULL) {
3510 1.48 oster /* Close the vp, and give it back */
3511 1.48 oster if (ac->vp) {
3512 1.96 oster vn_lock(ac->vp, LK_EXCLUSIVE | LK_RETRY);
3513 1.335 mlelstv VOP_CLOSE(ac->vp, FREAD | FWRITE, NOCRED);
3514 1.48 oster vput(ac->vp);
3515 1.86 oster ac->vp = NULL;
3516 1.48 oster }
3517 1.48 oster ac = ac->next;
3518 1.48 oster }
3519 1.48 oster }
3520 1.48 oster
3521 1.48 oster
3522 1.393 mrg static void
3523 1.169 oster rf_cleanup_config_set(RF_ConfigSet_t *cset)
3524 1.48 oster {
3525 1.48 oster RF_AutoConfig_t *ac;
3526 1.48 oster RF_AutoConfig_t *next_ac;
3527 1.186 perry
3528 1.48 oster ac = cset->ac;
3529 1.48 oster while(ac!=NULL) {
3530 1.48 oster next_ac = ac->next;
3531 1.48 oster /* nuke the label */
3532 1.48 oster free(ac->clabel, M_RAIDFRAME);
3533 1.48 oster /* cleanup the config structure */
3534 1.48 oster free(ac, M_RAIDFRAME);
3535 1.48 oster /* "next.." */
3536 1.48 oster ac = next_ac;
3537 1.48 oster }
3538 1.48 oster /* and, finally, nuke the config set */
3539 1.48 oster free(cset, M_RAIDFRAME);
3540 1.48 oster }
3541 1.48 oster
3542 1.48 oster
3543 1.48 oster void
3544 1.169 oster raid_init_component_label(RF_Raid_t *raidPtr, RF_ComponentLabel_t *clabel)
3545 1.48 oster {
3546 1.394 mrg /* avoid over-writing byteswapped version. */
3547 1.394 mrg if (clabel->version != bswap32(RF_COMPONENT_LABEL_VERSION))
3548 1.394 mrg clabel->version = RF_COMPONENT_LABEL_VERSION;
3549 1.57 oster clabel->serial_number = raidPtr->serial_number;
3550 1.48 oster clabel->mod_counter = raidPtr->mod_counter;
3551 1.269 jld
3552 1.166 oster clabel->num_rows = 1;
3553 1.48 oster clabel->num_columns = raidPtr->numCol;
3554 1.48 oster clabel->clean = RF_RAID_DIRTY; /* not clean */
3555 1.48 oster clabel->status = rf_ds_optimal; /* "It's good!" */
3556 1.186 perry
3557 1.48 oster clabel->sectPerSU = raidPtr->Layout.sectorsPerStripeUnit;
3558 1.48 oster clabel->SUsPerPU = raidPtr->Layout.SUsPerPU;
3559 1.48 oster clabel->SUsPerRU = raidPtr->Layout.SUsPerRU;
3560 1.54 oster
3561 1.54 oster clabel->blockSize = raidPtr->bytesPerSector;
3562 1.282 enami rf_component_label_set_numblocks(clabel, raidPtr->sectorsPerDisk);
3563 1.54 oster
3564 1.48 oster /* XXX not portable */
3565 1.48 oster clabel->parityConfig = raidPtr->Layout.map->parityConfig;
3566 1.54 oster clabel->maxOutstanding = raidPtr->maxOutstanding;
3567 1.54 oster clabel->autoconfigure = raidPtr->autoconfigure;
3568 1.54 oster clabel->root_partition = raidPtr->root_partition;
3569 1.48 oster clabel->last_unit = raidPtr->raidid;
3570 1.54 oster clabel->config_order = raidPtr->config_order;
3571 1.269 jld
3572 1.269 jld #ifndef RF_NO_PARITY_MAP
3573 1.269 jld rf_paritymap_init_label(raidPtr->parity_map, clabel);
3574 1.269 jld #endif
3575 1.51 oster }
3576 1.51 oster
3577 1.393 mrg static struct raid_softc *
3578 1.300 christos rf_auto_config_set(RF_ConfigSet_t *cset)
3579 1.51 oster {
3580 1.51 oster RF_Raid_t *raidPtr;
3581 1.51 oster RF_Config_t *config;
3582 1.51 oster int raidID;
3583 1.300 christos struct raid_softc *sc;
3584 1.51 oster
3585 1.224 oster #ifdef DEBUG
3586 1.72 oster printf("RAID autoconfigure\n");
3587 1.127 oster #endif
3588 1.51 oster
3589 1.51 oster /* 1. Create a config structure */
3590 1.379 chs config = malloc(sizeof(*config), M_RAIDFRAME, M_WAITOK|M_ZERO);
3591 1.77 oster
3592 1.186 perry /*
3593 1.186 perry 2. Figure out what RAID ID this one is supposed to live at
3594 1.51 oster See if we can get the same RAID dev that it was configured
3595 1.186 perry on last time..
3596 1.51 oster */
3597 1.51 oster
3598 1.51 oster raidID = cset->ac->clabel->last_unit;
3599 1.327 pgoyette for (sc = raidget(raidID, false); sc && sc->sc_r.valid != 0;
3600 1.327 pgoyette sc = raidget(++raidID, false))
3601 1.300 christos continue;
3602 1.224 oster #ifdef DEBUG
3603 1.72 oster printf("Configuring raid%d:\n",raidID);
3604 1.127 oster #endif
3605 1.127 oster
3606 1.327 pgoyette if (sc == NULL)
3607 1.327 pgoyette sc = raidget(raidID, true);
3608 1.300 christos raidPtr = &sc->sc_r;
3609 1.51 oster
3610 1.51 oster /* XXX all this stuff should be done SOMEWHERE ELSE! */
3611 1.302 christos raidPtr->softc = sc;
3612 1.51 oster raidPtr->raidid = raidID;
3613 1.51 oster raidPtr->openings = RAIDOUTSTANDING;
3614 1.51 oster
3615 1.51 oster /* 3. Build the configuration structure */
3616 1.51 oster rf_create_configuration(cset->ac, config, raidPtr);
3617 1.51 oster
3618 1.51 oster /* 4. Do the configuration */
3619 1.300 christos if (rf_Configure(raidPtr, config, cset->ac) == 0) {
3620 1.300 christos raidinit(sc);
3621 1.186 perry
3622 1.300 christos rf_markalldirty(raidPtr);
3623 1.300 christos raidPtr->autoconfigure = 1; /* XXX do this here? */
3624 1.308 christos switch (cset->ac->clabel->root_partition) {
3625 1.308 christos case 1: /* Force Root */
3626 1.308 christos case 2: /* Soft Root: root when boot partition part of raid */
3627 1.308 christos /*
3628 1.308 christos * everything configured just fine. Make a note
3629 1.308 christos * that this set is eligible to be root,
3630 1.308 christos * or forced to be root
3631 1.308 christos */
3632 1.308 christos cset->rootable = cset->ac->clabel->root_partition;
3633 1.54 oster /* XXX do this here? */
3634 1.308 christos raidPtr->root_partition = cset->rootable;
3635 1.308 christos break;
3636 1.308 christos default:
3637 1.308 christos break;
3638 1.51 oster }
3639 1.300 christos } else {
3640 1.300 christos raidput(sc);
3641 1.300 christos sc = NULL;
3642 1.51 oster }
3643 1.51 oster
3644 1.51 oster /* 5. Cleanup */
3645 1.51 oster free(config, M_RAIDFRAME);
3646 1.300 christos return sc;
3647 1.99 oster }
3648 1.99 oster
3649 1.99 oster void
3650 1.395 oster rf_pool_init(RF_Raid_t *raidPtr, char *w_chan, struct pool *p, size_t size, const char *pool_name,
3651 1.187 christos size_t xmin, size_t xmax)
3652 1.177 oster {
3653 1.352 christos
3654 1.395 oster /* Format: raid%d_foo */
3655 1.395 oster snprintf(w_chan, RF_MAX_POOLNAMELEN, "raid%d_%s", raidPtr->raidid, pool_name);
3656 1.395 oster
3657 1.227 ad pool_init(p, size, 0, 0, 0, w_chan, NULL, IPL_BIO);
3658 1.187 christos pool_sethiwat(p, xmax);
3659 1.382 chs pool_prime(p, xmin);
3660 1.177 oster }
3661 1.190 oster
3662 1.395 oster
3663 1.190 oster /*
3664 1.335 mlelstv * rf_buf_queue_check(RF_Raid_t raidPtr) -- looks into the buffer queue
3665 1.335 mlelstv * to see if there is IO pending and if that IO could possibly be done
3666 1.335 mlelstv * for a given RAID set. Returns 0 if IO is waiting and can be done, 1
3667 1.190 oster * otherwise.
3668 1.190 oster *
3669 1.190 oster */
3670 1.190 oster int
3671 1.300 christos rf_buf_queue_check(RF_Raid_t *raidPtr)
3672 1.190 oster {
3673 1.335 mlelstv struct raid_softc *rs;
3674 1.335 mlelstv struct dk_softc *dksc;
3675 1.335 mlelstv
3676 1.335 mlelstv rs = raidPtr->softc;
3677 1.335 mlelstv dksc = &rs->sc_dksc;
3678 1.335 mlelstv
3679 1.335 mlelstv if ((rs->sc_flags & RAIDF_INITED) == 0)
3680 1.335 mlelstv return 1;
3681 1.335 mlelstv
3682 1.335 mlelstv if (dk_strategy_pending(dksc) && raidPtr->openings > 0) {
3683 1.190 oster /* there is work to do */
3684 1.190 oster return 0;
3685 1.335 mlelstv }
3686 1.190 oster /* default is nothing to do */
3687 1.190 oster return 1;
3688 1.190 oster }
3689 1.213 christos
3690 1.213 christos int
3691 1.294 oster rf_getdisksize(struct vnode *vp, RF_RaidDisk_t *diskPtr)
3692 1.213 christos {
3693 1.275 mrg uint64_t numsecs;
3694 1.275 mrg unsigned secsize;
3695 1.213 christos int error;
3696 1.213 christos
3697 1.275 mrg error = getdisksize(vp, &numsecs, &secsize);
3698 1.213 christos if (error == 0) {
3699 1.275 mrg diskPtr->blockSize = secsize;
3700 1.275 mrg diskPtr->numBlocks = numsecs - rf_protectedSectors;
3701 1.275 mrg diskPtr->partitionSize = numsecs;
3702 1.213 christos return 0;
3703 1.213 christos }
3704 1.213 christos return error;
3705 1.213 christos }
3706 1.217 oster
3707 1.217 oster static int
3708 1.261 dyoung raid_match(device_t self, cfdata_t cfdata, void *aux)
3709 1.217 oster {
3710 1.217 oster return 1;
3711 1.217 oster }
3712 1.217 oster
3713 1.217 oster static void
3714 1.261 dyoung raid_attach(device_t parent, device_t self, void *aux)
3715 1.217 oster {
3716 1.217 oster }
3717 1.217 oster
3718 1.217 oster
3719 1.217 oster static int
3720 1.261 dyoung raid_detach(device_t self, int flags)
3721 1.217 oster {
3722 1.266 dyoung int error;
3723 1.335 mlelstv struct raid_softc *rs = raidsoftc(self);
3724 1.303 christos
3725 1.303 christos if (rs == NULL)
3726 1.303 christos return ENXIO;
3727 1.266 dyoung
3728 1.266 dyoung if ((error = raidlock(rs)) != 0)
3729 1.389 skrll return error;
3730 1.217 oster
3731 1.266 dyoung error = raid_detach_unlocked(rs);
3732 1.266 dyoung
3733 1.332 mlelstv raidunlock(rs);
3734 1.332 mlelstv
3735 1.332 mlelstv /* XXX raid can be referenced here */
3736 1.332 mlelstv
3737 1.332 mlelstv if (error)
3738 1.332 mlelstv return error;
3739 1.332 mlelstv
3740 1.332 mlelstv /* Free the softc */
3741 1.332 mlelstv raidput(rs);
3742 1.332 mlelstv
3743 1.332 mlelstv return 0;
3744 1.217 oster }
3745 1.217 oster
3746 1.234 oster static void
3747 1.304 christos rf_set_geometry(struct raid_softc *rs, RF_Raid_t *raidPtr)
3748 1.234 oster {
3749 1.335 mlelstv struct dk_softc *dksc = &rs->sc_dksc;
3750 1.335 mlelstv struct disk_geom *dg = &dksc->sc_dkdev.dk_geom;
3751 1.304 christos
3752 1.304 christos memset(dg, 0, sizeof(*dg));
3753 1.304 christos
3754 1.304 christos dg->dg_secperunit = raidPtr->totalSectors;
3755 1.304 christos dg->dg_secsize = raidPtr->bytesPerSector;
3756 1.304 christos dg->dg_nsectors = raidPtr->Layout.dataSectorsPerStripe;
3757 1.304 christos dg->dg_ntracks = 4 * raidPtr->numCol;
3758 1.304 christos
3759 1.335 mlelstv disk_set_info(dksc->sc_dev, &dksc->sc_dkdev, NULL);
3760 1.234 oster }
3761 1.252 oster
3762 1.348 jdolecek /*
3763 1.348 jdolecek * Get cache info for all the components (including spares).
3764 1.348 jdolecek * Returns intersection of all the cache flags of all disks, or first
3765 1.348 jdolecek * error if any encountered.
3766 1.348 jdolecek * XXXfua feature flags can change as spares are added - lock down somehow
3767 1.348 jdolecek */
3768 1.348 jdolecek static int
3769 1.348 jdolecek rf_get_component_caches(RF_Raid_t *raidPtr, int *data)
3770 1.348 jdolecek {
3771 1.348 jdolecek int c;
3772 1.348 jdolecek int error;
3773 1.348 jdolecek int dkwhole = 0, dkpart;
3774 1.385 riastrad
3775 1.348 jdolecek for (c = 0; c < raidPtr->numCol + raidPtr->numSpare; c++) {
3776 1.348 jdolecek /*
3777 1.348 jdolecek * Check any non-dead disk, even when currently being
3778 1.348 jdolecek * reconstructed.
3779 1.348 jdolecek */
3780 1.348 jdolecek if (!RF_DEAD_DISK(raidPtr->Disks[c].status)
3781 1.348 jdolecek || raidPtr->Disks[c].status == rf_ds_reconstructing) {
3782 1.348 jdolecek error = VOP_IOCTL(raidPtr->raid_cinfo[c].ci_vp,
3783 1.348 jdolecek DIOCGCACHE, &dkpart, FREAD, NOCRED);
3784 1.348 jdolecek if (error) {
3785 1.348 jdolecek if (error != ENODEV) {
3786 1.348 jdolecek printf("raid%d: get cache for component %s failed\n",
3787 1.348 jdolecek raidPtr->raidid,
3788 1.348 jdolecek raidPtr->Disks[c].devname);
3789 1.348 jdolecek }
3790 1.348 jdolecek
3791 1.348 jdolecek return error;
3792 1.348 jdolecek }
3793 1.348 jdolecek
3794 1.348 jdolecek if (c == 0)
3795 1.348 jdolecek dkwhole = dkpart;
3796 1.348 jdolecek else
3797 1.348 jdolecek dkwhole = DKCACHE_COMBINE(dkwhole, dkpart);
3798 1.348 jdolecek }
3799 1.348 jdolecek }
3800 1.348 jdolecek
3801 1.349 jdolecek *data = dkwhole;
3802 1.348 jdolecek
3803 1.348 jdolecek return 0;
3804 1.348 jdolecek }
3805 1.348 jdolecek
3806 1.385 riastrad /*
3807 1.252 oster * Implement forwarding of the DIOCCACHESYNC ioctl to each of the components.
3808 1.252 oster * We end up returning whatever error was returned by the first cache flush
3809 1.252 oster * that fails.
3810 1.252 oster */
3811 1.252 oster
3812 1.386 christos static int
3813 1.390 christos rf_sync_component_cache(RF_Raid_t *raidPtr, int c, int force)
3814 1.386 christos {
3815 1.386 christos int e = 0;
3816 1.386 christos for (int i = 0; i < 5; i++) {
3817 1.386 christos e = VOP_IOCTL(raidPtr->raid_cinfo[c].ci_vp, DIOCCACHESYNC,
3818 1.386 christos &force, FWRITE, NOCRED);
3819 1.386 christos if (!e || e == ENODEV)
3820 1.386 christos return e;
3821 1.386 christos printf("raid%d: cache flush[%d] to component %s failed (%d)\n",
3822 1.386 christos raidPtr->raidid, i, raidPtr->Disks[c].devname, e);
3823 1.386 christos }
3824 1.387 christos return e;
3825 1.386 christos }
3826 1.386 christos
3827 1.269 jld int
3828 1.390 christos rf_sync_component_caches(RF_Raid_t *raidPtr, int force)
3829 1.252 oster {
3830 1.386 christos int c, error;
3831 1.385 riastrad
3832 1.252 oster error = 0;
3833 1.252 oster for (c = 0; c < raidPtr->numCol; c++) {
3834 1.252 oster if (raidPtr->Disks[c].status == rf_ds_optimal) {
3835 1.390 christos int e = rf_sync_component_cache(raidPtr, c, force);
3836 1.387 christos if (e && !error)
3837 1.386 christos error = e;
3838 1.252 oster }
3839 1.252 oster }
3840 1.252 oster
3841 1.386 christos for (c = 0; c < raidPtr->numSpare ; c++) {
3842 1.386 christos int sparecol = raidPtr->numCol + c;
3843 1.252 oster /* Need to ensure that the reconstruct actually completed! */
3844 1.252 oster if (raidPtr->Disks[sparecol].status == rf_ds_used_spare) {
3845 1.390 christos int e = rf_sync_component_cache(raidPtr, sparecol,
3846 1.390 christos force);
3847 1.387 christos if (e && !error)
3848 1.386 christos error = e;
3849 1.252 oster }
3850 1.252 oster }
3851 1.252 oster return error;
3852 1.252 oster }
3853 1.327 pgoyette
3854 1.353 mrg /* Fill in info with the current status */
3855 1.353 mrg void
3856 1.353 mrg rf_check_recon_status_ext(RF_Raid_t *raidPtr, RF_ProgressInfo_t *info)
3857 1.353 mrg {
3858 1.353 mrg
3859 1.401 riastrad memset(info, 0, sizeof(*info));
3860 1.401 riastrad
3861 1.353 mrg if (raidPtr->status != rf_rs_reconstructing) {
3862 1.353 mrg info->total = 100;
3863 1.353 mrg info->completed = 100;
3864 1.353 mrg } else {
3865 1.353 mrg info->total = raidPtr->reconControl->numRUsTotal;
3866 1.353 mrg info->completed = raidPtr->reconControl->numRUsComplete;
3867 1.353 mrg }
3868 1.353 mrg info->remaining = info->total - info->completed;
3869 1.353 mrg }
3870 1.353 mrg
3871 1.353 mrg /* Fill in info with the current status */
3872 1.353 mrg void
3873 1.353 mrg rf_check_parityrewrite_status_ext(RF_Raid_t *raidPtr, RF_ProgressInfo_t *info)
3874 1.353 mrg {
3875 1.353 mrg
3876 1.401 riastrad memset(info, 0, sizeof(*info));
3877 1.401 riastrad
3878 1.353 mrg if (raidPtr->parity_rewrite_in_progress == 1) {
3879 1.353 mrg info->total = raidPtr->Layout.numStripe;
3880 1.353 mrg info->completed = raidPtr->parity_rewrite_stripes_done;
3881 1.353 mrg } else {
3882 1.353 mrg info->completed = 100;
3883 1.353 mrg info->total = 100;
3884 1.353 mrg }
3885 1.353 mrg info->remaining = info->total - info->completed;
3886 1.353 mrg }
3887 1.353 mrg
3888 1.353 mrg /* Fill in info with the current status */
3889 1.353 mrg void
3890 1.353 mrg rf_check_copyback_status_ext(RF_Raid_t *raidPtr, RF_ProgressInfo_t *info)
3891 1.353 mrg {
3892 1.353 mrg
3893 1.401 riastrad memset(info, 0, sizeof(*info));
3894 1.401 riastrad
3895 1.353 mrg if (raidPtr->copyback_in_progress == 1) {
3896 1.353 mrg info->total = raidPtr->Layout.numStripe;
3897 1.353 mrg info->completed = raidPtr->copyback_stripes_done;
3898 1.353 mrg info->remaining = info->total - info->completed;
3899 1.353 mrg } else {
3900 1.353 mrg info->remaining = 0;
3901 1.353 mrg info->completed = 100;
3902 1.353 mrg info->total = 100;
3903 1.353 mrg }
3904 1.353 mrg }
3905 1.353 mrg
3906 1.353 mrg /* Fill in config with the current info */
3907 1.353 mrg int
3908 1.353 mrg rf_get_info(RF_Raid_t *raidPtr, RF_DeviceConfig_t *config)
3909 1.353 mrg {
3910 1.353 mrg int d, i, j;
3911 1.353 mrg
3912 1.353 mrg if (!raidPtr->valid)
3913 1.389 skrll return ENODEV;
3914 1.353 mrg config->cols = raidPtr->numCol;
3915 1.353 mrg config->ndevs = raidPtr->numCol;
3916 1.353 mrg if (config->ndevs >= RF_MAX_DISKS)
3917 1.389 skrll return ENOMEM;
3918 1.353 mrg config->nspares = raidPtr->numSpare;
3919 1.353 mrg if (config->nspares >= RF_MAX_DISKS)
3920 1.389 skrll return ENOMEM;
3921 1.353 mrg config->maxqdepth = raidPtr->maxQueueDepth;
3922 1.353 mrg d = 0;
3923 1.353 mrg for (j = 0; j < config->cols; j++) {
3924 1.353 mrg config->devs[d] = raidPtr->Disks[j];
3925 1.353 mrg d++;
3926 1.353 mrg }
3927 1.353 mrg for (j = config->cols, i = 0; i < config->nspares; i++, j++) {
3928 1.353 mrg config->spares[i] = raidPtr->Disks[j];
3929 1.353 mrg if (config->spares[i].status == rf_ds_rebuilding_spare) {
3930 1.353 mrg /* XXX: raidctl(8) expects to see this as a used spare */
3931 1.353 mrg config->spares[i].status = rf_ds_used_spare;
3932 1.353 mrg }
3933 1.353 mrg }
3934 1.353 mrg return 0;
3935 1.353 mrg }
3936 1.353 mrg
3937 1.353 mrg int
3938 1.353 mrg rf_get_component_label(RF_Raid_t *raidPtr, void *data)
3939 1.353 mrg {
3940 1.353 mrg RF_ComponentLabel_t *clabel = (RF_ComponentLabel_t *)data;
3941 1.353 mrg RF_ComponentLabel_t *raid_clabel;
3942 1.353 mrg int column = clabel->column;
3943 1.353 mrg
3944 1.353 mrg if ((column < 0) || (column >= raidPtr->numCol + raidPtr->numSpare))
3945 1.353 mrg return EINVAL;
3946 1.353 mrg raid_clabel = raidget_component_label(raidPtr, column);
3947 1.353 mrg memcpy(clabel, raid_clabel, sizeof *clabel);
3948 1.394 mrg /* Fix-up for userland. */
3949 1.394 mrg if (clabel->version == bswap32(RF_COMPONENT_LABEL_VERSION))
3950 1.394 mrg clabel->version = RF_COMPONENT_LABEL_VERSION;
3951 1.353 mrg
3952 1.353 mrg return 0;
3953 1.353 mrg }
3954 1.353 mrg
3955 1.327 pgoyette /*
3956 1.327 pgoyette * Module interface
3957 1.327 pgoyette */
3958 1.327 pgoyette
3959 1.356 pgoyette MODULE(MODULE_CLASS_DRIVER, raid, "dk_subr,bufq_fcfs");
3960 1.327 pgoyette
3961 1.327 pgoyette #ifdef _MODULE
3962 1.327 pgoyette CFDRIVER_DECL(raid, DV_DISK, NULL);
3963 1.327 pgoyette #endif
3964 1.327 pgoyette
3965 1.327 pgoyette static int raid_modcmd(modcmd_t, void *);
3966 1.327 pgoyette static int raid_modcmd_init(void);
3967 1.327 pgoyette static int raid_modcmd_fini(void);
3968 1.327 pgoyette
3969 1.327 pgoyette static int
3970 1.327 pgoyette raid_modcmd(modcmd_t cmd, void *data)
3971 1.327 pgoyette {
3972 1.327 pgoyette int error;
3973 1.327 pgoyette
3974 1.327 pgoyette error = 0;
3975 1.327 pgoyette switch (cmd) {
3976 1.327 pgoyette case MODULE_CMD_INIT:
3977 1.327 pgoyette error = raid_modcmd_init();
3978 1.327 pgoyette break;
3979 1.327 pgoyette case MODULE_CMD_FINI:
3980 1.327 pgoyette error = raid_modcmd_fini();
3981 1.327 pgoyette break;
3982 1.327 pgoyette default:
3983 1.327 pgoyette error = ENOTTY;
3984 1.327 pgoyette break;
3985 1.327 pgoyette }
3986 1.327 pgoyette return error;
3987 1.327 pgoyette }
3988 1.327 pgoyette
3989 1.327 pgoyette static int
3990 1.327 pgoyette raid_modcmd_init(void)
3991 1.327 pgoyette {
3992 1.327 pgoyette int error;
3993 1.327 pgoyette int bmajor, cmajor;
3994 1.327 pgoyette
3995 1.327 pgoyette mutex_init(&raid_lock, MUTEX_DEFAULT, IPL_NONE);
3996 1.327 pgoyette mutex_enter(&raid_lock);
3997 1.327 pgoyette #if (RF_INCLUDE_PARITY_DECLUSTERING_DS > 0)
3998 1.327 pgoyette rf_init_mutex2(rf_sparet_wait_mutex, IPL_VM);
3999 1.327 pgoyette rf_init_cond2(rf_sparet_wait_cv, "sparetw");
4000 1.327 pgoyette rf_init_cond2(rf_sparet_resp_cv, "rfgst");
4001 1.327 pgoyette
4002 1.327 pgoyette rf_sparet_wait_queue = rf_sparet_resp_queue = NULL;
4003 1.327 pgoyette #endif
4004 1.327 pgoyette
4005 1.327 pgoyette bmajor = cmajor = -1;
4006 1.327 pgoyette error = devsw_attach("raid", &raid_bdevsw, &bmajor,
4007 1.327 pgoyette &raid_cdevsw, &cmajor);
4008 1.327 pgoyette if (error != 0 && error != EEXIST) {
4009 1.327 pgoyette aprint_error("%s: devsw_attach failed %d\n", __func__, error);
4010 1.327 pgoyette mutex_exit(&raid_lock);
4011 1.327 pgoyette return error;
4012 1.327 pgoyette }
4013 1.327 pgoyette #ifdef _MODULE
4014 1.327 pgoyette error = config_cfdriver_attach(&raid_cd);
4015 1.327 pgoyette if (error != 0) {
4016 1.327 pgoyette aprint_error("%s: config_cfdriver_attach failed %d\n",
4017 1.327 pgoyette __func__, error);
4018 1.327 pgoyette devsw_detach(&raid_bdevsw, &raid_cdevsw);
4019 1.327 pgoyette mutex_exit(&raid_lock);
4020 1.327 pgoyette return error;
4021 1.327 pgoyette }
4022 1.327 pgoyette #endif
4023 1.327 pgoyette error = config_cfattach_attach(raid_cd.cd_name, &raid_ca);
4024 1.327 pgoyette if (error != 0) {
4025 1.327 pgoyette aprint_error("%s: config_cfattach_attach failed %d\n",
4026 1.327 pgoyette __func__, error);
4027 1.327 pgoyette #ifdef _MODULE
4028 1.327 pgoyette config_cfdriver_detach(&raid_cd);
4029 1.327 pgoyette #endif
4030 1.327 pgoyette devsw_detach(&raid_bdevsw, &raid_cdevsw);
4031 1.327 pgoyette mutex_exit(&raid_lock);
4032 1.327 pgoyette return error;
4033 1.327 pgoyette }
4034 1.327 pgoyette
4035 1.327 pgoyette raidautoconfigdone = false;
4036 1.327 pgoyette
4037 1.327 pgoyette mutex_exit(&raid_lock);
4038 1.327 pgoyette
4039 1.327 pgoyette if (error == 0) {
4040 1.327 pgoyette if (rf_BootRaidframe(true) == 0)
4041 1.327 pgoyette aprint_verbose("Kernelized RAIDframe activated\n");
4042 1.327 pgoyette else
4043 1.327 pgoyette panic("Serious error activating RAID!!");
4044 1.327 pgoyette }
4045 1.327 pgoyette
4046 1.327 pgoyette /*
4047 1.327 pgoyette * Register a finalizer which will be used to auto-config RAID
4048 1.327 pgoyette * sets once all real hardware devices have been found.
4049 1.327 pgoyette */
4050 1.327 pgoyette error = config_finalize_register(NULL, rf_autoconfig);
4051 1.327 pgoyette if (error != 0) {
4052 1.327 pgoyette aprint_error("WARNING: unable to register RAIDframe "
4053 1.327 pgoyette "finalizer\n");
4054 1.329 pgoyette error = 0;
4055 1.327 pgoyette }
4056 1.327 pgoyette
4057 1.327 pgoyette return error;
4058 1.327 pgoyette }
4059 1.327 pgoyette
4060 1.327 pgoyette static int
4061 1.327 pgoyette raid_modcmd_fini(void)
4062 1.327 pgoyette {
4063 1.327 pgoyette int error;
4064 1.327 pgoyette
4065 1.327 pgoyette mutex_enter(&raid_lock);
4066 1.327 pgoyette
4067 1.327 pgoyette /* Don't allow unload if raid device(s) exist. */
4068 1.327 pgoyette if (!LIST_EMPTY(&raids)) {
4069 1.327 pgoyette mutex_exit(&raid_lock);
4070 1.327 pgoyette return EBUSY;
4071 1.327 pgoyette }
4072 1.327 pgoyette
4073 1.327 pgoyette error = config_cfattach_detach(raid_cd.cd_name, &raid_ca);
4074 1.327 pgoyette if (error != 0) {
4075 1.335 mlelstv aprint_error("%s: cannot detach cfattach\n",__func__);
4076 1.327 pgoyette mutex_exit(&raid_lock);
4077 1.327 pgoyette return error;
4078 1.327 pgoyette }
4079 1.327 pgoyette #ifdef _MODULE
4080 1.327 pgoyette error = config_cfdriver_detach(&raid_cd);
4081 1.327 pgoyette if (error != 0) {
4082 1.335 mlelstv aprint_error("%s: cannot detach cfdriver\n",__func__);
4083 1.327 pgoyette config_cfattach_attach(raid_cd.cd_name, &raid_ca);
4084 1.327 pgoyette mutex_exit(&raid_lock);
4085 1.327 pgoyette return error;
4086 1.327 pgoyette }
4087 1.327 pgoyette #endif
4088 1.404 riastrad devsw_detach(&raid_bdevsw, &raid_cdevsw);
4089 1.327 pgoyette rf_BootRaidframe(false);
4090 1.327 pgoyette #if (RF_INCLUDE_PARITY_DECLUSTERING_DS > 0)
4091 1.327 pgoyette rf_destroy_mutex2(rf_sparet_wait_mutex);
4092 1.327 pgoyette rf_destroy_cond2(rf_sparet_wait_cv);
4093 1.327 pgoyette rf_destroy_cond2(rf_sparet_resp_cv);
4094 1.327 pgoyette #endif
4095 1.327 pgoyette mutex_exit(&raid_lock);
4096 1.327 pgoyette mutex_destroy(&raid_lock);
4097 1.327 pgoyette
4098 1.327 pgoyette return error;
4099 1.327 pgoyette }
4100