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     Error *err = NULL;
  94
  95     if (tc->init_cpu_bitmap) {
  96         error_setg(errp, "Mixing CPU and node affinity not supported");
  97         return;
  98     }
  99
 100     visit_type_uint16List(v, name, &host_cpus, &err);
 101     if (err) {
 102         error_propagate(errp, err);
 103         return;
 104     }
 105
 106     if (!host_cpus) {
 107         error_setg(errp, "CPU list is empty");
 108         goto out;
 109     }
 110
 111     for (l = host_cpus; l; l = l->next) {
 112         nbits = MAX(nbits, l->value + 1);
 113     }
 114     bitmap = bitmap_new(nbits);
 115     for (l = host_cpus; l; l = l->next) {
 116         set_bit(l->value, bitmap);
 117     }
 118
 119     if (tc->thread_id != -1) {
 120         /*
 121          * Note: we won't be adjusting the affinity of any thread that is still
 122          * around, but only the affinity of the context thread.
 123          */
 124         ret = qemu_thread_set_affinity(&tc->thread, bitmap, nbits);
 125         if (ret) {
 126             error_setg(errp, "Setting CPU affinity failed: %s", strerror(ret));
 127         }
 128     } else {
 129         tc->init_cpu_bitmap = bitmap;
 130         bitmap = NULL;
 131         tc->init_cpu_nbits = nbits;
 132     }
 133 out:
 134     g_free(bitmap);
 135     qapi_free_uint16List(host_cpus);
 136 }
 137
 138 static void thread_context_get_cpu_affinity(Object *obj, Visitor *v,
 139                                             const char *name, void *opaque,
 140                                             Error **errp)
 141 {
 142     unsigned long *bitmap, nbits, value;
 143     ThreadContext *tc = THREAD_CONTEXT(obj);
 144     uint16List *host_cpus = NULL;
 145     uint16List **tail = &host_cpus;
 146     int ret;
 147
 148     if (tc->thread_id == -1) {
 149         error_setg(errp, "Object not initialized yet");
 150         return;
 151     }
 152
 153     ret = qemu_thread_get_affinity(&tc->thread, &bitmap, &nbits);
 154     if (ret) {
 155         error_setg(errp, "Getting CPU affinity failed: %s", strerror(ret));
 156         return;
 157     }
 158
 159     value = find_first_bit(bitmap, nbits);
 160     while (value < nbits) {
 161         QAPI_LIST_APPEND(tail, value);
 162
 163         value = find_next_bit(bitmap, nbits, value + 1);
 164     }
 165     g_free(bitmap);
 166
 167     visit_type_uint16List(v, name, &host_cpus, errp);
 168     qapi_free_uint16List(host_cpus);
 169 }
 170
 171 static void thread_context_set_node_affinity(Object *obj, Visitor *v,
 172                                              const char *name, void *opaque,
 173                                              Error **errp)
 174 {
 175 #ifdef CONFIG_NUMA
 176     const int nbits = numa_num_possible_cpus();
 177     ThreadContext *tc = THREAD_CONTEXT(obj);
 178     uint16List *l, *host_nodes = NULL;
 179     unsigned long *bitmap = NULL;
 180     struct bitmask *tmp_cpus;
 181     Error *err = NULL;
 182     int ret, i;
 183
 184     if (tc->init_cpu_bitmap) {
 185         error_setg(errp, "Mixing CPU and node affinity not supported");
 186         return;
 187     }
 188
 189     visit_type_uint16List(v, name, &host_nodes, &err);
 190     if (err) {
 191         error_propagate(errp, err);
 192         return;
 193     }
 194
 195     if (!host_nodes) {
 196         error_setg(errp, "Node list is empty");
 197         goto out;
 198     }
 199
 200     bitmap = bitmap_new(nbits);
 201     tmp_cpus = numa_allocate_cpumask();
 202     for (l = host_nodes; l; l = l->next) {
 203         numa_bitmask_clearall(tmp_cpus);
 204         ret = numa_node_to_cpus(l->value, tmp_cpus);
 205         if (ret) {
 206             /* We ignore any errors, such as impossible nodes. */
 207             continue;
 208         }
 209         for (i = 0; i < nbits; i++) {
 210             if (numa_bitmask_isbitset(tmp_cpus, i)) {
 211                 set_bit(i, bitmap);
 212             }
 213         }
 214     }
 215     numa_free_cpumask(tmp_cpus);
 216
 217     if (bitmap_empty(bitmap, nbits)) {
 218         error_setg(errp, "The nodes select no CPUs");
 219         goto out;
 220     }
 221
 222     if (tc->thread_id != -1) {
 223         /*
 224          * Note: we won't be adjusting the affinity of any thread that is still
 225          * around for now, but only the affinity of the context thread.
 226          */
 227         ret = qemu_thread_set_affinity(&tc->thread, bitmap, nbits);
 228         if (ret) {
 229             error_setg(errp, "Setting CPU affinity failed: %s", strerror(ret));
 230         }
 231     } else {
 232         tc->init_cpu_bitmap = bitmap;
 233         bitmap = NULL;
 234         tc->init_cpu_nbits = nbits;
 235     }
 236 out:
 237     g_free(bitmap);
 238     qapi_free_uint16List(host_nodes);
 239 #else
 240     error_setg(errp, "NUMA node affinity is not supported by this QEMU");
 241 #endif
 242 }
 243
 244 static void thread_context_get_thread_id(Object *obj, Visitor *v,
 245                                          const char *name, void *opaque,
 246                                          Error **errp)
 247 {
 248     ThreadContext *tc = THREAD_CONTEXT(obj);
 249     uint64_t value = tc->thread_id;
 250
 251     visit_type_uint64(v, name, &value, errp);
 252 }
 253
 254 static void thread_context_instance_complete(UserCreatable *uc, Error **errp)
 255 {
 256     ThreadContext *tc = THREAD_CONTEXT(uc);
 257     char *thread_name;
 258     int ret;
 259
 260     thread_name = g_strdup_printf("TC %s",
 261                                object_get_canonical_path_component(OBJECT(uc)));
 262     qemu_thread_create(&tc->thread, thread_name, thread_context_run, tc,
 263                        QEMU_THREAD_JOINABLE);
 264     g_free(thread_name);
 265
 266     /* Wait until initialization of the thread is done. */
 267     while (tc->thread_id == -1) {
 268         qemu_sem_wait(&tc->sem);
 269     }
 270
 271     if (tc->init_cpu_bitmap) {
 272         ret = qemu_thread_set_affinity(&tc->thread, tc->init_cpu_bitmap,
 273                                        tc->init_cpu_nbits);
 274         if (ret) {
 275             error_setg(errp, "Setting CPU affinity failed: %s", strerror(ret));
 276         }
 277         g_free(tc->init_cpu_bitmap);
 278         tc->init_cpu_bitmap = NULL;
 279     }
 280 }
 281
 282 static void thread_context_class_init(ObjectClass *oc, void *data)
 283 {
 284     UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
 285
 286     ucc->complete = thread_context_instance_complete;
 287     object_class_property_add(oc, "thread-id", "int",
 288                               thread_context_get_thread_id, NULL, NULL,
 289                               NULL);
 290     object_class_property_add(oc, "cpu-affinity", "int",
 291                               thread_context_get_cpu_affinity,
 292                               thread_context_set_cpu_affinity, NULL, NULL);
 293     object_class_property_add(oc, "node-affinity", "int", NULL,
 294                               thread_context_set_node_affinity, NULL, NULL);
 295 }
 296
 297 static void thread_context_instance_init(Object *obj)
 298 {
 299     ThreadContext *tc = THREAD_CONTEXT(obj);
 300
 301     tc->thread_id = -1;
 302     qemu_sem_init(&tc->sem, 0);
 303     qemu_sem_init(&tc->sem_thread, 0);
 304     qemu_mutex_init(&tc->mutex);
 305 }
 306
 307 static void thread_context_instance_finalize(Object *obj)
 308 {
 309     ThreadContext *tc = THREAD_CONTEXT(obj);
 310
 311     if (tc->thread_id != -1) {
 312         tc->thread_cmd = TC_CMD_STOP;
 313         qemu_sem_post(&tc->sem_thread);
 314         qemu_thread_join(&tc->thread);
 315     }
 316     qemu_sem_destroy(&tc->sem);
 317     qemu_sem_destroy(&tc->sem_thread);
 318     qemu_mutex_destroy(&tc->mutex);
 319 }
 320
 321 static const TypeInfo thread_context_info = {
 322     .name = TYPE_THREAD_CONTEXT,
 323     .parent = TYPE_OBJECT,
 324     .class_init = thread_context_class_init,
 325     .instance_size = sizeof(ThreadContext),
 326     .instance_init = thread_context_instance_init,
 327     .instance_finalize = thread_context_instance_finalize,
 328     .interfaces = (InterfaceInfo[]) {
 329         { TYPE_USER_CREATABLE },
 330         { }
 331     }
 332 };
 333
 334 static void thread_context_register_types(void)
 335 {
 336     type_register_static(&thread_context_info);
 337 }
 338 type_init(thread_context_register_types)
 339
 340 void thread_context_create_thread(ThreadContext *tc, QemuThread *thread,
 341                                   const char *name,
 342                                   void *(*start_routine)(void *), void *arg,
 343                                   int mode)
 344 {
 345     ThreadContextCmdNew data = {
 346         .thread = thread,
 347         .name = name,
 348         .start_routine = start_routine,
 349         .arg = arg,
 350         .mode = mode,
 351     };
 352
 353     qemu_mutex_lock(&tc->mutex);
 354     tc->thread_cmd = TC_CMD_NEW;
 355     tc->thread_cmd_data = &data;
 356     qemu_sem_post(&tc->sem_thread);
 357
 358     while (tc->thread_cmd != TC_CMD_NONE) {
 359         qemu_sem_wait(&tc->sem);
 360     }
 361     qemu_mutex_unlock(&tc->mutex);
 362 }