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

Bug Summary

File:	dev/softraid.c
Warning:	line 1238, column 5 Potential leak of memory pointed to by 'bc'
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/*
* Copyright (c) 2007, 2008, 2009 Marco Peereboom <marco@peereboom.us>
* Copyright (c) 2008 Chris Kuethe <ckuethe@openbsd.org>
* Copyright (c) 2009 Joel Sing <jsing@openbsd.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

20#include "bio.h"

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>

47#include <scsi/scsi_all.h>
48#include <scsi/scsiconf.h>
49#include <scsi/scsi_disk.h>

51#include <dev/softraidvar.h>

53#ifdef HIBERNATE1
54#include <lib/libsa/aes_xts.h>
55#include <sys/hibernate.h>
56#include <scsi/sdvar.h>
57#endif /* HIBERNATE */

59/* #define SR_FANCY_STATS */

61#ifdef SR_DEBUG
62#define SR_FANCY_STATS
63uint32_t	sr_debug = 0
    /* | SR_D_CMD */
    /* | SR_D_MISC */
    /* | SR_D_INTR */
    /* | SR_D_IOCTL */
    /* | SR_D_CCB */
    /* | SR_D_WU */
    /* | SR_D_META */
    /* | SR_D_DIS */
    /* | SR_D_STATE */
    /* | SR_D_REBUILD */
;
75#endif

77struct sr_softc	*softraid0;
78struct sr_uuid	sr_bootuuid;
79u_int8_t	sr_bootkey[SR_CRYPTO_MAXKEYBYTES32];

81int		sr_match(struct device *, void *, void *);
82void		sr_attach(struct device *, struct device *, void *);
83int		sr_detach(struct device *, int);
84void		sr_map_root(void);

86const struct cfattach softraid_ca = {
sizeof(struct sr_softc), sr_match, sr_attach, sr_detach,
88};

90struct cfdriver softraid_cd = {
NULL((void *)0), "softraid", DV_DULL
92};

94/* scsi & discipline */
95void			sr_scsi_cmd(struct scsi_xfer *);
96int			sr_scsi_probe(struct scsi_link *);
97int			sr_scsi_ioctl(struct scsi_link *, u_long,
	    caddr_t, int);
99int			sr_bio_ioctl(struct device *, u_long, caddr_t);
100int			sr_bio_handler(struct sr_softc *,
	    struct sr_discipline *, u_long, struct bio *);
102int			sr_ioctl_inq(struct sr_softc *, struct bioc_inq *);
103int			sr_ioctl_vol(struct sr_softc *, struct bioc_vol *);
104int			sr_ioctl_disk(struct sr_softc *, struct bioc_disk *);
105int			sr_ioctl_setstate(struct sr_softc *,
	    struct bioc_setstate *);
107int			sr_ioctl_createraid(struct sr_softc *,
	    struct bioc_createraid *, int, void *);
109int			sr_ioctl_deleteraid(struct sr_softc *,
	    struct sr_discipline *, struct bioc_deleteraid *);
111int			sr_ioctl_discipline(struct sr_softc *,
	    struct sr_discipline *, struct bioc_discipline *);
113int			sr_ioctl_installboot(struct sr_softc *,
	    struct sr_discipline *, struct bioc_installboot *);
115void			sr_chunks_unwind(struct sr_softc *,
	    struct sr_chunk_head *);
117void			sr_discipline_free(struct sr_discipline *);
118void			sr_discipline_shutdown(struct sr_discipline *, int, int);
119int			sr_discipline_init(struct sr_discipline *, int);
120int			sr_alloc_resources(struct sr_discipline *);
121void			sr_free_resources(struct sr_discipline *);
122void			sr_set_chunk_state(struct sr_discipline *, int, int);
123void			sr_set_vol_state(struct sr_discipline *);

125/* utility functions */
126void			sr_shutdown(int);
127void			sr_uuid_generate(struct sr_uuid *);
128char			*sr_uuid_format(struct sr_uuid *);
129void			sr_uuid_print(struct sr_uuid *, int);
130void			sr_checksum_print(u_int8_t *);
131int			sr_boot_assembly(struct sr_softc *);
132int			sr_already_assembled(struct sr_discipline *);
133int			sr_hotspare(struct sr_softc *, dev_t);
134void			sr_hotspare_rebuild(struct sr_discipline *);
135int			sr_rebuild_init(struct sr_discipline *, dev_t, int);
136void			sr_rebuild_start(void *);
137void			sr_rebuild_thread(void *);
138void			sr_rebuild(struct sr_discipline *);
139void			sr_roam_chunks(struct sr_discipline *);
140int			sr_chunk_in_use(struct sr_softc *, dev_t);
141int			sr_rw(struct sr_softc *, dev_t, char *, size_t,
	    daddr_t, long);
143void			sr_wu_done_callback(void *);
144struct sr_discipline	*sr_find_discipline(struct sr_softc *sc, const char *);

146/* don't include these on RAMDISK */
147#ifndef SMALL_KERNEL
148void			sr_sensors_refresh(void *);
149int			sr_sensors_create(struct sr_discipline *);
150void			sr_sensors_delete(struct sr_discipline *);
151#endif

153/* metadata */
154int			sr_meta_probe(struct sr_discipline *, dev_t *, int);
155int			sr_meta_attach(struct sr_discipline *, int, int);
156int			sr_meta_rw(struct sr_discipline *, dev_t, void *, long);
157int			sr_meta_clear(struct sr_discipline *);
158void			sr_meta_init(struct sr_discipline *, int, int);
159void			sr_meta_init_complete(struct sr_discipline *);
160void			sr_meta_opt_handler(struct sr_discipline *,
	    struct sr_meta_opt_hdr *);

163/* hotplug magic */
164void			sr_disk_attach(struct disk *, int);

166struct sr_hotplug_list {
void			(*sh_hotplug)(struct sr_discipline *,
		    struct disk *, int);
struct sr_discipline	*sh_sd;

SLIST_ENTRY(sr_hotplug_list)struct { struct sr_hotplug_list *sle_next; } shl_link;
172};
173SLIST_HEAD(sr_hotplug_list_head, sr_hotplug_list)struct sr_hotplug_list_head { struct sr_hotplug_list *slh_first
; };

175struct			sr_hotplug_list_head	sr_hotplug_callbacks;
176extern void		(*softraid_disk_attach)(struct disk *, int);

178/* scsi glue */
179const struct scsi_adapter sr_switch = {
sr_scsi_cmd, NULL((void *)0), sr_scsi_probe, NULL((void *)0), sr_scsi_ioctl
181};

183/* native metadata format */
184int			sr_meta_native_bootprobe(struct sr_softc *, dev_t,
	    struct sr_boot_chunk_head *);
186#define SR_META_NOTCLAIMED(0)	(0)
187#define SR_META_CLAIMED(1)		(1)
188int			sr_meta_native_probe(struct sr_softc *,
	   struct sr_chunk *);
190int			sr_meta_native_attach(struct sr_discipline *, int);
191int			sr_meta_native_write(struct sr_discipline *, dev_t,
	    struct sr_metadata *,void *);

194#ifdef SR_DEBUG
195void			sr_meta_print(struct sr_metadata *);
196#else
197#define			sr_meta_print(m)
198#endif

200/* the metadata driver should remain stateless */
201struct sr_meta_driver {
daddr_t			smd_offset;	/* metadata location */
u_int32_t		smd_size;	/* size of metadata */

int			(*smd_probe)(struct sr_softc *,
		   struct sr_chunk *);
int			(*smd_attach)(struct sr_discipline *, int);
int			(*smd_detach)(struct sr_discipline *);
int			(*smd_read)(struct sr_discipline *, dev_t,
		    struct sr_metadata *, void *);
int			(*smd_write)(struct sr_discipline *, dev_t,
		    struct sr_metadata *, void *);
int			(*smd_validate)(struct sr_discipline *,
		    struct sr_metadata *, void *);
215} smd[] = {
{ SR_META_OFFSET16, SR_META_SIZE64 * DEV_BSIZE(1 << 9),
 sr_meta_native_probe, sr_meta_native_attach, NULL((void *)0),
 sr_meta_native_read, sr_meta_native_write, NULL((void *)0) },
{ 0, 0, NULL((void *)0), NULL((void *)0), NULL((void *)0), NULL((void *)0) }
220};

222int
223sr_meta_attach(struct sr_discipline *sd, int chunk_no, int force)
224{
struct sr_softc		*sc = sd->sd_sc;
struct sr_chunk_head	*cl;
struct sr_chunk		*ch_entry, *chunk1, *chunk2;
int			rv = 1, i = 0;

DNPRINTF(SR_D_META, "%s: sr_meta_attach(%d)\n", DEVNAME(sc), chunk_no);

/* in memory copy of metadata */
sd->sd_meta = malloc(SR_META_SIZE64 * DEV_BSIZE(1 << 9), M_DEVBUF2,
   M_ZERO0x0008 | M_NOWAIT0x0002);
if (!sd->sd_meta) {
sr_error(sc, "could not allocate memory for metadata");
goto bad;
}

if (sd->sd_meta_type != SR_META_F_NATIVE0) {
/* in memory copy of foreign metadata */
sd->sd_meta_foreign = malloc(smd[sd->sd_meta_type].smd_size,
    M_DEVBUF2, M_ZERO0x0008 | M_NOWAIT0x0002);
if (!sd->sd_meta_foreign) {
	/* unwind frees sd_meta */
	sr_error(sc, "could not allocate memory for foreign "
	    "metadata");
	goto bad;
}
}

/* we have a valid list now create an array index */
cl = &sd->sd_vol.sv_chunk_list;
sd->sd_vol.sv_chunks = mallocarray(chunk_no, sizeof(struct sr_chunk *),
   M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);

/* fill out chunk array */
i = 0;
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))
sd->sd_vol.sv_chunks[i++] = ch_entry;

/* attach metadata */
if (smd[sd->sd_meta_type].smd_attach(sd, force))
goto bad;

/* Force chunks into correct order now that metadata is attached. */
SLIST_INIT(cl){ ((cl)->slh_first) = ((void *)0); };
for (i = 0; i < chunk_no; i++) {
ch_entry = sd->sd_vol.sv_chunks[i];
chunk2 = NULL((void *)0);
SLIST_FOREACH(chunk1, cl, src_link)for((chunk1) = ((cl)->slh_first); (chunk1) != ((void *)0);
 (chunk1) = ((chunk1)->src_link.sle_next)) {
	if (chunk1->src_meta.scmi_scm_invariant.scm_chunk_id >
	    ch_entry->src_meta.scmi_scm_invariant.scm_chunk_id)
		break;
	chunk2 = chunk1;
}
if (chunk2 == NULL((void *)0))
	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);
else
	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);
}
i = 0;
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))
sd->sd_vol.sv_chunks[i++] = ch_entry;

rv = 0;
287bad:
return (rv);
289}

291int
292sr_meta_probe(struct sr_discipline *sd, dev_t *dt, int no_chunk)
293{
struct sr_softc		*sc = sd->sd_sc;
struct vnode		*vn;
struct sr_chunk		*ch_entry, *ch_prev = NULL((void *)0);
struct sr_chunk_head	*cl;
char			devname[32];
int			i, d, type, found, prevf, error;
dev_t			dev;

DNPRINTF(SR_D_META, "%s: sr_meta_probe(%d)\n", DEVNAME(sc), no_chunk);

if (no_chunk == 0)
goto unwind;

cl = &sd->sd_vol.sv_chunk_list;

for (d = 0, prevf = SR_META_F_INVALID-1; d < no_chunk; d++) {
ch_entry = malloc(sizeof(struct sr_chunk), M_DEVBUF2,
    M_WAITOK0x0001 | M_ZERO0x0008);
/* keep disks in user supplied order */
if (ch_prev)
	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);
else
	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);
ch_prev = ch_entry;
dev = dt[d];
ch_entry->src_dev_mm = dev;

if (dev == NODEV(dev_t)(-1)) {
	ch_entry->src_meta.scm_status = BIOC_SDOFFLINE0x01;
	continue;
} else {
	sr_meta_getdevname(sc, dev, devname, sizeof(devname));
	if (bdevvp(dev, &vn)) {
		sr_error(sc, "sr_meta_probe: cannot allocate "
		    "vnode");
		goto unwind;
	}

	/*
	 * XXX leaving dev open for now; move this to attach
	 * and figure out the open/close dance for unwind.
	 */
	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);
	if (error) {
		DNPRINTF(SR_D_META,"%s: sr_meta_probe can't "
		    "open %s\n", DEVNAME(sc), devname);
		vput(vn);
		goto unwind;
	}

	strlcpy(ch_entry->src_devname, devname,
	    sizeof(ch_entry->src_devname));
	ch_entry->src_vn = vn;
}

/* determine if this is a device we understand */
for (i = 0, found = SR_META_F_INVALID-1; smd[i].smd_probe; i++) {
	type = smd[i].smd_probe(sc, ch_entry);
	if (type == SR_META_F_INVALID-1)
		continue;
	else {
		found = type;
		break;
	}
}

if (found == SR_META_F_INVALID-1)
	goto unwind;
if (prevf == SR_META_F_INVALID-1)
	prevf = found;
if (prevf != found) {
	DNPRINTF(SR_D_META, "%s: prevf != found\n",
	    DEVNAME(sc));
	goto unwind;
}
}

return (prevf);
372unwind:
return (SR_META_F_INVALID-1);
374}

376void
377sr_meta_getdevname(struct sr_softc *sc, dev_t dev, char *buf, int size)
378{
int			maj, unit, part;
char			*name;

DNPRINTF(SR_D_META, "%s: sr_meta_getdevname(%p, %d)\n",
   DEVNAME(sc), buf, size);

if (!buf)
return;

maj = major(dev)(((unsigned)(dev) >> 8) & 0xff);
part = DISKPART(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
 8)) % 16);
unit = DISKUNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
 8)) / 16);

name = findblkname(maj);
if (name == NULL((void *)0))
return;

snprintf(buf, size, "%s%d%c", name, unit, part + 'a');
397}

399int
400sr_rw(struct sr_softc *sc, dev_t dev, char *buf, size_t size, daddr_t blkno,
  long flags)
402{
struct vnode		*vp;
struct buf		b;
size_t			bufsize, dma_bufsize;
int			rv = 1;
char			*dma_buf;
int			s;

DNPRINTF(SR_D_MISC, "%s: sr_rw(0x%x, %p, %zu, %lld 0x%lx)\n",
   DEVNAME(sc), dev, buf, size, (long long)blkno, flags);

dma_bufsize = (size > MAXPHYS(64 * 1024)) ? MAXPHYS(64 * 1024) : size;
dma_buf = dma_alloc(dma_bufsize, PR_WAITOK0x0001);

if (bdevvp(dev, &vp)) {
printf("%s: sr_rw: failed to allocate vnode\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
goto done;
}

while (size > 0) {
DNPRINTF(SR_D_MISC, "%s: dma_buf %p, size %zu, blkno %lld)\n",
    DEVNAME(sc), dma_buf, size, (long long)blkno);

bufsize = (size > MAXPHYS(64 * 1024)) ? MAXPHYS(64 * 1024) : size;
if (flags == B_WRITE0x00000000)
	memcpy(dma_buf, buf, bufsize)__builtin_memcpy((dma_buf), (buf), (bufsize));

bzero(&b, sizeof(b))__builtin_bzero((&b), (sizeof(b)));
b.b_flags = flags | B_PHYS0x00002000;
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;
b.b_dev = dev;
b.b_iodone = NULL((void *)0);
b.b_error = 0;
b.b_blkno = blkno;
b.b_data = dma_buf;
b.b_bcount = bufsize;
b.b_bufsize = bufsize;
b.b_resid = bufsize;
b.b_vp = vp;

if ((b.b_flags & B_READ0x00008000) == 0) {
	s = splbio()splraise(0x3);
	vp->v_numoutput++;
	splx(s)spllower(s);
}

LIST_INIT(&b.b_dep)do { ((&b.b_dep)->lh_first) = ((void *)0); } while (0);
VOP_STRATEGY(vp, &b);
biowait(&b);

if (b.b_flags & B_ERROR0x00000400) {
	printf("%s: I/O error %d on dev 0x%x at block %llu\n",
	    DEVNAME(sc)((sc)->sc_dev.dv_xname), b.b_error, dev, b.b_blkno);
	goto done;
}

if (flags == B_READ0x00008000)
	memcpy(buf, dma_buf, bufsize)__builtin_memcpy((buf), (dma_buf), (bufsize));

size -= bufsize;
buf += bufsize;
blkno += howmany(bufsize, DEV_BSIZE)(((bufsize) + (((1 << 9)) - 1)) / ((1 << 9)));
}

rv = 0;

468done:
if (vp)
vput(vp);

dma_free(dma_buf, dma_bufsize);

return (rv);
475}

477int
478sr_meta_rw(struct sr_discipline *sd, dev_t dev, void *md, long flags)
479{
int			rv = 1;

DNPRINTF(SR_D_META, "%s: sr_meta_rw(0x%x, %p, 0x%lx)\n",
   DEVNAME(sd->sd_sc), dev, md, flags);

if (md == NULL((void *)0)) {
printf("%s: sr_meta_rw: invalid metadata pointer\n",
    DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname));
goto done;
}

rv = sr_rw(sd->sd_sc, dev, md, SR_META_SIZE64 * DEV_BSIZE(1 << 9),
   SR_META_OFFSET16, flags);

494done:
return (rv);
496}

498int
499sr_meta_clear(struct sr_discipline *sd)
500{
struct sr_softc		*sc = sd->sd_sc;
struct sr_chunk_head	*cl = &sd->sd_vol.sv_chunk_list;
struct sr_chunk		*ch_entry;
void			*m;
int			rv = 1;

DNPRINTF(SR_D_META, "%s: sr_meta_clear\n", DEVNAME(sc));

if (sd->sd_meta_type != SR_META_F_NATIVE0) {
sr_error(sc, "cannot clear foreign metadata");
goto done;
}

m = malloc(SR_META_SIZE64 * DEV_BSIZE(1 << 9), M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
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)) {
if (sr_meta_native_write(sd, ch_entry->src_dev_mm, m, NULL((void *)0))) {
	/* XXX mark disk offline */
	DNPRINTF(SR_D_META, "%s: sr_meta_clear failed to "
	    "clear %s\n", DEVNAME(sc), ch_entry->src_devname);
	rv++;
	continue;
}
bzero(&ch_entry->src_meta, sizeof(ch_entry->src_meta))__builtin_bzero((&ch_entry->src_meta), (sizeof(ch_entry
->src_meta)));
}

bzero(sd->sd_meta, SR_META_SIZE * DEV_BSIZE)__builtin_bzero((sd->sd_meta), (64 * (1 << 9)));

free(m, M_DEVBUF2, SR_META_SIZE64 * DEV_BSIZE(1 << 9));
rv = 0;
530done:
return (rv);
532}

534void
535sr_meta_init(struct sr_discipline *sd, int level, int no_chunk)
536{
struct sr_softc		*sc = sd->sd_sc;
struct sr_metadata	*sm = sd->sd_meta;
struct sr_chunk_head	*cl = &sd->sd_vol.sv_chunk_list;
struct sr_meta_chunk	*scm;
struct sr_chunk		*chunk;
int			cid = 0;
u_int64_t		max_chunk_sz = 0, min_chunk_sz = 0;
u_int32_t		secsize = DEV_BSIZE(1 << 9);

DNPRINTF(SR_D_META, "%s: sr_meta_init\n", DEVNAME(sc));

if (!sm)
return;

/* Initialise volume metadata. */
sm->ssdi_sdd_invariant.ssd_magic = SR_MAGIC0x4d4152436372616dLLU;
sm->ssdi_sdd_invariant.ssd_version = SR_META_VERSION6;
sm->ssdi_sdd_invariant.ssd_vol_flags = sd->sd_meta_flags;
sm->ssdi_sdd_invariant.ssd_volid = 0;
sm->ssdi_sdd_invariant.ssd_chunk_no = no_chunk;
sm->ssdi_sdd_invariant.ssd_level = level;

sm->ssd_data_blkno = SR_DATA_OFFSET(16 + (64 + (320 + 128)));
sm->ssd_ondisk = 0;

sr_uuid_generate(&sm->ssdi_sdd_invariant.ssd_uuid);

/* Initialise chunk metadata and get min/max chunk sizes & secsize. */
SLIST_FOREACH(chunk, cl, src_link)for((chunk) = ((cl)->slh_first); (chunk) != ((void *)0); (
chunk) = ((chunk)->src_link.sle_next)) {
scm = &chunk->src_meta;
scm->scmi_scm_invariant.scm_size = chunk->src_size;
scm->scmi_scm_invariant.scm_chunk_id = cid++;
scm->scm_status = BIOC_SDONLINE0x00;
scm->scmi_scm_invariant.scm_volid = 0;
strlcpy(scm->scmi_scm_invariant.scm_devname, chunk->src_devname,
    sizeof(scm->scmi_scm_invariant.scm_devname));
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)))
    sizeof(scm->scmi.scm_uuid))__builtin_memcpy((&scm->_scm_invariant.scm_uuid), (&
sm->_sdd_invariant.ssd_uuid), (sizeof(scm->_scm_invariant
.scm_uuid)));
sr_checksum(sc, scm, &scm->scm_checksum,
    sizeof(scm->scm_checksum));

if (min_chunk_sz == 0)
	min_chunk_sz = scm->scmi_scm_invariant.scm_size;
if (chunk->src_secsize > secsize)
	secsize = chunk->src_secsize;
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));
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));
}

sm->ssdi_sdd_invariant.ssd_secsize = secsize;

/* Equalize chunk sizes. */
SLIST_FOREACH(chunk, cl, src_link)for((chunk) = ((cl)->slh_first); (chunk) != ((void *)0); (
chunk) = ((chunk)->src_link.sle_next))
chunk->src_meta.scmi_scm_invariant.scm_coerced_size = min_chunk_sz;

sd->sd_vol.sv_chunk_minsz = min_chunk_sz;
sd->sd_vol.sv_chunk_maxsz = max_chunk_sz;
594}

596void
597sr_meta_init_complete(struct sr_discipline *sd)
598{
599#ifdef SR_DEBUG
struct sr_softc		*sc = sd->sd_sc;
601#endif
struct sr_metadata	*sm = sd->sd_meta;

DNPRINTF(SR_D_META, "%s: sr_meta_complete\n", DEVNAME(sc));

/* Complete initialisation of volume metadata. */
strlcpy(sm->ssdi_sdd_invariant.ssd_vendor, "OPENBSD", sizeof(sm->ssdi_sdd_invariant.ssd_vendor));
snprintf(sm->ssdi_sdd_invariant.ssd_product, sizeof(sm->ssdi_sdd_invariant.ssd_product),
   "SR %s", sd->sd_name);
snprintf(sm->ssdi_sdd_invariant.ssd_revision, sizeof(sm->ssdi_sdd_invariant.ssd_revision),
   "%03d", sm->ssdi_sdd_invariant.ssd_version);
612}

614void
615sr_meta_opt_handler(struct sr_discipline *sd, struct sr_meta_opt_hdr *om)
616{
if (om->som_type != SR_OPT_BOOT0x02)
panic("unknown optional metadata type");
619}

621void
622sr_meta_save_callback(void *xsd)
623{
struct sr_discipline	*sd = xsd;
int			s;

s = splbio()splraise(0x3);

if (sr_meta_save(sd, SR_META_DIRTY0x1))
printf("%s: save metadata failed\n", DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname));

sd->sd_must_flush = 0;
splx(s)spllower(s);
634}

636int
637sr_meta_save(struct sr_discipline *sd, u_int32_t flags)
638{
struct sr_softc		*sc = sd->sd_sc;
struct sr_metadata	*sm = sd->sd_meta, *m;
struct sr_meta_driver	*s;
struct sr_chunk		*src;
struct sr_meta_chunk	*cm;
struct sr_workunit	wu;
struct sr_meta_opt_hdr	*omh;
struct sr_meta_opt_item *omi;
int			i;

DNPRINTF(SR_D_META, "%s: sr_meta_save %s\n",
   DEVNAME(sc), sd->sd_meta->ssd_devname);

if (!sm) {
printf("%s: no in memory copy of metadata\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
goto bad;
}

/* meta scratchpad */
s = &smd[sd->sd_meta_type];
m = malloc(SR_META_SIZE64 * DEV_BSIZE(1 << 9), M_DEVBUF2, M_ZERO0x0008 | M_NOWAIT0x0002);
if (!m) {
printf("%s: could not allocate metadata scratch area\n",
    DEVNAME(sc)((sc)->sc_dev.dv_xname));
goto bad;
}

/* from here on out metadata is updated */
667restart:
sm->ssd_ondisk++;
sm->ssd_meta_flags = flags;
memcpy(m, sm, sizeof(*m))__builtin_memcpy((m), (sm), (sizeof(*m)));

/* Chunk metadata. */
cm = (struct sr_meta_chunk *)(m + 1);
for (i = 0; i < sm->ssdi_sdd_invariant.ssd_chunk_no; i++) {
src = sd->sd_vol.sv_chunks[i];
memcpy(cm, &src->src_meta, sizeof(*cm))__builtin_memcpy((cm), (&src->src_meta), (sizeof(*cm))
);
cm++;
}

/* Optional metadata. */
omh = (struct sr_meta_opt_hdr *)(cm);
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)) {
DNPRINTF(SR_D_META, "%s: saving optional metadata type %u with "
    "length %u\n", DEVNAME(sc), omi->omi_som->som_type,
    omi->omi_som->som_length);
bzero(&omi->omi_som->som_checksum, MD5_DIGEST_LENGTH)__builtin_bzero((&omi->omi_som->som_checksum), (16)
);
sr_checksum(sc, omi->omi_som, &omi->omi_som->som_checksum,
    omi->omi_som->som_length);
memcpy(omh, omi->omi_som, omi->omi_som->som_length)__builtin_memcpy((omh), (omi->omi_som), (omi->omi_som->
som_length));
omh = (struct sr_meta_opt_hdr *)((u_int8_t *)omh +
    omi->omi_som->som_length);
}

