Annotation of src/sys/dev/dm/dm_target_delay.c, revision 1.2
1.2 ! tkusumi 1: /* $NetBSD: dm_target_delay.c,v 1.1 2020/01/05 08:08:26 tkusumi Exp $ */
1.1 tkusumi 2:
3: /*
4: * Copyright (c) 2020 The NetBSD Foundation, Inc.
5: * Copyright (c) 2015 The DragonFly Project. All rights reserved.
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_delay.c,v 1.1 2020/01/05 08:08:26 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: #include <sys/mutex.h>
41: #include <sys/queue.h>
42: #include <sys/callout.h>
43: #include <sys/pool.h>
44: #include <sys/kthread.h>
45:
46: #include "dm.h"
47:
48: struct dm_delay_buf {
49: TAILQ_ENTRY(dm_delay_buf) entry;
50: struct buf *bp;
51: int expire;
52: };
53: TAILQ_HEAD(dm_delay_buf_list, dm_delay_buf);
54:
55: struct dm_delay_info {
56: dm_pdev_t *pdev;
57: uint64_t offset;
58: int delay;
59: int count;
60: int enabled;
61: struct dm_delay_buf_list buf_list;
62: struct callout cal;
63: kmutex_t buf_mtx;
64: kmutex_t cal_mtx;
65: kmutex_t token; /* lwkt_token in DragonFly */
66: };
67:
68: typedef struct target_delay_config {
69: struct dm_delay_info read;
70: struct dm_delay_info write;
71: int argc; /* either 3 or 6 */
72: } dm_target_delay_config_t;
73:
74: static int _init(struct dm_delay_info*, char**);
75: static int _table(struct dm_delay_info*, char*);
76: static void _strategy(struct dm_delay_info*, struct buf*);
77: static __inline void _submit(struct dm_delay_info*, struct buf*);
78: static void _destroy(struct dm_delay_info*);
79: static void _timeout(void*);
80: static void _thread(void*);
81: static __inline void _debug(struct dm_delay_info*, const char*);
82:
83: static struct pool pool;
84: static bool pool_initialized = false;
85:
86: #ifdef DM_TARGET_MODULE
87: /*
88: * Every target can be compiled directly to dm driver or as a
89: * separate module this part of target is used for loading targets
90: * to dm driver.
91: * Target can be unloaded from kernel only if there are no users of
92: * it e.g. there are no devices which uses that target.
93: */
94: #include <sys/kernel.h>
95: #include <sys/module.h>
96:
97: MODULE(MODULE_CLASS_MISC, dm_target_delay, NULL);
98:
99: static int
100: dm_target_delay_modcmd(modcmd_t cmd, void *arg)
101: {
102: dm_target_t *dmt;
103: int r;
104:
105: switch (cmd) {
106: case MODULE_CMD_INIT:
107: if ((dmt = dm_target_lookup("delay")) != NULL) {
108: dm_target_unbusy(dmt);
109: return EEXIST;
110: }
111: dmt = dm_target_alloc("delay");
112:
113: dmt->version[0] = 1;
114: dmt->version[1] = 0;
115: dmt->version[2] = 0;
116: dmt->init = &dm_target_delay_init;
117: dmt->table = &dm_target_delay_table;
118: dmt->strategy = &dm_target_delay_strategy;
119: dmt->sync = &dm_target_delay_sync;
120: dmt->destroy = &dm_target_delay_destroy;
1.2 ! tkusumi 121: //dmt->upcall = &dm_target_delay_upcall;
1.1 tkusumi 122: dmt->secsize = &dm_target_delay_secsize;
123:
124: dm_target_delay_pool_create();
125: r = dm_target_insert(dmt);
126:
127: break;
128:
129: case MODULE_CMD_FINI:
130: r = dm_target_rem("delay");
131: dm_target_delay_pool_destroy();
132: break;
133:
134: case MODULE_CMD_STAT:
135: return ENOTTY;
136:
137: default:
138: return ENOTTY;
139: }
140:
141: return r;
142: }
143: #endif
144:
145: int
146: dm_target_delay_init(dm_table_entry_t *table_en, int argc, char **argv)
147: {
148: dm_target_delay_config_t *tdc;
149: int ret;
150:
151: if (argc != 3 && argc != 6) {
152: printf("Delay target takes 3 or 6 args, %d given\n", argc);
153: return EINVAL;
154: }
155:
156: aprint_debug("Delay target init function called: argc=%d\n", argc);
157:
158: tdc = kmem_alloc(sizeof(dm_target_delay_config_t), KM_SLEEP);
159: tdc->argc = argc;
160:
161: ret = _init(&tdc->read, argv);
162: if (ret) {
163: kmem_free(tdc, sizeof(*tdc));
164: return ret;
165: }
166:
167: if (argc == 6)
168: argv += 3;
169:
170: ret = _init(&tdc->write, argv);
171: if (ret) {
172: dm_pdev_decr(tdc->read.pdev);
173: kmem_free(tdc, sizeof(*tdc));
174: return ret;
175: }
176:
177: dm_table_add_deps(table_en, tdc->read.pdev);
178: dm_table_add_deps(table_en, tdc->write.pdev);
179:
180: table_en->target_config = tdc;
181:
182: return 0;
183: }
184:
185: static int
186: _init(struct dm_delay_info *di, char **argv)
187: {
188: dm_pdev_t *dmp;
189: int tmp;
190:
191: if (argv[0] == NULL)
192: return EINVAL;
193: if ((dmp = dm_pdev_insert(argv[0])) == NULL)
194: return ENOENT;
195:
196: di->pdev = dmp;
197: di->offset = atoi64(argv[1]);
198: tmp = atoi64(argv[2]);
199: di->delay = tmp * hz / 1000;
200: di->count = 0;
201:
202: TAILQ_INIT(&di->buf_list);
203: callout_init(&di->cal, 0);
204: mutex_init(&di->buf_mtx, MUTEX_DEFAULT, IPL_NONE);
205: mutex_init(&di->cal_mtx, MUTEX_DEFAULT, IPL_NONE);
206: mutex_init(&di->token, MUTEX_DEFAULT, IPL_NONE);
207:
208: di->enabled = 1;
209: if (kthread_create(PRI_NONE, 0, NULL, _thread, di, NULL,
210: "dmdlthread")) {
211: printf("Failed to create delay target's kthread\n");
212: /* XXX cleanup ? */
213: return EINVAL;
214: }
215:
216: _debug(di, "init");
217: return 0;
218: }
219:
220: char *
221: dm_target_delay_info(void *target_config)
222: {
223: dm_target_delay_config_t *tdc;
224: char *params;
225:
226: tdc = target_config;
227: KASSERT(tdc != NULL);
228:
229: aprint_debug("Delay target info function called\n");
230:
231: params = kmem_alloc(DM_MAX_PARAMS_SIZE, KM_SLEEP);
232: snprintf(params, DM_MAX_PARAMS_SIZE, "%d %d", tdc->read.count,
233: tdc->write.count);
234:
235: return params;
236: }
237:
238: char *
239: dm_target_delay_table(void *target_config)
240: {
241: dm_target_delay_config_t *tdc;
242: char *params, *p;
243:
244: tdc = target_config;
245: KASSERT(tdc != NULL);
246:
247: aprint_debug("Delay target table function called\n");
248:
249: params = kmem_alloc(DM_MAX_PARAMS_SIZE, KM_SLEEP);
250: p = params;
251: p += _table(&tdc->read, p);
252: if (tdc->argc == 6) {
253: p += snprintf(p, DM_MAX_PARAMS_SIZE, " ");
254: _table(&tdc->write, p);
255: }
256:
257: return params;
258: }
259:
260: static int
261: _table(struct dm_delay_info *di, char *p)
262: {
263:
264: return snprintf(p, DM_MAX_PARAMS_SIZE, "%s %" PRIu64 " %d",
265: di->pdev->udev_name, di->offset, di->delay);
266: }
267:
268: int
269: dm_target_delay_strategy(dm_table_entry_t *table_en, struct buf *bp)
270: {
271: dm_target_delay_config_t *tdc;
272: struct dm_delay_info *di;
273:
274: tdc = table_en->target_config;
275: KASSERT(tdc != NULL);
276:
277: if (bp->b_flags & B_READ)
278: di = &tdc->read;
279: else
280: di = &tdc->write;
281:
282: if (di) {
283: if (di->delay) {
284: _strategy(di, bp);
285: } else {
286: _submit(di, bp);
287: }
288: } else {
289: struct vnode *vnode = tdc->write.pdev->pdev_vnode;
290: KASSERT(0);
291: VOP_STRATEGY(vnode, bp);
292: }
293:
294: return 0;
295: }
296:
297: static void
298: _strategy(struct dm_delay_info *di, struct buf *bp)
299: {
300: struct dm_delay_buf *dp;
301:
302: dp = pool_get(&pool, PR_WAITOK);
303: dp->bp = bp;
304: dp->expire = tick + di->delay;
305:
306: mutex_enter(&di->buf_mtx);
307: di->count++;
308: TAILQ_INSERT_TAIL(&di->buf_list, dp, entry);
309: mutex_exit(&di->buf_mtx);
310:
311: mutex_enter(&di->cal_mtx);
312: if (!callout_pending(&di->cal))
313: callout_reset(&di->cal, di->delay, _timeout, di);
314: mutex_exit(&di->cal_mtx);
315: }
316:
317: static __inline void
318: _submit(struct dm_delay_info *di, struct buf *bp)
319: {
320:
321: _debug(di, "submit");
322:
323: bp->b_blkno += di->offset;
324: VOP_STRATEGY(di->pdev->pdev_vnode, bp);
325: }
326:
327: static void
328: _submit_queue(struct dm_delay_info *di, int submit_all)
329: {
330: struct dm_delay_buf *dp;
331: struct dm_delay_buf_list tmp_list;
332: int next = -1;
333: int reset = 0;
334:
335: _debug(di, "submitq");
336: TAILQ_INIT(&tmp_list);
337:
338: mutex_enter(&di->buf_mtx);
339: while ((dp = TAILQ_FIRST(&di->buf_list)) != NULL) {
340: if (submit_all || tick > dp->expire) {
341: TAILQ_REMOVE(&di->buf_list, dp, entry);
342: TAILQ_INSERT_TAIL(&tmp_list, dp, entry);
343: di->count--;
344: continue;
345: }
346: if (reset == 0) {
347: reset = 1;
348: next = dp->expire;
349: } else {
350: next = lmin(next, dp->expire);
351: }
352: }
353: mutex_exit(&di->buf_mtx);
354:
355: if (reset) {
356: mutex_enter(&di->cal_mtx);
357: callout_reset(&di->cal, next - tick, _timeout, di);
358: mutex_exit(&di->cal_mtx);
359: }
360:
361: while ((dp = TAILQ_FIRST(&tmp_list)) != NULL) {
362: TAILQ_REMOVE(&tmp_list, dp, entry);
363: _submit(di, dp->bp);
364: pool_put(&pool, dp);
365: }
366: }
367:
368: int
369: dm_target_delay_sync(dm_table_entry_t *table_en)
370: {
371: dm_target_delay_config_t *tdc;
372: int cmd;
373:
374: tdc = table_en->target_config;
375: cmd = 1;
376:
377: return VOP_IOCTL(tdc->write.pdev->pdev_vnode, DIOCCACHESYNC, &cmd,
378: FREAD | FWRITE, kauth_cred_get());
379: }
380:
381: int
382: dm_target_delay_destroy(dm_table_entry_t *table_en)
383: {
384: dm_target_delay_config_t *tdc;
385:
386: tdc = table_en->target_config;
387: if (tdc == NULL)
388: goto out;
389:
390: _destroy(&tdc->read);
391: _destroy(&tdc->write);
392:
393: kmem_free(tdc, sizeof(*tdc));
394: out:
395: /* Unbusy target so we can unload it */
396: dm_target_unbusy(table_en->target);
397:
398: return 0;
399: }
400:
401: static void
402: _destroy(struct dm_delay_info *di)
403: {
404:
405: _debug(di, "destroy");
406:
407: mutex_enter(&di->token);
408: di->enabled = 0;
409:
410: mutex_enter(&di->cal_mtx);
411: if (callout_pending(&di->cal))
412: callout_halt(&di->cal, NULL);
413: mutex_exit(&di->cal_mtx);
414:
415: _submit_queue(di, 1);
416: mutex_exit(&di->token);
417: wakeup(di);
418: /* XXX race here (DragonFly uses lwkt_token instead of mutex) */
419: tsleep(&di->enabled, 0, "dmdldestroy", 0);
420:
421: mutex_destroy(&di->token);
422: mutex_destroy(&di->cal_mtx);
423: mutex_destroy(&di->buf_mtx);
424:
425: dm_pdev_decr(di->pdev);
426: }
427:
1.2 ! tkusumi 428: #if 0
1.1 tkusumi 429: int
430: dm_target_delay_upcall(dm_table_entry_t *table_en, struct buf *bp)
431: {
432:
433: return 0;
434: }
1.2 ! tkusumi 435: #endif
1.1 tkusumi 436:
437: int
438: dm_target_delay_secsize(dm_table_entry_t *table_en, unsigned int *secsizep)
439: {
440: dm_target_delay_config_t *tdc;
441: unsigned int secsize;
442:
443: secsize = 0;
444:
445: tdc = table_en->target_config;
446: if (tdc != NULL)
447: secsize = tdc->write.pdev->pdev_secsize;
448:
449: *secsizep = secsize;
450:
451: return 0;
452: }
453:
454: static void
455: _timeout(void *arg)
456: {
457: struct dm_delay_info *di = arg;
458:
459: _debug(di, "timeout");
460: wakeup(di);
461: }
462:
463: static void
464: _thread(void *arg)
465: {
466: struct dm_delay_info *di = arg;
467:
468: _debug(di, "thread init");
469: mutex_enter(&di->token);
470:
471: while (di->enabled) {
472: mutex_exit(&di->token);
473: tsleep(di, 0, "dmdlthread", 0);
474: _submit_queue(di, 0);
475: mutex_enter(&di->token);
476: }
477:
478: mutex_exit(&di->token);
479: wakeup(&di->enabled);
480:
481: _debug(di, "thread exit");
482: kthread_exit(0);
483: }
484:
485: static __inline void
486: _debug(struct dm_delay_info *di, const char *msg)
487: {
488:
489: aprint_debug("%-8s: %d pdev=%s offset=%ju delay=%d count=%d\n",
490: msg, di->enabled, di->pdev->name, (uintmax_t)di->offset, di->delay,
491: di->count);
492: }
493:
494: void
495: dm_target_delay_pool_create(void)
496: {
497:
498: if (!pool_initialized) {
499: pool_init(&pool, sizeof(struct dm_delay_buf), 0, 0, 0,
500: "dmdlobj", &pool_allocator_nointr, IPL_NONE);
501: pool_initialized = true;
502: aprint_debug("Delay target pool initialized\n");
503: }
504: }
505:
506: void
507: dm_target_delay_pool_destroy(void)
508: {
509:
510: if (pool_initialized) {
511: pool_destroy(&pool);
512: pool_initialized = false;
513: aprint_debug("Delay target pool destroyed\n");
514: }
515: }
CVSweb <webmaster@jp.NetBSD.org>