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

0001 /*
0002  * Copyright (C) 2017 Red Hat. All rights reserved.
0003  *
0004  * This file is released under the GPL.
0005  */
0006
0007 #include "dm-cache-background-tracker.h"
0008
0009 /*----------------------------------------------------------------*/
0010
0011 #define DM_MSG_PREFIX "dm-background-tracker"
0012
0013 struct bt_work {
0014     struct list_head list;
0015     struct rb_node node;
0016     struct policy_work work;
0017 };
0018
0019 struct background_tracker {
0020     unsigned max_work;
0021     atomic_t pending_promotes;
0022     atomic_t pending_writebacks;
0023     atomic_t pending_demotes;
0024
0025     struct list_head issued;
0026     struct list_head queued;
0027     struct rb_root pending;
0028
0029     struct kmem_cache *work_cache;
0030 };
0031
0032 struct background_tracker *btracker_create(unsigned max_work)
0033 {
0034     struct background_tracker *b = kmalloc(sizeof(*b), GFP_KERNEL);
0035
0036     if (!b) {
0037         DMERR("couldn't create background_tracker");
0038         return NULL;
0039     }
0040
0041     b->max_work = max_work;
0042     atomic_set(&b->pending_promotes, 0);
0043     atomic_set(&b->pending_writebacks, 0);
0044     atomic_set(&b->pending_demotes, 0);
0045
0046     INIT_LIST_HEAD(&b->issued);
0047     INIT_LIST_HEAD(&b->queued);
0048
0049     b->pending = RB_ROOT;
0050     b->work_cache = KMEM_CACHE(bt_work, 0);
0051     if (!b->work_cache) {
0052         DMERR("couldn't create mempool for background work items");
0053         kfree(b);
0054         b = NULL;
0055     }
0056
0057     return b;
0058 }
0059 EXPORT_SYMBOL_GPL(btracker_create);
0060
0061 void btracker_destroy(struct background_tracker *b)
0062 {
0063     kmem_cache_destroy(b->work_cache);
0064     kfree(b);
0065 }
0066 EXPORT_SYMBOL_GPL(btracker_destroy);
0067
0068 static int cmp_oblock(dm_oblock_t lhs, dm_oblock_t rhs)
0069 {
0070     if (from_oblock(lhs) < from_oblock(rhs))
0071         return -1;
0072
0073     if (from_oblock(rhs) < from_oblock(lhs))
0074         return 1;
0075
0076     return 0;
0077 }
0078
0079 static bool __insert_pending(struct background_tracker *b,
0080                  struct bt_work *nw)
0081 {
0082     int cmp;
0083     struct bt_work *w;
0084     struct rb_node **new = &b->pending.rb_node, *parent = NULL;
0085
0086     while (*new) {
0087         w = container_of(*new, struct bt_work, node);
0088
0089         parent = *new;
0090         cmp = cmp_oblock(w->work.oblock, nw->work.oblock);
0091         if (cmp < 0)
0092             new = &((*new)->rb_left);
0093
0094         else if (cmp > 0)
0095             new = &((*new)->rb_right);
0096
0097         else
0098             /* already present */
0099             return false;
0100     }
0101
0102     rb_link_node(&nw->node, parent, new);
0103     rb_insert_color(&nw->node, &b->pending);
0104
0105     return true;
0106 }
0107
0108 static struct bt_work *__find_pending(struct background_tracker *b,
0109                       dm_oblock_t oblock)
0110 {
0111     int cmp;
0112     struct bt_work *w;
0113     struct rb_node **new = &b->pending.rb_node;
0114
0115     while (*new) {
0116         w = container_of(*new, struct bt_work, node);
0117
0118         cmp = cmp_oblock(w->work.oblock, oblock);
0119         if (cmp < 0)
0120             new = &((*new)->rb_left);
0121
0122         else if (cmp > 0)
0123             new = &((*new)->rb_right);
0124
0125         else
0126             break;
0127     }
0128
0129     return *new ? w : NULL;
0130 }
0131
0132
0133 static void update_stats(struct background_tracker *b, struct policy_work *w, int delta)
0134 {
0135     switch (w->op) {
0136     case POLICY_PROMOTE:
0137         atomic_add(delta, &b->pending_promotes);
0138         break;
0139
0140     case POLICY_DEMOTE:
0141         atomic_add(delta, &b->pending_demotes);
0142         break;
0143
0144     case POLICY_WRITEBACK:
0145         atomic_add(delta, &b->pending_writebacks);
0146         break;
0147     }
0148 }
0149
0150 unsigned btracker_nr_writebacks_queued(struct background_tracker *b)
0151 {
0152     return atomic_read(&b->pending_writebacks);
0153 }
0154 EXPORT_SYMBOL_GPL(btracker_nr_writebacks_queued);
0155
0156 unsigned btracker_nr_demotions_queued(struct background_tracker *b)
0157 {
0158     return atomic_read(&b->pending_demotes);
0159 }
0160 EXPORT_SYMBOL_GPL(btracker_nr_demotions_queued);
0161
0162 static bool max_work_reached(struct background_tracker *b)
0163 {
0164     return atomic_read(&b->pending_promotes) +
0165         atomic_read(&b->pending_writebacks) +
0166         atomic_read(&b->pending_demotes) >= b->max_work;
0167 }
0168
0169 static struct bt_work *alloc_work(struct background_tracker *b)
0170 {
0171     if (max_work_reached(b))
0172         return NULL;
0173
0174     return kmem_cache_alloc(b->work_cache, GFP_NOWAIT);
0175 }
0176
0177 int btracker_queue(struct background_tracker *b,
0178            struct policy_work *work,
0179            struct policy_work **pwork)
0180 {
0181     struct bt_work *w;
0182
0183     if (pwork)
0184         *pwork = NULL;
0185
0186     w = alloc_work(b);
0187     if (!w)
0188         return -ENOMEM;
0189
0190     memcpy(&w->work, work, sizeof(*work));
0191
0192     if (!__insert_pending(b, w)) {
0193         /*
0194          * There was a race, we'll just ignore this second
0195          * bit of work for the same oblock.
0196          */
0197         kmem_cache_free(b->work_cache, w);
0198         return -EINVAL;
0199     }
0200
0201     if (pwork) {
0202         *pwork = &w->work;
0203         list_add(&w->list, &b->issued);
0204     } else
0205         list_add(&w->list, &b->queued);
0206     update_stats(b, &w->work, 1);
0207
0208     return 0;
0209 }
0210 EXPORT_SYMBOL_GPL(btracker_queue);
0211
0212 /*
0213  * Returns -ENODATA if there's no work.
0214  */
0215 int btracker_issue(struct background_tracker *b, struct policy_work **work)
0216 {
0217     struct bt_work *w;
0218
0219     if (list_empty(&b->queued))
0220         return -ENODATA;
0221
0222     w = list_first_entry(&b->queued, struct bt_work, list);
0223     list_move(&w->list, &b->issued);
0224     *work = &w->work;
0225
0226     return 0;
0227 }
0228 EXPORT_SYMBOL_GPL(btracker_issue);
0229
0230 void btracker_complete(struct background_tracker *b,
0231                struct policy_work *op)
0232 {
0233     struct bt_work *w = container_of(op, struct bt_work, work);
0234
0235     update_stats(b, &w->work, -1);
0236     rb_erase(&w->node, &b->pending);
0237     list_del(&w->list);
0238     kmem_cache_free(b->work_cache, w);
0239 }
0240 EXPORT_SYMBOL_GPL(btracker_complete);
0241
0242 bool btracker_promotion_already_present(struct background_tracker *b,
0243                     dm_oblock_t oblock)
0244 {
0245     return __find_pending(b, oblock) != NULL;
0246 }
0247 EXPORT_SYMBOL_GPL(btracker_promotion_already_present);
0248
0249 /*----------------------------------------------------------------*/