for (i = 0; i < sm->ssdi_sdd_invariant.ssd_chunk_no; i++) {
src = sd->sd_vol.sv_chunks[i];

/* skip disks that are offline */
if (src->src_meta.scm_status == BIOC_SDOFFLINE0x01)
	continue;

/* calculate metadata checksum for correct chunk */
m->ssdi_sdd_invariant.ssd_chunk_id = i;
sr_checksum(sc, m, &m->ssd_checksum,
    sizeof(struct sr_meta_invariant));

706#ifdef SR_DEBUG
DNPRINTF(SR_D_META, "%s: sr_meta_save %s: volid: %d "
    "chunkid: %d checksum: ",
    DEVNAME(sc), src->src_meta.scmi.scm_devname,
    m->ssdi.ssd_volid, m->ssdi.ssd_chunk_id);

if (sr_debug & SR_D_META)
	sr_checksum_print((u_int8_t *)&m->ssd_checksum);
DNPRINTF(SR_D_META, "\n");
sr_meta_print(m);
716#endif

/* translate and write to disk */
if (s->smd_write(sd, src->src_dev_mm, m, NULL((void *)0) /* XXX */)) {
	printf("%s: could not write metadata to %s\n",
	    DEVNAME(sc)((sc)->sc_dev.dv_xname), src->src_devname);
	/* restart the meta write */
	src->src_meta.scm_status = BIOC_SDOFFLINE0x01;
	/* XXX recalculate volume status */
	goto restart;
}
}

/* not all disciplines have sync */
if (sd->sd_scsi_sync) {
bzero(&wu, sizeof(wu))__builtin_bzero((&wu), (sizeof(wu)));
wu.swu_flags |= SR_WUF_FAKE(1<<6);
wu.swu_dis = sd;
sd->sd_scsi_sync(&wu);
}
free(m, M_DEVBUF2, SR_META_SIZE64 * DEV_BSIZE(1 << 9));
return (0);
738bad:
return (1);
740}

742int
743sr_meta_read(struct sr_discipline *sd)
744{
struct sr_softc		*sc = sd->sd_sc;
struct sr_chunk_head	*cl = &sd->sd_vol.sv_chunk_list;
struct sr_metadata	*sm;
struct sr_chunk		*ch_entry;
struct sr_meta_chunk	*cp;
struct sr_meta_driver	*s;
void			*fm = NULL((void *)0);
int			no_disk = 0, got_meta = 0;

DNPRINTF(SR_D_META, "%s: sr_meta_read\n", DEVNAME(sc));

sm = malloc(SR_META_SIZE64 * DEV_BSIZE(1 << 9), M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
s = &smd[sd->sd_meta_type];
if (sd->sd_meta_type != SR_META_F_NATIVE0)
fm = malloc(s->smd_size, M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);

cp = (struct sr_meta_chunk *)(sm + 1);
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)) {
/* skip disks that are offline */
if (ch_entry->src_meta.scm_status == BIOC_SDOFFLINE0x01) {
	DNPRINTF(SR_D_META,
	    "%s: %s chunk marked offline, spoofing status\n",
	    DEVNAME(sc), ch_entry->src_devname);
	cp++; /* adjust chunk pointer to match failure */
	continue;
} else if (s->smd_read(sd, ch_entry->src_dev_mm, sm, fm)) {
	/* read and translate */
	/* XXX mark chunk offline, elsewhere!! */
	ch_entry->src_meta.scm_status = BIOC_SDOFFLINE0x01;
	cp++; /* adjust chunk pointer to match failure */
	DNPRINTF(SR_D_META, "%s: sr_meta_read failed\n",
	    DEVNAME(sc));
	continue;
}

if (sm->ssdi_sdd_invariant.ssd_magic != SR_MAGIC0x4d4152436372616dLLU) {
	DNPRINTF(SR_D_META, "%s: sr_meta_read !SR_MAGIC\n",
	    DEVNAME(sc));
	continue;
}

/* validate metadata */
if (sr_meta_validate(sd, ch_entry->src_dev_mm, sm, fm)) {
	DNPRINTF(SR_D_META, "%s: invalid metadata\n",
	    DEVNAME(sc));
	no_disk = -1;
	goto done;
}

/* assume first chunk contains metadata */
if (got_meta == 0) {
	sr_meta_opt_load(sc, sm, &sd->sd_meta_opt);
	memcpy(sd->sd_meta, sm, sizeof(*sd->sd_meta))__builtin_memcpy((sd->sd_meta), (sm), (sizeof(*sd->sd_meta
)));
	got_meta = 1;
}

memcpy(&ch_entry->src_meta, cp, sizeof(ch_entry->src_meta))__builtin_memcpy((&ch_entry->src_meta), (cp), (sizeof(
ch_entry->src_meta)));

no_disk++;
cp++;
}

free(sm, M_DEVBUF2, SR_META_SIZE64 * DEV_BSIZE(1 << 9));
free(fm, M_DEVBUF2, s->smd_size);

810done:
DNPRINTF(SR_D_META, "%s: sr_meta_read found %d parts\n", DEVNAME(sc),
   no_disk);
return (no_disk);
814}

816void
817sr_meta_opt_load(struct sr_softc *sc, struct sr_metadata *sm,
  struct sr_meta_opt_head *som)
819{
struct sr_meta_opt_hdr	*omh;
struct sr_meta_opt_item *omi;
u_int8_t		checksum[MD5_DIGEST_LENGTH16];
int			i;

/* Process optional metadata. */
omh = (struct sr_meta_opt_hdr *)((u_int8_t *)(sm + 1) +
   sizeof(struct sr_meta_chunk) * sm->ssdi_sdd_invariant.ssd_chunk_no);
for (i = 0; i < sm->ssdi_sdd_invariant.ssd_opt_no; i++) {

omi = malloc(sizeof(struct sr_meta_opt_item), M_DEVBUF2,
    M_WAITOK0x0001 | M_ZERO0x0008);
SLIST_INSERT_HEAD(som, omi, omi_link)do { (omi)->omi_link.sle_next = (som)->slh_first; (som)
->slh_first = (omi); } while (0);

if (omh->som_length == 0) {

	/* Load old fixed length optional metadata. */
	DNPRINTF(SR_D_META, "%s: old optional metadata of type "
	    "%u\n", DEVNAME(sc), omh->som_type);

	/* Validate checksum. */
	sr_checksum(sc, (void *)omh, &checksum,
	    SR_OLD_META_OPT_SIZE2480 - MD5_DIGEST_LENGTH16);
	if (bcmp(&checksum, (void *)omh + SR_OLD_META_OPT_MD5(2480 - 16),
	    sizeof(checksum)))
		panic("%s: invalid optional metadata checksum",
		    DEVNAME(sc)((sc)->sc_dev.dv_xname));

	/* Determine correct length. */
	switch (omh->som_type) {
	case SR_OPT_CRYPTO0x01:
		omh->som_length = sizeof(struct sr_meta_crypto);
		break;
	case SR_OPT_BOOT0x02:
		omh->som_length = sizeof(struct sr_meta_boot);
		break;
	case SR_OPT_KEYDISK0x03:
		omh->som_length =
		    sizeof(struct sr_meta_keydisk);
		break;
	default:
		panic("unknown old optional metadata type %u",
		    omh->som_type);
	}

	omi->omi_som = malloc(omh->som_length, M_DEVBUF2,
	    M_WAITOK0x0001 | M_ZERO0x0008);
	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)))
	    (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)))
	    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)));
	omi->omi_som->som_type = omh->som_type;
	omi->omi_som->som_length = omh->som_length;

	omh = (struct sr_meta_opt_hdr *)((void *)omh +
	    SR_OLD_META_OPT_SIZE2480);
} else {

	/* Load variable length optional metadata. */
	DNPRINTF(SR_D_META, "%s: optional metadata of type %u, "
	    "length %u\n", DEVNAME(sc), omh->som_type,
	    omh->som_length);
	omi->omi_som = malloc(omh->som_length, M_DEVBUF2,
	    M_WAITOK0x0001 | M_ZERO0x0008);
	memcpy(omi->omi_som, omh, omh->som_length)__builtin_memcpy((omi->omi_som), (omh), (omh->som_length
));

	/* Validate checksum. */
	memcpy(&checksum, &omi->omi_som->som_checksum,__builtin_memcpy((&checksum), (&omi->omi_som->som_checksum
), (16))
	    MD5_DIGEST_LENGTH)__builtin_memcpy((&checksum), (&omi->omi_som->som_checksum
), (16));
	bzero(&omi->omi_som->som_checksum, MD5_DIGEST_LENGTH)__builtin_bzero((&omi->omi_som->som_checksum), (16)
);
	sr_checksum(sc, omi->omi_som,
	    &omi->omi_som->som_checksum, omh->som_length);
	if (bcmp(&checksum, &omi->omi_som->som_checksum,
	    sizeof(checksum)))
		panic("%s: invalid optional metadata checksum",
		    DEVNAME(sc)((sc)->sc_dev.dv_xname));

	omh = (struct sr_meta_opt_hdr *)((void *)omh +
	    omh->som_length);
}
}
900}

902int
903sr_meta_validate(struct sr_discipline *sd, dev_t dev, struct sr_metadata *sm,
  void *fm)
905{
struct sr_softc		*sc = sd->sd_sc;
struct sr_meta_driver	*s;
908#ifdef SR_DEBUG
struct sr_meta_chunk	*mc;
910#endif
u_int8_t		checksum[MD5_DIGEST_LENGTH16];
char			devname[32];
int			rv = 1;

DNPRINTF(SR_D_META, "%s: sr_meta_validate(%p)\n", DEVNAME(sc), sm);

sr_meta_getdevname(sc, dev, devname, sizeof(devname));

s = &smd[sd->sd_meta_type];
if (sd->sd_meta_type != SR_META_F_NATIVE0)
if (s->smd_validate(sd, sm, fm)) {
	sr_error(sc, "invalid foreign metadata");
	goto done;
}

/*
* at this point all foreign metadata has been translated to the native
* format and will be treated just like the native format
*/

if (sm->ssdi_sdd_invariant.ssd_magic != SR_MAGIC0x4d4152436372616dLLU) {
sr_error(sc, "not valid softraid metadata");
goto done;
}

/* Verify metadata checksum. */
sr_checksum(sc, sm, &checksum, sizeof(struct sr_meta_invariant));
if (bcmp(&checksum, &sm->ssd_checksum, sizeof(checksum))) {
sr_error(sc, "invalid metadata checksum");
goto done;
}

/* Handle changes between versions. */
if (sm->ssdi_sdd_invariant.ssd_version == 3) {

/*
 * Version 3 - update metadata version and fix up data blkno
 * value since this did not exist in version 3.
 */
if (sm->ssd_data_blkno == 0)
	sm->ssd_data_blkno = SR_META_V3_DATA_OFFSET(16 + 64);
sm->ssdi_sdd_invariant.ssd_secsize = DEV_BSIZE(1 << 9);

} else if (sm->ssdi_sdd_invariant.ssd_version == 4) {

/*
 * Version 4 - original metadata format did not store
 * data blkno so fix this up if necessary.
 */
if (sm->ssd_data_blkno == 0)
	sm->ssd_data_blkno = SR_DATA_OFFSET(16 + (64 + (320 + 128)));
sm->ssdi_sdd_invariant.ssd_secsize = DEV_BSIZE(1 << 9);

} else if (sm->ssdi_sdd_invariant.ssd_version == 5) {

/*
 * Version 5 - variable length optional metadata. Migration
 * from earlier fixed length optional metadata is handled
 * in sr_meta_read().
 */
sm->ssdi_sdd_invariant.ssd_secsize = DEV_BSIZE(1 << 9);

} else if (sm->ssdi_sdd_invariant.ssd_version == SR_META_VERSION6) {

/*
 * Version 6 - store & report a sector size.
 */

} else {

sr_error(sc, "cannot read metadata version %u on %s, "
    "expected version %u or earlier",
    sm->ssdi_sdd_invariant.ssd_version, devname, SR_META_VERSION6);
goto done;

}

/* Update version number and revision string. */
sm->ssdi_sdd_invariant.ssd_version = SR_META_VERSION6;
snprintf(sm->ssdi_sdd_invariant.ssd_revision, sizeof(sm->ssdi_sdd_invariant.ssd_revision),
   "%03d", SR_META_VERSION6);

993#ifdef SR_DEBUG
/* warn if disk changed order */
mc = (struct sr_meta_chunk *)(sm + 1);
if (strncmp(mc[sm->ssdi_sdd_invariant.ssd_chunk_id].scmi_scm_invariant.scm_devname, devname,
   sizeof(mc[sm->ssdi_sdd_invariant.ssd_chunk_id].scmi_scm_invariant.scm_devname)))
DNPRINTF(SR_D_META, "%s: roaming device %s -> %s\n",
    DEVNAME(sc), mc[sm->ssdi.ssd_chunk_id].scmi.scm_devname,
    devname);
1001#endif

/* we have meta data on disk */
DNPRINTF(SR_D_META, "%s: sr_meta_validate valid metadata %s\n",
   DEVNAME(sc), devname);

rv = 0;
1008done:
return (rv);
1010}

1012int
1013sr_meta_native_bootprobe(struct sr_softc *sc, dev_t devno,
  struct sr_boot_chunk_head *bch)
1015{
struct vnode		*vn;
struct disklabel	label;
struct sr_metadata	*md = NULL((void *)0);
struct sr_discipline	*fake_sd = NULL((void *)0);
struct sr_boot_chunk	*bc;
char			devname[32];
dev_t			chrdev, rawdev;
int			error, i;
int			rv = SR_META_NOTCLAIMED(0);

DNPRINTF(SR_D_META, "%s: sr_meta_native_bootprobe\n", DEVNAME(sc));

/*
* Use character raw device to avoid SCSI complaints about missing
* media on removable media devices.
*/
chrdev = blktochr(devno);
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))));
if (cdevvp(rawdev, &vn)) {
9
←
Assuming the condition is false→
10
←
Taking false branch→
sr_error(sc, "sr_meta_native_bootprobe: cannot allocate vnode");
goto done;
}

/* open device */
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);
if (error) {
11
←
Assuming 'error' is 0→
12
←
Taking false branch→
DNPRINTF(SR_D_META, "%s: sr_meta_native_bootprobe open "
    "failed\n", DEVNAME(sc));
vput(vn);
goto done;
}

/* get disklabel */
error = VOP_IOCTL(vn, DIOCGDINFO((unsigned long)0x40000000 | ((sizeof(struct disklabel) &
 0x1fff) << 16) | ((('d')) << 8) | ((101))), (caddr_t)&label, 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);
if (error) {
13
←
Assuming 'error' is 0→
14
←
Taking false branch→
DNPRINTF(SR_D_META, "%s: sr_meta_native_bootprobe ioctl "
    "failed\n", DEVNAME(sc));
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);
vput(vn);
goto done;
}

/* we are done, close device */
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);
if (error) {
15
←
Assuming 'error' is 0→
16
←
Taking false branch→
DNPRINTF(SR_D_META, "%s: sr_meta_native_bootprobe close "
    "failed\n", DEVNAME(sc));
vput(vn);
goto done;
}
vput(vn);

md = malloc(SR_META_SIZE64 * DEV_BSIZE(1 << 9), M_DEVBUF2, M_ZERO0x0008 | M_NOWAIT0x0002);
if (md == NULL((void *)0)) {
17
←
Assuming 'md' is not equal to NULL→
18
←
Taking false branch→
sr_error(sc, "not enough memory for metadata buffer");
goto done;
}

/* create fake sd to use utility functions */
fake_sd = malloc(sizeof(struct sr_discipline), M_DEVBUF2,
   M_ZERO0x0008 | M_NOWAIT0x0002);
if (fake_sd == NULL((void *)0)) {
19
←
Assuming 'fake_sd' is not equal to NULL→
20
←
Taking false branch→
sr_error(sc, "not enough memory for fake discipline");
goto done;
}
fake_sd->sd_sc = sc;
fake_sd->sd_meta_type = SR_META_F_NATIVE0;

for (i = 0; i < MAXPARTITIONS16; i++) {
21
←
Loop condition is true.  Entering loop body→
35
←
Loop condition is true.  Entering loop body→
if (label.d_partitions[i].p_fstype != FS_RAID19)
22
←
Assuming field 'p_fstype' is equal to FS_RAID→
23
←
Taking false branch→
36
←
Assuming field 'p_fstype' is equal to FS_RAID→
37
←
Taking false branch→
	continue;

/* open partition */
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))));
if (bdevvp(rawdev, &vn)) {
24
←
Assuming the condition is false→
25
←
Taking false branch→
38
←
Assuming the condition is true→
39
←
Taking true branch→
	sr_error(sc, "sr_meta_native_bootprobe: cannot "
	    "allocate vnode for partition");
	goto done;
40
←
Control jumps to line 1139→
}
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);
if (error) {
26
←
Assuming 'error' is 0→
27
←
Taking false branch→
	DNPRINTF(SR_D_META, "%s: sr_meta_native_bootprobe "
	    "open failed, partition %d\n",
	    DEVNAME(sc), i);
	vput(vn);
	continue;
}

if (sr_meta_native_read(fake_sd, rawdev, md, NULL((void *)0))) {
28
←
Assuming the condition is false→
29
←
Taking false branch→
	sr_error(sc, "native bootprobe could not read native "
	    "metadata");
	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);
	vput(vn);
	continue;
}

/* are we a softraid partition? */
if (md->ssdi_sdd_invariant.ssd_magic != SR_MAGIC0x4d4152436372616dLLU) {
30
←
Assuming field 'ssd_magic' is equal to SR_MAGIC→
31
←
Taking false branch→
	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);
	vput(vn);
	continue;
}

sr_meta_getdevname(sc, rawdev, devname, sizeof(devname));
if (sr_meta_validate(fake_sd, rawdev, md, NULL((void *)0)) == 0) {
32
←
Taking true branch→
	/* XXX fix M_WAITOK, this is boot time */
	bc = malloc(sizeof(struct sr_boot_chunk),
33
←
Memory is allocated→
	    M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
	bc->sbc_metadata = malloc(sizeof(struct sr_metadata),
	    M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
	memcpy(bc->sbc_metadata, md, sizeof(struct sr_metadata))__builtin_memcpy((bc->sbc_metadata), (md), (sizeof(struct sr_metadata
)));
	bc->sbc_mm = rawdev;
	SLIST_INSERT_HEAD(bch, bc, sbc_link)do { (bc)->sbc_link.sle_next = (bch)->slh_first; (bch)->
slh_first = (bc); } while (0);
34
←
Loop condition is false.  Exiting loop→
	rv = SR_META_CLAIMED(1);
}

/* we are done, close partition */
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);
vput(vn);
}

1138done:
free(fake_sd, M_DEVBUF2, sizeof(struct sr_discipline));
free(md, M_DEVBUF2, SR_META_SIZE64 * DEV_BSIZE(1 << 9));

return (rv);
1143}

1145int
1146sr_boot_assembly(struct sr_softc *sc)
1147{
struct sr_boot_volume_head bvh;
struct sr_boot_chunk_head bch, kdh;
struct sr_boot_volume	*bv, *bv1, *bv2;
struct sr_boot_chunk	*bc, *bcnext, *bc1, *bc2;
struct sr_disk_head	sdklist;
struct sr_disk		*sdk;
struct disk		*dk;
struct bioc_createraid	bcr;
struct sr_meta_chunk	*hm;
struct sr_chunk_head	*cl;
struct sr_chunk		*hotspare, *chunk, *last;
u_int64_t		*ondisk = NULL((void *)0);
dev_t			*devs = NULL((void *)0);
void			*data;
char			devname[32];
int			rv = 0, i;

DNPRINTF(SR_D_META, "%s: sr_boot_assembly\n", DEVNAME(sc));

SLIST_INIT(&sdklist){ ((&sdklist)->slh_first) = ((void *)0); };
SLIST_INIT(&bvh){ ((&bvh)->slh_first) = ((void *)0); };
SLIST_INIT(&bch){ ((&bch)->slh_first) = ((void *)0); };
SLIST_INIT(&kdh){ ((&kdh)->slh_first) = ((void *)0); };

dk = TAILQ_FIRST(&disklist)((&disklist)->tqh_first);
while (dk != NULL((void *)0)) {
1
Assuming 'dk' is not equal to NULL→
2
←
Loop condition is true.  Entering loop body→
42
←
Assuming 'dk' is equal to NULL→
43
←
Loop condition is false. Execution continues on line 1215→

/* See if this disk has been checked. */
SLIST_FOREACH(sdk, &sdklist, sdk_link)for((sdk) = ((&sdklist)->slh_first); (sdk) != ((void *
)0); (sdk) = ((sdk)->sdk_link.sle_next))
	if (sdk->sdk_devno == dk->dk_devno)
		break;

if (sdk2.1
'sdk' is equal to NULL
 != NULL((void *)0) || dk->dk_devno == NODEV(dev_t)(-1)) {
3
←
Assuming the condition is false→
4
←
Taking false branch→
	dk = TAILQ_NEXT(dk, dk_link)((dk)->dk_link.tqe_next);
	continue;
}

/* Add this disk to the list that we've checked. */
sdk = malloc(sizeof(struct sr_disk), M_DEVBUF2,
    M_NOWAIT0x0002 | M_ZERO0x0008);
if (sdk == NULL((void *)0))
5
←
Assuming 'sdk' is not equal to NULL→
6
←
Taking false branch→
	goto unwind;
sdk->sdk_devno = dk->dk_devno;
SLIST_INSERT_HEAD(&sdklist, sdk, sdk_link)do { (sdk)->sdk_link.sle_next = (&sdklist)->slh_first
; (&sdklist)->slh_first = (sdk); } while (0);

/* Only check sd(4) and wd(4) devices. */
if (strncmp(dk->dk_name, "sd", 2) &&
7
←
Assuming the condition is false→
    strncmp(dk->dk_name, "wd", 2)) {
	dk = TAILQ_NEXT(dk, dk_link)((dk)->dk_link.tqe_next);
	continue;
}

/* native softraid uses partitions */
rw_enter_write(&sc->sc_lock);
bio_status_init(&sc->sc_status, &sc->sc_dev);
sr_meta_native_bootprobe(sc, dk->dk_devno, &bch);
8
←
Calling 'sr_meta_native_bootprobe'→
41
←
Returned allocated memory→
rw_exit_write(&sc->sc_lock);

/* probe non-native disks if native failed. */

/* Restart scan since we may have slept. */
dk = TAILQ_FIRST(&disklist)((&disklist)->tqh_first);
}

/*
* Create a list of volumes and associate chunks with each volume.
*/
for (bc = SLIST_FIRST(&bch)((&bch)->slh_first); bc43.1
'bc' is not equal to NULL
 != NULL((void *)0); bc = bcnext) {
44
←
Loop condition is true.  Entering loop body→

bcnext = SLIST_NEXT(bc, sbc_link)((bc)->sbc_link.sle_next);
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);
45
←
Taking true branch→
46
←
Loop condition is false.  Exiting loop→
47
←
Loop condition is false.  Exiting loop→
bc->sbc_chunk_id = bc->sbc_metadata->ssdi_sdd_invariant.ssd_chunk_id;

/* Handle key disks separately. */
if (bc->sbc_metadata->ssdi_sdd_invariant.ssd_level == SR_KEYDISK_LEVEL0xfffffffe) {
48
←
Assuming field 'ssd_level' is not equal to SR_KEYDISK_LEVEL→
49
←
Taking false branch→
	SLIST_INSERT_HEAD(&kdh, bc, sbc_link)do { (bc)->sbc_link.sle_next = (&kdh)->slh_first; (
&kdh)->slh_first = (bc); } while (0);
	continue;
}

SLIST_FOREACH(bv, &bvh, sbv_link)for((bv) = ((&bvh)->slh_first); (bv) != ((void *)0); (
bv) = ((bv)->sbv_link.sle_next)) {
50
←
Loop condition is false. Execution continues on line 1234→
	if (bcmp(&bc->sbc_metadata->ssdi_sdd_invariant.ssd_uuid,
	    &bv->sbv_uuid,
	    sizeof(bc->sbc_metadata->ssdi_sdd_invariant.ssd_uuid)) == 0)
		break;
}

if (bv50.1
'bv' is equal to NULL
 == NULL((void *)0)) {
51
←
Taking true branch→
	bv = malloc(sizeof(struct sr_boot_volume),
	    M_DEVBUF2, M_NOWAIT0x0002 | M_ZERO0x0008);
	if (bv == NULL((void *)0)) {
52
←
Assuming 'bv' is equal to NULL→
53
←
Taking true branch→
		printf("%s: failed to allocate boot volume\n",
54
←
Potential leak of memory pointed to by 'bc'
		    DEVNAME(sc)((sc)->sc_dev.dv_xname));
		goto unwind;
	}

	bv->sbv_level = bc->sbc_metadata->ssdi_sdd_invariant.ssd_level;
	bv->sbv_volid = bc->sbc_metadata->ssdi_sdd_invariant.ssd_volid;
	bv->sbv_chunk_no = bc->sbc_metadata->ssdi_sdd_invariant.ssd_chunk_no;
	bv->sbv_flags = bc->sbc_metadata->ssdi_sdd_invariant.ssd_vol_flags;
	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)))
	    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)));
	SLIST_INIT(&bv->sbv_chunks){ ((&bv->sbv_chunks)->slh_first) = ((void *)0); };

	/* Maintain volume order. */
	bv2 = NULL((void *)0);
	SLIST_FOREACH(bv1, &bvh, sbv_link)for((bv1) = ((&bvh)->slh_first); (bv1) != ((void *)0);
 (bv1) = ((bv1)->sbv_link.sle_next)) {
		if (bv1->sbv_volid > bv->sbv_volid)
			break;
		bv2 = bv1;
	}
	if (bv2 == NULL((void *)0)) {
		DNPRINTF(SR_D_META, "%s: insert volume %u "
		    "at head\n", DEVNAME(sc), bv->sbv_volid);
		SLIST_INSERT_HEAD(&bvh, bv, sbv_link)do { (bv)->sbv_link.sle_next = (&bvh)->slh_first; (
&bvh)->slh_first = (bv); } while (0);
	} else {
		DNPRINTF(SR_D_META, "%s: insert volume %u "
		    "after %u\n", DEVNAME(sc), bv->sbv_volid,
		    bv2->sbv_volid);
		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);
	}
}

