drivers/md/dm-cache-background-tracker.c

   1 /*
   2  * Copyright (C) 2017 Red Hat. All rights reserved.
   3  *
   4  * This file is released under the GPL.
   5  */
   6
   7 #include "dm-cache-background-tracker.h"
   8
   9 /*----------------------------------------------------------------*/
  10
  11 #define DM_MSG_PREFIX "dm-background-tracker"
  12
  13 struct bt_work {
  14         struct list_head list;
  15         struct rb_node node;
  16         struct policy_work work;
  17 };
  18
  19 struct background_tracker {
  20         unsigned int max_work;
  21         atomic_t pending_promotes;
  22         atomic_t pending_writebacks;
  23         atomic_t pending_demotes;
  24
  25         struct list_head issued;
  26         struct list_head queued;
  27         struct rb_root pending;
  28
  29         struct kmem_cache *work_cache;
  30 };
  31
  32 struct background_tracker *btracker_create(unsigned int max_work)
  33 {
  34         struct background_tracker *b = kmalloc(sizeof(*b), GFP_KERNEL);
  35
  36         if (!b) {
  37                 DMERR("couldn't create background_tracker");
  38                 return NULL;
  39         }
  40
  41         b->max_work = max_work;
  42         atomic_set(&b->pending_promotes, 0);
  43         atomic_set(&b->pending_writebacks, 0);
  44         atomic_set(&b->pending_demotes, 0);
  45
  46         INIT_LIST_HEAD(&b->issued);
  47         INIT_LIST_HEAD(&b->queued);
  48
  49         b->pending = RB_ROOT;
  50         b->work_cache = KMEM_CACHE(bt_work, 0);
  51         if (!b->work_cache) {
  52                 DMERR("couldn't create mempool for background work items");
  53                 kfree(b);
  54                 b = NULL;
  55         }
  56
  57         return b;
  58 }
  59 EXPORT_SYMBOL_GPL(btracker_create);
  60
  61 void btracker_destroy(struct background_tracker *b)
  62 {
  63         struct bt_work *w, *tmp;
  64
  65         BUG_ON(!list_empty(&b->issued));
  66         list_for_each_entry_safe (w, tmp, &b->queued, list) {
  67                 list_del(&w->list);
  68                 kmem_cache_free(b->work_cache, w);
  69         }
  70
  71         kmem_cache_destroy(b->work_cache);
  72         kfree(b);
  73 }
  74 EXPORT_SYMBOL_GPL(btracker_destroy);
  75
  76 static int cmp_oblock(dm_oblock_t lhs, dm_oblock_t rhs)
  77 {
  78         if (from_oblock(lhs) < from_oblock(rhs))
  79                 return -1;
  80
  81         if (from_oblock(rhs) < from_oblock(lhs))
  82                 return 1;
  83
  84         return 0;
  85 }
  86
  87 static bool __insert_pending(struct background_tracker *b,
  88                              struct bt_work *nw)
  89 {
  90         int cmp;
  91         struct bt_work *w;
  92         struct rb_node **new = &b->pending.rb_node, *parent = NULL;
  93
  94         while (*new) {
  95                 w = container_of(*new, struct bt_work, node);
  96
  97                 parent = *new;
  98                 cmp = cmp_oblock(w->work.oblock, nw->work.oblock);
  99                 if (cmp < 0)
 100                         new = &((*new)->rb_left);
 101
 102                 else if (cmp > 0)
 103                         new = &((*new)->rb_right);
 104
 105                 else
 106                         /* already present */
 107                         return false;
 108         }
 109
 110         rb_link_node(&nw->node, parent, new);
 111         rb_insert_color(&nw->node, &b->pending);
 112
 113         return true;
 114 }
 115
 116 static struct bt_work *__find_pending(struct background_tracker *b,
 117                                       dm_oblock_t oblock)
 118 {
 119         int cmp;
 120         struct bt_work *w;
 121         struct rb_node **new = &b->pending.rb_node;
 122
 123         while (*new) {
 124                 w = container_of(*new, struct bt_work, node);
 125
 126                 cmp = cmp_oblock(w->work.oblock, oblock);
 127                 if (cmp < 0)
 128                         new = &((*new)->rb_left);
 129
 130                 else if (cmp > 0)
 131                         new = &((*new)->rb_right);
 132
 133                 else
 134                         break;
 135         }
 136
 137         return *new ? w : NULL;
 138 }
 139
 140
 141 static void update_stats(struct background_tracker *b, struct policy_work *w, int delta)
 142 {
 143         switch (w->op) {
 144         case POLICY_PROMOTE:
 145                 atomic_add(delta, &b->pending_promotes);
 146                 break;
 147
 148         case POLICY_DEMOTE:
 149                 atomic_add(delta, &b->pending_demotes);
 150                 break;
 151
 152         case POLICY_WRITEBACK:
 153                 atomic_add(delta, &b->pending_writebacks);
 154                 break;
 155         }
 156 }
 157
 158 unsigned int btracker_nr_writebacks_queued(struct background_tracker *b)
 159 {
 160         return atomic_read(&b->pending_writebacks);
 161 }
 162 EXPORT_SYMBOL_GPL(btracker_nr_writebacks_queued);
 163
 164 unsigned int btracker_nr_demotions_queued(struct background_tracker *b)
 165 {
 166         return atomic_read(&b->pending_demotes);
 167 }
 168 EXPORT_SYMBOL_GPL(btracker_nr_demotions_queued);
 169
 170 static bool max_work_reached(struct background_tracker *b)
 171 {
 172         return atomic_read(&b->pending_promotes) +
 173                 atomic_read(&b->pending_writebacks) +
 174                 atomic_read(&b->pending_demotes) >= b->max_work;
 175 }
 176
 177 static struct bt_work *alloc_work(struct background_tracker *b)
 178 {
 179         if (max_work_reached(b))
 180                 return NULL;
 181
 182         return kmem_cache_alloc(b->work_cache, GFP_NOWAIT);
 183 }
 184
 185 int btracker_queue(struct background_tracker *b,
 186                    struct policy_work *work,
 187                    struct policy_work **pwork)
 188 {
 189         struct bt_work *w;
 190
 191         if (pwork)
 192                 *pwork = NULL;
 193
 194         w = alloc_work(b);
 195         if (!w)
 196                 return -ENOMEM;
 197
 198         memcpy(&w->work, work, sizeof(*work));
 199
 200         if (!__insert_pending(b, w)) {
 201                 /*
 202                  * There was a race, we'll just ignore this second
 203                  * bit of work for the same oblock.
 204                  */
 205                 kmem_cache_free(b->work_cache, w);
 206                 return -EINVAL;
 207         }
 208
 209         if (pwork) {
 210                 *pwork = &w->work;
 211                 list_add(&w->list, &b->issued);
 212         } else
 213                 list_add(&w->list, &b->queued);
 214         update_stats(b, &w->work, 1);
 215
 216         return 0;
 217 }
 218 EXPORT_SYMBOL_GPL(btracker_queue);
 219
 220 /*
 221  * Returns -ENODATA if there's no work.
 222  */
 223 int btracker_issue(struct background_tracker *b, struct policy_work **work)
 224 {
 225         struct bt_work *w;
 226
 227         if (list_empty(&b->queued))
 228                 return -ENODATA;
 229
 230         w = list_first_entry(&b->queued, struct bt_work, list);
 231         list_move(&w->list, &b->issued);
 232         *work = &w->work;
 233
 234         return 0;
 235 }
 236 EXPORT_SYMBOL_GPL(btracker_issue);
 237
 238 void btracker_complete(struct background_tracker *b,
 239                        struct policy_work *op)
 240 {
 241         struct bt_work *w = container_of(op, struct bt_work, work);
 242
 243         update_stats(b, &w->work, -1);
 244         rb_erase(&w->node, &b->pending);
 245         list_del(&w->list);
 246         kmem_cache_free(b->work_cache, w);
 247 }
 248 EXPORT_SYMBOL_GPL(btracker_complete);
 249
 250 bool btracker_promotion_already_present(struct background_tracker *b,
 251                                         dm_oblock_t oblock)
 252 {
 253         return __find_pending(b, oblock) != NULL;
 254 }
 255 EXPORT_SYMBOL_GPL(btracker_promotion_already_present);
 256
 257 /*----------------------------------------------------------------*/