util/yank.c

   1 /*
   2  * QEMU yank feature
   3  *
   4  * Copyright (c) Lukas Straub <lukasstraub2@web.de>
   5  *
   6  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   7  * See the COPYING file in the top-level directory.
   8  */
   9
  10 #include "qemu/osdep.h"
  11 #include "qapi/error.h"
  12 #include "qemu/thread.h"
  13 #include "qemu/queue.h"
  14 #include "qemu/lockable.h"
  15 #include "qapi/qapi-commands-yank.h"
  16 #include "qapi/qapi-visit-yank.h"
  17 #include "qapi/clone-visitor.h"
  18 #include "qemu/yank.h"
  19
  20 struct YankFuncAndParam {
  21     YankFn *func;
  22     void *opaque;
  23     QLIST_ENTRY(YankFuncAndParam) next;
  24 };
  25
  26 struct YankInstanceEntry {
  27     YankInstance *instance;
  28     QLIST_HEAD(, YankFuncAndParam) yankfns;
  29     QLIST_ENTRY(YankInstanceEntry) next;
  30 };
  31
  32 typedef struct YankFuncAndParam YankFuncAndParam;
  33 typedef struct YankInstanceEntry YankInstanceEntry;
  34
  35 /*
  36  * This lock protects the yank_instance_list below. Because it's taken by
  37  * OOB-capable commands, it must be "fast", i.e. it may only be held for a
  38  * bounded, short time. See docs/devel/qapi-code-gen.txt for additional
  39  * information.
  40  */
  41 static QemuMutex yank_lock;
  42
  43 static QLIST_HEAD(, YankInstanceEntry) yank_instance_list
  44     = QLIST_HEAD_INITIALIZER(yank_instance_list);
  45
  46 static bool yank_instance_equal(const YankInstance *a, const YankInstance *b)
  47 {
  48     if (a->type != b->type) {
  49         return false;
  50     }
  51
  52     switch (a->type) {
  53     case YANK_INSTANCE_TYPE_BLOCK_NODE:
  54         return g_str_equal(a->u.block_node.node_name,
  55                            b->u.block_node.node_name);
  56
  57     case YANK_INSTANCE_TYPE_CHARDEV:
  58         return g_str_equal(a->u.chardev.id, b->u.chardev.id);
  59
  60     case YANK_INSTANCE_TYPE_MIGRATION:
  61         return true;
  62
  63     default:
  64         abort();
  65     }
  66 }
  67
  68 static YankInstanceEntry *yank_find_entry(const YankInstance *instance)
  69 {
  70     YankInstanceEntry *entry;
  71
  72     QLIST_FOREACH(entry, &yank_instance_list, next) {
  73         if (yank_instance_equal(entry->instance, instance)) {
  74             return entry;
  75         }
  76     }
  77     return NULL;
  78 }
  79
  80 bool yank_register_instance(const YankInstance *instance, Error **errp)
  81 {
  82     YankInstanceEntry *entry;
  83
  84     QEMU_LOCK_GUARD(&yank_lock);
  85
  86     if (yank_find_entry(instance)) {
  87         error_setg(errp, "duplicate yank instance");
  88         return false;
  89     }
  90
  91     entry = g_new0(YankInstanceEntry, 1);
  92     entry->instance = QAPI_CLONE(YankInstance, instance);
  93     QLIST_INIT(&entry->yankfns);
  94     QLIST_INSERT_HEAD(&yank_instance_list, entry, next);
  95
  96     return true;
  97 }
  98
  99 void yank_unregister_instance(const YankInstance *instance)
 100 {
 101     YankInstanceEntry *entry;
 102
 103     QEMU_LOCK_GUARD(&yank_lock);
 104     entry = yank_find_entry(instance);
 105     assert(entry);
 106
 107     assert(QLIST_EMPTY(&entry->yankfns));
 108     QLIST_REMOVE(entry, next);
 109     qapi_free_YankInstance(entry->instance);
 110     g_free(entry);
 111 }
 112
 113 void yank_register_function(const YankInstance *instance,
 114                             YankFn *func,
 115                             void *opaque)
 116 {
 117     YankInstanceEntry *entry;
 118     YankFuncAndParam *func_entry;
 119
 120     QEMU_LOCK_GUARD(&yank_lock);
 121     entry = yank_find_entry(instance);
 122     assert(entry);
 123
 124     func_entry = g_new0(YankFuncAndParam, 1);
 125     func_entry->func = func;
 126     func_entry->opaque = opaque;
 127
 128     QLIST_INSERT_HEAD(&entry->yankfns, func_entry, next);
 129 }
 130
 131 void yank_unregister_function(const YankInstance *instance,
 132                               YankFn *func,
 133                               void *opaque)
 134 {
 135     YankInstanceEntry *entry;
 136     YankFuncAndParam *func_entry;
 137
 138     QEMU_LOCK_GUARD(&yank_lock);
 139     entry = yank_find_entry(instance);
 140     assert(entry);
 141
 142     QLIST_FOREACH(func_entry, &entry->yankfns, next) {
 143         if (func_entry->func == func && func_entry->opaque == opaque) {
 144             QLIST_REMOVE(func_entry, next);
 145             g_free(func_entry);
 146             return;
 147         }
 148     }
 149
 150     abort();
 151 }
 152
 153 void qmp_yank(YankInstanceList *instances,
 154               Error **errp)
 155 {
 156     YankInstanceList *tail;
 157     YankInstanceEntry *entry;
 158     YankFuncAndParam *func_entry;
 159
 160     QEMU_LOCK_GUARD(&yank_lock);
 161     for (tail = instances; tail; tail = tail->next) {
 162         entry = yank_find_entry(tail->value);
 163         if (!entry) {
 164             error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, "Instance not found");
 165             return;
 166         }
 167     }
 168     for (tail = instances; tail; tail = tail->next) {
 169         entry = yank_find_entry(tail->value);
 170         assert(entry);
 171         QLIST_FOREACH(func_entry, &entry->yankfns, next) {
 172             func_entry->func(func_entry->opaque);
 173         }
 174     }
 175 }
 176
 177 YankInstanceList *qmp_query_yank(Error **errp)
 178 {
 179     YankInstanceEntry *entry;
 180     YankInstanceList *ret;
 181
 182     ret = NULL;
 183
 184     QEMU_LOCK_GUARD(&yank_lock);
 185     QLIST_FOREACH(entry, &yank_instance_list, next) {
 186         YankInstanceList *new_entry;
 187         new_entry = g_new0(YankInstanceList, 1);
 188         new_entry->value = QAPI_CLONE(YankInstance, entry->instance);
 189         new_entry->next = ret;
 190         ret = new_entry;
 191     }
 192
 193     return ret;
 194 }
 195
 196 static void __attribute__((__constructor__)) yank_init(void)
 197 {
 198     qemu_mutex_init(&yank_lock);
 199 }