/* Maintain chunk order. */
bc2 = NULL((void *)0);
SLIST_FOREACH(bc1, &bv->sbv_chunks, sbc_link)for((bc1) = ((&bv->sbv_chunks)->slh_first); (bc1) !=
 ((void *)0); (bc1) = ((bc1)->sbc_link.sle_next)) {
	if (bc1->sbc_chunk_id > bc->sbc_chunk_id)
		break;
	bc2 = bc1;
}
if (bc2 == NULL((void *)0)) {
	DNPRINTF(SR_D_META, "%s: volume %u insert chunk %u "
	    "at head\n", DEVNAME(sc), bv->sbv_volid,
	    bc->sbc_chunk_id);
	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);
} else {
	DNPRINTF(SR_D_META, "%s: volume %u insert chunk %u "
	    "after %u\n", DEVNAME(sc), bv->sbv_volid,
	    bc->sbc_chunk_id, bc2->sbc_chunk_id);
	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);
}

bv->sbv_chunks_found++;
}

/* Allocate memory for device and ondisk version arrays. */
devs = mallocarray(BIOC_CRMAXLEN1024, sizeof(dev_t), M_DEVBUF2,
   M_NOWAIT0x0002);
if (devs == NULL((void *)0)) {
printf("%s: failed to allocate device array\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
goto unwind;
}
ondisk = mallocarray(BIOC_CRMAXLEN1024, sizeof(u_int64_t), M_DEVBUF2,
   M_NOWAIT0x0002);
if (ondisk == NULL((void *)0)) {
printf("%s: failed to allocate ondisk array\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
goto unwind;
}

/*
* Assemble hotspare "volumes".
*/
SLIST_FOREACH(bv, &bvh, sbv_link)for((bv) = ((&bvh)->slh_first); (bv) != ((void *)0); (
bv) = ((bv)->sbv_link.sle_next)) {

/* Check if this is a hotspare "volume". */
if (bv->sbv_level != SR_HOTSPARE_LEVEL0xffffffff ||
    bv->sbv_chunk_no != 1)
	continue;

1316#ifdef SR_DEBUG
DNPRINTF(SR_D_META, "%s: assembling hotspare volume ",
    DEVNAME(sc));
if (sr_debug & SR_D_META)
	sr_uuid_print(&bv->sbv_uuid, 0);
DNPRINTF(SR_D_META, " volid %u with %u chunks\n",
    bv->sbv_volid, bv->sbv_chunk_no);
1323#endif

/* Create hotspare chunk metadata. */
hotspare = malloc(sizeof(struct sr_chunk), M_DEVBUF2,
    M_NOWAIT0x0002 | M_ZERO0x0008);
if (hotspare == NULL((void *)0)) {
	printf("%s: failed to allocate hotspare\n",
	    DEVNAME(sc)((sc)->sc_dev.dv_xname));
	goto unwind;
}

bc = SLIST_FIRST(&bv->sbv_chunks)((&bv->sbv_chunks)->slh_first);
sr_meta_getdevname(sc, bc->sbc_mm, devname, sizeof(devname));
hotspare->src_dev_mm = bc->sbc_mm;
strlcpy(hotspare->src_devname, devname,
    sizeof(hotspare->src_devname));
hotspare->src_size = bc->sbc_metadata->ssdi_sdd_invariant.ssd_size;

hm = &hotspare->src_meta;
hm->scmi_scm_invariant.scm_volid = SR_HOTSPARE_VOLID0xffffffff;
hm->scmi_scm_invariant.scm_chunk_id = 0;
hm->scmi_scm_invariant.scm_size = bc->sbc_metadata->ssdi_sdd_invariant.ssd_size;
hm->scmi_scm_invariant.scm_coerced_size = bc->sbc_metadata->ssdi_sdd_invariant.ssd_size;
strlcpy(hm->scmi_scm_invariant.scm_devname, devname,
    sizeof(hm->scmi_scm_invariant.scm_devname));
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)))
    sizeof(struct sr_uuid))__builtin_memcpy((&hm->_scm_invariant.scm_uuid), (&
bc->sbc_metadata->_sdd_invariant.ssd_uuid), (sizeof(struct
 sr_uuid)));

sr_checksum(sc, hm, &hm->scm_checksum,
    sizeof(struct sr_meta_chunk_invariant));

hm->scm_status = BIOC_SDHOTSPARE0x04;

/* Add chunk to hotspare list. */
rw_enter_write(&sc->sc_hs_lock);
cl = &sc->sc_hotspare_list;
if (SLIST_EMPTY(cl)(((cl)->slh_first) == ((void *)0)))
	SLIST_INSERT_HEAD(cl, hotspare, src_link)do { (hotspare)->src_link.sle_next = (cl)->slh_first; (
cl)->slh_first = (hotspare); } while (0);
else {
	SLIST_FOREACH(chunk, cl, src_link)for((chunk) = ((cl)->slh_first); (chunk) != ((void *)0); (
chunk) = ((chunk)->src_link.sle_next))
		last = chunk;
	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);
}
sc->sc_hotspare_no++;
rw_exit_write(&sc->sc_hs_lock);

}

/*
* Assemble RAID volumes.
*/
SLIST_FOREACH(bv, &bvh, sbv_link)for((bv) = ((&bvh)->slh_first); (bv) != ((void *)0); (
bv) = ((bv)->sbv_link.sle_next)) {

bzero(&bcr, sizeof(bcr))__builtin_bzero((&bcr), (sizeof(bcr)));
data = NULL((void *)0);

/* Check if this is a hotspare "volume". */
if (bv->sbv_level == SR_HOTSPARE_LEVEL0xffffffff &&
    bv->sbv_chunk_no == 1)
	continue;

/*
 * Skip volumes that are marked as no auto assemble, unless
 * this was the volume which we actually booted from.
 */
if (bcmp(&sr_bootuuid, &bv->sbv_uuid, sizeof(sr_bootuuid)) != 0)
	if (bv->sbv_flags & BIOC_SCNOAUTOASSEMBLE0x04)
		continue;

1392#ifdef SR_DEBUG
DNPRINTF(SR_D_META, "%s: assembling volume ", DEVNAME(sc));
if (sr_debug & SR_D_META)
	sr_uuid_print(&bv->sbv_uuid, 0);
DNPRINTF(SR_D_META, " volid %u with %u chunks\n",
    bv->sbv_volid, bv->sbv_chunk_no);
1398#endif

/*
 * If this is a crypto volume, try to find a matching
 * key disk...
 */
bcr.bc_key_disk = NODEV(dev_t)(-1);
if (bv->sbv_level == 'C' || bv->sbv_level == 0x1C) {
	SLIST_FOREACH(bc, &kdh, sbc_link)for((bc) = ((&kdh)->slh_first); (bc) != ((void *)0); (
bc) = ((bc)->sbc_link.sle_next)) {
		if (bcmp(&bc->sbc_metadata->ssdi_sdd_invariant.ssd_uuid,
		    &bv->sbv_uuid,
		    sizeof(bc->sbc_metadata->ssdi_sdd_invariant.ssd_uuid))
		    == 0)
			bcr.bc_key_disk = bc->sbc_mm;
	}
}

for (i = 0; i < BIOC_CRMAXLEN1024; i++) {
	devs[i] = NODEV(dev_t)(-1); /* mark device as illegal */
	ondisk[i] = 0;
}

SLIST_FOREACH(bc, &bv->sbv_chunks, sbc_link)for((bc) = ((&bv->sbv_chunks)->slh_first); (bc) != (
(void *)0); (bc) = ((bc)->sbc_link.sle_next)) {
	if (devs[bc->sbc_chunk_id] != NODEV(dev_t)(-1)) {
		bv->sbv_chunks_found--;
		sr_meta_getdevname(sc, bc->sbc_mm, devname,
		    sizeof(devname));
		printf("%s: found duplicate chunk %u for "
		    "volume %u on device %s\n", DEVNAME(sc)((sc)->sc_dev.dv_xname),
		    bc->sbc_chunk_id, bv->sbv_volid, devname);
	}

	if (devs[bc->sbc_chunk_id] == NODEV(dev_t)(-1) ||
	    bc->sbc_metadata->ssd_ondisk >
	    ondisk[bc->sbc_chunk_id]) {
		devs[bc->sbc_chunk_id] = bc->sbc_mm;
		ondisk[bc->sbc_chunk_id] =
		    bc->sbc_metadata->ssd_ondisk;
		DNPRINTF(SR_D_META, "%s: using ondisk "
		    "metadata version %llu for chunk %u\n",
		    DEVNAME(sc), ondisk[bc->sbc_chunk_id],
		    bc->sbc_chunk_id);
	}
}

if (bv->sbv_chunk_no != bv->sbv_chunks_found) {
	printf("%s: not all chunks were provided; "
	    "attempting to bring volume %d online\n",
	    DEVNAME(sc)((sc)->sc_dev.dv_xname), bv->sbv_volid);
}

bcr.bc_level = bv->sbv_level;
bcr.bc_dev_list_len = bv->sbv_chunk_no * sizeof(dev_t);
bcr.bc_dev_list = devs;
bcr.bc_flags = BIOC_SCDEVT0x02 |
    (bv->sbv_flags & BIOC_SCNOAUTOASSEMBLE0x04);

if ((bv->sbv_level == 'C' || bv->sbv_level == 0x1C) &&
    bcmp(&sr_bootuuid, &bv->sbv_uuid, sizeof(sr_bootuuid)) == 0)
	data = sr_bootkey;

rw_enter_write(&sc->sc_lock);
bio_status_init(&sc->sc_status, &sc->sc_dev);
sr_ioctl_createraid(sc, &bcr, 0, data);
rw_exit_write(&sc->sc_lock);

rv++;
}

/* done with metadata */
1468unwind:
/* Free boot volumes and associated chunks. */
for (bv1 = SLIST_FIRST(&bvh)((&bvh)->slh_first); bv1 != NULL((void *)0); bv1 = bv2) {
bv2 = SLIST_NEXT(bv1, sbv_link)((bv1)->sbv_link.sle_next);
for (bc1 = SLIST_FIRST(&bv1->sbv_chunks)((&bv1->sbv_chunks)->slh_first); bc1 != NULL((void *)0);
    bc1 = bc2) {
	bc2 = SLIST_NEXT(bc1, sbc_link)((bc1)->sbc_link.sle_next);
	free(bc1->sbc_metadata, M_DEVBUF2,
	    sizeof(*bc1->sbc_metadata));
	free(bc1, M_DEVBUF2, sizeof(*bc1));
}
free(bv1, M_DEVBUF2, sizeof(*bv1));
}
/* Free keydisks chunks. */
for (bc1 = SLIST_FIRST(&kdh)((&kdh)->slh_first); bc1 != NULL((void *)0); bc1 = bc2) {
bc2 = SLIST_NEXT(bc1, sbc_link)((bc1)->sbc_link.sle_next);
free(bc1->sbc_metadata, M_DEVBUF2, sizeof(*bc1->sbc_metadata));
free(bc1, M_DEVBUF2, sizeof(*bc1));
}
/* Free unallocated chunks. */
for (bc1 = SLIST_FIRST(&bch)((&bch)->slh_first); bc1 != NULL((void *)0); bc1 = bc2) {
bc2 = SLIST_NEXT(bc1, sbc_link)((bc1)->sbc_link.sle_next);
free(bc1->sbc_metadata, M_DEVBUF2, sizeof(*bc1->sbc_metadata));
free(bc1, M_DEVBUF2, sizeof(*bc1));
}

while (!SLIST_EMPTY(&sdklist)(((&sdklist)->slh_first) == ((void *)0))) {
sdk = SLIST_FIRST(&sdklist)((&sdklist)->slh_first);
SLIST_REMOVE_HEAD(&sdklist, sdk_link)do { (&sdklist)->slh_first = (&sdklist)->slh_first
->sdk_link.sle_next; } while (0);
free(sdk, M_DEVBUF2, sizeof(*sdk));
}

free(devs, M_DEVBUF2, BIOC_CRMAXLEN1024 * sizeof(dev_t));
free(ondisk, M_DEVBUF2, BIOC_CRMAXLEN1024 * sizeof(u_int64_t));

return (rv);
1504}

1506void
1507sr_map_root(void)
1508{
struct sr_softc		*sc = softraid0;
struct sr_discipline	*sd;
struct sr_meta_opt_item	*omi;
struct sr_meta_boot	*sbm;
u_char			duid[8];
int			i;

if (sc == NULL((void *)0))
return;

DNPRINTF(SR_D_MISC, "%s: sr_map_root\n", DEVNAME(sc));

bzero(duid, sizeof(duid))__builtin_bzero((duid), (sizeof(duid)));
if (bcmp(rootduid, duid, sizeof(duid)) == 0) {
DNPRINTF(SR_D_MISC, "%s: root duid is zero\n", DEVNAME(sc));
return;
}

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)) {
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)) {
	if (omi->omi_som->som_type != SR_OPT_BOOT0x02)
		continue;
	sbm = (struct sr_meta_boot *)omi->omi_som;
	for (i = 0; i < SR_MAX_BOOT_DISKS16; i++) {
		if (bcmp(rootduid, sbm->sbm_boot_duid[i],
		    sizeof(rootduid)) == 0) {
			memcpy(rootduid, sbm->sbm_root_duid,__builtin_memcpy((rootduid), (sbm->sbm_root_duid), (sizeof
(rootduid)))
			    sizeof(rootduid))__builtin_memcpy((rootduid), (sbm->sbm_root_duid), (sizeof
(rootduid)));
			DNPRINTF(SR_D_MISC, "%s: root duid "
			    "mapped to %s\n", DEVNAME(sc),
			    duid_format(rootduid));
			return;
		}
	}
}
}
1545}

1547int
1548sr_meta_native_probe(struct sr_softc *sc, struct sr_chunk *ch_entry)
1549{
struct disklabel	label;
char			*devname;
int			error, part;
u_int64_t		size;

DNPRINTF(SR_D_META, "%s: sr_meta_native_probe(%s)\n",
  DEVNAME(sc), ch_entry->src_devname);

devname = ch_entry->src_devname;
part = DISKPART(ch_entry->src_dev_mm)(((unsigned)((ch_entry->src_dev_mm) & 0xff) | (((ch_entry
->src_dev_mm) & 0xffff0000) >> 8)) % 16);

/* get disklabel */
error = VOP_IOCTL(ch_entry->src_vn, DIOCGDINFO((unsigned long)0x40000000 | ((sizeof(struct disklabel) &
 0x1fff) << 16) | ((('d')) << 8) | ((101))), (caddr_t)&label, 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);
if (error) {
DNPRINTF(SR_D_META, "%s: %s can't obtain disklabel\n",
    DEVNAME(sc), devname);
goto unwind;
}
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)));

/* make sure the partition is of the right type */
if (label.d_partitions[part].p_fstype != FS_RAID19) {
DNPRINTF(SR_D_META,
    "%s: %s partition not of type RAID (%d)\n", DEVNAME(sc),
    devname,
    label.d_partitions[part].p_fstype);
goto unwind;
}

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)));
if (size <= SR_DATA_OFFSET(16 + (64 + (320 + 128)))) {
DNPRINTF(SR_D_META, "%s: %s partition too small\n", DEVNAME(sc),
    devname);
goto unwind;
}
size -= SR_DATA_OFFSET(16 + (64 + (320 + 128)));
if (size > INT64_MAX0x7fffffffffffffffLL) {
DNPRINTF(SR_D_META, "%s: %s partition too large\n", DEVNAME(sc),
    devname);
goto unwind;
}
ch_entry->src_size = size;
ch_entry->src_secsize = label.d_secsize;

DNPRINTF(SR_D_META, "%s: probe found %s size %lld\n", DEVNAME(sc),
   devname, (long long)size);

return (SR_META_F_NATIVE0);
1599unwind:
DNPRINTF(SR_D_META, "%s: invalid device: %s\n", DEVNAME(sc),
   devname ? devname : "nodev");
return (SR_META_F_INVALID-1);
1603}

1605int
1606sr_meta_native_attach(struct sr_discipline *sd, int force)
1607{
struct sr_softc		*sc = sd->sd_sc;
struct sr_chunk_head	*cl = &sd->sd_vol.sv_chunk_list;
struct sr_metadata	*md = NULL((void *)0);
struct sr_chunk		*ch_entry, *ch_next;
struct sr_uuid		uuid;
u_int64_t		version = 0;
int			sr, not_sr, rv = 1, d, expected = -1, old_meta = 0;

DNPRINTF(SR_D_META, "%s: sr_meta_native_attach\n", DEVNAME(sc));

md = malloc(SR_META_SIZE64 * DEV_BSIZE(1 << 9), M_DEVBUF2, M_ZERO0x0008 | M_NOWAIT0x0002);
if (md == NULL((void *)0)) {
sr_error(sc, "not enough memory for metadata buffer");
goto bad;
}

bzero(&uuid, sizeof uuid)__builtin_bzero((&uuid), (sizeof uuid));

sr = not_sr = d = 0;
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)) {
if (ch_entry->src_dev_mm == NODEV(dev_t)(-1))
	continue;

if (sr_meta_native_read(sd, ch_entry->src_dev_mm, md, NULL((void *)0))) {
	sr_error(sc, "could not read native metadata");
	goto bad;
}

if (md->ssdi_sdd_invariant.ssd_magic == SR_MAGIC0x4d4152436372616dLLU) {
	sr++;
	ch_entry->src_meta.scmi_scm_invariant.scm_chunk_id =
	    md->ssdi_sdd_invariant.ssd_chunk_id;
	if (d == 0) {
		memcpy(&uuid, &md->ssdi.ssd_uuid, sizeof uuid)__builtin_memcpy((&uuid), (&md->_sdd_invariant.ssd_uuid
), (sizeof uuid));
		expected = md->ssdi_sdd_invariant.ssd_chunk_no;
		version = md->ssd_ondisk;
		d++;
		continue;
	} else if (bcmp(&md->ssdi_sdd_invariant.ssd_uuid, &uuid,
	    sizeof uuid)) {
		sr_error(sc, "not part of the same volume");
		goto bad;
	}
	if (md->ssd_ondisk != version) {
		old_meta++;
		version = MAX(md->ssd_ondisk, version)(((md->ssd_ondisk)>(version))?(md->ssd_ondisk):(version
));
	}
} else
	not_sr++;
}

if (sr && not_sr && !force) {
sr_error(sc, "not all chunks are of the native metadata "
    "format");
goto bad;
}

/* mixed metadata versions; mark bad disks offline */
if (old_meta) {
d = 0;
for (ch_entry = SLIST_FIRST(cl)((cl)->slh_first); ch_entry != NULL((void *)0);
    ch_entry = ch_next, d++) {
	ch_next = SLIST_NEXT(ch_entry, src_link)((ch_entry)->src_link.sle_next);

	/* XXX do we want to read this again? */
	if (ch_entry->src_dev_mm == NODEV(dev_t)(-1))
		panic("src_dev_mm == NODEV");
	if (sr_meta_native_read(sd, ch_entry->src_dev_mm, md,
	    NULL((void *)0)))
		sr_warn(sc, "could not read native metadata");
	if (md->ssd_ondisk != version)
		sd->sd_vol.sv_chunks[d]->src_meta.scm_status =
		    BIOC_SDOFFLINE0x01;
}
}

if (expected != sr && !force && expected != -1) {
DNPRINTF(SR_D_META, "%s: not all chunks were provided, trying "
    "anyway\n", DEVNAME(sc));
}

rv = 0;
1690bad:
free(md, M_DEVBUF2, SR_META_SIZE64 * DEV_BSIZE(1 << 9));
return (rv);
1693}

1695int
1696sr_meta_native_read(struct sr_discipline *sd, dev_t dev,
  struct sr_metadata *md, void *fm)
1698{
1699#ifdef SR_DEBUG
struct sr_softc		*sc = sd->sd_sc;
1701#endif
DNPRINTF(SR_D_META, "%s: sr_meta_native_read(0x%x, %p)\n",
   DEVNAME(sc), dev, md);

return (sr_meta_rw(sd, dev, md, B_READ0x00008000));
1706}

1708int
1709sr_meta_native_write(struct sr_discipline *sd, dev_t dev,
  struct sr_metadata *md, void *fm)
1711{
1712#ifdef SR_DEBUG
struct sr_softc		*sc = sd->sd_sc;
1714#endif
DNPRINTF(SR_D_META, "%s: sr_meta_native_write(0x%x, %p)\n",
   DEVNAME(sc), dev, md);

return (sr_meta_rw(sd, dev, md, B_WRITE0x00000000));
1719}

1721void
1722sr_hotplug_register(struct sr_discipline *sd, void *func)
1723{
struct sr_hotplug_list	*mhe;

DNPRINTF(SR_D_MISC, "%s: sr_hotplug_register: %p\n",
   DEVNAME(sd->sd_sc), func);

/* make sure we aren't on the list yet */
SLIST_FOREACH(mhe, &sr_hotplug_callbacks, shl_link)for((mhe) = ((&sr_hotplug_callbacks)->slh_first); (mhe
) != ((void *)0); (mhe) = ((mhe)->shl_link.sle_next))
if (mhe->sh_hotplug == func)
	return;

mhe = malloc(sizeof(struct sr_hotplug_list), M_DEVBUF2,
   M_WAITOK0x0001 | M_ZERO0x0008);
mhe->sh_hotplug = func;
mhe->sh_sd = sd;
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}

1741void
1742sr_hotplug_unregister(struct sr_discipline *sd, void *func)
1743{
struct sr_hotplug_list	*mhe;

DNPRINTF(SR_D_MISC, "%s: sr_hotplug_unregister: %s %p\n",
   DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname, func);

/* make sure we are on the list yet */
SLIST_FOREACH(mhe, &sr_hotplug_callbacks, shl_link)for((mhe) = ((&sr_hotplug_callbacks)->slh_first); (mhe
) != ((void *)0); (mhe) = ((mhe)->shl_link.sle_next)) {
if (mhe->sh_hotplug == func)
	break;
}
if (mhe != NULL((void *)0)) {
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)
    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);
free(mhe, M_DEVBUF2, sizeof(*mhe));
}
1759}

1761void
1762sr_disk_attach(struct disk *diskp, int action)
1763{
struct sr_hotplug_list	*mhe;

SLIST_FOREACH(mhe, &sr_hotplug_callbacks, shl_link)for((mhe) = ((&sr_hotplug_callbacks)->slh_first); (mhe
) != ((void *)0); (mhe) = ((mhe)->shl_link.sle_next))
if (mhe->sh_sd->sd_ready)
	mhe->sh_hotplug(mhe->sh_sd, diskp, action);
1769}

1771int
1772sr_match(struct device *parent, void *match, void *aux)
1773{
return (1);
1775}

