/usr/src/sys/dev/softraid.c

Bug Summary

File:	dev/softraid.c
Warning:	line 3732, column 18 Result of 'malloc' is converted to a pointer of type 'struct sr_meta_opt_hdr', which is incompatible with sizeof operand type 'struct sr_meta_boot'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name softraid.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -ffreestanding -mcmodel=kernel -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -target-feature -sse2 -target-feature -sse -target-feature -3dnow -target-feature -mmx -target-feature +save-args -target-feature +retpoline-external-thunk -disable-red-zone -no-implicit-float -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -nostdsysteminc -nobuiltininc -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/sys -I /usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -I /usr/src/sys/arch -I /usr/src/sys/dev/pci/drm/include -I /usr/src/sys/dev/pci/drm/include/uapi -I /usr/src/sys/dev/pci/drm/amd/include/asic_reg -I /usr/src/sys/dev/pci/drm/amd/include -I /usr/src/sys/dev/pci/drm/amd/amdgpu -I /usr/src/sys/dev/pci/drm/amd/display -I /usr/src/sys/dev/pci/drm/amd/display/include -I /usr/src/sys/dev/pci/drm/amd/display/dc -I /usr/src/sys/dev/pci/drm/amd/display/amdgpu_dm -I /usr/src/sys/dev/pci/drm/amd/pm/inc -I /usr/src/sys/dev/pci/drm/amd/pm/legacy-dpm -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu11 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu12 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu13 -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/inc -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/hwmgr -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/smumgr -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc/pmfw_if -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc/hw -I /usr/src/sys/dev/pci/drm/amd/display/dc/clk_mgr -I /usr/src/sys/dev/pci/drm/amd/display/modules/inc -I /usr/src/sys/dev/pci/drm/amd/display/modules/hdcp -I /usr/src/sys/dev/pci/drm/amd/display/dmub/inc -I /usr/src/sys/dev/pci/drm/i915 -D DDB -D DIAGNOSTIC -D KTRACE -D ACCOUNTING -D KMEMSTATS -D PTRACE -D POOL_DEBUG -D CRYPTO -D SYSVMSG -D SYSVSEM -D SYSVSHM -D UVM_SWAP_ENCRYPT -D FFS -D FFS2 -D FFS_SOFTUPDATES -D UFS_DIRHASH -D QUOTA -D EXT2FS -D MFS -D NFSCLIENT -D NFSSERVER -D CD9660 -D UDF -D MSDOSFS -D FIFO -D FUSE -D SOCKET_SPLICE -D TCP_ECN -D TCP_SIGNATURE -D INET6 -D IPSEC -D PPP_BSDCOMP -D PPP_DEFLATE -D PIPEX -D MROUTING -D MPLS -D BOOT_CONFIG -D USER_PCICONF -D APERTURE -D MTRR -D NTFS -D SUSPEND -D HIBERNATE -D PCIVERBOSE -D USBVERBOSE -D WSDISPLAY_COMPAT_USL -D WSDISPLAY_COMPAT_RAWKBD -D WSDISPLAY_DEFAULTSCREENS=6 -D X86EMU -D ONEWIREVERBOSE -D MULTIPROCESSOR -D MAXUSERS=80 -D _KERNEL -O2 -Wno-pointer-sign -Wno-address-of-packed-member -Wno-constant-conversion -Wno-unused-but-set-variable -Wno-gnu-folding-constant -fdebug-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -o /home/ben/Projects/scan/2024-01-11-110808-61670-1 -x c /usr/src/sys/dev/softraid.c

