1 /* $NetBSD: dm_target_delay.c,v 1.2 2020/01/21 16:27:53 tkusumi Exp $ */ 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> 33 __KERNEL_RCSID(0, "$NetBSD: dm_target_delay.c,v 1.2 2020/01/21 16:27:53 tkusumi Exp $"); 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; 121 //dmt->upcall = &dm_target_delay_upcall; 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 428 #if 0 429 int 430 dm_target_delay_upcall(dm_table_entry_t *table_en, struct buf *bp) 431 { 432 433 return 0; 434 } 435 #endif 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 } 516