1777void
1778sr_attach(struct device *parent, struct device *self, void *aux)
1779{
struct sr_softc		*sc = (void *)self;
struct scsibus_attach_args saa;

DNPRINTF(SR_D_MISC, "\n%s: sr_attach", DEVNAME(sc));

if (softraid0 == NULL((void *)0))
softraid0 = sc;

rw_init(&sc->sc_lock, "sr_lock")_rw_init_flags(&sc->sc_lock, "sr_lock", 0, ((void *)0)
);
rw_init(&sc->sc_hs_lock, "sr_hs_lock")_rw_init_flags(&sc->sc_hs_lock, "sr_hs_lock", 0, ((void
 *)0));

SLIST_INIT(&sr_hotplug_callbacks){ ((&sr_hotplug_callbacks)->slh_first) = ((void *)0); };
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);
SLIST_INIT(&sc->sc_hotspare_list){ ((&sc->sc_hotspare_list)->slh_first) = ((void *)0
); };

1795#if NBIO1 > 0
if (bio_register(&sc->sc_dev, sr_bio_ioctl) != 0)
printf("%s: controller registration failed", DEVNAME(sc)((sc)->sc_dev.dv_xname));
1798#endif /* NBIO > 0 */

1800#ifndef SMALL_KERNEL
strlcpy(sc->sc_sensordev.xname, DEVNAME(sc)((sc)->sc_dev.dv_xname),
   sizeof(sc->sc_sensordev.xname));
sensordev_install(&sc->sc_sensordev);
1804#endif /* SMALL_KERNEL */

printf("\n");

saa.saa_adapter_softc = sc;
saa.saa_adapter = &sr_switch;
saa.saa_adapter_target = SDEV_NO_ADAPTER_TARGET0xffff;
saa.saa_adapter_buswidth = SR_MAX_LD256;
saa.saa_luns = 1;
saa.saa_openings = 0;
saa.saa_pool = NULL((void *)0);
saa.saa_quirks = saa.saa_flags = 0;
saa.saa_wwpn = saa.saa_wwnn = 0;

sc->sc_scsibus = (struct scsibus_softc *)config_found(&sc->sc_dev, &saa,config_found_sm((&sc->sc_dev), (&saa), (scsiprint)
, ((void *)0))
   scsiprint)config_found_sm((&sc->sc_dev), (&saa), (scsiprint)
, ((void *)0));

softraid_disk_attach = sr_disk_attach;

sr_boot_assembly(sc);

explicit_bzero(sr_bootkey, sizeof(sr_bootkey));
1826}

1828int
1829sr_detach(struct device *self, int flags)
1830{
struct sr_softc		*sc = (void *)self;
int			rv;

DNPRINTF(SR_D_MISC, "%s: sr_detach\n", DEVNAME(sc));

softraid_disk_attach = NULL((void *)0);

sr_shutdown(0);

1840#ifndef SMALL_KERNEL
if (sc->sc_sensor_task != NULL((void *)0))
sensor_task_unregister(sc->sc_sensor_task);
sensordev_deinstall(&sc->sc_sensordev);
1844#endif /* SMALL_KERNEL */

if (sc->sc_scsibus != NULL((void *)0)) {
rv = config_detach((struct device *)sc->sc_scsibus, flags);
if (rv != 0)
	return (rv);
sc->sc_scsibus = NULL((void *)0);
}

return (0);
1854}

1856void
1857sr_info(struct sr_softc *sc, const char *fmt, ...)
1858{
va_list			ap;

rw_assert_wrlock(&sc->sc_lock);

va_start(ap, fmt)__builtin_va_start((ap), fmt);
bio_status(&sc->sc_status, 0, BIO_MSG_INFO1, fmt, &ap);
va_end(ap)__builtin_va_end((ap));
1866}

1868void
1869sr_warn(struct sr_softc *sc, const char *fmt, ...)
1870{
va_list			ap;

rw_assert_wrlock(&sc->sc_lock);

va_start(ap, fmt)__builtin_va_start((ap), fmt);
bio_status(&sc->sc_status, 1, BIO_MSG_WARN2, fmt, &ap);
va_end(ap)__builtin_va_end((ap));
1878}

1880void
1881sr_error(struct sr_softc *sc, const char *fmt, ...)
1882{
va_list			ap;

rw_assert_wrlock(&sc->sc_lock);

va_start(ap, fmt)__builtin_va_start((ap), fmt);
bio_status(&sc->sc_status, 1, BIO_MSG_ERROR3, fmt, &ap);
va_end(ap)__builtin_va_end((ap));
1890}

1892int
1893sr_ccb_alloc(struct sr_discipline *sd)
1894{
struct sr_ccb		*ccb;
int			i;

if (!sd)
return (1);

DNPRINTF(SR_D_CCB, "%s: sr_ccb_alloc\n", DEVNAME(sd->sd_sc));

if (sd->sd_ccb)
return (1);

sd->sd_ccb = mallocarray(sd->sd_max_wu,
   sd->sd_max_ccb_per_wu * sizeof(struct sr_ccb),
   M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
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);
for (i = 0; i < sd->sd_max_wu * sd->sd_max_ccb_per_wu; i++) {
ccb = &sd->sd_ccb[i];
ccb->ccb_dis = sd;
sr_ccb_put(ccb);
}

DNPRINTF(SR_D_CCB, "%s: sr_ccb_alloc ccb: %d\n",
   DEVNAME(sd->sd_sc), sd->sd_max_wu * sd->sd_max_ccb_per_wu);

return (0);
1920}

1922void
1923sr_ccb_free(struct sr_discipline *sd)
1924{
struct sr_ccb		*ccb;

if (!sd)
return;

DNPRINTF(SR_D_CCB, "%s: sr_ccb_free %p\n", DEVNAME(sd->sd_sc), sd);

while ((ccb = TAILQ_FIRST(&sd->sd_ccb_freeq)((&sd->sd_ccb_freeq)->tqh_first)) != NULL((void *)0))
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);

free(sd->sd_ccb, M_DEVBUF2, sd->sd_max_wu * sd->sd_max_ccb_per_wu *
   sizeof(struct sr_ccb));
1937}

1939struct sr_ccb *
1940sr_ccb_get(struct sr_discipline *sd)
1941{
struct sr_ccb		*ccb;
int			s;

s = splbio()splraise(0x3);

ccb = TAILQ_FIRST(&sd->sd_ccb_freeq)((&sd->sd_ccb_freeq)->tqh_first);
if (ccb) {
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);
ccb->ccb_state = SR_CCB_INPROGRESS1;
}

splx(s)spllower(s);

DNPRINTF(SR_D_CCB, "%s: sr_ccb_get: %p\n", DEVNAME(sd->sd_sc),
   ccb);

return (ccb);
1959}

1961void
1962sr_ccb_put(struct sr_ccb *ccb)
1963{
struct sr_discipline	*sd = ccb->ccb_dis;
int			s;

DNPRINTF(SR_D_CCB, "%s: sr_ccb_put: %p\n", DEVNAME(sd->sd_sc),
   ccb);

s = splbio()splraise(0x3);

ccb->ccb_wu = NULL((void *)0);
ccb->ccb_state = SR_CCB_FREE0;
ccb->ccb_target = -1;
ccb->ccb_opaque = NULL((void *)0);

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
);

splx(s)spllower(s);
1980}

1982struct sr_ccb *
1983sr_ccb_rw(struct sr_discipline *sd, int chunk, daddr_t blkno,
  long len, u_int8_t *data, int xsflags, int ccbflags)
1985{
struct sr_chunk		*sc = sd->sd_vol.sv_chunks[chunk];
struct sr_ccb		*ccb = NULL((void *)0);
int			s;

ccb = sr_ccb_get(sd);
if (ccb == NULL((void *)0))
goto out;

ccb->ccb_flags = ccbflags;
ccb->ccb_target = chunk;

ccb->ccb_buf.b_flags = B_PHYS0x00002000 | B_CALL0x00000040;
if (ISSET(xsflags, SCSI_DATA_IN)((xsflags) & (0x00800)))
ccb->ccb_buf.b_flags |= B_READ0x00008000;
else
ccb->ccb_buf.b_flags |= B_WRITE0x00000000;

ccb->ccb_buf.b_blkno = blkno + sd->sd_meta->ssd_data_blkno;
ccb->ccb_buf.b_bcount = len;
ccb->ccb_buf.b_bufsize = len;
ccb->ccb_buf.b_resid = len;
ccb->ccb_buf.b_data = data;
ccb->ccb_buf.b_error = 0;
ccb->ccb_buf.b_iodone = sd->sd_scsi_intr;
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;
ccb->ccb_buf.b_dev = sc->src_dev_mm;
ccb->ccb_buf.b_vp = sc->src_vn;
ccb->ccb_buf.b_bq = NULL((void *)0);

if (!ISSET(ccb->ccb_buf.b_flags, B_READ)((ccb->ccb_buf.b_flags) & (0x00008000))) {
s = splbio()splraise(0x3);
ccb->ccb_buf.b_vp->v_numoutput++;
splx(s)spllower(s);
}

LIST_INIT(&ccb->ccb_buf.b_dep)do { ((&ccb->ccb_buf.b_dep)->lh_first) = ((void *)0
); } while (0);

DNPRINTF(SR_D_DIS, "%s: %s %s ccb "
   "b_bcount %ld b_blkno %lld b_flags 0x%0lx b_data %p\n",
   DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname, sd->sd_name,
   ccb->ccb_buf.b_bcount, (long long)ccb->ccb_buf.b_blkno,
   ccb->ccb_buf.b_flags, ccb->ccb_buf.b_data);

2029out:
return ccb;
2031}

2033void
2034sr_ccb_done(struct sr_ccb *ccb)
2035{
struct sr_workunit	*wu = ccb->ccb_wu;
struct sr_discipline	*sd = wu->swu_dis;
struct sr_softc		*sc = sd->sd_sc;

DNPRINTF(SR_D_INTR, "%s: %s %s ccb done b_bcount %ld b_resid %zu"
   " b_flags 0x%0lx block %lld target %d\n",
   DEVNAME(sc), sd->sd_meta->ssd_devname, sd->sd_name,
   ccb->ccb_buf.b_bcount, ccb->ccb_buf.b_resid, ccb->ccb_buf.b_flags,
   (long long)ccb->ccb_buf.b_blkno, ccb->ccb_target);

splassert(IPL_BIO)do { if (splassert_ctl > 0) { splassert_check(0x3, __func__
); } } while (0);

if (ccb->ccb_target == -1)
panic("%s: invalid target on wu: %p", DEVNAME(sc)((sc)->sc_dev.dv_xname), wu);

if (ccb->ccb_buf.b_flags & B_ERROR0x00000400) {
DNPRINTF(SR_D_INTR, "%s: i/o error on block %lld target %d\n",
    DEVNAME(sc), (long long)ccb->ccb_buf.b_blkno,
    ccb->ccb_target);
if (ISSET(sd->sd_capabilities, SR_CAP_REDUNDANT)((sd->sd_capabilities) & (0x00000010)))
	sd->sd_set_chunk_state(sd, ccb->ccb_target,
	    BIOC_SDOFFLINE0x01);
else
	printf("%s: %s: i/o error %d @ %s block %lld\n",
	    DEVNAME(sc)((sc)->sc_dev.dv_xname), sd->sd_meta->ssd_devname,
	    ccb->ccb_buf.b_error, sd->sd_name,
	    (long long)ccb->ccb_buf.b_blkno);
ccb->ccb_state = SR_CCB_FAILED3;
wu->swu_ios_failed++;
} else {
ccb->ccb_state = SR_CCB_OK2;
wu->swu_ios_succeeded++;
}

wu->swu_ios_complete++;
2071}

2073int
2074sr_wu_alloc(struct sr_discipline *sd)
2075{
struct sr_workunit	*wu;
int			i, no_wu;

DNPRINTF(SR_D_WU, "%s: sr_wu_alloc %p %d\n", DEVNAME(sd->sd_sc),
   sd, sd->sd_max_wu);

no_wu = sd->sd_max_wu;
sd->sd_wu_pending = no_wu;

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);
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);
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);
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);
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);

for (i = 0; i < no_wu; i++) {
wu = malloc(sd->sd_wu_size, M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
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);
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);
wu->swu_dis = sd;
task_set(&wu->swu_task, sr_wu_done_callback, wu);
sr_wu_put(sd, wu);
}

return (0);
2101}

2103void
2104sr_wu_free(struct sr_discipline *sd)
2105{
struct sr_workunit	*wu;

DNPRINTF(SR_D_WU, "%s: sr_wu_free %p\n", DEVNAME(sd->sd_sc), sd);

while ((wu = TAILQ_FIRST(&sd->sd_wu_freeq)((&sd->sd_wu_freeq)->tqh_first)) != NULL((void *)0))
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);
while ((wu = TAILQ_FIRST(&sd->sd_wu_pendq)((&sd->sd_wu_pendq)->tqh_first)) != NULL((void *)0))
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);
while ((wu = TAILQ_FIRST(&sd->sd_wu_defq)((&sd->sd_wu_defq)->tqh_first)) != NULL((void *)0))
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);

while ((wu = TAILQ_FIRST(&sd->sd_wu)((&sd->sd_wu)->tqh_first)) != NULL((void *)0)) {
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);
free(wu, M_DEVBUF2, sd->sd_wu_size);
}
2121}

2123void *
2124sr_wu_get(void *xsd)
2125{
struct sr_discipline	*sd = (struct sr_discipline *)xsd;
struct sr_workunit	*wu;

mtx_enter(&sd->sd_wu_mtx);
wu = TAILQ_FIRST(&sd->sd_wu_freeq)((&sd->sd_wu_freeq)->tqh_first);
if (wu) {
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);
sd->sd_wu_pending++;
}
mtx_leave(&sd->sd_wu_mtx);

DNPRINTF(SR_D_WU, "%s: sr_wu_get: %p\n", DEVNAME(sd->sd_sc), wu);

return (wu);
2140}

2142void
2143sr_wu_put(void *xsd, void *xwu)
2144{
struct sr_discipline	*sd = (struct sr_discipline *)xsd;
struct sr_workunit	*wu = (struct sr_workunit *)xwu;

DNPRINTF(SR_D_WU, "%s: sr_wu_put: %p\n", DEVNAME(sd->sd_sc), wu);

sr_wu_release_ccbs(wu);
sr_wu_init(sd, wu);

mtx_enter(&sd->sd_wu_mtx);
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);
sd->sd_wu_pending--;
mtx_leave(&sd->sd_wu_mtx);
2157}

2159void
2160sr_wu_init(struct sr_discipline *sd, struct sr_workunit *wu)
2161{
int			s;

s = splbio()splraise(0x3);
if (wu->swu_cb_active == 1)
panic("%s: sr_wu_init got active wu", DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname));
splx(s)spllower(s);

wu->swu_xs = NULL((void *)0);
wu->swu_state = SR_WU_FREE0;
wu->swu_flags = 0;
wu->swu_blk_start = 0;
wu->swu_blk_end = 0;
wu->swu_collider = NULL((void *)0);
2175}

2177void
2178sr_wu_enqueue_ccb(struct sr_workunit *wu, struct sr_ccb *ccb)
2179{
struct sr_discipline	*sd = wu->swu_dis;
int			s;

s = splbio()splraise(0x3);
if (wu->swu_cb_active == 1)
panic("%s: sr_wu_enqueue_ccb got active wu",
    DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname));
ccb->ccb_wu = wu;
wu->swu_io_count++;
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);
splx(s)spllower(s);
2191}

2193void
2194sr_wu_release_ccbs(struct sr_workunit *wu)
2195{
struct sr_ccb		*ccb;

/* Return all ccbs that are associated with this workunit. */
while ((ccb = TAILQ_FIRST(&wu->swu_ccb)((&wu->swu_ccb)->tqh_first)) != NULL((void *)0)) {
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);
sr_ccb_put(ccb);
}

wu->swu_io_count = 0;
wu->swu_ios_complete = 0;
wu->swu_ios_failed = 0;
wu->swu_ios_succeeded = 0;
2208}

2210void
2211sr_wu_done(struct sr_workunit *wu)
2212{
struct sr_discipline	*sd = wu->swu_dis;

DNPRINTF(SR_D_INTR, "%s: sr_wu_done count %d completed %d failed %d\n",
   DEVNAME(sd->sd_sc), wu->swu_io_count, wu->swu_ios_complete,
   wu->swu_ios_failed);

if (wu->swu_ios_complete < wu->swu_io_count)
return;

task_add(sd->sd_taskq, &wu->swu_task);
2223}

2225void
2226sr_wu_done_callback(void *xwu)
2227{
struct sr_workunit	*wu = xwu;
struct sr_discipline	*sd = wu->swu_dis;
struct scsi_xfer	*xs = wu->swu_xs;
struct sr_workunit	*wup;
int			s;

/*
* The SR_WUF_DISCIPLINE or SR_WUF_REBUILD flag must be set if
* the work unit is not associated with a scsi_xfer.
*/
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))"
))
   (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))"
));

s = splbio()splraise(0x3);

if (xs != NULL((void *)0)) {
if (wu->swu_ios_failed)
	xs->error = XS_DRIVER_STUFFUP2;
else
	xs->error = XS_NOERROR0;
}

if (sd->sd_scsi_wu_done) {
if (sd->sd_scsi_wu_done(wu) == SR_WU_RESTART7)
	goto done;
}

/* Remove work unit from pending queue. */
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))
if (wup == wu)
	break;
if (wup == NULL((void *)0))
panic("%s: wu %p not on pending queue",
    DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname), wu);
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);

if (wu->swu_collider) {
if (wu->swu_ios_failed)
	sr_raid_recreate_wu(wu->swu_collider);

/* XXX Should the collider be failed if this xs failed? */
sr_raid_startwu(wu->swu_collider);
}

/*
* If a discipline provides its own sd_scsi_done function, then it
* is responsible for calling sr_scsi_done() once I/O is complete.
*/
if (wu->swu_flags & SR_WUF_REBUILD(1<<0))
wu->swu_flags |= SR_WUF_REBUILDIOCOMP(1<<1);
if (wu->swu_flags & SR_WUF_WAKEUP(1<<4))
wakeup(wu);
if (sd->sd_scsi_done)
sd->sd_scsi_done(wu);
else if (wu->swu_flags & SR_WUF_DISCIPLINE(1<<5))
sr_scsi_wu_put(sd, wu);
else if (!(wu->swu_flags & SR_WUF_REBUILD(1<<0)))
sr_scsi_done(sd, xs);

2287done:
splx(s)spllower(s);
2289}

2291struct sr_workunit *
2292sr_scsi_wu_get(struct sr_discipline *sd, int flags)
2293{
return scsi_io_get(&sd->sd_iopool, flags);
2295}

2297void
2298sr_scsi_wu_put(struct sr_discipline *sd, struct sr_workunit *wu)
2299{
scsi_io_put(&sd->sd_iopool, wu);

if (sd->sd_sync && sd->sd_wu_pending == 0)
wakeup(sd);
2304}

2306void
2307sr_scsi_done(struct sr_discipline *sd, struct scsi_xfer *xs)
2308{
DNPRINTF(SR_D_DIS, "%s: sr_scsi_done: xs %p\n", DEVNAME(sd->sd_sc), xs);

if (xs->error == XS_NOERROR0)
xs->resid = 0;

scsi_done(xs);

if (sd->sd_sync && sd->sd_wu_pending == 0)
wakeup(sd);
2318}

2320void
2321sr_scsi_cmd(struct scsi_xfer *xs)
2322{
struct scsi_link	*link = xs->sc_link;
struct sr_softc		*sc = link->bus->sb_adapter_softc;
struct sr_workunit	*wu = xs->io;
struct sr_discipline	*sd;

DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd target %d xs %p flags %#x\n",
   DEVNAME(sc), link->target, xs, xs->flags);

sd = sc->sc_targets[link->target];
if (sd == NULL((void *)0))
panic("%s: sr_scsi_cmd NULL discipline", DEVNAME(sc)((sc)->sc_dev.dv_xname));

if (sd->sd_deleted) {
printf("%s: %s device is being deleted, failing io\n",
    DEVNAME(sc)((sc)->sc_dev.dv_xname), sd->sd_meta->ssd_devname);
goto stuffup;
}

/* scsi layer *can* re-send wu without calling sr_wu_put(). */
sr_wu_release_ccbs(wu);
sr_wu_init(sd, wu);
wu->swu_state = SR_WU_INPROGRESS1;
wu->swu_xs = xs;

switch (xs->cmd.opcode) {
case READ_COMMAND0x08:
case READ_100x28:
case READ_160x88:
case WRITE_COMMAND0x0a:
case WRITE_100x2a:
case WRITE_160x8a:
DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd: READ/WRITE %02x\n",
    DEVNAME(sc), xs->cmd.opcode);
if (sd->sd_scsi_rw(wu))
	goto stuffup;
break;

case SYNCHRONIZE_CACHE0x35:
DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd: SYNCHRONIZE_CACHE\n",
    DEVNAME(sc));
if (sd->sd_scsi_sync(wu))
	goto stuffup;
goto complete;

case TEST_UNIT_READY0x00:
DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd: TEST_UNIT_READY\n",
    DEVNAME(sc));
if (sd->sd_scsi_tur(wu))
	goto stuffup;
goto complete;

case START_STOP0x1b:
DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd: START_STOP\n",
    DEVNAME(sc));
if (sd->sd_scsi_start_stop(wu))
	goto stuffup;
goto complete;

case INQUIRY0x12:
DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd: INQUIRY\n",
    DEVNAME(sc));
if (sd->sd_scsi_inquiry(wu))
	goto stuffup;
goto complete;

case READ_CAPACITY0x25:
case READ_CAPACITY_160x9e:
DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd READ CAPACITY 0x%02x\n",
    DEVNAME(sc), xs->cmd.opcode);
if (sd->sd_scsi_read_cap(wu))
	goto stuffup;
goto complete;

case REQUEST_SENSE0x03:
DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd REQUEST SENSE\n",
    DEVNAME(sc));
if (sd->sd_scsi_req_sense(wu))
	goto stuffup;
goto complete;

default:
DNPRINTF(SR_D_CMD, "%s: unsupported scsi command %x\n",
    DEVNAME(sc), xs->cmd.opcode);
/* XXX might need to add generic function to handle others */
goto stuffup;
}

return;
2411stuffup:
if (sd->sd_scsi_sense.error_code) {
xs->error = XS_SENSE1;
memcpy(&xs->sense, &sd->sd_scsi_sense, sizeof(xs->sense))__builtin_memcpy((&xs->sense), (&sd->sd_scsi_sense
), (sizeof(xs->sense)));
bzero(&sd->sd_scsi_sense, sizeof(sd->sd_scsi_sense))__builtin_bzero((&sd->sd_scsi_sense), (sizeof(sd->sd_scsi_sense
)));
} else {
xs->error = XS_DRIVER_STUFFUP2;
}
2419complete:
sr_scsi_done(sd, xs);
2421}

2423int
2424sr_scsi_probe(struct scsi_link *link)
2425{
struct sr_softc		*sc = link->bus->sb_adapter_softc;
struct sr_discipline	*sd;

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"
));

sd = sc->sc_targets[link->target];
if (sd == NULL((void *)0))
return (ENODEV19);

link->pool = &sd->sd_iopool;
if (sd->sd_openings)
link->openings = sd->sd_openings(sd);
else
link->openings = sd->sd_max_wu;

return (0);
2442}

2444int
2445sr_scsi_ioctl(struct scsi_link *link, u_long cmd, caddr_t addr, int flag)
2446{
struct sr_softc		*sc = link->bus->sb_adapter_softc;
struct sr_discipline	*sd;

sd = sc->sc_targets[link->target];
if (sd == NULL((void *)0))
return (ENODEV19);

DNPRINTF(SR_D_IOCTL, "%s: %s sr_scsi_ioctl cmd: %#lx\n",
   DEVNAME(sc), sd->sd_meta->ssd_devname, cmd);

/* Pass bio ioctls through to the bio handler. */
if (IOCGROUP(cmd)(((cmd) >> 8) & 0xff) == 'B')
return (sr_bio_handler(sc, sd, cmd, (struct bio *)addr));

switch (cmd) {
case DIOCGCACHE((unsigned long)0x40000000 | ((sizeof(struct dk_cache) & 0x1fff
) << 16) | ((('d')) << 8) | ((117))):
case DIOCSCACHE((unsigned long)0x80000000 | ((sizeof(struct dk_cache) & 0x1fff
) << 16) | ((('d')) << 8) | ((118))):
return (EOPNOTSUPP45);
default:
return (ENOTTY25);
}
2468}

2470int
2471sr_bio_ioctl(struct device *dev, u_long cmd, caddr_t addr)
2472{
struct sr_softc *sc = (struct sr_softc *) dev;
DNPRINTF(SR_D_IOCTL, "%s: sr_bio_ioctl\n", DEVNAME(sc));

return sr_bio_handler(sc, NULL((void *)0), cmd, (struct bio *)addr);
2477}

2479int
2480sr_bio_handler(struct sr_softc *sc, struct sr_discipline *sd, u_long cmd,
  struct bio *bio)
