sys/sys/dsched.h

   1 /*
   2  * Copyright (c) 2009 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Alex Hornung <ahornung@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 #ifndef _SYS_DSCHED_H_
  35 #define _SYS_DSCHED_H_
  36
  37 #if defined(_KERNEL)
  38
  39 #ifndef _SYS_QUEUE_H_
  40 #include <sys/queue.h>
  41 #endif
  42 #ifndef _SYS_BIO_H_
  43 #include <sys/bio.h>
  44 #endif
  45 #ifndef _SYS_BIOTRACK_H_
  46 #include <sys/biotrack.h>
  47 #endif
  48 #ifndef _SYS_LOCK_H_
  49 #include <sys/lock.h>
  50 #endif
  51 #ifndef _SYS_CONF_H_
  52 #include <sys/conf.h>
  53 #endif
  54 #ifndef _SYS_MSGPORT_H_
  55 #include <sys/msgport.h>
  56 #endif
  57 #ifndef _SYS_SYSCTL_H_
  58 #include <sys/sysctl.h>
  59 #endif
  60 #ifndef SYS_DISK_H_
  61 #include <sys/disk.h>
  62 #endif
  63
  64 #define DSCHED_POLICY_NAME_LENGTH       64
  65
  66 #define dsched_set_disk_priv(dp, x)     ((dp)->d_dsched_priv1 = (x))
  67 #define dsched_get_disk_priv(dp)        ((dp)?((dp)->d_dsched_priv1):NULL)
  68 #define dsched_set_proc_priv(pp, x)     ((pp)->p_dsched_priv1 = (x))
  69 #define dsched_get_proc_priv(pp)        ((pp)?((pp)->p_dsched_priv1):NULL)
  70
  71 #define dsched_set_thread_priv(td, x)   ((td)->td_dsched_priv1 = (x))
  72 #define dsched_get_thread_priv(td)      ((td)?((td)->td_dsched_priv1):NULL)
  73
  74 #define dsched_set_buf_priv(bp, x)      ((bp)->b_iosched = (x))
  75 #define dsched_get_buf_priv(bp)         ((bp)?((bp)->b_iosched):NULL)
  76 #define dsched_clr_buf_priv(bp)         ((bp)->b_iosched = NULL)
  77 #define dsched_is_clear_buf_priv(bp)    ((bp)->b_iosched == NULL)
  78
  79
  80 #define dsched_set_bio_dp(bio, x)       ((bio)->bio_caller_info1.ptr = (x))
  81 #define dsched_get_bio_dp(bio)          ((bio)?((bio)->bio_caller_info1.ptr):NULL)
  82 #define dsched_set_bio_priv(bio, x)     ((bio)->bio_caller_info2.ptr = (x))
  83 #define dsched_get_bio_priv(bio)        ((bio)?((bio)->bio_caller_info2.ptr):NULL)
  84 #define dsched_set_bio_stime(bio, x)    ((bio)->bio_caller_info3.lvalue = (x))
  85 #define dsched_get_bio_stime(bio)       ((bio)?((bio)->bio_caller_info3.lvalue):0)
  86
  87
  88 struct dsched_thread_ctx {
  89         TAILQ_ENTRY(dsched_thread_ctx)  link;
  90
  91         TAILQ_HEAD(, dsched_thread_io)  tdio_list;      /* list of thread_io */
  92         struct lock     lock;
  93
  94         int32_t         refcount;
  95
  96         struct proc *p;
  97         struct thread *td;
  98         int32_t dead;
  99 };
 100
 101 struct dsched_disk_ctx {
 102         TAILQ_ENTRY(dsched_disk_ctx)    link;
 103
 104         TAILQ_HEAD(, dsched_thread_io)  tdio_list;      /* list of thread_io of disk */
 105         struct lock     lock;
 106
 107         int32_t         refcount;
 108         int32_t         flags;
 109
 110         struct disk     *dp;            /* back pointer to disk struct */
 111
 112         struct sysctl_ctx_list sysctl_ctx;
 113 };
 114
 115 struct dsched_thread_io {
 116         TAILQ_ENTRY(dsched_thread_io)   link;
 117         TAILQ_ENTRY(dsched_thread_io)   dlink;
 118
 119         TAILQ_HEAD(, bio)       queue;  /* IO queue (bio) */
 120         struct lock             lock;
 121         int32_t                 qlength;/* IO queue length */
 122
 123         int32_t refcount;
 124
 125         int32_t flags;
 126
 127         struct disk             *dp;
 128         struct dsched_disk_ctx  *diskctx;
 129         struct dsched_thread_ctx        *tdctx;
 130         struct proc             *p;
 131 };
 132
 133 typedef int     dsched_prepare_t(struct dsched_disk_ctx *diskctx);
 134 typedef void    dsched_teardown_t(struct dsched_disk_ctx *diskctx);
 135 typedef void    dsched_cancel_t(struct dsched_disk_ctx *diskctx);
 136 typedef int     dsched_queue_t(struct dsched_disk_ctx *diskctx,
 137                     struct dsched_thread_io *tdio, struct bio *bio);
 138
 139 typedef void    dsched_new_tdio_t(struct dsched_thread_io *tdio);
 140 typedef void    dsched_new_diskctx_t(struct dsched_disk_ctx *diskctx);
 141 typedef void    dsched_destroy_tdio_t(struct dsched_thread_io *tdio);
 142 typedef void    dsched_destroy_diskctx_t(struct dsched_disk_ctx *diskctx);
 143
 144
 145 struct dsched_policy {
 146         char                    name[DSCHED_POLICY_NAME_LENGTH];
 147         uint64_t                uniq_id;
 148         int                     ref_count;
 149
 150         TAILQ_ENTRY(dsched_policy) link;
 151
 152         dsched_prepare_t        *prepare;
 153         dsched_teardown_t       *teardown;
 154         dsched_cancel_t         *cancel_all;
 155         dsched_queue_t          *bio_queue;
 156
 157         dsched_new_tdio_t       *new_tdio;
 158         dsched_new_diskctx_t    *new_diskctx;
 159         dsched_destroy_tdio_t   *destroy_tdio;
 160         dsched_destroy_diskctx_t        *destroy_diskctx;
 161 };
 162
 163 TAILQ_HEAD(dsched_policy_head, dsched_policy);
 164
 165
 166 #define DSCHED_THREAD_IO_LOCKINIT(x)    \
 167                 lockinit(&(x)->lock, "tdiobioq", 0, LK_CANRECURSE)
 168
 169 #define DSCHED_THREAD_IO_LOCK(x)        do {                    \
 170                         dsched_thread_io_ref((x));              \
 171                         lockmgr(&(x)->lock, LK_EXCLUSIVE);      \
 172                 } while(0)
 173
 174 #define DSCHED_THREAD_IO_UNLOCK(x)      do {                    \
 175                         lockmgr(&(x)->lock, LK_RELEASE);        \
 176                         dsched_thread_io_unref((x));            \
 177                 } while(0)
 178
 179 #define DSCHED_DISK_CTX_LOCKINIT(x)     \
 180                 lockinit(&(x)->lock, "tdiodiskq", 0, LK_CANRECURSE)
 181
 182 #define DSCHED_DISK_CTX_LOCK(x)         do {                    \
 183                         dsched_disk_ctx_ref((x));               \
 184                         lockmgr(&(x)->lock, LK_EXCLUSIVE);      \
 185                 } while(0)
 186
 187 #define DSCHED_DISK_CTX_UNLOCK(x)       do {                    \
 188                         lockmgr(&(x)->lock, LK_RELEASE);        \
 189                         dsched_disk_ctx_unref((x));             \
 190                 } while(0)
 191
 192 #define DSCHED_DISK_CTX_LOCK_ASSERT(x)  \
 193                 KKASSERT(lockstatus(&(x)->lock, curthread) == LK_EXCLUSIVE)
 194
 195 #define DSCHED_GLOBAL_THREAD_CTX_LOCKINIT(x)    \
 196                 lockinit(&dsched_tdctx_lock, "tdctxglob", 0, LK_CANRECURSE)
 197 #define DSCHED_GLOBAL_THREAD_CTX_LOCK(x)        \
 198                 lockmgr(&dsched_tdctx_lock, LK_EXCLUSIVE)
 199 #define DSCHED_GLOBAL_THREAD_CTX_UNLOCK(x)      \
 200                 lockmgr(&dsched_tdctx_lock, LK_RELEASE)
 201
 202 #define DSCHED_THREAD_CTX_LOCKINIT(x)   \
 203                 lockinit(&(x)->lock, "tdctx", 0, LK_CANRECURSE)
 204
 205 #define DSCHED_THREAD_CTX_LOCK(x)       do {                    \
 206                         dsched_thread_ctx_ref((x));             \
 207                         lockmgr(&(x)->lock, LK_EXCLUSIVE);      \
 208                 } while(0)
 209
 210 #define DSCHED_THREAD_CTX_UNLOCK(x)     do {                    \
 211                         lockmgr(&(x)->lock, LK_RELEASE);        \
 212                         dsched_thread_ctx_unref((x));           \
 213                 } while(0)
 214
 215 /* flags for thread_io */
 216 #define DSCHED_LINKED_DISK_CTX          0x01
 217 #define DSCHED_LINKED_THREAD_CTX        0x02
 218 /* flags for disk_ctx */
 219 #define DSCHED_SYSCTL_CTX_INITED        0x01
 220
 221 #define DSCHED_THREAD_CTX_MAX_SZ        sizeof(struct dsched_thread_ctx)
 222 #define DSCHED_THREAD_IO_MAX_SZ         256
 223 #define DSCHED_DISK_CTX_MAX_SZ          512
 224
 225 #define DSCHED_POLICY_MODULE(name, evh)                                 \
 226 static moduledata_t name##_mod = {                                      \
 227     #name,                                                              \
 228     evh,                                                                \
 229     NULL                                                                \
 230 };                                                                      \
 231 DECLARE_MODULE(name, name##_mod, SI_SUB_PRE_DRIVERS, SI_ORDER_MIDDLE)
 232
 233 void    dsched_disk_create_callback(struct disk *dp, const char *head_name, int unit);
 234 void    dsched_disk_update_callback(struct disk *dp, struct disk_info *info);
 235 void    dsched_disk_destroy_callback(struct disk *dp);
 236 void    dsched_queue(struct disk *dp, struct bio *bio);
 237 int     dsched_register(struct dsched_policy *d_policy);
 238 int     dsched_unregister(struct dsched_policy *d_policy);
 239 int     dsched_switch(struct disk *dp, struct dsched_policy *new_policy);
 240 void    dsched_set_policy(struct disk *dp, struct dsched_policy *new_policy);
 241 struct dsched_policy *dsched_find_policy(char *search);
 242 struct disk     *dsched_find_disk(char *search);
 243 struct dsched_policy *dsched_policy_enumerate(struct dsched_policy *pol);
 244 struct disk     *dsched_disk_enumerate(struct disk *dp, struct dsched_policy *policy);
 245 void    dsched_cancel_bio(struct bio *bp);
 246 void    dsched_strategy_raw(struct disk *dp, struct bio *bp);
 247 void    dsched_strategy_sync(struct disk *dp, struct bio *bp);
 248 void    dsched_strategy_async(struct disk *dp, struct bio *bp, biodone_t *done, void *priv);
 249 int     dsched_debug(int level, char *fmt, ...) __printflike(2, 3);
 250
 251 void    policy_new(struct disk *dp, struct dsched_policy *pol);
 252 void    policy_destroy(struct disk *dp);
 253
 254 void    dsched_disk_ctx_ref(struct dsched_disk_ctx *diskctx);
 255 void    dsched_thread_io_ref(struct dsched_thread_io *tdio);
 256 void    dsched_thread_ctx_ref(struct dsched_thread_ctx *tdctx);
 257 void    dsched_disk_ctx_unref(struct dsched_disk_ctx *diskctx);
 258 void    dsched_thread_io_unref(struct dsched_thread_io *tdio);
 259 void    dsched_thread_ctx_unref(struct dsched_thread_ctx *tdctx);
 260
 261 struct dsched_thread_io *dsched_new_policy_thread_tdio(struct dsched_disk_ctx *diskctx,
 262         struct dsched_policy *pol);
 263 struct dsched_thread_io *dsched_thread_io_alloc(struct disk *dp,
 264         struct dsched_thread_ctx *tdctx, struct dsched_policy *pol);
 265 struct dsched_disk_ctx *dsched_disk_ctx_alloc(struct disk *dp,
 266         struct dsched_policy *pol);
 267 struct dsched_thread_ctx *dsched_thread_ctx_alloc(struct proc *p);
 268
 269 typedef void    dsched_new_buf_t(struct buf *bp);
 270 typedef void    dsched_new_proc_t(struct proc *p);
 271 typedef void    dsched_new_thread_t(struct thread *td);
 272 typedef void    dsched_exit_buf_t(struct buf *bp);
 273 typedef void    dsched_exit_proc_t(struct proc *p);
 274 typedef void    dsched_exit_thread_t(struct thread *td);
 275
 276 dsched_new_buf_t        dsched_new_buf;
 277 dsched_new_proc_t       dsched_new_proc;
 278 dsched_new_thread_t     dsched_new_thread;
 279 dsched_exit_buf_t       dsched_exit_buf;
 280 dsched_exit_proc_t      dsched_exit_proc;
 281 dsched_exit_thread_t    dsched_exit_thread;
 282
 283 #endif /* _KERNEL */
 284
 285
 286 #define DSCHED_NAME_LENGTH              64
 287 #define DSCHED_SET_DEVICE_POLICY        _IOWR('d', 1, struct dsched_ioctl)
 288 #define DSCHED_LIST_DISKS               _IOWR('d', 2, struct dsched_ioctl)
 289 #define DSCHED_LIST_DISK                _IOWR('d', 3, struct dsched_ioctl)
 290 #define DSCHED_LIST_POLICIES            _IOWR('d', 4, struct dsched_ioctl)
 291
 292 struct dsched_ioctl {
 293         uint16_t        num_elem;
 294         char            dev_name[DSCHED_NAME_LENGTH];
 295         char            pol_name[DSCHED_NAME_LENGTH];
 296 };
 297
 298 struct dsched_stats {
 299         int32_t tdctx_allocations;
 300         int32_t tdio_allocations;
 301         int32_t diskctx_allocations;
 302
 303         int32_t no_tdctx;
 304
 305         int32_t nthreads;
 306         int32_t nprocs;
 307 };
 308
 309 #endif /* _SYS_DSCHED_H_ */