util/thread-context.c

   1 /*
   2  * QEMU Thread Context
   3  *
   4  * Copyright Red Hat Inc., 2022
   5  *
   6  * Authors:
   7  *  David Hildenbrand <david@redhat.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10  * See the COPYING file in the top-level directory.
  11  */
  12
  13 #include "qemu/osdep.h"
  14 #include "qemu/thread-context.h"
  15 #include "qapi/error.h"
  16 #include "qapi/qapi-builtin-visit.h"
  17 #include "qapi/visitor.h"
  18 #include "qemu/config-file.h"
  19 #include "qapi/qapi-builtin-visit.h"
  20 #include "qom/object_interfaces.h"
  21 #include "qemu/module.h"
  22 #include "qemu/bitmap.h"
  23
  24 #ifdef CONFIG_NUMA
  25 #include <numa.h>
  26 #endif
  27
  28 enum {
  29     TC_CMD_NONE = 0,
  30     TC_CMD_STOP,
  31     TC_CMD_NEW,
  32 };
  33
  34 typedef struct ThreadContextCmdNew {
  35     QemuThread *thread;
  36     const char *name;
  37     void *(*start_routine)(void *);
  38     void *arg;
  39     int mode;
  40 } ThreadContextCmdNew;
  41
  42 static void *thread_context_run(void *opaque)
  43 {
  44     ThreadContext *tc = opaque;
  45
  46     tc->thread_id = qemu_get_thread_id();
  47     qemu_sem_post(&tc->sem);
  48
  49     while (true) {
  50         /*
  51          * Threads inherit the CPU affinity of the creating thread. For this
  52          * reason, we create new (especially short-lived) threads from our
  53          * persistent context thread.
  54          *
  55          * Especially when QEMU is not allowed to set the affinity itself,
  56          * management tools can simply set the affinity of the context thread
  57          * after creating the context, to have new threads created via
  58          * the context inherit the CPU affinity automatically.
  59          */
  60         switch (tc->thread_cmd) {
  61         case TC_CMD_NONE:
  62             break;
  63         case TC_CMD_STOP:
  64             tc->thread_cmd = TC_CMD_NONE;
  65             qemu_sem_post(&tc->sem);
  66             return NULL;
  67         case TC_CMD_NEW: {
  68             ThreadContextCmdNew *cmd_new = tc->thread_cmd_data;
  69
  70             qemu_thread_create(cmd_new->thread, cmd_new->name,
  71                                cmd_new->start_routine, cmd_new->arg,
  72                                cmd_new->mode);
  73             tc->thread_cmd = TC_CMD_NONE;
  74             tc->thread_cmd_data = NULL;
  75             qemu_sem_post(&tc->sem);
  76             break;
  77         }
  78         default:
  79             g_assert_not_reached();
  80         }
  81         qemu_sem_wait(&tc->sem_thread);
  82     }
  83 }
  84
  85 static void thread_context_set_cpu_affinity(Object *obj, Visitor *v,
  86                                             const char *name, void *opaque,
  87                                             Error **errp)
  88 {
  89     ThreadContext *tc = THREAD_CONTEXT(obj);
  90     uint16List *l, *host_cpus = NULL;
  91     unsigned long *bitmap = NULL;
  92     int nbits = 0, ret;
  93
  94     if (tc->init_cpu_bitmap) {
  95         error_setg(errp, "Mixing CPU and node affinity not supported");
  96         return;
  97     }
  98
  99     if (!visit_type_uint16List(v, name, &host_cpus, errp)) {
 100         return;
 101     }
 102
 103     if (!host_cpus) {
 104         error_setg(errp, "CPU list is empty");
 105         goto out;
 106     }
 107
 108     for (l = host_cpus; l; l = l->next) {
 109         nbits = MAX(nbits, l->value + 1);
 110     }
 111     bitmap = bitmap_new(nbits);
 112     for (l = host_cpus; l; l = l->next) {
 113         set_bit(l->value, bitmap);
 114     }
 115
 116     if (tc->thread_id != -1) {
 117         /*
 118          * Note: we won't be adjusting the affinity of any thread that is still
 119          * around, but only the affinity of the context thread.
 120          */
 121         ret = qemu_thread_set_affinity(&tc->thread, bitmap, nbits);
 122         if (ret) {
 123             error_setg(errp, "Setting CPU affinity failed: %s", strerror(ret));
 124         }
 125     } else {
 126         tc->init_cpu_bitmap = bitmap;
 127         bitmap = NULL;
 128         tc->init_cpu_nbits = nbits;
 129     }
 130 out:
 131     g_free(bitmap);
 132     qapi_free_uint16List(host_cpus);
 133 }
 134
 135 static void thread_context_get_cpu_affinity(Object *obj, Visitor *v,
 136                                             const char *name, void *opaque,
 137                                             Error **errp)
 138 {
 139     unsigned long *bitmap, nbits, value;
 140     ThreadContext *tc = THREAD_CONTEXT(obj);
 141     uint16List *host_cpus = NULL;
 142     uint16List **tail = &host_cpus;
 143     int ret;
 144
 145     if (tc->thread_id == -1) {
 146         error_setg(errp, "Object not initialized yet");
 147         return;
 148     }
 149
 150     ret = qemu_thread_get_affinity(&tc->thread, &bitmap, &nbits);
 151     if (ret) {
 152         error_setg(errp, "Getting CPU affinity failed: %s", strerror(ret));
 153         return;
 154     }
 155
 156     value = find_first_bit(bitmap, nbits);
 157     while (value < nbits) {
 158         QAPI_LIST_APPEND(tail, value);
 159
 160         value = find_next_bit(bitmap, nbits, value + 1);
 161     }
 162     g_free(bitmap);
 163
 164     visit_type_uint16List(v, name, &host_cpus, errp);
 165     qapi_free_uint16List(host_cpus);
 166 }
 167
 168 static void thread_context_set_node_affinity(Object *obj, Visitor *v,
 169                                              const char *name, void *opaque,
 170                                              Error **errp)
 171 {
 172 #ifdef CONFIG_NUMA
 173     const int nbits = numa_num_possible_cpus();
 174     ThreadContext *tc = THREAD_CONTEXT(obj);
 175     uint16List *l, *host_nodes = NULL;
 176     unsigned long *bitmap = NULL;
 177     struct bitmask *tmp_cpus;
 178     int ret, i;
 179
 180     if (tc->init_cpu_bitmap) {
 181         error_setg(errp, "Mixing CPU and node affinity not supported");
 182         return;
 183     }
 184
 185     if (!visit_type_uint16List(v, name, &host_nodes, errp)) {
 186         return;
 187     }
 188
 189     if (!host_nodes) {
 190         error_setg(errp, "Node list is empty");
 191         goto out;
 192     }
 193
 194     bitmap = bitmap_new(nbits);
 195     tmp_cpus = numa_allocate_cpumask();
 196     for (l = host_nodes; l; l = l->next) {
 197         numa_bitmask_clearall(tmp_cpus);
 198         ret = numa_node_to_cpus(l->value, tmp_cpus);
 199         if (ret) {
 200             /* We ignore any errors, such as impossible nodes. */
 201             continue;
 202         }
 203         for (i = 0; i < nbits; i++) {
 204             if (numa_bitmask_isbitset(tmp_cpus, i)) {
 205                 set_bit(i, bitmap);
 206             }
 207         }
 208     }
 209     numa_free_cpumask(tmp_cpus);
 210
 211     if (bitmap_empty(bitmap, nbits)) {
 212         error_setg(errp, "The nodes select no CPUs");
 213         goto out;
 214     }
 215
 216     if (tc->thread_id != -1) {
 217         /*
 218          * Note: we won't be adjusting the affinity of any thread that is still
 219          * around for now, but only the affinity of the context thread.
 220          */
 221         ret = qemu_thread_set_affinity(&tc->thread, bitmap, nbits);
 222         if (ret) {
 223             error_setg(errp, "Setting CPU affinity failed: %s", strerror(ret));
 224         }
 225     } else {
 226         tc->init_cpu_bitmap = bitmap;
 227         bitmap = NULL;
 228         tc->init_cpu_nbits = nbits;
 229     }
 230 out:
 231     g_free(bitmap);
 232     qapi_free_uint16List(host_nodes);
 233 #else
 234     error_setg(errp, "NUMA node affinity is not supported by this QEMU");
 235 #endif
 236 }
 237
 238 static void thread_context_get_thread_id(Object *obj, Visitor *v,
 239                                          const char *name, void *opaque,
 240                                          Error **errp)
 241 {
 242     ThreadContext *tc = THREAD_CONTEXT(obj);
 243     uint64_t value = tc->thread_id;
 244
 245     visit_type_uint64(v, name, &value, errp);
 246 }
 247
 248 static void thread_context_instance_complete(UserCreatable *uc, Error **errp)
 249 {
 250     ThreadContext *tc = THREAD_CONTEXT(uc);
 251     char *thread_name;
 252     int ret;
 253
 254     thread_name = g_strdup_printf("TC %s",
 255                                object_get_canonical_path_component(OBJECT(uc)));
 256     qemu_thread_create(&tc->thread, thread_name, thread_context_run, tc,
 257                        QEMU_THREAD_JOINABLE);
 258     g_free(thread_name);
 259
 260     /* Wait until initialization of the thread is done. */
 261     while (tc->thread_id == -1) {
 262         qemu_sem_wait(&tc->sem);
 263     }
 264
 265     if (tc->init_cpu_bitmap) {
 266         ret = qemu_thread_set_affinity(&tc->thread, tc->init_cpu_bitmap,
 267                                        tc->init_cpu_nbits);
 268         if (ret) {
 269             error_setg(errp, "Setting CPU affinity failed: %s", strerror(ret));
 270         }
 271         g_free(tc->init_cpu_bitmap);
 272         tc->init_cpu_bitmap = NULL;
 273     }
 274 }
 275
 276 static void thread_context_class_init(ObjectClass *oc, void *data)
 277 {
 278     UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
 279
 280     ucc->complete = thread_context_instance_complete;
 281     object_class_property_add(oc, "thread-id", "int",
 282                               thread_context_get_thread_id, NULL, NULL,
 283                               NULL);
 284     object_class_property_add(oc, "cpu-affinity", "int",
 285                               thread_context_get_cpu_affinity,
 286                               thread_context_set_cpu_affinity, NULL, NULL);
 287     object_class_property_add(oc, "node-affinity", "int", NULL,
 288                               thread_context_set_node_affinity, NULL, NULL);
 289 }
 290
 291 static void thread_context_instance_init(Object *obj)
 292 {
 293     ThreadContext *tc = THREAD_CONTEXT(obj);
 294
 295     tc->thread_id = -1;
 296     qemu_sem_init(&tc->sem, 0);
 297     qemu_sem_init(&tc->sem_thread, 0);
 298     qemu_mutex_init(&tc->mutex);
 299 }
 300
 301 static void thread_context_instance_finalize(Object *obj)
 302 {
 303     ThreadContext *tc = THREAD_CONTEXT(obj);
 304
 305     if (tc->thread_id != -1) {
 306         tc->thread_cmd = TC_CMD_STOP;
 307         qemu_sem_post(&tc->sem_thread);
 308         qemu_thread_join(&tc->thread);
 309     }
 310     qemu_sem_destroy(&tc->sem);
 311     qemu_sem_destroy(&tc->sem_thread);
 312     qemu_mutex_destroy(&tc->mutex);
 313 }
 314
 315 static const TypeInfo thread_context_info = {
 316     .name = TYPE_THREAD_CONTEXT,
 317     .parent = TYPE_OBJECT,
 318     .class_init = thread_context_class_init,
 319     .instance_size = sizeof(ThreadContext),
 320     .instance_init = thread_context_instance_init,
 321     .instance_finalize = thread_context_instance_finalize,
 322     .interfaces = (InterfaceInfo[]) {
 323         { TYPE_USER_CREATABLE },
 324         { }
 325     }
 326 };
 327
 328 static void thread_context_register_types(void)
 329 {
 330     type_register_static(&thread_context_info);
 331 }
 332 type_init(thread_context_register_types)
 333
 334 void thread_context_create_thread(ThreadContext *tc, QemuThread *thread,
 335                                   const char *name,
 336                                   void *(*start_routine)(void *), void *arg,
 337                                   int mode)
 338 {
 339     ThreadContextCmdNew data = {
 340         .thread = thread,
 341         .name = name,
 342         .start_routine = start_routine,
 343         .arg = arg,
 344         .mode = mode,
 345     };
 346
 347     qemu_mutex_lock(&tc->mutex);
 348     tc->thread_cmd = TC_CMD_NEW;
 349     tc->thread_cmd_data = &data;
 350     qemu_sem_post(&tc->sem_thread);
 351
 352     while (tc->thread_cmd != TC_CMD_NONE) {
 353         qemu_sem_wait(&tc->sem);
 354     }
 355     qemu_mutex_unlock(&tc->mutex);
 356 }