2482{
int			rv = 0;

DNPRINTF(SR_D_IOCTL, "%s: sr_bio_handler ", DEVNAME(sc));

rw_enter_write(&sc->sc_lock);

bio_status_init(&sc->sc_status, &sc->sc_dev);

switch (cmd) {
case BIOCINQ(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct bioc_inq) & 0x1fff) << 16) | ((('B')) <<
 8) | ((32))):
DNPRINTF(SR_D_IOCTL, "inq\n");
rv = sr_ioctl_inq(sc, (struct bioc_inq *)bio);
break;

case BIOCVOL(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct bioc_vol) & 0x1fff) << 16) | ((('B')) <<
 8) | ((34))):
DNPRINTF(SR_D_IOCTL, "vol\n");
rv = sr_ioctl_vol(sc, (struct bioc_vol *)bio);
break;

case BIOCDISK(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct bioc_disk) & 0x1fff) << 16) | ((('B')) <<
 8) | ((33))):
DNPRINTF(SR_D_IOCTL, "disk\n");
rv = sr_ioctl_disk(sc, (struct bioc_disk *)bio);
break;

case BIOCALARM(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct bioc_alarm) & 0x1fff) << 16) | ((('B')) <<
 8) | ((35))):
DNPRINTF(SR_D_IOCTL, "alarm\n");
/*rv = sr_ioctl_alarm(sc, (struct bioc_alarm *)bio); */
break;

case BIOCBLINK(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct bioc_blink) & 0x1fff) << 16) | ((('B')) <<
 8) | ((36))):
DNPRINTF(SR_D_IOCTL, "blink\n");
/*rv = sr_ioctl_blink(sc, (struct bioc_blink *)bio); */
break;

case BIOCSETSTATE(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct bioc_setstate) & 0x1fff) << 16) | ((('B')) <<
 8) | ((37))):
DNPRINTF(SR_D_IOCTL, "setstate\n");
rv = sr_ioctl_setstate(sc, (struct bioc_setstate *)bio);
break;

case BIOCCREATERAID(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct bioc_createraid) & 0x1fff) << 16) | ((('B')
) << 8) | ((38))):
DNPRINTF(SR_D_IOCTL, "createraid\n");
rv = sr_ioctl_createraid(sc, (struct bioc_createraid *)bio,
    1, NULL((void *)0));
break;

case BIOCDELETERAID(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct bioc_deleteraid) & 0x1fff) << 16) | ((('B')
) << 8) | ((39))):
DNPRINTF(SR_D_IOCTL, "deleteraid\n");
rv = sr_ioctl_deleteraid(sc, sd, (struct bioc_deleteraid *)bio);
break;

case BIOCDISCIPLINE(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct bioc_discipline) & 0x1fff) << 16) | ((('B')
) << 8) | ((40))):
DNPRINTF(SR_D_IOCTL, "discipline\n");
rv = sr_ioctl_discipline(sc, sd, (struct bioc_discipline *)bio);
break;

case BIOCINSTALLBOOT(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct bioc_installboot) & 0x1fff) << 16) | ((('B'
)) << 8) | ((41))):
DNPRINTF(SR_D_IOCTL, "installboot\n");
rv = sr_ioctl_installboot(sc, sd,
    (struct bioc_installboot *)bio);
break;

default:
DNPRINTF(SR_D_IOCTL, "invalid ioctl\n");
rv = ENOTTY25;
}

sc->sc_status.bs_status = (rv ? BIO_STATUS_ERROR2 : BIO_STATUS_SUCCESS1);

if (sc->sc_status.bs_msg_count > 0)
rv = 0;

memcpy(&bio->bio_status, &sc->sc_status, sizeof(struct bio_status))__builtin_memcpy((&bio->bio_status), (&sc->sc_status
), (sizeof(struct bio_status)));

rw_exit_write(&sc->sc_lock);

return (rv);
2559}

2561int
2562sr_ioctl_inq(struct sr_softc *sc, struct bioc_inq *bi)
2563{
struct sr_discipline	*sd;
int			vol = 0, disk = 0;

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)) {
vol++;
disk += sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no;
}

strlcpy(bi->bi_dev, sc->sc_dev.dv_xname, sizeof(bi->bi_dev));
bi->bi_novol = vol + sc->sc_hotspare_no;
bi->bi_nodisk = disk + sc->sc_hotspare_no;

return (0);
2577}

2579int
2580sr_ioctl_vol(struct sr_softc *sc, struct bioc_vol *bv)
2581{
int			vol = -1, rv = EINVAL22;
struct sr_discipline	*sd;
struct sr_chunk		*hotspare;

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)) {
vol++;
if (vol != bv->bv_volid)
	continue;

bv->bv_status = sd->sd_vol_status;
bv->bv_size = sd->sd_meta->ssdi_sdd_invariant.ssd_size << DEV_BSHIFT9;
bv->bv_level = sd->sd_meta->ssdi_sdd_invariant.ssd_level;
bv->bv_nodisk = sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no;

2596#ifdef CRYPTO1
if (sd->sd_meta->ssdi_sdd_invariant.ssd_level == 'C' &&
    sd->mdssd_dis_specific.mdd_crypto.key_disk != NULL((void *)0))
	bv->bv_nodisk++;
else if (sd->sd_meta->ssdi_sdd_invariant.ssd_level == 0x1C &&
    sd->mdssd_dis_specific.mdd_raid1c.sr1c_crypto.key_disk != NULL((void *)0))
	bv->bv_nodisk++;
2603#endif
if (bv->bv_status == BIOC_SVREBUILD0x05)
	bv->bv_percent = sr_rebuild_percent(sd);

strlcpy(bv->bv_dev, sd->sd_meta->ssd_devname,
    sizeof(bv->bv_dev));
strlcpy(bv->bv_vendor, sd->sd_meta->ssdi_sdd_invariant.ssd_vendor,
    sizeof(bv->bv_vendor));
rv = 0;
goto done;
}

/* Check hotspares list. */
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)) {
vol++;
if (vol != bv->bv_volid)
	continue;

bv->bv_status = BIOC_SVONLINE0x00;
bv->bv_size = hotspare->src_meta.scmi_scm_invariant.scm_size << DEV_BSHIFT9;
bv->bv_level = -1;	/* Hotspare. */
bv->bv_nodisk = 1;
strlcpy(bv->bv_dev, hotspare->src_meta.scmi_scm_invariant.scm_devname,
    sizeof(bv->bv_dev));
strlcpy(bv->bv_vendor, hotspare->src_meta.scmi_scm_invariant.scm_devname,
    sizeof(bv->bv_vendor));
rv = 0;
goto done;
}

2633done:
return (rv);
2635}

2637int
2638sr_ioctl_disk(struct sr_softc *sc, struct bioc_disk *bd)
2639{
struct sr_discipline	*sd;
struct sr_chunk		*src, *hotspare;
int			vol = -1, rv = EINVAL22;

if (bd->bd_diskid < 0)
goto done;

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)) {
vol++;
if (vol != bd->bd_volid)
	continue;

if (bd->bd_diskid < sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no)
	src = sd->sd_vol.sv_chunks[bd->bd_diskid];
2654#ifdef CRYPTO1
else if (bd->bd_diskid == sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no &&
    sd->sd_meta->ssdi_sdd_invariant.ssd_level == 'C' &&
    sd->mdssd_dis_specific.mdd_crypto.key_disk != NULL((void *)0))
	src = sd->mdssd_dis_specific.mdd_crypto.key_disk;
else if (bd->bd_diskid == sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no &&
    sd->sd_meta->ssdi_sdd_invariant.ssd_level == 0x1C &&
    sd->mdssd_dis_specific.mdd_raid1c.sr1c_crypto.key_disk != NULL((void *)0))
	src = sd->mdssd_dis_specific.mdd_crypto.key_disk;
2663#endif
else
	break;

bd->bd_status = src->src_meta.scm_status;
bd->bd_size = src->src_meta.scmi_scm_invariant.scm_size << DEV_BSHIFT9;
bd->bd_channel = vol;
bd->bd_target = bd->bd_diskid;
strlcpy(bd->bd_vendor, src->src_meta.scmi_scm_invariant.scm_devname,
    sizeof(bd->bd_vendor));
rv = 0;
goto done;
}

/* Check hotspares list. */
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)) {
vol++;
if (vol != bd->bd_volid)
	continue;

if (bd->bd_diskid != 0)
	break;

bd->bd_status = hotspare->src_meta.scm_status;
bd->bd_size = hotspare->src_meta.scmi_scm_invariant.scm_size << DEV_BSHIFT9;
bd->bd_channel = vol;
bd->bd_target = bd->bd_diskid;
strlcpy(bd->bd_vendor, hotspare->src_meta.scmi_scm_invariant.scm_devname,
    sizeof(bd->bd_vendor));
rv = 0;
goto done;
}

2696done:
return (rv);
2698}

2700int
2701sr_ioctl_setstate(struct sr_softc *sc, struct bioc_setstate *bs)
2702{
int			rv = EINVAL22;
int			vol = -1, found, c;
struct sr_discipline	*sd;
struct sr_chunk		*ch_entry;
struct sr_chunk_head	*cl;

if (bs->bs_other_id_type == BIOC_SSOTHER_UNUSED0x00)
goto done;

if (bs->bs_status == BIOC_SSHOTSPARE0x02) {
rv = sr_hotspare(sc, (dev_t)bs->bs_other_id);
goto done;
}

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)) {
vol++;
if (vol == bs->bs_volid)
	break;
}
if (sd == NULL((void *)0))
goto done;

switch (bs->bs_status) {
case BIOC_SSOFFLINE0x01:
/* Take chunk offline */
found = c = 0;
cl = &sd->sd_vol.sv_chunk_list;
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)) {
	if (ch_entry->src_dev_mm == bs->bs_other_id) {
		found = 1;
		break;
	}
	c++;
}
if (found == 0) {
	sr_error(sc, "chunk not part of array");
	goto done;
}

/* XXX: check current state first */
sd->sd_set_chunk_state(sd, c, BIOC_SDOFFLINE0x01);

if (sr_meta_save(sd, SR_META_DIRTY0x1)) {
	sr_error(sc, "could not save metadata for %s",
	    sd->sd_meta->ssd_devname);
	goto done;
}
rv = 0;
break;

case BIOC_SDSCRUB0x06:
break;

case BIOC_SSREBUILD0x03:
rv = sr_rebuild_init(sd, (dev_t)bs->bs_other_id, 0);
break;

default:
sr_error(sc, "unsupported state request %d", bs->bs_status);
}

2764done:
return (rv);
2766}

2768int
2769sr_chunk_in_use(struct sr_softc *sc, dev_t dev)
2770{
struct sr_discipline	*sd;
struct sr_chunk		*chunk;
int			i;

DNPRINTF(SR_D_MISC, "%s: sr_chunk_in_use(%d)\n", DEVNAME(sc), dev);

if (dev == NODEV(dev_t)(-1))
return BIOC_SDINVALID0xff;

/* See if chunk is already in use. */
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)) {
for (i = 0; i < sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no; i++) {
	chunk = sd->sd_vol.sv_chunks[i];
	if (chunk->src_dev_mm == dev)
		return chunk->src_meta.scm_status;
}
}

/* Check hotspares list. */
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
))
if (chunk->src_dev_mm == dev)
	return chunk->src_meta.scm_status;

return BIOC_SDINVALID0xff;
2795}

2797int
2798sr_hotspare(struct sr_softc *sc, dev_t dev)
2799{
struct sr_discipline	*sd = NULL((void *)0);
struct sr_metadata	*sm = NULL((void *)0);
struct sr_meta_chunk    *hm;
struct sr_chunk_head	*cl;
struct sr_chunk		*chunk, *last, *hotspare = NULL((void *)0);
struct sr_uuid		uuid;
struct disklabel	label;
struct vnode		*vn;
u_int64_t		size;
char			devname[32];
int			rv = EINVAL22;
int			c, part, open = 0;

/*
* Add device to global hotspares list.
*/

sr_meta_getdevname(sc, dev, devname, sizeof(devname));

/* Make sure chunk is not already in use. */
c = sr_chunk_in_use(sc, dev);
if (c != BIOC_SDINVALID0xff && c != BIOC_SDOFFLINE0x01) {
if (c == BIOC_SDHOTSPARE0x04)
	sr_error(sc, "%s is already a hotspare", devname);
else
	sr_error(sc, "%s is already in use", devname);
goto done;
}

/* XXX - See if there is an existing degraded volume... */

/* Open device. */
if (bdevvp(dev, &vn)) {
sr_error(sc, "sr_hotspare: cannot allocate vnode");
goto done;
}
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)) {
DNPRINTF(SR_D_META,"%s: sr_hotspare cannot open %s\n",
    DEVNAME(sc), devname);
vput(vn);
goto fail;
}
open = 1; /* close dev on error */

/* Get partition details. */
part = DISKPART(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
 8)) % 16);
if (VOP_IOCTL(vn, DIOCGDINFO((unsigned long)0x40000000 | ((sizeof(struct disklabel) &
 0x1fff) << 16) | ((('d')) << 8) | ((101))), (caddr_t)&label, 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)) {
DNPRINTF(SR_D_META, "%s: sr_hotspare ioctl failed\n",
    DEVNAME(sc));
goto fail;
}
if (label.d_partitions[part].p_fstype != FS_RAID19) {
sr_error(sc, "%s partition not of type RAID (%d)",
    devname, label.d_partitions[part].p_fstype);
goto fail;
}

/* Calculate partition size. */
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)));
if (size <= SR_DATA_OFFSET(16 + (64 + (320 + 128)))) {
DNPRINTF(SR_D_META, "%s: %s partition too small\n", DEVNAME(sc),
    devname);
goto fail;
}
size -= SR_DATA_OFFSET(16 + (64 + (320 + 128)));
if (size > INT64_MAX0x7fffffffffffffffLL) {
DNPRINTF(SR_D_META, "%s: %s partition too large\n", DEVNAME(sc),
    devname);
goto fail;
}

/*
* Create and populate chunk metadata.
*/

sr_uuid_generate(&uuid);
hotspare = malloc(sizeof(struct sr_chunk), M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);

hotspare->src_dev_mm = dev;
hotspare->src_vn = vn;
strlcpy(hotspare->src_devname, devname, sizeof(hm->scmi_scm_invariant.scm_devname));
hotspare->src_size = size;

hm = &hotspare->src_meta;
hm->scmi_scm_invariant.scm_volid = SR_HOTSPARE_VOLID0xffffffff;
hm->scmi_scm_invariant.scm_chunk_id = 0;
hm->scmi_scm_invariant.scm_size = size;
hm->scmi_scm_invariant.scm_coerced_size = size;
strlcpy(hm->scmi_scm_invariant.scm_devname, devname, sizeof(hm->scmi_scm_invariant.scm_devname));
memcpy(&hm->scmi.scm_uuid, &uuid, sizeof(struct sr_uuid))__builtin_memcpy((&hm->_scm_invariant.scm_uuid), (&
uuid), (sizeof(struct sr_uuid)));

sr_checksum(sc, hm, &hm->scm_checksum,
   sizeof(struct sr_meta_chunk_invariant));

hm->scm_status = BIOC_SDHOTSPARE0x04;

/*
* Create and populate our own discipline and metadata.
*/

sm = malloc(sizeof(struct sr_metadata), M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
sm->ssdi_sdd_invariant.ssd_magic = SR_MAGIC0x4d4152436372616dLLU;
sm->ssdi_sdd_invariant.ssd_version = SR_META_VERSION6;
sm->ssd_ondisk = 0;
sm->ssdi_sdd_invariant.ssd_vol_flags = 0;
memcpy(&sm->ssdi.ssd_uuid, &uuid, sizeof(struct sr_uuid))__builtin_memcpy((&sm->_sdd_invariant.ssd_uuid), (&
uuid), (sizeof(struct sr_uuid)));
sm->ssdi_sdd_invariant.ssd_chunk_no = 1;
sm->ssdi_sdd_invariant.ssd_volid = SR_HOTSPARE_VOLID0xffffffff;
sm->ssdi_sdd_invariant.ssd_level = SR_HOTSPARE_LEVEL0xffffffff;
sm->ssdi_sdd_invariant.ssd_size = size;
sm->ssdi_sdd_invariant.ssd_secsize = label.d_secsize;
strlcpy(sm->ssdi_sdd_invariant.ssd_vendor, "OPENBSD", sizeof(sm->ssdi_sdd_invariant.ssd_vendor));
snprintf(sm->ssdi_sdd_invariant.ssd_product, sizeof(sm->ssdi_sdd_invariant.ssd_product),
   "SR %s", "HOTSPARE");
snprintf(sm->ssdi_sdd_invariant.ssd_revision, sizeof(sm->ssdi_sdd_invariant.ssd_revision),
   "%03d", SR_META_VERSION6);

sd = malloc(sizeof(struct sr_discipline), M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
sd->sd_sc = sc;
sd->sd_meta = sm;
sd->sd_meta_type = SR_META_F_NATIVE0;
sd->sd_vol_status = BIOC_SVONLINE0x00;
strlcpy(sd->sd_name, "HOTSPARE", sizeof(sd->sd_name));
SLIST_INIT(&sd->sd_meta_opt){ ((&sd->sd_meta_opt)->slh_first) = ((void *)0); };

/* Add chunk to volume. */
sd->sd_vol.sv_chunks = malloc(sizeof(struct sr_chunk *), M_DEVBUF2,
   M_WAITOK0x0001 | M_ZERO0x0008);
sd->sd_vol.sv_chunks[0] = hotspare;
SLIST_INIT(&sd->sd_vol.sv_chunk_list){ ((&sd->sd_vol.sv_chunk_list)->slh_first) = ((void
 *)0); };
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);

/* Save metadata. */
if (sr_meta_save(sd, SR_META_DIRTY0x1)) {
sr_error(sc, "could not save metadata to %s", devname);
goto fail;
}

/*
* Add chunk to hotspare list.
*/
rw_enter_write(&sc->sc_hs_lock);
cl = &sc->sc_hotspare_list;
if (SLIST_EMPTY(cl)(((cl)->slh_first) == ((void *)0)))
SLIST_INSERT_HEAD(cl, hotspare, src_link)do { (hotspare)->src_link.sle_next = (cl)->slh_first; (
cl)->slh_first = (hotspare); } while (0);
else {
SLIST_FOREACH(chunk, cl, src_link)for((chunk) = ((cl)->slh_first); (chunk) != ((void *)0); (
chunk) = ((chunk)->src_link.sle_next))
	last = chunk;
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);
}
sc->sc_hotspare_no++;
rw_exit_write(&sc->sc_hs_lock);

rv = 0;
goto done;

2957fail:
free(hotspare, M_DEVBUF2, sizeof(*hotspare));

2960done:
if (sd)
free(sd->sd_vol.sv_chunks, M_DEVBUF2,
    sizeof(sd->sd_vol.sv_chunks));
free(sd, M_DEVBUF2, sizeof(*sd));
free(sm, M_DEVBUF2, sizeof(*sm));
if (open) {
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);
vput(vn);
}

return (rv);
2972}

2974void
2975sr_hotspare_rebuild_callback(void *xsd)
2976{
struct sr_discipline *sd = xsd;
sr_hotspare_rebuild(sd);
2979}

2981void
2982sr_hotspare_rebuild(struct sr_discipline *sd)
2983{
struct sr_softc		*sc = sd->sd_sc;
struct sr_chunk_head	*cl;
struct sr_chunk		*hotspare, *chunk = NULL((void *)0);
struct sr_workunit	*wu;
struct sr_ccb		*ccb;
int			i, s, cid, busy;

/*
* Attempt to locate a hotspare and initiate rebuild.
*/

/* Find first offline chunk. */
for (cid = 0; cid < sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no; cid++) {
if (sd->sd_vol.sv_chunks[cid]->src_meta.scm_status ==
    BIOC_SDOFFLINE0x01) {
	chunk = sd->sd_vol.sv_chunks[cid];
	break;
}
}
if (chunk == NULL((void *)0)) {
printf("%s: no offline chunk found on %s!\n",
    DEVNAME(sc)((sc)->sc_dev.dv_xname), sd->sd_meta->ssd_devname);
return;
}

/* See if we have a suitable hotspare... */
rw_enter_write(&sc->sc_hs_lock);
cl = &sc->sc_hotspare_list;
SLIST_FOREACH(hotspare, cl, src_link)for((hotspare) = ((cl)->slh_first); (hotspare) != ((void *
)0); (hotspare) = ((hotspare)->src_link.sle_next))
if (hotspare->src_size >= chunk->src_size &&
    hotspare->src_secsize <= sd->sd_meta->ssdi_sdd_invariant.ssd_secsize)
	break;

if (hotspare != NULL((void *)0)) {

printf("%s: %s volume degraded, will attempt to "
    "rebuild on hotspare %s\n", DEVNAME(sc)((sc)->sc_dev.dv_xname),
    sd->sd_meta->ssd_devname, hotspare->src_devname);

/*
 * Ensure that all pending I/O completes on the failed chunk
 * before trying to initiate a rebuild.
 */
i = 0;
do {
	busy = 0;

	s = splbio()splraise(0x3);
	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)) {
		TAILQ_FOREACH(ccb, &wu->swu_ccb, ccb_link)for((ccb) = ((&wu->swu_ccb)->tqh_first); (ccb) != (
(void *)0); (ccb) = ((ccb)->ccb_link.tqe_next)) {
			if (ccb->ccb_target == cid)
				busy = 1;
		}
	}
	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)) {
		TAILQ_FOREACH(ccb, &wu->swu_ccb, ccb_link)for((ccb) = ((&wu->swu_ccb)->tqh_first); (ccb) != (
(void *)0); (ccb) = ((ccb)->ccb_link.tqe_next)) {
			if (ccb->ccb_target == cid)
				busy = 1;
		}
	}
	splx(s)spllower(s);

	if (busy) {
		tsleep_nsec(sd, PRIBIO16, "sr_hotspare",
		    SEC_TO_NSEC(1));
		i++;
	}

} while (busy && i < 120);

DNPRINTF(SR_D_META, "%s: waited %i seconds for I/O to "
    "complete on failed chunk %s\n", DEVNAME(sc),
    i, chunk->src_devname);

if (busy) {
	printf("%s: pending I/O failed to complete on "
	    "failed chunk %s, hotspare rebuild aborted...\n",
	    DEVNAME(sc)((sc)->sc_dev.dv_xname), chunk->src_devname);
	goto done;
}

s = splbio()splraise(0x3);
rw_enter_write(&sc->sc_lock);
bio_status_init(&sc->sc_status, &sc->sc_dev);
if (sr_rebuild_init(sd, hotspare->src_dev_mm, 1) == 0) {

	/* Remove hotspare from available list. */
	sc->sc_hotspare_no--;
	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);
	free(hotspare, M_DEVBUF2, sizeof(*hotspare));

}
rw_exit_write(&sc->sc_lock);
splx(s)spllower(s);
}
3079done:
rw_exit_write(&sc->sc_hs_lock);
3081}

3083int
3084sr_rebuild_init(struct sr_discipline *sd, dev_t dev, int hotspare)
3085{
struct sr_softc		*sc = sd->sd_sc;
struct sr_chunk		*chunk = NULL((void *)0);
struct sr_meta_chunk	*meta;
struct disklabel	label;
struct vnode		*vn;
u_int64_t		size;
int64_t			csize;
char			devname[32];
int			rv = EINVAL22, open = 0;
int			cid, i, part, status;

/*
* Attempt to initiate a rebuild onto the specified device.
*/

if (!(sd->sd_capabilities & SR_CAP_REBUILD0x00000004)) {
sr_error(sc, "discipline does not support rebuild");
goto done;
}

/* make sure volume is in the right state */
if (sd->sd_vol_status == BIOC_SVREBUILD0x05) {
sr_error(sc, "rebuild already in progress");
goto done;
}
if (sd->sd_vol_status != BIOC_SVDEGRADED0x02) {
sr_error(sc, "volume not degraded");
goto done;
}

/* Find first offline chunk. */
for (cid = 0; cid < sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no; cid++) {
if (sd->sd_vol.sv_chunks[cid]->src_meta.scm_status ==
    BIOC_SDOFFLINE0x01) {
	chunk = sd->sd_vol.sv_chunks[cid];
	break;
}
}
if (chunk == NULL((void *)0)) {
sr_error(sc, "no offline chunks available to rebuild");
goto done;
}

/* Get coerced size from another online chunk. */
csize = 0;
for (i = 0; i < sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no; i++) {
if (sd->sd_vol.sv_chunks[i]->src_meta.scm_status ==
    BIOC_SDONLINE0x00) {
	meta = &sd->sd_vol.sv_chunks[i]->src_meta;
	csize = meta->scmi_scm_invariant.scm_coerced_size;
	break;
}
}
if (csize == 0) {
sr_error(sc, "no online chunks available for rebuild");
goto done;
}

sr_meta_getdevname(sc, dev, devname, sizeof(devname));
if (bdevvp(dev, &vn)) {
printf("%s: sr_rebuild_init: can't allocate vnode\n",
    DEVNAME(sc)((sc)->sc_dev.dv_xname));
goto done;
}
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)) {
DNPRINTF(SR_D_META,"%s: sr_ioctl_setstate can't "
    "open %s\n", DEVNAME(sc), devname);
vput(vn);
goto done;
}
open = 1; /* close dev on error */