1	/* $OpenBSD: softraid.c,v 1.429 2022/12/21 09:54:23 kn Exp $ */
2	/*
3	* Copyright (c) 2007, 2008, 2009 Marco Peereboom <marco@peereboom.us>
4	* Copyright (c) 2008 Chris Kuethe <ckuethe@openbsd.org>
5	* Copyright (c) 2009 Joel Sing <jsing@openbsd.org>
6	*
7	* Permission to use, copy, modify, and distribute this software for any
8	* purpose with or without fee is hereby granted, provided that the above
9	* copyright notice and this permission notice appear in all copies.
10	*
11	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18	*/
19
20	#include "bio.h"
21
22	#include <sys/param.h>
23	#include <sys/systm.h>
24	#include <sys/buf.h>
25	#include <sys/device.h>
26	#include <sys/ioctl.h>
27	#include <sys/malloc.h>
28	#include <sys/pool.h>
29	#include <sys/kernel.h>
30	#include <sys/disk.h>
31	#include <sys/rwlock.h>
32	#include <sys/queue.h>
33	#include <sys/fcntl.h>
34	#include <sys/disklabel.h>
35	#include <sys/vnode.h>
36	#include <sys/lock.h>
37	#include <sys/mount.h>
38	#include <sys/sensors.h>
39	#include <sys/stat.h>
40	#include <sys/conf.h>
41	#include <sys/uio.h>
42	#include <sys/task.h>
43	#include <sys/kthread.h>
44	#include <sys/dkio.h>
45	#include <sys/stdint.h>
46
47	#include <scsi/scsi_all.h>
48	#include <scsi/scsiconf.h>
49	#include <scsi/scsi_disk.h>
50
51	#include <dev/softraidvar.h>
52
53	#ifdef HIBERNATE1
54	#include <lib/libsa/aes_xts.h>
55	#include <sys/hibernate.h>
56	#include <scsi/sdvar.h>
57	#endif /* HIBERNATE */
58
59	/* #define SR_FANCY_STATS */
60
61	#ifdef SR_DEBUG
62	#define SR_FANCY_STATS
63	uint32_t sr_debug = 0
64	/* \| SR_D_CMD */
65	/* \| SR_D_MISC */
66	/* \| SR_D_INTR */
67	/* \| SR_D_IOCTL */
68	/* \| SR_D_CCB */
69	/* \| SR_D_WU */
70	/* \| SR_D_META */
71	/* \| SR_D_DIS */
72	/* \| SR_D_STATE */
73	/* \| SR_D_REBUILD */
74	;
75	#endif
76
77	struct sr_softc *softraid0;
78	struct sr_uuid sr_bootuuid;
79	u_int8_t sr_bootkey[SR_CRYPTO_MAXKEYBYTES32];
80
81	int sr_match(struct device , void , void *);
82	void sr_attach(struct device , struct device , void *);
83	int sr_detach(struct device *, int);
84	void sr_map_root(void);
85
86	const struct cfattach softraid_ca = {
87	sizeof(struct sr_softc), sr_match, sr_attach, sr_detach,
88	};
89
90	struct cfdriver softraid_cd = {
91	NULL((void *)0), "softraid", DV_DULL
92	};
93
94	/* scsi & discipline */
95	void sr_scsi_cmd(struct scsi_xfer *);
96	int sr_scsi_probe(struct scsi_link *);
97	int sr_scsi_ioctl(struct scsi_link *, u_long,
98	caddr_t, int);
99	int sr_bio_ioctl(struct device *, u_long, caddr_t);
100	int sr_bio_handler(struct sr_softc *,
101	struct sr_discipline , u_long, struct bio );
102	int sr_ioctl_inq(struct sr_softc , struct bioc_inq );
103	int sr_ioctl_vol(struct sr_softc , struct bioc_vol );
104	int sr_ioctl_disk(struct sr_softc , struct bioc_disk );
105	int sr_ioctl_setstate(struct sr_softc *,
106	struct bioc_setstate *);
107	int sr_ioctl_createraid(struct sr_softc *,
108	struct bioc_createraid , int, void );
109	int sr_ioctl_deleteraid(struct sr_softc *,
110	struct sr_discipline , struct bioc_deleteraid );
111	int sr_ioctl_discipline(struct sr_softc *,
112	struct sr_discipline , struct bioc_discipline );
113	int sr_ioctl_installboot(struct sr_softc *,
114	struct sr_discipline , struct bioc_installboot );
115	void sr_chunks_unwind(struct sr_softc *,
116	struct sr_chunk_head *);
117	void sr_discipline_free(struct sr_discipline *);
118	void sr_discipline_shutdown(struct sr_discipline *, int, int);
119	int sr_discipline_init(struct sr_discipline *, int);
120	int sr_alloc_resources(struct sr_discipline *);
121	void sr_free_resources(struct sr_discipline *);
122	void sr_set_chunk_state(struct sr_discipline *, int, int);
123	void sr_set_vol_state(struct sr_discipline *);
124
125	/* utility functions */
126	void sr_shutdown(int);
127	void sr_uuid_generate(struct sr_uuid *);
128	char sr_uuid_format(struct sr_uuid );
129	void sr_uuid_print(struct sr_uuid *, int);
130	void sr_checksum_print(u_int8_t *);
131	int sr_boot_assembly(struct sr_softc *);
132	int sr_already_assembled(struct sr_discipline *);
133	int sr_hotspare(struct sr_softc *, dev_t);
134	void sr_hotspare_rebuild(struct sr_discipline *);
135	int sr_rebuild_init(struct sr_discipline *, dev_t, int);
136	void sr_rebuild_start(void *);
137	void sr_rebuild_thread(void *);
138	void sr_rebuild(struct sr_discipline *);
139	void sr_roam_chunks(struct sr_discipline *);
140	int sr_chunk_in_use(struct sr_softc *, dev_t);
141	int sr_rw(struct sr_softc , dev_t, char , size_t,
142	daddr_t, long);
143	void sr_wu_done_callback(void *);
144	struct sr_discipline sr_find_discipline(struct sr_softc sc, const char *);
145
146	/* don't include these on RAMDISK */
147	#ifndef SMALL_KERNEL
148	void sr_sensors_refresh(void *);
149	int sr_sensors_create(struct sr_discipline *);
150	void sr_sensors_delete(struct sr_discipline *);
151	#endif
152
153	/* metadata */
154	int sr_meta_probe(struct sr_discipline , dev_t , int);
155	int sr_meta_attach(struct sr_discipline *, int, int);
156	int sr_meta_rw(struct sr_discipline , dev_t, void , long);
157	int sr_meta_clear(struct sr_discipline *);
158	void sr_meta_init(struct sr_discipline *, int, int);
159	void sr_meta_init_complete(struct sr_discipline *);
160	void sr_meta_opt_handler(struct sr_discipline *,
161	struct sr_meta_opt_hdr *);
162
163	/* hotplug magic */
164	void sr_disk_attach(struct disk *, int);
165
166	struct sr_hotplug_list {
167	void (sh_hotplug)(struct sr_discipline ,
168	struct disk *, int);
169	struct sr_discipline *sh_sd;
170
171	SLIST_ENTRY(sr_hotplug_list)struct { struct sr_hotplug_list *sle_next; } shl_link;
172	};
173	SLIST_HEAD(sr_hotplug_list_head, sr_hotplug_list)struct sr_hotplug_list_head { struct sr_hotplug_list *slh_first ; };
174
175	struct sr_hotplug_list_head sr_hotplug_callbacks;
176	extern void (softraid_disk_attach)(struct disk , int);
177
178	/* scsi glue */
179	const struct scsi_adapter sr_switch = {
180	sr_scsi_cmd, NULL((void )0), sr_scsi_probe, NULL((void )0), sr_scsi_ioctl
181	};
182
183	/* native metadata format */
184	int sr_meta_native_bootprobe(struct sr_softc *, dev_t,
185	struct sr_boot_chunk_head *);
186	#define SR_META_NOTCLAIMED(0) (0)
187	#define SR_META_CLAIMED(1) (1)
188	int sr_meta_native_probe(struct sr_softc *,
189	struct sr_chunk *);
190	int sr_meta_native_attach(struct sr_discipline *, int);
191	int sr_meta_native_write(struct sr_discipline *, dev_t,
192	struct sr_metadata ,void );
193
194	#ifdef SR_DEBUG
195	void sr_meta_print(struct sr_metadata *);
196	#else
197	#define sr_meta_print(m)
198	#endif
199
200	/* the metadata driver should remain stateless */
201	struct sr_meta_driver {
202	daddr_t smd_offset; /* metadata location */
203	u_int32_t smd_size; /* size of metadata */
204
205	int (smd_probe)(struct sr_softc ,
206	struct sr_chunk *);
207	int (smd_attach)(struct sr_discipline , int);
208	int (smd_detach)(struct sr_discipline );
209	int (smd_read)(struct sr_discipline , dev_t,
210	struct sr_metadata , void );
211	int (smd_write)(struct sr_discipline , dev_t,
212	struct sr_metadata , void );
213	int (smd_validate)(struct sr_discipline ,
214	struct sr_metadata , void );
215	} smd[] = {
216	{ SR_META_OFFSET16, SR_META_SIZE64 * DEV_BSIZE(1 << 9),
217	sr_meta_native_probe, sr_meta_native_attach, NULL((void *)0),
218	sr_meta_native_read, sr_meta_native_write, NULL((void *)0) },
219	{ 0, 0, NULL((void )0), NULL((void )0), NULL((void )0), NULL((void )0) }
220	};
221
222	int
223	sr_meta_attach(struct sr_discipline *sd, int chunk_no, int force)
224	{
225	struct sr_softc *sc = sd->sd_sc;
226	struct sr_chunk_head *cl;
227	struct sr_chunk ch_entry, chunk1, *chunk2;
228	int rv = 1, i = 0;
229
230	DNPRINTF(SR_D_META, "%s: sr_meta_attach(%d)\n", DEVNAME(sc), chunk_no);
231
232	/* in memory copy of metadata */
233	sd->sd_meta = malloc(SR_META_SIZE64 * DEV_BSIZE(1 << 9), M_DEVBUF2,
234	M_ZERO0x0008 \| M_NOWAIT0x0002);
235	if (!sd->sd_meta) {
236	sr_error(sc, "could not allocate memory for metadata");
237	goto bad;
238	}
239
240	if (sd->sd_meta_type != SR_META_F_NATIVE0) {
241	/* in memory copy of foreign metadata */
242	sd->sd_meta_foreign = malloc(smd[sd->sd_meta_type].smd_size,
243	M_DEVBUF2, M_ZERO0x0008 \| M_NOWAIT0x0002);
244	if (!sd->sd_meta_foreign) {
245	/* unwind frees sd_meta */
246	sr_error(sc, "could not allocate memory for foreign "
247	"metadata");
248	goto bad;
249	}
250	}
251
252	/* we have a valid list now create an array index */
253	cl = &sd->sd_vol.sv_chunk_list;
254	sd->sd_vol.sv_chunks = mallocarray(chunk_no, sizeof(struct sr_chunk *),
255	M_DEVBUF2, M_WAITOK0x0001 \| M_ZERO0x0008);
256
257	/* fill out chunk array */
258	i = 0;
259	SLIST_FOREACH(ch_entry, cl, src_link)for((ch_entry) = ((cl)->slh_first); (ch_entry) != ((void * )0); (ch_entry) = ((ch_entry)->src_link.sle_next))
260	sd->sd_vol.sv_chunks[i++] = ch_entry;
261
262	/* attach metadata */
263	if (smd[sd->sd_meta_type].smd_attach(sd, force))
264	goto bad;
265
266	/* Force chunks into correct order now that metadata is attached. */
267	SLIST_INIT(cl){ ((cl)->slh_first) = ((void *)0); };
268	for (i = 0; i < chunk_no; i++) {
269	ch_entry = sd->sd_vol.sv_chunks[i];
270	chunk2 = NULL((void *)0);
271	SLIST_FOREACH(chunk1, cl, src_link)for((chunk1) = ((cl)->slh_first); (chunk1) != ((void *)0); (chunk1) = ((chunk1)->src_link.sle_next)) {
272	if (chunk1->src_meta.scmi_scm_invariant.scm_chunk_id >
273	ch_entry->src_meta.scmi_scm_invariant.scm_chunk_id)
274	break;
275	chunk2 = chunk1;
276	}
277	if (chunk2 == NULL((void *)0))
278	SLIST_INSERT_HEAD(cl, ch_entry, src_link)do { (ch_entry)->src_link.sle_next = (cl)->slh_first; ( cl)->slh_first = (ch_entry); } while (0);
279	else
280	SLIST_INSERT_AFTER(chunk2, ch_entry, src_link)do { (ch_entry)->src_link.sle_next = (chunk2)->src_link .sle_next; (chunk2)->src_link.sle_next = (ch_entry); } while (0);
281	}
282	i = 0;
283	SLIST_FOREACH(ch_entry, cl, src_link)for((ch_entry) = ((cl)->slh_first); (ch_entry) != ((void * )0); (ch_entry) = ((ch_entry)->src_link.sle_next))
284	sd->sd_vol.sv_chunks[i++] = ch_entry;
285
286	rv = 0;
287	bad:
288	return (rv);
289	}
290
291	int
292	sr_meta_probe(struct sr_discipline sd, dev_t dt, int no_chunk)
293	{
294	struct sr_softc *sc = sd->sd_sc;
295	struct vnode *vn;
296	struct sr_chunk ch_entry, ch_prev = NULL((void *)0);
297	struct sr_chunk_head *cl;
298	char devname[32];
299	int i, d, type, found, prevf, error;
300	dev_t dev;
301
302	DNPRINTF(SR_D_META, "%s: sr_meta_probe(%d)\n", DEVNAME(sc), no_chunk);
303
304	if (no_chunk == 0)
305	goto unwind;
306
307	cl = &sd->sd_vol.sv_chunk_list;
308
309	for (d = 0, prevf = SR_META_F_INVALID-1; d < no_chunk; d++) {
310	ch_entry = malloc(sizeof(struct sr_chunk), M_DEVBUF2,
311	M_WAITOK0x0001 \| M_ZERO0x0008);
312	/* keep disks in user supplied order */
313	if (ch_prev)
314	SLIST_INSERT_AFTER(ch_prev, ch_entry, src_link)do { (ch_entry)->src_link.sle_next = (ch_prev)->src_link .sle_next; (ch_prev)->src_link.sle_next = (ch_entry); } while (0);
315	else
316	SLIST_INSERT_HEAD(cl, ch_entry, src_link)do { (ch_entry)->src_link.sle_next = (cl)->slh_first; ( cl)->slh_first = (ch_entry); } while (0);
317	ch_prev = ch_entry;
318	dev = dt[d];
319	ch_entry->src_dev_mm = dev;
320
321	if (dev == NODEV(dev_t)(-1)) {
322	ch_entry->src_meta.scm_status = BIOC_SDOFFLINE0x01;
323	continue;
324	} else {
325	sr_meta_getdevname(sc, dev, devname, sizeof(devname));
326	if (bdevvp(dev, &vn)) {
327	sr_error(sc, "sr_meta_probe: cannot allocate "
328	"vnode");
329	goto unwind;
330	}
331
332	/*
333	* XXX leaving dev open for now; move this to attach
334	* and figure out the open/close dance for unwind.
335	*/
336	error = VOP_OPEN(vn, FREAD0x0001 \| FWRITE0x0002, NOCRED((struct ucred )-1), curproc({struct cpu_info __ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc);
337	if (error) {
338	DNPRINTF(SR_D_META,"%s: sr_meta_probe can't "
339	"open %s\n", DEVNAME(sc), devname);
340	vput(vn);
341	goto unwind;
342	}
343
344	strlcpy(ch_entry->src_devname, devname,
345	sizeof(ch_entry->src_devname));
346	ch_entry->src_vn = vn;
347	}
348
349	/* determine if this is a device we understand */
350	for (i = 0, found = SR_META_F_INVALID-1; smd[i].smd_probe; i++) {
351	type = smd[i].smd_probe(sc, ch_entry);
352	if (type == SR_META_F_INVALID-1)
353	continue;
354	else {
355	found = type;
356	break;
357	}
358	}
359
360	if (found == SR_META_F_INVALID-1)
361	goto unwind;
362	if (prevf == SR_META_F_INVALID-1)
363	prevf = found;
364	if (prevf != found) {
365	DNPRINTF(SR_D_META, "%s: prevf != found\n",
366	DEVNAME(sc));
367	goto unwind;
368	}
369	}
370
371	return (prevf);
372	unwind:
373	return (SR_META_F_INVALID-1);
374	}
375
376	void
377	sr_meta_getdevname(struct sr_softc sc, dev_t dev, char buf, int size)
378	{
379	int maj, unit, part;
380	char *name;
381
382	DNPRINTF(SR_D_META, "%s: sr_meta_getdevname(%p, %d)\n",
383	DEVNAME(sc), buf, size);
384
385	if (!buf)
386	return;
387
388	maj = major(dev)(((unsigned)(dev) >> 8) & 0xff);
389	part = DISKPART(dev)(((unsigned)((dev) & 0xff) \| (((dev) & 0xffff0000) >> 8)) % 16);
390	unit = DISKUNIT(dev)(((unsigned)((dev) & 0xff) \| (((dev) & 0xffff0000) >> 8)) / 16);
391
392	name = findblkname(maj);
393	if (name == NULL((void *)0))
394	return;
395
396	snprintf(buf, size, "%s%d%c", name, unit, part + 'a');
397	}
398
399	int
400	sr_rw(struct sr_softc sc, dev_t dev, char buf, size_t size, daddr_t blkno,
401	long flags)
402	{
403	struct vnode *vp;
404	struct buf b;
405	size_t bufsize, dma_bufsize;
406	int rv = 1;
407	char *dma_buf;
408	int s;
409
410	DNPRINTF(SR_D_MISC, "%s: sr_rw(0x%x, %p, %zu, %lld 0x%lx)\n",
411	DEVNAME(sc), dev, buf, size, (long long)blkno, flags);
412
413	dma_bufsize = (size > MAXPHYS(64 * 1024)) ? MAXPHYS(64 * 1024) : size;
414	dma_buf = dma_alloc(dma_bufsize, PR_WAITOK0x0001);
415
416	if (bdevvp(dev, &vp)) {
417	printf("%s: sr_rw: failed to allocate vnode\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
418	goto done;
419	}
420
421	while (size > 0) {
422	DNPRINTF(SR_D_MISC, "%s: dma_buf %p, size %zu, blkno %lld)\n",
423	DEVNAME(sc), dma_buf, size, (long long)blkno);
424
425	bufsize = (size > MAXPHYS(64 * 1024)) ? MAXPHYS(64 * 1024) : size;
426	if (flags == B_WRITE0x00000000)
427	memcpy(dma_buf, buf, bufsize)__builtin_memcpy((dma_buf), (buf), (bufsize));
428
429	bzero(&b, sizeof(b))__builtin_bzero((&b), (sizeof(b)));
430	b.b_flags = flags \| B_PHYS0x00002000;
431	b.b_proc = curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc;
432	b.b_dev = dev;
433	b.b_iodone = NULL((void *)0);
434	b.b_error = 0;
435	b.b_blkno = blkno;
436	b.b_data = dma_buf;
437	b.b_bcount = bufsize;
438	b.b_bufsize = bufsize;
439	b.b_resid = bufsize;
440	b.b_vp = vp;
441
442	if ((b.b_flags & B_READ0x00008000) == 0) {
443	s = splbio()splraise(0x3);
444	vp->v_numoutput++;
445	splx(s)spllower(s);
446	}
447
448	LIST_INIT(&b.b_dep)do { ((&b.b_dep)->lh_first) = ((void *)0); } while (0);
449	VOP_STRATEGY(vp, &b);
450	biowait(&b);
451
452	if (b.b_flags & B_ERROR0x00000400) {
453	printf("%s: I/O error %d on dev 0x%x at block %llu\n",
454	DEVNAME(sc)((sc)->sc_dev.dv_xname), b.b_error, dev, b.b_blkno);
455	goto done;
456	}
457
458	if (flags == B_READ0x00008000)
459	memcpy(buf, dma_buf, bufsize)__builtin_memcpy((buf), (dma_buf), (bufsize));
460
461	size -= bufsize;
462	buf += bufsize;
463	blkno += howmany(bufsize, DEV_BSIZE)(((bufsize) + (((1 << 9)) - 1)) / ((1 << 9)));
464	}
465
466	rv = 0;
467
468	done:
469	if (vp)
470	vput(vp);
471
472	dma_free(dma_buf, dma_bufsize);
473
474	return (rv);
475	}
476
477	int
478	sr_meta_rw(struct sr_discipline sd, dev_t dev, void md, long flags)
479	{
480	int rv = 1;
481
482	DNPRINTF(SR_D_META, "%s: sr_meta_rw(0x%x, %p, 0x%lx)\n",
483	DEVNAME(sd->sd_sc), dev, md, flags);
484
485	if (md == NULL((void *)0)) {
486	printf("%s: sr_meta_rw: invalid metadata pointer\n",
487	DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname));
488	goto done;
489	}
490
491	rv = sr_rw(sd->sd_sc, dev, md, SR_META_SIZE64 * DEV_BSIZE(1 << 9),
492	SR_META_OFFSET16, flags);
493
494	done:
495	return (rv);
496	}
497
498	int
499	sr_meta_clear(struct sr_discipline *sd)
500	{
501	struct sr_softc *sc = sd->sd_sc;
502	struct sr_chunk_head *cl = &sd->sd_vol.sv_chunk_list;
503	struct sr_chunk *ch_entry;
504	void *m;
505	int rv = 1;
506
507	DNPRINTF(SR_D_META, "%s: sr_meta_clear\n", DEVNAME(sc));
508
509	if (sd->sd_meta_type != SR_META_F_NATIVE0) {
510	sr_error(sc, "cannot clear foreign metadata");
511	goto done;
512	}
513
514	m = malloc(SR_META_SIZE64 * DEV_BSIZE(1 << 9), M_DEVBUF2, M_WAITOK0x0001 \| M_ZERO0x0008);
515	SLIST_FOREACH(ch_entry, cl, src_link)for((ch_entry) = ((cl)->slh_first); (ch_entry) != ((void * )0); (ch_entry) = ((ch_entry)->src_link.sle_next)) {
516	if (sr_meta_native_write(sd, ch_entry->src_dev_mm, m, NULL((void *)0))) {
517	/* XXX mark disk offline */
518	DNPRINTF(SR_D_META, "%s: sr_meta_clear failed to "
519	"clear %s\n", DEVNAME(sc), ch_entry->src_devname);
520	rv++;
521	continue;
522	}
523	bzero(&ch_entry->src_meta, sizeof(ch_entry->src_meta))__builtin_bzero((&ch_entry->src_meta), (sizeof(ch_entry ->src_meta)));
524	}
525
526	bzero(sd->sd_meta, SR_META_SIZE * DEV_BSIZE)__builtin_bzero((sd->sd_meta), (64 * (1 << 9)));
527
528	free(m, M_DEVBUF2, SR_META_SIZE64 * DEV_BSIZE(1 << 9));
529	rv = 0;
530	done:
531	return (rv);
532	}
533
534	void
535	sr_meta_init(struct sr_discipline *sd, int level, int no_chunk)
536	{
537	struct sr_softc *sc = sd->sd_sc;
538	struct sr_metadata *sm = sd->sd_meta;
539	struct sr_chunk_head *cl = &sd->sd_vol.sv_chunk_list;
540	struct sr_meta_chunk *scm;
541	struct sr_chunk *chunk;
542	int cid = 0;
543	u_int64_t max_chunk_sz = 0, min_chunk_sz = 0;
544	u_int32_t secsize = DEV_BSIZE(1 << 9);
545
546	DNPRINTF(SR_D_META, "%s: sr_meta_init\n", DEVNAME(sc));
547
548	if (!sm)
549	return;
550
551	/* Initialise volume metadata. */
552	sm->ssdi_sdd_invariant.ssd_magic = SR_MAGIC0x4d4152436372616dLLU;
553	sm->ssdi_sdd_invariant.ssd_version = SR_META_VERSION6;
554	sm->ssdi_sdd_invariant.ssd_vol_flags = sd->sd_meta_flags;
555	sm->ssdi_sdd_invariant.ssd_volid = 0;
556	sm->ssdi_sdd_invariant.ssd_chunk_no = no_chunk;
557	sm->ssdi_sdd_invariant.ssd_level = level;
558
559	sm->ssd_data_blkno = SR_DATA_OFFSET(16 + (64 + (320 + 128)));
560	sm->ssd_ondisk = 0;
561
562	sr_uuid_generate(&sm->ssdi_sdd_invariant.ssd_uuid);
563
564	/* Initialise chunk metadata and get min/max chunk sizes & secsize. */
565	SLIST_FOREACH(chunk, cl, src_link)for((chunk) = ((cl)->slh_first); (chunk) != ((void *)0); ( chunk) = ((chunk)->src_link.sle_next)) {
566	scm = &chunk->src_meta;
567	scm->scmi_scm_invariant.scm_size = chunk->src_size;
568	scm->scmi_scm_invariant.scm_chunk_id = cid++;
569	scm->scm_status = BIOC_SDONLINE0x00;
570	scm->scmi_scm_invariant.scm_volid = 0;
571	strlcpy(scm->scmi_scm_invariant.scm_devname, chunk->src_devname,
572	sizeof(scm->scmi_scm_invariant.scm_devname));
573	memcpy(&scm->scmi.scm_uuid, &sm->ssdi.ssd_uuid,__builtin_memcpy((&scm->_scm_invariant.scm_uuid), (& sm->_sdd_invariant.ssd_uuid), (sizeof(scm->_scm_invariant .scm_uuid)))
574	sizeof(scm->scmi.scm_uuid))__builtin_memcpy((&scm->_scm_invariant.scm_uuid), (& sm->_sdd_invariant.ssd_uuid), (sizeof(scm->_scm_invariant .scm_uuid)));
575	sr_checksum(sc, scm, &scm->scm_checksum,
576	sizeof(scm->scm_checksum));
577
578	if (min_chunk_sz == 0)
579	min_chunk_sz = scm->scmi_scm_invariant.scm_size;
580	if (chunk->src_secsize > secsize)
581	secsize = chunk->src_secsize;
582	min_chunk_sz = MIN(min_chunk_sz, scm->scmi.scm_size)(((min_chunk_sz)<(scm->_scm_invariant.scm_size))?(min_chunk_sz ):(scm->_scm_invariant.scm_size));
583	max_chunk_sz = MAX(max_chunk_sz, scm->scmi.scm_size)(((max_chunk_sz)>(scm->_scm_invariant.scm_size))?(max_chunk_sz ):(scm->_scm_invariant.scm_size));
584	}
585
586	sm->ssdi_sdd_invariant.ssd_secsize = secsize;
587
588	/* Equalize chunk sizes. */
589	SLIST_FOREACH(chunk, cl, src_link)for((chunk) = ((cl)->slh_first); (chunk) != ((void *)0); ( chunk) = ((chunk)->src_link.sle_next))
590	chunk->src_meta.scmi_scm_invariant.scm_coerced_size = min_chunk_sz;
591
592	sd->sd_vol.sv_chunk_minsz = min_chunk_sz;
593	sd->sd_vol.sv_chunk_maxsz = max_chunk_sz;
594	}
595
596	void
597	sr_meta_init_complete(struct sr_discipline *sd)
598	{
599	#ifdef SR_DEBUG
600	struct sr_softc *sc = sd->sd_sc;
601	#endif
602	struct sr_metadata *sm = sd->sd_meta;
603
604	DNPRINTF(SR_D_META, "%s: sr_meta_complete\n", DEVNAME(sc));
605
606	/* Complete initialisation of volume metadata. */
607	strlcpy(sm->ssdi_sdd_invariant.ssd_vendor, "OPENBSD", sizeof(sm->ssdi_sdd_invariant.ssd_vendor));
608	snprintf(sm->ssdi_sdd_invariant.ssd_product, sizeof(sm->ssdi_sdd_invariant.ssd_product),
609	"SR %s", sd->sd_name);
610	snprintf(sm->ssdi_sdd_invariant.ssd_revision, sizeof(sm->ssdi_sdd_invariant.ssd_revision),
611	"%03d", sm->ssdi_sdd_invariant.ssd_version);
612	}
613
614	void
615	sr_meta_opt_handler(struct sr_discipline sd, struct sr_meta_opt_hdr om)
616	{
617	if (om->som_type != SR_OPT_BOOT0x02)
618	panic("unknown optional metadata type");
619	}
620
621	void
622	sr_meta_save_callback(void *xsd)
623	{
624	struct sr_discipline *sd = xsd;
625	int s;
626
627	s = splbio()splraise(0x3);
628
629	if (sr_meta_save(sd, SR_META_DIRTY0x1))
630	printf("%s: save metadata failed\n", DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname));
631
632	sd->sd_must_flush = 0;
633	splx(s)spllower(s);
634	}
635
636	int
637	sr_meta_save(struct sr_discipline *sd, u_int32_t flags)
638	{
639	struct sr_softc *sc = sd->sd_sc;
640	struct sr_metadata sm = sd->sd_meta, m;
641	struct sr_meta_driver *s;
642	struct sr_chunk *src;
643	struct sr_meta_chunk *cm;
644	struct sr_workunit wu;
645	struct sr_meta_opt_hdr *omh;
646	struct sr_meta_opt_item *omi;
647	int i;
648
649	DNPRINTF(SR_D_META, "%s: sr_meta_save %s\n",
650	DEVNAME(sc), sd->sd_meta->ssd_devname);
651
652	if (!sm) {
653	printf("%s: no in memory copy of metadata\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
654	goto bad;
655	}
656
657	/* meta scratchpad */
658	s = &smd[sd->sd_meta_type];
659	m = malloc(SR_META_SIZE64 * DEV_BSIZE(1 << 9), M_DEVBUF2, M_ZERO0x0008 \| M_NOWAIT0x0002);
660	if (!m) {
661	printf("%s: could not allocate metadata scratch area\n",
662	DEVNAME(sc)((sc)->sc_dev.dv_xname));
663	goto bad;
664	}
665
666	/* from here on out metadata is updated */
667	restart:
668	sm->ssd_ondisk++;
669	sm->ssd_meta_flags = flags;
670	memcpy(m, sm, sizeof(m))__builtin_memcpy((m), (sm), (sizeof(m)));
671
672	/* Chunk metadata. */
673	cm = (struct sr_meta_chunk *)(m + 1);
674	for (i = 0; i < sm->ssdi_sdd_invariant.ssd_chunk_no; i++) {
675	src = sd->sd_vol.sv_chunks[i];
676	memcpy(cm, &src->src_meta, sizeof(cm))__builtin_memcpy((cm), (&src->src_meta), (sizeof(cm)) );
677	cm++;
678	}
679
680	/* Optional metadata. */
681	omh = (struct sr_meta_opt_hdr *)(cm);
682	SLIST_FOREACH(omi, &sd->sd_meta_opt, omi_link)for((omi) = ((&sd->sd_meta_opt)->slh_first); (omi) != ((void *)0); (omi) = ((omi)->omi_link.sle_next)) {
683	DNPRINTF(SR_D_META, "%s: saving optional metadata type %u with "
684	"length %u\n", DEVNAME(sc), omi->omi_som->som_type,
685	omi->omi_som->som_length);
686	bzero(&omi->omi_som->som_checksum, MD5_DIGEST_LENGTH)__builtin_bzero((&omi->omi_som->som_checksum), (16) );
687	sr_checksum(sc, omi->omi_som, &omi->omi_som->som_checksum,
688	omi->omi_som->som_length);
689	memcpy(omh, omi->omi_som, omi->omi_som->som_length)__builtin_memcpy((omh), (omi->omi_som), (omi->omi_som-> som_length));
690	omh = (struct sr_meta_opt_hdr )((u_int8_t )omh +
691	omi->omi_som->som_length);
692	}
693
694	for (i = 0; i < sm->ssdi_sdd_invariant.ssd_chunk_no; i++) {
695	src = sd->sd_vol.sv_chunks[i];
696
697	/* skip disks that are offline */
698	if (src->src_meta.scm_status == BIOC_SDOFFLINE0x01)
699	continue;
700
701	/* calculate metadata checksum for correct chunk */
702	m->ssdi_sdd_invariant.ssd_chunk_id = i;
703	sr_checksum(sc, m, &m->ssd_checksum,
704	sizeof(struct sr_meta_invariant));
705
706	#ifdef SR_DEBUG
707	DNPRINTF(SR_D_META, "%s: sr_meta_save %s: volid: %d "
708	"chunkid: %d checksum: ",
709	DEVNAME(sc), src->src_meta.scmi.scm_devname,
710	m->ssdi.ssd_volid, m->ssdi.ssd_chunk_id);
711
712	if (sr_debug & SR_D_META)
713	sr_checksum_print((u_int8_t *)&m->ssd_checksum);
714	DNPRINTF(SR_D_META, "\n");
715	sr_meta_print(m);
716	#endif
717
718	/* translate and write to disk */
719	if (s->smd_write(sd, src->src_dev_mm, m, NULL((void )0) / XXX */)) {
720	printf("%s: could not write metadata to %s\n",
721	DEVNAME(sc)((sc)->sc_dev.dv_xname), src->src_devname);
722	/* restart the meta write */
723	src->src_meta.scm_status = BIOC_SDOFFLINE0x01;
724	/* XXX recalculate volume status */
725	goto restart;
726	}
727	}
728
729	/* not all disciplines have sync */
730	if (sd->sd_scsi_sync) {
731	bzero(&wu, sizeof(wu))__builtin_bzero((&wu), (sizeof(wu)));
732	wu.swu_flags \|= SR_WUF_FAKE(1<<6);
733	wu.swu_dis = sd;
734	sd->sd_scsi_sync(&wu);
735	}
736	free(m, M_DEVBUF2, SR_META_SIZE64 * DEV_BSIZE(1 << 9));
737	return (0);
738	bad:
739	return (1);
740	}
741
742	int
743	sr_meta_read(struct sr_discipline *sd)
744	{
745	struct sr_softc *sc = sd->sd_sc;
746	struct sr_chunk_head *cl = &sd->sd_vol.sv_chunk_list;
747	struct sr_metadata *sm;
748	struct sr_chunk *ch_entry;
749	struct sr_meta_chunk *cp;
750	struct sr_meta_driver *s;
751	void fm = NULL((void )0);
752	int no_disk = 0, got_meta = 0;
753
754	DNPRINTF(SR_D_META, "%s: sr_meta_read\n", DEVNAME(sc));
755
756	sm = malloc(SR_META_SIZE64 * DEV_BSIZE(1 << 9), M_DEVBUF2, M_WAITOK0x0001 \| M_ZERO0x0008);
757	s = &smd[sd->sd_meta_type];
758	if (sd->sd_meta_type != SR_META_F_NATIVE0)
759	fm = malloc(s->smd_size, M_DEVBUF2, M_WAITOK0x0001 \| M_ZERO0x0008);
760
761	cp = (struct sr_meta_chunk *)(sm + 1);
762	SLIST_FOREACH(ch_entry, cl, src_link)for((ch_entry) = ((cl)->slh_first); (ch_entry) != ((void * )0); (ch_entry) = ((ch_entry)->src_link.sle_next)) {
763	/* skip disks that are offline */
764	if (ch_entry->src_meta.scm_status == BIOC_SDOFFLINE0x01) {
765	DNPRINTF(SR_D_META,
766	"%s: %s chunk marked offline, spoofing status\n",
767	DEVNAME(sc), ch_entry->src_devname);
768	cp++; /* adjust chunk pointer to match failure */
769	continue;
770	} else if (s->smd_read(sd, ch_entry->src_dev_mm, sm, fm)) {
771	/* read and translate */
772	/* XXX mark chunk offline, elsewhere!! */
773	ch_entry->src_meta.scm_status = BIOC_SDOFFLINE0x01;
774	cp++; /* adjust chunk pointer to match failure */
775	DNPRINTF(SR_D_META, "%s: sr_meta_read failed\n",
776	DEVNAME(sc));
777	continue;
778	}
779
780	if (sm->ssdi_sdd_invariant.ssd_magic != SR_MAGIC0x4d4152436372616dLLU) {
781	DNPRINTF(SR_D_META, "%s: sr_meta_read !SR_MAGIC\n",
782	DEVNAME(sc));
783	continue;
784	}
785
786	/* validate metadata */
787	if (sr_meta_validate(sd, ch_entry->src_dev_mm, sm, fm)) {
788	DNPRINTF(SR_D_META, "%s: invalid metadata\n",
789	DEVNAME(sc));
790	no_disk = -1;
791	goto done;
792	}
793
794	/* assume first chunk contains metadata */
795	if (got_meta == 0) {
796	sr_meta_opt_load(sc, sm, &sd->sd_meta_opt);
797	memcpy(sd->sd_meta, sm, sizeof(sd->sd_meta))__builtin_memcpy((sd->sd_meta), (sm), (sizeof(sd->sd_meta )));
798	got_meta = 1;
799	}
800
801	memcpy(&ch_entry->src_meta, cp, sizeof(ch_entry->src_meta))__builtin_memcpy((&ch_entry->src_meta), (cp), (sizeof( ch_entry->src_meta)));
802
803	no_disk++;
804	cp++;
805	}
806
807	free(sm, M_DEVBUF2, SR_META_SIZE64 * DEV_BSIZE(1 << 9));
808	free(fm, M_DEVBUF2, s->smd_size);
809
810	done:
811	DNPRINTF(SR_D_META, "%s: sr_meta_read found %d parts\n", DEVNAME(sc),
812	no_disk);
813	return (no_disk);
814	}
815
816	void
817	sr_meta_opt_load(struct sr_softc sc, struct sr_metadata sm,
818	struct sr_meta_opt_head *som)
819	{
820	struct sr_meta_opt_hdr *omh;
821	struct sr_meta_opt_item *omi;
822	u_int8_t checksum[MD5_DIGEST_LENGTH16];
823	int i;
824
825	/* Process optional metadata. */
826	omh = (struct sr_meta_opt_hdr )((u_int8_t )(sm + 1) +
827	sizeof(struct sr_meta_chunk) * sm->ssdi_sdd_invariant.ssd_chunk_no);
828	for (i = 0; i < sm->ssdi_sdd_invariant.ssd_opt_no; i++) {
829
830	omi = malloc(sizeof(struct sr_meta_opt_item), M_DEVBUF2,
831	M_WAITOK0x0001 \| M_ZERO0x0008);
832	SLIST_INSERT_HEAD(som, omi, omi_link)do { (omi)->omi_link.sle_next = (som)->slh_first; (som) ->slh_first = (omi); } while (0);
833
834	if (omh->som_length == 0) {
835
836	/* Load old fixed length optional metadata. */
837	DNPRINTF(SR_D_META, "%s: old optional metadata of type "
838	"%u\n", DEVNAME(sc), omh->som_type);
839
840	/* Validate checksum. */
841	sr_checksum(sc, (void *)omh, &checksum,
842	SR_OLD_META_OPT_SIZE2480 - MD5_DIGEST_LENGTH16);
843	if (bcmp(&checksum, (void *)omh + SR_OLD_META_OPT_MD5(2480 - 16),
844	sizeof(checksum)))
845	panic("%s: invalid optional metadata checksum",
846	DEVNAME(sc)((sc)->sc_dev.dv_xname));
847
848	/* Determine correct length. */
849	switch (omh->som_type) {
850	case SR_OPT_CRYPTO0x01:
851	omh->som_length = sizeof(struct sr_meta_crypto);
852	break;
853	case SR_OPT_BOOT0x02:
854	omh->som_length = sizeof(struct sr_meta_boot);
855	break;
856	case SR_OPT_KEYDISK0x03:
857	omh->som_length =
858	sizeof(struct sr_meta_keydisk);
859	break;
860	default:
861	panic("unknown old optional metadata type %u",
862	omh->som_type);
863	}
864
865	omi->omi_som = malloc(omh->som_length, M_DEVBUF2,
866	M_WAITOK0x0001 \| M_ZERO0x0008);
867	memcpy((u_int8_t )omi->omi_som + sizeof(omi->omi_som),__builtin_memcpy(((u_int8_t )omi->omi_som + sizeof(omi-> omi_som)), ((u_int8_t )omh + 8), (omh->som_length - sizeof (omi->omi_som)))
868	(u_int8_t )omh + SR_OLD_META_OPT_OFFSET,__builtin_memcpy(((u_int8_t )omi->omi_som + sizeof(omi-> omi_som)), ((u_int8_t )omh + 8), (omh->som_length - sizeof (*omi->omi_som)))
869	omh->som_length - sizeof(omi->omi_som))__builtin_memcpy(((u_int8_t )omi->omi_som + sizeof(omi-> omi_som)), ((u_int8_t )omh + 8), (omh->som_length - sizeof (*omi->omi_som)));
870	omi->omi_som->som_type = omh->som_type;
871	omi->omi_som->som_length = omh->som_length;
872
873	omh = (struct sr_meta_opt_hdr )((void )omh +
874	SR_OLD_META_OPT_SIZE2480);
875	} else {
876
877	/* Load variable length optional metadata. */
878	DNPRINTF(SR_D_META, "%s: optional metadata of type %u, "
879	"length %u\n", DEVNAME(sc), omh->som_type,
880	omh->som_length);
881	omi->omi_som = malloc(omh->som_length, M_DEVBUF2,
882	M_WAITOK0x0001 \| M_ZERO0x0008);
883	memcpy(omi->omi_som, omh, omh->som_length)__builtin_memcpy((omi->omi_som), (omh), (omh->som_length ));
884
885	/* Validate checksum. */
886	memcpy(&checksum, &omi->omi_som->som_checksum,__builtin_memcpy((&checksum), (&omi->omi_som->som_checksum ), (16))
887	MD5_DIGEST_LENGTH)__builtin_memcpy((&checksum), (&omi->omi_som->som_checksum ), (16));
888	bzero(&omi->omi_som->som_checksum, MD5_DIGEST_LENGTH)__builtin_bzero((&omi->omi_som->som_checksum), (16) );
889	sr_checksum(sc, omi->omi_som,
890	&omi->omi_som->som_checksum, omh->som_length);
891	if (bcmp(&checksum, &omi->omi_som->som_checksum,
892	sizeof(checksum)))
893	panic("%s: invalid optional metadata checksum",
894	DEVNAME(sc)((sc)->sc_dev.dv_xname));
895
896	omh = (struct sr_meta_opt_hdr )((void )omh +
897	omh->som_length);
898	}
899	}
900	}
901
902	int
903	sr_meta_validate(struct sr_discipline sd, dev_t dev, struct sr_metadata sm,
904	void *fm)
905	{
906	struct sr_softc *sc = sd->sd_sc;
907	struct sr_meta_driver *s;
908	#ifdef SR_DEBUG
909	struct sr_meta_chunk *mc;
910	#endif
911	u_int8_t checksum[MD5_DIGEST_LENGTH16];
912	char devname[32];
913	int rv = 1;
914
915	DNPRINTF(SR_D_META, "%s: sr_meta_validate(%p)\n", DEVNAME(sc), sm);
916
917	sr_meta_getdevname(sc, dev, devname, sizeof(devname));
918
919	s = &smd[sd->sd_meta_type];
920	if (sd->sd_meta_type != SR_META_F_NATIVE0)
921	if (s->smd_validate(sd, sm, fm)) {
922	sr_error(sc, "invalid foreign metadata");
923	goto done;
924	}
925
926	/*
927	* at this point all foreign metadata has been translated to the native
928	* format and will be treated just like the native format
929	*/
930
931	if (sm->ssdi_sdd_invariant.ssd_magic != SR_MAGIC0x4d4152436372616dLLU) {
932	sr_error(sc, "not valid softraid metadata");
933	goto done;
934	}
935
936	/* Verify metadata checksum. */
937	sr_checksum(sc, sm, &checksum, sizeof(struct sr_meta_invariant));
938	if (bcmp(&checksum, &sm->ssd_checksum, sizeof(checksum))) {
939	sr_error(sc, "invalid metadata checksum");
940	goto done;
941	}
942
943	/* Handle changes between versions. */
944	if (sm->ssdi_sdd_invariant.ssd_version == 3) {
945
946	/*
947	* Version 3 - update metadata version and fix up data blkno
948	* value since this did not exist in version 3.
949	*/
950	if (sm->ssd_data_blkno == 0)
951	sm->ssd_data_blkno = SR_META_V3_DATA_OFFSET(16 + 64);
952	sm->ssdi_sdd_invariant.ssd_secsize = DEV_BSIZE(1 << 9);
953
954	} else if (sm->ssdi_sdd_invariant.ssd_version == 4) {
955
956	/*
957	* Version 4 - original metadata format did not store
958	* data blkno so fix this up if necessary.
959	*/
960	if (sm->ssd_data_blkno == 0)
961	sm->ssd_data_blkno = SR_DATA_OFFSET(16 + (64 + (320 + 128)));
962	sm->ssdi_sdd_invariant.ssd_secsize = DEV_BSIZE(1 << 9);
963
964	} else if (sm->ssdi_sdd_invariant.ssd_version == 5) {
965
966	/*
967	* Version 5 - variable length optional metadata. Migration
968	* from earlier fixed length optional metadata is handled
969	* in sr_meta_read().
970	*/
971	sm->ssdi_sdd_invariant.ssd_secsize = DEV_BSIZE(1 << 9);
972
973	} else if (sm->ssdi_sdd_invariant.ssd_version == SR_META_VERSION6) {
974
975	/*
976	* Version 6 - store & report a sector size.
977	*/
978
979	} else {
980
981	sr_error(sc, "cannot read metadata version %u on %s, "
982	"expected version %u or earlier",
983	sm->ssdi_sdd_invariant.ssd_version, devname, SR_META_VERSION6);
984	goto done;
985
986	}
987
988	/* Update version number and revision string. */
989	sm->ssdi_sdd_invariant.ssd_version = SR_META_VERSION6;
990	snprintf(sm->ssdi_sdd_invariant.ssd_revision, sizeof(sm->ssdi_sdd_invariant.ssd_revision),
991	"%03d", SR_META_VERSION6);
992
993	#ifdef SR_DEBUG
994	/* warn if disk changed order */
995	mc = (struct sr_meta_chunk *)(sm + 1);
996	if (strncmp(mc[sm->ssdi_sdd_invariant.ssd_chunk_id].scmi_scm_invariant.scm_devname, devname,
997	sizeof(mc[sm->ssdi_sdd_invariant.ssd_chunk_id].scmi_scm_invariant.scm_devname)))
998	DNPRINTF(SR_D_META, "%s: roaming device %s -> %s\n",
999	DEVNAME(sc), mc[sm->ssdi.ssd_chunk_id].scmi.scm_devname,
1000	devname);
1001	#endif
1002
1003	/* we have meta data on disk */
1004	DNPRINTF(SR_D_META, "%s: sr_meta_validate valid metadata %s\n",
1005	DEVNAME(sc), devname);
1006
1007	rv = 0;
1008	done:
1009	return (rv);
1010	}
1011
1012	int
1013	sr_meta_native_bootprobe(struct sr_softc *sc, dev_t devno,
1014	struct sr_boot_chunk_head *bch)
1015	{
1016	struct vnode *vn;
1017	struct disklabel label;
1018	struct sr_metadata md = NULL((void )0);
1019	struct sr_discipline fake_sd = NULL((void )0);
1020	struct sr_boot_chunk *bc;
1021	char devname[32];
1022	dev_t chrdev, rawdev;
1023	int error, i;
1024	int rv = SR_META_NOTCLAIMED(0);
1025
1026	DNPRINTF(SR_D_META, "%s: sr_meta_native_bootprobe\n", DEVNAME(sc));
1027
1028	/*
1029	* Use character raw device to avoid SCSI complaints about missing
1030	* media on removable media devices.
1031	*/
1032	chrdev = blktochr(devno);
1033	rawdev = MAKEDISKDEV(major(chrdev), DISKUNIT(devno), RAW_PART)(((dev_t)((((((((unsigned)(chrdev) >> 8) & 0xff))) & 0xff) << 8) \| (((((((((unsigned)((devno) & 0xff) \| (((devno) & 0xffff0000) >> 8)) / 16))) * 16) + ((2 )))) & 0xff) \| ((((((((((unsigned)((devno) & 0xff) \| ( ((devno) & 0xffff0000) >> 8)) / 16))) * 16) + ((2)) )) & 0xffff00) << 8))));
1034	if (cdevvp(rawdev, &vn)) {
1035	sr_error(sc, "sr_meta_native_bootprobe: cannot allocate vnode");
1036	goto done;
1037	}
1038
1039	/* open device */
1040	error = VOP_OPEN(vn, FREAD0x0001, NOCRED((struct ucred )-1), curproc({struct cpu_info __ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc);
1041	if (error) {
1042	DNPRINTF(SR_D_META, "%s: sr_meta_native_bootprobe open "
1043	"failed\n", DEVNAME(sc));
1044	vput(vn);
1045	goto done;
1046	}
1047
1048	/* get disklabel */
1049	error = VOP_IOCTL(vn, DIOCGDINFO((unsigned long)0x40000000 \| ((sizeof(struct disklabel) & 0x1fff) << 16) \| ((('d')) << 8) \| ((101))), (caddr_t)&label, FREAD0x0001, NOCRED((struct ucred *)-1),
1050	curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc);
1051	if (error) {
1052	DNPRINTF(SR_D_META, "%s: sr_meta_native_bootprobe ioctl "
1053	"failed\n", DEVNAME(sc));
1054	VOP_CLOSE(vn, FREAD0x0001, NOCRED((struct ucred )-1), curproc({struct cpu_info __ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc);
1055	vput(vn);
1056	goto done;
1057	}
1058
1059	/* we are done, close device */
1060	error = VOP_CLOSE(vn, FREAD0x0001, NOCRED((struct ucred )-1), curproc({struct cpu_info __ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc);
1061	if (error) {
1062	DNPRINTF(SR_D_META, "%s: sr_meta_native_bootprobe close "
1063	"failed\n", DEVNAME(sc));
1064	vput(vn);
1065	goto done;
1066	}
1067	vput(vn);
1068
1069	md = malloc(SR_META_SIZE64 * DEV_BSIZE(1 << 9), M_DEVBUF2, M_ZERO0x0008 \| M_NOWAIT0x0002);
1070	if (md == NULL((void *)0)) {
1071	sr_error(sc, "not enough memory for metadata buffer");
1072	goto done;
1073	}
1074
1075	/* create fake sd to use utility functions */
1076	fake_sd = malloc(sizeof(struct sr_discipline), M_DEVBUF2,
1077	M_ZERO0x0008 \| M_NOWAIT0x0002);
1078	if (fake_sd == NULL((void *)0)) {
1079	sr_error(sc, "not enough memory for fake discipline");
1080	goto done;
1081	}
1082	fake_sd->sd_sc = sc;
1083	fake_sd->sd_meta_type = SR_META_F_NATIVE0;
1084
1085	for (i = 0; i < MAXPARTITIONS16; i++) {
1086	if (label.d_partitions[i].p_fstype != FS_RAID19)
1087	continue;
1088
1089	/* open partition */
1090	rawdev = MAKEDISKDEV(major(devno), DISKUNIT(devno), i)(((dev_t)((((((((unsigned)(devno) >> 8) & 0xff))) & 0xff) << 8) \| (((((((((unsigned)((devno) & 0xff) \| (((devno) & 0xffff0000) >> 8)) / 16))) * 16) + ((i )))) & 0xff) \| ((((((((((unsigned)((devno) & 0xff) \| ( ((devno) & 0xffff0000) >> 8)) / 16))) * 16) + ((i)) )) & 0xffff00) << 8))));
1091	if (bdevvp(rawdev, &vn)) {
1092	sr_error(sc, "sr_meta_native_bootprobe: cannot "
1093	"allocate vnode for partition");
1094	goto done;
1095	}
1096	error = VOP_OPEN(vn, FREAD0x0001, NOCRED((struct ucred )-1), curproc({struct cpu_info __ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc);
1097	if (error) {
1098	DNPRINTF(SR_D_META, "%s: sr_meta_native_bootprobe "
1099	"open failed, partition %d\n",
1100	DEVNAME(sc), i);
1101	vput(vn);
1102	continue;
1103	}
1104
1105	if (sr_meta_native_read(fake_sd, rawdev, md, NULL((void *)0))) {
1106	sr_error(sc, "native bootprobe could not read native "
1107	"metadata");
1108	VOP_CLOSE(vn, FREAD0x0001, NOCRED((struct ucred )-1), curproc({struct cpu_info __ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc);
1109	vput(vn);
1110	continue;
1111	}
1112
1113	/* are we a softraid partition? */
1114	if (md->ssdi_sdd_invariant.ssd_magic != SR_MAGIC0x4d4152436372616dLLU) {
1115	VOP_CLOSE(vn, FREAD0x0001, NOCRED((struct ucred )-1), curproc({struct cpu_info __ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc);
1116	vput(vn);
1117	continue;
1118	}
1119
1120	sr_meta_getdevname(sc, rawdev, devname, sizeof(devname));
1121	if (sr_meta_validate(fake_sd, rawdev, md, NULL((void *)0)) == 0) {
1122	/* XXX fix M_WAITOK, this is boot time */
1123	bc = malloc(sizeof(struct sr_boot_chunk),
1124	M_DEVBUF2, M_WAITOK0x0001 \| M_ZERO0x0008);
1125	bc->sbc_metadata = malloc(sizeof(struct sr_metadata),
1126	M_DEVBUF2, M_WAITOK0x0001 \| M_ZERO0x0008);
1127	memcpy(bc->sbc_metadata, md, sizeof(struct sr_metadata))__builtin_memcpy((bc->sbc_metadata), (md), (sizeof(struct sr_metadata )));
1128	bc->sbc_mm = rawdev;
1129	SLIST_INSERT_HEAD(bch, bc, sbc_link)do { (bc)->sbc_link.sle_next = (bch)->slh_first; (bch)-> slh_first = (bc); } while (0);
1130	rv = SR_META_CLAIMED(1);
1131	}
1132
1133	/* we are done, close partition */
1134	VOP_CLOSE(vn, FREAD0x0001, NOCRED((struct ucred )-1), curproc({struct cpu_info __ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc);
1135	vput(vn);
1136	}
1137
1138	done:
1139	free(fake_sd, M_DEVBUF2, sizeof(struct sr_discipline));
1140	free(md, M_DEVBUF2, SR_META_SIZE64 * DEV_BSIZE(1 << 9));
1141
1142	return (rv);
1143	}
1144
1145	int
1146	sr_boot_assembly(struct sr_softc *sc)
1147	{
1148	struct sr_boot_volume_head bvh;
1149	struct sr_boot_chunk_head bch, kdh;
1150	struct sr_boot_volume bv, bv1, *bv2;
1151	struct sr_boot_chunk bc, bcnext, bc1, bc2;
1152	struct sr_disk_head sdklist;
1153	struct sr_disk *sdk;
1154	struct disk *dk;
1155	struct bioc_createraid bcr;
1156	struct sr_meta_chunk *hm;
1157	struct sr_chunk_head *cl;
1158	struct sr_chunk hotspare, chunk, *last;
1159	u_int64_t ondisk = NULL((void )0);
1160	dev_t devs = NULL((void )0);
1161	void *data;
1162	char devname[32];
1163	int rv = 0, i;
1164
1165	DNPRINTF(SR_D_META, "%s: sr_boot_assembly\n", DEVNAME(sc));
1166
1167	SLIST_INIT(&sdklist){ ((&sdklist)->slh_first) = ((void *)0); };
1168	SLIST_INIT(&bvh){ ((&bvh)->slh_first) = ((void *)0); };
1169	SLIST_INIT(&bch){ ((&bch)->slh_first) = ((void *)0); };
1170	SLIST_INIT(&kdh){ ((&kdh)->slh_first) = ((void *)0); };
1171
1172	dk = TAILQ_FIRST(&disklist)((&disklist)->tqh_first);
1173	while (dk != NULL((void *)0)) {
1174
1175	/* See if this disk has been checked. */
1176	SLIST_FOREACH(sdk, &sdklist, sdk_link)for((sdk) = ((&sdklist)->slh_first); (sdk) != ((void * )0); (sdk) = ((sdk)->sdk_link.sle_next))
1177	if (sdk->sdk_devno == dk->dk_devno)
1178	break;
1179
1180	if (sdk != NULL((void *)0) \|\| dk->dk_devno == NODEV(dev_t)(-1)) {
1181	dk = TAILQ_NEXT(dk, dk_link)((dk)->dk_link.tqe_next);
1182	continue;
1183	}
1184
1185	/* Add this disk to the list that we've checked. */
1186	sdk = malloc(sizeof(struct sr_disk), M_DEVBUF2,
1187	M_NOWAIT0x0002 \| M_ZERO0x0008);
1188	if (sdk == NULL((void *)0))
1189	goto unwind;
1190	sdk->sdk_devno = dk->dk_devno;
1191	SLIST_INSERT_HEAD(&sdklist, sdk, sdk_link)do { (sdk)->sdk_link.sle_next = (&sdklist)->slh_first ; (&sdklist)->slh_first = (sdk); } while (0);
1192
1193	/* Only check sd(4) and wd(4) devices. */
1194	if (strncmp(dk->dk_name, "sd", 2) &&
1195	strncmp(dk->dk_name, "wd", 2)) {
1196	dk = TAILQ_NEXT(dk, dk_link)((dk)->dk_link.tqe_next);
1197	continue;
1198	}
1199
1200	/* native softraid uses partitions */
1201	rw_enter_write(&sc->sc_lock);
1202	bio_status_init(&sc->sc_status, &sc->sc_dev);
1203	sr_meta_native_bootprobe(sc, dk->dk_devno, &bch);
1204	rw_exit_write(&sc->sc_lock);
1205
1206	/* probe non-native disks if native failed. */
1207
1208	/* Restart scan since we may have slept. */
1209	dk = TAILQ_FIRST(&disklist)((&disklist)->tqh_first);
1210	}
1211
1212	/*
1213	* Create a list of volumes and associate chunks with each volume.
1214	*/
1215	for (bc = SLIST_FIRST(&bch)((&bch)->slh_first); bc != NULL((void *)0); bc = bcnext) {
1216
1217	bcnext = SLIST_NEXT(bc, sbc_link)((bc)->sbc_link.sle_next);
1218	SLIST_REMOVE(&bch, bc, sr_boot_chunk, sbc_link)do { if ((&bch)->slh_first == (bc)) { do { ((&bch) )->slh_first = ((&bch))->slh_first->sbc_link.sle_next ; } while (0); } else { struct sr_boot_chunk curelm = (& bch)->slh_first; while (curelm->sbc_link.sle_next != (bc )) curelm = curelm->sbc_link.sle_next; curelm->sbc_link .sle_next = curelm->sbc_link.sle_next->sbc_link.sle_next ; } ((bc)->sbc_link.sle_next) = ((void )-1); } while (0);
1219	bc->sbc_chunk_id = bc->sbc_metadata->ssdi_sdd_invariant.ssd_chunk_id;
1220
1221	/* Handle key disks separately. */
1222	if (bc->sbc_metadata->ssdi_sdd_invariant.ssd_level == SR_KEYDISK_LEVEL0xfffffffe) {
1223	SLIST_INSERT_HEAD(&kdh, bc, sbc_link)do { (bc)->sbc_link.sle_next = (&kdh)->slh_first; ( &kdh)->slh_first = (bc); } while (0);
1224	continue;
1225	}
1226
1227	SLIST_FOREACH(bv, &bvh, sbv_link)for((bv) = ((&bvh)->slh_first); (bv) != ((void *)0); ( bv) = ((bv)->sbv_link.sle_next)) {
1228	if (bcmp(&bc->sbc_metadata->ssdi_sdd_invariant.ssd_uuid,
1229	&bv->sbv_uuid,
1230	sizeof(bc->sbc_metadata->ssdi_sdd_invariant.ssd_uuid)) == 0)
1231	break;
1232	}
1233
1234	if (bv == NULL((void *)0)) {
1235	bv = malloc(sizeof(struct sr_boot_volume),
1236	M_DEVBUF2, M_NOWAIT0x0002 \| M_ZERO0x0008);
1237	if (bv == NULL((void *)0)) {
1238	printf("%s: failed to allocate boot volume\n",
1239	DEVNAME(sc)((sc)->sc_dev.dv_xname));
1240	goto unwind;
1241	}
1242
1243	bv->sbv_level = bc->sbc_metadata->ssdi_sdd_invariant.ssd_level;
1244	bv->sbv_volid = bc->sbc_metadata->ssdi_sdd_invariant.ssd_volid;
1245	bv->sbv_chunk_no = bc->sbc_metadata->ssdi_sdd_invariant.ssd_chunk_no;
1246	bv->sbv_flags = bc->sbc_metadata->ssdi_sdd_invariant.ssd_vol_flags;
1247	memcpy(&bv->sbv_uuid, &bc->sbc_metadata->ssdi.ssd_uuid,__builtin_memcpy((&bv->sbv_uuid), (&bc->sbc_metadata ->_sdd_invariant.ssd_uuid), (sizeof(bc->sbc_metadata-> _sdd_invariant.ssd_uuid)))
1248	sizeof(bc->sbc_metadata->ssdi.ssd_uuid))__builtin_memcpy((&bv->sbv_uuid), (&bc->sbc_metadata ->_sdd_invariant.ssd_uuid), (sizeof(bc->sbc_metadata-> _sdd_invariant.ssd_uuid)));
1249	SLIST_INIT(&bv->sbv_chunks){ ((&bv->sbv_chunks)->slh_first) = ((void *)0); };
1250
1251	/* Maintain volume order. */
1252	bv2 = NULL((void *)0);
1253	SLIST_FOREACH(bv1, &bvh, sbv_link)for((bv1) = ((&bvh)->slh_first); (bv1) != ((void *)0); (bv1) = ((bv1)->sbv_link.sle_next)) {
1254	if (bv1->sbv_volid > bv->sbv_volid)
1255	break;
1256	bv2 = bv1;
1257	}
1258	if (bv2 == NULL((void *)0)) {
1259	DNPRINTF(SR_D_META, "%s: insert volume %u "
1260	"at head\n", DEVNAME(sc), bv->sbv_volid);
1261	SLIST_INSERT_HEAD(&bvh, bv, sbv_link)do { (bv)->sbv_link.sle_next = (&bvh)->slh_first; ( &bvh)->slh_first = (bv); } while (0);
1262	} else {
1263	DNPRINTF(SR_D_META, "%s: insert volume %u "
1264	"after %u\n", DEVNAME(sc), bv->sbv_volid,
1265	bv2->sbv_volid);
1266	SLIST_INSERT_AFTER(bv2, bv, sbv_link)do { (bv)->sbv_link.sle_next = (bv2)->sbv_link.sle_next ; (bv2)->sbv_link.sle_next = (bv); } while (0);
1267	}
1268	}
1269
1270	/* Maintain chunk order. */
1271	bc2 = NULL((void *)0);
1272	SLIST_FOREACH(bc1, &bv->sbv_chunks, sbc_link)for((bc1) = ((&bv->sbv_chunks)->slh_first); (bc1) != ((void *)0); (bc1) = ((bc1)->sbc_link.sle_next)) {
1273	if (bc1->sbc_chunk_id > bc->sbc_chunk_id)
1274	break;
1275	bc2 = bc1;
1276	}
1277	if (bc2 == NULL((void *)0)) {
1278	DNPRINTF(SR_D_META, "%s: volume %u insert chunk %u "
1279	"at head\n", DEVNAME(sc), bv->sbv_volid,
1280	bc->sbc_chunk_id);
1281	SLIST_INSERT_HEAD(&bv->sbv_chunks, bc, sbc_link)do { (bc)->sbc_link.sle_next = (&bv->sbv_chunks)-> slh_first; (&bv->sbv_chunks)->slh_first = (bc); } while (0);
1282	} else {
1283	DNPRINTF(SR_D_META, "%s: volume %u insert chunk %u "
1284	"after %u\n", DEVNAME(sc), bv->sbv_volid,
1285	bc->sbc_chunk_id, bc2->sbc_chunk_id);
1286	SLIST_INSERT_AFTER(bc2, bc, sbc_link)do { (bc)->sbc_link.sle_next = (bc2)->sbc_link.sle_next ; (bc2)->sbc_link.sle_next = (bc); } while (0);
1287	}
1288
1289	bv->sbv_chunks_found++;
1290	}
1291
1292	/* Allocate memory for device and ondisk version arrays. */
1293	devs = mallocarray(BIOC_CRMAXLEN1024, sizeof(dev_t), M_DEVBUF2,
1294	M_NOWAIT0x0002);
1295	if (devs == NULL((void *)0)) {
1296	printf("%s: failed to allocate device array\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
1297	goto unwind;
1298	}
1299	ondisk = mallocarray(BIOC_CRMAXLEN1024, sizeof(u_int64_t), M_DEVBUF2,
1300	M_NOWAIT0x0002);
1301	if (ondisk == NULL((void *)0)) {
1302	printf("%s: failed to allocate ondisk array\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
1303	goto unwind;
1304	}
1305
1306	/*
1307	* Assemble hotspare "volumes".
1308	*/
1309	SLIST_FOREACH(bv, &bvh, sbv_link)for((bv) = ((&bvh)->slh_first); (bv) != ((void *)0); ( bv) = ((bv)->sbv_link.sle_next)) {
1310
1311	/* Check if this is a hotspare "volume". */
1312	if (bv->sbv_level != SR_HOTSPARE_LEVEL0xffffffff \|\|
1313	bv->sbv_chunk_no != 1)
1314	continue;
1315
1316	#ifdef SR_DEBUG
1317	DNPRINTF(SR_D_META, "%s: assembling hotspare volume ",
1318	DEVNAME(sc));
1319	if (sr_debug & SR_D_META)
1320	sr_uuid_print(&bv->sbv_uuid, 0);
1321	DNPRINTF(SR_D_META, " volid %u with %u chunks\n",
1322	bv->sbv_volid, bv->sbv_chunk_no);
1323	#endif
1324
1325	/* Create hotspare chunk metadata. */
1326	hotspare = malloc(sizeof(struct sr_chunk), M_DEVBUF2,
1327	M_NOWAIT0x0002 \| M_ZERO0x0008);
1328	if (hotspare == NULL((void *)0)) {
1329	printf("%s: failed to allocate hotspare\n",
1330	DEVNAME(sc)((sc)->sc_dev.dv_xname));
1331	goto unwind;
1332	}
1333
1334	bc = SLIST_FIRST(&bv->sbv_chunks)((&bv->sbv_chunks)->slh_first);
1335	sr_meta_getdevname(sc, bc->sbc_mm, devname, sizeof(devname));
1336	hotspare->src_dev_mm = bc->sbc_mm;
1337	strlcpy(hotspare->src_devname, devname,
1338	sizeof(hotspare->src_devname));
1339	hotspare->src_size = bc->sbc_metadata->ssdi_sdd_invariant.ssd_size;
1340
1341	hm = &hotspare->src_meta;
1342	hm->scmi_scm_invariant.scm_volid = SR_HOTSPARE_VOLID0xffffffff;
1343	hm->scmi_scm_invariant.scm_chunk_id = 0;
1344	hm->scmi_scm_invariant.scm_size = bc->sbc_metadata->ssdi_sdd_invariant.ssd_size;
1345	hm->scmi_scm_invariant.scm_coerced_size = bc->sbc_metadata->ssdi_sdd_invariant.ssd_size;
1346	strlcpy(hm->scmi_scm_invariant.scm_devname, devname,
1347	sizeof(hm->scmi_scm_invariant.scm_devname));
1348	memcpy(&hm->scmi.scm_uuid, &bc->sbc_metadata->ssdi.ssd_uuid,__builtin_memcpy((&hm->_scm_invariant.scm_uuid), (& bc->sbc_metadata->_sdd_invariant.ssd_uuid), (sizeof(struct sr_uuid)))
1349	sizeof(struct sr_uuid))__builtin_memcpy((&hm->_scm_invariant.scm_uuid), (& bc->sbc_metadata->_sdd_invariant.ssd_uuid), (sizeof(struct sr_uuid)));
1350
1351	sr_checksum(sc, hm, &hm->scm_checksum,
1352	sizeof(struct sr_meta_chunk_invariant));
1353
1354	hm->scm_status = BIOC_SDHOTSPARE0x04;
1355
1356	/* Add chunk to hotspare list. */
1357	rw_enter_write(&sc->sc_hs_lock);
1358	cl = &sc->sc_hotspare_list;
1359	if (SLIST_EMPTY(cl)(((cl)->slh_first) == ((void *)0)))
1360	SLIST_INSERT_HEAD(cl, hotspare, src_link)do { (hotspare)->src_link.sle_next = (cl)->slh_first; ( cl)->slh_first = (hotspare); } while (0);
1361	else {
1362	SLIST_FOREACH(chunk, cl, src_link)for((chunk) = ((cl)->slh_first); (chunk) != ((void *)0); ( chunk) = ((chunk)->src_link.sle_next))
1363	last = chunk;
1364	SLIST_INSERT_AFTER(last, hotspare, src_link)do { (hotspare)->src_link.sle_next = (last)->src_link.sle_next ; (last)->src_link.sle_next = (hotspare); } while (0);
1365	}
1366	sc->sc_hotspare_no++;
1367	rw_exit_write(&sc->sc_hs_lock);
1368
1369	}
1370
1371	/*
1372	* Assemble RAID volumes.
1373	*/
1374	SLIST_FOREACH(bv, &bvh, sbv_link)for((bv) = ((&bvh)->slh_first); (bv) != ((void *)0); ( bv) = ((bv)->sbv_link.sle_next)) {
1375
1376	bzero(&bcr, sizeof(bcr))__builtin_bzero((&bcr), (sizeof(bcr)));
1377	data = NULL((void *)0);
1378
1379	/* Check if this is a hotspare "volume". */
1380	if (bv->sbv_level == SR_HOTSPARE_LEVEL0xffffffff &&
1381	bv->sbv_chunk_no == 1)
1382	continue;
1383
1384	/*
1385	* Skip volumes that are marked as no auto assemble, unless
1386	* this was the volume which we actually booted from.
1387	*/
1388	if (bcmp(&sr_bootuuid, &bv->sbv_uuid, sizeof(sr_bootuuid)) != 0)
1389	if (bv->sbv_flags & BIOC_SCNOAUTOASSEMBLE0x04)
1390	continue;
1391
1392	#ifdef SR_DEBUG
1393	DNPRINTF(SR_D_META, "%s: assembling volume ", DEVNAME(sc));
1394	if (sr_debug & SR_D_META)
1395	sr_uuid_print(&bv->sbv_uuid, 0);
1396	DNPRINTF(SR_D_META, " volid %u with %u chunks\n",
1397	bv->sbv_volid, bv->sbv_chunk_no);
1398	#endif
1399
1400	/*
1401	* If this is a crypto volume, try to find a matching
1402	* key disk...
1403	*/
1404	bcr.bc_key_disk = NODEV(dev_t)(-1);
1405	if (bv->sbv_level == 'C' \|\| bv->sbv_level == 0x1C) {
1406	SLIST_FOREACH(bc, &kdh, sbc_link)for((bc) = ((&kdh)->slh_first); (bc) != ((void *)0); ( bc) = ((bc)->sbc_link.sle_next)) {
1407	if (bcmp(&bc->sbc_metadata->ssdi_sdd_invariant.ssd_uuid,
1408	&bv->sbv_uuid,
1409	sizeof(bc->sbc_metadata->ssdi_sdd_invariant.ssd_uuid))
1410	== 0)
1411	bcr.bc_key_disk = bc->sbc_mm;
1412	}
1413	}
1414
1415	for (i = 0; i < BIOC_CRMAXLEN1024; i++) {
1416	devs[i] = NODEV(dev_t)(-1); /* mark device as illegal */
1417	ondisk[i] = 0;
1418	}
1419
1420	SLIST_FOREACH(bc, &bv->sbv_chunks, sbc_link)for((bc) = ((&bv->sbv_chunks)->slh_first); (bc) != ( (void *)0); (bc) = ((bc)->sbc_link.sle_next)) {
1421	if (devs[bc->sbc_chunk_id] != NODEV(dev_t)(-1)) {
1422	bv->sbv_chunks_found--;
1423	sr_meta_getdevname(sc, bc->sbc_mm, devname,
1424	sizeof(devname));
1425	printf("%s: found duplicate chunk %u for "
1426	"volume %u on device %s\n", DEVNAME(sc)((sc)->sc_dev.dv_xname),
1427	bc->sbc_chunk_id, bv->sbv_volid, devname);
1428	}
1429
1430	if (devs[bc->sbc_chunk_id] == NODEV(dev_t)(-1) \|\|
1431	bc->sbc_metadata->ssd_ondisk >
1432	ondisk[bc->sbc_chunk_id]) {
1433	devs[bc->sbc_chunk_id] = bc->sbc_mm;
1434	ondisk[bc->sbc_chunk_id] =
1435	bc->sbc_metadata->ssd_ondisk;
1436	DNPRINTF(SR_D_META, "%s: using ondisk "
1437	"metadata version %llu for chunk %u\n",
1438	DEVNAME(sc), ondisk[bc->sbc_chunk_id],
1439	bc->sbc_chunk_id);
1440	}
1441	}
1442
1443	if (bv->sbv_chunk_no != bv->sbv_chunks_found) {
1444	printf("%s: not all chunks were provided; "
1445	"attempting to bring volume %d online\n",
1446	DEVNAME(sc)((sc)->sc_dev.dv_xname), bv->sbv_volid);
1447	}
1448
1449	bcr.bc_level = bv->sbv_level;
1450	bcr.bc_dev_list_len = bv->sbv_chunk_no * sizeof(dev_t);
1451	bcr.bc_dev_list = devs;
1452	bcr.bc_flags = BIOC_SCDEVT0x02 \|
1453	(bv->sbv_flags & BIOC_SCNOAUTOASSEMBLE0x04);
1454
1455	if ((bv->sbv_level == 'C' \|\| bv->sbv_level == 0x1C) &&
1456	bcmp(&sr_bootuuid, &bv->sbv_uuid, sizeof(sr_bootuuid)) == 0)
1457	data = sr_bootkey;
1458
1459	rw_enter_write(&sc->sc_lock);
1460	bio_status_init(&sc->sc_status, &sc->sc_dev);
1461	sr_ioctl_createraid(sc, &bcr, 0, data);
1462	rw_exit_write(&sc->sc_lock);
1463
1464	rv++;
1465	}
1466
1467	/* done with metadata */
1468	unwind:
1469	/* Free boot volumes and associated chunks. */
1470	for (bv1 = SLIST_FIRST(&bvh)((&bvh)->slh_first); bv1 != NULL((void *)0); bv1 = bv2) {
1471	bv2 = SLIST_NEXT(bv1, sbv_link)((bv1)->sbv_link.sle_next);
1472	for (bc1 = SLIST_FIRST(&bv1->sbv_chunks)((&bv1->sbv_chunks)->slh_first); bc1 != NULL((void *)0);
1473	bc1 = bc2) {
1474	bc2 = SLIST_NEXT(bc1, sbc_link)((bc1)->sbc_link.sle_next);
1475	free(bc1->sbc_metadata, M_DEVBUF2,
1476	sizeof(*bc1->sbc_metadata));
1477	free(bc1, M_DEVBUF2, sizeof(*bc1));
1478	}
1479	free(bv1, M_DEVBUF2, sizeof(*bv1));
1480	}
1481	/* Free keydisks chunks. */
1482	for (bc1 = SLIST_FIRST(&kdh)((&kdh)->slh_first); bc1 != NULL((void *)0); bc1 = bc2) {
1483	bc2 = SLIST_NEXT(bc1, sbc_link)((bc1)->sbc_link.sle_next);
1484	free(bc1->sbc_metadata, M_DEVBUF2, sizeof(*bc1->sbc_metadata));
1485	free(bc1, M_DEVBUF2, sizeof(*bc1));
1486	}
1487	/* Free unallocated chunks. */
1488	for (bc1 = SLIST_FIRST(&bch)((&bch)->slh_first); bc1 != NULL((void *)0); bc1 = bc2) {
1489	bc2 = SLIST_NEXT(bc1, sbc_link)((bc1)->sbc_link.sle_next);
1490	free(bc1->sbc_metadata, M_DEVBUF2, sizeof(*bc1->sbc_metadata));
1491	free(bc1, M_DEVBUF2, sizeof(*bc1));
1492	}
1493
1494	while (!SLIST_EMPTY(&sdklist)(((&sdklist)->slh_first) == ((void *)0))) {
1495	sdk = SLIST_FIRST(&sdklist)((&sdklist)->slh_first);
1496	SLIST_REMOVE_HEAD(&sdklist, sdk_link)do { (&sdklist)->slh_first = (&sdklist)->slh_first ->sdk_link.sle_next; } while (0);
1497	free(sdk, M_DEVBUF2, sizeof(*sdk));
1498	}
1499
1500	free(devs, M_DEVBUF2, BIOC_CRMAXLEN1024 * sizeof(dev_t));
1501	free(ondisk, M_DEVBUF2, BIOC_CRMAXLEN1024 * sizeof(u_int64_t));
1502
1503	return (rv);
1504	}
1505
1506	void
1507	sr_map_root(void)
1508	{
1509	struct sr_softc *sc = softraid0;
1510	struct sr_discipline *sd;
1511	struct sr_meta_opt_item *omi;
1512	struct sr_meta_boot *sbm;
1513	u_char duid[8];
1514	int i;
1515
1516	if (sc == NULL((void *)0))
1517	return;
1518
1519	DNPRINTF(SR_D_MISC, "%s: sr_map_root\n", DEVNAME(sc));
1520
1521	bzero(duid, sizeof(duid))__builtin_bzero((duid), (sizeof(duid)));
1522	if (bcmp(rootduid, duid, sizeof(duid)) == 0) {
1523	DNPRINTF(SR_D_MISC, "%s: root duid is zero\n", DEVNAME(sc));
1524	return;
1525	}
1526
1527	TAILQ_FOREACH(sd, &sc->sc_dis_list, sd_link)for((sd) = ((&sc->sc_dis_list)->tqh_first); (sd) != ((void *)0); (sd) = ((sd)->sd_link.tqe_next)) {
1528	SLIST_FOREACH(omi, &sd->sd_meta_opt, omi_link)for((omi) = ((&sd->sd_meta_opt)->slh_first); (omi) != ((void *)0); (omi) = ((omi)->omi_link.sle_next)) {
1529	if (omi->omi_som->som_type != SR_OPT_BOOT0x02)
1530	continue;
1531	sbm = (struct sr_meta_boot *)omi->omi_som;
1532	for (i = 0; i < SR_MAX_BOOT_DISKS16; i++) {
1533	if (bcmp(rootduid, sbm->sbm_boot_duid[i],
1534	sizeof(rootduid)) == 0) {
1535	memcpy(rootduid, sbm->sbm_root_duid,__builtin_memcpy((rootduid), (sbm->sbm_root_duid), (sizeof (rootduid)))
1536	sizeof(rootduid))__builtin_memcpy((rootduid), (sbm->sbm_root_duid), (sizeof (rootduid)));
1537	DNPRINTF(SR_D_MISC, "%s: root duid "
1538	"mapped to %s\n", DEVNAME(sc),
1539	duid_format(rootduid));
1540	return;
1541	}
1542	}
1543	}
1544	}
1545	}
1546
1547	int
1548	sr_meta_native_probe(struct sr_softc sc, struct sr_chunk ch_entry)
1549	{
1550	struct disklabel label;
1551	char *devname;
1552	int error, part;
1553	u_int64_t size;
1554
1555	DNPRINTF(SR_D_META, "%s: sr_meta_native_probe(%s)\n",
1556	DEVNAME(sc), ch_entry->src_devname);
1557
1558	devname = ch_entry->src_devname;
1559	part = DISKPART(ch_entry->src_dev_mm)(((unsigned)((ch_entry->src_dev_mm) & 0xff) \| (((ch_entry ->src_dev_mm) & 0xffff0000) >> 8)) % 16);
1560
1561	/* get disklabel */
1562	error = VOP_IOCTL(ch_entry->src_vn, DIOCGDINFO((unsigned long)0x40000000 \| ((sizeof(struct disklabel) & 0x1fff) << 16) \| ((('d')) << 8) \| ((101))), (caddr_t)&label, FREAD0x0001,
1563	NOCRED((struct ucred )-1), curproc({struct cpu_info __ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc);
1564	if (error) {
1565	DNPRINTF(SR_D_META, "%s: %s can't obtain disklabel\n",
1566	DEVNAME(sc), devname);
1567	goto unwind;
1568	}
1569	memcpy(ch_entry->src_duid, label.d_uid, sizeof(ch_entry->src_duid))__builtin_memcpy((ch_entry->src_duid), (label.d_uid), (sizeof (ch_entry->src_duid)));
1570
1571	/* make sure the partition is of the right type */
1572	if (label.d_partitions[part].p_fstype != FS_RAID19) {
1573	DNPRINTF(SR_D_META,
1574	"%s: %s partition not of type RAID (%d)\n", DEVNAME(sc),
1575	devname,
1576	label.d_partitions[part].p_fstype);
1577	goto unwind;
1578	}
1579
1580	size = DL_SECTOBLK(&label, DL_GETPSIZE(&label.d_partitions[part]))(((((u_int64_t)(&label.d_partitions[part])->p_sizeh << 32) + (&label.d_partitions[part])->p_size)) * ((& label)->d_secsize / (1 << 9)));
1581	if (size <= SR_DATA_OFFSET(16 + (64 + (320 + 128)))) {
1582	DNPRINTF(SR_D_META, "%s: %s partition too small\n", DEVNAME(sc),
1583	devname);
1584	goto unwind;
1585	}
1586	size -= SR_DATA_OFFSET(16 + (64 + (320 + 128)));
1587	if (size > INT64_MAX0x7fffffffffffffffLL) {
1588	DNPRINTF(SR_D_META, "%s: %s partition too large\n", DEVNAME(sc),
1589	devname);
1590	goto unwind;
1591	}
1592	ch_entry->src_size = size;
1593	ch_entry->src_secsize = label.d_secsize;
1594
1595	DNPRINTF(SR_D_META, "%s: probe found %s size %lld\n", DEVNAME(sc),
1596	devname, (long long)size);
1597
1598	return (SR_META_F_NATIVE0);
1599	unwind:
1600	DNPRINTF(SR_D_META, "%s: invalid device: %s\n", DEVNAME(sc),
1601	devname ? devname : "nodev");
1602	return (SR_META_F_INVALID-1);
1603	}
1604
1605	int
1606	sr_meta_native_attach(struct sr_discipline *sd, int force)
1607	{
1608	struct sr_softc *sc = sd->sd_sc;
1609	struct sr_chunk_head *cl = &sd->sd_vol.sv_chunk_list;
1610	struct sr_metadata md = NULL((void )0);
1611	struct sr_chunk ch_entry, ch_next;
1612	struct sr_uuid uuid;
1613	u_int64_t version = 0;
1614	int sr, not_sr, rv = 1, d, expected = -1, old_meta = 0;
1615
1616	DNPRINTF(SR_D_META, "%s: sr_meta_native_attach\n", DEVNAME(sc));
1617
1618	md = malloc(SR_META_SIZE64 * DEV_BSIZE(1 << 9), M_DEVBUF2, M_ZERO0x0008 \| M_NOWAIT0x0002);
1619	if (md == NULL((void *)0)) {
1620	sr_error(sc, "not enough memory for metadata buffer");
1621	goto bad;
1622	}
1623
1624	bzero(&uuid, sizeof uuid)__builtin_bzero((&uuid), (sizeof uuid));
1625
1626	sr = not_sr = d = 0;
1627	SLIST_FOREACH(ch_entry, cl, src_link)for((ch_entry) = ((cl)->slh_first); (ch_entry) != ((void * )0); (ch_entry) = ((ch_entry)->src_link.sle_next)) {
1628	if (ch_entry->src_dev_mm == NODEV(dev_t)(-1))
1629	continue;
1630
1631	if (sr_meta_native_read(sd, ch_entry->src_dev_mm, md, NULL((void *)0))) {
1632	sr_error(sc, "could not read native metadata");
1633	goto bad;
1634	}
1635
1636	if (md->ssdi_sdd_invariant.ssd_magic == SR_MAGIC0x4d4152436372616dLLU) {
1637	sr++;
1638	ch_entry->src_meta.scmi_scm_invariant.scm_chunk_id =
1639	md->ssdi_sdd_invariant.ssd_chunk_id;
1640	if (d == 0) {
1641	memcpy(&uuid, &md->ssdi.ssd_uuid, sizeof uuid)__builtin_memcpy((&uuid), (&md->_sdd_invariant.ssd_uuid ), (sizeof uuid));
1642	expected = md->ssdi_sdd_invariant.ssd_chunk_no;
1643	version = md->ssd_ondisk;
1644	d++;
1645	continue;
1646	} else if (bcmp(&md->ssdi_sdd_invariant.ssd_uuid, &uuid,
1647	sizeof uuid)) {
1648	sr_error(sc, "not part of the same volume");
1649	goto bad;
1650	}
1651	if (md->ssd_ondisk != version) {
1652	old_meta++;
1653	version = MAX(md->ssd_ondisk, version)(((md->ssd_ondisk)>(version))?(md->ssd_ondisk):(version ));
1654	}
1655	} else
1656	not_sr++;
1657	}
1658
1659	if (sr && not_sr && !force) {
1660	sr_error(sc, "not all chunks are of the native metadata "
1661	"format");
1662	goto bad;
1663	}
1664
1665	/* mixed metadata versions; mark bad disks offline */
1666	if (old_meta) {
1667	d = 0;
1668	for (ch_entry = SLIST_FIRST(cl)((cl)->slh_first); ch_entry != NULL((void *)0);
1669	ch_entry = ch_next, d++) {
1670	ch_next = SLIST_NEXT(ch_entry, src_link)((ch_entry)->src_link.sle_next);
1671
1672	/* XXX do we want to read this again? */
1673	if (ch_entry->src_dev_mm == NODEV(dev_t)(-1))
1674	panic("src_dev_mm == NODEV");
1675	if (sr_meta_native_read(sd, ch_entry->src_dev_mm, md,
1676	NULL((void *)0)))
1677	sr_warn(sc, "could not read native metadata");
1678	if (md->ssd_ondisk != version)
1679	sd->sd_vol.sv_chunks[d]->src_meta.scm_status =
1680	BIOC_SDOFFLINE0x01;
1681	}
1682	}
1683
1684	if (expected != sr && !force && expected != -1) {
1685	DNPRINTF(SR_D_META, "%s: not all chunks were provided, trying "
1686	"anyway\n", DEVNAME(sc));
1687	}
1688
1689	rv = 0;
1690	bad:
1691	free(md, M_DEVBUF2, SR_META_SIZE64 * DEV_BSIZE(1 << 9));
1692	return (rv);
1693	}
1694
1695	int
1696	sr_meta_native_read(struct sr_discipline *sd, dev_t dev,
1697	struct sr_metadata md, void fm)
1698	{
1699	#ifdef SR_DEBUG
1700	struct sr_softc *sc = sd->sd_sc;
1701	#endif
1702	DNPRINTF(SR_D_META, "%s: sr_meta_native_read(0x%x, %p)\n",
1703	DEVNAME(sc), dev, md);
1704
1705	return (sr_meta_rw(sd, dev, md, B_READ0x00008000));
1706	}
1707
1708	int
1709	sr_meta_native_write(struct sr_discipline *sd, dev_t dev,
1710	struct sr_metadata md, void fm)
1711	{
1712	#ifdef SR_DEBUG
1713	struct sr_softc *sc = sd->sd_sc;
1714	#endif
1715	DNPRINTF(SR_D_META, "%s: sr_meta_native_write(0x%x, %p)\n",
1716	DEVNAME(sc), dev, md);
1717
1718	return (sr_meta_rw(sd, dev, md, B_WRITE0x00000000));
1719	}
1720
1721	void
1722	sr_hotplug_register(struct sr_discipline sd, void func)
1723	{
1724	struct sr_hotplug_list *mhe;
1725
1726	DNPRINTF(SR_D_MISC, "%s: sr_hotplug_register: %p\n",
1727	DEVNAME(sd->sd_sc), func);
1728
1729	/* make sure we aren't on the list yet */
1730	SLIST_FOREACH(mhe, &sr_hotplug_callbacks, shl_link)for((mhe) = ((&sr_hotplug_callbacks)->slh_first); (mhe ) != ((void *)0); (mhe) = ((mhe)->shl_link.sle_next))
1731	if (mhe->sh_hotplug == func)
1732	return;
1733
1734	mhe = malloc(sizeof(struct sr_hotplug_list), M_DEVBUF2,
1735	M_WAITOK0x0001 \| M_ZERO0x0008);
1736	mhe->sh_hotplug = func;
1737	mhe->sh_sd = sd;
1738	SLIST_INSERT_HEAD(&sr_hotplug_callbacks, mhe, shl_link)do { (mhe)->shl_link.sle_next = (&sr_hotplug_callbacks )->slh_first; (&sr_hotplug_callbacks)->slh_first = ( mhe); } while (0);
1739	}
1740
1741	void
1742	sr_hotplug_unregister(struct sr_discipline sd, void func)
1743	{
1744	struct sr_hotplug_list *mhe;
1745
1746	DNPRINTF(SR_D_MISC, "%s: sr_hotplug_unregister: %s %p\n",
1747	DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname, func);
1748
1749	/* make sure we are on the list yet */
1750	SLIST_FOREACH(mhe, &sr_hotplug_callbacks, shl_link)for((mhe) = ((&sr_hotplug_callbacks)->slh_first); (mhe ) != ((void *)0); (mhe) = ((mhe)->shl_link.sle_next)) {
1751	if (mhe->sh_hotplug == func)
1752	break;
1753	}
1754	if (mhe != NULL((void *)0)) {
1755	SLIST_REMOVE(&sr_hotplug_callbacks, mhe,do { if ((&sr_hotplug_callbacks)->slh_first == (mhe)) { do { ((&sr_hotplug_callbacks))->slh_first = ((&sr_hotplug_callbacks ))->slh_first->shl_link.sle_next; } while (0); } else { struct sr_hotplug_list curelm = (&sr_hotplug_callbacks) ->slh_first; while (curelm->shl_link.sle_next != (mhe)) curelm = curelm->shl_link.sle_next; curelm->shl_link.sle_next = curelm->shl_link.sle_next->shl_link.sle_next; } ((mhe )->shl_link.sle_next) = ((void )-1); } while (0)
1756	sr_hotplug_list, shl_link)do { if ((&sr_hotplug_callbacks)->slh_first == (mhe)) { do { ((&sr_hotplug_callbacks))->slh_first = ((&sr_hotplug_callbacks ))->slh_first->shl_link.sle_next; } while (0); } else { struct sr_hotplug_list curelm = (&sr_hotplug_callbacks) ->slh_first; while (curelm->shl_link.sle_next != (mhe)) curelm = curelm->shl_link.sle_next; curelm->shl_link.sle_next = curelm->shl_link.sle_next->shl_link.sle_next; } ((mhe )->shl_link.sle_next) = ((void )-1); } while (0);
1757	free(mhe, M_DEVBUF2, sizeof(*mhe));
1758	}
1759	}
1760
1761	void
1762	sr_disk_attach(struct disk *diskp, int action)
1763	{
1764	struct sr_hotplug_list *mhe;
1765
1766	SLIST_FOREACH(mhe, &sr_hotplug_callbacks, shl_link)for((mhe) = ((&sr_hotplug_callbacks)->slh_first); (mhe ) != ((void *)0); (mhe) = ((mhe)->shl_link.sle_next))
1767	if (mhe->sh_sd->sd_ready)
1768	mhe->sh_hotplug(mhe->sh_sd, diskp, action);
1769	}
1770
1771	int
1772	sr_match(struct device parent, void match, void *aux)
1773	{
1774	return (1);
1775	}
1776
1777	void
1778	sr_attach(struct device parent, struct device self, void *aux)
1779	{
1780	struct sr_softc sc = (void )self;
1781	struct scsibus_attach_args saa;
1782
1783	DNPRINTF(SR_D_MISC, "\n%s: sr_attach", DEVNAME(sc));
1784
1785	if (softraid0 == NULL((void *)0))
1786	softraid0 = sc;
1787
1788	rw_init(&sc->sc_lock, "sr_lock")_rw_init_flags(&sc->sc_lock, "sr_lock", 0, ((void *)0) );
1789	rw_init(&sc->sc_hs_lock, "sr_hs_lock")_rw_init_flags(&sc->sc_hs_lock, "sr_hs_lock", 0, ((void *)0));
1790
1791	SLIST_INIT(&sr_hotplug_callbacks){ ((&sr_hotplug_callbacks)->slh_first) = ((void *)0); };
1792	TAILQ_INIT(&sc->sc_dis_list)do { (&sc->sc_dis_list)->tqh_first = ((void *)0); ( &sc->sc_dis_list)->tqh_last = &(&sc->sc_dis_list )->tqh_first; } while (0);
1793	SLIST_INIT(&sc->sc_hotspare_list){ ((&sc->sc_hotspare_list)->slh_first) = ((void *)0 ); };
1794
1795	#if NBIO1 > 0
1796	if (bio_register(&sc->sc_dev, sr_bio_ioctl) != 0)
1797	printf("%s: controller registration failed", DEVNAME(sc)((sc)->sc_dev.dv_xname));
1798	#endif /* NBIO > 0 */
1799
1800	#ifndef SMALL_KERNEL
1801	strlcpy(sc->sc_sensordev.xname, DEVNAME(sc)((sc)->sc_dev.dv_xname),
1802	sizeof(sc->sc_sensordev.xname));
1803	sensordev_install(&sc->sc_sensordev);
1804	#endif /* SMALL_KERNEL */
1805
1806	printf("\n");
1807
1808	saa.saa_adapter_softc = sc;
1809	saa.saa_adapter = &sr_switch;
1810	saa.saa_adapter_target = SDEV_NO_ADAPTER_TARGET0xffff;
1811	saa.saa_adapter_buswidth = SR_MAX_LD256;
1812	saa.saa_luns = 1;
1813	saa.saa_openings = 0;
1814	saa.saa_pool = NULL((void *)0);
1815	saa.saa_quirks = saa.saa_flags = 0;
1816	saa.saa_wwpn = saa.saa_wwnn = 0;
1817
1818	sc->sc_scsibus = (struct scsibus_softc )config_found(&sc->sc_dev, &saa,config_found_sm((&sc->sc_dev), (&saa), (scsiprint) , ((void )0))
1819	scsiprint)config_found_sm((&sc->sc_dev), (&saa), (scsiprint) , ((void *)0));
1820
1821	softraid_disk_attach = sr_disk_attach;
1822
1823	sr_boot_assembly(sc);
1824
1825	explicit_bzero(sr_bootkey, sizeof(sr_bootkey));
1826	}
1827
1828	int
1829	sr_detach(struct device *self, int flags)
1830	{
1831	struct sr_softc sc = (void )self;
1832	int rv;
1833
1834	DNPRINTF(SR_D_MISC, "%s: sr_detach\n", DEVNAME(sc));
1835
1836	softraid_disk_attach = NULL((void *)0);
1837
1838	sr_shutdown(0);
1839
1840	#ifndef SMALL_KERNEL
1841	if (sc->sc_sensor_task != NULL((void *)0))
1842	sensor_task_unregister(sc->sc_sensor_task);
1843	sensordev_deinstall(&sc->sc_sensordev);
1844	#endif /* SMALL_KERNEL */
1845
1846	if (sc->sc_scsibus != NULL((void *)0)) {
1847	rv = config_detach((struct device *)sc->sc_scsibus, flags);
1848	if (rv != 0)
1849	return (rv);
1850	sc->sc_scsibus = NULL((void *)0);
1851	}
1852
1853	return (0);
1854	}
1855
1856	void
1857	sr_info(struct sr_softc sc, const char fmt, ...)
1858	{
1859	va_list ap;
1860
1861	rw_assert_wrlock(&sc->sc_lock);
1862
1863	va_start(ap, fmt)__builtin_va_start((ap), fmt);
1864	bio_status(&sc->sc_status, 0, BIO_MSG_INFO1, fmt, &ap);
1865	va_end(ap)__builtin_va_end((ap));
1866	}
1867
1868	void
1869	sr_warn(struct sr_softc sc, const char fmt, ...)
1870	{
1871	va_list ap;
1872
1873	rw_assert_wrlock(&sc->sc_lock);
1874
1875	va_start(ap, fmt)__builtin_va_start((ap), fmt);
1876	bio_status(&sc->sc_status, 1, BIO_MSG_WARN2, fmt, &ap);
1877	va_end(ap)__builtin_va_end((ap));
1878	}
1879
1880	void
1881	sr_error(struct sr_softc sc, const char fmt, ...)
1882	{
1883	va_list ap;
1884
1885	rw_assert_wrlock(&sc->sc_lock);
1886
1887	va_start(ap, fmt)__builtin_va_start((ap), fmt);
1888	bio_status(&sc->sc_status, 1, BIO_MSG_ERROR3, fmt, &ap);
1889	va_end(ap)__builtin_va_end((ap));
1890	}
1891
1892	int
1893	sr_ccb_alloc(struct sr_discipline *sd)
1894	{
1895	struct sr_ccb *ccb;
1896	int i;
1897
1898	if (!sd)
1899	return (1);
1900
1901	DNPRINTF(SR_D_CCB, "%s: sr_ccb_alloc\n", DEVNAME(sd->sd_sc));
1902
1903	if (sd->sd_ccb)
1904	return (1);
1905
1906	sd->sd_ccb = mallocarray(sd->sd_max_wu,
1907	sd->sd_max_ccb_per_wu * sizeof(struct sr_ccb),
1908	M_DEVBUF2, M_WAITOK0x0001 \| M_ZERO0x0008);
1909	TAILQ_INIT(&sd->sd_ccb_freeq)do { (&sd->sd_ccb_freeq)->tqh_first = ((void *)0); ( &sd->sd_ccb_freeq)->tqh_last = &(&sd->sd_ccb_freeq )->tqh_first; } while (0);
1910	for (i = 0; i < sd->sd_max_wu * sd->sd_max_ccb_per_wu; i++) {
1911	ccb = &sd->sd_ccb[i];
1912	ccb->ccb_dis = sd;
1913	sr_ccb_put(ccb);
1914	}
1915
1916	DNPRINTF(SR_D_CCB, "%s: sr_ccb_alloc ccb: %d\n",
1917	DEVNAME(sd->sd_sc), sd->sd_max_wu * sd->sd_max_ccb_per_wu);
1918
1919	return (0);
1920	}
1921
1922	void
1923	sr_ccb_free(struct sr_discipline *sd)
1924	{
1925	struct sr_ccb *ccb;
1926
1927	if (!sd)
1928	return;
1929
1930	DNPRINTF(SR_D_CCB, "%s: sr_ccb_free %p\n", DEVNAME(sd->sd_sc), sd);
1931
1932	while ((ccb = TAILQ_FIRST(&sd->sd_ccb_freeq)((&sd->sd_ccb_freeq)->tqh_first)) != NULL((void *)0))
1933	TAILQ_REMOVE(&sd->sd_ccb_freeq, ccb, ccb_link)do { if (((ccb)->ccb_link.tqe_next) != ((void )0)) (ccb)-> ccb_link.tqe_next->ccb_link.tqe_prev = (ccb)->ccb_link. tqe_prev; else (&sd->sd_ccb_freeq)->tqh_last = (ccb )->ccb_link.tqe_prev; (ccb)->ccb_link.tqe_prev = (ccb) ->ccb_link.tqe_next; ((ccb)->ccb_link.tqe_prev) = ((void )-1); ((ccb)->ccb_link.tqe_next) = ((void )-1); } while (0);
1934
1935	free(sd->sd_ccb, M_DEVBUF2, sd->sd_max_wu * sd->sd_max_ccb_per_wu *
1936	sizeof(struct sr_ccb));
1937	}
1938
1939	struct sr_ccb *
1940	sr_ccb_get(struct sr_discipline *sd)
1941	{
1942	struct sr_ccb *ccb;
1943	int s;
1944
1945	s = splbio()splraise(0x3);
1946
1947	ccb = TAILQ_FIRST(&sd->sd_ccb_freeq)((&sd->sd_ccb_freeq)->tqh_first);
1948	if (ccb) {
1949	TAILQ_REMOVE(&sd->sd_ccb_freeq, ccb, ccb_link)do { if (((ccb)->ccb_link.tqe_next) != ((void )0)) (ccb)-> ccb_link.tqe_next->ccb_link.tqe_prev = (ccb)->ccb_link. tqe_prev; else (&sd->sd_ccb_freeq)->tqh_last = (ccb )->ccb_link.tqe_prev; (ccb)->ccb_link.tqe_prev = (ccb) ->ccb_link.tqe_next; ((ccb)->ccb_link.tqe_prev) = ((void )-1); ((ccb)->ccb_link.tqe_next) = ((void )-1); } while (0);
1950	ccb->ccb_state = SR_CCB_INPROGRESS1;
1951	}
1952
1953	splx(s)spllower(s);
1954
1955	DNPRINTF(SR_D_CCB, "%s: sr_ccb_get: %p\n", DEVNAME(sd->sd_sc),
1956	ccb);
1957
1958	return (ccb);
1959	}
1960
1961	void
1962	sr_ccb_put(struct sr_ccb *ccb)
1963	{
1964	struct sr_discipline *sd = ccb->ccb_dis;
1965	int s;
1966
1967	DNPRINTF(SR_D_CCB, "%s: sr_ccb_put: %p\n", DEVNAME(sd->sd_sc),
1968	ccb);
1969
1970	s = splbio()splraise(0x3);
1971
1972	ccb->ccb_wu = NULL((void *)0);
1973	ccb->ccb_state = SR_CCB_FREE0;
1974	ccb->ccb_target = -1;
1975	ccb->ccb_opaque = NULL((void *)0);
1976
1977	TAILQ_INSERT_TAIL(&sd->sd_ccb_freeq, ccb, ccb_link)do { (ccb)->ccb_link.tqe_next = ((void )0); (ccb)->ccb_link .tqe_prev = (&sd->sd_ccb_freeq)->tqh_last; (&sd ->sd_ccb_freeq)->tqh_last = (ccb); (&sd->sd_ccb_freeq )->tqh_last = &(ccb)->ccb_link.tqe_next; } while (0 );
1978
1979	splx(s)spllower(s);
1980	}
1981
1982	struct sr_ccb *
1983	sr_ccb_rw(struct sr_discipline *sd, int chunk, daddr_t blkno,
1984	long len, u_int8_t *data, int xsflags, int ccbflags)
1985	{
1986	struct sr_chunk *sc = sd->sd_vol.sv_chunks[chunk];
1987	struct sr_ccb ccb = NULL((void )0);
1988	int s;
1989
1990	ccb = sr_ccb_get(sd);
1991	if (ccb == NULL((void *)0))
1992	goto out;
1993
1994	ccb->ccb_flags = ccbflags;
1995	ccb->ccb_target = chunk;
1996
1997	ccb->ccb_buf.b_flags = B_PHYS0x00002000 \| B_CALL0x00000040;
1998	if (ISSET(xsflags, SCSI_DATA_IN)((xsflags) & (0x00800)))
1999	ccb->ccb_buf.b_flags \|= B_READ0x00008000;
2000	else
2001	ccb->ccb_buf.b_flags \|= B_WRITE0x00000000;
2002
2003	ccb->ccb_buf.b_blkno = blkno + sd->sd_meta->ssd_data_blkno;
2004	ccb->ccb_buf.b_bcount = len;
2005	ccb->ccb_buf.b_bufsize = len;
2006	ccb->ccb_buf.b_resid = len;
2007	ccb->ccb_buf.b_data = data;
2008	ccb->ccb_buf.b_error = 0;
2009	ccb->ccb_buf.b_iodone = sd->sd_scsi_intr;
2010	ccb->ccb_buf.b_proc = curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc;
2011	ccb->ccb_buf.b_dev = sc->src_dev_mm;
2012	ccb->ccb_buf.b_vp = sc->src_vn;
2013	ccb->ccb_buf.b_bq = NULL((void *)0);
2014
2015	if (!ISSET(ccb->ccb_buf.b_flags, B_READ)((ccb->ccb_buf.b_flags) & (0x00008000))) {
2016	s = splbio()splraise(0x3);
2017	ccb->ccb_buf.b_vp->v_numoutput++;
2018	splx(s)spllower(s);
2019	}
2020
2021	LIST_INIT(&ccb->ccb_buf.b_dep)do { ((&ccb->ccb_buf.b_dep)->lh_first) = ((void *)0 ); } while (0);
2022
2023	DNPRINTF(SR_D_DIS, "%s: %s %s ccb "
2024	"b_bcount %ld b_blkno %lld b_flags 0x%0lx b_data %p\n",
2025	DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname, sd->sd_name,
2026	ccb->ccb_buf.b_bcount, (long long)ccb->ccb_buf.b_blkno,
2027	ccb->ccb_buf.b_flags, ccb->ccb_buf.b_data);
2028
2029	out:
2030	return ccb;
2031	}
2032
2033	void
2034	sr_ccb_done(struct sr_ccb *ccb)
2035	{
2036	struct sr_workunit *wu = ccb->ccb_wu;
2037	struct sr_discipline *sd = wu->swu_dis;
2038	struct sr_softc *sc = sd->sd_sc;
2039
2040	DNPRINTF(SR_D_INTR, "%s: %s %s ccb done b_bcount %ld b_resid %zu"
2041	" b_flags 0x%0lx block %lld target %d\n",
2042	DEVNAME(sc), sd->sd_meta->ssd_devname, sd->sd_name,
2043	ccb->ccb_buf.b_bcount, ccb->ccb_buf.b_resid, ccb->ccb_buf.b_flags,
2044	(long long)ccb->ccb_buf.b_blkno, ccb->ccb_target);
2045
2046	splassert(IPL_BIO)do { if (splassert_ctl > 0) { splassert_check(0x3, __func__ ); } } while (0);
2047
2048	if (ccb->ccb_target == -1)
2049	panic("%s: invalid target on wu: %p", DEVNAME(sc)((sc)->sc_dev.dv_xname), wu);
2050
2051	if (ccb->ccb_buf.b_flags & B_ERROR0x00000400) {
2052	DNPRINTF(SR_D_INTR, "%s: i/o error on block %lld target %d\n",
2053	DEVNAME(sc), (long long)ccb->ccb_buf.b_blkno,
2054	ccb->ccb_target);
2055	if (ISSET(sd->sd_capabilities, SR_CAP_REDUNDANT)((sd->sd_capabilities) & (0x00000010)))
2056	sd->sd_set_chunk_state(sd, ccb->ccb_target,
2057	BIOC_SDOFFLINE0x01);
2058	else
2059	printf("%s: %s: i/o error %d @ %s block %lld\n",
2060	DEVNAME(sc)((sc)->sc_dev.dv_xname), sd->sd_meta->ssd_devname,
2061	ccb->ccb_buf.b_error, sd->sd_name,
2062	(long long)ccb->ccb_buf.b_blkno);
2063	ccb->ccb_state = SR_CCB_FAILED3;
2064	wu->swu_ios_failed++;
2065	} else {
2066	ccb->ccb_state = SR_CCB_OK2;
2067	wu->swu_ios_succeeded++;
2068	}
2069
2070	wu->swu_ios_complete++;
2071	}
2072
2073	int
2074	sr_wu_alloc(struct sr_discipline *sd)
2075	{
2076	struct sr_workunit *wu;
2077	int i, no_wu;
2078
2079	DNPRINTF(SR_D_WU, "%s: sr_wu_alloc %p %d\n", DEVNAME(sd->sd_sc),
2080	sd, sd->sd_max_wu);
2081
2082	no_wu = sd->sd_max_wu;
2083	sd->sd_wu_pending = no_wu;
2084
2085	mtx_init(&sd->sd_wu_mtx, IPL_BIO)do { (void)(((void *)0)); (void)(0); __mtx_init((&sd-> sd_wu_mtx), ((((0x3)) > 0x0 && ((0x3)) < 0x9) ? 0x9 : ((0x3)))); } while (0);
2086	TAILQ_INIT(&sd->sd_wu)do { (&sd->sd_wu)->tqh_first = ((void *)0); (&sd ->sd_wu)->tqh_last = &(&sd->sd_wu)->tqh_first ; } while (0);
2087	TAILQ_INIT(&sd->sd_wu_freeq)do { (&sd->sd_wu_freeq)->tqh_first = ((void *)0); ( &sd->sd_wu_freeq)->tqh_last = &(&sd->sd_wu_freeq )->tqh_first; } while (0);
2088	TAILQ_INIT(&sd->sd_wu_pendq)do { (&sd->sd_wu_pendq)->tqh_first = ((void *)0); ( &sd->sd_wu_pendq)->tqh_last = &(&sd->sd_wu_pendq )->tqh_first; } while (0);
2089	TAILQ_INIT(&sd->sd_wu_defq)do { (&sd->sd_wu_defq)->tqh_first = ((void *)0); (& sd->sd_wu_defq)->tqh_last = &(&sd->sd_wu_defq )->tqh_first; } while (0);
2090
2091	for (i = 0; i < no_wu; i++) {
2092	wu = malloc(sd->sd_wu_size, M_DEVBUF2, M_WAITOK0x0001 \| M_ZERO0x0008);
2093	TAILQ_INSERT_TAIL(&sd->sd_wu, wu, swu_next)do { (wu)->swu_next.tqe_next = ((void )0); (wu)->swu_next .tqe_prev = (&sd->sd_wu)->tqh_last; (&sd->sd_wu )->tqh_last = (wu); (&sd->sd_wu)->tqh_last = & (wu)->swu_next.tqe_next; } while (0);
2094	TAILQ_INIT(&wu->swu_ccb)do { (&wu->swu_ccb)->tqh_first = ((void *)0); (& wu->swu_ccb)->tqh_last = &(&wu->swu_ccb)-> tqh_first; } while (0);
2095	wu->swu_dis = sd;
2096	task_set(&wu->swu_task, sr_wu_done_callback, wu);
2097	sr_wu_put(sd, wu);
2098	}
2099
2100	return (0);
2101	}
2102
2103	void
2104	sr_wu_free(struct sr_discipline *sd)
2105	{
2106	struct sr_workunit *wu;
2107
2108	DNPRINTF(SR_D_WU, "%s: sr_wu_free %p\n", DEVNAME(sd->sd_sc), sd);
2109
2110	while ((wu = TAILQ_FIRST(&sd->sd_wu_freeq)((&sd->sd_wu_freeq)->tqh_first)) != NULL((void *)0))
2111	TAILQ_REMOVE(&sd->sd_wu_freeq, wu, swu_link)do { if (((wu)->swu_link.tqe_next) != ((void )0)) (wu)-> swu_link.tqe_next->swu_link.tqe_prev = (wu)->swu_link.tqe_prev ; else (&sd->sd_wu_freeq)->tqh_last = (wu)->swu_link .tqe_prev; (wu)->swu_link.tqe_prev = (wu)->swu_link.tqe_next ; ((wu)->swu_link.tqe_prev) = ((void )-1); ((wu)->swu_link .tqe_next) = ((void )-1); } while (0);
2112	while ((wu = TAILQ_FIRST(&sd->sd_wu_pendq)((&sd->sd_wu_pendq)->tqh_first)) != NULL((void *)0))
2113	TAILQ_REMOVE(&sd->sd_wu_pendq, wu, swu_link)do { if (((wu)->swu_link.tqe_next) != ((void )0)) (wu)-> swu_link.tqe_next->swu_link.tqe_prev = (wu)->swu_link.tqe_prev ; else (&sd->sd_wu_pendq)->tqh_last = (wu)->swu_link .tqe_prev; (wu)->swu_link.tqe_prev = (wu)->swu_link.tqe_next ; ((wu)->swu_link.tqe_prev) = ((void )-1); ((wu)->swu_link .tqe_next) = ((void )-1); } while (0);
2114	while ((wu = TAILQ_FIRST(&sd->sd_wu_defq)((&sd->sd_wu_defq)->tqh_first)) != NULL((void *)0))
2115	TAILQ_REMOVE(&sd->sd_wu_defq, wu, swu_link)do { if (((wu)->swu_link.tqe_next) != ((void )0)) (wu)-> swu_link.tqe_next->swu_link.tqe_prev = (wu)->swu_link.tqe_prev ; else (&sd->sd_wu_defq)->tqh_last = (wu)->swu_link .tqe_prev; (wu)->swu_link.tqe_prev = (wu)->swu_link.tqe_next ; ((wu)->swu_link.tqe_prev) = ((void )-1); ((wu)->swu_link .tqe_next) = ((void )-1); } while (0);
2116
2117	while ((wu = TAILQ_FIRST(&sd->sd_wu)((&sd->sd_wu)->tqh_first)) != NULL((void *)0)) {
2118	TAILQ_REMOVE(&sd->sd_wu, wu, swu_next)do { if (((wu)->swu_next.tqe_next) != ((void )0)) (wu)-> swu_next.tqe_next->swu_next.tqe_prev = (wu)->swu_next.tqe_prev ; else (&sd->sd_wu)->tqh_last = (wu)->swu_next.tqe_prev ; (wu)->swu_next.tqe_prev = (wu)->swu_next.tqe_next; ( (wu)->swu_next.tqe_prev) = ((void )-1); ((wu)->swu_next .tqe_next) = ((void )-1); } while (0);
2119	free(wu, M_DEVBUF2, sd->sd_wu_size);
2120	}
2121	}
2122
2123	void *
2124	sr_wu_get(void *xsd)
2125	{
2126	struct sr_discipline sd = (struct sr_discipline )xsd;
2127	struct sr_workunit *wu;
2128
2129	mtx_enter(&sd->sd_wu_mtx);
2130	wu = TAILQ_FIRST(&sd->sd_wu_freeq)((&sd->sd_wu_freeq)->tqh_first);
2131	if (wu) {
2132	TAILQ_REMOVE(&sd->sd_wu_freeq, wu, swu_link)do { if (((wu)->swu_link.tqe_next) != ((void )0)) (wu)-> swu_link.tqe_next->swu_link.tqe_prev = (wu)->swu_link.tqe_prev ; else (&sd->sd_wu_freeq)->tqh_last = (wu)->swu_link .tqe_prev; (wu)->swu_link.tqe_prev = (wu)->swu_link.tqe_next ; ((wu)->swu_link.tqe_prev) = ((void )-1); ((wu)->swu_link .tqe_next) = ((void )-1); } while (0);
2133	sd->sd_wu_pending++;
2134	}
2135	mtx_leave(&sd->sd_wu_mtx);
2136
2137	DNPRINTF(SR_D_WU, "%s: sr_wu_get: %p\n", DEVNAME(sd->sd_sc), wu);
2138
2139	return (wu);
2140	}
2141
2142	void
2143	sr_wu_put(void xsd, void xwu)
2144	{
2145	struct sr_discipline sd = (struct sr_discipline )xsd;
2146	struct sr_workunit wu = (struct sr_workunit )xwu;
2147
2148	DNPRINTF(SR_D_WU, "%s: sr_wu_put: %p\n", DEVNAME(sd->sd_sc), wu);
2149
2150	sr_wu_release_ccbs(wu);
2151	sr_wu_init(sd, wu);
2152
2153	mtx_enter(&sd->sd_wu_mtx);
2154	TAILQ_INSERT_TAIL(&sd->sd_wu_freeq, wu, swu_link)do { (wu)->swu_link.tqe_next = ((void )0); (wu)->swu_link .tqe_prev = (&sd->sd_wu_freeq)->tqh_last; (&sd ->sd_wu_freeq)->tqh_last = (wu); (&sd->sd_wu_freeq )->tqh_last = &(wu)->swu_link.tqe_next; } while (0);
2155	sd->sd_wu_pending--;
2156	mtx_leave(&sd->sd_wu_mtx);
2157	}
2158
2159	void
2160	sr_wu_init(struct sr_discipline sd, struct sr_workunit wu)
2161	{
2162	int s;
2163
2164	s = splbio()splraise(0x3);
2165	if (wu->swu_cb_active == 1)
2166	panic("%s: sr_wu_init got active wu", DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname));
2167	splx(s)spllower(s);
2168
2169	wu->swu_xs = NULL((void *)0);
2170	wu->swu_state = SR_WU_FREE0;
2171	wu->swu_flags = 0;
2172	wu->swu_blk_start = 0;
2173	wu->swu_blk_end = 0;
2174	wu->swu_collider = NULL((void *)0);
2175	}
2176
2177	void
2178	sr_wu_enqueue_ccb(struct sr_workunit wu, struct sr_ccb ccb)
2179	{
2180	struct sr_discipline *sd = wu->swu_dis;
2181	int s;
2182
2183	s = splbio()splraise(0x3);
2184	if (wu->swu_cb_active == 1)
2185	panic("%s: sr_wu_enqueue_ccb got active wu",
2186	DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname));
2187	ccb->ccb_wu = wu;
2188	wu->swu_io_count++;
2189	TAILQ_INSERT_TAIL(&wu->swu_ccb, ccb, ccb_link)do { (ccb)->ccb_link.tqe_next = ((void )0); (ccb)->ccb_link .tqe_prev = (&wu->swu_ccb)->tqh_last; (&wu-> swu_ccb)->tqh_last = (ccb); (&wu->swu_ccb)->tqh_last = &(ccb)->ccb_link.tqe_next; } while (0);
2190	splx(s)spllower(s);
2191	}
2192
2193	void
2194	sr_wu_release_ccbs(struct sr_workunit *wu)
2195	{
2196	struct sr_ccb *ccb;
2197
2198	/* Return all ccbs that are associated with this workunit. */
2199	while ((ccb = TAILQ_FIRST(&wu->swu_ccb)((&wu->swu_ccb)->tqh_first)) != NULL((void *)0)) {
2200	TAILQ_REMOVE(&wu->swu_ccb, ccb, ccb_link)do { if (((ccb)->ccb_link.tqe_next) != ((void )0)) (ccb)-> ccb_link.tqe_next->ccb_link.tqe_prev = (ccb)->ccb_link. tqe_prev; else (&wu->swu_ccb)->tqh_last = (ccb)-> ccb_link.tqe_prev; (ccb)->ccb_link.tqe_prev = (ccb)->ccb_link .tqe_next; ((ccb)->ccb_link.tqe_prev) = ((void )-1); ((ccb )->ccb_link.tqe_next) = ((void )-1); } while (0);
2201	sr_ccb_put(ccb);
2202	}
2203
2204	wu->swu_io_count = 0;
2205	wu->swu_ios_complete = 0;
2206	wu->swu_ios_failed = 0;
2207	wu->swu_ios_succeeded = 0;
2208	}
2209
2210	void
2211	sr_wu_done(struct sr_workunit *wu)
2212	{
2213	struct sr_discipline *sd = wu->swu_dis;
2214
2215	DNPRINTF(SR_D_INTR, "%s: sr_wu_done count %d completed %d failed %d\n",
2216	DEVNAME(sd->sd_sc), wu->swu_io_count, wu->swu_ios_complete,
2217	wu->swu_ios_failed);
2218
2219	if (wu->swu_ios_complete < wu->swu_io_count)
2220	return;
2221
2222	task_add(sd->sd_taskq, &wu->swu_task);
2223	}
2224
2225	void
2226	sr_wu_done_callback(void *xwu)
2227	{
2228	struct sr_workunit *wu = xwu;
2229	struct sr_discipline *sd = wu->swu_dis;
2230	struct scsi_xfer *xs = wu->swu_xs;
2231	struct sr_workunit *wup;
2232	int s;
2233
2234	/*
2235	* The SR_WUF_DISCIPLINE or SR_WUF_REBUILD flag must be set if
2236	* the work unit is not associated with a scsi_xfer.
2237	*/
2238	KASSERT(xs != NULL \|\|((xs != ((void *)0) \|\| (wu->swu_flags & ((1<<5)\| (1<<0)))) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/dev/softraid.c" , 2239, "xs != NULL \|\| (wu->swu_flags & (SR_WUF_DISCIPLINE\|SR_WUF_REBUILD))" ))
2239	(wu->swu_flags & (SR_WUF_DISCIPLINE\|SR_WUF_REBUILD)))((xs != ((void *)0) \|\| (wu->swu_flags & ((1<<5)\| (1<<0)))) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/dev/softraid.c" , 2239, "xs != NULL \|\| (wu->swu_flags & (SR_WUF_DISCIPLINE\|SR_WUF_REBUILD))" ));
2240
2241	s = splbio()splraise(0x3);
2242
2243	if (xs != NULL((void *)0)) {
2244	if (wu->swu_ios_failed)
2245	xs->error = XS_DRIVER_STUFFUP2;
2246	else
2247	xs->error = XS_NOERROR0;
2248	}
2249
2250	if (sd->sd_scsi_wu_done) {
2251	if (sd->sd_scsi_wu_done(wu) == SR_WU_RESTART7)
2252	goto done;
2253	}
2254
2255	/* Remove work unit from pending queue. */
2256	TAILQ_FOREACH(wup, &sd->sd_wu_pendq, swu_link)for((wup) = ((&sd->sd_wu_pendq)->tqh_first); (wup) != ((void *)0); (wup) = ((wup)->swu_link.tqe_next))
2257	if (wup == wu)
2258	break;
2259	if (wup == NULL((void *)0))
2260	panic("%s: wu %p not on pending queue",
2261	DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname), wu);
2262	TAILQ_REMOVE(&sd->sd_wu_pendq, wu, swu_link)do { if (((wu)->swu_link.tqe_next) != ((void )0)) (wu)-> swu_link.tqe_next->swu_link.tqe_prev = (wu)->swu_link.tqe_prev ; else (&sd->sd_wu_pendq)->tqh_last = (wu)->swu_link .tqe_prev; (wu)->swu_link.tqe_prev = (wu)->swu_link.tqe_next ; ((wu)->swu_link.tqe_prev) = ((void )-1); ((wu)->swu_link .tqe_next) = ((void )-1); } while (0);
2263
2264	if (wu->swu_collider) {
2265	if (wu->swu_ios_failed)
2266	sr_raid_recreate_wu(wu->swu_collider);
2267
2268	/* XXX Should the collider be failed if this xs failed? */
2269	sr_raid_startwu(wu->swu_collider);
2270	}
2271
2272	/*
2273	* If a discipline provides its own sd_scsi_done function, then it
2274	* is responsible for calling sr_scsi_done() once I/O is complete.
2275	*/
2276	if (wu->swu_flags & SR_WUF_REBUILD(1<<0))
2277	wu->swu_flags \|= SR_WUF_REBUILDIOCOMP(1<<1);
2278	if (wu->swu_flags & SR_WUF_WAKEUP(1<<4))
2279	wakeup(wu);
2280	if (sd->sd_scsi_done)
2281	sd->sd_scsi_done(wu);
2282	else if (wu->swu_flags & SR_WUF_DISCIPLINE(1<<5))
2283	sr_scsi_wu_put(sd, wu);
2284	else if (!(wu->swu_flags & SR_WUF_REBUILD(1<<0)))
2285	sr_scsi_done(sd, xs);
2286
2287	done:
2288	splx(s)spllower(s);
2289	}
2290
2291	struct sr_workunit *
2292	sr_scsi_wu_get(struct sr_discipline *sd, int flags)
2293	{
2294	return scsi_io_get(&sd->sd_iopool, flags);
2295	}
2296
2297	void
2298	sr_scsi_wu_put(struct sr_discipline sd, struct sr_workunit wu)
2299	{
2300	scsi_io_put(&sd->sd_iopool, wu);
2301
2302	if (sd->sd_sync && sd->sd_wu_pending == 0)
2303	wakeup(sd);
2304	}
2305
2306	void
2307	sr_scsi_done(struct sr_discipline sd, struct scsi_xfer xs)
2308	{
2309	DNPRINTF(SR_D_DIS, "%s: sr_scsi_done: xs %p\n", DEVNAME(sd->sd_sc), xs);
2310
2311	if (xs->error == XS_NOERROR0)
2312	xs->resid = 0;
2313
2314	scsi_done(xs);
2315
2316	if (sd->sd_sync && sd->sd_wu_pending == 0)
2317	wakeup(sd);
2318	}
2319
2320	void
2321	sr_scsi_cmd(struct scsi_xfer *xs)
2322	{
2323	struct scsi_link *link = xs->sc_link;
2324	struct sr_softc *sc = link->bus->sb_adapter_softc;
2325	struct sr_workunit *wu = xs->io;
2326	struct sr_discipline *sd;
2327
2328	DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd target %d xs %p flags %#x\n",
2329	DEVNAME(sc), link->target, xs, xs->flags);
2330
2331	sd = sc->sc_targets[link->target];
2332	if (sd == NULL((void *)0))
2333	panic("%s: sr_scsi_cmd NULL discipline", DEVNAME(sc)((sc)->sc_dev.dv_xname));
2334
2335	if (sd->sd_deleted) {
2336	printf("%s: %s device is being deleted, failing io\n",
2337	DEVNAME(sc)((sc)->sc_dev.dv_xname), sd->sd_meta->ssd_devname);
2338	goto stuffup;
2339	}
2340
2341	/* scsi layer can re-send wu without calling sr_wu_put(). */
2342	sr_wu_release_ccbs(wu);
2343	sr_wu_init(sd, wu);
2344	wu->swu_state = SR_WU_INPROGRESS1;
2345	wu->swu_xs = xs;
2346
2347	switch (xs->cmd.opcode) {
2348	case READ_COMMAND0x08:
2349	case READ_100x28:
2350	case READ_160x88:
2351	case WRITE_COMMAND0x0a:
2352	case WRITE_100x2a:
2353	case WRITE_160x8a:
2354	DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd: READ/WRITE %02x\n",
2355	DEVNAME(sc), xs->cmd.opcode);
2356	if (sd->sd_scsi_rw(wu))
2357	goto stuffup;
2358	break;
2359
2360	case SYNCHRONIZE_CACHE0x35:
2361	DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd: SYNCHRONIZE_CACHE\n",
2362	DEVNAME(sc));
2363	if (sd->sd_scsi_sync(wu))
2364	goto stuffup;
2365	goto complete;
2366
2367	case TEST_UNIT_READY0x00:
2368	DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd: TEST_UNIT_READY\n",
2369	DEVNAME(sc));
2370	if (sd->sd_scsi_tur(wu))
2371	goto stuffup;
2372	goto complete;
2373
2374	case START_STOP0x1b:
2375	DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd: START_STOP\n",
2376	DEVNAME(sc));
2377	if (sd->sd_scsi_start_stop(wu))
2378	goto stuffup;
2379	goto complete;
2380
2381	case INQUIRY0x12:
2382	DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd: INQUIRY\n",
2383	DEVNAME(sc));
2384	if (sd->sd_scsi_inquiry(wu))
2385	goto stuffup;
2386	goto complete;
2387
2388	case READ_CAPACITY0x25:
2389	case READ_CAPACITY_160x9e:
2390	DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd READ CAPACITY 0x%02x\n",
2391	DEVNAME(sc), xs->cmd.opcode);
2392	if (sd->sd_scsi_read_cap(wu))
2393	goto stuffup;
2394	goto complete;
2395
2396	case REQUEST_SENSE0x03:
2397	DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd REQUEST SENSE\n",
2398	DEVNAME(sc));
2399	if (sd->sd_scsi_req_sense(wu))
2400	goto stuffup;
2401	goto complete;
2402
2403	default:
2404	DNPRINTF(SR_D_CMD, "%s: unsupported scsi command %x\n",
2405	DEVNAME(sc), xs->cmd.opcode);
2406	/* XXX might need to add generic function to handle others */
2407	goto stuffup;
2408	}
2409
2410	return;
2411	stuffup:
2412	if (sd->sd_scsi_sense.error_code) {
2413	xs->error = XS_SENSE1;
2414	memcpy(&xs->sense, &sd->sd_scsi_sense, sizeof(xs->sense))__builtin_memcpy((&xs->sense), (&sd->sd_scsi_sense ), (sizeof(xs->sense)));
2415	bzero(&sd->sd_scsi_sense, sizeof(sd->sd_scsi_sense))__builtin_bzero((&sd->sd_scsi_sense), (sizeof(sd->sd_scsi_sense )));
2416	} else {
2417	xs->error = XS_DRIVER_STUFFUP2;
2418	}
2419	complete:
2420	sr_scsi_done(sd, xs);
2421	}
2422
2423	int
2424	sr_scsi_probe(struct scsi_link *link)
2425	{
2426	struct sr_softc *sc = link->bus->sb_adapter_softc;
2427	struct sr_discipline *sd;
2428
2429	KASSERT(link->target < SR_MAX_LD && link->lun == 0)((link->target < 256 && link->lun == 0) ? (void )0 : __assert("diagnostic ", "/usr/src/sys/dev/softraid.c", 2429 , "link->target < SR_MAX_LD && link->lun == 0" ));
2430
2431	sd = sc->sc_targets[link->target];
2432	if (sd == NULL((void *)0))
2433	return (ENODEV19);
2434
2435	link->pool = &sd->sd_iopool;
2436	if (sd->sd_openings)
2437	link->openings = sd->sd_openings(sd);
2438	else
2439	link->openings = sd->sd_max_wu;
2440
2441	return (0);
2442	}
2443
2444	int
2445	sr_scsi_ioctl(struct scsi_link *link, u_long cmd, caddr_t addr, int flag)
2446	{
2447	struct sr_softc *sc = link->bus->sb_adapter_softc;
2448	struct sr_discipline *sd;
2449
2450	sd = sc->sc_targets[link->target];
2451	if (sd == NULL((void *)0))
2452	return (ENODEV19);
2453
2454	DNPRINTF(SR_D_IOCTL, "%s: %s sr_scsi_ioctl cmd: %#lx\n",
2455	DEVNAME(sc), sd->sd_meta->ssd_devname, cmd);
2456
2457	/* Pass bio ioctls through to the bio handler. */
2458	if (IOCGROUP(cmd)(((cmd) >> 8) & 0xff) == 'B')
2459	return (sr_bio_handler(sc, sd, cmd, (struct bio *)addr));
2460
2461	switch (cmd) {
2462	case DIOCGCACHE((unsigned long)0x40000000 \| ((sizeof(struct dk_cache) & 0x1fff ) << 16) \| ((('d')) << 8) \| ((117))):
2463	case DIOCSCACHE((unsigned long)0x80000000 \| ((sizeof(struct dk_cache) & 0x1fff ) << 16) \| ((('d')) << 8) \| ((118))):
2464	return (EOPNOTSUPP45);
2465	default:
2466	return (ENOTTY25);
2467	}
2468	}
2469
2470	int
2471	sr_bio_ioctl(struct device *dev, u_long cmd, caddr_t addr)
2472	{
2473	struct sr_softc sc = (struct sr_softc ) dev;
2474	DNPRINTF(SR_D_IOCTL, "%s: sr_bio_ioctl\n", DEVNAME(sc));
2475
2476	return sr_bio_handler(sc, NULL((void )0), cmd, (struct bio )addr);
2477	}
2478
2479	int
2480	sr_bio_handler(struct sr_softc sc, struct sr_discipline sd, u_long cmd,
2481	struct bio *bio)
2482	{
2483	int rv = 0;
2484
2485	DNPRINTF(SR_D_IOCTL, "%s: sr_bio_handler ", DEVNAME(sc));
2486
2487	rw_enter_write(&sc->sc_lock);
2488
2489	bio_status_init(&sc->sc_status, &sc->sc_dev);
2490
2491	switch (cmd) {
2492	case BIOCINQ(((unsigned long)0x80000000\|(unsigned long)0x40000000) \| ((sizeof (struct bioc_inq) & 0x1fff) << 16) \| ((('B')) << 8) \| ((32))):
2493	DNPRINTF(SR_D_IOCTL, "inq\n");
2494	rv = sr_ioctl_inq(sc, (struct bioc_inq *)bio);
2495	break;
2496
2497	case BIOCVOL(((unsigned long)0x80000000\|(unsigned long)0x40000000) \| ((sizeof (struct bioc_vol) & 0x1fff) << 16) \| ((('B')) << 8) \| ((34))):
2498	DNPRINTF(SR_D_IOCTL, "vol\n");
2499	rv = sr_ioctl_vol(sc, (struct bioc_vol *)bio);
2500	break;
2501
2502	case BIOCDISK(((unsigned long)0x80000000\|(unsigned long)0x40000000) \| ((sizeof (struct bioc_disk) & 0x1fff) << 16) \| ((('B')) << 8) \| ((33))):
2503	DNPRINTF(SR_D_IOCTL, "disk\n");
2504	rv = sr_ioctl_disk(sc, (struct bioc_disk *)bio);
2505	break;
2506
2507	case BIOCALARM(((unsigned long)0x80000000\|(unsigned long)0x40000000) \| ((sizeof (struct bioc_alarm) & 0x1fff) << 16) \| ((('B')) << 8) \| ((35))):
2508	DNPRINTF(SR_D_IOCTL, "alarm\n");
2509	/rv = sr_ioctl_alarm(sc, (struct bioc_alarm )bio); */
2510	break;
2511
2512	case BIOCBLINK(((unsigned long)0x80000000\|(unsigned long)0x40000000) \| ((sizeof (struct bioc_blink) & 0x1fff) << 16) \| ((('B')) << 8) \| ((36))):
2513	DNPRINTF(SR_D_IOCTL, "blink\n");
2514	/rv = sr_ioctl_blink(sc, (struct bioc_blink )bio); */
2515	break;
2516
2517	case BIOCSETSTATE(((unsigned long)0x80000000\|(unsigned long)0x40000000) \| ((sizeof (struct bioc_setstate) & 0x1fff) << 16) \| ((('B')) << 8) \| ((37))):
2518	DNPRINTF(SR_D_IOCTL, "setstate\n");
2519	rv = sr_ioctl_setstate(sc, (struct bioc_setstate *)bio);
2520	break;
2521
2522	case BIOCCREATERAID(((unsigned long)0x80000000\|(unsigned long)0x40000000) \| ((sizeof (struct bioc_createraid) & 0x1fff) << 16) \| ((('B') ) << 8) \| ((38))):
2523	DNPRINTF(SR_D_IOCTL, "createraid\n");
2524	rv = sr_ioctl_createraid(sc, (struct bioc_createraid *)bio,
2525	1, NULL((void *)0));
2526	break;
2527
2528	case BIOCDELETERAID(((unsigned long)0x80000000\|(unsigned long)0x40000000) \| ((sizeof (struct bioc_deleteraid) & 0x1fff) << 16) \| ((('B') ) << 8) \| ((39))):
2529	DNPRINTF(SR_D_IOCTL, "deleteraid\n");
2530	rv = sr_ioctl_deleteraid(sc, sd, (struct bioc_deleteraid *)bio);
2531	break;
2532
2533	case BIOCDISCIPLINE(((unsigned long)0x80000000\|(unsigned long)0x40000000) \| ((sizeof (struct bioc_discipline) & 0x1fff) << 16) \| ((('B') ) << 8) \| ((40))):
2534	DNPRINTF(SR_D_IOCTL, "discipline\n");
2535	rv = sr_ioctl_discipline(sc, sd, (struct bioc_discipline *)bio);
2536	break;
2537
2538	case BIOCINSTALLBOOT(((unsigned long)0x80000000\|(unsigned long)0x40000000) \| ((sizeof (struct bioc_installboot) & 0x1fff) << 16) \| ((('B' )) << 8) \| ((41))):
2539	DNPRINTF(SR_D_IOCTL, "installboot\n");
2540	rv = sr_ioctl_installboot(sc, sd,
2541	(struct bioc_installboot *)bio);
2542	break;
2543
2544	default:
2545	DNPRINTF(SR_D_IOCTL, "invalid ioctl\n");
2546	rv = ENOTTY25;
2547	}
2548
2549	sc->sc_status.bs_status = (rv ? BIO_STATUS_ERROR2 : BIO_STATUS_SUCCESS1);
2550
2551	if (sc->sc_status.bs_msg_count > 0)
2552	rv = 0;
2553
2554	memcpy(&bio->bio_status, &sc->sc_status, sizeof(struct bio_status))__builtin_memcpy((&bio->bio_status), (&sc->sc_status ), (sizeof(struct bio_status)));
2555
2556	rw_exit_write(&sc->sc_lock);
2557
2558	return (rv);
2559	}
2560
2561	int
2562	sr_ioctl_inq(struct sr_softc sc, struct bioc_inq bi)
2563	{
2564	struct sr_discipline *sd;
2565	int vol = 0, disk = 0;
2566
2567	TAILQ_FOREACH(sd, &sc->sc_dis_list, sd_link)for((sd) = ((&sc->sc_dis_list)->tqh_first); (sd) != ((void *)0); (sd) = ((sd)->sd_link.tqe_next)) {
2568	vol++;
2569	disk += sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no;
2570	}
2571
2572	strlcpy(bi->bi_dev, sc->sc_dev.dv_xname, sizeof(bi->bi_dev));
2573	bi->bi_novol = vol + sc->sc_hotspare_no;
2574	bi->bi_nodisk = disk + sc->sc_hotspare_no;
2575
2576	return (0);
2577	}
2578
2579	int
2580	sr_ioctl_vol(struct sr_softc sc, struct bioc_vol bv)
2581	{
2582	int vol = -1, rv = EINVAL22;
2583	struct sr_discipline *sd;
2584	struct sr_chunk *hotspare;
2585
2586	TAILQ_FOREACH(sd, &sc->sc_dis_list, sd_link)for((sd) = ((&sc->sc_dis_list)->tqh_first); (sd) != ((void *)0); (sd) = ((sd)->sd_link.tqe_next)) {
2587	vol++;
2588	if (vol != bv->bv_volid)
2589	continue;
2590
2591	bv->bv_status = sd->sd_vol_status;
2592	bv->bv_size = sd->sd_meta->ssdi_sdd_invariant.ssd_size << DEV_BSHIFT9;
2593	bv->bv_level = sd->sd_meta->ssdi_sdd_invariant.ssd_level;
2594	bv->bv_nodisk = sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no;
2595
2596	#ifdef CRYPTO1
2597	if (sd->sd_meta->ssdi_sdd_invariant.ssd_level == 'C' &&
2598	sd->mdssd_dis_specific.mdd_crypto.key_disk != NULL((void *)0))
2599	bv->bv_nodisk++;
2600	else if (sd->sd_meta->ssdi_sdd_invariant.ssd_level == 0x1C &&
2601	sd->mdssd_dis_specific.mdd_raid1c.sr1c_crypto.key_disk != NULL((void *)0))
2602	bv->bv_nodisk++;
2603	#endif
2604	if (bv->bv_status == BIOC_SVREBUILD0x05)
2605	bv->bv_percent = sr_rebuild_percent(sd);
2606
2607	strlcpy(bv->bv_dev, sd->sd_meta->ssd_devname,
2608	sizeof(bv->bv_dev));
2609	strlcpy(bv->bv_vendor, sd->sd_meta->ssdi_sdd_invariant.ssd_vendor,
2610	sizeof(bv->bv_vendor));
2611	rv = 0;
2612	goto done;
2613	}
2614
2615	/* Check hotspares list. */
2616	SLIST_FOREACH(hotspare, &sc->sc_hotspare_list, src_link)for((hotspare) = ((&sc->sc_hotspare_list)->slh_first ); (hotspare) != ((void *)0); (hotspare) = ((hotspare)->src_link .sle_next)) {
2617	vol++;
2618	if (vol != bv->bv_volid)
2619	continue;
2620
2621	bv->bv_status = BIOC_SVONLINE0x00;
2622	bv->bv_size = hotspare->src_meta.scmi_scm_invariant.scm_size << DEV_BSHIFT9;
2623	bv->bv_level = -1; /* Hotspare. */
2624	bv->bv_nodisk = 1;
2625	strlcpy(bv->bv_dev, hotspare->src_meta.scmi_scm_invariant.scm_devname,
2626	sizeof(bv->bv_dev));
2627	strlcpy(bv->bv_vendor, hotspare->src_meta.scmi_scm_invariant.scm_devname,
2628	sizeof(bv->bv_vendor));
2629	rv = 0;
2630	goto done;
2631	}
2632
2633	done:
2634	return (rv);
2635	}
2636
2637	int
2638	sr_ioctl_disk(struct sr_softc sc, struct bioc_disk bd)
2639	{
2640	struct sr_discipline *sd;
2641	struct sr_chunk src, hotspare;
2642	int vol = -1, rv = EINVAL22;
2643
2644	if (bd->bd_diskid < 0)
2645	goto done;
2646
2647	TAILQ_FOREACH(sd, &sc->sc_dis_list, sd_link)for((sd) = ((&sc->sc_dis_list)->tqh_first); (sd) != ((void *)0); (sd) = ((sd)->sd_link.tqe_next)) {
2648	vol++;
2649	if (vol != bd->bd_volid)
2650	continue;
2651
2652	if (bd->bd_diskid < sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no)
2653	src = sd->sd_vol.sv_chunks[bd->bd_diskid];
2654	#ifdef CRYPTO1
2655	else if (bd->bd_diskid == sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no &&
2656	sd->sd_meta->ssdi_sdd_invariant.ssd_level == 'C' &&
2657	sd->mdssd_dis_specific.mdd_crypto.key_disk != NULL((void *)0))
2658	src = sd->mdssd_dis_specific.mdd_crypto.key_disk;
2659	else if (bd->bd_diskid == sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no &&
2660	sd->sd_meta->ssdi_sdd_invariant.ssd_level == 0x1C &&
2661	sd->mdssd_dis_specific.mdd_raid1c.sr1c_crypto.key_disk != NULL((void *)0))
2662	src = sd->mdssd_dis_specific.mdd_crypto.key_disk;
2663	#endif
2664	else
2665	break;
2666
2667	bd->bd_status = src->src_meta.scm_status;
2668	bd->bd_size = src->src_meta.scmi_scm_invariant.scm_size << DEV_BSHIFT9;
2669	bd->bd_channel = vol;
2670	bd->bd_target = bd->bd_diskid;
2671	strlcpy(bd->bd_vendor, src->src_meta.scmi_scm_invariant.scm_devname,
2672	sizeof(bd->bd_vendor));
2673	rv = 0;
2674	goto done;
2675	}
2676
2677	/* Check hotspares list. */
2678	SLIST_FOREACH(hotspare, &sc->sc_hotspare_list, src_link)for((hotspare) = ((&sc->sc_hotspare_list)->slh_first ); (hotspare) != ((void *)0); (hotspare) = ((hotspare)->src_link .sle_next)) {
2679	vol++;
2680	if (vol != bd->bd_volid)
2681	continue;
2682
2683	if (bd->bd_diskid != 0)
2684	break;
2685
2686	bd->bd_status = hotspare->src_meta.scm_status;
2687	bd->bd_size = hotspare->src_meta.scmi_scm_invariant.scm_size << DEV_BSHIFT9;
2688	bd->bd_channel = vol;
2689	bd->bd_target = bd->bd_diskid;
2690	strlcpy(bd->bd_vendor, hotspare->src_meta.scmi_scm_invariant.scm_devname,
2691	sizeof(bd->bd_vendor));
2692	rv = 0;
2693	goto done;
2694	}
2695
2696	done:
2697	return (rv);
2698	}
2699
2700	int
2701	sr_ioctl_setstate(struct sr_softc sc, struct bioc_setstate bs)
2702	{
2703	int rv = EINVAL22;
2704	int vol = -1, found, c;
2705	struct sr_discipline *sd;
2706	struct sr_chunk *ch_entry;
2707	struct sr_chunk_head *cl;
2708
2709	if (bs->bs_other_id_type == BIOC_SSOTHER_UNUSED0x00)
2710	goto done;
2711
2712	if (bs->bs_status == BIOC_SSHOTSPARE0x02) {
2713	rv = sr_hotspare(sc, (dev_t)bs->bs_other_id);
2714	goto done;
2715	}
2716
2717	TAILQ_FOREACH(sd, &sc->sc_dis_list, sd_link)for((sd) = ((&sc->sc_dis_list)->tqh_first); (sd) != ((void *)0); (sd) = ((sd)->sd_link.tqe_next)) {
2718	vol++;
2719	if (vol == bs->bs_volid)
2720	break;
2721	}
2722	if (sd == NULL((void *)0))
2723	goto done;
2724
2725	switch (bs->bs_status) {
2726	case BIOC_SSOFFLINE0x01:
2727	/* Take chunk offline */
2728	found = c = 0;
2729	cl = &sd->sd_vol.sv_chunk_list;
2730	SLIST_FOREACH(ch_entry, cl, src_link)for((ch_entry) = ((cl)->slh_first); (ch_entry) != ((void * )0); (ch_entry) = ((ch_entry)->src_link.sle_next)) {
2731	if (ch_entry->src_dev_mm == bs->bs_other_id) {
2732	found = 1;
2733	break;
2734	}
2735	c++;
2736	}
2737	if (found == 0) {
2738	sr_error(sc, "chunk not part of array");
2739	goto done;
2740	}
2741
2742	/* XXX: check current state first */
2743	sd->sd_set_chunk_state(sd, c, BIOC_SDOFFLINE0x01);
2744
2745	if (sr_meta_save(sd, SR_META_DIRTY0x1)) {
2746	sr_error(sc, "could not save metadata for %s",
2747	sd->sd_meta->ssd_devname);
2748	goto done;
2749	}
2750	rv = 0;
2751	break;
2752
2753	case BIOC_SDSCRUB0x06:
2754	break;
2755
2756	case BIOC_SSREBUILD0x03:
2757	rv = sr_rebuild_init(sd, (dev_t)bs->bs_other_id, 0);
2758	break;
2759
2760	default:
2761	sr_error(sc, "unsupported state request %d", bs->bs_status);
2762	}
2763
2764	done:
2765	return (rv);
2766	}
2767
2768	int
2769	sr_chunk_in_use(struct sr_softc *sc, dev_t dev)
2770	{
2771	struct sr_discipline *sd;
2772	struct sr_chunk *chunk;
2773	int i;
2774
2775	DNPRINTF(SR_D_MISC, "%s: sr_chunk_in_use(%d)\n", DEVNAME(sc), dev);
2776
2777	if (dev == NODEV(dev_t)(-1))
2778	return BIOC_SDINVALID0xff;
2779
2780	/* See if chunk is already in use. */
2781	TAILQ_FOREACH(sd, &sc->sc_dis_list, sd_link)for((sd) = ((&sc->sc_dis_list)->tqh_first); (sd) != ((void *)0); (sd) = ((sd)->sd_link.tqe_next)) {
2782	for (i = 0; i < sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no; i++) {
2783	chunk = sd->sd_vol.sv_chunks[i];
2784	if (chunk->src_dev_mm == dev)
2785	return chunk->src_meta.scm_status;
2786	}
2787	}
2788
2789	/* Check hotspares list. */
2790	SLIST_FOREACH(chunk, &sc->sc_hotspare_list, src_link)for((chunk) = ((&sc->sc_hotspare_list)->slh_first); (chunk) != ((void *)0); (chunk) = ((chunk)->src_link.sle_next ))
2791	if (chunk->src_dev_mm == dev)
2792	return chunk->src_meta.scm_status;
2793
2794	return BIOC_SDINVALID0xff;
2795	}
2796
2797	int
2798	sr_hotspare(struct sr_softc *sc, dev_t dev)
2799	{
2800	struct sr_discipline sd = NULL((void )0);
2801	struct sr_metadata sm = NULL((void )0);
2802	struct sr_meta_chunk *hm;
2803	struct sr_chunk_head *cl;
2804	struct sr_chunk chunk, last, hotspare = NULL((void )0);
2805	struct sr_uuid uuid;
2806	struct disklabel label;
2807	struct vnode *vn;
2808	u_int64_t size;
2809	char devname[32];
2810	int rv = EINVAL22;
2811	int c, part, open = 0;
2812
2813	/*
2814	* Add device to global hotspares list.
2815	*/
2816
2817	sr_meta_getdevname(sc, dev, devname, sizeof(devname));
2818
2819	/* Make sure chunk is not already in use. */
2820	c = sr_chunk_in_use(sc, dev);
2821	if (c != BIOC_SDINVALID0xff && c != BIOC_SDOFFLINE0x01) {
2822	if (c == BIOC_SDHOTSPARE0x04)
2823	sr_error(sc, "%s is already a hotspare", devname);
2824	else
2825	sr_error(sc, "%s is already in use", devname);
2826	goto done;
2827	}
2828
2829	/* XXX - See if there is an existing degraded volume... */
2830
2831	/* Open device. */
2832	if (bdevvp(dev, &vn)) {
2833	sr_error(sc, "sr_hotspare: cannot allocate vnode");
2834	goto done;
2835	}
2836	if (VOP_OPEN(vn, FREAD0x0001 \| FWRITE0x0002, NOCRED((struct ucred )-1), curproc({struct cpu_info __ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc)) {
2837	DNPRINTF(SR_D_META,"%s: sr_hotspare cannot open %s\n",
2838	DEVNAME(sc), devname);
2839	vput(vn);
2840	goto fail;
2841	}
2842	open = 1; /* close dev on error */
2843
2844	/* Get partition details. */
2845	part = DISKPART(dev)(((unsigned)((dev) & 0xff) \| (((dev) & 0xffff0000) >> 8)) % 16);
2846	if (VOP_IOCTL(vn, DIOCGDINFO((unsigned long)0x40000000 \| ((sizeof(struct disklabel) & 0x1fff) << 16) \| ((('d')) << 8) \| ((101))), (caddr_t)&label, FREAD0x0001,
2847	NOCRED((struct ucred )-1), curproc({struct cpu_info __ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc)) {
2848	DNPRINTF(SR_D_META, "%s: sr_hotspare ioctl failed\n",
2849	DEVNAME(sc));
2850	goto fail;
2851	}
2852	if (label.d_partitions[part].p_fstype != FS_RAID19) {
2853	sr_error(sc, "%s partition not of type RAID (%d)",
2854	devname, label.d_partitions[part].p_fstype);
2855	goto fail;
2856	}
2857
2858	/* Calculate partition size. */
2859	size = DL_SECTOBLK(&label, DL_GETPSIZE(&label.d_partitions[part]))(((((u_int64_t)(&label.d_partitions[part])->p_sizeh << 32) + (&label.d_partitions[part])->p_size)) * ((& label)->d_secsize / (1 << 9)));
2860	if (size <= SR_DATA_OFFSET(16 + (64 + (320 + 128)))) {
2861	DNPRINTF(SR_D_META, "%s: %s partition too small\n", DEVNAME(sc),
2862	devname);
2863	goto fail;
2864	}
2865	size -= SR_DATA_OFFSET(16 + (64 + (320 + 128)));
2866	if (size > INT64_MAX0x7fffffffffffffffLL) {
2867	DNPRINTF(SR_D_META, "%s: %s partition too large\n", DEVNAME(sc),
2868	devname);
2869	goto fail;
2870	}
2871
2872	/*
2873	* Create and populate chunk metadata.
2874	*/
2875
2876	sr_uuid_generate(&uuid);
2877	hotspare = malloc(sizeof(struct sr_chunk), M_DEVBUF2, M_WAITOK0x0001 \| M_ZERO0x0008);
2878
2879	hotspare->src_dev_mm = dev;
2880	hotspare->src_vn = vn;
2881	strlcpy(hotspare->src_devname, devname, sizeof(hm->scmi_scm_invariant.scm_devname));
2882	hotspare->src_size = size;
2883
2884	hm = &hotspare->src_meta;
2885	hm->scmi_scm_invariant.scm_volid = SR_HOTSPARE_VOLID0xffffffff;
2886	hm->scmi_scm_invariant.scm_chunk_id = 0;
2887	hm->scmi_scm_invariant.scm_size = size;
2888	hm->scmi_scm_invariant.scm_coerced_size = size;
2889	strlcpy(hm->scmi_scm_invariant.scm_devname, devname, sizeof(hm->scmi_scm_invariant.scm_devname));
2890	memcpy(&hm->scmi.scm_uuid, &uuid, sizeof(struct sr_uuid))__builtin_memcpy((&hm->_scm_invariant.scm_uuid), (& uuid), (sizeof(struct sr_uuid)));
2891
2892	sr_checksum(sc, hm, &hm->scm_checksum,
2893	sizeof(struct sr_meta_chunk_invariant));
2894
2895	hm->scm_status = BIOC_SDHOTSPARE0x04;
2896
2897	/*
2898	* Create and populate our own discipline and metadata.
2899	*/
2900
2901	sm = malloc(sizeof(struct sr_metadata), M_DEVBUF2, M_WAITOK0x0001 \| M_ZERO0x0008);
2902	sm->ssdi_sdd_invariant.ssd_magic = SR_MAGIC0x4d4152436372616dLLU;
2903	sm->ssdi_sdd_invariant.ssd_version = SR_META_VERSION6;
2904	sm->ssd_ondisk = 0;
2905	sm->ssdi_sdd_invariant.ssd_vol_flags = 0;
2906	memcpy(&sm->ssdi.ssd_uuid, &uuid, sizeof(struct sr_uuid))__builtin_memcpy((&sm->_sdd_invariant.ssd_uuid), (& uuid), (sizeof(struct sr_uuid)));
2907	sm->ssdi_sdd_invariant.ssd_chunk_no = 1;
2908	sm->ssdi_sdd_invariant.ssd_volid = SR_HOTSPARE_VOLID0xffffffff;
2909	sm->ssdi_sdd_invariant.ssd_level = SR_HOTSPARE_LEVEL0xffffffff;
2910	sm->ssdi_sdd_invariant.ssd_size = size;
2911	sm->ssdi_sdd_invariant.ssd_secsize = label.d_secsize;
2912	strlcpy(sm->ssdi_sdd_invariant.ssd_vendor, "OPENBSD", sizeof(sm->ssdi_sdd_invariant.ssd_vendor));
2913	snprintf(sm->ssdi_sdd_invariant.ssd_product, sizeof(sm->ssdi_sdd_invariant.ssd_product),
2914	"SR %s", "HOTSPARE");
2915	snprintf(sm->ssdi_sdd_invariant.ssd_revision, sizeof(sm->ssdi_sdd_invariant.ssd_revision),
2916	"%03d", SR_META_VERSION6);
2917
2918	sd = malloc(sizeof(struct sr_discipline), M_DEVBUF2, M_WAITOK0x0001 \| M_ZERO0x0008);
2919	sd->sd_sc = sc;
2920	sd->sd_meta = sm;
2921	sd->sd_meta_type = SR_META_F_NATIVE0;
2922	sd->sd_vol_status = BIOC_SVONLINE0x00;
2923	strlcpy(sd->sd_name, "HOTSPARE", sizeof(sd->sd_name));
2924	SLIST_INIT(&sd->sd_meta_opt){ ((&sd->sd_meta_opt)->slh_first) = ((void *)0); };
2925
2926	/* Add chunk to volume. */
2927	sd->sd_vol.sv_chunks = malloc(sizeof(struct sr_chunk *), M_DEVBUF2,
2928	M_WAITOK0x0001 \| M_ZERO0x0008);
2929	sd->sd_vol.sv_chunks[0] = hotspare;
2930	SLIST_INIT(&sd->sd_vol.sv_chunk_list){ ((&sd->sd_vol.sv_chunk_list)->slh_first) = ((void *)0); };
2931	SLIST_INSERT_HEAD(&sd->sd_vol.sv_chunk_list, hotspare, src_link)do { (hotspare)->src_link.sle_next = (&sd->sd_vol.sv_chunk_list )->slh_first; (&sd->sd_vol.sv_chunk_list)->slh_first = (hotspare); } while (0);
2932
2933	/* Save metadata. */
2934	if (sr_meta_save(sd, SR_META_DIRTY0x1)) {
2935	sr_error(sc, "could not save metadata to %s", devname);
2936	goto fail;
2937	}
2938
2939	/*
2940	* Add chunk to hotspare list.
2941	*/
2942	rw_enter_write(&sc->sc_hs_lock);
2943	cl = &sc->sc_hotspare_list;
2944	if (SLIST_EMPTY(cl)(((cl)->slh_first) == ((void *)0)))
2945	SLIST_INSERT_HEAD(cl, hotspare, src_link)do { (hotspare)->src_link.sle_next = (cl)->slh_first; ( cl)->slh_first = (hotspare); } while (0);
2946	else {
2947	SLIST_FOREACH(chunk, cl, src_link)for((chunk) = ((cl)->slh_first); (chunk) != ((void *)0); ( chunk) = ((chunk)->src_link.sle_next))
2948	last = chunk;
2949	SLIST_INSERT_AFTER(last, hotspare, src_link)do { (hotspare)->src_link.sle_next = (last)->src_link.sle_next ; (last)->src_link.sle_next = (hotspare); } while (0);
2950	}
2951	sc->sc_hotspare_no++;
2952	rw_exit_write(&sc->sc_hs_lock);
2953
2954	rv = 0;
2955	goto done;
2956
2957	fail:
2958	free(hotspare, M_DEVBUF2, sizeof(*hotspare));
2959
2960	done:
2961	if (sd)
2962	free(sd->sd_vol.sv_chunks, M_DEVBUF2,
2963	sizeof(sd->sd_vol.sv_chunks));
2964	free(sd, M_DEVBUF2, sizeof(*sd));
2965	free(sm, M_DEVBUF2, sizeof(*sm));
2966	if (open) {
2967	VOP_CLOSE(vn, FREAD0x0001 \| FWRITE0x0002, NOCRED((struct ucred )-1), curproc({struct cpu_info __ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc);
2968	vput(vn);
2969	}
2970
2971	return (rv);
2972	}
2973
2974	void
2975	sr_hotspare_rebuild_callback(void *xsd)
2976	{
2977	struct sr_discipline *sd = xsd;
2978	sr_hotspare_rebuild(sd);
2979	}
2980
2981	void
2982	sr_hotspare_rebuild(struct sr_discipline *sd)
2983	{
2984	struct sr_softc *sc = sd->sd_sc;
2985	struct sr_chunk_head *cl;
2986	struct sr_chunk hotspare, chunk = NULL((void *)0);
2987	struct sr_workunit *wu;
2988	struct sr_ccb *ccb;
2989	int i, s, cid, busy;
2990
2991	/*
2992	* Attempt to locate a hotspare and initiate rebuild.
2993	*/
2994
2995	/* Find first offline chunk. */
2996	for (cid = 0; cid < sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no; cid++) {
2997	if (sd->sd_vol.sv_chunks[cid]->src_meta.scm_status ==
2998	BIOC_SDOFFLINE0x01) {
2999	chunk = sd->sd_vol.sv_chunks[cid];
3000	break;
3001	}
3002	}
3003	if (chunk == NULL((void *)0)) {
3004	printf("%s: no offline chunk found on %s!\n",
3005	DEVNAME(sc)((sc)->sc_dev.dv_xname), sd->sd_meta->ssd_devname);
3006	return;
3007	}
3008
3009	/* See if we have a suitable hotspare... */
3010	rw_enter_write(&sc->sc_hs_lock);
3011	cl = &sc->sc_hotspare_list;
3012	SLIST_FOREACH(hotspare, cl, src_link)for((hotspare) = ((cl)->slh_first); (hotspare) != ((void * )0); (hotspare) = ((hotspare)->src_link.sle_next))
3013	if (hotspare->src_size >= chunk->src_size &&
3014	hotspare->src_secsize <= sd->sd_meta->ssdi_sdd_invariant.ssd_secsize)
3015	break;
3016
3017	if (hotspare != NULL((void *)0)) {
3018
3019	printf("%s: %s volume degraded, will attempt to "
3020	"rebuild on hotspare %s\n", DEVNAME(sc)((sc)->sc_dev.dv_xname),
3021	sd->sd_meta->ssd_devname, hotspare->src_devname);
3022
3023	/*
3024	* Ensure that all pending I/O completes on the failed chunk
3025	* before trying to initiate a rebuild.
3026	*/
3027	i = 0;
3028	do {
3029	busy = 0;
3030
3031	s = splbio()splraise(0x3);
3032	TAILQ_FOREACH(wu, &sd->sd_wu_pendq, swu_link)for((wu) = ((&sd->sd_wu_pendq)->tqh_first); (wu) != ((void *)0); (wu) = ((wu)->swu_link.tqe_next)) {
3033	TAILQ_FOREACH(ccb, &wu->swu_ccb, ccb_link)for((ccb) = ((&wu->swu_ccb)->tqh_first); (ccb) != ( (void *)0); (ccb) = ((ccb)->ccb_link.tqe_next)) {
3034	if (ccb->ccb_target == cid)
3035	busy = 1;
3036	}
3037	}
3038	TAILQ_FOREACH(wu, &sd->sd_wu_defq, swu_link)for((wu) = ((&sd->sd_wu_defq)->tqh_first); (wu) != ( (void *)0); (wu) = ((wu)->swu_link.tqe_next)) {
3039	TAILQ_FOREACH(ccb, &wu->swu_ccb, ccb_link)for((ccb) = ((&wu->swu_ccb)->tqh_first); (ccb) != ( (void *)0); (ccb) = ((ccb)->ccb_link.tqe_next)) {
3040	if (ccb->ccb_target == cid)
3041	busy = 1;
3042	}
3043	}
3044	splx(s)spllower(s);
3045
3046	if (busy) {
3047	tsleep_nsec(sd, PRIBIO16, "sr_hotspare",
3048	SEC_TO_NSEC(1));
3049	i++;
3050	}
3051
3052	} while (busy && i < 120);
3053
3054	DNPRINTF(SR_D_META, "%s: waited %i seconds for I/O to "
3055	"complete on failed chunk %s\n", DEVNAME(sc),
3056	i, chunk->src_devname);
3057
3058	if (busy) {
3059	printf("%s: pending I/O failed to complete on "
3060	"failed chunk %s, hotspare rebuild aborted...\n",
3061	DEVNAME(sc)((sc)->sc_dev.dv_xname), chunk->src_devname);
3062	goto done;
3063	}
3064
3065	s = splbio()splraise(0x3);
3066	rw_enter_write(&sc->sc_lock);
3067	bio_status_init(&sc->sc_status, &sc->sc_dev);
3068	if (sr_rebuild_init(sd, hotspare->src_dev_mm, 1) == 0) {
3069
3070	/* Remove hotspare from available list. */
3071	sc->sc_hotspare_no--;
3072	SLIST_REMOVE(cl, hotspare, sr_chunk, src_link)do { if ((cl)->slh_first == (hotspare)) { do { ((cl))-> slh_first = ((cl))->slh_first->src_link.sle_next; } while (0); } else { struct sr_chunk curelm = (cl)->slh_first; while (curelm->src_link.sle_next != (hotspare)) curelm = curelm ->src_link.sle_next; curelm->src_link.sle_next = curelm ->src_link.sle_next->src_link.sle_next; } ((hotspare)-> src_link.sle_next) = ((void )-1); } while (0);
3073	free(hotspare, M_DEVBUF2, sizeof(*hotspare));
3074
3075	}
3076	rw_exit_write(&sc->sc_lock);
3077	splx(s)spllower(s);
3078	}
3079	done:
3080	rw_exit_write(&sc->sc_hs_lock);
3081	}
3082
3083	int
3084	sr_rebuild_init(struct sr_discipline *sd, dev_t dev, int hotspare)
3085	{
3086	struct sr_softc *sc = sd->sd_sc;
3087	struct sr_chunk chunk = NULL((void )0);
3088	struct sr_meta_chunk *meta;
3089	struct disklabel label;
3090	struct vnode *vn;
3091	u_int64_t size;
3092	int64_t csize;
3093	char devname[32];
3094	int rv = EINVAL22, open = 0;
3095	int cid, i, part, status;
3096
3097	/*
3098	* Attempt to initiate a rebuild onto the specified device.
3099	*/
3100
3101	if (!(sd->sd_capabilities & SR_CAP_REBUILD0x00000004)) {
3102	sr_error(sc, "discipline does not support rebuild");
3103	goto done;
3104	}
3105
3106	/* make sure volume is in the right state */
3107	if (sd->sd_vol_status == BIOC_SVREBUILD0x05) {
3108	sr_error(sc, "rebuild already in progress");
3109	goto done;
3110	}
3111	if (sd->sd_vol_status != BIOC_SVDEGRADED0x02) {
3112	sr_error(sc, "volume not degraded");
3113	goto done;
3114	}
3115
3116	/* Find first offline chunk. */
3117	for (cid = 0; cid < sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no; cid++) {
3118	if (sd->sd_vol.sv_chunks[cid]->src_meta.scm_status ==
3119	BIOC_SDOFFLINE0x01) {
3120	chunk = sd->sd_vol.sv_chunks[cid];
3121	break;
3122	}
3123	}
3124	if (chunk == NULL((void *)0)) {
3125	sr_error(sc, "no offline chunks available to rebuild");
3126	goto done;
3127	}
3128
3129	/* Get coerced size from another online chunk. */
3130	csize = 0;
3131	for (i = 0; i < sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no; i++) {
3132	if (sd->sd_vol.sv_chunks[i]->src_meta.scm_status ==
3133	BIOC_SDONLINE0x00) {
3134	meta = &sd->sd_vol.sv_chunks[i]->src_meta;
3135	csize = meta->scmi_scm_invariant.scm_coerced_size;
3136	break;
3137	}
3138	}
3139	if (csize == 0) {
3140	sr_error(sc, "no online chunks available for rebuild");
3141	goto done;
3142	}
3143
3144	sr_meta_getdevname(sc, dev, devname, sizeof(devname));
3145	if (bdevvp(dev, &vn)) {
3146	printf("%s: sr_rebuild_init: can't allocate vnode\n",
3147	DEVNAME(sc)((sc)->sc_dev.dv_xname));
3148	goto done;
3149	}
3150	if (VOP_OPEN(vn, FREAD0x0001 \| FWRITE0x0002, NOCRED((struct ucred )-1), curproc({struct cpu_info __ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc)) {
3151	DNPRINTF(SR_D_META,"%s: sr_ioctl_setstate can't "
3152	"open %s\n", DEVNAME(sc), devname);
3153	vput(vn);
3154	goto done;
3155	}
3156	open = 1; /* close dev on error */
3157
3158	/* Get disklabel and check partition. */
3159	part = DISKPART(dev)(((unsigned)((dev) & 0xff) \| (((dev) & 0xffff0000) >> 8)) % 16);
3160	if (VOP_IOCTL(vn, DIOCGDINFO((unsigned long)0x40000000 \| ((sizeof(struct disklabel) & 0x1fff) << 16) \| ((('d')) << 8) \| ((101))), (caddr_t)&label, FREAD0x0001,
3161	NOCRED((struct ucred )-1), curproc({struct cpu_info __ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc)) {
3162	DNPRINTF(SR_D_META, "%s: sr_ioctl_setstate ioctl failed\n",
3163	DEVNAME(sc));
3164	goto done;
3165	}
3166	if (label.d_partitions[part].p_fstype != FS_RAID19) {
3167	sr_error(sc, "%s partition not of type RAID (%d)",
3168	devname, label.d_partitions[part].p_fstype);
3169	goto done;
3170	}
3171
3172	/* Is the partition large enough? */
3173	size = DL_SECTOBLK(&label, DL_GETPSIZE(&label.d_partitions[part]))(((((u_int64_t)(&label.d_partitions[part])->p_sizeh << 32) + (&label.d_partitions[part])->p_size)) * ((& label)->d_secsize / (1 << 9)));
3174	if (size <= sd->sd_meta->ssd_data_blkno) {
3175	sr_error(sc, "%s: %s partition too small", DEVNAME(sc)((sc)->sc_dev.dv_xname),
3176	devname);
3177	goto done;
3178	}
3179	size -= sd->sd_meta->ssd_data_blkno;
3180	if (size > INT64_MAX0x7fffffffffffffffLL) {
3181	sr_error(sc, "%s: %s partition too large", DEVNAME(sc)((sc)->sc_dev.dv_xname),
3182	devname);
3183	goto done;
3184	}
3185	if (size < csize) {
3186	sr_error(sc, "%s partition too small, at least %lld bytes "
3187	"required", devname, (long long)(csize << DEV_BSHIFT9));
3188	goto done;
3189	} else if (size > csize)
3190	sr_warn(sc, "%s partition too large, wasting %lld bytes",
3191	devname, (long long)((size - csize) << DEV_BSHIFT9));
3192	if (label.d_secsize > sd->sd_meta->ssdi_sdd_invariant.ssd_secsize) {
3193	sr_error(sc, "%s sector size too large, <= %u bytes "
3194	"required", devname, sd->sd_meta->ssdi_sdd_invariant.ssd_secsize);
3195	goto done;
3196	}
3197
3198	/* Ensure that this chunk is not already in use. */
3199	status = sr_chunk_in_use(sc, dev);
3200	if (status != BIOC_SDINVALID0xff && status != BIOC_SDOFFLINE0x01 &&
3201	!(hotspare && status == BIOC_SDHOTSPARE0x04)) {
3202	sr_error(sc, "%s is already in use", devname);
3203	goto done;
3204	}
3205
3206	/* Reset rebuild counter since we rebuilding onto a new chunk. */
3207	sd->sd_meta->ssd_rebuild = 0;
3208
3209	open = 0; /* leave dev open from here on out */
3210
3211	/* Fix up chunk. */
3212	memcpy(chunk->src_duid, label.d_uid, sizeof(chunk->src_duid))__builtin_memcpy((chunk->src_duid), (label.d_uid), (sizeof (chunk->src_duid)));
3213	chunk->src_dev_mm = dev;
3214	chunk->src_vn = vn;
3215
3216	/* Reconstruct metadata. */
3217	meta = &chunk->src_meta;
3218	meta->scmi_scm_invariant.scm_volid = sd->sd_meta->ssdi_sdd_invariant.ssd_volid;
3219	meta->scmi_scm_invariant.scm_chunk_id = cid;
3220	strlcpy(meta->scmi_scm_invariant.scm_devname, devname,
3221	sizeof(meta->scmi_scm_invariant.scm_devname));
3222	meta->scmi_scm_invariant.scm_size = size;
3223	meta->scmi_scm_invariant.scm_coerced_size = csize;
3224	memcpy(&meta->scmi.scm_uuid, &sd->sd_meta->ssdi.ssd_uuid,__builtin_memcpy((&meta->_scm_invariant.scm_uuid), (& sd->sd_meta->_sdd_invariant.ssd_uuid), (sizeof(meta-> _scm_invariant.scm_uuid)))
3225	sizeof(meta->scmi.scm_uuid))__builtin_memcpy((&meta->_scm_invariant.scm_uuid), (& sd->sd_meta->_sdd_invariant.ssd_uuid), (sizeof(meta-> _scm_invariant.scm_uuid)));
3226	sr_checksum(sc, meta, &meta->scm_checksum,
3227	sizeof(struct sr_meta_chunk_invariant));
3228
3229	sd->sd_set_chunk_state(sd, cid, BIOC_SDREBUILD0x03);
3230
3231	if (sr_meta_save(sd, SR_META_DIRTY0x1)) {
3232	sr_error(sc, "could not save metadata to %s", devname);
3233	open = 1;
3234	goto done;
3235	}
3236
3237	sr_warn(sc, "rebuild of %s started on %s",
3238	sd->sd_meta->ssd_devname, devname);
3239
3240	sd->sd_reb_abort = 0;
3241	kthread_create_deferred(sr_rebuild_start, sd);
3242
3243	rv = 0;
3244	done:
3245	if (open) {
3246	VOP_CLOSE(vn, FREAD0x0001 \| FWRITE0x0002, NOCRED((struct ucred )-1), curproc({struct cpu_info __ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc);
3247	vput(vn);
3248	}
3249
3250	return (rv);
3251	}
3252
3253	int
3254	sr_rebuild_percent(struct sr_discipline *sd)
3255	{
3256	daddr_t rb, sz;
3257
3258	sz = sd->sd_meta->ssdi_sdd_invariant.ssd_size;
3259	rb = sd->sd_meta->ssd_rebuild;
3260
3261	if (rb > 0)
3262	return (100 - ((sz * 100 - rb * 100) / sz) - 1);
3263
3264	return (0);
3265	}
3266
3267	void
3268	sr_roam_chunks(struct sr_discipline *sd)
3269	{
3270	struct sr_softc *sc = sd->sd_sc;
3271	struct sr_chunk *chunk;
3272	struct sr_meta_chunk *meta;
3273	int roamed = 0;
3274
3275	/* Have any chunks roamed? */
3276	SLIST_FOREACH(chunk, &sd->sd_vol.sv_chunk_list, src_link)for((chunk) = ((&sd->sd_vol.sv_chunk_list)->slh_first ); (chunk) != ((void *)0); (chunk) = ((chunk)->src_link.sle_next )) {
3277	meta = &chunk->src_meta;
3278	if (strncmp(meta->scmi_scm_invariant.scm_devname, chunk->src_devname,
3279	sizeof(meta->scmi_scm_invariant.scm_devname))) {
3280
3281	printf("%s: roaming device %s -> %s\n", DEVNAME(sc)((sc)->sc_dev.dv_xname),
3282	meta->scmi_scm_invariant.scm_devname, chunk->src_devname);
3283
3284	strlcpy(meta->scmi_scm_invariant.scm_devname, chunk->src_devname,
3285	sizeof(meta->scmi_scm_invariant.scm_devname));
3286
3287	roamed++;
3288	}
3289	}
3290
3291	if (roamed)
3292	sr_meta_save(sd, SR_META_DIRTY0x1);
3293	}
3294
3295	int
3296	sr_ioctl_createraid(struct sr_softc sc, struct bioc_createraid bc,
3297	int user, void *data)
3298	{
3299	struct sr_meta_opt_item *omi;
3300	struct sr_chunk_head *cl;
3301	struct sr_discipline sd = NULL((void )0);
3302	struct sr_chunk *ch_entry;
3303	struct scsi_link *link;
3304	struct device *dev;
3305	char *uuid, devname[32];
3306	dev_t dt = NULL((void )0);
3307	int i, no_chunk, rv = EINVAL22, target, vol;
3308	int no_meta;
3309
3310	DNPRINTF(SR_D_IOCTL, "%s: sr_ioctl_createraid(%d)\n",
3311	DEVNAME(sc), user);
3312
3313	/* user input */
3314	if (bc->bc_dev_list_len > BIOC_CRMAXLEN1024)
3315	goto unwind;
3316
3317	dt = malloc(bc->bc_dev_list_len, M_DEVBUF2, M_WAITOK0x0001 \| M_ZERO0x0008);
3318	if (user) {
3319	if (copyin(bc->bc_dev_list, dt, bc->bc_dev_list_len) != 0)
3320	goto unwind;
3321	} else
3322	memcpy(dt, bc->bc_dev_list, bc->bc_dev_list_len)__builtin_memcpy((dt), (bc->bc_dev_list), (bc->bc_dev_list_len ));
3323
3324	/* Initialise discipline. */
3325	sd = malloc(sizeof(struct sr_discipline), M_DEVBUF2, M_WAITOK0x0001 \| M_ZERO0x0008);
3326	sd->sd_sc = sc;
3327	SLIST_INIT(&sd->sd_meta_opt){ ((&sd->sd_meta_opt)->slh_first) = ((void *)0); };
3328	sd->sd_taskq = taskq_create("srdis", 1, IPL_BIO0x3, 0);
3329	if (sd->sd_taskq == NULL((void *)0)) {
3330	sr_error(sc, "could not create discipline taskq");
3331	goto unwind;
3332	}
3333	if (sr_discipline_init(sd, bc->bc_level)) {
3334	sr_error(sc, "could not initialize discipline");
3335	goto unwind;
3336	}
3337
3338	no_chunk = bc->bc_dev_list_len / sizeof(dev_t);
3339	cl = &sd->sd_vol.sv_chunk_list;
3340	SLIST_INIT(cl){ ((cl)->slh_first) = ((void *)0); };
3341
3342	/* Ensure that chunks are not already in use. */
3343	for (i = 0; i < no_chunk; i++) {
3344	if (sr_chunk_in_use(sc, dt[i]) != BIOC_SDINVALID0xff) {
3345	sr_meta_getdevname(sc, dt[i], devname, sizeof(devname));
3346	sr_error(sc, "chunk %s already in use", devname);
3347	goto unwind;
3348	}
3349	}
3350
3351	sd->sd_meta_type = sr_meta_probe(sd, dt, no_chunk);
3352	if (sd->sd_meta_type == SR_META_F_INVALID-1) {
3353	sr_error(sc, "invalid metadata format");
3354	goto unwind;
3355	}
3356
3357	if (sr_meta_attach(sd, no_chunk, bc->bc_flags & BIOC_SCFORCE0x01))
3358	goto unwind;
3359
3360	/* force the raid volume by clearing metadata region */
3361	if (bc->bc_flags & BIOC_SCFORCE0x01) {
3362	/* make sure disk isn't up and running */
3363	if (sr_meta_read(sd))
3364	if (sr_already_assembled(sd)) {
3365	uuid = sr_uuid_format(
3366	&sd->sd_meta->ssdi_sdd_invariant.ssd_uuid);
3367	sr_error(sc, "disk %s is currently in use; "
3368	"cannot force create", uuid);
3369	free(uuid, M_DEVBUF2, 37);
3370	goto unwind;
3371	}
3372
3373	if (sr_meta_clear(sd)) {
3374	sr_error(sc, "failed to clear metadata");
3375	goto unwind;
3376	}
3377	}
3378
3379	no_meta = sr_meta_read(sd);
3380	if (no_meta == -1) {
3381
3382	/* Corrupt metadata on one or more chunks. */
3383	sr_error(sc, "one of the chunks has corrupt metadata; "
3384	"aborting assembly");
3385	goto unwind;
3386
3387	} else if (no_meta == 0) {
3388
3389	/* Initialise volume and chunk metadata. */
3390	sr_meta_init(sd, bc->bc_level, no_chunk);
3391	sd->sd_vol_status = BIOC_SVONLINE0x00;
3392	sd->sd_meta_flags = bc->bc_flags & BIOC_SCNOAUTOASSEMBLE0x04;
3393	if (sd->sd_create) {
3394	if ((i = sd->sd_create(sd, bc, no_chunk,
3395	sd->sd_vol.sv_chunk_minsz))) {
3396	rv = i;
3397	goto unwind;
3398	}
3399	}
3400	sr_meta_init_complete(sd);
3401
3402	DNPRINTF(SR_D_IOCTL,
3403	"%s: sr_ioctl_createraid: vol_size: %lld\n",
3404	DEVNAME(sc), sd->sd_meta->ssdi.ssd_size);
3405
3406	/* Warn if we've wasted chunk space due to coercing. */
3407	if ((sd->sd_capabilities & SR_CAP_NON_COERCED0x00000008) == 0 &&
3408	sd->sd_vol.sv_chunk_minsz != sd->sd_vol.sv_chunk_maxsz)
3409	sr_warn(sc, "chunk sizes are not equal; up to %llu "
3410	"blocks wasted per chunk",
3411	sd->sd_vol.sv_chunk_maxsz -
3412	sd->sd_vol.sv_chunk_minsz);
3413
3414	} else {
3415
3416	/* Ensure we are assembling the correct # of chunks. */
3417	if (bc->bc_level == 0x1C &&
3418	sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no > no_chunk) {
3419	sr_warn(sc, "trying to bring up %s degraded",
3420	sd->sd_meta->ssd_devname);
3421	} else if (sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no != no_chunk) {
3422	sr_error(sc, "volume chunk count does not match metadata "
3423	"chunk count");
3424	goto unwind;
3425	}
3426
3427	/* Ensure metadata level matches requested assembly level. */
3428	if (sd->sd_meta->ssdi_sdd_invariant.ssd_level != bc->bc_level) {
3429	sr_error(sc, "volume level does not match metadata "
3430	"level");
3431	goto unwind;
3432	}
3433
3434	if (sr_already_assembled(sd)) {
3435	uuid = sr_uuid_format(&sd->sd_meta->ssdi_sdd_invariant.ssd_uuid);
3436	sr_error(sc, "disk %s already assembled", uuid);
3437	free(uuid, M_DEVBUF2, 37);
3438	goto unwind;
3439	}
3440
3441	if (user == 0 && sd->sd_meta_flags & BIOC_SCNOAUTOASSEMBLE0x04) {
3442	DNPRINTF(SR_D_META, "%s: disk not auto assembled from "
3443	"metadata\n", DEVNAME(sc));
3444	goto unwind;
3445	}
3446
3447	if (no_meta != no_chunk)
3448	sr_warn(sc, "trying to bring up %s degraded",
3449	sd->sd_meta->ssd_devname);
3450
3451	if (sd->sd_meta->ssd_meta_flags & SR_META_DIRTY0x1)
3452	sr_warn(sc, "%s was not shutdown properly",
3453	sd->sd_meta->ssd_devname);
3454
3455	SLIST_FOREACH(omi, &sd->sd_meta_opt, omi_link)for((omi) = ((&sd->sd_meta_opt)->slh_first); (omi) != ((void *)0); (omi) = ((omi)->omi_link.sle_next))
3456	if (sd->sd_meta_opt_handler == NULL((void *)0) \|\|
3457	sd->sd_meta_opt_handler(sd, omi->omi_som) != 0)
3458	sr_meta_opt_handler(sd, omi->omi_som);
3459
3460	if (sd->sd_assemble) {
3461	if ((i = sd->sd_assemble(sd, bc, no_chunk, data))) {
3462	rv = i;
3463	goto unwind;
3464	}
3465	}
3466
3467	DNPRINTF(SR_D_META, "%s: disk assembled from metadata\n",
3468	DEVNAME(sc));
3469
3470	}
3471
3472	/* Metadata MUST be fully populated by this point. */
3473	TAILQ_INSERT_TAIL(&sc->sc_dis_list, sd, sd_link)do { (sd)->sd_link.tqe_next = ((void )0); (sd)->sd_link .tqe_prev = (&sc->sc_dis_list)->tqh_last; (&sc ->sc_dis_list)->tqh_last = (sd); (&sc->sc_dis_list )->tqh_last = &(sd)->sd_link.tqe_next; } while (0);
3474
3475	/* Allocate all resources. */
3476	if ((rv = sd->sd_alloc_resources(sd)))
3477	goto unwind;
3478
3479	/* Adjust flags if necessary. */
3480	if ((sd->sd_capabilities & SR_CAP_AUTO_ASSEMBLE0x00000002) &&
3481	(bc->bc_flags & BIOC_SCNOAUTOASSEMBLE0x04) !=
3482	(sd->sd_meta->ssdi_sdd_invariant.ssd_vol_flags & BIOC_SCNOAUTOASSEMBLE0x04)) {
3483	sd->sd_meta->ssdi_sdd_invariant.ssd_vol_flags &= ~BIOC_SCNOAUTOASSEMBLE0x04;
3484	sd->sd_meta->ssdi_sdd_invariant.ssd_vol_flags \|=
3485	bc->bc_flags & BIOC_SCNOAUTOASSEMBLE0x04;
3486	}
3487
3488	if (sd->sd_capabilities & SR_CAP_SYSTEM_DISK0x00000001) {
3489	/* Initialise volume state. */
3490	sd->sd_set_vol_state(sd);
3491	if (sd->sd_vol_status == BIOC_SVOFFLINE0x01) {
3492	sr_error(sc, "%s is offline, will not be brought "
3493	"online", sd->sd_meta->ssd_devname);
3494	goto unwind;
3495	}
3496
3497	/* Setup SCSI iopool. */
3498	scsi_iopool_init(&sd->sd_iopool, sd, sr_wu_get, sr_wu_put);
3499
3500	/*
3501	* All checks passed - return ENXIO if volume cannot be created.
3502	*/
3503	rv = ENXIO6;
3504
3505	/*
3506	* Find a free target.
3507	*
3508	* XXX: We reserve sd_target == 0 to indicate the
3509	* discipline is not linked into sc->sc_targets, so begin
3510	* the search with target = 1.
3511	*/
3512	for (target = 1; target < SR_MAX_LD256; target++)
3513	if (sc->sc_targets[target] == NULL((void *)0))
3514	break;
3515	if (target == SR_MAX_LD256) {
3516	sr_error(sc, "no free target for %s",
3517	sd->sd_meta->ssd_devname);
3518	goto unwind;
3519	}
3520
3521	/* Clear sense data. */
3522	bzero(&sd->sd_scsi_sense, sizeof(sd->sd_scsi_sense))__builtin_bzero((&sd->sd_scsi_sense), (sizeof(sd->sd_scsi_sense )));
3523
3524	/* Attach discipline and get midlayer to probe it. */
3525	sd->sd_target = target;
3526	sc->sc_targets[target] = sd;
3527	if (scsi_probe_lun(sc->sc_scsibus, target, 0) != 0) {
3528	sr_error(sc, "scsi_probe_lun failed");
3529	sc->sc_targets[target] = NULL((void *)0);
3530	sd->sd_target = 0;
3531	goto unwind;
3532	}
3533
3534	link = scsi_get_link(sc->sc_scsibus, target, 0);
3535	if (link == NULL((void *)0))
3536	goto unwind;
3537
3538	dev = link->device_softc;
3539	DNPRINTF(SR_D_IOCTL, "%s: sr device added: %s at target %d\n",
3540	DEVNAME(sc), dev->dv_xname, sd->sd_target);
3541
3542	/* XXX - Count volumes, not targets. */
3543	for (i = 0, vol = -1; i <= sd->sd_target; i++)
3544	if (sc->sc_targets[i])
3545	vol++;
3546
3547	rv = 0;
3548
3549	if (sd->sd_meta->ssd_devname[0] != '\0' &&
3550	strncmp(sd->sd_meta->ssd_devname, dev->dv_xname,
3551	sizeof(dev->dv_xname)))
3552	sr_warn(sc, "volume %s is roaming, it used to be %s, "
3553	"updating metadata", dev->dv_xname,
3554	sd->sd_meta->ssd_devname);
3555
3556	/* Populate remaining volume metadata. */
3557	sd->sd_meta->ssdi_sdd_invariant.ssd_volid = vol;
3558	strlcpy(sd->sd_meta->ssd_devname, dev->dv_xname,
3559	sizeof(sd->sd_meta->ssd_devname));
3560
3561	sr_info(sc, "%s volume attached as %s",
3562	sd->sd_name, sd->sd_meta->ssd_devname);
3563
3564	/* Update device name on any roaming chunks. */
3565	sr_roam_chunks(sd);
3566
3567	#ifndef SMALL_KERNEL
3568	if (sr_sensors_create(sd))
3569	sr_warn(sc, "unable to create sensor for %s",
3570	dev->dv_xname);
3571	#endif /* SMALL_KERNEL */
3572	} else {
3573	/* This volume does not attach as a system disk. */
3574	ch_entry = SLIST_FIRST(cl)((cl)->slh_first); /* XXX */
3575	strlcpy(sd->sd_meta->ssd_devname, ch_entry->src_devname,
3576	sizeof(sd->sd_meta->ssd_devname));
3577
3578	if (sd->sd_start_discipline(sd))
3579	goto unwind;
3580	}
3581
3582	/* Save current metadata to disk. */
3583	rv = sr_meta_save(sd, SR_META_DIRTY0x1);
3584
3585	if (sd->sd_vol_status == BIOC_SVREBUILD0x05)
3586	kthread_create_deferred(sr_rebuild_start, sd);
3587
3588	sd->sd_ready = 1;
3589
3590	free(dt, M_DEVBUF2, bc->bc_dev_list_len);
3591
3592	return (rv);
3593
3594	unwind:
3595	free(dt, M_DEVBUF2, bc->bc_dev_list_len);
3596
3597	sr_discipline_shutdown(sd, 0, 0);
3598
3599	if (rv == EAGAIN35)
3600	rv = 0;
3601
3602	return (rv);
3603	}
3604
3605	int
3606	sr_ioctl_deleteraid(struct sr_softc sc, struct sr_discipline sd,
3607	struct bioc_deleteraid *bd)
3608	{
3609	int rv = 1;
3610
3611	DNPRINTF(SR_D_IOCTL, "%s: sr_ioctl_deleteraid %s\n",
3612	DEVNAME(sc), bd->bd_dev);
3613
3614	if (sd == NULL((void )0) && (sd = sr_find_discipline(sc, bd->bd_dev)) == NULL((void )0)) {
3615	sr_error(sc, "volume %s not found", bd->bd_dev);
3616	goto bad;
3617	}
3618
3619	/*
3620	* XXX Better check for mounted file systems and refuse to detach any
3621	* volume that is actively in use.
3622	*/
3623	if (bcmp(&sr_bootuuid, &sd->sd_meta->ssdi_sdd_invariant.ssd_uuid,
3624	sizeof(sr_bootuuid)) == 0) {
3625	sr_error(sc, "refusing to delete boot volume");
3626	goto bad;
3627	}
3628
3629	sd->sd_deleted = 1;
3630	sd->sd_meta->ssdi_sdd_invariant.ssd_vol_flags = BIOC_SCNOAUTOASSEMBLE0x04;
3631	sr_discipline_shutdown(sd, 1, 0);
3632
3633	rv = 0;
3634	bad:
3635	return (rv);
3636	}
3637
3638	int
3639	sr_ioctl_discipline(struct sr_softc sc, struct sr_discipline sd,
3640	struct bioc_discipline *bd)
3641	{
3642	int rv = 1;
3643
3644	/* Dispatch a discipline specific ioctl. */
3645
3646	DNPRINTF(SR_D_IOCTL, "%s: sr_ioctl_discipline %s\n", DEVNAME(sc),
3647	bd->bd_dev);
3648
3649	if (sd == NULL((void )0) && (sd = sr_find_discipline(sc, bd->bd_dev)) == NULL((void )0)) {
3650	sr_error(sc, "volume %s not found", bd->bd_dev);
3651	goto bad;
3652	}
3653
3654	if (sd->sd_ioctl_handler)
3655	rv = sd->sd_ioctl_handler(sd, bd);
3656
3657	bad:
3658	return (rv);
3659	}
3660
3661	int
3662	sr_ioctl_installboot(struct sr_softc sc, struct sr_discipline sd,
3663	struct bioc_installboot *bb)
3664	{
3665	void bootblk = NULL((void )0), bootldr = NULL((void )0);
3666	struct sr_chunk *chunk;
3667	struct sr_meta_opt_item *omi;
3668	struct sr_meta_boot *sbm;
3669	struct disk *dk;
3670	u_int32_t bbs = 0, bls = 0, secsize;
3671	u_char duid[8];
3672	int rv = EINVAL22;
3673	int i;
3674
3675	DNPRINTF(SR_D_IOCTL, "%s: sr_ioctl_installboot %s\n", DEVNAME(sc),
3676	bb->bb_dev);
3677
3678	if (sd == NULL((void )0) && (sd = sr_find_discipline(sc, bb->bb_dev)) == NULL((void )0)) {
3679	sr_error(sc, "volume %s not found", bb->bb_dev);
3680	goto done;
3681	}
3682
3683	TAILQ_FOREACH(dk, &disklist, dk_link)for((dk) = ((&disklist)->tqh_first); (dk) != ((void *) 0); (dk) = ((dk)->dk_link.tqe_next))
3684	if (!strncmp(dk->dk_name, bb->bb_dev, sizeof(bb->bb_dev)))
3685	break;
3686	if (dk == NULL((void )0) \|\| dk->dk_label == NULL((void )0) \|\|
3687	duid_iszero(dk->dk_label->d_uid)) {
3688	sr_error(sc, "failed to get DUID for softraid volume");
3689	goto done;
3690	}
3691	memcpy(duid, dk->dk_label->d_uid, sizeof(duid))__builtin_memcpy((duid), (dk->dk_label->d_uid), (sizeof (duid)));
3692
3693	/* Ensure that boot storage area is large enough. */
3694	if (sd->sd_meta->ssd_data_blkno < (SR_BOOT_OFFSET(16 + 64) + SR_BOOT_SIZE(320 + 128))) {
3695	sr_error(sc, "insufficient boot storage");
3696	goto done;
3697	}
3698
3699	if (bb->bb_bootblk_size > SR_BOOT_BLOCKS_SIZE128 * DEV_BSIZE(1 << 9)) {
3700	sr_error(sc, "boot block too large (%d > %d)",
3701	bb->bb_bootblk_size, SR_BOOT_BLOCKS_SIZE128 * DEV_BSIZE(1 << 9));
3702	goto done;
3703	}
3704
3705	if (bb->bb_bootldr_size > SR_BOOT_LOADER_SIZE320 * DEV_BSIZE(1 << 9)) {
3706	sr_error(sc, "boot loader too large (%d > %d)",
3707	bb->bb_bootldr_size, SR_BOOT_LOADER_SIZE320 * DEV_BSIZE(1 << 9));
3708	goto done;
3709	}
3710
3711	secsize = sd->sd_meta->ssdi_sdd_invariant.ssd_secsize;
3712
3713	/* Copy in boot block. */
3714	bbs = howmany(bb->bb_bootblk_size, secsize)(((bb->bb_bootblk_size) + ((secsize) - 1)) / (secsize)) * secsize;
3715	bootblk = malloc(bbs, M_DEVBUF2, M_WAITOK0x0001 \| M_ZERO0x0008);
3716	if (copyin(bb->bb_bootblk, bootblk, bb->bb_bootblk_size) != 0)
3717	goto done;
3718
3719	/* Copy in boot loader. */
3720	bls = howmany(bb->bb_bootldr_size, secsize)(((bb->bb_bootldr_size) + ((secsize) - 1)) / (secsize)) * secsize;
3721	bootldr = malloc(bls, M_DEVBUF2, M_WAITOK0x0001 \| M_ZERO0x0008);
3722	if (copyin(bb->bb_bootldr, bootldr, bb->bb_bootldr_size) != 0)
3723	goto done;
3724
3725	/* Create or update optional meta for bootable volumes. */
3726	SLIST_FOREACH(omi, &sd->sd_meta_opt, omi_link)for((omi) = ((&sd->sd_meta_opt)->slh_first); (omi) != ((void *)0); (omi) = ((omi)->omi_link.sle_next))
3727	if (omi->omi_som->som_type == SR_OPT_BOOT0x02)
3728	break;
3729	if (omi == NULL((void *)0)) {
3730	omi = malloc(sizeof(struct sr_meta_opt_item), M_DEVBUF2,
3731	M_WAITOK0x0001 \| M_ZERO0x0008);
3732	omi->omi_som = malloc(sizeof(struct sr_meta_boot), M_DEVBUF2,
	Result of 'malloc' is converted to a pointer of type 'struct sr_meta_opt_hdr', which is incompatible with sizeof operand type 'struct sr_meta_boot'
3733	M_WAITOK0x0001 \| M_ZERO0x0008);
3734	omi->omi_som->som_type = SR_OPT_BOOT0x02;
3735	omi->omi_som->som_length = sizeof(struct sr_meta_boot);
3736	SLIST_INSERT_HEAD(&sd->sd_meta_opt, omi, omi_link)do { (omi)->omi_link.sle_next = (&sd->sd_meta_opt)-> slh_first; (&sd->sd_meta_opt)->slh_first = (omi); } while (0);
3737	sd->sd_meta->ssdi_sdd_invariant.ssd_opt_no++;
3738	}
3739	sbm = (struct sr_meta_boot *)omi->omi_som;
3740
3741	memcpy(sbm->sbm_root_duid, duid, sizeof(sbm->sbm_root_duid))__builtin_memcpy((sbm->sbm_root_duid), (duid), (sizeof(sbm ->sbm_root_duid)));
3742	bzero(&sbm->sbm_boot_duid, sizeof(sbm->sbm_boot_duid))__builtin_bzero((&sbm->sbm_boot_duid), (sizeof(sbm-> sbm_boot_duid)));
3743	sbm->sbm_bootblk_size = bbs;
3744	sbm->sbm_bootldr_size = bls;
3745
3746	DNPRINTF(SR_D_IOCTL, "sr_ioctl_installboot: root duid is %s\n",
3747	duid_format(sbm->sbm_root_duid));
3748
3749	/* Save boot block and boot loader to each chunk. */
3750	for (i = 0; i < sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no; i++) {
3751
3752	chunk = sd->sd_vol.sv_chunks[i];
3753	if (chunk->src_meta.scm_status != BIOC_SDONLINE0x00 &&
3754	chunk->src_meta.scm_status != BIOC_SDREBUILD0x03)
3755	continue;
3756
3757	if (i < SR_MAX_BOOT_DISKS16)
3758	memcpy(&sbm->sbm_boot_duid[i], chunk->src_duid,__builtin_memcpy((&sbm->sbm_boot_duid[i]), (chunk-> src_duid), (sizeof(sbm->sbm_boot_duid[i])))
3759	sizeof(sbm->sbm_boot_duid[i]))__builtin_memcpy((&sbm->sbm_boot_duid[i]), (chunk-> src_duid), (sizeof(sbm->sbm_boot_duid[i])));
3760
3761	/* Save boot blocks. */
3762	DNPRINTF(SR_D_IOCTL,
3763	"sr_ioctl_installboot: saving boot block to %s "
3764	"(%u bytes)\n", chunk->src_devname, bbs);
3765
3766	if (sr_rw(sc, chunk->src_dev_mm, bootblk, bbs,
3767	SR_BOOT_BLOCKS_OFFSET((16 + 64) + 320), B_WRITE0x00000000)) {
3768	sr_error(sc, "failed to write boot block");
3769	goto done;
3770	}
3771
3772	/* Save boot loader.*/
3773	DNPRINTF(SR_D_IOCTL,
3774	"sr_ioctl_installboot: saving boot loader to %s "
3775	"(%u bytes)\n", chunk->src_devname, bls);
3776
3777	if (sr_rw(sc, chunk->src_dev_mm, bootldr, bls,
3778	SR_BOOT_LOADER_OFFSET(16 + 64), B_WRITE0x00000000)) {
3779	sr_error(sc, "failed to write boot loader");
3780	goto done;
3781	}
3782	}
3783
3784	/* XXX - Install boot block on disk - MD code. */
3785
3786	/* Mark volume as bootable and save metadata. */
3787	sd->sd_meta->ssdi_sdd_invariant.ssd_vol_flags \|= BIOC_SCBOOTABLE0x08;
3788	if (sr_meta_save(sd, SR_META_DIRTY0x1)) {
3789	sr_error(sc, "could not save metadata to %s", DEVNAME(sc)((sc)->sc_dev.dv_xname));
3790	goto done;
3791	}
3792
3793	rv = 0;
3794
3795	done:
3796	free(bootblk, M_DEVBUF2, bbs);
3797	free(bootldr, M_DEVBUF2, bls);
3798
3799	return (rv);
3800	}
3801
3802	void
3803	sr_chunks_unwind(struct sr_softc sc, struct sr_chunk_head cl)
3804	{
3805	struct sr_chunk ch_entry, ch_next;
3806
3807	DNPRINTF(SR_D_IOCTL, "%s: sr_chunks_unwind\n", DEVNAME(sc));
3808
3809	if (!cl)
3810	return;
3811
3812	for (ch_entry = SLIST_FIRST(cl)((cl)->slh_first); ch_entry != NULL((void *)0); ch_entry = ch_next) {
3813	ch_next = SLIST_NEXT(ch_entry, src_link)((ch_entry)->src_link.sle_next);
3814
3815	DNPRINTF(SR_D_IOCTL, "%s: sr_chunks_unwind closing: %s\n",
3816	DEVNAME(sc), ch_entry->src_devname);
3817	if (ch_entry->src_vn) {
3818	/*
3819	* XXX - explicitly lock the vnode until we can resolve
3820	* the problem introduced by vnode aliasing... specfs
3821	* has no locking, whereas ufs/ffs does!
3822	*/
3823	vn_lock(ch_entry->src_vn, LK_EXCLUSIVE0x0001UL \| LK_RETRY0x2000UL);
3824	VOP_CLOSE(ch_entry->src_vn, FREAD0x0001 \| FWRITE0x0002, NOCRED((struct ucred *)-1),
3825	curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc);
3826	vput(ch_entry->src_vn);
3827	}
3828	free(ch_entry, M_DEVBUF2, sizeof(*ch_entry));
3829	}
3830	SLIST_INIT(cl){ ((cl)->slh_first) = ((void *)0); };
3831	}
3832
3833	void
3834	sr_discipline_free(struct sr_discipline *sd)
3835	{
3836	struct sr_softc *sc;
3837	struct sr_discipline *sdtmp1;
3838	struct sr_meta_opt_head *som;
3839	struct sr_meta_opt_item omi, omi_next;
3840
3841	if (!sd)
3842	return;
3843
3844	sc = sd->sd_sc;
3845
3846	DNPRINTF(SR_D_DIS, "%s: sr_discipline_free %s\n",
3847	DEVNAME(sc),
3848	sd->sd_meta ? sd->sd_meta->ssd_devname : "nodev");
3849	if (sd->sd_free_resources)
3850	sd->sd_free_resources(sd);
3851	free(sd->sd_vol.sv_chunks, M_DEVBUF2, 0);
3852	free(sd->sd_meta, M_DEVBUF2, SR_META_SIZE64 * DEV_BSIZE(1 << 9));
3853	free(sd->sd_meta_foreign, M_DEVBUF2, smd[sd->sd_meta_type].smd_size);
3854
3855	som = &sd->sd_meta_opt;
3856	for (omi = SLIST_FIRST(som)((som)->slh_first); omi != NULL((void *)0); omi = omi_next) {
3857	omi_next = SLIST_NEXT(omi, omi_link)((omi)->omi_link.sle_next);
3858	free(omi->omi_som, M_DEVBUF2, 0);
3859	free(omi, M_DEVBUF2, sizeof(*omi));
3860	}
3861
3862	if (sd->sd_target != 0) {
3863	KASSERT(sc->sc_targets[sd->sd_target] == sd)((sc->sc_targets[sd->sd_target] == sd) ? (void)0 : __assert ("diagnostic ", "/usr/src/sys/dev/softraid.c", 3863, "sc->sc_targets[sd->sd_target] == sd" ));
3864	sc->sc_targets[sd->sd_target] = NULL((void *)0);
3865	}
3866
3867	TAILQ_FOREACH(sdtmp1, &sc->sc_dis_list, sd_link)for((sdtmp1) = ((&sc->sc_dis_list)->tqh_first); (sdtmp1 ) != ((void *)0); (sdtmp1) = ((sdtmp1)->sd_link.tqe_next)) {
3868	if (sdtmp1 == sd)
3869	break;
3870	}
3871	if (sdtmp1 != NULL((void *)0))
3872	TAILQ_REMOVE(&sc->sc_dis_list, sd, sd_link)do { if (((sd)->sd_link.tqe_next) != ((void )0)) (sd)-> sd_link.tqe_next->sd_link.tqe_prev = (sd)->sd_link.tqe_prev ; else (&sc->sc_dis_list)->tqh_last = (sd)->sd_link .tqe_prev; (sd)->sd_link.tqe_prev = (sd)->sd_link.tqe_next ; ((sd)->sd_link.tqe_prev) = ((void )-1); ((sd)->sd_link .tqe_next) = ((void )-1); } while (0);
3873
3874	explicit_bzero(sd, sizeof *sd);
3875	free(sd, M_DEVBUF2, sizeof(*sd));
3876	}
3877
3878	void
3879	sr_discipline_shutdown(struct sr_discipline *sd, int meta_save, int dying)
3880	{
3881	struct sr_softc *sc;
3882	int ret, s;
3883
3884	if (!sd)
3885	return;
3886	sc = sd->sd_sc;
3887
3888	DNPRINTF(SR_D_DIS, "%s: sr_discipline_shutdown %s\n", DEVNAME(sc),
3889	sd->sd_meta ? sd->sd_meta->ssd_devname : "nodev");
3890
3891	/* If rebuilding, abort rebuild and drain I/O. */
3892	if (sd->sd_reb_active) {
3893	sd->sd_reb_abort = 1;
3894	while (sd->sd_reb_active)
3895	tsleep_nsec(sd, PWAIT32, "sr_shutdown", MSEC_TO_NSEC(1));
3896	}
3897
3898	if (meta_save)
3899	sr_meta_save(sd, 0);
3900
3901	s = splbio()splraise(0x3);
3902
3903	sd->sd_ready = 0;
3904
3905	/* make sure there isn't a sync pending and yield */
3906	wakeup(sd);
3907	while (sd->sd_sync \|\| sd->sd_must_flush) {
3908	ret = tsleep_nsec(&sd->sd_sync, MAXPRI127, "sr_down",
3909	SEC_TO_NSEC(60));
3910	if (ret == EWOULDBLOCK35)
3911	break;
3912	}
3913	if (dying == -1) {
3914	sd->sd_ready = 1;
3915	splx(s)spllower(s);
3916	return;
3917	}
3918
3919	#ifndef SMALL_KERNEL
3920	sr_sensors_delete(sd);
3921	#endif /* SMALL_KERNEL */
3922
3923	if (sd->sd_target != 0)
3924	scsi_detach_lun(sc->sc_scsibus, sd->sd_target, 0,
3925	dying ? 0 : DETACH_FORCE0x01);
3926
3927	sr_chunks_unwind(sc, &sd->sd_vol.sv_chunk_list);
3928
3929	if (sd->sd_taskq)
3930	taskq_destroy(sd->sd_taskq);
3931
3932	sr_discipline_free(sd);
3933
3934	splx(s)spllower(s);
3935	}
3936
3937	int
3938	sr_discipline_init(struct sr_discipline *sd, int level)
3939	{
3940	int rv = 1;
3941
3942	/* Initialise discipline function pointers with defaults. */
3943	sd->sd_alloc_resources = sr_alloc_resources;
3944	sd->sd_assemble = NULL((void *)0);
3945	sd->sd_create = NULL((void *)0);
3946	sd->sd_free_resources = sr_free_resources;
3947	sd->sd_ioctl_handler = NULL((void *)0);
3948	sd->sd_openings = NULL((void *)0);
3949	sd->sd_meta_opt_handler = NULL((void *)0);
3950	sd->sd_rebuild = sr_rebuild;
3951	sd->sd_scsi_inquiry = sr_raid_inquiry;
3952	sd->sd_scsi_read_cap = sr_raid_read_cap;
3953	sd->sd_scsi_tur = sr_raid_tur;
3954	sd->sd_scsi_req_sense = sr_raid_request_sense;
3955	sd->sd_scsi_start_stop = sr_raid_start_stop;
3956	sd->sd_scsi_sync = sr_raid_sync;
3957	sd->sd_scsi_rw = NULL((void *)0);
3958	sd->sd_scsi_intr = sr_raid_intr;
3959	sd->sd_scsi_wu_done = NULL((void *)0);
3960	sd->sd_scsi_done = NULL((void *)0);
3961	sd->sd_set_chunk_state = sr_set_chunk_state;
3962	sd->sd_set_vol_state = sr_set_vol_state;
3963	sd->sd_start_discipline = NULL((void *)0);
3964
3965	task_set(&sd->sd_meta_save_task, sr_meta_save_callback, sd);
3966	task_set(&sd->sd_hotspare_rebuild_task, sr_hotspare_rebuild_callback,
3967	sd);
3968
3969	sd->sd_wu_size = sizeof(struct sr_workunit);
3970	switch (level) {
3971	case 0:
3972	sr_raid0_discipline_init(sd);
3973	break;
3974	case 1:
3975	sr_raid1_discipline_init(sd);
3976	break;
3977	case 5:
3978	sr_raid5_discipline_init(sd);
3979	break;
3980	case 6:
3981	sr_raid6_discipline_init(sd);
3982	break;
3983	#ifdef CRYPTO1
3984	case 'C':
3985	sr_crypto_discipline_init(sd);
3986	break;
3987	case 0x1C:
3988	sr_raid1c_discipline_init(sd);
3989	break;
3990	#endif
3991	case 'c':
3992	sr_concat_discipline_init(sd);
3993	break;
3994	default:
3995	goto bad;
3996	}
3997
3998	rv = 0;
3999	bad:
4000	return (rv);
4001	}
4002
4003	int
4004	sr_raid_inquiry(struct sr_workunit *wu)
4005	{
4006	struct sr_discipline *sd = wu->swu_dis;
4007	struct scsi_xfer *xs = wu->swu_xs;
4008	struct scsi_inquiry cdb = (struct scsi_inquiry )&xs->cmd;
4009	struct scsi_inquiry_data inq;
4010
4011	DNPRINTF(SR_D_DIS, "%s: sr_raid_inquiry\n", DEVNAME(sd->sd_sc));
4012
4013	if (xs->cmdlen != sizeof(*cdb))
4014	return (EINVAL22);
4015
4016	if (ISSET(cdb->flags, SI_EVPD)((cdb->flags) & (0x01)))
4017	return (EOPNOTSUPP45);
4018
4019	bzero(&inq, sizeof(inq))__builtin_bzero((&inq), (sizeof(inq)));
4020	inq.device = T_DIRECT0x00;
4021	inq.dev_qual2 = 0;
4022	inq.version = SCSI_REV_20x02;
4023	inq.response_format = SID_SCSI2_RESPONSE0x02;
4024	inq.additional_length = SID_SCSI2_ALEN31;
4025	inq.flags \|= SID_CmdQue0x02;
4026	strlcpy(inq.vendor, sd->sd_meta->ssdi_sdd_invariant.ssd_vendor,
4027	sizeof(inq.vendor));
4028	strlcpy(inq.product, sd->sd_meta->ssdi_sdd_invariant.ssd_product,
4029	sizeof(inq.product));
4030	strlcpy(inq.revision, sd->sd_meta->ssdi_sdd_invariant.ssd_revision,
4031	sizeof(inq.revision));
4032	scsi_copy_internal_data(xs, &inq, sizeof(inq));
4033
4034	return (0);
4035	}
4036
4037	int
4038	sr_raid_read_cap(struct sr_workunit *wu)
4039	{
4040	struct sr_discipline *sd = wu->swu_dis;
4041	struct scsi_xfer *xs = wu->swu_xs;
4042	struct scsi_read_cap_data rcd;
4043	struct scsi_read_cap_data_16 rcd16;
4044	u_int64_t addr;
4045	int rv = 1;
4046	u_int32_t secsize;
4047
4048	DNPRINTF(SR_D_DIS, "%s: sr_raid_read_cap\n", DEVNAME(sd->sd_sc));
4049
4050	secsize = sd->sd_meta->ssdi_sdd_invariant.ssd_secsize;
4051
4052	addr = ((sd->sd_meta->ssdi_sdd_invariant.ssd_size * DEV_BSIZE(1 << 9)) / secsize) - 1;
4053	if (xs->cmd.opcode == READ_CAPACITY0x25) {
4054	bzero(&rcd, sizeof(rcd))__builtin_bzero((&rcd), (sizeof(rcd)));
4055	if (addr > 0xffffffffllu)
4056	_lto4b(0xffffffff, rcd.addr);
4057	else
4058	_lto4b(addr, rcd.addr);
4059	_lto4b(secsize, rcd.length);
4060	scsi_copy_internal_data(xs, &rcd, sizeof(rcd));
4061	rv = 0;
4062	} else if (xs->cmd.opcode == READ_CAPACITY_160x9e) {
4063	bzero(&rcd16, sizeof(rcd16))__builtin_bzero((&rcd16), (sizeof(rcd16)));
4064	_lto8b(addr, rcd16.addr);
4065	_lto4b(secsize, rcd16.length);
4066	scsi_copy_internal_data(xs, &rcd16, sizeof(rcd16));
4067	rv = 0;
4068	}
4069
4070	return (rv);
4071	}
4072
4073	int
4074	sr_raid_tur(struct sr_workunit *wu)
4075	{
4076	struct sr_discipline *sd = wu->swu_dis;
4077
4078	DNPRINTF(SR_D_DIS, "%s: sr_raid_tur\n", DEVNAME(sd->sd_sc));
4079
4080	if (sd->sd_vol_status == BIOC_SVOFFLINE0x01) {
4081	sd->sd_scsi_sense.error_code = SSD_ERRCODE_CURRENT0x70;
4082	sd->sd_scsi_sense.flags = SKEY_NOT_READY0x02;
4083	sd->sd_scsi_sense.add_sense_code = 0x04;
4084	sd->sd_scsi_sense.add_sense_code_qual = 0x11;
4085	sd->sd_scsi_sense.extra_len = 4;
4086	return (1);
4087	} else if (sd->sd_vol_status == BIOC_SVINVALID0xff) {
4088	sd->sd_scsi_sense.error_code = SSD_ERRCODE_CURRENT0x70;
4089	sd->sd_scsi_sense.flags = SKEY_HARDWARE_ERROR0x04;
4090	sd->sd_scsi_sense.add_sense_code = 0x05;
4091	sd->sd_scsi_sense.add_sense_code_qual = 0x00;
4092	sd->sd_scsi_sense.extra_len = 4;
4093	return (1);
4094	}
4095
4096	return (0);
4097	}
4098
4099	int
4100	sr_raid_request_sense(struct sr_workunit *wu)
4101	{
4102	struct sr_discipline *sd = wu->swu_dis;
4103	struct scsi_xfer *xs = wu->swu_xs;
4104
4105	DNPRINTF(SR_D_DIS, "%s: sr_raid_request_sense\n",
4106	DEVNAME(sd->sd_sc));
4107
4108	/* use latest sense data */
4109	memcpy(&xs->sense, &sd->sd_scsi_sense, sizeof(xs->sense))__builtin_memcpy((&xs->sense), (&sd->sd_scsi_sense ), (sizeof(xs->sense)));
4110
4111	/* clear sense data */
4112	bzero(&sd->sd_scsi_sense, sizeof(sd->sd_scsi_sense))__builtin_bzero((&sd->sd_scsi_sense), (sizeof(sd->sd_scsi_sense )));
4113
4114	return (0);
4115	}
4116
4117	int
4118	sr_raid_start_stop(struct sr_workunit *wu)
4119	{
4120	struct scsi_xfer *xs = wu->swu_xs;
4121	struct scsi_start_stop ss = (struct scsi_start_stop )&xs->cmd;
4122
4123	DNPRINTF(SR_D_DIS, "%s: sr_raid_start_stop\n",
4124	DEVNAME(wu->swu_dis->sd_sc));
4125
4126	if (!ss)
4127	return (1);
4128
4129	/*
4130	* do nothing!
4131	* a softraid discipline should always reflect correct status
4132	*/
4133	return (0);
4134	}
4135
4136	int
4137	sr_raid_sync(struct sr_workunit *wu)
4138	{
4139	struct sr_discipline *sd = wu->swu_dis;
4140	int s, ret, rv = 0, ios;
4141
4142	DNPRINTF(SR_D_DIS, "%s: sr_raid_sync\n", DEVNAME(sd->sd_sc));
4143
4144	/* when doing a fake sync don't count the wu */
4145	ios = (wu->swu_flags & SR_WUF_FAKE(1<<6)) ? 0 : 1;
4146
4147	s = splbio()splraise(0x3);
4148	sd->sd_sync = 1;
4149	while (sd->sd_wu_pending > ios) {
4150	ret = tsleep_nsec(sd, PRIBIO16, "sr_sync", SEC_TO_NSEC(15));
4151	if (ret == EWOULDBLOCK35) {
4152	DNPRINTF(SR_D_DIS, "%s: sr_raid_sync timeout\n",
4153	DEVNAME(sd->sd_sc));
4154	rv = 1;
4155	break;
4156	}
4157	}
4158	sd->sd_sync = 0;
4159	splx(s)spllower(s);
4160
4161	wakeup(&sd->sd_sync);
4162
4163	return (rv);
4164	}
4165
4166	void
4167	sr_raid_intr(struct buf *bp)
4168	{
4169	struct sr_ccb ccb = (struct sr_ccb )bp;
4170	struct sr_workunit *wu = ccb->ccb_wu;
4171	#ifdef SR_DEBUG
4172	struct sr_discipline *sd = wu->swu_dis;
4173	struct scsi_xfer *xs = wu->swu_xs;
4174	#endif
4175	int s;
4176
4177	DNPRINTF(SR_D_INTR, "%s: %s %s intr bp %p xs %p\n",
4178	DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname, sd->sd_name, bp, xs);
4179
4180	s = splbio()splraise(0x3);
4181	sr_ccb_done(ccb);
4182	sr_wu_done(wu);
4183	splx(s)spllower(s);
4184	}
4185
4186	void
4187	sr_schedule_wu(struct sr_workunit *wu)
4188	{
4189	struct sr_discipline *sd = wu->swu_dis;
4190	struct sr_workunit *wup;
4191	int s;
4192
4193	DNPRINTF(SR_D_WU, "sr_schedule_wu: schedule wu %p state %i "
4194	"flags 0x%x\n", wu, wu->swu_state, wu->swu_flags);
4195
4196	KASSERT(wu->swu_io_count > 0)((wu->swu_io_count > 0) ? (void)0 : __assert("diagnostic " , "/usr/src/sys/dev/softraid.c", 4196, "wu->swu_io_count > 0" ));
4197
4198	s = splbio()splraise(0x3);
4199
4200	/* Construct the work unit, do not schedule it. */
4201	if (wu->swu_state == SR_WU_CONSTRUCT9)
4202	goto queued;
4203
4204	/* Deferred work unit being reconstructed, do not start. */
4205	if (wu->swu_state == SR_WU_REQUEUE8)
4206	goto queued;
4207
4208	/* Current work unit failed, restart. */
4209	if (wu->swu_state == SR_WU_RESTART7)
4210	goto start;
4211
4212	if (wu->swu_state != SR_WU_INPROGRESS1)
4213	panic("sr_schedule_wu: work unit not in progress (state %i)",
4214	wu->swu_state);
4215
4216	/* Walk queue backwards and fill in collider if we have one. */
4217	TAILQ_FOREACH_REVERSE(wup, &sd->sd_wu_pendq, sr_wu_list, swu_link)for((wup) = ((((struct sr_wu_list )((&sd->sd_wu_pendq )->tqh_last))->tqh_last)); (wup) != ((void )0); (wup) = ((((struct sr_wu_list *)((wup)->swu_link.tqe_prev))-> tqh_last))) {
4218	if (wu->swu_blk_end < wup->swu_blk_start \|\|
4219	wup->swu_blk_end < wu->swu_blk_start)
4220	continue;
4221
4222	/* Defer work unit due to LBA collision. */
4223	DNPRINTF(SR_D_WU, "sr_schedule_wu: deferring work unit %p\n",
4224	wu);
4225	wu->swu_state = SR_WU_DEFERRED5;
4226	while (wup->swu_collider)
4227	wup = wup->swu_collider;
4228	wup->swu_collider = wu;
4229	TAILQ_INSERT_TAIL(&sd->sd_wu_defq, wu, swu_link)do { (wu)->swu_link.tqe_next = ((void )0); (wu)->swu_link .tqe_prev = (&sd->sd_wu_defq)->tqh_last; (&sd-> sd_wu_defq)->tqh_last = (wu); (&sd->sd_wu_defq)-> tqh_last = &(wu)->swu_link.tqe_next; } while (0);
4230	sd->sd_wu_collisions++;
4231	goto queued;
4232	}
4233
4234	start:
4235	sr_raid_startwu(wu);
4236
4237	queued:
4238	splx(s)spllower(s);
4239	}
4240
4241	void
4242	sr_raid_startwu(struct sr_workunit *wu)
4243	{
4244	struct sr_discipline *sd = wu->swu_dis;
4245	struct sr_ccb *ccb;
4246
4247	DNPRINTF(SR_D_WU, "sr_raid_startwu: start wu %p\n", wu);
4248
4249	splassert(IPL_BIO)do { if (splassert_ctl > 0) { splassert_check(0x3, __func__ ); } } while (0);
4250
4251	if (wu->swu_state == SR_WU_DEFERRED5) {
4252	TAILQ_REMOVE(&sd->sd_wu_defq, wu, swu_link)do { if (((wu)->swu_link.tqe_next) != ((void )0)) (wu)-> swu_link.tqe_next->swu_link.tqe_prev = (wu)->swu_link.tqe_prev ; else (&sd->sd_wu_defq)->tqh_last = (wu)->swu_link .tqe_prev; (wu)->swu_link.tqe_prev = (wu)->swu_link.tqe_next ; ((wu)->swu_link.tqe_prev) = ((void )-1); ((wu)->swu_link .tqe_next) = ((void )-1); } while (0);
4253	wu->swu_state = SR_WU_INPROGRESS1;
4254	}
4255
4256	if (wu->swu_state != SR_WU_RESTART7)
4257	TAILQ_INSERT_TAIL(&sd->sd_wu_pendq, wu, swu_link)do { (wu)->swu_link.tqe_next = ((void )0); (wu)->swu_link .tqe_prev = (&sd->sd_wu_pendq)->tqh_last; (&sd ->sd_wu_pendq)->tqh_last = (wu); (&sd->sd_wu_pendq )->tqh_last = &(wu)->swu_link.tqe_next; } while (0);
4258
4259	/* Start all of the individual I/Os. */
4260	if (wu->swu_cb_active == 1)
4261	panic("%s: sr_startwu_callback", DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname));
4262	wu->swu_cb_active = 1;
4263
4264	TAILQ_FOREACH(ccb, &wu->swu_ccb, ccb_link)for((ccb) = ((&wu->swu_ccb)->tqh_first); (ccb) != ( (void *)0); (ccb) = ((ccb)->ccb_link.tqe_next))
4265	VOP_STRATEGY(ccb->ccb_buf.b_vp, &ccb->ccb_buf);
4266
4267	wu->swu_cb_active = 0;
4268	}
4269
4270	void
4271	sr_raid_recreate_wu(struct sr_workunit *wu)
4272	{
4273	struct sr_discipline *sd = wu->swu_dis;
4274	struct sr_workunit *wup = wu;
4275
4276	/*
4277	* Recreate a work unit by releasing the associated CCBs and reissuing
4278	* the SCSI I/O request. This process is then repeated for all of the
4279	* colliding work units.
4280	*/
4281	do {
4282	sr_wu_release_ccbs(wup);
4283
4284	wup->swu_state = SR_WU_REQUEUE8;
4285	if (sd->sd_scsi_rw(wup))
4286	panic("could not requeue I/O");
4287
4288	wup = wup->swu_collider;
4289	} while (wup);
4290	}
4291
4292	int
4293	sr_alloc_resources(struct sr_discipline *sd)
4294	{
4295	if (sr_wu_alloc(sd)) {
4296	sr_error(sd->sd_sc, "unable to allocate work units");
4297	return (ENOMEM12);
4298	}
4299	if (sr_ccb_alloc(sd)) {
4300	sr_error(sd->sd_sc, "unable to allocate ccbs");
4301	return (ENOMEM12);
4302	}
4303
4304	return (0);
4305	}
4306
4307	void
4308	sr_free_resources(struct sr_discipline *sd)
4309	{
4310	sr_wu_free(sd);
4311	sr_ccb_free(sd);
4312	}
4313
4314	void
4315	sr_set_chunk_state(struct sr_discipline *sd, int c, int new_state)
4316	{
4317	int old_state, s;
4318
4319	DNPRINTF(SR_D_STATE, "%s: %s: %s: sr_set_chunk_state %d -> %d\n",
4320	DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname,
4321	sd->sd_vol.sv_chunks[c]->src_meta.scmi.scm_devname, c, new_state);
4322
4323	/* ok to go to splbio since this only happens in error path */
4324	s = splbio()splraise(0x3);
4325	old_state = sd->sd_vol.sv_chunks[c]->src_meta.scm_status;
4326
4327	/* multiple IOs to the same chunk that fail will come through here */
4328	if (old_state == new_state)
4329	goto done;
4330
4331	switch (old_state) {
4332	case BIOC_SDONLINE0x00:
4333	if (new_state == BIOC_SDOFFLINE0x01)
4334	break;
4335	else
4336	goto die;
4337	break;
4338
4339	case BIOC_SDOFFLINE0x01:
4340	goto die;
4341
4342	default:
4343	die:
4344	splx(s)spllower(s); /* XXX */
4345	panic("%s: %s: %s: invalid chunk state transition %d -> %d",
4346	DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname),
4347	sd->sd_meta->ssd_devname,
4348	sd->sd_vol.sv_chunks[c]->src_meta.scmi_scm_invariant.scm_devname,
4349	old_state, new_state);
4350	/* NOTREACHED */
4351	}
4352
4353	sd->sd_vol.sv_chunks[c]->src_meta.scm_status = new_state;
4354	sd->sd_set_vol_state(sd);
4355
4356	sd->sd_must_flush = 1;
4357	task_add(systq, &sd->sd_meta_save_task);
4358	done:
4359	splx(s)spllower(s);
4360	}
4361
4362	void
4363	sr_set_vol_state(struct sr_discipline *sd)
4364	{
4365	int states[SR_MAX_STATES7];
4366	int new_state, i, nd;
4367	int old_state = sd->sd_vol_status;
4368	u_int32_t s;
4369
4370	DNPRINTF(SR_D_STATE, "%s: %s: sr_set_vol_state\n",
4371	DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname);
4372
4373	nd = sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no;
4374
4375	for (i = 0; i < SR_MAX_STATES7; i++)
4376	states[i] = 0;
4377
4378	for (i = 0; i < nd; i++) {
4379	s = sd->sd_vol.sv_chunks[i]->src_meta.scm_status;
4380	if (s >= SR_MAX_STATES7)
4381	panic("%s: %s: %s: invalid chunk state",
4382	DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname),
4383	sd->sd_meta->ssd_devname,
4384	sd->sd_vol.sv_chunks[i]->src_meta.scmi_scm_invariant.scm_devname);
4385	states[s]++;
4386	}
4387
4388	if (states[BIOC_SDONLINE0x00] == nd)
4389	new_state = BIOC_SVONLINE0x00;
4390	else
4391	new_state = BIOC_SVOFFLINE0x01;
4392
4393	DNPRINTF(SR_D_STATE, "%s: %s: sr_set_vol_state %d -> %d\n",
4394	DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname,
4395	old_state, new_state);
4396
4397	switch (old_state) {
4398	case BIOC_SVONLINE0x00:
4399	if (new_state == BIOC_SVOFFLINE0x01 \|\| new_state == BIOC_SVONLINE0x00)
4400	break;
4401	else
4402	goto die;
4403	break;
4404
4405	case BIOC_SVOFFLINE0x01:
4406	/* XXX this might be a little too much */
4407	goto die;
4408
4409	default:
4410	die:
4411	panic("%s: %s: invalid volume state transition %d -> %d",
4412	DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname),
4413	sd->sd_meta->ssd_devname,
4414	old_state, new_state);
4415	/* NOTREACHED */
4416	}
4417
4418	sd->sd_vol_status = new_state;
4419	}
4420
4421	void *
4422	sr_block_get(struct sr_discipline *sd, long length)
4423	{
4424	return dma_alloc(length, PR_NOWAIT0x0002 \| PR_ZERO0x0008);
4425	}
4426
4427	void
4428	sr_block_put(struct sr_discipline sd, void ptr, int length)
4429	{
4430	dma_free(ptr, length);
4431	}
4432
4433	void
4434	sr_checksum_print(u_int8_t *md5)
4435	{
4436	int i;
4437
4438	for (i = 0; i < MD5_DIGEST_LENGTH16; i++)
4439	printf("%02x", md5[i]);
4440	}
4441
4442	void
4443	sr_checksum(struct sr_softc sc, void src, void *md5, u_int32_t len)
4444	{
4445	MD5_CTX ctx;
4446
4447	DNPRINTF(SR_D_MISC, "%s: sr_checksum(%p %p %d)\n", DEVNAME(sc), src,
4448	md5, len);
4449
4450	MD5Init(&ctx);
4451	MD5Update(&ctx, src, len);
4452	MD5Final(md5, &ctx);
4453	}
4454
4455	void
4456	sr_uuid_generate(struct sr_uuid *uuid)
4457	{
4458	arc4random_buf(uuid->sui_id, sizeof(uuid->sui_id));
4459	/* UUID version 4: random */
4460	uuid->sui_id[6] &= 0x0f;
4461	uuid->sui_id[6] \|= 0x40;
4462	/* RFC4122 variant */
4463	uuid->sui_id[8] &= 0x3f;
4464	uuid->sui_id[8] \|= 0x80;
4465	}
4466
4467	char *
4468	sr_uuid_format(struct sr_uuid *uuid)
4469	{
4470	char *uuidstr;
4471
4472	uuidstr = malloc(37, M_DEVBUF2, M_WAITOK0x0001);
4473
4474	snprintf(uuidstr, 37,
4475	"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-"
4476	"%02x%02x%02x%02x%02x%02x",
4477	uuid->sui_id[0], uuid->sui_id[1],
4478	uuid->sui_id[2], uuid->sui_id[3],
4479	uuid->sui_id[4], uuid->sui_id[5],
4480	uuid->sui_id[6], uuid->sui_id[7],
4481	uuid->sui_id[8], uuid->sui_id[9],
4482	uuid->sui_id[10], uuid->sui_id[11],
4483	uuid->sui_id[12], uuid->sui_id[13],
4484	uuid->sui_id[14], uuid->sui_id[15]);
4485
4486	return uuidstr;
4487	}
4488
4489	void
4490	sr_uuid_print(struct sr_uuid *uuid, int cr)
4491	{
4492	char *uuidstr;
4493
4494	uuidstr = sr_uuid_format(uuid);
4495	printf("%s%s", uuidstr, (cr ? "\n" : ""));
4496	free(uuidstr, M_DEVBUF2, 37);
4497	}
4498
4499	int
4500	sr_already_assembled(struct sr_discipline *sd)
4501	{
4502	struct sr_softc *sc = sd->sd_sc;
4503	struct sr_discipline *sdtmp;
4504
4505	TAILQ_FOREACH(sdtmp, &sc->sc_dis_list, sd_link)for((sdtmp) = ((&sc->sc_dis_list)->tqh_first); (sdtmp ) != ((void *)0); (sdtmp) = ((sdtmp)->sd_link.tqe_next)) {
4506	if (!bcmp(&sd->sd_meta->ssdi_sdd_invariant.ssd_uuid,
4507	&sdtmp->sd_meta->ssdi_sdd_invariant.ssd_uuid,
4508	sizeof(sd->sd_meta->ssdi_sdd_invariant.ssd_uuid)))
4509	return (1);
4510	}
4511
4512	return (0);
4513	}
4514
4515	int32_t
4516	sr_validate_stripsize(u_int32_t b)
4517	{
4518	int s = 0;
4519
4520	if (b % DEV_BSIZE(1 << 9))
4521	return (-1);
4522
4523	while ((b & 1) == 0) {
4524	b >>= 1;
4525	s++;
4526	}
4527
4528	/* only multiple of twos */
4529	b >>= 1;
4530	if (b)
4531	return(-1);
4532
4533	return (s);
4534	}
4535
4536	void
4537	sr_quiesce(void)
4538	{
4539	struct sr_softc *sc = softraid0;
4540	struct sr_discipline sd, nsd;
4541
4542	if (sc == NULL((void *)0))
4543	return;
4544
4545	/* Shutdown disciplines in reverse attach order. */
4546	TAILQ_FOREACH_REVERSE_SAFE(sd, &sc->sc_dis_list,for ((sd) = ((((struct sr_discipline_list )((&sc->sc_dis_list )->tqh_last))->tqh_last)); (sd) != ((void )0) && ((nsd) = ((((struct sr_discipline_list *)((sd)->sd_link. tqe_prev))->tqh_last)), 1); (sd) = (nsd))
4547	sr_discipline_list, sd_link, nsd)for ((sd) = ((((struct sr_discipline_list )((&sc->sc_dis_list )->tqh_last))->tqh_last)); (sd) != ((void )0) && ((nsd) = ((((struct sr_discipline_list *)((sd)->sd_link. tqe_prev))->tqh_last)), 1); (sd) = (nsd))
4548	sr_discipline_shutdown(sd, 1, -1);
4549	}
4550
4551	void
4552	sr_shutdown(int dying)
4553	{
4554	struct sr_softc *sc = softraid0;
4555	struct sr_discipline *sd;
4556
4557	if (sc == NULL((void *)0))
4558	return;
4559
4560	DNPRINTF(SR_D_MISC, "%s: sr_shutdown\n", DEVNAME(sc));
4561
4562	/*
4563	* Since softraid is not under mainbus, we have to explicitly
4564	* notify its children that the power is going down, so they
4565	* can execute their shutdown hooks.
4566	*/
4567	config_suspend((struct device *)sc, DVACT_POWERDOWN6);
4568
4569	/* Shutdown disciplines in reverse attach order. */
4570	while ((sd = TAILQ_LAST(&sc->sc_dis_list, sr_discipline_list)((((struct sr_discipline_list )((&sc->sc_dis_list)-> tqh_last))->tqh_last))) != NULL((void *)0))
4571	sr_discipline_shutdown(sd, 1, dying);
4572	}
4573
4574	int
4575	sr_validate_io(struct sr_workunit wu, daddr_t blkno, char *func)
4576	{
4577	struct sr_discipline *sd = wu->swu_dis;
4578	struct scsi_xfer *xs = wu->swu_xs;
4579	int rv = 1;
4580
4581	DNPRINTF(SR_D_DIS, "%s: %s 0x%02x\n", DEVNAME(sd->sd_sc), func,
4582	xs->cmd.opcode);
4583
4584	if (sd->sd_meta->ssd_data_blkno == 0)
4585	panic("invalid data blkno");
4586
4587	if (sd->sd_vol_status == BIOC_SVOFFLINE0x01) {
4588	DNPRINTF(SR_D_DIS, "%s: %s device offline\n",
4589	DEVNAME(sd->sd_sc), func);
4590	goto bad;
4591	}
4592
4593	if (xs->datalen == 0) {
4594	printf("%s: %s: illegal block count for %s\n",
4595	DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname), func, sd->sd_meta->ssd_devname);
4596	goto bad;
4597	}
4598
4599	if (xs->cmdlen == 10)
4600	blkno = _4btol(((struct scsi_rw_10 )&xs->cmd)->addr);
4601	else if (xs->cmdlen == 16)
4602	blkno = _8btol(((struct scsi_rw_16 )&xs->cmd)->addr);
4603	else if (xs->cmdlen == 6)
4604	blkno = _3btol(((struct scsi_rw )&xs->cmd)->addr);
4605	else {
4606	printf("%s: %s: illegal cmdlen for %s\n",
4607	DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname), func, sd->sd_meta->ssd_devname);
4608	goto bad;
4609	}
4610
4611	blkno = (sd->sd_meta->ssdi_sdd_invariant.ssd_secsize / DEV_BSIZE(1 << 9));
4612
4613	wu->swu_blk_start = *blkno;
4614	wu->swu_blk_end = *blkno + (xs->datalen >> DEV_BSHIFT9) - 1;
4615
4616	if (wu->swu_blk_end > sd->sd_meta->ssdi_sdd_invariant.ssd_size) {
4617	DNPRINTF(SR_D_DIS, "%s: %s out of bounds start: %lld "
4618	"end: %lld length: %d\n",
4619	DEVNAME(sd->sd_sc), func, (long long)wu->swu_blk_start,
4620	(long long)wu->swu_blk_end, xs->datalen);
4621
4622	sd->sd_scsi_sense.error_code = SSD_ERRCODE_CURRENT0x70 \|
4623	SSD_ERRCODE_VALID0x80;
4624	sd->sd_scsi_sense.flags = SKEY_ILLEGAL_REQUEST0x05;
4625	sd->sd_scsi_sense.add_sense_code = 0x21;
4626	sd->sd_scsi_sense.add_sense_code_qual = 0x00;
4627	sd->sd_scsi_sense.extra_len = 4;
4628	goto bad;
4629	}
4630
4631	rv = 0;
4632	bad:
4633	return (rv);
4634	}
4635
4636	void
4637	sr_rebuild_start(void *arg)
4638	{
4639	struct sr_discipline *sd = arg;
4640	struct sr_softc *sc = sd->sd_sc;
4641
4642	DNPRINTF(SR_D_REBUILD, "%s: %s starting rebuild thread\n",
4643	DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname);
4644
4645	if (kthread_create(sr_rebuild_thread, sd, &sd->sd_background_proc,
4646	DEVNAME(sc)((sc)->sc_dev.dv_xname)) != 0)
4647	printf("%s: unable to start background operation\n",
4648	DEVNAME(sc)((sc)->sc_dev.dv_xname));
4649	}
4650
4651	void
4652	sr_rebuild_thread(void *arg)
4653	{
4654	struct sr_discipline *sd = arg;
4655
4656	DNPRINTF(SR_D_REBUILD, "%s: %s rebuild thread started\n",
4657	DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname);
4658
4659	sd->sd_reb_active = 1;
4660	sd->sd_rebuild(sd);
4661	sd->sd_reb_active = 0;
4662
4663	kthread_exit(0);
4664	}
4665
4666	void
4667	sr_rebuild(struct sr_discipline *sd)
4668	{
4669	struct sr_softc *sc = sd->sd_sc;
4670	u_int64_t sz, whole_blk, partial_blk, blk, restart;
4671	daddr_t lba;
4672	struct sr_workunit wu_r, wu_w;
4673	struct scsi_xfer xs_r, xs_w;
4674	struct scsi_rw_16 cr, cw;
4675	int c, s, slept, percent = 0, old_percent = -1;
4676	u_int8_t *buf;
4677
4678	whole_blk = sd->sd_meta->ssdi_sdd_invariant.ssd_size / SR_REBUILD_IO_SIZE128;
4679	partial_blk = sd->sd_meta->ssdi_sdd_invariant.ssd_size % SR_REBUILD_IO_SIZE128;
4680
4681	restart = sd->sd_meta->ssd_rebuild / SR_REBUILD_IO_SIZE128;
4682	if (restart > whole_blk) {
4683	printf("%s: bogus rebuild restart offset, starting from 0\n",
4684	DEVNAME(sc)((sc)->sc_dev.dv_xname));
4685	restart = 0;
4686	}
4687	if (restart) {
4688	/*
4689	* XXX there is a hole here; there is a possibility that we
4690	* had a restart however the chunk that was supposed to
4691	* be rebuilt is no longer valid; we can reach this situation
4692	* when a rebuild is in progress and the box crashes and
4693	* on reboot the rebuild chunk is different (like zero'd or
4694	* replaced). We need to check the uuid of the chunk that is
4695	* being rebuilt to assert this.
4696	*/
4697	percent = sr_rebuild_percent(sd);
4698	printf("%s: resuming rebuild on %s at %d%%\n",
4699	DEVNAME(sc)((sc)->sc_dev.dv_xname), sd->sd_meta->ssd_devname, percent);
4700	}
4701
4702	/* currently this is 64k therefore we can use dma_alloc */
4703	buf = dma_alloc(SR_REBUILD_IO_SIZE128 << DEV_BSHIFT9, PR_WAITOK0x0001);
4704	for (blk = restart; blk <= whole_blk; blk++) {
4705	lba = blk * SR_REBUILD_IO_SIZE128;
4706	sz = SR_REBUILD_IO_SIZE128;
4707	if (blk == whole_blk) {
4708	if (partial_blk == 0)
4709	break;
4710	sz = partial_blk;
4711	}
4712
4713	/* get some wu */
4714	wu_r = sr_scsi_wu_get(sd, 0);
4715	wu_w = sr_scsi_wu_get(sd, 0);
4716
4717	DNPRINTF(SR_D_REBUILD, "%s: %s rebuild wu_r %p, wu_w %p\n",
4718	DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname, wu_r, wu_w);
4719
4720	/* setup read io */
4721	bzero(&xs_r, sizeof xs_r)__builtin_bzero((&xs_r), (sizeof xs_r));
4722	xs_r.error = XS_NOERROR0;
4723	xs_r.flags = SCSI_DATA_IN0x00800;
4724	xs_r.datalen = sz << DEV_BSHIFT9;
4725	xs_r.data = buf;
4726	xs_r.cmdlen = sizeof(*cr);
4727	cr = (struct scsi_rw_16 *)&xs_r.cmd;
4728	cr->opcode = READ_160x88;
4729	_lto4b(sz, cr->length);
4730	_lto8b(lba, cr->addr);
4731	wu_r->swu_state = SR_WU_CONSTRUCT9;
4732	wu_r->swu_flags \|= SR_WUF_REBUILD(1<<0);
4733	wu_r->swu_xs = &xs_r;
4734	if (sd->sd_scsi_rw(wu_r)) {
4735	printf("%s: could not create read io\n",
4736	DEVNAME(sc)((sc)->sc_dev.dv_xname));
4737	goto fail;
4738	}
4739
4740	/* setup write io */
4741	bzero(&xs_w, sizeof xs_w)__builtin_bzero((&xs_w), (sizeof xs_w));
4742	xs_w.error = XS_NOERROR0;
4743	xs_w.flags = SCSI_DATA_OUT0x01000;
4744	xs_w.datalen = sz << DEV_BSHIFT9;
4745	xs_w.data = buf;
4746	xs_w.cmdlen = sizeof(*cw);
4747	cw = (struct scsi_rw_16 *)&xs_w.cmd;
4748	cw->opcode = WRITE_160x8a;
4749	_lto4b(sz, cw->length);
4750	_lto8b(lba, cw->addr);
4751	wu_w->swu_state = SR_WU_CONSTRUCT9;
4752	wu_w->swu_flags \|= SR_WUF_REBUILD(1<<0) \| SR_WUF_WAKEUP(1<<4);
4753	wu_w->swu_xs = &xs_w;
4754	if (sd->sd_scsi_rw(wu_w)) {
4755	printf("%s: could not create write io\n",
4756	DEVNAME(sc)((sc)->sc_dev.dv_xname));
4757	goto fail;
4758	}
4759
4760	/*
4761	* collide with the read io so that we get automatically
4762	* started when the read is done
4763	*/
4764	wu_w->swu_state = SR_WU_DEFERRED5;
4765	wu_r->swu_collider = wu_w;
4766	s = splbio()splraise(0x3);
4767	TAILQ_INSERT_TAIL(&sd->sd_wu_defq, wu_w, swu_link)do { (wu_w)->swu_link.tqe_next = ((void )0); (wu_w)->swu_link .tqe_prev = (&sd->sd_wu_defq)->tqh_last; (&sd-> sd_wu_defq)->tqh_last = (wu_w); (&sd->sd_wu_defq)-> tqh_last = &(wu_w)->swu_link.tqe_next; } while (0);
4768	splx(s)spllower(s);
4769
4770	DNPRINTF(SR_D_REBUILD, "%s: %s rebuild scheduling wu_r %p\n",
4771	DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname, wu_r);
4772
4773	wu_r->swu_state = SR_WU_INPROGRESS1;
4774	sr_schedule_wu(wu_r);
4775
4776	/* wait for write completion */
4777	slept = 0;
4778	while ((wu_w->swu_flags & SR_WUF_REBUILDIOCOMP(1<<1)) == 0) {
4779	tsleep_nsec(wu_w, PRIBIO16, "sr_rebuild", INFSLP0xffffffffffffffffULL);
4780	slept = 1;
4781	}
4782	/* yield if we didn't sleep */
4783	if (slept == 0)
4784	tsleep_nsec(sc, PWAIT32, "sr_yield", MSEC_TO_NSEC(1));
4785
4786	sr_scsi_wu_put(sd, wu_r);
4787	sr_scsi_wu_put(sd, wu_w);
4788
4789	sd->sd_meta->ssd_rebuild = lba;
4790
4791	/* XXX - this should be based on size, not percentage. */
4792	/* save metadata every percent */
4793	percent = sr_rebuild_percent(sd);
4794	if (percent != old_percent && blk != whole_blk) {
4795	if (sr_meta_save(sd, SR_META_DIRTY0x1))
4796	printf("%s: could not save metadata to %s\n",
4797	DEVNAME(sc)((sc)->sc_dev.dv_xname), sd->sd_meta->ssd_devname);
4798	old_percent = percent;
4799	}
4800
4801	if (sd->sd_reb_abort)
4802	goto abort;
4803	}
4804
4805	/* all done */
4806	sd->sd_meta->ssd_rebuild = 0;
4807	for (c = 0; c < sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no; c++) {
4808	if (sd->sd_vol.sv_chunks[c]->src_meta.scm_status ==
4809	BIOC_SDREBUILD0x03) {
4810	sd->sd_set_chunk_state(sd, c, BIOC_SDONLINE0x00);
4811	break;
4812	}
4813	}
4814
4815	abort:
4816	if (sr_meta_save(sd, SR_META_DIRTY0x1))
4817	printf("%s: could not save metadata to %s\n",
4818	DEVNAME(sc)((sc)->sc_dev.dv_xname), sd->sd_meta->ssd_devname);
4819	fail:
4820	dma_free(buf, SR_REBUILD_IO_SIZE128 << DEV_BSHIFT9);
4821	}
4822
4823	struct sr_discipline *
4824	sr_find_discipline(struct sr_softc sc, const char devname)
4825	{
4826	struct sr_discipline *sd;
4827
4828	TAILQ_FOREACH(sd, &sc->sc_dis_list, sd_link)for((sd) = ((&sc->sc_dis_list)->tqh_first); (sd) != ((void *)0); (sd) = ((sd)->sd_link.tqe_next))
4829	if (!strncmp(sd->sd_meta->ssd_devname, devname,
4830	sizeof(sd->sd_meta->ssd_devname)))
4831	break;
4832	return sd;
4833	}
4834
4835	#ifndef SMALL_KERNEL
4836	int
4837	sr_sensors_create(struct sr_discipline *sd)
4838	{
4839	struct sr_softc *sc = sd->sd_sc;
4840	int rv = 1;
4841
4842	DNPRINTF(SR_D_STATE, "%s: %s: sr_sensors_create\n",
4843	DEVNAME(sc), sd->sd_meta->ssd_devname);
4844
4845	sd->sd_vol.sv_sensor.type = SENSOR_DRIVE;
4846	sd->sd_vol.sv_sensor.status = SENSOR_S_UNKNOWN;
4847	strlcpy(sd->sd_vol.sv_sensor.desc, sd->sd_meta->ssd_devname,
4848	sizeof(sd->sd_vol.sv_sensor.desc));
4849
4850	sensor_attach(&sc->sc_sensordev, &sd->sd_vol.sv_sensor);
4851	sd->sd_vol.sv_sensor_attached = 1;
4852
4853	if (sc->sc_sensor_task == NULL((void *)0)) {
4854	sc->sc_sensor_task = sensor_task_register(sc,
4855	sr_sensors_refresh, 10);
4856	if (sc->sc_sensor_task == NULL((void *)0))
4857	goto bad;
4858	}
4859
4860	rv = 0;
4861	bad:
4862	return (rv);
4863	}
4864
4865	void
4866	sr_sensors_delete(struct sr_discipline *sd)
4867	{
4868	DNPRINTF(SR_D_STATE, "%s: sr_sensors_delete\n", DEVNAME(sd->sd_sc));
4869
4870	if (sd->sd_vol.sv_sensor_attached)
4871	sensor_detach(&sd->sd_sc->sc_sensordev, &sd->sd_vol.sv_sensor);
4872	}
4873
4874	void
4875	sr_sensors_refresh(void *arg)
4876	{
4877	struct sr_softc *sc = arg;
4878	struct sr_volume *sv;
4879	struct sr_discipline *sd;
4880
4881	DNPRINTF(SR_D_STATE, "%s: sr_sensors_refresh\n", DEVNAME(sc));
4882
4883	TAILQ_FOREACH(sd, &sc->sc_dis_list, sd_link)for((sd) = ((&sc->sc_dis_list)->tqh_first); (sd) != ((void *)0); (sd) = ((sd)->sd_link.tqe_next)) {
4884	sv = &sd->sd_vol;
4885
4886	switch(sd->sd_vol_status) {
4887	case BIOC_SVOFFLINE0x01:
4888	sv->sv_sensor.value = SENSOR_DRIVE_FAIL9;
4889	sv->sv_sensor.status = SENSOR_S_CRIT;
4890	break;
4891
4892	case BIOC_SVDEGRADED0x02:
4893	sv->sv_sensor.value = SENSOR_DRIVE_PFAIL10;
4894	sv->sv_sensor.status = SENSOR_S_WARN;
4895	break;
4896
4897	case BIOC_SVREBUILD0x05:
4898	sv->sv_sensor.value = SENSOR_DRIVE_REBUILD7;
4899	sv->sv_sensor.status = SENSOR_S_WARN;
4900	break;
4901
4902	case BIOC_SVSCRUB0x04:
4903	case BIOC_SVONLINE0x00:
4904	sv->sv_sensor.value = SENSOR_DRIVE_ONLINE4;
4905	sv->sv_sensor.status = SENSOR_S_OK;
4906	break;
4907
4908	default:
4909	sv->sv_sensor.value = 0; /* unknown */
4910	sv->sv_sensor.status = SENSOR_S_UNKNOWN;
4911	}
4912	}
4913	}
4914	#endif /* SMALL_KERNEL */
4915
4916	#ifdef SR_FANCY_STATS
4917	void sr_print_stats(void);
4918
4919	void
4920	sr_print_stats(void)
4921	{
4922	struct sr_softc *sc = softraid0;
4923	struct sr_discipline *sd;
4924
4925	if (sc == NULL((void *)0)) {
4926	printf("no softraid softc found\n");
4927	return;
4928	}
4929
4930	TAILQ_FOREACH(sd, &sc->sc_dis_list, sd_link)for((sd) = ((&sc->sc_dis_list)->tqh_first); (sd) != ((void *)0); (sd) = ((sd)->sd_link.tqe_next)) {
4931	printf("%s: ios pending %d, collisions %llu\n",
4932	sd->sd_meta->ssd_devname,
4933	sd->sd_wu_pending,
4934	sd->sd_wu_collisions);
4935	}
4936	}
4937	#endif /* SR_FANCY_STATS */
4938
4939	#ifdef SR_DEBUG
4940	void
4941	sr_meta_print(struct sr_metadata *m)
4942	{
4943	int i;
4944	struct sr_meta_chunk *mc;
4945	struct sr_meta_opt_hdr *omh;
4946
4947	if (!(sr_debug & SR_D_META))
4948	return;
4949
4950	printf("\tssd_magic 0x%llx\n", m->ssdi_sdd_invariant.ssd_magic);
4951	printf("\tssd_version %d\n", m->ssdi_sdd_invariant.ssd_version);
4952	printf("\tssd_vol_flags 0x%x\n", m->ssdi_sdd_invariant.ssd_vol_flags);
4953	printf("\tssd_uuid ");
4954	sr_uuid_print(&m->ssdi_sdd_invariant.ssd_uuid, 1);
4955	printf("\tssd_chunk_no %d\n", m->ssdi_sdd_invariant.ssd_chunk_no);
4956	printf("\tssd_chunk_id %d\n", m->ssdi_sdd_invariant.ssd_chunk_id);
4957	printf("\tssd_opt_no %d\n", m->ssdi_sdd_invariant.ssd_opt_no);
4958	printf("\tssd_volid %d\n", m->ssdi_sdd_invariant.ssd_volid);
4959	printf("\tssd_level %d\n", m->ssdi_sdd_invariant.ssd_level);
4960	printf("\tssd_size %lld\n", m->ssdi_sdd_invariant.ssd_size);
4961	printf("\tssd_devname %s\n", m->ssd_devname);
4962	printf("\tssd_vendor %s\n", m->ssdi_sdd_invariant.ssd_vendor);
4963	printf("\tssd_product %s\n", m->ssdi_sdd_invariant.ssd_product);
4964	printf("\tssd_revision %s\n", m->ssdi_sdd_invariant.ssd_revision);
4965	printf("\tssd_strip_size %d\n", m->ssdi_sdd_invariant.ssd_strip_size);
4966	printf("\tssd_checksum ");
4967	sr_checksum_print(m->ssd_checksum);
4968	printf("\n");
4969	printf("\tssd_meta_flags 0x%x\n", m->ssd_meta_flags);
4970	printf("\tssd_ondisk %llu\n", m->ssd_ondisk);
4971
4972	mc = (struct sr_meta_chunk *)(m + 1);
4973	for (i = 0; i < m->ssdi_sdd_invariant.ssd_chunk_no; i++, mc++) {
4974	printf("\t\tscm_volid %d\n", mc->scmi_scm_invariant.scm_volid);
4975	printf("\t\tscm_chunk_id %d\n", mc->scmi_scm_invariant.scm_chunk_id);
4976	printf("\t\tscm_devname %s\n", mc->scmi_scm_invariant.scm_devname);
4977	printf("\t\tscm_size %lld\n", mc->scmi_scm_invariant.scm_size);
4978	printf("\t\tscm_coerced_size %lld\n",mc->scmi_scm_invariant.scm_coerced_size);
4979	printf("\t\tscm_uuid ");
4980	sr_uuid_print(&mc->scmi_scm_invariant.scm_uuid, 1);
4981	printf("\t\tscm_checksum ");
4982	sr_checksum_print(mc->scm_checksum);
4983	printf("\n");
4984	printf("\t\tscm_status %d\n", mc->scm_status);
4985	}
4986
4987	omh = (struct sr_meta_opt_hdr )((u_int8_t )(m + 1) +
4988	sizeof(struct sr_meta_chunk) * m->ssdi_sdd_invariant.ssd_chunk_no);
4989	for (i = 0; i < m->ssdi_sdd_invariant.ssd_opt_no; i++) {
4990	printf("\t\t\tsom_type %d\n", omh->som_type);
4991	printf("\t\t\tsom_checksum ");
4992	sr_checksum_print(omh->som_checksum);
4993	printf("\n");
4994	omh = (struct sr_meta_opt_hdr )((void )omh +
4995	omh->som_length);
4996	}
4997	}
4998
4999	void
5000	sr_dump_block(void *blk, int len)
5001	{
5002	uint8_t *b = blk;
5003	int i, j, c;
5004
5005	for (i = 0; i < len; i += 16) {
5006	for (j = 0; j < 16; j++)
5007	printf("%.2x ", b[i + j]);
5008	printf(" ");
5009	for (j = 0; j < 16; j++) {
5010	c = b[i + j];
5011	if (c < ' ' \|\| c > 'z' \|\| i + j > len)
5012	c = '.';
5013	printf("%c", c);
5014	}
5015	printf("\n");
5016	}
5017	}
5018
5019	void
5020	sr_dump_mem(u_int8_t *p, int len)
5021	{
5022	int i;
5023
5024	for (i = 0; i < len; i++)
5025	printf("%02x ", *p++);
5026	printf("\n");
5027	}
5028
5029	#endif /* SR_DEBUG */
5030
5031	#ifdef HIBERNATE1
5032	/*
5033	* Side-effect free (no malloc, printf, pool, splx) softraid crypto writer.
5034	*
5035	* This function must perform the following:
5036	* 1. Determine the underlying device's own side-effect free I/O function
5037	* (eg, ahci_hibernate_io, wd_hibernate_io, etc).
5038	* 2. Store enough information in the provided page argument for subsequent
5039	* I/O calls (such as the crypto discipline structure for the keys, the
5040	* offset of the softraid partition on the underlying disk, as well as
5041	* the offset of the swap partition within the crypto volume.
5042	* 3. Encrypt the incoming data using the sr_discipline keys, then pass
5043	* the request to the underlying device's own I/O function.
5044	*/
5045	int
5046	sr_hibernate_io(dev_t dev, daddr_t blkno, vaddr_t addr, size_t size, int op, void *page)
5047	{
5048	/* Struct for stashing data obtained on HIB_INIT.
5049	* XXX
5050	* We share the page with the underlying device's own
5051	* side-effect free I/O function, so we pad our data to
5052	* the end of the page. Presently this does not overlap
5053	* with either of the two other side-effect free i/o
5054	* functions (ahci/wd).
5055	*/
5056	struct {
5057	char pad[3072];
5058	struct sr_discipline *srd;
5059	hibio_fn subfn; /* underlying device i/o fn */
5060	dev_t subdev; /* underlying device dev_t */
5061	daddr_t sr_swapoff; /* ofs of swap part in sr volume */
5062	char buf[DEV_BSIZE(1 << 9)]; /* encryption performed into this buf */
5063	} *my = page;
5064	extern struct cfdriver sd_cd;
5065	char errstr[128], *dl_ret;
5066	struct sr_chunk *schunk;
5067	struct sd_softc *sd;
5068	struct aes_xts_ctx ctx;
5069	struct sr_softc *sc;
5070	struct device *dv;
5071	daddr_t key_blkno;
5072	uint32_t sub_raidoff; /* ofs of sr part in underlying dev */
5073	struct disklabel dl;
5074	struct partition *pp;
5075	size_t i, j;
5076	u_char iv[8];
5077
5078	/*
5079	* In HIB_INIT, we are passed the swap partition size and offset
5080	* in 'size' and 'blkno' respectively. These are relative to the
5081	* start of the softraid partition, and we need to save these
5082	* for later translation to the underlying device's layout.
5083	*/
5084	if (op == HIB_INIT-1) {
5085	dv = disk_lookup(&sd_cd, DISKUNIT(dev)(((unsigned)((dev) & 0xff) \| (((dev) & 0xffff0000) >> 8)) / 16));
5086	sd = (struct sd_softc *)dv;
5087	sc = (struct sr_softc *)dv->dv_parent->dv_parent;
5088
5089	/*
5090	* Look up the sr discipline. This is used to determine
5091	* if we are SR crypto and what the underlying device is.
5092	*/
5093	my->srd = sc->sc_targets[sd->sc_link->target];
5094	DNPRINTF(SR_D_MISC, "sr_hibernate_io: discipline is %s\n",
5095	my->srd->sd_name);
5096	if (strncmp(my->srd->sd_name, "CRYPTO",
5097	sizeof(my->srd->sd_name)))
5098	return (ENOTSUP91);
5099
5100	/* Find the underlying device */
5101	schunk = my->srd->sd_vol.sv_chunks[0];
5102	my->subdev = schunk->src_dev_mm;
5103
5104	/*
5105	* Find the appropriate underlying device side effect free
5106	* I/O function, based on the type of device it is.
5107	*/
5108	my->subfn = get_hibernate_io_function(my->subdev);
5109	if (!my->subfn)
5110	return (ENODEV19);
5111
5112	/*
5113	* Find blkno where this raid partition starts on
5114	* the underlying disk.
5115	*/
5116	dl_ret = disk_readlabel(&dl, my->subdev, errstr,
5117	sizeof(errstr));
5118	if (dl_ret) {
5119	printf("Hibernate error reading disklabel: %s\n", dl_ret);
5120	return (ENOTSUP91);
5121	}
5122
5123	pp = &dl.d_partitions[DISKPART(my->subdev)(((unsigned)((my->subdev) & 0xff) \| (((my->subdev) & 0xffff0000) >> 8)) % 16)];
5124	if (pp->p_fstype != FS_RAID19 \|\| DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size) == 0)
5125	return (ENOTSUP91);
5126
5127	/* Find the blkno of the SR part in the underlying device */
5128	sub_raidoff = my->srd->sd_meta->ssd_data_blkno +
5129	DL_SECTOBLK(&dl, DL_GETPOFFSET(pp))(((((u_int64_t)(pp)->p_offseth << 32) + (pp)->p_offset )) * ((&dl)->d_secsize / (1 << 9)));
5130	DNPRINTF(SR_D_MISC,"sr_hibernate_io: blk trans ofs: %d blks\n",
5131	sub_raidoff);
5132
5133	/* Save the blkno of the swap partition in the SR disk */
5134	my->sr_swapoff = blkno;
5135
5136	/* Initialize the sub-device */
5137	return my->subfn(my->subdev, sub_raidoff + blkno,
5138	addr, size, op, page);
5139	}
5140
5141	/* Hibernate only uses (and we only support) writes */
5142	if (op != HIB_W1)
5143	return (ENOTSUP91);
5144
5145	/*
5146	* Blocks act as the IV for the encryption. These block numbers
5147	* are relative to the start of the sr partition, but the 'blkno'
5148	* passed above is relative to the start of the swap partition
5149	* inside the sr partition, so bias appropriately.
5150	*/
5151	key_blkno = my->sr_swapoff + blkno;
5152
5153	/* Process each disk block one at a time. */
5154	for (i = 0; i < size; i += DEV_BSIZE(1 << 9)) {
5155	int res;
5156
5157	bzero(&ctx, sizeof(ctx))__builtin_bzero((&ctx), (sizeof(ctx)));
5158
5159	/*
5160	* Set encryption key (from the sr discipline stashed
5161	* during HIB_INIT. This code is based on the softraid
5162	* bootblock code.
5163	*/
5164	aes_xts_setkey(&ctx, my->srd->mdssd_dis_specific.mdd_crypto.scr_key[0], 64);
5165	/* We encrypt DEV_BSIZE bytes at a time in my->buf */
5166	memcpy(my->buf, ((char )addr) + i, DEV_BSIZE)__builtin_memcpy((my->buf), (((char )addr) + i), ((1 << 9)));
5167
5168	/* Block number is the IV */
5169	memcpy(&iv, &key_blkno, sizeof(key_blkno))__builtin_memcpy((&iv), (&key_blkno), (sizeof(key_blkno )));
5170	aes_xts_reinit(&ctx, iv);
5171
5172	/* Encrypt DEV_BSIZE bytes, AES_XTS_BLOCKSIZE bytes at a time */
5173	for (j = 0; j < DEV_BSIZE(1 << 9); j += AES_XTS_BLOCKSIZE16)
5174	aes_xts_encrypt(&ctx, my->buf + j);
5175
5176	/*
5177	* Write one block out from my->buf to the underlying device
5178	* using its own side-effect free I/O function.
5179	*/
5180	res = my->subfn(my->subdev, blkno + (i / DEV_BSIZE(1 << 9)),
5181	(vaddr_t)(my->buf), DEV_BSIZE(1 << 9), op, page);
5182	if (res != 0)
5183	return (res);
5184	key_blkno++;
5185	}
5186	return (0);
5187	}
5188	#endif /* HIBERNATE */