1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2005 Pawel Jakub Dawidek <pjd@FreeBSD.org>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__FBSDID("$FreeBSD$");
31
32#include <sys/param.h>
33#include <sys/systm.h>
34#include <sys/kernel.h>
35#include <sys/module.h>
36#include <sys/lock.h>
37#include <sys/mutex.h>
38#include <sys/bio.h>
39#include <sys/sbuf.h>
40#include <sys/sysctl.h>
41#include <sys/malloc.h>
42#include <vm/uma.h>
43#include <geom/geom.h>
44#include <geom/geom_dbg.h>
45#include <geom/shsec/g_shsec.h>
46
47FEATURE(geom_shsec, "GEOM shared secret device support");
48
49static MALLOC_DEFINE(M_SHSEC, "shsec_data", "GEOM_SHSEC Data");
50
51static uma_zone_t g_shsec_zone;
52
53static int g_shsec_destroy(struct g_shsec_softc *sc, boolean_t force);
54static int g_shsec_destroy_geom(struct gctl_req *req, struct g_class *mp,
55    struct g_geom *gp);
56
57static g_taste_t g_shsec_taste;
58static g_ctl_req_t g_shsec_config;
59static g_dumpconf_t g_shsec_dumpconf;
60static g_init_t g_shsec_init;
61static g_fini_t g_shsec_fini;
62
63struct g_class g_shsec_class = {
64	.name = G_SHSEC_CLASS_NAME,
65	.version = G_VERSION,
66	.ctlreq = g_shsec_config,
67	.taste = g_shsec_taste,
68	.destroy_geom = g_shsec_destroy_geom,
69	.init = g_shsec_init,
70	.fini = g_shsec_fini
71};
72
73SYSCTL_DECL(_kern_geom);
74static SYSCTL_NODE(_kern_geom, OID_AUTO, shsec, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
75    "GEOM_SHSEC stuff");
76static u_int g_shsec_debug;
77SYSCTL_UINT(_kern_geom_shsec, OID_AUTO, debug, CTLFLAG_RWTUN, &g_shsec_debug, 0,
78    "Debug level");
79static u_long g_shsec_maxmem;
80SYSCTL_ULONG(_kern_geom_shsec, OID_AUTO, maxmem,
81    CTLFLAG_RDTUN | CTLFLAG_NOFETCH, &g_shsec_maxmem,
82    0, "Maximum memory that can be allocated for I/O (in bytes)");
83static u_int g_shsec_alloc_failed = 0;
84SYSCTL_UINT(_kern_geom_shsec, OID_AUTO, alloc_failed, CTLFLAG_RD,
85    &g_shsec_alloc_failed, 0, "How many times I/O allocation failed");
86
87/*
88 * Greatest Common Divisor.
89 */
90static u_int
91gcd(u_int a, u_int b)
92{
93	u_int c;
94
95	while (b != 0) {
96		c = a;
97		a = b;
98		b = (c % b);
99	}
100	return (a);
101}
102
103/*
104 * Least Common Multiple.
105 */
106static u_int
107lcm(u_int a, u_int b)
108{
109
110	return ((a * b) / gcd(a, b));
111}
112
113static void
114g_shsec_init(struct g_class *mp __unused)
115{
116
117	g_shsec_maxmem = maxphys * 100;
118	TUNABLE_ULONG_FETCH("kern.geom.shsec.maxmem,", &g_shsec_maxmem);
119	g_shsec_zone = uma_zcreate("g_shsec_zone", maxphys, NULL, NULL, NULL,
120	    NULL, 0, 0);
121	g_shsec_maxmem -= g_shsec_maxmem % maxphys;
122	uma_zone_set_max(g_shsec_zone, g_shsec_maxmem / maxphys);
123}
124
125static void
126g_shsec_fini(struct g_class *mp __unused)
127{
128
129	uma_zdestroy(g_shsec_zone);
130}
131
132/*
133 * Return the number of valid disks.
134 */
135static u_int
136g_shsec_nvalid(struct g_shsec_softc *sc)
137{
138	u_int i, no;
139
140	no = 0;
141	for (i = 0; i < sc->sc_ndisks; i++) {
142		if (sc->sc_disks[i] != NULL)
143			no++;
144	}
145
146	return (no);
147}
148
149static void
150g_shsec_remove_disk(struct g_consumer *cp)
151{
152	struct g_shsec_softc *sc;
153	u_int no;
154
155	KASSERT(cp != NULL, ("Non-valid disk in %s.", __func__));
156	sc = (struct g_shsec_softc *)cp->private;
157	KASSERT(sc != NULL, ("NULL sc in %s.", __func__));
158	no = cp->index;
159
160	G_SHSEC_DEBUG(0, "Disk %s removed from %s.", cp->provider->name,
161	    sc->sc_name);
162
163	sc->sc_disks[no] = NULL;
164	if (sc->sc_provider != NULL) {
165		g_wither_provider(sc->sc_provider, ENXIO);
166		sc->sc_provider = NULL;
167		G_SHSEC_DEBUG(0, "Device %s removed.", sc->sc_name);
168	}
169
170	if (cp->acr > 0 || cp->acw > 0 || cp->ace > 0)
171		return;
172	g_detach(cp);
173	g_destroy_consumer(cp);
174}
175
176static void
177g_shsec_orphan(struct g_consumer *cp)
178{
179	struct g_shsec_softc *sc;
180	struct g_geom *gp;
181
182	g_topology_assert();
183	gp = cp->geom;
184	sc = gp->softc;
185	if (sc == NULL)
186		return;
187
188	g_shsec_remove_disk(cp);
189	/* If there are no valid disks anymore, remove device. */
190	if (LIST_EMPTY(&gp->consumer))
191		g_shsec_destroy(sc, 1);
192}
193
194static int
195g_shsec_access(struct g_provider *pp, int dr, int dw, int de)
196{
197	struct g_consumer *cp1, *cp2, *tmp;
198	struct g_shsec_softc *sc;
199	struct g_geom *gp;
200	int error;
201
202	gp = pp->geom;
203	sc = gp->softc;
204
205	/* On first open, grab an extra "exclusive" bit */
206	if (pp->acr == 0 && pp->acw == 0 && pp->ace == 0)
207		de++;
208	/* ... and let go of it on last close */
209	if ((pp->acr + dr) == 0 && (pp->acw + dw) == 0 && (pp->ace + de) == 0)
210		de--;
211
212	error = ENXIO;
213	LIST_FOREACH_SAFE(cp1, &gp->consumer, consumer, tmp) {
214		error = g_access(cp1, dr, dw, de);
215		if (error != 0)
216			goto fail;
217		if (cp1->acr == 0 && cp1->acw == 0 && cp1->ace == 0 &&
218		    cp1->flags & G_CF_ORPHAN) {
219			g_detach(cp1);
220			g_destroy_consumer(cp1);
221		}
222	}
223
224	/* If there are no valid disks anymore, remove device. */
225	if (LIST_EMPTY(&gp->consumer))
226		g_shsec_destroy(sc, 1);
227
228	return (error);
229
230fail:
231	/* If we fail here, backout all previous changes. */
232	LIST_FOREACH(cp2, &gp->consumer, consumer) {
233		if (cp1 == cp2)
234			break;
235		g_access(cp2, -dr, -dw, -de);
236	}
237	return (error);
238}
239
240static void
241g_shsec_xor1(uint32_t *src, uint32_t *dst, ssize_t len)
242{
243
244	for (; len > 0; len -= sizeof(uint32_t), dst++)
245		*dst = *dst ^ *src++;
246	KASSERT(len == 0, ("len != 0 (len=%zd)", len));
247}
248
249static void
250g_shsec_done(struct bio *bp)
251{
252	struct g_shsec_softc *sc;
253	struct bio *pbp;
254
255	pbp = bp->bio_parent;
256	sc = pbp->bio_to->geom->softc;
257	if (bp->bio_error == 0)
258		G_SHSEC_LOGREQ(2, bp, "Request done.");
259	else {
260		G_SHSEC_LOGREQ(0, bp, "Request failed (error=%d).",
261		    bp->bio_error);
262		if (pbp->bio_error == 0)
263			pbp->bio_error = bp->bio_error;
264	}
265	if (pbp->bio_cmd == BIO_READ) {
266		if ((pbp->bio_pflags & G_SHSEC_BFLAG_FIRST) != 0) {
267			bcopy(bp->bio_data, pbp->bio_data, pbp->bio_length);
268			pbp->bio_pflags = 0;
269		} else {
270			g_shsec_xor1((uint32_t *)bp->bio_data,
271			    (uint32_t *)pbp->bio_data,
272			    (ssize_t)pbp->bio_length);
273		}
274	}
275	explicit_bzero(bp->bio_data, bp->bio_length);
276	uma_zfree(g_shsec_zone, bp->bio_data);
277	g_destroy_bio(bp);
278	pbp->bio_inbed++;
279	if (pbp->bio_children == pbp->bio_inbed) {
280		pbp->bio_completed = pbp->bio_length;
281		g_io_deliver(pbp, pbp->bio_error);
282	}
283}
284
285static void
286g_shsec_xor2(uint32_t *rand, uint32_t *dst, ssize_t len)
287{
288
289	for (; len > 0; len -= sizeof(uint32_t), dst++) {
290		*rand = arc4random();
291		*dst = *dst ^ *rand++;
292	}
293	KASSERT(len == 0, ("len != 0 (len=%zd)", len));
294}
295
296static void
297g_shsec_start(struct bio *bp)
298{
299	TAILQ_HEAD(, bio) queue = TAILQ_HEAD_INITIALIZER(queue);
300	struct g_shsec_softc *sc;
301	struct bio *cbp;
302	uint32_t *dst;
303	ssize_t len;
304	u_int no;
305	int error;
306
307	sc = bp->bio_to->geom->softc;
308	/*
309	 * If sc == NULL, provider's error should be set and g_shsec_start()
310	 * should not be called at all.
311	 */
312	KASSERT(sc != NULL,
313	    ("Provider's error should be set (error=%d)(device=%s).",
314	    bp->bio_to->error, bp->bio_to->name));
315
316	G_SHSEC_LOGREQ(2, bp, "Request received.");
317
318	switch (bp->bio_cmd) {
319	case BIO_READ:
320	case BIO_WRITE:
321	case BIO_FLUSH:
322	case BIO_SPEEDUP:
323		/*
324		 * Only those requests are supported.
325		 */
326		break;
327	case BIO_DELETE:
328	case BIO_GETATTR:
329		/* To which provider it should be delivered? */
330	default:
331		g_io_deliver(bp, EOPNOTSUPP);
332		return;
333	}
334
335	/*
336	 * Allocate all bios first and calculate XOR.
337	 */
338	dst = NULL;
339	len = bp->bio_length;
340	if (bp->bio_cmd == BIO_READ)
341		bp->bio_pflags = G_SHSEC_BFLAG_FIRST;
342	for (no = 0; no < sc->sc_ndisks; no++) {
343		cbp = g_clone_bio(bp);
344		if (cbp == NULL) {
345			error = ENOMEM;
346			goto failure;
347		}
348		TAILQ_INSERT_TAIL(&queue, cbp, bio_queue);
349
350		/*
351		 * Fill in the component buf structure.
352		 */
353		cbp->bio_done = g_shsec_done;
354		cbp->bio_data = uma_zalloc(g_shsec_zone, M_NOWAIT);
355		if (cbp->bio_data == NULL) {
356			g_shsec_alloc_failed++;
357			error = ENOMEM;
358			goto failure;
359		}
360		cbp->bio_caller2 = sc->sc_disks[no];
361		if (bp->bio_cmd == BIO_WRITE) {
362			if (no == 0) {
363				dst = (uint32_t *)cbp->bio_data;
364				bcopy(bp->bio_data, dst, len);
365			} else {
366				g_shsec_xor2((uint32_t *)cbp->bio_data, dst,
367				    len);
368			}
369		}
370	}
371	/*
372	 * Fire off all allocated requests!
373	 */
374	while ((cbp = TAILQ_FIRST(&queue)) != NULL) {
375		struct g_consumer *cp;
376
377		TAILQ_REMOVE(&queue, cbp, bio_queue);
378		cp = cbp->bio_caller2;
379		cbp->bio_caller2 = NULL;
380		cbp->bio_to = cp->provider;
381		G_SHSEC_LOGREQ(2, cbp, "Sending request.");
382		g_io_request(cbp, cp);
383	}
384	return;
385failure:
386	while ((cbp = TAILQ_FIRST(&queue)) != NULL) {
387		TAILQ_REMOVE(&queue, cbp, bio_queue);
388		bp->bio_children--;
389		if (cbp->bio_data != NULL) {
390			explicit_bzero(cbp->bio_data, cbp->bio_length);
391			uma_zfree(g_shsec_zone, cbp->bio_data);
392		}
393		g_destroy_bio(cbp);
394	}
395	if (bp->bio_error == 0)
396		bp->bio_error = error;
397	g_io_deliver(bp, bp->bio_error);
398}
399
400static void
401g_shsec_check_and_run(struct g_shsec_softc *sc)
402{
403	off_t mediasize, ms;
404	u_int no, sectorsize = 0;
405
406	if (g_shsec_nvalid(sc) != sc->sc_ndisks)
407		return;
408
409	sc->sc_provider = g_new_providerf(sc->sc_geom, "shsec/%s", sc->sc_name);
410	/*
411	 * Find the smallest disk.
412	 */
413	mediasize = sc->sc_disks[0]->provider->mediasize;
414	mediasize -= sc->sc_disks[0]->provider->sectorsize;
415	sectorsize = sc->sc_disks[0]->provider->sectorsize;
416	for (no = 1; no < sc->sc_ndisks; no++) {
417		ms = sc->sc_disks[no]->provider->mediasize;
418		ms -= sc->sc_disks[no]->provider->sectorsize;
419		if (ms < mediasize)
420			mediasize = ms;
421		sectorsize = lcm(sectorsize,
422		    sc->sc_disks[no]->provider->sectorsize);
423	}
424	sc->sc_provider->sectorsize = sectorsize;
425	sc->sc_provider->mediasize = mediasize;
426	g_error_provider(sc->sc_provider, 0);
427
428	G_SHSEC_DEBUG(0, "Device %s activated.", sc->sc_name);
429}
430
431static int
432g_shsec_read_metadata(struct g_consumer *cp, struct g_shsec_metadata *md)
433{
434	struct g_provider *pp;
435	u_char *buf;
436	int error;
437
438	g_topology_assert();
439
440	error = g_access(cp, 1, 0, 0);
441	if (error != 0)
442		return (error);
443	pp = cp->provider;
444	g_topology_unlock();
445	buf = g_read_data(cp, pp->mediasize - pp->sectorsize, pp->sectorsize,
446	    &error);
447	g_topology_lock();
448	g_access(cp, -1, 0, 0);
449	if (buf == NULL)
450		return (error);
451
452	/* Decode metadata. */
453	shsec_metadata_decode(buf, md);
454	g_free(buf);
455
456	return (0);
457}
458
459/*
460 * Add disk to given device.
461 */
462static int
463g_shsec_add_disk(struct g_shsec_softc *sc, struct g_provider *pp, u_int no)
464{
465	struct g_consumer *cp, *fcp;
466	struct g_geom *gp;
467	struct g_shsec_metadata md;
468	int error;
469
470	/* Metadata corrupted? */
471	if (no >= sc->sc_ndisks)
472		return (EINVAL);
473
474	/* Check if disk is not already attached. */
475	if (sc->sc_disks[no] != NULL)
476		return (EEXIST);
477
478	gp = sc->sc_geom;
479	fcp = LIST_FIRST(&gp->consumer);
480
481	cp = g_new_consumer(gp);
482	error = g_attach(cp, pp);
483	if (error != 0) {
484		g_destroy_consumer(cp);
485		return (error);
486	}
487
488	if (fcp != NULL && (fcp->acr > 0 || fcp->acw > 0 || fcp->ace > 0)) {
489		error = g_access(cp, fcp->acr, fcp->acw, fcp->ace);
490		if (error != 0) {
491			g_detach(cp);
492			g_destroy_consumer(cp);
493			return (error);
494		}
495	}
496
497	/* Reread metadata. */
498	error = g_shsec_read_metadata(cp, &md);
499	if (error != 0)
500		goto fail;
501
502	if (strcmp(md.md_magic, G_SHSEC_MAGIC) != 0 ||
503	    strcmp(md.md_name, sc->sc_name) != 0 || md.md_id != sc->sc_id) {
504		G_SHSEC_DEBUG(0, "Metadata on %s changed.", pp->name);
505		goto fail;
506	}
507
508	cp->private = sc;
509	cp->index = no;
510	sc->sc_disks[no] = cp;
511
512	G_SHSEC_DEBUG(0, "Disk %s attached to %s.", pp->name, sc->sc_name);
513
514	g_shsec_check_and_run(sc);
515
516	return (0);
517fail:
518	if (fcp != NULL && (fcp->acr > 0 || fcp->acw > 0 || fcp->ace > 0))
519		g_access(cp, -fcp->acr, -fcp->acw, -fcp->ace);
520	g_detach(cp);
521	g_destroy_consumer(cp);
522	return (error);
523}
524
525static struct g_geom *
526g_shsec_create(struct g_class *mp, const struct g_shsec_metadata *md)
527{
528	struct g_shsec_softc *sc;
529	struct g_geom *gp;
530	u_int no;
531
532	G_SHSEC_DEBUG(1, "Creating device %s (id=%u).", md->md_name, md->md_id);
533
534	/* Two disks is minimum. */
535	if (md->md_all < 2) {
536		G_SHSEC_DEBUG(0, "Too few disks defined for %s.", md->md_name);
537		return (NULL);
538	}
539
540	/* Check for duplicate unit */
541	LIST_FOREACH(gp, &mp->geom, geom) {
542		sc = gp->softc;
543		if (sc != NULL && strcmp(sc->sc_name, md->md_name) == 0) {
544			G_SHSEC_DEBUG(0, "Device %s already configured.",
545			    sc->sc_name);
546			return (NULL);
547		}
548	}
549	gp = g_new_geomf(mp, "%s", md->md_name);
550	sc = malloc(sizeof(*sc), M_SHSEC, M_WAITOK | M_ZERO);
551	gp->start = g_shsec_start;
552	gp->spoiled = g_shsec_orphan;
553	gp->orphan = g_shsec_orphan;
554	gp->access = g_shsec_access;
555	gp->dumpconf = g_shsec_dumpconf;
556
557	sc->sc_id = md->md_id;
558	sc->sc_ndisks = md->md_all;
559	sc->sc_disks = malloc(sizeof(struct g_consumer *) * sc->sc_ndisks,
560	    M_SHSEC, M_WAITOK | M_ZERO);
561	for (no = 0; no < sc->sc_ndisks; no++)
562		sc->sc_disks[no] = NULL;
563
564	gp->softc = sc;
565	sc->sc_geom = gp;
566	sc->sc_provider = NULL;
567
568	G_SHSEC_DEBUG(0, "Device %s created (id=%u).", sc->sc_name, sc->sc_id);
569
570	return (gp);
571}
572
573static int
574g_shsec_destroy(struct g_shsec_softc *sc, boolean_t force)
575{
576	struct g_provider *pp;
577	struct g_geom *gp;
578	u_int no;
579
580	g_topology_assert();
581
582	if (sc == NULL)
583		return (ENXIO);
584
585	pp = sc->sc_provider;
586	if (pp != NULL && (pp->acr != 0 || pp->acw != 0 || pp->ace != 0)) {
587		if (force) {
588			G_SHSEC_DEBUG(0, "Device %s is still open, so it "
589			    "can't be definitely removed.", pp->name);
590		} else {
591			G_SHSEC_DEBUG(1,
592			    "Device %s is still open (r%dw%de%d).", pp->name,
593			    pp->acr, pp->acw, pp->ace);
594			return (EBUSY);
595		}
596	}
597
598	for (no = 0; no < sc->sc_ndisks; no++) {
599		if (sc->sc_disks[no] != NULL)
600			g_shsec_remove_disk(sc->sc_disks[no]);
601	}
602
603	gp = sc->sc_geom;
604	gp->softc = NULL;
605	KASSERT(sc->sc_provider == NULL, ("Provider still exists? (device=%s)",
606	    gp->name));
607	free(sc->sc_disks, M_SHSEC);
608	free(sc, M_SHSEC);
609
610	pp = LIST_FIRST(&gp->provider);
611	if (pp == NULL || (pp->acr == 0 && pp->acw == 0 && pp->ace == 0))
612		G_SHSEC_DEBUG(0, "Device %s destroyed.", gp->name);
613
614	g_wither_geom(gp, ENXIO);
615
616	return (0);
617}
618
619static int
620g_shsec_destroy_geom(struct gctl_req *req __unused, struct g_class *mp __unused,
621    struct g_geom *gp)
622{
623	struct g_shsec_softc *sc;
624
625	sc = gp->softc;
626	return (g_shsec_destroy(sc, 0));
627}
628
629static struct g_geom *
630g_shsec_taste(struct g_class *mp, struct g_provider *pp, int flags __unused)
631{
632	struct g_shsec_metadata md;
633	struct g_shsec_softc *sc;
634	struct g_consumer *cp;
635	struct g_geom *gp;
636	int error;
637
638	g_trace(G_T_TOPOLOGY, "%s(%s, %s)", __func__, mp->name, pp->name);
639	g_topology_assert();
640
641	/* Skip providers that are already open for writing. */
642	if (pp->acw > 0)
643		return (NULL);
644
645	G_SHSEC_DEBUG(3, "Tasting %s.", pp->name);
646
647	gp = g_new_geomf(mp, "shsec:taste");
648	gp->start = g_shsec_start;
649	gp->access = g_shsec_access;
650	gp->orphan = g_shsec_orphan;
651	cp = g_new_consumer(gp);
652	error = g_attach(cp, pp);
653	if (error == 0) {
654		error = g_shsec_read_metadata(cp, &md);
655		g_detach(cp);
656	}
657	g_destroy_consumer(cp);
658	g_destroy_geom(gp);
659	if (error != 0)
660		return (NULL);
661	gp = NULL;
662
663	if (strcmp(md.md_magic, G_SHSEC_MAGIC) != 0)
664		return (NULL);
665	if (md.md_version > G_SHSEC_VERSION) {
666		G_SHSEC_DEBUG(0, "Kernel module is too old to handle %s.\n",
667		    pp->name);
668		return (NULL);
669	}
670	/*
671	 * Backward compatibility:
672	 */
673	/* There was no md_provsize field in earlier versions of metadata. */
674	if (md.md_version < 1)
675		md.md_provsize = pp->mediasize;
676
677	if (md.md_provider[0] != '\0' &&
678	    !g_compare_names(md.md_provider, pp->name))
679		return (NULL);
680	if (md.md_provsize != pp->mediasize)
681		return (NULL);
682
683	/*
684	 * Let's check if device already exists.
685	 */
686	sc = NULL;
687	LIST_FOREACH(gp, &mp->geom, geom) {
688		sc = gp->softc;
689		if (sc == NULL)
690			continue;
691		if (strcmp(md.md_name, sc->sc_name) != 0)
692			continue;
693		if (md.md_id != sc->sc_id)
694			continue;
695		break;
696	}
697	if (gp != NULL) {
698		G_SHSEC_DEBUG(1, "Adding disk %s to %s.", pp->name, gp->name);
699		error = g_shsec_add_disk(sc, pp, md.md_no);
700		if (error != 0) {
701			G_SHSEC_DEBUG(0, "Cannot add disk %s to %s (error=%d).",
702			    pp->name, gp->name, error);
703			return (NULL);
704		}
705	} else {
706		gp = g_shsec_create(mp, &md);
707		if (gp == NULL) {
708			G_SHSEC_DEBUG(0, "Cannot create device %s.", md.md_name);
709			return (NULL);
710		}
711		sc = gp->softc;
712		G_SHSEC_DEBUG(1, "Adding disk %s to %s.", pp->name, gp->name);
713		error = g_shsec_add_disk(sc, pp, md.md_no);
714		if (error != 0) {
715			G_SHSEC_DEBUG(0, "Cannot add disk %s to %s (error=%d).",
716			    pp->name, gp->name, error);
717			g_shsec_destroy(sc, 1);
718			return (NULL);
719		}
720	}
721	return (gp);
722}
723
724static struct g_shsec_softc *
725g_shsec_find_device(struct g_class *mp, const char *name)
726{
727	struct g_shsec_softc *sc;
728	struct g_geom *gp;
729
730	LIST_FOREACH(gp, &mp->geom, geom) {
731		sc = gp->softc;
732		if (sc == NULL)
733			continue;
734		if (strcmp(sc->sc_name, name) == 0)
735			return (sc);
736	}
737	return (NULL);
738}
739
740static void
741g_shsec_ctl_destroy(struct gctl_req *req, struct g_class *mp)
742{
743	struct g_shsec_softc *sc;
744	int *force, *nargs, error;
745	const char *name;
746	char param[16];
747	u_int i;
748
749	g_topology_assert();
750
751	nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
752	if (nargs == NULL) {
753		gctl_error(req, "No '%s' argument.", "nargs");
754		return;
755	}
756	if (*nargs <= 0) {
757		gctl_error(req, "Missing device(s).");
758		return;
759	}
760	force = gctl_get_paraml(req, "force", sizeof(*force));
761	if (force == NULL) {
762		gctl_error(req, "No '%s' argument.", "force");
763		return;
764	}
765
766	for (i = 0; i < (u_int)*nargs; i++) {
767		snprintf(param, sizeof(param), "arg%u", i);
768		name = gctl_get_asciiparam(req, param);
769		if (name == NULL) {
770			gctl_error(req, "No 'arg%u' argument.", i);
771			return;
772		}
773		sc = g_shsec_find_device(mp, name);
774		if (sc == NULL) {
775			gctl_error(req, "No such device: %s.", name);
776			return;
777		}
778		error = g_shsec_destroy(sc, *force);
779		if (error != 0) {
780			gctl_error(req, "Cannot destroy device %s (error=%d).",
781			    sc->sc_name, error);
782			return;
783		}
784	}
785}
786
787static void
788g_shsec_config(struct gctl_req *req, struct g_class *mp, const char *verb)
789{
790	uint32_t *version;
791
792	g_topology_assert();
793
794	version = gctl_get_paraml(req, "version", sizeof(*version));
795	if (version == NULL) {
796		gctl_error(req, "No '%s' argument.", "version");
797		return;
798	}
799	if (*version != G_SHSEC_VERSION) {
800		gctl_error(req, "Userland and kernel parts are out of sync.");
801		return;
802	}
803
804	if (strcmp(verb, "stop") == 0) {
805		g_shsec_ctl_destroy(req, mp);
806		return;
807	}
808
809	gctl_error(req, "Unknown verb.");
810}
811
812static void
813g_shsec_dumpconf(struct sbuf *sb, const char *indent, struct g_geom *gp,
814    struct g_consumer *cp, struct g_provider *pp)
815{
816	struct g_shsec_softc *sc;
817
818	sc = gp->softc;
819	if (sc == NULL)
820		return;
821	if (pp != NULL) {
822		/* Nothing here. */
823	} else if (cp != NULL) {
824		sbuf_printf(sb, "%s<Number>%u</Number>\n", indent,
825		    (u_int)cp->index);
826	} else {
827		sbuf_printf(sb, "%s<ID>%u</ID>\n", indent, (u_int)sc->sc_id);
828		sbuf_printf(sb, "%s<Status>Total=%u, Online=%u</Status>\n",
829		    indent, sc->sc_ndisks, g_shsec_nvalid(sc));
830		sbuf_printf(sb, "%s<State>", indent);
831		if (sc->sc_provider != NULL && sc->sc_provider->error == 0)
832			sbuf_printf(sb, "UP");
833		else
834			sbuf_printf(sb, "DOWN");
835		sbuf_printf(sb, "</State>\n");
836	}
837}
838
839DECLARE_GEOM_CLASS(g_shsec_class, g_shsec);
840MODULE_VERSION(geom_shsec, 0);
841