Annotation of src/sys/dev/dm/dm_target_flakey.c, revision 1.2
1.2 ! tkusumi 1: /* $NetBSD: dm_target_flakey.c,v 1.1 2020/01/02 06:22:23 tkusumi Exp $ */
1.1 tkusumi 2:
3: /*
4: * Copyright (c) 2020 The NetBSD Foundation, Inc.
1.2 ! tkusumi 5: * Copyright (c) 2015 The DragonFly Project. All rights reserved.
1.1 tkusumi 6: * All rights reserved.
7: *
8: * This code is derived from software contributed to The NetBSD Foundation
9: * by Tomohiro Kusumi <tkusumi@netbsd.org>.
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in the
18: * documentation and/or other materials provided with the distribution.
19: *
20: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30: * POSSIBILITY OF SUCH DAMAGE.
31: */
32: #include <sys/cdefs.h>
1.2 ! tkusumi 33: __KERNEL_RCSID(0, "$NetBSD: dm_target_flakey.c,v 1.1 2020/01/02 06:22:23 tkusumi Exp $");
1.1 tkusumi 34:
35: #include <sys/types.h>
36: #include <sys/param.h>
37: #include <sys/kernel.h>
38: #include <sys/buf.h>
39: #include <sys/kmem.h>
40:
41: #include "dm.h"
42:
43: //#define DEBUG_FLAKEY
44: //#define HAS_BUF_PRIV2 /* XXX requires nonexistent buf::b_private2. */
45:
46: typedef struct target_flakey_config {
47: dm_pdev_t *pdev;
48: uint64_t offset;
49: int up_int;
50: int down_int;
51: int offset_time; /* XXX "tick" in hz(9) not working. */
52:
53: /* drop_writes feature */
54: int drop_writes;
55:
56: /* corrupt_bio_byte feature */
57: unsigned int corrupt_buf_byte;
58: unsigned int corrupt_buf_rw;
59: unsigned int corrupt_buf_value;
60: unsigned int corrupt_buf_flags; /* for B_XXX flags */
61: } dm_target_flakey_config_t;
62:
63: #define BUF_CMD_READ 1
64: #define BUF_CMD_WRITE 2
65:
66: #define FLAKEY_CORRUPT_DIR(tfc) \
67: ((tfc)->corrupt_buf_rw == BUF_CMD_READ ? 'r' : 'w')
68:
69: static int _init_features(dm_target_flakey_config_t*, int, char**);
70: static __inline void _submit(dm_target_flakey_config_t*, struct buf*);
71: static int _flakey_read(dm_target_flakey_config_t*, struct buf*);
72: static int _flakey_write(dm_target_flakey_config_t*, struct buf*);
73: static int _flakey_corrupt_buf(dm_target_flakey_config_t*, struct buf*);
74:
75: #ifdef DM_TARGET_MODULE
76: /*
77: * Every target can be compiled directly to dm driver or as a
78: * separate module this part of target is used for loading targets
79: * to dm driver.
80: * Target can be unloaded from kernel only if there are no users of
81: * it e.g. there are no devices which uses that target.
82: */
83: #include <sys/kernel.h>
84: #include <sys/module.h>
85:
86: MODULE(MODULE_CLASS_MISC, dm_target_flakey, NULL);
87:
88: static int
89: dm_target_flakey_modcmd(modcmd_t cmd, void *arg)
90: {
91: dm_target_t *dmt;
92: int r;
93:
94: switch (cmd) {
95: case MODULE_CMD_INIT:
96: if ((dmt = dm_target_lookup("flakey")) != NULL) {
97: dm_target_unbusy(dmt);
98: return EEXIST;
99: }
100: dmt = dm_target_alloc("flakey");
101:
102: dmt->version[0] = 1;
103: dmt->version[1] = 0;
104: dmt->version[2] = 0;
105: dmt->init = &dm_target_flakey_init;
106: dmt->table = &dm_target_flakey_table;
107: dmt->strategy = &dm_target_flakey_strategy;
108: dmt->sync = &dm_target_flakey_sync;
109: dmt->destroy = &dm_target_flakey_destroy;
110: dmt->upcall = &dm_target_flakey_upcall;
111: dmt->secsize = &dm_target_flakey_secsize;
112:
113: r = dm_target_insert(dmt);
114:
115: break;
116:
117: case MODULE_CMD_FINI:
118: r = dm_target_rem("flakey");
119: break;
120:
121: case MODULE_CMD_STAT:
122: return ENOTTY;
123:
124: default:
125: return ENOTTY;
126: }
127:
128: return r;
129: }
130: #endif
131:
132: int
133: dm_target_flakey_init(dm_table_entry_t *table_en, int argc, char **argv)
134: {
135: dm_target_flakey_config_t *tfc;
136: dm_pdev_t *dmp;
137: int err;
138:
139: if (argc < 4) {
140: printf("Flakey target takes at least 4 args, %d given\n", argc);
141: return EINVAL;
142: }
143:
144: aprint_debug("Flakey target init function called: argc=%d\n", argc);
145:
146: /* Insert dmp to global pdev list */
147: if ((dmp = dm_pdev_insert(argv[0])) == NULL)
148: return ENOENT;
149:
150: tfc = kmem_alloc(sizeof(dm_target_flakey_config_t), KM_SLEEP);
151: tfc->pdev = dmp;
152: tfc->offset = atoi64(argv[1]);
153: tfc->up_int = atoi64(argv[2]);
154: tfc->down_int = atoi64(argv[3]);
155: tfc->offset_time = tick;
156:
157: if ((tfc->up_int + tfc->down_int) == 0) {
158: printf("Sum of up/down interval is 0\n");
159: err = EINVAL;
160: goto fail;
161: }
162:
163: if (tfc->up_int + tfc->down_int < tfc->up_int) {
164: printf("Interval time overflow\n");
165: err = EINVAL;
166: goto fail;
167: }
168:
169: err = _init_features(tfc, argc - 4, argv + 4);
170: if (err)
171: goto fail;
172:
173: dm_table_add_deps(table_en, dmp);
174: table_en->target_config = tfc;
175:
176: return 0;
177: fail:
178: kmem_free(tfc, sizeof(*tfc));
179: return err;
180: }
181:
182: static int
183: _init_features(dm_target_flakey_config_t *tfc, int argc, char **argv)
184: {
185: char *arg;
186: unsigned int value;
187:
188: if (argc == 0)
189: return 0;
190:
191: argc = atoi64(*argv++); /* # of args for features */
192: if (argc > 6) {
193: printf("Invalid # of feature args %d\n", argc);
194: return EINVAL;
195: }
196:
197: while (argc) {
198: argc--;
199: arg = *argv++;
200:
201: /* drop_writes */
202: if (strcmp(arg, "drop_writes") == 0) {
203: tfc->drop_writes = 1;
204: continue;
205: }
206:
207: /* corrupt_bio_byte <Nth_byte> <direction> <value> <flags> */
208: if (strcmp(arg, "corrupt_bio_byte") == 0) {
209: if (argc < 4) {
210: printf("Invalid # of feature args %d for "
211: "corrupt_bio_byte\n", argc);
212: return EINVAL;
213: }
214:
215: /* <Nth_byte> */
216: argc--;
217: value = atoi64(*argv++);
218: if (value < 1) {
219: printf("Invalid corrupt_bio_byte "
220: "<Nth_byte> arg %u\n", value);
221: return EINVAL;
222: }
223: tfc->corrupt_buf_byte = value;
224:
225: /* <direction> */
226: argc--;
227: arg = *argv++;
228: if (strcmp(arg, "r") == 0) {
229: tfc->corrupt_buf_rw = BUF_CMD_READ;
230: } else if (strcmp(arg, "w") == 0) {
231: tfc->corrupt_buf_rw = BUF_CMD_WRITE;
232: } else {
233: printf("Invalid corrupt_bio_byte "
234: "<direction> arg %s\n", arg);
235: return EINVAL;
236: }
237:
238: /* <value> */
239: argc--;
240: value = atoi64(*argv++);
241: if (value > 0xff) {
242: printf("Invalid corrupt_bio_byte "
243: "<value> arg %u\n", value);
244: return EINVAL;
245: }
246: tfc->corrupt_buf_value = value;
247:
248: /* <flags> */
249: argc--;
250: tfc->corrupt_buf_flags = atoi64(*argv++);
251:
252: continue;
253: }
254:
255: printf("Unknown Flakey target feature %s\n", arg);
256: return EINVAL;
257: }
258:
259: if (tfc->drop_writes && (tfc->corrupt_buf_rw == BUF_CMD_WRITE)) {
260: printf("Flakey target doesn't allow drop_writes feature and "
261: "corrupt_bio_byte feature with 'w' set\n");
262: return EINVAL;
263: }
264:
265: return 0;
266: }
267:
268: char *
269: dm_target_flakey_table(void *target_config)
270: {
271: dm_target_flakey_config_t *tfc;
272: char *params, *p;
273: int drop_writes;
274:
275: tfc = target_config;
276: KASSERT(tfc != NULL);
277:
278: aprint_debug("Flakey target table function called\n");
279:
280: drop_writes = tfc->drop_writes;
281:
282: params = kmem_alloc(DM_MAX_PARAMS_SIZE, KM_SLEEP);
283: p = params;
284: p += snprintf(p, DM_MAX_PARAMS_SIZE, "%s %d %d %d %u ",
285: tfc->pdev->udev_name, tfc->offset_time,
286: tfc->up_int, tfc->down_int,
287: drop_writes + (tfc->corrupt_buf_byte > 0) * 5);
288:
289: if (drop_writes)
290: p += snprintf(p, DM_MAX_PARAMS_SIZE, "drop_writes ");
291:
292: if (tfc->corrupt_buf_byte)
293: p += snprintf(p, DM_MAX_PARAMS_SIZE,
294: "corrupt_bio_byte %u %c %u %u ",
295: tfc->corrupt_buf_byte,
296: FLAKEY_CORRUPT_DIR(tfc),
297: tfc->corrupt_buf_value,
298: tfc->corrupt_buf_flags);
299: *(--p) = '\0';
300:
301: return params;
302: }
303:
304: #ifdef DEBUG_FLAKEY
305: static int count = 0;
306: #endif
307:
308: int
309: dm_target_flakey_strategy(dm_table_entry_t *table_en, struct buf *bp)
310: {
311: dm_target_flakey_config_t *tfc;
312: #ifndef DEBUG_FLAKEY
313: int elapsed;
314: #endif
315:
316: tfc = table_en->target_config;
317: #ifndef DEBUG_FLAKEY
318: elapsed = (tick - tfc->offset_time) / hz;
319: if (elapsed % (tfc->up_int + tfc->down_int) >= tfc->up_int) {
320: #else
321: if (++count % 100 == 0) {
322: #endif
323: if (bp->b_flags & B_READ)
324: return _flakey_read(tfc, bp);
325: else
326: return _flakey_write(tfc, bp);
327: }
328:
329: /* This is what linear target does */
330: _submit(tfc, bp);
331:
332: return 0;
333: }
334:
335: static __inline void
336: _submit(dm_target_flakey_config_t *tfc, struct buf *bp)
337: {
338:
339: bp->b_blkno += tfc->offset;
340: VOP_STRATEGY(tfc->pdev->pdev_vnode, bp);
341: }
342:
343: static __inline void
344: _flakey_eio_buf(struct buf *bp)
345: {
346:
347: bp->b_error = EIO;
348: bp->b_resid = 0;
349: }
350:
351: static void
352: _flakey_nestiobuf_iodone(buf_t *bp)
353: {
354: #ifdef HAS_BUF_PRIV2
355: dm_target_flakey_config_t *tfc;
356: #endif
357: buf_t *mbp = bp->b_private;
358: int error;
359: int donebytes;
360:
361: KASSERT(bp->b_bcount <= bp->b_bufsize);
362: KASSERT(mbp != bp);
363:
364: error = bp->b_error;
365: if (bp->b_error == 0 &&
366: (bp->b_bcount < bp->b_bufsize || bp->b_resid > 0)) {
367: /*
368: * Not all got transfered, raise an error. We have no way to
369: * propagate these conditions to mbp.
370: */
371: error = EIO;
372: }
373:
374: #ifdef HAS_BUF_PRIV2
375: tfc = bp->b_private2;
376: /*
377: * Linux dm-flakey has changed its read behavior in 2016.
378: * This conditional is to sync with that change.
379: */
380: if (tfc->corrupt_buf_byte && tfc->corrupt_buf_rw == BUF_CMD_READ)
381: _flakey_corrupt_buf(tfc, mbp);
382: else if (!tfc->drop_writes)
383: _flakey_eio_buf(mbp);
384: #endif
385: donebytes = bp->b_bufsize;
386: putiobuf(bp);
387: nestiobuf_done(mbp, donebytes, error);
388: }
389:
390: static int
391: _flakey_read(dm_target_flakey_config_t *tfc, struct buf *bp)
392: {
393: struct buf *nestbuf;
394:
395: /*
396: * Linux dm-flakey has changed its read behavior in 2016.
397: * This conditional is to sync with that change.
398: */
399: if (!tfc->corrupt_buf_byte && !tfc->drop_writes) {
400: _flakey_eio_buf(bp);
401: biodone(bp);
402: return 0;
403: }
404:
405: nestbuf = getiobuf(NULL, true);
406: nestiobuf_setup(bp, nestbuf, 0, bp->b_bcount);
407: nestbuf->b_iodone = _flakey_nestiobuf_iodone;
408: nestbuf->b_blkno = bp->b_blkno;
409: #ifdef HAS_BUF_PRIV2
410: nestbuf->b_private2 = tfc;
411: #endif
412: _submit(tfc, nestbuf);
413:
414: return 0;
415: }
416:
417: static int
418: _flakey_write(dm_target_flakey_config_t *tfc, struct buf *bp)
419: {
420:
421: if (tfc->drop_writes) {
422: aprint_debug("bp=%p drop_writes blkno=%ju\n", bp, bp->b_blkno);
423: biodone(bp);
424: return 0;
425: }
426:
427: if (tfc->corrupt_buf_byte && tfc->corrupt_buf_rw == BUF_CMD_WRITE) {
428: _flakey_corrupt_buf(tfc, bp);
429: _submit(tfc, bp);
430: return 0;
431: }
432:
433: /* Error all I/Os if neither of the above two */
434: _flakey_eio_buf(bp);
435: biodone(bp);
436:
437: return 0;
438: }
439:
440: static int
441: _flakey_corrupt_buf(dm_target_flakey_config_t *tfc, struct buf *bp)
442: {
443: char *buf;
444:
445: if (bp->b_data == NULL)
446: return 1;
447: if (bp->b_error)
448: return 1; /* Don't corrupt on error */
449: if (bp->b_bcount < tfc->corrupt_buf_byte)
450: return 1;
451: if ((bp->b_flags & tfc->corrupt_buf_flags) != tfc->corrupt_buf_flags)
452: return 1;
453:
454: buf = bp->b_data;
455: buf[tfc->corrupt_buf_byte - 1] = tfc->corrupt_buf_value;
456:
457: aprint_debug("bp=%p dir=%c blkno=%ju Nth=%u value=%u\n",
458: bp, FLAKEY_CORRUPT_DIR(tfc), bp->b_blkno, tfc->corrupt_buf_byte,
459: tfc->corrupt_buf_value);
460:
461: return 0;
462: }
463:
464: int
465: dm_target_flakey_sync(dm_table_entry_t *table_en)
466: {
467: dm_target_flakey_config_t *tfc;
468: int cmd;
469:
470: tfc = table_en->target_config;
471: cmd = 1;
472:
473: return VOP_IOCTL(tfc->pdev->pdev_vnode, DIOCCACHESYNC, &cmd,
474: FREAD | FWRITE, kauth_cred_get());
475: }
476:
477: int
478: dm_target_flakey_destroy(dm_table_entry_t *table_en)
479: {
480:
481: if (table_en->target_config == NULL)
482: goto out;
483:
484: dm_target_flakey_config_t *tfc = table_en->target_config;
485:
486: /* Decrement pdev ref counter if 0 remove it */
487: dm_pdev_decr(tfc->pdev);
488:
489: kmem_free(tfc, sizeof(*tfc));
490: out:
491: /* Unbusy target so we can unload it */
492: dm_target_unbusy(table_en->target);
493:
494: return 0;
495: }
496:
497: int
498: dm_target_flakey_upcall(dm_table_entry_t *table_en, struct buf *bp)
499: {
500:
501: return 0;
502: }
503:
504: int
505: dm_target_flakey_secsize(dm_table_entry_t *table_en, unsigned int *secsizep)
506: {
507: dm_target_flakey_config_t *tfc;
508: unsigned int secsize;
509:
510: secsize = 0;
511:
512: tfc = table_en->target_config;
513: if (tfc != NULL)
514: secsize = tfc->pdev->pdev_secsize;
515:
516: *secsizep = secsize;
517:
518: return 0;
519: }
CVSweb <webmaster@jp.NetBSD.org>