/* Get disklabel and check partition. */
part = DISKPART(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
 8)) % 16);
if (VOP_IOCTL(vn, DIOCGDINFO((unsigned long)0x40000000 | ((sizeof(struct disklabel) &
 0x1fff) << 16) | ((('d')) << 8) | ((101))), (caddr_t)&label, 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)) {
DNPRINTF(SR_D_META, "%s: sr_ioctl_setstate ioctl failed\n",
    DEVNAME(sc));
goto done;
}
if (label.d_partitions[part].p_fstype != FS_RAID19) {
sr_error(sc, "%s partition not of type RAID (%d)",
    devname, label.d_partitions[part].p_fstype);
goto done;
}

/* Is the partition large enough? */
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)));
if (size <= sd->sd_meta->ssd_data_blkno) {
sr_error(sc, "%s: %s partition too small", DEVNAME(sc)((sc)->sc_dev.dv_xname),
    devname);
goto done;
}
size -= sd->sd_meta->ssd_data_blkno;
if (size > INT64_MAX0x7fffffffffffffffLL) {
sr_error(sc, "%s: %s partition too large", DEVNAME(sc)((sc)->sc_dev.dv_xname),
    devname);
goto done;
}
if (size < csize) {
sr_error(sc, "%s partition too small, at least %lld bytes "
    "required", devname, (long long)(csize << DEV_BSHIFT9));
goto done;
} else if (size > csize)
sr_warn(sc, "%s partition too large, wasting %lld bytes",
    devname, (long long)((size - csize) << DEV_BSHIFT9));
if (label.d_secsize > sd->sd_meta->ssdi_sdd_invariant.ssd_secsize) {
sr_error(sc, "%s sector size too large, <= %u bytes "
    "required", devname, sd->sd_meta->ssdi_sdd_invariant.ssd_secsize);
goto done;
}

/* Ensure that this chunk is not already in use. */
status = sr_chunk_in_use(sc, dev);
if (status != BIOC_SDINVALID0xff && status != BIOC_SDOFFLINE0x01 &&
   !(hotspare && status == BIOC_SDHOTSPARE0x04)) {
sr_error(sc, "%s is already in use", devname);
goto done;
}

/* Reset rebuild counter since we rebuilding onto a new chunk. */
sd->sd_meta->ssd_rebuild = 0;

open = 0; /* leave dev open from here on out */

/* Fix up chunk. */
memcpy(chunk->src_duid, label.d_uid, sizeof(chunk->src_duid))__builtin_memcpy((chunk->src_duid), (label.d_uid), (sizeof
(chunk->src_duid)));
chunk->src_dev_mm = dev;
chunk->src_vn = vn;

/* Reconstruct metadata. */
meta = &chunk->src_meta;
meta->scmi_scm_invariant.scm_volid = sd->sd_meta->ssdi_sdd_invariant.ssd_volid;
meta->scmi_scm_invariant.scm_chunk_id = cid;
strlcpy(meta->scmi_scm_invariant.scm_devname, devname,
   sizeof(meta->scmi_scm_invariant.scm_devname));
meta->scmi_scm_invariant.scm_size = size;
meta->scmi_scm_invariant.scm_coerced_size = csize;
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)))
   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)));
sr_checksum(sc, meta, &meta->scm_checksum,
   sizeof(struct sr_meta_chunk_invariant));

sd->sd_set_chunk_state(sd, cid, BIOC_SDREBUILD0x03);

if (sr_meta_save(sd, SR_META_DIRTY0x1)) {
sr_error(sc, "could not save metadata to %s", devname);
open = 1;
goto done;
}

sr_warn(sc, "rebuild of %s started on %s",
   sd->sd_meta->ssd_devname, devname);

sd->sd_reb_abort = 0;
kthread_create_deferred(sr_rebuild_start, sd);

rv = 0;
3244done:
if (open) {
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);
vput(vn);
}

return (rv);
3251}

3253int
3254sr_rebuild_percent(struct sr_discipline *sd)
3255{
daddr_t			rb, sz;

sz = sd->sd_meta->ssdi_sdd_invariant.ssd_size;
rb = sd->sd_meta->ssd_rebuild;

if (rb > 0)
return (100 - ((sz * 100 - rb * 100) / sz) - 1);

return (0);
3265}

3267void
3268sr_roam_chunks(struct sr_discipline *sd)
3269{
struct sr_softc		*sc = sd->sd_sc;
struct sr_chunk		*chunk;
struct sr_meta_chunk	*meta;
int			roamed = 0;

/* Have any chunks roamed? */
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
)) {
meta = &chunk->src_meta;
if (strncmp(meta->scmi_scm_invariant.scm_devname, chunk->src_devname,
    sizeof(meta->scmi_scm_invariant.scm_devname))) {

	printf("%s: roaming device %s -> %s\n", DEVNAME(sc)((sc)->sc_dev.dv_xname),
	    meta->scmi_scm_invariant.scm_devname, chunk->src_devname);

	strlcpy(meta->scmi_scm_invariant.scm_devname, chunk->src_devname,
	    sizeof(meta->scmi_scm_invariant.scm_devname));

	roamed++;
}
}

if (roamed)
sr_meta_save(sd, SR_META_DIRTY0x1);
3293}

3295int
3296sr_ioctl_createraid(struct sr_softc *sc, struct bioc_createraid *bc,
  int user, void *data)
3298{
struct sr_meta_opt_item *omi;
struct sr_chunk_head	*cl;
struct sr_discipline	*sd = NULL((void *)0);
struct sr_chunk		*ch_entry;
struct scsi_link	*link;
struct device		*dev;
char			*uuid, devname[32];
dev_t			*dt = NULL((void *)0);
int			i, no_chunk, rv = EINVAL22, target, vol;
int			no_meta;

DNPRINTF(SR_D_IOCTL, "%s: sr_ioctl_createraid(%d)\n",
   DEVNAME(sc), user);

/* user input */
if (bc->bc_dev_list_len > BIOC_CRMAXLEN1024)
goto unwind;

dt = malloc(bc->bc_dev_list_len, M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
if (user) {
if (copyin(bc->bc_dev_list, dt, bc->bc_dev_list_len) != 0)
	goto unwind;
} else
memcpy(dt, bc->bc_dev_list, bc->bc_dev_list_len)__builtin_memcpy((dt), (bc->bc_dev_list), (bc->bc_dev_list_len
));

/* Initialise discipline. */
sd = malloc(sizeof(struct sr_discipline), M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
sd->sd_sc = sc;
SLIST_INIT(&sd->sd_meta_opt){ ((&sd->sd_meta_opt)->slh_first) = ((void *)0); };
sd->sd_taskq = taskq_create("srdis", 1, IPL_BIO0x3, 0);
if (sd->sd_taskq == NULL((void *)0)) {
sr_error(sc, "could not create discipline taskq");
goto unwind;
}
if (sr_discipline_init(sd, bc->bc_level)) {
sr_error(sc, "could not initialize discipline");
goto unwind;
}

no_chunk = bc->bc_dev_list_len / sizeof(dev_t);
cl = &sd->sd_vol.sv_chunk_list;
SLIST_INIT(cl){ ((cl)->slh_first) = ((void *)0); };

/* Ensure that chunks are not already in use. */
for (i = 0; i < no_chunk; i++) {
if (sr_chunk_in_use(sc, dt[i]) != BIOC_SDINVALID0xff) {
	sr_meta_getdevname(sc, dt[i], devname, sizeof(devname));
	sr_error(sc, "chunk %s already in use", devname);
	goto unwind;
}
}

sd->sd_meta_type = sr_meta_probe(sd, dt, no_chunk);
if (sd->sd_meta_type == SR_META_F_INVALID-1) {
sr_error(sc, "invalid metadata format");
goto unwind;
}

if (sr_meta_attach(sd, no_chunk, bc->bc_flags & BIOC_SCFORCE0x01))
goto unwind;

/* force the raid volume by clearing metadata region */
if (bc->bc_flags & BIOC_SCFORCE0x01) {
/* make sure disk isn't up and running */
if (sr_meta_read(sd))
	if (sr_already_assembled(sd)) {
		uuid = sr_uuid_format(
		    &sd->sd_meta->ssdi_sdd_invariant.ssd_uuid);
		sr_error(sc, "disk %s is currently in use; "
		    "cannot force create", uuid);
		free(uuid, M_DEVBUF2, 37);
		goto unwind;
	}

if (sr_meta_clear(sd)) {
	sr_error(sc, "failed to clear metadata");
	goto unwind;
}
}

no_meta = sr_meta_read(sd);
if (no_meta == -1) {

/* Corrupt metadata on one or more chunks. */
sr_error(sc, "one of the chunks has corrupt metadata; "
    "aborting assembly");
goto unwind;

} else if (no_meta == 0) {

/* Initialise volume and chunk metadata. */
sr_meta_init(sd, bc->bc_level, no_chunk);
sd->sd_vol_status = BIOC_SVONLINE0x00;
sd->sd_meta_flags = bc->bc_flags & BIOC_SCNOAUTOASSEMBLE0x04;
if (sd->sd_create) {
	if ((i = sd->sd_create(sd, bc, no_chunk,
	    sd->sd_vol.sv_chunk_minsz))) {
		rv = i;
		goto unwind;
	}
}
sr_meta_init_complete(sd);

DNPRINTF(SR_D_IOCTL,
    "%s: sr_ioctl_createraid: vol_size: %lld\n",
    DEVNAME(sc), sd->sd_meta->ssdi.ssd_size);

/* Warn if we've wasted chunk space due to coercing. */
if ((sd->sd_capabilities & SR_CAP_NON_COERCED0x00000008) == 0 &&
    sd->sd_vol.sv_chunk_minsz != sd->sd_vol.sv_chunk_maxsz)
	sr_warn(sc, "chunk sizes are not equal; up to %llu "
	    "blocks wasted per chunk",
	    sd->sd_vol.sv_chunk_maxsz -
	    sd->sd_vol.sv_chunk_minsz);

} else {

/* Ensure we are assembling the correct # of chunks. */
if (bc->bc_level == 0x1C &&
    sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no > no_chunk) {
	sr_warn(sc, "trying to bring up %s degraded",
	    sd->sd_meta->ssd_devname);
} else if (sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no != no_chunk) {
	sr_error(sc, "volume chunk count does not match metadata "
	    "chunk count");
	goto unwind;
}

/* Ensure metadata level matches requested assembly level. */
if (sd->sd_meta->ssdi_sdd_invariant.ssd_level != bc->bc_level) {
	sr_error(sc, "volume level does not match metadata "
	    "level");
	goto unwind;
}

if (sr_already_assembled(sd)) {
	uuid = sr_uuid_format(&sd->sd_meta->ssdi_sdd_invariant.ssd_uuid);
	sr_error(sc, "disk %s already assembled", uuid);
	free(uuid, M_DEVBUF2, 37);
	goto unwind;
}

if (user == 0 && sd->sd_meta_flags & BIOC_SCNOAUTOASSEMBLE0x04) {
	DNPRINTF(SR_D_META, "%s: disk not auto assembled from "
	    "metadata\n", DEVNAME(sc));
	goto unwind;
}

if (no_meta != no_chunk)
	sr_warn(sc, "trying to bring up %s degraded",
	    sd->sd_meta->ssd_devname);

if (sd->sd_meta->ssd_meta_flags & SR_META_DIRTY0x1)
	sr_warn(sc, "%s was not shutdown properly",
	    sd->sd_meta->ssd_devname);

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))
	if (sd->sd_meta_opt_handler == NULL((void *)0) ||
	    sd->sd_meta_opt_handler(sd, omi->omi_som) != 0)
		sr_meta_opt_handler(sd, omi->omi_som);

if (sd->sd_assemble) {
	if ((i = sd->sd_assemble(sd, bc, no_chunk, data))) {
		rv = i;
		goto unwind;
	}
}

DNPRINTF(SR_D_META, "%s: disk assembled from metadata\n",
    DEVNAME(sc));

}

/* Metadata MUST be fully populated by this point. */
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);

/* Allocate all resources. */
if ((rv = sd->sd_alloc_resources(sd)))
goto unwind;

/* Adjust flags if necessary. */
if ((sd->sd_capabilities & SR_CAP_AUTO_ASSEMBLE0x00000002) &&
   (bc->bc_flags & BIOC_SCNOAUTOASSEMBLE0x04) !=
   (sd->sd_meta->ssdi_sdd_invariant.ssd_vol_flags & BIOC_SCNOAUTOASSEMBLE0x04)) {
sd->sd_meta->ssdi_sdd_invariant.ssd_vol_flags &= ~BIOC_SCNOAUTOASSEMBLE0x04;
sd->sd_meta->ssdi_sdd_invariant.ssd_vol_flags |=
    bc->bc_flags & BIOC_SCNOAUTOASSEMBLE0x04;
}

if (sd->sd_capabilities & SR_CAP_SYSTEM_DISK0x00000001) {
/* Initialise volume state. */
sd->sd_set_vol_state(sd);
if (sd->sd_vol_status == BIOC_SVOFFLINE0x01) {
	sr_error(sc, "%s is offline, will not be brought "
	    "online", sd->sd_meta->ssd_devname);
	goto unwind;
}

/* Setup SCSI iopool. */
scsi_iopool_init(&sd->sd_iopool, sd, sr_wu_get, sr_wu_put);

/*
 * All checks passed - return ENXIO if volume cannot be created.
 */
rv = ENXIO6;

/*
 * Find a free target.
 *
 * XXX: We reserve sd_target == 0 to indicate the
 * discipline is not linked into sc->sc_targets, so begin
 * the search with target = 1.
 */
for (target = 1; target < SR_MAX_LD256; target++)
	if (sc->sc_targets[target] == NULL((void *)0))
		break;
if (target == SR_MAX_LD256) {
	sr_error(sc, "no free target for %s",
	    sd->sd_meta->ssd_devname);
	goto unwind;
}

/* Clear sense data. */
bzero(&sd->sd_scsi_sense, sizeof(sd->sd_scsi_sense))__builtin_bzero((&sd->sd_scsi_sense), (sizeof(sd->sd_scsi_sense
)));

/* Attach discipline and get midlayer to probe it. */
sd->sd_target = target;
sc->sc_targets[target] = sd;
if (scsi_probe_lun(sc->sc_scsibus, target, 0) != 0) {
	sr_error(sc, "scsi_probe_lun failed");
	sc->sc_targets[target] = NULL((void *)0);
	sd->sd_target = 0;
	goto unwind;
}

link = scsi_get_link(sc->sc_scsibus, target, 0);
if (link == NULL((void *)0))
	goto unwind;

dev = link->device_softc;
DNPRINTF(SR_D_IOCTL, "%s: sr device added: %s at target %d\n",
    DEVNAME(sc), dev->dv_xname, sd->sd_target);

/* XXX - Count volumes, not targets. */
for (i = 0, vol = -1; i <= sd->sd_target; i++)
	if (sc->sc_targets[i])
		vol++;

rv = 0;

if (sd->sd_meta->ssd_devname[0] != '\0' &&
    strncmp(sd->sd_meta->ssd_devname, dev->dv_xname,
    sizeof(dev->dv_xname)))
	sr_warn(sc, "volume %s is roaming, it used to be %s, "
	    "updating metadata", dev->dv_xname,
	    sd->sd_meta->ssd_devname);

/* Populate remaining volume metadata. */
sd->sd_meta->ssdi_sdd_invariant.ssd_volid = vol;
strlcpy(sd->sd_meta->ssd_devname, dev->dv_xname,
    sizeof(sd->sd_meta->ssd_devname));

sr_info(sc, "%s volume attached as %s",
    sd->sd_name, sd->sd_meta->ssd_devname);

/* Update device name on any roaming chunks. */
sr_roam_chunks(sd);

3567#ifndef SMALL_KERNEL
if (sr_sensors_create(sd))
	sr_warn(sc, "unable to create sensor for %s",
	    dev->dv_xname);
3571#endif /* SMALL_KERNEL */
} else {
/* This volume does not attach as a system disk. */
ch_entry = SLIST_FIRST(cl)((cl)->slh_first); /* XXX */
strlcpy(sd->sd_meta->ssd_devname, ch_entry->src_devname,
    sizeof(sd->sd_meta->ssd_devname));

if (sd->sd_start_discipline(sd))
	goto unwind;
}

/* Save current metadata to disk. */
rv = sr_meta_save(sd, SR_META_DIRTY0x1);

if (sd->sd_vol_status == BIOC_SVREBUILD0x05)
kthread_create_deferred(sr_rebuild_start, sd);

sd->sd_ready = 1;

free(dt, M_DEVBUF2, bc->bc_dev_list_len);

return (rv);

3594unwind:
free(dt, M_DEVBUF2, bc->bc_dev_list_len);

sr_discipline_shutdown(sd, 0, 0);

if (rv == EAGAIN35)
rv = 0;

return (rv);
3603}

3605int
3606sr_ioctl_deleteraid(struct sr_softc *sc, struct sr_discipline *sd,
  struct bioc_deleteraid *bd)
3608{
int			rv = 1;

DNPRINTF(SR_D_IOCTL, "%s: sr_ioctl_deleteraid %s\n",
   DEVNAME(sc), bd->bd_dev);

if (sd == NULL((void *)0) && (sd = sr_find_discipline(sc, bd->bd_dev)) == NULL((void *)0)) {
sr_error(sc, "volume %s not found", bd->bd_dev);
goto bad;
}

/*
* XXX Better check for mounted file systems and refuse to detach any
* volume that is actively in use.
*/
if (bcmp(&sr_bootuuid, &sd->sd_meta->ssdi_sdd_invariant.ssd_uuid,
   sizeof(sr_bootuuid)) == 0) {
sr_error(sc, "refusing to delete boot volume");
goto bad;
}

sd->sd_deleted = 1;
sd->sd_meta->ssdi_sdd_invariant.ssd_vol_flags = BIOC_SCNOAUTOASSEMBLE0x04;
sr_discipline_shutdown(sd, 1, 0);

rv = 0;
3634bad:
return (rv);
3636}

3638int
3639sr_ioctl_discipline(struct sr_softc *sc, struct sr_discipline *sd,
  struct bioc_discipline *bd)
3641{
int			rv = 1;

/* Dispatch a discipline specific ioctl. */

DNPRINTF(SR_D_IOCTL, "%s: sr_ioctl_discipline %s\n", DEVNAME(sc),
   bd->bd_dev);

if (sd == NULL((void *)0) && (sd = sr_find_discipline(sc, bd->bd_dev)) == NULL((void *)0)) {
sr_error(sc, "volume %s not found", bd->bd_dev);
goto bad;
}

if (sd->sd_ioctl_handler)
rv = sd->sd_ioctl_handler(sd, bd);

3657bad:
return (rv);
3659}

3661int
3662sr_ioctl_installboot(struct sr_softc *sc, struct sr_discipline *sd,
  struct bioc_installboot *bb)
3664{
void			*bootblk = NULL((void *)0), *bootldr = NULL((void *)0);
struct sr_chunk		*chunk;
struct sr_meta_opt_item *omi;
struct sr_meta_boot	*sbm;
struct disk		*dk;
u_int32_t		bbs = 0, bls = 0, secsize;
u_char			duid[8];
int			rv = EINVAL22;
int			i;

DNPRINTF(SR_D_IOCTL, "%s: sr_ioctl_installboot %s\n", DEVNAME(sc),
   bb->bb_dev);

if (sd == NULL((void *)0) && (sd = sr_find_discipline(sc, bb->bb_dev)) == NULL((void *)0)) {
sr_error(sc, "volume %s not found", bb->bb_dev);
goto done;
}

TAILQ_FOREACH(dk, &disklist,  dk_link)for((dk) = ((&disklist)->tqh_first); (dk) != ((void *)
0); (dk) = ((dk)->dk_link.tqe_next))
if (!strncmp(dk->dk_name, bb->bb_dev, sizeof(bb->bb_dev)))
	break;
if (dk == NULL((void *)0) || dk->dk_label == NULL((void *)0) ||
   duid_iszero(dk->dk_label->d_uid)) {
sr_error(sc, "failed to get DUID for softraid volume");
goto done;
}
memcpy(duid, dk->dk_label->d_uid, sizeof(duid))__builtin_memcpy((duid), (dk->dk_label->d_uid), (sizeof
(duid)));

/* Ensure that boot storage area is large enough. */
if (sd->sd_meta->ssd_data_blkno < (SR_BOOT_OFFSET(16 + 64) + SR_BOOT_SIZE(320 + 128))) {
sr_error(sc, "insufficient boot storage");
goto done;
}

if (bb->bb_bootblk_size > SR_BOOT_BLOCKS_SIZE128 * DEV_BSIZE(1 << 9)) {
sr_error(sc, "boot block too large (%d > %d)",
    bb->bb_bootblk_size, SR_BOOT_BLOCKS_SIZE128 * DEV_BSIZE(1 << 9));
goto done;
}

if (bb->bb_bootldr_size > SR_BOOT_LOADER_SIZE320 * DEV_BSIZE(1 << 9)) {
sr_error(sc, "boot loader too large (%d > %d)",
    bb->bb_bootldr_size, SR_BOOT_LOADER_SIZE320 * DEV_BSIZE(1 << 9));
goto done;
}

secsize = sd->sd_meta->ssdi_sdd_invariant.ssd_secsize;

/* Copy in boot block. */
bbs = howmany(bb->bb_bootblk_size, secsize)(((bb->bb_bootblk_size) + ((secsize) - 1)) / (secsize)) * secsize;
bootblk = malloc(bbs, M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
if (copyin(bb->bb_bootblk, bootblk, bb->bb_bootblk_size) != 0)
goto done;

/* Copy in boot loader. */
bls = howmany(bb->bb_bootldr_size, secsize)(((bb->bb_bootldr_size) + ((secsize) - 1)) / (secsize)) * secsize;
bootldr = malloc(bls, M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
if (copyin(bb->bb_bootldr, bootldr, bb->bb_bootldr_size) != 0)
goto done;

/* Create or update optional meta for bootable volumes. */
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))
if (omi->omi_som->som_type == SR_OPT_BOOT0x02)
	break;
if (omi == NULL((void *)0)) {
omi = malloc(sizeof(struct sr_meta_opt_item), M_DEVBUF2,
    M_WAITOK0x0001 | M_ZERO0x0008);
omi->omi_som = malloc(sizeof(struct sr_meta_boot), M_DEVBUF2,
    M_WAITOK0x0001 | M_ZERO0x0008);
omi->omi_som->som_type = SR_OPT_BOOT0x02;
omi->omi_som->som_length = sizeof(struct sr_meta_boot);
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);
sd->sd_meta->ssdi_sdd_invariant.ssd_opt_no++;
}
sbm = (struct sr_meta_boot *)omi->omi_som;

memcpy(sbm->sbm_root_duid, duid, sizeof(sbm->sbm_root_duid))__builtin_memcpy((sbm->sbm_root_duid), (duid), (sizeof(sbm
->sbm_root_duid)));
bzero(&sbm->sbm_boot_duid, sizeof(sbm->sbm_boot_duid))__builtin_bzero((&sbm->sbm_boot_duid), (sizeof(sbm->
sbm_boot_duid)));
sbm->sbm_bootblk_size = bbs;
sbm->sbm_bootldr_size = bls;

DNPRINTF(SR_D_IOCTL, "sr_ioctl_installboot: root duid is %s\n",
   duid_format(sbm->sbm_root_duid));

/* Save boot block and boot loader to each chunk. */
for (i = 0; i < sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no; i++) {

chunk = sd->sd_vol.sv_chunks[i];
if (chunk->src_meta.scm_status != BIOC_SDONLINE0x00 &&
    chunk->src_meta.scm_status != BIOC_SDREBUILD0x03)
	continue;

if (i < SR_MAX_BOOT_DISKS16)
	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])))
	    sizeof(sbm->sbm_boot_duid[i]))__builtin_memcpy((&sbm->sbm_boot_duid[i]), (chunk->
src_duid), (sizeof(sbm->sbm_boot_duid[i])));

/* Save boot blocks. */
DNPRINTF(SR_D_IOCTL,
    "sr_ioctl_installboot: saving boot block to %s "
    "(%u bytes)\n", chunk->src_devname, bbs);

if (sr_rw(sc, chunk->src_dev_mm, bootblk, bbs,
    SR_BOOT_BLOCKS_OFFSET((16 + 64) + 320), B_WRITE0x00000000)) {
	sr_error(sc, "failed to write boot block");
	goto done;
}

/* Save boot loader.*/
DNPRINTF(SR_D_IOCTL,
    "sr_ioctl_installboot: saving boot loader to %s "
    "(%u bytes)\n", chunk->src_devname, bls);

if (sr_rw(sc, chunk->src_dev_mm, bootldr, bls,
    SR_BOOT_LOADER_OFFSET(16 + 64), B_WRITE0x00000000)) {
	sr_error(sc, "failed to write boot loader");
	goto done;
}
}

/* XXX - Install boot block on disk - MD code. */

