xref: /freebsd/sys/geom/nop/g_nop.c (revision f05cddf9) 
1 /*-
2  * Copyright (c) 2004-2006 Pawel Jakub Dawidek <pjd@FreeBSD.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  */
26 
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29 
30 #include <sys/param.h>
31 #include <sys/systm.h>
32 #include <sys/kernel.h>
33 #include <sys/module.h>
34 #include <sys/lock.h>
35 #include <sys/mutex.h>
36 #include <sys/bio.h>
37 #include <sys/sbuf.h>
38 #include <sys/sysctl.h>
39 #include <sys/malloc.h>
40 #include <geom/geom.h>
41 #include <geom/nop/g_nop.h>
42 
43 
44 SYSCTL_DECL(_kern_geom);
45 static SYSCTL_NODE(_kern_geom, OID_AUTO, nop, CTLFLAG_RW, 0, "GEOM_NOP stuff");
46 static u_int g_nop_debug = 0;
47 SYSCTL_UINT(_kern_geom_nop, OID_AUTO, debug, CTLFLAG_RW, &g_nop_debug, 0,
48     "Debug level");
49 
50 static int g_nop_destroy(struct g_geom *gp, boolean_t force);
51 static int g_nop_destroy_geom(struct gctl_req *req, struct g_class *mp,
52     struct g_geom *gp);
53 static void g_nop_config(struct gctl_req *req, struct g_class *mp,
54     const char *verb);
55 static void g_nop_dumpconf(struct sbuf *sb, const char *indent,
56     struct g_geom *gp, struct g_consumer *cp, struct g_provider *pp);
57 
58 struct g_class g_nop_class = {
59 	.name = G_NOP_CLASS_NAME,
60 	.version = G_VERSION,
61 	.ctlreq = g_nop_config,
62 	.destroy_geom = g_nop_destroy_geom
63 };
64 
65 
66 static void
67 g_nop_orphan(struct g_consumer *cp)
68 {
69 
70 	g_topology_assert();
71 	g_nop_destroy(cp->geom, 1);
72 }
73 
74 static void
75 g_nop_resize(struct g_consumer *cp)
76 {
77 	struct g_nop_softc *sc;
78 	struct g_geom *gp;
79 	struct g_provider *pp;
80 	off_t size;
81 
82 	g_topology_assert();
83 
84 	gp = cp->geom;
85 	sc = gp->softc;
86 
87 	if (sc->sc_explicitsize != 0)
88 		return;
89 	if (cp->provider->mediasize < sc->sc_offset) {
90 		g_nop_destroy(gp, 1);
91 		return;
92 	}
93 	size = cp->provider->mediasize - sc->sc_offset;
94 	LIST_FOREACH(pp, &gp->provider, provider)
95 		g_resize_provider(pp, size);
96 }
97 
98 static void
99 g_nop_start(struct bio *bp)
100 {
101 	struct g_nop_softc *sc;
102 	struct g_geom *gp;
103 	struct g_provider *pp;
104 	struct bio *cbp;
105 	u_int failprob = 0;
106 
107 	gp = bp->bio_to->geom;
108 	sc = gp->softc;
109 	G_NOP_LOGREQ(bp, "Request received.");
110 	switch (bp->bio_cmd) {
111 	case BIO_READ:
112 		sc->sc_reads++;
113 		sc->sc_readbytes += bp->bio_length;
114 		failprob = sc->sc_rfailprob;
115 		break;
116 	case BIO_WRITE:
117 		sc->sc_writes++;
118 		sc->sc_wrotebytes += bp->bio_length;
119 		failprob = sc->sc_wfailprob;
120 		break;
121 	}
122 	if (failprob > 0) {
123 		u_int rval;
124 
125 		rval = arc4random() % 100;
126 		if (rval < failprob) {
127 			G_NOP_LOGREQLVL(1, bp, "Returning error=%d.", sc->sc_error);
128 			g_io_deliver(bp, sc->sc_error);
129 			return;
130 		}
131 	}
132 	cbp = g_clone_bio(bp);
133 	if (cbp == NULL) {
134 		g_io_deliver(bp, ENOMEM);
135 		return;
136 	}
137 	cbp->bio_done = g_std_done;
138 	cbp->bio_offset = bp->bio_offset + sc->sc_offset;
139 	pp = LIST_FIRST(&gp->provider);
140 	KASSERT(pp != NULL, ("NULL pp"));
141 	cbp->bio_to = pp;
142 	G_NOP_LOGREQ(cbp, "Sending request.");
143 	g_io_request(cbp, LIST_FIRST(&gp->consumer));
144 }
145 
146 static int
147 g_nop_access(struct g_provider *pp, int dr, int dw, int de)
148 {
149 	struct g_geom *gp;
150 	struct g_consumer *cp;
151 	int error;
152 
153 	gp = pp->geom;
154 	cp = LIST_FIRST(&gp->consumer);
155 	error = g_access(cp, dr, dw, de);
156 
157 	return (error);
158 }
159 
160 static int
161 g_nop_create(struct gctl_req *req, struct g_class *mp, struct g_provider *pp,
162     int ioerror, u_int rfailprob, u_int wfailprob, off_t offset, off_t size,
163     u_int secsize)
164 {
165 	struct g_nop_softc *sc;
166 	struct g_geom *gp;
167 	struct g_provider *newpp;
168 	struct g_consumer *cp;
169 	char name[64];
170 	int error;
171 	off_t explicitsize;
172 
173 	g_topology_assert();
174 
175 	gp = NULL;
176 	newpp = NULL;
177 	cp = NULL;
178 
179 	if ((offset % pp->sectorsize) != 0) {
180 		gctl_error(req, "Invalid offset for provider %s.", pp->name);
181 		return (EINVAL);
182 	}
183 	if ((size % pp->sectorsize) != 0) {
184 		gctl_error(req, "Invalid size for provider %s.", pp->name);
185 		return (EINVAL);
186 	}
187 	if (offset >= pp->mediasize) {
188 		gctl_error(req, "Invalid offset for provider %s.", pp->name);
189 		return (EINVAL);
190 	}
191 	explicitsize = size;
192 	if (size == 0)
193 		size = pp->mediasize - offset;
194 	if (offset + size > pp->mediasize) {
195 		gctl_error(req, "Invalid size for provider %s.", pp->name);
196 		return (EINVAL);
197 	}
198 	if (secsize == 0)
199 		secsize = pp->sectorsize;
200 	else if ((secsize % pp->sectorsize) != 0) {
201 		gctl_error(req, "Invalid secsize for provider %s.", pp->name);
202 		return (EINVAL);
203 	}
204 	if (secsize > MAXPHYS) {
205 		gctl_error(req, "secsize is too big.");
206 		return (EINVAL);
207 	}
208 	size -= size % secsize;
209 	snprintf(name, sizeof(name), "%s%s", pp->name, G_NOP_SUFFIX);
210 	LIST_FOREACH(gp, &mp->geom, geom) {
211 		if (strcmp(gp->name, name) == 0) {
212 			gctl_error(req, "Provider %s already exists.", name);
213 			return (EEXIST);
214 		}
215 	}
216 	gp = g_new_geomf(mp, "%s", name);
217 	sc = g_malloc(sizeof(*sc), M_WAITOK);
218 	sc->sc_offset = offset;
219 	sc->sc_explicitsize = explicitsize;
220 	sc->sc_error = ioerror;
221 	sc->sc_rfailprob = rfailprob;
222 	sc->sc_wfailprob = wfailprob;
223 	sc->sc_reads = 0;
224 	sc->sc_writes = 0;
225 	sc->sc_readbytes = 0;
226 	sc->sc_wrotebytes = 0;
227 	gp->softc = sc;
228 	gp->start = g_nop_start;
229 	gp->orphan = g_nop_orphan;
230 	gp->resize = g_nop_resize;
231 	gp->access = g_nop_access;
232 	gp->dumpconf = g_nop_dumpconf;
233 
234 	newpp = g_new_providerf(gp, "%s", gp->name);
235 	newpp->mediasize = size;
236 	newpp->sectorsize = secsize;
237 
238 	cp = g_new_consumer(gp);
239 	error = g_attach(cp, pp);
240 	if (error != 0) {
241 		gctl_error(req, "Cannot attach to provider %s.", pp->name);
242 		goto fail;
243 	}
244 
245 	newpp->flags |= pp->flags & G_PF_ACCEPT_UNMAPPED;
246 	g_error_provider(newpp, 0);
247 	G_NOP_DEBUG(0, "Device %s created.", gp->name);
248 	return (0);
249 fail:
250 	if (cp->provider != NULL)
251 		g_detach(cp);
252 	g_destroy_consumer(cp);
253 	g_destroy_provider(newpp);
254 	g_free(gp->softc);
255 	g_destroy_geom(gp);
256 	return (error);
257 }
258 
259 static int
260 g_nop_destroy(struct g_geom *gp, boolean_t force)
261 {
262 	struct g_provider *pp;
263 
264 	g_topology_assert();
265 	if (gp->softc == NULL)
266 		return (ENXIO);
267 	pp = LIST_FIRST(&gp->provider);
268 	if (pp != NULL && (pp->acr != 0 || pp->acw != 0 || pp->ace != 0)) {
269 		if (force) {
270 			G_NOP_DEBUG(0, "Device %s is still open, so it "
271 			    "can't be definitely removed.", pp->name);
272 		} else {
273 			G_NOP_DEBUG(1, "Device %s is still open (r%dw%de%d).",
274 			    pp->name, pp->acr, pp->acw, pp->ace);
275 			return (EBUSY);
276 		}
277 	} else {
278 		G_NOP_DEBUG(0, "Device %s removed.", gp->name);
279 	}
280 	g_free(gp->softc);
281 	gp->softc = NULL;
282 	g_wither_geom(gp, ENXIO);
283 
284 	return (0);
285 }
286 
287 static int
288 g_nop_destroy_geom(struct gctl_req *req, struct g_class *mp, struct g_geom *gp)
289 {
290 
291 	return (g_nop_destroy(gp, 0));
292 }
293 
294 static void
295 g_nop_ctl_create(struct gctl_req *req, struct g_class *mp)
296 {
297 	struct g_provider *pp;
298 	intmax_t *error, *rfailprob, *wfailprob, *offset, *secsize, *size;
299 	const char *name;
300 	char param[16];
301 	int i, *nargs;
302 
303 	g_topology_assert();
304 
305 	nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
306 	if (nargs == NULL) {
307 		gctl_error(req, "No '%s' argument", "nargs");
308 		return;
309 	}
310 	if (*nargs <= 0) {
311 		gctl_error(req, "Missing device(s).");
312 		return;
313 	}
314 	error = gctl_get_paraml(req, "error", sizeof(*error));
315 	if (error == NULL) {
316 		gctl_error(req, "No '%s' argument", "error");
317 		return;
318 	}
319 	rfailprob = gctl_get_paraml(req, "rfailprob", sizeof(*rfailprob));
320 	if (rfailprob == NULL) {
321 		gctl_error(req, "No '%s' argument", "rfailprob");
322 		return;
323 	}
324 	if (*rfailprob < -1 || *rfailprob > 100) {
325 		gctl_error(req, "Invalid '%s' argument", "rfailprob");
326 		return;
327 	}
328 	wfailprob = gctl_get_paraml(req, "wfailprob", sizeof(*wfailprob));
329 	if (wfailprob == NULL) {
330 		gctl_error(req, "No '%s' argument", "wfailprob");
331 		return;
332 	}
333 	if (*wfailprob < -1 || *wfailprob > 100) {
334 		gctl_error(req, "Invalid '%s' argument", "wfailprob");
335 		return;
336 	}
337 	offset = gctl_get_paraml(req, "offset", sizeof(*offset));
338 	if (offset == NULL) {
339 		gctl_error(req, "No '%s' argument", "offset");
340 		return;
341 	}
342 	if (*offset < 0) {
343 		gctl_error(req, "Invalid '%s' argument", "offset");
344 		return;
345 	}
346 	size = gctl_get_paraml(req, "size", sizeof(*size));
347 	if (size == NULL) {
348 		gctl_error(req, "No '%s' argument", "size");
349 		return;
350 	}
351 	if (*size < 0) {
352 		gctl_error(req, "Invalid '%s' argument", "size");
353 		return;
354 	}
355 	secsize = gctl_get_paraml(req, "secsize", sizeof(*secsize));
356 	if (secsize == NULL) {
357 		gctl_error(req, "No '%s' argument", "secsize");
358 		return;
359 	}
360 	if (*secsize < 0) {
361 		gctl_error(req, "Invalid '%s' argument", "secsize");
362 		return;
363 	}
364 
365 	for (i = 0; i < *nargs; i++) {
366 		snprintf(param, sizeof(param), "arg%d", i);
367 		name = gctl_get_asciiparam(req, param);
368 		if (name == NULL) {
369 			gctl_error(req, "No 'arg%d' argument", i);
370 			return;
371 		}
372 		if (strncmp(name, "/dev/", strlen("/dev/")) == 0)
373 			name += strlen("/dev/");
374 		pp = g_provider_by_name(name);
375 		if (pp == NULL) {
376 			G_NOP_DEBUG(1, "Provider %s is invalid.", name);
377 			gctl_error(req, "Provider %s is invalid.", name);
378 			return;
379 		}
380 		if (g_nop_create(req, mp, pp,
381 		    *error == -1 ? EIO : (int)*error,
382 		    *rfailprob == -1 ? 0 : (u_int)*rfailprob,
383 		    *wfailprob == -1 ? 0 : (u_int)*wfailprob,
384 		    (off_t)*offset, (off_t)*size, (u_int)*secsize) != 0) {
385 			return;
386 		}
387 	}
388 }
389 
390 static void
391 g_nop_ctl_configure(struct gctl_req *req, struct g_class *mp)
392 {
393 	struct g_nop_softc *sc;
394 	struct g_provider *pp;
395 	intmax_t *error, *rfailprob, *wfailprob;
396 	const char *name;
397 	char param[16];
398 	int i, *nargs;
399 
400 	g_topology_assert();
401 
402 	nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
403 	if (nargs == NULL) {
404 		gctl_error(req, "No '%s' argument", "nargs");
405 		return;
406 	}
407 	if (*nargs <= 0) {
408 		gctl_error(req, "Missing device(s).");
409 		return;
410 	}
411 	error = gctl_get_paraml(req, "error", sizeof(*error));
412 	if (error == NULL) {
413 		gctl_error(req, "No '%s' argument", "error");
414 		return;
415 	}
416 	rfailprob = gctl_get_paraml(req, "rfailprob", sizeof(*rfailprob));
417 	if (rfailprob == NULL) {
418 		gctl_error(req, "No '%s' argument", "rfailprob");
419 		return;
420 	}
421 	if (*rfailprob < -1 || *rfailprob > 100) {
422 		gctl_error(req, "Invalid '%s' argument", "rfailprob");
423 		return;
424 	}
425 	wfailprob = gctl_get_paraml(req, "wfailprob", sizeof(*wfailprob));
426 	if (wfailprob == NULL) {
427 		gctl_error(req, "No '%s' argument", "wfailprob");
428 		return;
429 	}
430 	if (*wfailprob < -1 || *wfailprob > 100) {
431 		gctl_error(req, "Invalid '%s' argument", "wfailprob");
432 		return;
433 	}
434 
435 	for (i = 0; i < *nargs; i++) {
436 		snprintf(param, sizeof(param), "arg%d", i);
437 		name = gctl_get_asciiparam(req, param);
438 		if (name == NULL) {
439 			gctl_error(req, "No 'arg%d' argument", i);
440 			return;
441 		}
442 		if (strncmp(name, "/dev/", strlen("/dev/")) == 0)
443 			name += strlen("/dev/");
444 		pp = g_provider_by_name(name);
445 		if (pp == NULL || pp->geom->class != mp) {
446 			G_NOP_DEBUG(1, "Provider %s is invalid.", name);
447 			gctl_error(req, "Provider %s is invalid.", name);
448 			return;
449 		}
450 		sc = pp->geom->softc;
451 		if (*error != -1)
452 			sc->sc_error = (int)*error;
453 		if (*rfailprob != -1)
454 			sc->sc_rfailprob = (u_int)*rfailprob;
455 		if (*wfailprob != -1)
456 			sc->sc_wfailprob = (u_int)*wfailprob;
457 	}
458 }
459 
460 static struct g_geom *
461 g_nop_find_geom(struct g_class *mp, const char *name)
462 {
463 	struct g_geom *gp;
464 
465 	LIST_FOREACH(gp, &mp->geom, geom) {
466 		if (strcmp(gp->name, name) == 0)
467 			return (gp);
468 	}
469 	return (NULL);
470 }
471 
472 static void
473 g_nop_ctl_destroy(struct gctl_req *req, struct g_class *mp)
474 {
475 	int *nargs, *force, error, i;
476 	struct g_geom *gp;
477 	const char *name;
478 	char param[16];
479 
480 	g_topology_assert();
481 
482 	nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
483 	if (nargs == NULL) {
484 		gctl_error(req, "No '%s' argument", "nargs");
485 		return;
486 	}
487 	if (*nargs <= 0) {
488 		gctl_error(req, "Missing device(s).");
489 		return;
490 	}
491 	force = gctl_get_paraml(req, "force", sizeof(*force));
492 	if (force == NULL) {
493 		gctl_error(req, "No 'force' argument");
494 		return;
495 	}
496 
497 	for (i = 0; i < *nargs; i++) {
498 		snprintf(param, sizeof(param), "arg%d", i);
499 		name = gctl_get_asciiparam(req, param);
500 		if (name == NULL) {
501 			gctl_error(req, "No 'arg%d' argument", i);
502 			return;
503 		}
504 		if (strncmp(name, "/dev/", strlen("/dev/")) == 0)
505 			name += strlen("/dev/");
506 		gp = g_nop_find_geom(mp, name);
507 		if (gp == NULL) {
508 			G_NOP_DEBUG(1, "Device %s is invalid.", name);
509 			gctl_error(req, "Device %s is invalid.", name);
510 			return;
511 		}
512 		error = g_nop_destroy(gp, *force);
513 		if (error != 0) {
514 			gctl_error(req, "Cannot destroy device %s (error=%d).",
515 			    gp->name, error);
516 			return;
517 		}
518 	}
519 }
520 
521 static void
522 g_nop_ctl_reset(struct gctl_req *req, struct g_class *mp)
523 {
524 	struct g_nop_softc *sc;
525 	struct g_provider *pp;
526 	const char *name;
527 	char param[16];
528 	int i, *nargs;
529 
530 	g_topology_assert();
531 
532 	nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
533 	if (nargs == NULL) {
534 		gctl_error(req, "No '%s' argument", "nargs");
535 		return;
536 	}
537 	if (*nargs <= 0) {
538 		gctl_error(req, "Missing device(s).");
539 		return;
540 	}
541 
542 	for (i = 0; i < *nargs; i++) {
543 		snprintf(param, sizeof(param), "arg%d", i);
544 		name = gctl_get_asciiparam(req, param);
545 		if (name == NULL) {
546 			gctl_error(req, "No 'arg%d' argument", i);
547 			return;
548 		}
549 		if (strncmp(name, "/dev/", strlen("/dev/")) == 0)
550 			name += strlen("/dev/");
551 		pp = g_provider_by_name(name);
552 		if (pp == NULL || pp->geom->class != mp) {
553 			G_NOP_DEBUG(1, "Provider %s is invalid.", name);
554 			gctl_error(req, "Provider %s is invalid.", name);
555 			return;
556 		}
557 		sc = pp->geom->softc;
558 		sc->sc_reads = 0;
559 		sc->sc_writes = 0;
560 		sc->sc_readbytes = 0;
561 		sc->sc_wrotebytes = 0;
562 	}
563 }
564 
565 static void
566 g_nop_config(struct gctl_req *req, struct g_class *mp, const char *verb)
567 {
568 	uint32_t *version;
569 
570 	g_topology_assert();
571 
572 	version = gctl_get_paraml(req, "version", sizeof(*version));
573 	if (version == NULL) {
574 		gctl_error(req, "No '%s' argument.", "version");
575 		return;
576 	}
577 	if (*version != G_NOP_VERSION) {
578 		gctl_error(req, "Userland and kernel parts are out of sync.");
579 		return;
580 	}
581 
582 	if (strcmp(verb, "create") == 0) {
583 		g_nop_ctl_create(req, mp);
584 		return;
585 	} else if (strcmp(verb, "configure") == 0) {
586 		g_nop_ctl_configure(req, mp);
587 		return;
588 	} else if (strcmp(verb, "destroy") == 0) {
589 		g_nop_ctl_destroy(req, mp);
590 		return;
591 	} else if (strcmp(verb, "reset") == 0) {
592 		g_nop_ctl_reset(req, mp);
593 		return;
594 	}
595 
596 	gctl_error(req, "Unknown verb.");
597 }
598 
599 static void
600 g_nop_dumpconf(struct sbuf *sb, const char *indent, struct g_geom *gp,
601     struct g_consumer *cp, struct g_provider *pp)
602 {
603 	struct g_nop_softc *sc;
604 
605 	if (pp != NULL || cp != NULL)
606 		return;
607 	sc = gp->softc;
608 	sbuf_printf(sb, "%s<Offset>%jd</Offset>\n", indent,
609 	    (intmax_t)sc->sc_offset);
610 	sbuf_printf(sb, "%s<ReadFailProb>%u</ReadFailProb>\n", indent,
611 	    sc->sc_rfailprob);
612 	sbuf_printf(sb, "%s<WriteFailProb>%u</WriteFailProb>\n", indent,
613 	    sc->sc_wfailprob);
614 	sbuf_printf(sb, "%s<Error>%d</Error>\n", indent, sc->sc_error);
615 	sbuf_printf(sb, "%s<Reads>%ju</Reads>\n", indent, sc->sc_reads);
616 	sbuf_printf(sb, "%s<Writes>%ju</Writes>\n", indent, sc->sc_writes);
617 	sbuf_printf(sb, "%s<ReadBytes>%ju</ReadBytes>\n", indent,
618 	    sc->sc_readbytes);
619 	sbuf_printf(sb, "%s<WroteBytes>%ju</WroteBytes>\n", indent,
620 	    sc->sc_wrotebytes);
621 }
622 
623 DECLARE_GEOM_CLASS(g_nop_class, g_nop);
624