1 /* 2 * QEMU Plugin Core code 3 * 4 * This is the core code that deals with injecting instrumentation into the code 5 * 6 * Copyright (C) 2017, Emilio G. Cota <cota@braap.org> 7 * Copyright (C) 2019, Linaro 8 * 9 * License: GNU GPL, version 2 or later. 10 * See the COPYING file in the top-level directory. 11 * 12 * SPDX-License-Identifier: GPL-2.0-or-later 13 */ 14 #include "qemu/osdep.h" 15 #include "qemu/error-report.h" 16 #include "qemu/config-file.h" 17 #include "qapi/error.h" 18 #include "qemu/lockable.h" 19 #include "qemu/option.h" 20 #include "qemu/plugin.h" 21 #include "qemu/queue.h" 22 #include "qemu/rcu_queue.h" 23 #include "qemu/xxhash.h" 24 #include "qemu/rcu.h" 25 #include "hw/core/cpu.h" 26 27 #include "exec/exec-all.h" 28 #include "exec/tb-flush.h" 29 #include "tcg/tcg.h" 30 #include "tcg/tcg-op.h" 31 #include "plugin.h" 32 33 struct qemu_plugin_cb { 34 struct qemu_plugin_ctx *ctx; 35 union qemu_plugin_cb_sig f; 36 void *udata; 37 QLIST_ENTRY(qemu_plugin_cb) entry; 38 }; 39 40 struct qemu_plugin_state plugin; 41 42 struct qemu_plugin_ctx *plugin_id_to_ctx_locked(qemu_plugin_id_t id) 43 { 44 struct qemu_plugin_ctx *ctx; 45 qemu_plugin_id_t *id_p; 46 47 id_p = g_hash_table_lookup(plugin.id_ht, &id); 48 ctx = container_of(id_p, struct qemu_plugin_ctx, id); 49 if (ctx == NULL) { 50 error_report("plugin: invalid plugin id %" PRIu64, id); 51 abort(); 52 } 53 return ctx; 54 } 55 56 static void plugin_cpu_update__async(CPUState *cpu, run_on_cpu_data data) 57 { 58 bitmap_copy(cpu->plugin_state->event_mask, 59 &data.host_ulong, QEMU_PLUGIN_EV_MAX); 60 tcg_flush_jmp_cache(cpu); 61 } 62 63 static void plugin_cpu_update__locked(gpointer k, gpointer v, gpointer udata) 64 { 65 CPUState *cpu = container_of(k, CPUState, cpu_index); 66 run_on_cpu_data mask = RUN_ON_CPU_HOST_ULONG(*plugin.mask); 67 68 if (DEVICE(cpu)->realized) { 69 async_run_on_cpu(cpu, plugin_cpu_update__async, mask); 70 } else { 71 plugin_cpu_update__async(cpu, mask); 72 } 73 } 74 75 void plugin_unregister_cb__locked(struct qemu_plugin_ctx *ctx, 76 enum qemu_plugin_event ev) 77 { 78 struct qemu_plugin_cb *cb = ctx->callbacks[ev]; 79 80 if (cb == NULL) { 81 return; 82 } 83 QLIST_REMOVE_RCU(cb, entry); 84 g_free(cb); 85 ctx->callbacks[ev] = NULL; 86 if (QLIST_EMPTY_RCU(&plugin.cb_lists[ev])) { 87 clear_bit(ev, plugin.mask); 88 g_hash_table_foreach(plugin.cpu_ht, plugin_cpu_update__locked, NULL); 89 } 90 } 91 92 /* 93 * Disable CFI checks. 94 * The callback function has been loaded from an external library so we do not 95 * have type information 96 */ 97 QEMU_DISABLE_CFI 98 static void plugin_vcpu_cb__simple(CPUState *cpu, enum qemu_plugin_event ev) 99 { 100 struct qemu_plugin_cb *cb, *next; 101 102 switch (ev) { 103 case QEMU_PLUGIN_EV_VCPU_INIT: 104 case QEMU_PLUGIN_EV_VCPU_EXIT: 105 case QEMU_PLUGIN_EV_VCPU_IDLE: 106 case QEMU_PLUGIN_EV_VCPU_RESUME: 107 /* iterate safely; plugins might uninstall themselves at any time */ 108 QLIST_FOREACH_SAFE_RCU(cb, &plugin.cb_lists[ev], entry, next) { 109 qemu_plugin_vcpu_simple_cb_t func = cb->f.vcpu_simple; 110 111 func(cb->ctx->id, cpu->cpu_index); 112 } 113 break; 114 default: 115 g_assert_not_reached(); 116 } 117 } 118 119 /* 120 * Disable CFI checks. 121 * The callback function has been loaded from an external library so we do not 122 * have type information 123 */ 124 QEMU_DISABLE_CFI 125 static void plugin_cb__simple(enum qemu_plugin_event ev) 126 { 127 struct qemu_plugin_cb *cb, *next; 128 129 switch (ev) { 130 case QEMU_PLUGIN_EV_FLUSH: 131 QLIST_FOREACH_SAFE_RCU(cb, &plugin.cb_lists[ev], entry, next) { 132 qemu_plugin_simple_cb_t func = cb->f.simple; 133 134 func(cb->ctx->id); 135 } 136 break; 137 default: 138 g_assert_not_reached(); 139 } 140 } 141 142 /* 143 * Disable CFI checks. 144 * The callback function has been loaded from an external library so we do not 145 * have type information 146 */ 147 QEMU_DISABLE_CFI 148 static void plugin_cb__udata(enum qemu_plugin_event ev) 149 { 150 struct qemu_plugin_cb *cb, *next; 151 152 switch (ev) { 153 case QEMU_PLUGIN_EV_ATEXIT: 154 QLIST_FOREACH_SAFE_RCU(cb, &plugin.cb_lists[ev], entry, next) { 155 qemu_plugin_udata_cb_t func = cb->f.udata; 156 157 func(cb->ctx->id, cb->udata); 158 } 159 break; 160 default: 161 g_assert_not_reached(); 162 } 163 } 164 165 static void 166 do_plugin_register_cb(qemu_plugin_id_t id, enum qemu_plugin_event ev, 167 void *func, void *udata) 168 { 169 struct qemu_plugin_ctx *ctx; 170 171 QEMU_LOCK_GUARD(&plugin.lock); 172 ctx = plugin_id_to_ctx_locked(id); 173 /* if the plugin is on its way out, ignore this request */ 174 if (unlikely(ctx->uninstalling)) { 175 return; 176 } 177 if (func) { 178 struct qemu_plugin_cb *cb = ctx->callbacks[ev]; 179 180 if (cb) { 181 cb->f.generic = func; 182 cb->udata = udata; 183 } else { 184 cb = g_new(struct qemu_plugin_cb, 1); 185 cb->ctx = ctx; 186 cb->f.generic = func; 187 cb->udata = udata; 188 ctx->callbacks[ev] = cb; 189 QLIST_INSERT_HEAD_RCU(&plugin.cb_lists[ev], cb, entry); 190 if (!test_bit(ev, plugin.mask)) { 191 set_bit(ev, plugin.mask); 192 g_hash_table_foreach(plugin.cpu_ht, plugin_cpu_update__locked, 193 NULL); 194 } 195 } 196 } else { 197 plugin_unregister_cb__locked(ctx, ev); 198 } 199 } 200 201 void plugin_register_cb(qemu_plugin_id_t id, enum qemu_plugin_event ev, 202 void *func) 203 { 204 do_plugin_register_cb(id, ev, func, NULL); 205 } 206 207 void 208 plugin_register_cb_udata(qemu_plugin_id_t id, enum qemu_plugin_event ev, 209 void *func, void *udata) 210 { 211 do_plugin_register_cb(id, ev, func, udata); 212 } 213 214 CPUPluginState *qemu_plugin_create_vcpu_state(void) 215 { 216 return g_new0(CPUPluginState, 1); 217 } 218 219 static void plugin_grow_scoreboards__locked(CPUState *cpu) 220 { 221 if (cpu->cpu_index < plugin.scoreboard_alloc_size) { 222 return; 223 } 224 225 bool need_realloc = FALSE; 226 while (cpu->cpu_index >= plugin.scoreboard_alloc_size) { 227 plugin.scoreboard_alloc_size *= 2; 228 need_realloc = TRUE; 229 } 230 231 232 if (!need_realloc || QLIST_EMPTY(&plugin.scoreboards)) { 233 /* nothing to do, we just updated sizes for future scoreboards */ 234 return; 235 } 236 237 /* cpus must be stopped, as tb might still use an existing scoreboard. */ 238 start_exclusive(); 239 struct qemu_plugin_scoreboard *score; 240 QLIST_FOREACH(score, &plugin.scoreboards, entry) { 241 g_array_set_size(score->data, plugin.scoreboard_alloc_size); 242 } 243 /* force all tb to be flushed, as scoreboard pointers were changed. */ 244 tb_flush(cpu); 245 end_exclusive(); 246 } 247 248 void qemu_plugin_vcpu_init_hook(CPUState *cpu) 249 { 250 bool success; 251 252 qemu_rec_mutex_lock(&plugin.lock); 253 plugin.num_vcpus = MAX(plugin.num_vcpus, cpu->cpu_index + 1); 254 plugin_cpu_update__locked(&cpu->cpu_index, NULL, NULL); 255 success = g_hash_table_insert(plugin.cpu_ht, &cpu->cpu_index, 256 &cpu->cpu_index); 257 g_assert(success); 258 plugin_grow_scoreboards__locked(cpu); 259 qemu_rec_mutex_unlock(&plugin.lock); 260 261 plugin_vcpu_cb__simple(cpu, QEMU_PLUGIN_EV_VCPU_INIT); 262 } 263 264 void qemu_plugin_vcpu_exit_hook(CPUState *cpu) 265 { 266 bool success; 267 268 plugin_vcpu_cb__simple(cpu, QEMU_PLUGIN_EV_VCPU_EXIT); 269 270 qemu_rec_mutex_lock(&plugin.lock); 271 success = g_hash_table_remove(plugin.cpu_ht, &cpu->cpu_index); 272 g_assert(success); 273 qemu_rec_mutex_unlock(&plugin.lock); 274 } 275 276 struct plugin_for_each_args { 277 struct qemu_plugin_ctx *ctx; 278 qemu_plugin_vcpu_simple_cb_t cb; 279 }; 280 281 static void plugin_vcpu_for_each(gpointer k, gpointer v, gpointer udata) 282 { 283 struct plugin_for_each_args *args = udata; 284 int cpu_index = *(int *)k; 285 286 args->cb(args->ctx->id, cpu_index); 287 } 288 289 void qemu_plugin_vcpu_for_each(qemu_plugin_id_t id, 290 qemu_plugin_vcpu_simple_cb_t cb) 291 { 292 struct plugin_for_each_args args; 293 294 if (cb == NULL) { 295 return; 296 } 297 qemu_rec_mutex_lock(&plugin.lock); 298 args.ctx = plugin_id_to_ctx_locked(id); 299 args.cb = cb; 300 g_hash_table_foreach(plugin.cpu_ht, plugin_vcpu_for_each, &args); 301 qemu_rec_mutex_unlock(&plugin.lock); 302 } 303 304 /* Allocate and return a callback record */ 305 static struct qemu_plugin_dyn_cb *plugin_get_dyn_cb(GArray **arr) 306 { 307 GArray *cbs = *arr; 308 309 if (!cbs) { 310 cbs = g_array_sized_new(false, true, 311 sizeof(struct qemu_plugin_dyn_cb), 1); 312 *arr = cbs; 313 } 314 315 g_array_set_size(cbs, cbs->len + 1); 316 return &g_array_index(cbs, struct qemu_plugin_dyn_cb, cbs->len - 1); 317 } 318 319 void plugin_register_inline_op_on_entry(GArray **arr, 320 enum qemu_plugin_mem_rw rw, 321 enum qemu_plugin_op op, 322 qemu_plugin_u64 entry, 323 uint64_t imm) 324 { 325 struct qemu_plugin_dyn_cb *dyn_cb; 326 327 dyn_cb = plugin_get_dyn_cb(arr); 328 dyn_cb->userp = NULL; 329 dyn_cb->type = PLUGIN_CB_INLINE; 330 dyn_cb->rw = rw; 331 dyn_cb->inline_insn.entry = entry; 332 dyn_cb->inline_insn.op = op; 333 dyn_cb->inline_insn.imm = imm; 334 } 335 336 void plugin_register_dyn_cb__udata(GArray **arr, 337 qemu_plugin_vcpu_udata_cb_t cb, 338 enum qemu_plugin_cb_flags flags, 339 void *udata) 340 { 341 static TCGHelperInfo info[3] = { 342 [QEMU_PLUGIN_CB_NO_REGS].flags = TCG_CALL_NO_RWG | TCG_CALL_PLUGIN, 343 [QEMU_PLUGIN_CB_R_REGS].flags = TCG_CALL_NO_WG | TCG_CALL_PLUGIN, 344 [QEMU_PLUGIN_CB_RW_REGS].flags = TCG_CALL_PLUGIN, 345 /* 346 * Match qemu_plugin_vcpu_udata_cb_t: 347 * void (*)(uint32_t, void *) 348 */ 349 [0 ... 2].typemask = (dh_typemask(void, 0) | 350 dh_typemask(i32, 1) | 351 dh_typemask(ptr, 2)) 352 }; 353 354 struct qemu_plugin_dyn_cb *dyn_cb = plugin_get_dyn_cb(arr); 355 dyn_cb->userp = udata; 356 dyn_cb->type = PLUGIN_CB_REGULAR; 357 dyn_cb->regular.f.vcpu_udata = cb; 358 359 assert((unsigned)flags < ARRAY_SIZE(info)); 360 dyn_cb->regular.info = &info[flags]; 361 } 362 363 void plugin_register_vcpu_mem_cb(GArray **arr, 364 void *cb, 365 enum qemu_plugin_cb_flags flags, 366 enum qemu_plugin_mem_rw rw, 367 void *udata) 368 { 369 /* 370 * Expect that the underlying type for enum qemu_plugin_meminfo_t 371 * is either int32_t or uint32_t, aka int or unsigned int. 372 */ 373 QEMU_BUILD_BUG_ON( 374 !__builtin_types_compatible_p(qemu_plugin_meminfo_t, uint32_t) && 375 !__builtin_types_compatible_p(qemu_plugin_meminfo_t, int32_t)); 376 377 static TCGHelperInfo info[3] = { 378 [QEMU_PLUGIN_CB_NO_REGS].flags = TCG_CALL_NO_RWG | TCG_CALL_PLUGIN, 379 [QEMU_PLUGIN_CB_R_REGS].flags = TCG_CALL_NO_WG | TCG_CALL_PLUGIN, 380 [QEMU_PLUGIN_CB_RW_REGS].flags = TCG_CALL_PLUGIN, 381 /* 382 * Match qemu_plugin_vcpu_mem_cb_t: 383 * void (*)(uint32_t, qemu_plugin_meminfo_t, uint64_t, void *) 384 */ 385 [0 ... 2].typemask = 386 (dh_typemask(void, 0) | 387 dh_typemask(i32, 1) | 388 (__builtin_types_compatible_p(qemu_plugin_meminfo_t, uint32_t) 389 ? dh_typemask(i32, 2) : dh_typemask(s32, 2)) | 390 dh_typemask(i64, 3) | 391 dh_typemask(ptr, 4)) 392 }; 393 394 struct qemu_plugin_dyn_cb *dyn_cb = plugin_get_dyn_cb(arr); 395 dyn_cb->userp = udata; 396 dyn_cb->type = PLUGIN_CB_REGULAR; 397 dyn_cb->rw = rw; 398 dyn_cb->regular.f.vcpu_mem = cb; 399 400 assert((unsigned)flags < ARRAY_SIZE(info)); 401 dyn_cb->regular.info = &info[flags]; 402 } 403 404 /* 405 * Disable CFI checks. 406 * The callback function has been loaded from an external library so we do not 407 * have type information 408 */ 409 QEMU_DISABLE_CFI 410 void qemu_plugin_tb_trans_cb(CPUState *cpu, struct qemu_plugin_tb *tb) 411 { 412 struct qemu_plugin_cb *cb, *next; 413 enum qemu_plugin_event ev = QEMU_PLUGIN_EV_VCPU_TB_TRANS; 414 415 /* no plugin_mask check here; caller should have checked */ 416 417 QLIST_FOREACH_SAFE_RCU(cb, &plugin.cb_lists[ev], entry, next) { 418 qemu_plugin_vcpu_tb_trans_cb_t func = cb->f.vcpu_tb_trans; 419 420 func(cb->ctx->id, tb); 421 } 422 } 423 424 /* 425 * Disable CFI checks. 426 * The callback function has been loaded from an external library so we do not 427 * have type information 428 */ 429 QEMU_DISABLE_CFI 430 void 431 qemu_plugin_vcpu_syscall(CPUState *cpu, int64_t num, uint64_t a1, uint64_t a2, 432 uint64_t a3, uint64_t a4, uint64_t a5, 433 uint64_t a6, uint64_t a7, uint64_t a8) 434 { 435 struct qemu_plugin_cb *cb, *next; 436 enum qemu_plugin_event ev = QEMU_PLUGIN_EV_VCPU_SYSCALL; 437 438 if (!test_bit(ev, cpu->plugin_state->event_mask)) { 439 return; 440 } 441 442 QLIST_FOREACH_SAFE_RCU(cb, &plugin.cb_lists[ev], entry, next) { 443 qemu_plugin_vcpu_syscall_cb_t func = cb->f.vcpu_syscall; 444 445 func(cb->ctx->id, cpu->cpu_index, num, a1, a2, a3, a4, a5, a6, a7, a8); 446 } 447 } 448 449 /* 450 * Disable CFI checks. 451 * The callback function has been loaded from an external library so we do not 452 * have type information 453 */ 454 QEMU_DISABLE_CFI 455 void qemu_plugin_vcpu_syscall_ret(CPUState *cpu, int64_t num, int64_t ret) 456 { 457 struct qemu_plugin_cb *cb, *next; 458 enum qemu_plugin_event ev = QEMU_PLUGIN_EV_VCPU_SYSCALL_RET; 459 460 if (!test_bit(ev, cpu->plugin_state->event_mask)) { 461 return; 462 } 463 464 QLIST_FOREACH_SAFE_RCU(cb, &plugin.cb_lists[ev], entry, next) { 465 qemu_plugin_vcpu_syscall_ret_cb_t func = cb->f.vcpu_syscall_ret; 466 467 func(cb->ctx->id, cpu->cpu_index, num, ret); 468 } 469 } 470 471 void qemu_plugin_vcpu_idle_cb(CPUState *cpu) 472 { 473 /* idle and resume cb may be called before init, ignore in this case */ 474 if (cpu->cpu_index < plugin.num_vcpus) { 475 plugin_vcpu_cb__simple(cpu, QEMU_PLUGIN_EV_VCPU_IDLE); 476 } 477 } 478 479 void qemu_plugin_vcpu_resume_cb(CPUState *cpu) 480 { 481 if (cpu->cpu_index < plugin.num_vcpus) { 482 plugin_vcpu_cb__simple(cpu, QEMU_PLUGIN_EV_VCPU_RESUME); 483 } 484 } 485 486 void qemu_plugin_register_vcpu_idle_cb(qemu_plugin_id_t id, 487 qemu_plugin_vcpu_simple_cb_t cb) 488 { 489 plugin_register_cb(id, QEMU_PLUGIN_EV_VCPU_IDLE, cb); 490 } 491 492 void qemu_plugin_register_vcpu_resume_cb(qemu_plugin_id_t id, 493 qemu_plugin_vcpu_simple_cb_t cb) 494 { 495 plugin_register_cb(id, QEMU_PLUGIN_EV_VCPU_RESUME, cb); 496 } 497 498 void qemu_plugin_register_flush_cb(qemu_plugin_id_t id, 499 qemu_plugin_simple_cb_t cb) 500 { 501 plugin_register_cb(id, QEMU_PLUGIN_EV_FLUSH, cb); 502 } 503 504 static bool free_dyn_cb_arr(void *p, uint32_t h, void *userp) 505 { 506 g_array_free((GArray *) p, true); 507 return true; 508 } 509 510 void qemu_plugin_flush_cb(void) 511 { 512 qht_iter_remove(&plugin.dyn_cb_arr_ht, free_dyn_cb_arr, NULL); 513 qht_reset(&plugin.dyn_cb_arr_ht); 514 515 plugin_cb__simple(QEMU_PLUGIN_EV_FLUSH); 516 } 517 518 void exec_inline_op(struct qemu_plugin_dyn_cb *cb, int cpu_index) 519 { 520 char *ptr = cb->inline_insn.entry.score->data->data; 521 size_t elem_size = g_array_get_element_size( 522 cb->inline_insn.entry.score->data); 523 size_t offset = cb->inline_insn.entry.offset; 524 uint64_t *val = (uint64_t *)(ptr + offset + cpu_index * elem_size); 525 526 switch (cb->inline_insn.op) { 527 case QEMU_PLUGIN_INLINE_ADD_U64: 528 *val += cb->inline_insn.imm; 529 break; 530 default: 531 g_assert_not_reached(); 532 } 533 } 534 535 void qemu_plugin_vcpu_mem_cb(CPUState *cpu, uint64_t vaddr, 536 MemOpIdx oi, enum qemu_plugin_mem_rw rw) 537 { 538 GArray *arr = cpu->plugin_mem_cbs; 539 size_t i; 540 541 if (arr == NULL) { 542 return; 543 } 544 for (i = 0; i < arr->len; i++) { 545 struct qemu_plugin_dyn_cb *cb = 546 &g_array_index(arr, struct qemu_plugin_dyn_cb, i); 547 548 if (!(rw & cb->rw)) { 549 break; 550 } 551 switch (cb->type) { 552 case PLUGIN_CB_REGULAR: 553 cb->regular.f.vcpu_mem(cpu->cpu_index, make_plugin_meminfo(oi, rw), 554 vaddr, cb->userp); 555 break; 556 case PLUGIN_CB_INLINE: 557 exec_inline_op(cb, cpu->cpu_index); 558 break; 559 default: 560 g_assert_not_reached(); 561 } 562 } 563 } 564 565 void qemu_plugin_atexit_cb(void) 566 { 567 plugin_cb__udata(QEMU_PLUGIN_EV_ATEXIT); 568 } 569 570 void qemu_plugin_register_atexit_cb(qemu_plugin_id_t id, 571 qemu_plugin_udata_cb_t cb, 572 void *udata) 573 { 574 plugin_register_cb_udata(id, QEMU_PLUGIN_EV_ATEXIT, cb, udata); 575 } 576 577 /* 578 * Handle exit from linux-user. Unlike the normal atexit() mechanism 579 * we need to handle the clean-up manually as it's possible threads 580 * are still running. We need to remove all callbacks from code 581 * generation, flush the current translations and then we can safely 582 * trigger the exit callbacks. 583 */ 584 585 void qemu_plugin_user_exit(void) 586 { 587 enum qemu_plugin_event ev; 588 CPUState *cpu; 589 590 /* 591 * Locking order: we must acquire locks in an order that is consistent 592 * with the one in fork_start(). That is: 593 * - start_exclusive(), which acquires qemu_cpu_list_lock, 594 * must be called before acquiring plugin.lock. 595 * - tb_flush(), which acquires mmap_lock(), must be called 596 * while plugin.lock is not held. 597 */ 598 start_exclusive(); 599 600 qemu_rec_mutex_lock(&plugin.lock); 601 /* un-register all callbacks except the final AT_EXIT one */ 602 for (ev = 0; ev < QEMU_PLUGIN_EV_MAX; ev++) { 603 if (ev != QEMU_PLUGIN_EV_ATEXIT) { 604 struct qemu_plugin_cb *cb, *next; 605 606 QLIST_FOREACH_SAFE_RCU(cb, &plugin.cb_lists[ev], entry, next) { 607 plugin_unregister_cb__locked(cb->ctx, ev); 608 } 609 } 610 } 611 CPU_FOREACH(cpu) { 612 qemu_plugin_disable_mem_helpers(cpu); 613 } 614 qemu_rec_mutex_unlock(&plugin.lock); 615 616 tb_flush(current_cpu); 617 end_exclusive(); 618 619 /* now it's safe to handle the exit case */ 620 qemu_plugin_atexit_cb(); 621 } 622 623 /* 624 * Helpers for *-user to ensure locks are sane across fork() events. 625 */ 626 627 void qemu_plugin_user_prefork_lock(void) 628 { 629 qemu_rec_mutex_lock(&plugin.lock); 630 } 631 632 void qemu_plugin_user_postfork(bool is_child) 633 { 634 if (is_child) { 635 /* should we just reset via plugin_init? */ 636 qemu_rec_mutex_init(&plugin.lock); 637 } else { 638 qemu_rec_mutex_unlock(&plugin.lock); 639 } 640 } 641 642 static bool plugin_dyn_cb_arr_cmp(const void *ap, const void *bp) 643 { 644 return ap == bp; 645 } 646 647 static void __attribute__((__constructor__)) plugin_init(void) 648 { 649 int i; 650 651 for (i = 0; i < QEMU_PLUGIN_EV_MAX; i++) { 652 QLIST_INIT(&plugin.cb_lists[i]); 653 } 654 qemu_rec_mutex_init(&plugin.lock); 655 plugin.id_ht = g_hash_table_new(g_int64_hash, g_int64_equal); 656 plugin.cpu_ht = g_hash_table_new(g_int_hash, g_int_equal); 657 QLIST_INIT(&plugin.scoreboards); 658 plugin.scoreboard_alloc_size = 16; /* avoid frequent reallocation */ 659 QTAILQ_INIT(&plugin.ctxs); 660 qht_init(&plugin.dyn_cb_arr_ht, plugin_dyn_cb_arr_cmp, 16, 661 QHT_MODE_AUTO_RESIZE); 662 atexit(qemu_plugin_atexit_cb); 663 } 664 665 int plugin_num_vcpus(void) 666 { 667 return plugin.num_vcpus; 668 } 669 670 struct qemu_plugin_scoreboard *plugin_scoreboard_new(size_t element_size) 671 { 672 struct qemu_plugin_scoreboard *score = 673 g_malloc0(sizeof(struct qemu_plugin_scoreboard)); 674 score->data = g_array_new(FALSE, TRUE, element_size); 675 g_array_set_size(score->data, plugin.scoreboard_alloc_size); 676 677 qemu_rec_mutex_lock(&plugin.lock); 678 QLIST_INSERT_HEAD(&plugin.scoreboards, score, entry); 679 qemu_rec_mutex_unlock(&plugin.lock); 680 681 return score; 682 } 683 684 void plugin_scoreboard_free(struct qemu_plugin_scoreboard *score) 685 { 686 qemu_rec_mutex_lock(&plugin.lock); 687 QLIST_REMOVE(score, entry); 688 qemu_rec_mutex_unlock(&plugin.lock); 689 690 g_array_free(score->data, TRUE); 691 g_free(score); 692 } 693