/* Mark volume as bootable and save metadata. */
sd->sd_meta->ssdi_sdd_invariant.ssd_vol_flags |= BIOC_SCBOOTABLE0x08;
if (sr_meta_save(sd, SR_META_DIRTY0x1)) {
sr_error(sc, "could not save metadata to %s", DEVNAME(sc)((sc)->sc_dev.dv_xname));
goto done;
}

rv = 0;

3795done:
free(bootblk, M_DEVBUF2, bbs);
free(bootldr, M_DEVBUF2, bls);

return (rv);
3800}

3802void
3803sr_chunks_unwind(struct sr_softc *sc, struct sr_chunk_head *cl)
3804{
struct sr_chunk		*ch_entry, *ch_next;

DNPRINTF(SR_D_IOCTL, "%s: sr_chunks_unwind\n", DEVNAME(sc));

if (!cl)
return;

for (ch_entry = SLIST_FIRST(cl)((cl)->slh_first); ch_entry != NULL((void *)0); ch_entry = ch_next) {
ch_next = SLIST_NEXT(ch_entry, src_link)((ch_entry)->src_link.sle_next);

DNPRINTF(SR_D_IOCTL, "%s: sr_chunks_unwind closing: %s\n",
    DEVNAME(sc), ch_entry->src_devname);
if (ch_entry->src_vn) {
	/*
	 * XXX - explicitly lock the vnode until we can resolve
	 * the problem introduced by vnode aliasing... specfs
	 * has no locking, whereas ufs/ffs does!
	 */
	vn_lock(ch_entry->src_vn, LK_EXCLUSIVE0x0001UL | LK_RETRY0x2000UL);
	VOP_CLOSE(ch_entry->src_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);
	vput(ch_entry->src_vn);
}
free(ch_entry, M_DEVBUF2, sizeof(*ch_entry));
}
SLIST_INIT(cl){ ((cl)->slh_first) = ((void *)0); };
3831}

3833void
3834sr_discipline_free(struct sr_discipline *sd)
3835{
struct sr_softc		*sc;
struct sr_discipline	*sdtmp1;
struct sr_meta_opt_head *som;
struct sr_meta_opt_item	*omi, *omi_next;

if (!sd)
return;

sc = sd->sd_sc;

DNPRINTF(SR_D_DIS, "%s: sr_discipline_free %s\n",
   DEVNAME(sc),
   sd->sd_meta ? sd->sd_meta->ssd_devname : "nodev");
if (sd->sd_free_resources)
sd->sd_free_resources(sd);
free(sd->sd_vol.sv_chunks, M_DEVBUF2, 0);
free(sd->sd_meta, M_DEVBUF2, SR_META_SIZE64 * DEV_BSIZE(1 << 9));
free(sd->sd_meta_foreign, M_DEVBUF2, smd[sd->sd_meta_type].smd_size);

som = &sd->sd_meta_opt;
for (omi = SLIST_FIRST(som)((som)->slh_first); omi != NULL((void *)0); omi = omi_next) {
omi_next = SLIST_NEXT(omi, omi_link)((omi)->omi_link.sle_next);
free(omi->omi_som, M_DEVBUF2, 0);
free(omi, M_DEVBUF2, sizeof(*omi));
}

if (sd->sd_target != 0) {
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"
));
sc->sc_targets[sd->sd_target] = NULL((void *)0);
}

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)) {
if (sdtmp1 == sd)
	break;
}
if (sdtmp1 != NULL((void *)0))
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);

explicit_bzero(sd, sizeof *sd);
free(sd, M_DEVBUF2, sizeof(*sd));
3876}

3878void
3879sr_discipline_shutdown(struct sr_discipline *sd, int meta_save, int dying)
3880{
struct sr_softc		*sc;
int			ret, s;

if (!sd)
return;
sc = sd->sd_sc;

DNPRINTF(SR_D_DIS, "%s: sr_discipline_shutdown %s\n", DEVNAME(sc),
   sd->sd_meta ? sd->sd_meta->ssd_devname : "nodev");

/* If rebuilding, abort rebuild and drain I/O. */
if (sd->sd_reb_active) {
sd->sd_reb_abort = 1;
while (sd->sd_reb_active)
	tsleep_nsec(sd, PWAIT32, "sr_shutdown", MSEC_TO_NSEC(1));
}

if (meta_save)
sr_meta_save(sd, 0);

s = splbio()splraise(0x3);

sd->sd_ready = 0;

/* make sure there isn't a sync pending and yield */
wakeup(sd);
while (sd->sd_sync || sd->sd_must_flush) {
ret = tsleep_nsec(&sd->sd_sync, MAXPRI127, "sr_down",
    SEC_TO_NSEC(60));
if (ret == EWOULDBLOCK35)
	break;
}
if (dying == -1) {
sd->sd_ready = 1;
splx(s)spllower(s);
return;
}

3919#ifndef SMALL_KERNEL
sr_sensors_delete(sd);
3921#endif /* SMALL_KERNEL */

if (sd->sd_target != 0)
scsi_detach_lun(sc->sc_scsibus, sd->sd_target, 0,
    dying ? 0 : DETACH_FORCE0x01);

sr_chunks_unwind(sc, &sd->sd_vol.sv_chunk_list);

if (sd->sd_taskq)
taskq_destroy(sd->sd_taskq);

sr_discipline_free(sd);

splx(s)spllower(s);
3935}

3937int
3938sr_discipline_init(struct sr_discipline *sd, int level)
3939{
int			rv = 1;

/* Initialise discipline function pointers with defaults. */
sd->sd_alloc_resources = sr_alloc_resources;
sd->sd_assemble = NULL((void *)0);
sd->sd_create = NULL((void *)0);
sd->sd_free_resources = sr_free_resources;
sd->sd_ioctl_handler = NULL((void *)0);
sd->sd_openings = NULL((void *)0);
sd->sd_meta_opt_handler = NULL((void *)0);
sd->sd_rebuild = sr_rebuild;
sd->sd_scsi_inquiry = sr_raid_inquiry;
sd->sd_scsi_read_cap = sr_raid_read_cap;
sd->sd_scsi_tur = sr_raid_tur;
sd->sd_scsi_req_sense = sr_raid_request_sense;
sd->sd_scsi_start_stop = sr_raid_start_stop;
sd->sd_scsi_sync = sr_raid_sync;
sd->sd_scsi_rw = NULL((void *)0);
sd->sd_scsi_intr = sr_raid_intr;
sd->sd_scsi_wu_done = NULL((void *)0);
sd->sd_scsi_done = NULL((void *)0);
sd->sd_set_chunk_state = sr_set_chunk_state;
sd->sd_set_vol_state = sr_set_vol_state;
sd->sd_start_discipline = NULL((void *)0);

task_set(&sd->sd_meta_save_task, sr_meta_save_callback, sd);
task_set(&sd->sd_hotspare_rebuild_task, sr_hotspare_rebuild_callback,
   sd);

sd->sd_wu_size = sizeof(struct sr_workunit);
switch (level) {
case 0:
sr_raid0_discipline_init(sd);
break;
case 1:
sr_raid1_discipline_init(sd);
break;
case 5:
sr_raid5_discipline_init(sd);
break;
case 6:
sr_raid6_discipline_init(sd);
break;
3983#ifdef CRYPTO1
case 'C':
sr_crypto_discipline_init(sd);
break;
case 0x1C:
sr_raid1c_discipline_init(sd);
break;
3990#endif
case 'c':
sr_concat_discipline_init(sd);
break;
default:
goto bad;
}

rv = 0;
3999bad:
return (rv);
4001}

4003int
4004sr_raid_inquiry(struct sr_workunit *wu)
4005{
struct sr_discipline	*sd = wu->swu_dis;
struct scsi_xfer	*xs = wu->swu_xs;
struct scsi_inquiry	*cdb = (struct scsi_inquiry *)&xs->cmd;
struct scsi_inquiry_data inq;

DNPRINTF(SR_D_DIS, "%s: sr_raid_inquiry\n", DEVNAME(sd->sd_sc));

if (xs->cmdlen != sizeof(*cdb))
return (EINVAL22);

if (ISSET(cdb->flags, SI_EVPD)((cdb->flags) & (0x01)))
return (EOPNOTSUPP45);

bzero(&inq, sizeof(inq))__builtin_bzero((&inq), (sizeof(inq)));
inq.device = T_DIRECT0x00;
inq.dev_qual2 = 0;
inq.version = SCSI_REV_20x02;
inq.response_format = SID_SCSI2_RESPONSE0x02;
inq.additional_length = SID_SCSI2_ALEN31;
inq.flags |= SID_CmdQue0x02;
strlcpy(inq.vendor, sd->sd_meta->ssdi_sdd_invariant.ssd_vendor,
   sizeof(inq.vendor));
strlcpy(inq.product, sd->sd_meta->ssdi_sdd_invariant.ssd_product,
   sizeof(inq.product));
strlcpy(inq.revision, sd->sd_meta->ssdi_sdd_invariant.ssd_revision,
   sizeof(inq.revision));
scsi_copy_internal_data(xs, &inq, sizeof(inq));

return (0);
4035}

4037int
4038sr_raid_read_cap(struct sr_workunit *wu)
4039{
struct sr_discipline	*sd = wu->swu_dis;
struct scsi_xfer	*xs = wu->swu_xs;
struct scsi_read_cap_data rcd;
struct scsi_read_cap_data_16 rcd16;
u_int64_t		addr;
int			rv = 1;
u_int32_t		secsize;

DNPRINTF(SR_D_DIS, "%s: sr_raid_read_cap\n", DEVNAME(sd->sd_sc));

secsize = sd->sd_meta->ssdi_sdd_invariant.ssd_secsize;

addr = ((sd->sd_meta->ssdi_sdd_invariant.ssd_size * DEV_BSIZE(1 << 9)) / secsize) - 1;
if (xs->cmd.opcode == READ_CAPACITY0x25) {
bzero(&rcd, sizeof(rcd))__builtin_bzero((&rcd), (sizeof(rcd)));
if (addr > 0xffffffffllu)
	_lto4b(0xffffffff, rcd.addr);
else
	_lto4b(addr, rcd.addr);
_lto4b(secsize, rcd.length);
scsi_copy_internal_data(xs, &rcd, sizeof(rcd));
rv = 0;
} else if (xs->cmd.opcode == READ_CAPACITY_160x9e) {
bzero(&rcd16, sizeof(rcd16))__builtin_bzero((&rcd16), (sizeof(rcd16)));
_lto8b(addr, rcd16.addr);
_lto4b(secsize, rcd16.length);
scsi_copy_internal_data(xs, &rcd16, sizeof(rcd16));
rv = 0;
}

return (rv);
4071}

4073int
4074sr_raid_tur(struct sr_workunit *wu)
4075{
struct sr_discipline	*sd = wu->swu_dis;

DNPRINTF(SR_D_DIS, "%s: sr_raid_tur\n", DEVNAME(sd->sd_sc));

if (sd->sd_vol_status == BIOC_SVOFFLINE0x01) {
sd->sd_scsi_sense.error_code = SSD_ERRCODE_CURRENT0x70;
sd->sd_scsi_sense.flags = SKEY_NOT_READY0x02;
sd->sd_scsi_sense.add_sense_code = 0x04;
sd->sd_scsi_sense.add_sense_code_qual = 0x11;
sd->sd_scsi_sense.extra_len = 4;
return (1);
} else if (sd->sd_vol_status == BIOC_SVINVALID0xff) {
sd->sd_scsi_sense.error_code = SSD_ERRCODE_CURRENT0x70;
sd->sd_scsi_sense.flags = SKEY_HARDWARE_ERROR0x04;
sd->sd_scsi_sense.add_sense_code = 0x05;
sd->sd_scsi_sense.add_sense_code_qual = 0x00;
sd->sd_scsi_sense.extra_len = 4;
return (1);
}

return (0);
4097}

4099int
4100sr_raid_request_sense(struct sr_workunit *wu)
4101{
struct sr_discipline	*sd = wu->swu_dis;
struct scsi_xfer	*xs = wu->swu_xs;

DNPRINTF(SR_D_DIS, "%s: sr_raid_request_sense\n",
   DEVNAME(sd->sd_sc));

/* use latest sense data */
memcpy(&xs->sense, &sd->sd_scsi_sense, sizeof(xs->sense))__builtin_memcpy((&xs->sense), (&sd->sd_scsi_sense
), (sizeof(xs->sense)));

/* clear sense data */
bzero(&sd->sd_scsi_sense, sizeof(sd->sd_scsi_sense))__builtin_bzero((&sd->sd_scsi_sense), (sizeof(sd->sd_scsi_sense
)));

return (0);
4115}

4117int
4118sr_raid_start_stop(struct sr_workunit *wu)
4119{
struct scsi_xfer	*xs = wu->swu_xs;
struct scsi_start_stop	*ss = (struct scsi_start_stop *)&xs->cmd;

DNPRINTF(SR_D_DIS, "%s: sr_raid_start_stop\n",
   DEVNAME(wu->swu_dis->sd_sc));

if (!ss)
return (1);

/*
* do nothing!
* a softraid discipline should always reflect correct status
*/
return (0);
4134}

4136int
4137sr_raid_sync(struct sr_workunit *wu)
4138{
struct sr_discipline	*sd = wu->swu_dis;
int			s, ret, rv = 0, ios;

DNPRINTF(SR_D_DIS, "%s: sr_raid_sync\n", DEVNAME(sd->sd_sc));

/* when doing a fake sync don't count the wu */
ios = (wu->swu_flags & SR_WUF_FAKE(1<<6)) ? 0 : 1;

s = splbio()splraise(0x3);
sd->sd_sync = 1;
while (sd->sd_wu_pending > ios) {
ret = tsleep_nsec(sd, PRIBIO16, "sr_sync", SEC_TO_NSEC(15));
if (ret == EWOULDBLOCK35) {
	DNPRINTF(SR_D_DIS, "%s: sr_raid_sync timeout\n",
	    DEVNAME(sd->sd_sc));
	rv = 1;
	break;
}
}
sd->sd_sync = 0;
splx(s)spllower(s);

wakeup(&sd->sd_sync);

return (rv);
4164}

4166void
4167sr_raid_intr(struct buf *bp)
4168{
struct sr_ccb		*ccb = (struct sr_ccb *)bp;
struct sr_workunit	*wu = ccb->ccb_wu;
4171#ifdef SR_DEBUG
struct sr_discipline	*sd = wu->swu_dis;
struct scsi_xfer	*xs = wu->swu_xs;
4174#endif
int			s;

DNPRINTF(SR_D_INTR, "%s: %s %s intr bp %p xs %p\n",
   DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname, sd->sd_name, bp, xs);

s = splbio()splraise(0x3);
sr_ccb_done(ccb);
sr_wu_done(wu);
splx(s)spllower(s);
4184}

4186void
4187sr_schedule_wu(struct sr_workunit *wu)
4188{
struct sr_discipline	*sd = wu->swu_dis;
struct sr_workunit	*wup;
int			s;

DNPRINTF(SR_D_WU, "sr_schedule_wu: schedule wu %p state %i "
   "flags 0x%x\n", wu, wu->swu_state, wu->swu_flags);

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"
));

s = splbio()splraise(0x3);

/* Construct the work unit, do not schedule it. */
if (wu->swu_state == SR_WU_CONSTRUCT9)
goto queued;

/* Deferred work unit being reconstructed, do not start. */
if (wu->swu_state == SR_WU_REQUEUE8)
goto queued;

/* Current work unit failed, restart. */
if (wu->swu_state == SR_WU_RESTART7)
goto start;

if (wu->swu_state != SR_WU_INPROGRESS1)
panic("sr_schedule_wu: work unit not in progress (state %i)",
    wu->swu_state);

/* Walk queue backwards and fill in collider if we have one. */
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))) {
if (wu->swu_blk_end < wup->swu_blk_start ||
    wup->swu_blk_end < wu->swu_blk_start)
	continue;

/* Defer work unit due to LBA collision. */
DNPRINTF(SR_D_WU, "sr_schedule_wu: deferring work unit %p\n",
    wu);
wu->swu_state = SR_WU_DEFERRED5;
while (wup->swu_collider)
	wup = wup->swu_collider;
wup->swu_collider = wu;
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);
sd->sd_wu_collisions++;
goto queued;
}

4234start:
sr_raid_startwu(wu);

4237queued:
splx(s)spllower(s);
4239}

4241void
4242sr_raid_startwu(struct sr_workunit *wu)
4243{
struct sr_discipline	*sd = wu->swu_dis;
struct sr_ccb		*ccb;

DNPRINTF(SR_D_WU, "sr_raid_startwu: start wu %p\n", wu);

splassert(IPL_BIO)do { if (splassert_ctl > 0) { splassert_check(0x3, __func__
); } } while (0);

if (wu->swu_state == SR_WU_DEFERRED5) {
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);
wu->swu_state = SR_WU_INPROGRESS1;
}

if (wu->swu_state != SR_WU_RESTART7)
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);

/* Start all of the individual I/Os. */
if (wu->swu_cb_active == 1)
panic("%s: sr_startwu_callback", DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname));
wu->swu_cb_active = 1;

TAILQ_FOREACH(ccb, &wu->swu_ccb, ccb_link)for((ccb) = ((&wu->swu_ccb)->tqh_first); (ccb) != (
(void *)0); (ccb) = ((ccb)->ccb_link.tqe_next))
VOP_STRATEGY(ccb->ccb_buf.b_vp, &ccb->ccb_buf);

wu->swu_cb_active = 0;
4268}

4270void
4271sr_raid_recreate_wu(struct sr_workunit *wu)
4272{
struct sr_discipline	*sd = wu->swu_dis;
struct sr_workunit	*wup = wu;

/*
* Recreate a work unit by releasing the associated CCBs and reissuing
* the SCSI I/O request. This process is then repeated for all of the
* colliding work units.
*/
do {
sr_wu_release_ccbs(wup);

wup->swu_state = SR_WU_REQUEUE8;
if (sd->sd_scsi_rw(wup))
	panic("could not requeue I/O");

wup = wup->swu_collider;
} while (wup);
4290}

4292int
4293sr_alloc_resources(struct sr_discipline *sd)
4294{
if (sr_wu_alloc(sd)) {
sr_error(sd->sd_sc, "unable to allocate work units");
return (ENOMEM12);
}
if (sr_ccb_alloc(sd)) {
sr_error(sd->sd_sc, "unable to allocate ccbs");
return (ENOMEM12);
}

return (0);
4305}

4307void
4308sr_free_resources(struct sr_discipline *sd)
4309{
sr_wu_free(sd);
sr_ccb_free(sd);
4312}

4314void
4315sr_set_chunk_state(struct sr_discipline *sd, int c, int new_state)
4316{
int			old_state, s;

DNPRINTF(SR_D_STATE, "%s: %s: %s: sr_set_chunk_state %d -> %d\n",
   DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname,
   sd->sd_vol.sv_chunks[c]->src_meta.scmi.scm_devname, c, new_state);

/* ok to go to splbio since this only happens in error path */
s = splbio()splraise(0x3);
old_state = sd->sd_vol.sv_chunks[c]->src_meta.scm_status;

/* multiple IOs to the same chunk that fail will come through here */
if (old_state == new_state)
goto done;

switch (old_state) {
case BIOC_SDONLINE0x00:
if (new_state == BIOC_SDOFFLINE0x01)
	break;
else
	goto die;
break;

case BIOC_SDOFFLINE0x01:
goto die;

default:
4343die:
splx(s)spllower(s); /* XXX */
panic("%s: %s: %s: invalid chunk state transition %d -> %d",
    DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname),
    sd->sd_meta->ssd_devname,
    sd->sd_vol.sv_chunks[c]->src_meta.scmi_scm_invariant.scm_devname,
    old_state, new_state);
/* NOTREACHED */
}

sd->sd_vol.sv_chunks[c]->src_meta.scm_status = new_state;
sd->sd_set_vol_state(sd);

sd->sd_must_flush = 1;
task_add(systq, &sd->sd_meta_save_task);
4358done:
splx(s)spllower(s);
4360}

4362void
4363sr_set_vol_state(struct sr_discipline *sd)
4364{
int			states[SR_MAX_STATES7];
int			new_state, i, nd;
int			old_state = sd->sd_vol_status;
u_int32_t		s;

DNPRINTF(SR_D_STATE, "%s: %s: sr_set_vol_state\n",
   DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname);

nd = sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no;

for (i = 0; i < SR_MAX_STATES7; i++)
states[i] = 0;

for (i = 0; i < nd; i++) {
s = sd->sd_vol.sv_chunks[i]->src_meta.scm_status;
if (s >= SR_MAX_STATES7)
	panic("%s: %s: %s: invalid chunk state",
	    DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname),
	    sd->sd_meta->ssd_devname,
	    sd->sd_vol.sv_chunks[i]->src_meta.scmi_scm_invariant.scm_devname);
states[s]++;
}

if (states[BIOC_SDONLINE0x00] == nd)
new_state = BIOC_SVONLINE0x00;
else
new_state = BIOC_SVOFFLINE0x01;

DNPRINTF(SR_D_STATE, "%s: %s: sr_set_vol_state %d -> %d\n",
   DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname,
   old_state, new_state);

switch (old_state) {
case BIOC_SVONLINE0x00:
if (new_state == BIOC_SVOFFLINE0x01 || new_state == BIOC_SVONLINE0x00)
	break;
else
	goto die;
break;

case BIOC_SVOFFLINE0x01:
/* XXX this might be a little too much */
goto die;

default:
4410die:
panic("%s: %s: invalid volume state transition %d -> %d",
    DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname),
    sd->sd_meta->ssd_devname,
    old_state, new_state);
/* NOTREACHED */
}

sd->sd_vol_status = new_state;
4419}

4421void *
4422sr_block_get(struct sr_discipline *sd, long length)
4423{
return dma_alloc(length, PR_NOWAIT0x0002 | PR_ZERO0x0008);
4425}

4427void
4428sr_block_put(struct sr_discipline *sd, void *ptr, int length)
4429{
dma_free(ptr, length);
4431}

4433void
4434sr_checksum_print(u_int8_t *md5)
4435{
int			i;

for (i = 0; i < MD5_DIGEST_LENGTH16; i++)
printf("%02x", md5[i]);
4440}

4442void
4443sr_checksum(struct sr_softc *sc, void *src, void *md5, u_int32_t len)
4444{
MD5_CTX			ctx;

DNPRINTF(SR_D_MISC, "%s: sr_checksum(%p %p %d)\n", DEVNAME(sc), src,
   md5, len);

MD5Init(&ctx);
MD5Update(&ctx, src, len);
MD5Final(md5, &ctx);
4453}

4455void
4456sr_uuid_generate(struct sr_uuid *uuid)
4457{
arc4random_buf(uuid->sui_id, sizeof(uuid->sui_id));
/* UUID version 4: random */
uuid->sui_id[6] &= 0x0f;
uuid->sui_id[6] |= 0x40;
/* RFC4122 variant */
uuid->sui_id[8] &= 0x3f;
uuid->sui_id[8] |= 0x80;
4465}

4467char *
4468sr_uuid_format(struct sr_uuid *uuid)
4469{
char *uuidstr;

uuidstr = malloc(37, M_DEVBUF2, M_WAITOK0x0001);

snprintf(uuidstr, 37,
   "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-"
   "%02x%02x%02x%02x%02x%02x",
   uuid->sui_id[0], uuid->sui_id[1],
   uuid->sui_id[2], uuid->sui_id[3],
   uuid->sui_id[4], uuid->sui_id[5],
   uuid->sui_id[6], uuid->sui_id[7],
   uuid->sui_id[8], uuid->sui_id[9],
   uuid->sui_id[10], uuid->sui_id[11],
   uuid->sui_id[12], uuid->sui_id[13],
   uuid->sui_id[14], uuid->sui_id[15]);

return uuidstr;
4487}

4489void
4490sr_uuid_print(struct sr_uuid *uuid, int cr)
4491{
char *uuidstr;

uuidstr = sr_uuid_format(uuid);
printf("%s%s", uuidstr, (cr ? "\n" : ""));
free(uuidstr, M_DEVBUF2, 37);
4497}

4499int
4500sr_already_assembled(struct sr_discipline *sd)
4501{
struct sr_softc		*sc = sd->sd_sc;
struct sr_discipline	*sdtmp;

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)) {
if (!bcmp(&sd->sd_meta->ssdi_sdd_invariant.ssd_uuid,
    &sdtmp->sd_meta->ssdi_sdd_invariant.ssd_uuid,
    sizeof(sd->sd_meta->ssdi_sdd_invariant.ssd_uuid)))
	return (1);
}

return (0);
4513}

4515int32_t
4516sr_validate_stripsize(u_int32_t b)
4517{
int			s = 0;

if (b % DEV_BSIZE(1 << 9))
return (-1);

while ((b & 1) == 0) {
b >>= 1;
s++;
}

/* only multiple of twos */
b >>= 1;
if (b)
return(-1);

return (s);
4534}

4536void
4537sr_quiesce(void)
4538{
struct sr_softc		*sc = softraid0;
struct sr_discipline	*sd, *nsd;

if (sc == NULL((void *)0))
return;

/* Shutdown disciplines in reverse attach order. */
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))
   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))
