sys/dev/disk/dm/targets/delay/dm_target_delay.c

   1 /*
   2  * Copyright (c) 2015 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Tomohiro Kusumi <kusumi.tomohiro@gmail.com>
   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  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include <sys/types.h>
  36 #include <sys/buf.h>
  37 #include <sys/vnode.h>
  38 #include <sys/mutex2.h>
  39 #include <sys/objcache.h>
  40 #include <sys/callout.h>
  41
  42 #include <dev/disk/dm/dm.h>
  43
  44 MALLOC_DEFINE(M_DMDELAY, "dm_delay", "Device Mapper Target Delay");
  45
  46 struct dm_delay_buf {
  47         TAILQ_ENTRY(dm_delay_buf) entry;
  48         struct buf *bp;
  49         int expire;
  50 };
  51 TAILQ_HEAD(dm_delay_buf_list, dm_delay_buf);
  52
  53 struct dm_delay_info {
  54         dm_pdev_t *pdev;
  55         uint64_t offset;
  56         int delay;
  57         int count;
  58         int enabled;
  59         struct dm_delay_buf_list buf_list;
  60         struct callout cal;
  61         struct mtx buf_mtx;
  62         struct mtx cal_mtx;
  63         struct lwkt_token token;
  64         thread_t td;
  65 };
  66
  67 typedef struct target_delay_config {
  68         struct dm_delay_info read;
  69         struct dm_delay_info write;
  70         int argc;  /* either 3 or 6 */
  71 } dm_target_delay_config_t;
  72
  73 static int _init(struct dm_delay_info *di, char **argv, int id);
  74 static int _table(struct dm_delay_info *di, char *p);
  75 static void _strategy(struct dm_delay_info *di, struct buf *bp);
  76 static void _submit(struct dm_delay_info *di, struct buf *bp);
  77 static void _submit_queue(struct dm_delay_info *di, int submit_all);
  78 static void _destroy(struct dm_delay_info *di);
  79 static void _timeout(void *arg);
  80 static void _thread(void *arg);
  81 static __inline void _debug(struct dm_delay_info *di, const char *msg);
  82
  83 static struct objcache *obj_cache = NULL;
  84 static struct objcache_malloc_args obj_args = {
  85         sizeof(struct dm_delay_buf), M_DMDELAY,
  86 };
  87
  88 static int
  89 dm_target_delay_init(dm_table_entry_t *table_en, int argc, char **argv)
  90 {
  91         dm_target_delay_config_t *tdc;
  92         int ret;
  93
  94         aprint_debug("Delay target init: argc=%d\n", argc);
  95         if (argc != 3 && argc != 6) {
  96                 kprintf("Delay target takes 3 or 6 args\n");
  97                 return EINVAL;
  98         }
  99
 100         tdc = kmalloc(sizeof(*tdc), M_DMDELAY, M_WAITOK | M_ZERO);
 101         tdc->argc = argc;
 102
 103         ret = _init(&tdc->read, argv, 0);
 104         if (ret) {
 105                 kfree(tdc, M_DMDELAY);
 106                 return ret;
 107         }
 108
 109         if (argc == 6)
 110                 argv += 3;
 111
 112         ret = _init(&tdc->write, argv, 1);
 113         if (ret) {
 114                 dm_pdev_decr(tdc->read.pdev);
 115                 kfree(tdc, M_DMDELAY);
 116                 return ret;
 117         }
 118
 119         dm_table_add_deps(table_en, tdc->read.pdev);
 120         dm_table_add_deps(table_en, tdc->write.pdev);
 121
 122         dm_table_init_target(table_en, DM_DELAY_DEV, tdc);
 123
 124         return 0;
 125 }
 126
 127 static int
 128 _init(struct dm_delay_info *di, char **argv, int id)
 129 {
 130         dm_pdev_t *dmp;
 131         int tmp;
 132
 133         if (argv[0] == NULL)
 134                 return EINVAL;
 135         if ((dmp = dm_pdev_insert(argv[0])) == NULL)
 136                 return ENOENT;
 137
 138         di->pdev = dmp;
 139         di->offset = atoi64(argv[1]);
 140         tmp = atoi64(argv[2]);
 141         di->delay = tmp * hz / 1000;
 142         di->count = 0;
 143
 144         TAILQ_INIT(&di->buf_list);
 145         callout_init(&di->cal);
 146         mtx_init(&di->buf_mtx, "dmdlbuf");
 147         mtx_init(&di->cal_mtx, "dmdlcal");
 148         lwkt_token_init(&di->token, "dmdlthr");
 149
 150         di->enabled = 1;
 151         lwkt_create(_thread, di, &di->td, NULL, 0, -1, "dmdl%d", id);
 152
 153         _debug(di, "init");
 154         return 0;
 155 }
 156
 157 static char *
 158 dm_target_delay_info(void *target_config)
 159 {
 160         dm_target_delay_config_t *tdc;
 161         char *params;
 162
 163         tdc = target_config;
 164         KKASSERT(tdc != NULL);
 165
 166         params = dm_alloc_string(DM_MAX_PARAMS_SIZE);
 167         ksnprintf(params, DM_MAX_PARAMS_SIZE,
 168                 "%d %d", tdc->read.count, tdc->write.count);
 169
 170         return params;
 171 }
 172
 173 static char *
 174 dm_target_delay_table(void *target_config)
 175 {
 176         dm_target_delay_config_t *tdc;
 177         char *params, *p;
 178
 179         tdc = target_config;
 180         KKASSERT(tdc != NULL);
 181
 182         params = dm_alloc_string(DM_MAX_PARAMS_SIZE);
 183         p = params;
 184         p += _table(&tdc->read, p);
 185         if (tdc->argc == 6) {
 186                 p += ksnprintf(p, DM_MAX_PARAMS_SIZE, " ");
 187                 _table(&tdc->write, p);
 188         }
 189
 190         return params;
 191 }
 192
 193 static int _table(struct dm_delay_info *di, char *p)
 194 {
 195         int ret;
 196
 197         ret = ksnprintf(p, DM_MAX_PARAMS_SIZE,
 198                 "%s %" PRIu64 " %d",
 199                 di->pdev->udev_name, di->offset, di->delay);
 200         return ret;
 201 }
 202
 203 static int
 204 dm_target_delay_strategy(dm_table_entry_t *table_en, struct buf *bp)
 205 {
 206         dm_target_delay_config_t *tdc;
 207         struct dm_delay_info *di;
 208
 209         tdc = table_en->target_config;
 210         KKASSERT(tdc != NULL);
 211
 212         switch (bp->b_cmd) {
 213         case BUF_CMD_READ:
 214                 di = &tdc->read;
 215                 break;
 216         case BUF_CMD_WRITE:
 217         case BUF_CMD_FLUSH:
 218                 di = &tdc->write;
 219                 break;
 220         default:
 221                 di = NULL;
 222                 break;
 223         }
 224
 225         if (di) {
 226                 if (di->delay) {
 227                         _strategy(di, bp);
 228                 } else {
 229                         _submit(di, bp);
 230                 }
 231         } else {
 232                 /* XXX */
 233                 struct vnode *vnode = tdc->write.pdev->pdev_vnode;
 234                 vn_strategy(vnode, &bp->b_bio1);
 235         }
 236         return 0;
 237 }
 238
 239 static void
 240 _strategy(struct dm_delay_info *di, struct buf *bp)
 241 {
 242         struct dm_delay_buf *dp;
 243
 244         dp = objcache_get(obj_cache, M_WAITOK);
 245         dp->bp = bp;
 246         dp->expire = ticks + di->delay;
 247
 248         mtx_lock(&di->buf_mtx);
 249         di->count++;
 250         TAILQ_INSERT_TAIL(&di->buf_list, dp, entry);
 251         mtx_unlock(&di->buf_mtx);
 252
 253         mtx_lock(&di->cal_mtx);
 254         if (!callout_pending(&di->cal))
 255                 callout_reset(&di->cal, di->delay, _timeout, di);
 256         mtx_unlock(&di->cal_mtx);
 257 }
 258
 259 static void
 260 _submit(struct dm_delay_info *di, struct buf *bp)
 261 {
 262         _debug(di, "submit");
 263
 264         bp->b_bio1.bio_offset += di->offset * DEV_BSIZE;
 265         vn_strategy(di->pdev->pdev_vnode, &bp->b_bio1);
 266 }
 267
 268 static void
 269 _submit_queue(struct dm_delay_info *di, int submit_all)
 270 {
 271         struct dm_delay_buf *dp;
 272         struct dm_delay_buf_list tmp_list;
 273         int next = -1;
 274         int reset = 0;
 275
 276         _debug(di, "submitq");
 277         TAILQ_INIT(&tmp_list);
 278
 279         mtx_lock(&di->buf_mtx);
 280         while ((dp = TAILQ_FIRST(&di->buf_list)) != NULL) {
 281                 if (submit_all || ticks > dp->expire) {
 282                         TAILQ_REMOVE(&di->buf_list, dp, entry);
 283                         TAILQ_INSERT_TAIL(&tmp_list, dp, entry);
 284                         di->count--;
 285                         continue;
 286                 }
 287                 if (reset == 0) {
 288                         reset = 1;
 289                         next = dp->expire;
 290                 } else {
 291                         next = min(next, dp->expire);
 292                 }
 293         }
 294         mtx_unlock(&di->buf_mtx);
 295
 296         if (reset) {
 297                 mtx_lock(&di->cal_mtx);
 298                 callout_reset(&di->cal, next - ticks, _timeout, di);
 299                 mtx_unlock(&di->cal_mtx);
 300         }
 301
 302         while ((dp = TAILQ_FIRST(&tmp_list)) != NULL) {
 303                 TAILQ_REMOVE(&tmp_list, dp, entry);
 304                 _submit(di, dp->bp);
 305                 objcache_put(obj_cache, dp);
 306         }
 307 }
 308
 309 static int
 310 dm_target_delay_destroy(dm_table_entry_t *table_en)
 311 {
 312         dm_target_delay_config_t *tdc;
 313
 314         tdc = table_en->target_config;
 315         if (tdc == NULL)
 316                 return 0;
 317
 318         _destroy(&tdc->read);
 319         _destroy(&tdc->write);
 320
 321         kfree(tdc, M_DMDELAY);
 322         table_en->target_config = NULL;
 323
 324         return 0;
 325 }
 326
 327 static void
 328 _destroy(struct dm_delay_info *di)
 329 {
 330         _debug(di, "destroy");
 331
 332         lwkt_gettoken(&di->token);
 333         di->enabled = 0;
 334
 335         mtx_lock(&di->cal_mtx);
 336         if (callout_pending(&di->cal))
 337                 callout_stop_sync(&di->cal);
 338         mtx_unlock(&di->cal_mtx);
 339
 340         _submit_queue(di, 1);
 341         wakeup(di);
 342         tsleep(&di->enabled, 0, "dmdldestroy", 0);
 343         lwkt_reltoken(&di->token);
 344
 345         mtx_uninit(&di->cal_mtx);
 346         mtx_uninit(&di->buf_mtx);
 347
 348         dm_pdev_decr(di->pdev);
 349 }
 350
 351 static void
 352 _timeout(void *arg)
 353 {
 354         struct dm_delay_info *di = arg;
 355
 356         _debug(di, "timeout");
 357         wakeup(di);
 358 }
 359
 360 static void
 361 _thread(void *arg)
 362 {
 363         struct dm_delay_info *di = arg;
 364
 365         _debug(di, "thread init");
 366         lwkt_gettoken(&di->token);
 367
 368         while (di->enabled) {
 369                 tsleep(di, 0, "dmdlthread", 0);
 370                 _submit_queue(di, 0);
 371         }
 372
 373         di->td = NULL;
 374         wakeup(&di->enabled);
 375
 376         _debug(di, "thread exit");
 377         lwkt_reltoken(&di->token);
 378         lwkt_exit();
 379 }
 380
 381 static __inline
 382 void
 383 _debug(struct dm_delay_info *di, const char *msg)
 384 {
 385         aprint_debug("%-8s: %d pdev=%s offset=%ju delay=%d count=%d\n",
 386                 msg, di->enabled, di->pdev->name,
 387                 (uintmax_t)di->offset, di->delay, di->count);
 388 }
 389
 390 static void
 391 _objcache_create(void)
 392 {
 393         if (obj_cache == NULL) {
 394                 obj_cache = objcache_create("dmdlobj", 0, 0, NULL, NULL, NULL,
 395                         objcache_malloc_alloc,
 396                         objcache_malloc_free,
 397                         &obj_args);
 398         }
 399         KKASSERT(obj_cache);
 400 }
 401
 402 static void
 403 _objcache_destroy(void)
 404 {
 405         if (obj_cache) {
 406                 objcache_destroy(obj_cache);
 407                 obj_cache = NULL;
 408         }
 409 }
 410
 411 static int
 412 dmtd_mod_handler(module_t mod, int type, void *unused)
 413 {
 414         dm_target_t *dmt = NULL;
 415         int err = 0;
 416
 417         switch(type) {
 418         case MOD_LOAD:
 419                 if ((dmt = dm_target_lookup("delay")) != NULL) {
 420                         dm_target_unbusy(dmt);
 421                         return EEXIST;
 422                 }
 423                 dmt = dm_target_alloc("delay");
 424                 dmt->version[0] = 1;
 425                 dmt->version[1] = 0;
 426                 dmt->version[2] = 0;
 427                 strlcpy(dmt->name, "delay", DM_MAX_TYPE_NAME);
 428                 dmt->init = &dm_target_delay_init;
 429                 dmt->info = &dm_target_delay_info;
 430                 dmt->table = &dm_target_delay_table;
 431                 dmt->strategy = &dm_target_delay_strategy;
 432                 dmt->destroy = &dm_target_delay_destroy;
 433
 434                 _objcache_create();
 435                 err = dm_target_insert(dmt);
 436                 if (err == 0)
 437                         kprintf("dm_target_delay: Successfully initialized\n");
 438                 break;
 439
 440         case MOD_UNLOAD:
 441                 err = dm_target_rem("delay");
 442                 if (err == 0)
 443                         kprintf("dm_target_delay: unloaded\n");
 444                 _objcache_destroy();
 445                 break;
 446         }
 447
 448         return err;
 449 }
 450
 451 DM_TARGET_MODULE(dm_target_delay, dmtd_mod_handler);