sr_discipline_shutdown(sd, 1, -1);
4549}

4551void
4552sr_shutdown(int dying)
4553{
struct sr_softc		*sc = softraid0;
struct sr_discipline	*sd;

if (sc == NULL((void *)0))
return;

DNPRINTF(SR_D_MISC, "%s: sr_shutdown\n", DEVNAME(sc));

/*
* Since softraid is not under mainbus, we have to explicitly
* notify its children that the power is going down, so they
* can execute their shutdown hooks.
*/
config_suspend((struct device *)sc, DVACT_POWERDOWN6);

/* Shutdown disciplines in reverse attach order. */
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))
sr_discipline_shutdown(sd, 1, dying);
4572}

4574int
4575sr_validate_io(struct sr_workunit *wu, daddr_t *blkno, char *func)
4576{
struct sr_discipline	*sd = wu->swu_dis;
struct scsi_xfer	*xs = wu->swu_xs;
int			rv = 1;

DNPRINTF(SR_D_DIS, "%s: %s 0x%02x\n", DEVNAME(sd->sd_sc), func,
   xs->cmd.opcode);

if (sd->sd_meta->ssd_data_blkno == 0)
panic("invalid data blkno");

if (sd->sd_vol_status == BIOC_SVOFFLINE0x01) {
DNPRINTF(SR_D_DIS, "%s: %s device offline\n",
    DEVNAME(sd->sd_sc), func);
goto bad;
}

if (xs->datalen == 0) {
printf("%s: %s: illegal block count for %s\n",
    DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname), func, sd->sd_meta->ssd_devname);
goto bad;
}

if (xs->cmdlen == 10)
*blkno = _4btol(((struct scsi_rw_10 *)&xs->cmd)->addr);
else if (xs->cmdlen == 16)
*blkno = _8btol(((struct scsi_rw_16 *)&xs->cmd)->addr);
else if (xs->cmdlen == 6)
*blkno = _3btol(((struct scsi_rw *)&xs->cmd)->addr);
else {
printf("%s: %s: illegal cmdlen for %s\n",
    DEVNAME(sd->sd_sc)((sd->sd_sc)->sc_dev.dv_xname), func, sd->sd_meta->ssd_devname);
goto bad;
}

*blkno *= (sd->sd_meta->ssdi_sdd_invariant.ssd_secsize / DEV_BSIZE(1 << 9));

wu->swu_blk_start = *blkno;
wu->swu_blk_end = *blkno + (xs->datalen >> DEV_BSHIFT9) - 1;

if (wu->swu_blk_end > sd->sd_meta->ssdi_sdd_invariant.ssd_size) {
DNPRINTF(SR_D_DIS, "%s: %s out of bounds start: %lld "
    "end: %lld length: %d\n",
    DEVNAME(sd->sd_sc), func, (long long)wu->swu_blk_start,
    (long long)wu->swu_blk_end, xs->datalen);

sd->sd_scsi_sense.error_code = SSD_ERRCODE_CURRENT0x70 |
    SSD_ERRCODE_VALID0x80;
sd->sd_scsi_sense.flags = SKEY_ILLEGAL_REQUEST0x05;
sd->sd_scsi_sense.add_sense_code = 0x21;
sd->sd_scsi_sense.add_sense_code_qual = 0x00;
sd->sd_scsi_sense.extra_len = 4;
goto bad;
}

rv = 0;
4632bad:
return (rv);
4634}

4636void
4637sr_rebuild_start(void *arg)
4638{
struct sr_discipline	*sd = arg;
struct sr_softc		*sc = sd->sd_sc;

DNPRINTF(SR_D_REBUILD, "%s: %s starting rebuild thread\n",
   DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname);

if (kthread_create(sr_rebuild_thread, sd, &sd->sd_background_proc,
   DEVNAME(sc)((sc)->sc_dev.dv_xname)) != 0)
printf("%s: unable to start background operation\n",
    DEVNAME(sc)((sc)->sc_dev.dv_xname));
4649}

4651void
4652sr_rebuild_thread(void *arg)
4653{
struct sr_discipline	*sd = arg;

DNPRINTF(SR_D_REBUILD, "%s: %s rebuild thread started\n",
   DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname);

sd->sd_reb_active = 1;
sd->sd_rebuild(sd);
sd->sd_reb_active = 0;

kthread_exit(0);
4664}

4666void
4667sr_rebuild(struct sr_discipline *sd)
4668{
struct sr_softc		*sc = sd->sd_sc;
u_int64_t		sz, whole_blk, partial_blk, blk, restart;
daddr_t			lba;
struct sr_workunit	*wu_r, *wu_w;
struct scsi_xfer	xs_r, xs_w;
struct scsi_rw_16	*cr, *cw;
int			c, s, slept, percent = 0, old_percent = -1;
u_int8_t		*buf;

whole_blk = sd->sd_meta->ssdi_sdd_invariant.ssd_size / SR_REBUILD_IO_SIZE128;
partial_blk = sd->sd_meta->ssdi_sdd_invariant.ssd_size % SR_REBUILD_IO_SIZE128;

restart = sd->sd_meta->ssd_rebuild / SR_REBUILD_IO_SIZE128;
if (restart > whole_blk) {
printf("%s: bogus rebuild restart offset, starting from 0\n",
    DEVNAME(sc)((sc)->sc_dev.dv_xname));
restart = 0;
}
if (restart) {
/*
 * XXX there is a hole here; there is a possibility that we
 * had a restart however the chunk that was supposed to
 * be rebuilt is no longer valid; we can reach this situation
 * when a rebuild is in progress and the box crashes and
 * on reboot the rebuild chunk is different (like zero'd or
 * replaced).  We need to check the uuid of the chunk that is
 * being rebuilt to assert this.
 */
percent = sr_rebuild_percent(sd);
printf("%s: resuming rebuild on %s at %d%%\n",
    DEVNAME(sc)((sc)->sc_dev.dv_xname), sd->sd_meta->ssd_devname, percent);
}

/* currently this is 64k therefore we can use dma_alloc */
buf = dma_alloc(SR_REBUILD_IO_SIZE128 << DEV_BSHIFT9, PR_WAITOK0x0001);
for (blk = restart; blk <= whole_blk; blk++) {
lba = blk * SR_REBUILD_IO_SIZE128;
sz = SR_REBUILD_IO_SIZE128;
if (blk == whole_blk) {
	if (partial_blk == 0)
		break;
	sz = partial_blk;
}

/* get some wu */
wu_r = sr_scsi_wu_get(sd, 0);
wu_w = sr_scsi_wu_get(sd, 0);

DNPRINTF(SR_D_REBUILD, "%s: %s rebuild wu_r %p, wu_w %p\n",
    DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname, wu_r, wu_w);

/* setup read io */
bzero(&xs_r, sizeof xs_r)__builtin_bzero((&xs_r), (sizeof xs_r));
xs_r.error = XS_NOERROR0;
xs_r.flags = SCSI_DATA_IN0x00800;
xs_r.datalen = sz << DEV_BSHIFT9;
xs_r.data = buf;
xs_r.cmdlen = sizeof(*cr);
cr = (struct scsi_rw_16 *)&xs_r.cmd;
cr->opcode = READ_160x88;
_lto4b(sz, cr->length);
_lto8b(lba, cr->addr);
wu_r->swu_state = SR_WU_CONSTRUCT9;
wu_r->swu_flags |= SR_WUF_REBUILD(1<<0);
wu_r->swu_xs = &xs_r;
if (sd->sd_scsi_rw(wu_r)) {
	printf("%s: could not create read io\n",
	    DEVNAME(sc)((sc)->sc_dev.dv_xname));
	goto fail;
}

/* setup write io */
bzero(&xs_w, sizeof xs_w)__builtin_bzero((&xs_w), (sizeof xs_w));
xs_w.error = XS_NOERROR0;
xs_w.flags = SCSI_DATA_OUT0x01000;
xs_w.datalen = sz << DEV_BSHIFT9;
xs_w.data = buf;
xs_w.cmdlen = sizeof(*cw);
cw = (struct scsi_rw_16 *)&xs_w.cmd;
cw->opcode = WRITE_160x8a;
_lto4b(sz, cw->length);
_lto8b(lba, cw->addr);
wu_w->swu_state = SR_WU_CONSTRUCT9;
wu_w->swu_flags |= SR_WUF_REBUILD(1<<0) | SR_WUF_WAKEUP(1<<4);
wu_w->swu_xs = &xs_w;
if (sd->sd_scsi_rw(wu_w)) {
	printf("%s: could not create write io\n",
	    DEVNAME(sc)((sc)->sc_dev.dv_xname));
	goto fail;
}

/*
 * collide with the read io so that we get automatically
 * started when the read is done
 */
wu_w->swu_state = SR_WU_DEFERRED5;
wu_r->swu_collider = wu_w;
s = splbio()splraise(0x3);
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);
splx(s)spllower(s);

DNPRINTF(SR_D_REBUILD, "%s: %s rebuild scheduling wu_r %p\n",
    DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname, wu_r);

wu_r->swu_state = SR_WU_INPROGRESS1;
sr_schedule_wu(wu_r);

/* wait for write completion */
slept = 0;
while ((wu_w->swu_flags & SR_WUF_REBUILDIOCOMP(1<<1)) == 0) {
	tsleep_nsec(wu_w, PRIBIO16, "sr_rebuild", INFSLP0xffffffffffffffffULL);
	slept = 1;
}
/* yield if we didn't sleep */
if (slept == 0)
	tsleep_nsec(sc, PWAIT32, "sr_yield", MSEC_TO_NSEC(1));

sr_scsi_wu_put(sd, wu_r);
sr_scsi_wu_put(sd, wu_w);

sd->sd_meta->ssd_rebuild = lba;

/* XXX - this should be based on size, not percentage. */
/* save metadata every percent */
percent = sr_rebuild_percent(sd);
if (percent != old_percent && blk != whole_blk) {
	if (sr_meta_save(sd, SR_META_DIRTY0x1))
		printf("%s: could not save metadata to %s\n",
		    DEVNAME(sc)((sc)->sc_dev.dv_xname), sd->sd_meta->ssd_devname);
	old_percent = percent;
}

if (sd->sd_reb_abort)
	goto abort;
}

/* all done */
sd->sd_meta->ssd_rebuild = 0;
for (c = 0; c < sd->sd_meta->ssdi_sdd_invariant.ssd_chunk_no; c++) {
if (sd->sd_vol.sv_chunks[c]->src_meta.scm_status ==
    BIOC_SDREBUILD0x03) {
	sd->sd_set_chunk_state(sd, c, BIOC_SDONLINE0x00);
	break;
}
}

4815abort:
if (sr_meta_save(sd, SR_META_DIRTY0x1))
printf("%s: could not save metadata to %s\n",
    DEVNAME(sc)((sc)->sc_dev.dv_xname), sd->sd_meta->ssd_devname);
4819fail:
dma_free(buf, SR_REBUILD_IO_SIZE128 << DEV_BSHIFT9);
4821}

4823struct sr_discipline *
4824sr_find_discipline(struct sr_softc *sc, const char *devname)
4825{
struct sr_discipline	*sd;

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))
if (!strncmp(sd->sd_meta->ssd_devname, devname,
    sizeof(sd->sd_meta->ssd_devname)))
	break;
return sd;
4833}

4835#ifndef SMALL_KERNEL
4836int
4837sr_sensors_create(struct sr_discipline *sd)
4838{
struct sr_softc		*sc = sd->sd_sc;
int			rv = 1;

DNPRINTF(SR_D_STATE, "%s: %s: sr_sensors_create\n",
   DEVNAME(sc), sd->sd_meta->ssd_devname);

sd->sd_vol.sv_sensor.type = SENSOR_DRIVE;
sd->sd_vol.sv_sensor.status = SENSOR_S_UNKNOWN;
strlcpy(sd->sd_vol.sv_sensor.desc, sd->sd_meta->ssd_devname,
   sizeof(sd->sd_vol.sv_sensor.desc));

sensor_attach(&sc->sc_sensordev, &sd->sd_vol.sv_sensor);
sd->sd_vol.sv_sensor_attached = 1;

if (sc->sc_sensor_task == NULL((void *)0)) {
sc->sc_sensor_task = sensor_task_register(sc,
    sr_sensors_refresh, 10);
if (sc->sc_sensor_task == NULL((void *)0))
	goto bad;
}

rv = 0;
4861bad:
return (rv);
4863}

4865void
4866sr_sensors_delete(struct sr_discipline *sd)
4867{
DNPRINTF(SR_D_STATE, "%s: sr_sensors_delete\n", DEVNAME(sd->sd_sc));

if (sd->sd_vol.sv_sensor_attached)
sensor_detach(&sd->sd_sc->sc_sensordev, &sd->sd_vol.sv_sensor);
4872}

4874void
4875sr_sensors_refresh(void *arg)
4876{
struct sr_softc		*sc = arg;
struct sr_volume	*sv;
struct sr_discipline	*sd;

DNPRINTF(SR_D_STATE, "%s: sr_sensors_refresh\n", DEVNAME(sc));

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)) {
sv = &sd->sd_vol;

switch(sd->sd_vol_status) {
case BIOC_SVOFFLINE0x01:
	sv->sv_sensor.value = SENSOR_DRIVE_FAIL9;
	sv->sv_sensor.status = SENSOR_S_CRIT;
	break;

case BIOC_SVDEGRADED0x02:
	sv->sv_sensor.value = SENSOR_DRIVE_PFAIL10;
	sv->sv_sensor.status = SENSOR_S_WARN;
	break;

case BIOC_SVREBUILD0x05:
	sv->sv_sensor.value = SENSOR_DRIVE_REBUILD7;
	sv->sv_sensor.status = SENSOR_S_WARN;
	break;

case BIOC_SVSCRUB0x04:
case BIOC_SVONLINE0x00:
	sv->sv_sensor.value = SENSOR_DRIVE_ONLINE4;
	sv->sv_sensor.status = SENSOR_S_OK;
	break;

default:
	sv->sv_sensor.value = 0; /* unknown */
	sv->sv_sensor.status = SENSOR_S_UNKNOWN;
}
}
4913}
4914#endif /* SMALL_KERNEL */

4916#ifdef SR_FANCY_STATS
4917void				sr_print_stats(void);

4919void
4920sr_print_stats(void)
4921{
struct sr_softc		*sc = softraid0;
struct sr_discipline	*sd;

if (sc == NULL((void *)0)) {
printf("no softraid softc found\n");
return;
}

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)) {
printf("%s: ios pending %d, collisions %llu\n",
    sd->sd_meta->ssd_devname,
    sd->sd_wu_pending,
    sd->sd_wu_collisions);
}
4936}
4937#endif /* SR_FANCY_STATS */

4939#ifdef SR_DEBUG
4940void
4941sr_meta_print(struct sr_metadata *m)
4942{
int			i;
struct sr_meta_chunk	*mc;
struct sr_meta_opt_hdr	*omh;

if (!(sr_debug & SR_D_META))
return;

printf("\tssd_magic 0x%llx\n", m->ssdi_sdd_invariant.ssd_magic);
printf("\tssd_version %d\n", m->ssdi_sdd_invariant.ssd_version);
printf("\tssd_vol_flags 0x%x\n", m->ssdi_sdd_invariant.ssd_vol_flags);
printf("\tssd_uuid ");
sr_uuid_print(&m->ssdi_sdd_invariant.ssd_uuid, 1);
printf("\tssd_chunk_no %d\n", m->ssdi_sdd_invariant.ssd_chunk_no);
printf("\tssd_chunk_id %d\n", m->ssdi_sdd_invariant.ssd_chunk_id);
printf("\tssd_opt_no %d\n", m->ssdi_sdd_invariant.ssd_opt_no);
printf("\tssd_volid %d\n", m->ssdi_sdd_invariant.ssd_volid);
printf("\tssd_level %d\n", m->ssdi_sdd_invariant.ssd_level);
printf("\tssd_size %lld\n", m->ssdi_sdd_invariant.ssd_size);
printf("\tssd_devname %s\n", m->ssd_devname);
printf("\tssd_vendor %s\n", m->ssdi_sdd_invariant.ssd_vendor);
printf("\tssd_product %s\n", m->ssdi_sdd_invariant.ssd_product);
printf("\tssd_revision %s\n", m->ssdi_sdd_invariant.ssd_revision);
printf("\tssd_strip_size %d\n", m->ssdi_sdd_invariant.ssd_strip_size);
printf("\tssd_checksum ");
sr_checksum_print(m->ssd_checksum);
printf("\n");
printf("\tssd_meta_flags 0x%x\n", m->ssd_meta_flags);
printf("\tssd_ondisk %llu\n", m->ssd_ondisk);

mc = (struct sr_meta_chunk *)(m + 1);
for (i = 0; i < m->ssdi_sdd_invariant.ssd_chunk_no; i++, mc++) {
printf("\t\tscm_volid %d\n", mc->scmi_scm_invariant.scm_volid);
printf("\t\tscm_chunk_id %d\n", mc->scmi_scm_invariant.scm_chunk_id);
printf("\t\tscm_devname %s\n", mc->scmi_scm_invariant.scm_devname);
printf("\t\tscm_size %lld\n", mc->scmi_scm_invariant.scm_size);
printf("\t\tscm_coerced_size %lld\n",mc->scmi_scm_invariant.scm_coerced_size);
printf("\t\tscm_uuid ");
sr_uuid_print(&mc->scmi_scm_invariant.scm_uuid, 1);
printf("\t\tscm_checksum ");
sr_checksum_print(mc->scm_checksum);
printf("\n");
printf("\t\tscm_status %d\n", mc->scm_status);
}

omh = (struct sr_meta_opt_hdr *)((u_int8_t *)(m + 1) +
   sizeof(struct sr_meta_chunk) * m->ssdi_sdd_invariant.ssd_chunk_no);
for (i = 0; i < m->ssdi_sdd_invariant.ssd_opt_no; i++) {
printf("\t\t\tsom_type %d\n", omh->som_type);
printf("\t\t\tsom_checksum ");
sr_checksum_print(omh->som_checksum);
printf("\n");
omh = (struct sr_meta_opt_hdr *)((void *)omh +
    omh->som_length);
}
4997}

4999void
5000sr_dump_block(void *blk, int len)
5001{
uint8_t			*b = blk;
int			i, j, c;

for (i = 0; i < len; i += 16) {
for (j = 0; j < 16; j++)
	printf("%.2x ", b[i + j]);
printf("  ");
for (j = 0; j < 16; j++) {
	c = b[i + j];
	if (c < ' ' || c > 'z' || i + j > len)
		c = '.';
	printf("%c", c);
}
printf("\n");
}
5017}

5019void
5020sr_dump_mem(u_int8_t *p, int len)
5021{
int			i;

for (i = 0; i < len; i++)
printf("%02x ", *p++);
printf("\n");
5027}

5029#endif /* SR_DEBUG */

5031#ifdef HIBERNATE1
5032/*
* Side-effect free (no malloc, printf, pool, splx) softraid crypto writer.
*
* This function must perform the following:
* 1. Determine the underlying device's own side-effect free I/O function
*    (eg, ahci_hibernate_io, wd_hibernate_io, etc).
* 2. Store enough information in the provided page argument for subsequent
*    I/O calls (such as the crypto discipline structure for the keys, the
*    offset of the softraid partition on the underlying disk, as well as
*    the offset of the swap partition within the crypto volume.
* 3. Encrypt the incoming data using the sr_discipline keys, then pass
*    the request to the underlying device's own I/O function.
*/
5045int
5046sr_hibernate_io(dev_t dev, daddr_t blkno, vaddr_t addr, size_t size, int op, void *page)
5047{
/* Struct for stashing data obtained on HIB_INIT.
* XXX
* We share the page with the underlying device's own
* side-effect free I/O function, so we pad our data to
* the end of the page. Presently this does not overlap
* with either of the two other side-effect free i/o
* functions (ahci/wd).
*/
struct {
char pad[3072];
struct sr_discipline *srd;
hibio_fn subfn;		/* underlying device i/o fn */
dev_t subdev;		/* underlying device dev_t */
daddr_t sr_swapoff;	/* ofs of swap part in sr volume */
char buf[DEV_BSIZE(1 << 9)];	/* encryption performed into this buf */
} *my = page;
extern struct cfdriver sd_cd;
char errstr[128], *dl_ret;
struct sr_chunk *schunk;
struct sd_softc *sd;
struct aes_xts_ctx ctx;
struct sr_softc *sc;
struct device *dv;
daddr_t key_blkno;
uint32_t sub_raidoff;  /* ofs of sr part in underlying dev */
struct disklabel dl;
struct partition *pp;
size_t i, j;
u_char iv[8];

/*
* In HIB_INIT, we are passed the swap partition size and offset
* in 'size' and 'blkno' respectively. These are relative to the
* start of the softraid partition, and we need to save these
* for later translation to the underlying device's layout.
*/
if (op == HIB_INIT-1) {
dv = disk_lookup(&sd_cd, DISKUNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
 8)) / 16));
sd = (struct sd_softc *)dv;
sc = (struct sr_softc *)dv->dv_parent->dv_parent;

/*
 * Look up the sr discipline. This is used to determine
 * if we are SR crypto and what the underlying device is.
 */
my->srd = sc->sc_targets[sd->sc_link->target];
DNPRINTF(SR_D_MISC, "sr_hibernate_io: discipline is %s\n",
	my->srd->sd_name);
if (strncmp(my->srd->sd_name, "CRYPTO",
    sizeof(my->srd->sd_name)))
	return (ENOTSUP91);

/* Find the underlying device */
schunk = my->srd->sd_vol.sv_chunks[0];
my->subdev = schunk->src_dev_mm;

/*
 * Find the appropriate underlying device side effect free
 * I/O function, based on the type of device it is.
 */
my->subfn = get_hibernate_io_function(my->subdev);
if (!my->subfn)
	return (ENODEV19);

/*
 * Find blkno where this raid partition starts on
 * the underlying disk.
 */
dl_ret = disk_readlabel(&dl, my->subdev, errstr,
    sizeof(errstr));
if (dl_ret) {
	printf("Hibernate error reading disklabel: %s\n", dl_ret);
	return (ENOTSUP91);
}

pp = &dl.d_partitions[DISKPART(my->subdev)(((unsigned)((my->subdev) & 0xff) | (((my->subdev) &
 0xffff0000) >> 8)) % 16)];
if (pp->p_fstype != FS_RAID19 || DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size) == 0)
	return (ENOTSUP91);

/* Find the blkno of the SR part in the underlying device */
sub_raidoff = my->srd->sd_meta->ssd_data_blkno +
    DL_SECTOBLK(&dl, DL_GETPOFFSET(pp))(((((u_int64_t)(pp)->p_offseth << 32) + (pp)->p_offset
)) * ((&dl)->d_secsize / (1 << 9)));
DNPRINTF(SR_D_MISC,"sr_hibernate_io: blk trans ofs: %d blks\n",
    sub_raidoff);

/* Save the blkno of the swap partition in the SR disk */
my->sr_swapoff = blkno;

/* Initialize the sub-device */
return my->subfn(my->subdev, sub_raidoff + blkno,
    addr, size, op, page);
}

/* Hibernate only uses (and we only support) writes */
if (op != HIB_W1)
return (ENOTSUP91);

/*
* Blocks act as the IV for the encryption. These block numbers
* are relative to the start of the sr partition, but the 'blkno'
* passed above is relative to the start of the swap partition
* inside the sr partition, so bias appropriately.
*/
key_blkno = my->sr_swapoff + blkno;

/* Process each disk block one at a time. */
for (i = 0; i < size; i += DEV_BSIZE(1 << 9)) {
int res;

bzero(&ctx, sizeof(ctx))__builtin_bzero((&ctx), (sizeof(ctx)));

/*
 * Set encryption key (from the sr discipline stashed
 * during HIB_INIT. This code is based on the softraid
 * bootblock code.
 */
aes_xts_setkey(&ctx, my->srd->mdssd_dis_specific.mdd_crypto.scr_key[0], 64);
/* We encrypt DEV_BSIZE bytes at a time in my->buf */
memcpy(my->buf, ((char *)addr) + i, DEV_BSIZE)__builtin_memcpy((my->buf), (((char *)addr) + i), ((1 <<
 9)));

/* Block number is the IV */
memcpy(&iv, &key_blkno, sizeof(key_blkno))__builtin_memcpy((&iv), (&key_blkno), (sizeof(key_blkno
)));
aes_xts_reinit(&ctx, iv);

/* Encrypt DEV_BSIZE bytes, AES_XTS_BLOCKSIZE bytes at a time */
for (j = 0; j < DEV_BSIZE(1 << 9); j += AES_XTS_BLOCKSIZE16)
	aes_xts_encrypt(&ctx, my->buf + j);

/*
 * Write one block out from my->buf to the underlying device
 * using its own side-effect free I/O function.
 */
res = my->subfn(my->subdev, blkno + (i / DEV_BSIZE(1 << 9)),
    (vaddr_t)(my->buf), DEV_BSIZE(1 << 9), op, page);
if (res != 0)
	return (res);
key_blkno++;
}
return (0);
5187}
5188#endif /* HIBERNATE */