mingw-w64-x86_64-libgcrypt
mingw-w64-x86_64-libpng
mingw-w64-x86_64-libssh
- mingw-w64-x86_64-libxml2
mingw-w64-x86_64-snappy
mingw-w64-x86_64-libusb
mingw-w64-x86_64-usbredir
*.depend_raw
*.swp
*.patch
+*.gcov
TARGETS: x86_64-softmmu ppc64-softmmu riscv64-softmmu x86_64-linux-user
MAKE_CHECK_ARGS: bench V=1
-# These targets are on the way out
-build-deprecated:
- extends: .native_build_job_template
- needs:
- job: amd64-debian-user-cross-container
- variables:
- IMAGE: debian-all-test-cross
- CONFIGURE_ARGS: --disable-tools
- MAKE_CHECK_ARGS: build-tcg
- TARGETS: ppc64abi32-linux-user
- artifacts:
- expire_in: 2 days
- paths:
- - build
-
-# We split the check-tcg step as test failures are expected but we still
-# want to catch the build breaking.
-check-deprecated:
- extends: .native_test_job_template
- needs:
- - job: build-deprecated
- artifacts: true
- variables:
- IMAGE: debian-all-test-cross
- MAKE_CHECK_ARGS: check-tcg
- allow_failure: true
-
# gprof/gcov are GCC features
build-gprof-gcov:
extends: .native_build_job_template
NINJA='/usr/local/bin/ninja'
PACKAGING_COMMAND='pkg'
PIP3='/usr/local/bin/pip-3.8'
-PKGS='alsa-lib bash bzip2 ca_root_nss capstone4 ccache cdrkit-genisoimage ctags curl cyrus-sasl dbus diffutils dtc gettext git glib gmake gnutls gsed gtk3 libepoxy libffi libgcrypt libjpeg-turbo libnfs libspice-server libssh libtasn1 libxml2 llvm lttng-ust lzo2 meson ncurses nettle ninja opencv p5-Test-Harness perl5 pixman pkgconf png py38-numpy py38-pillow py38-pip py38-sphinx py38-sphinx_rtd_theme py38-virtualenv py38-yaml python3 rpm2cpio sdl2 sdl2_image snappy spice-protocol tesseract texinfo usbredir virglrenderer vte3 zstd'
+PKGS='alsa-lib bash bzip2 ca_root_nss capstone4 ccache cdrkit-genisoimage ctags curl cyrus-sasl dbus diffutils dtc fusefs-libs3 gettext git glib gmake gnutls gsed gtk3 libepoxy libffi libgcrypt libjpeg-turbo libnfs libspice-server libssh libtasn1 llvm lzo2 meson ncurses nettle ninja opencv p5-Test-Harness perl5 pixman pkgconf png py38-numpy py38-pillow py38-pip py38-sphinx py38-sphinx_rtd_theme py38-virtualenv py38-yaml python3 rpm2cpio sdl2 sdl2_image snappy spice-protocol tesseract texinfo usbredir virglrenderer vte3 zstd'
PYPI_PKGS=''
PYTHON='/usr/local/bin/python3'
NINJA='/usr/local/bin/ninja'
PACKAGING_COMMAND='pkg'
PIP3='/usr/local/bin/pip-3.8'
-PKGS='alsa-lib bash bzip2 ca_root_nss capstone4 ccache cdrkit-genisoimage ctags curl cyrus-sasl dbus diffutils dtc gettext git glib gmake gnutls gsed gtk3 libepoxy libffi libgcrypt libjpeg-turbo libnfs libspice-server libssh libtasn1 libxml2 llvm lttng-ust lzo2 meson ncurses nettle ninja opencv p5-Test-Harness perl5 pixman pkgconf png py38-numpy py38-pillow py38-pip py38-sphinx py38-sphinx_rtd_theme py38-virtualenv py38-yaml python3 rpm2cpio sdl2 sdl2_image snappy spice-protocol tesseract texinfo usbredir virglrenderer vte3 zstd'
+PKGS='alsa-lib bash bzip2 ca_root_nss capstone4 ccache cdrkit-genisoimage ctags curl cyrus-sasl dbus diffutils dtc fusefs-libs3 gettext git glib gmake gnutls gsed gtk3 libepoxy libffi libgcrypt libjpeg-turbo libnfs libspice-server libssh libtasn1 llvm lzo2 meson ncurses nettle ninja opencv p5-Test-Harness perl5 pixman pkgconf png py38-numpy py38-pillow py38-pip py38-sphinx py38-sphinx_rtd_theme py38-virtualenv py38-yaml python3 rpm2cpio sdl2 sdl2_image snappy spice-protocol tesseract texinfo usbredir virglrenderer vte3 zstd'
PYPI_PKGS=''
PYTHON='/usr/local/bin/python3'
NINJA='/usr/local/bin/ninja'
PACKAGING_COMMAND='brew'
PIP3='/usr/local/bin/pip3'
-PKGS='bash bc bzip2 capstone ccache cpanminus ctags curl dbus diffutils dtc gcovr gettext git glib gnu-sed gnutls gtk+3 jemalloc jpeg-turbo libepoxy libffi libgcrypt libiscsi libnfs libpng libslirp libssh libtasn1 libusb libxml2 llvm lzo make meson ncurses nettle ninja perl pixman pkg-config python3 rpm2cpio sdl2 sdl2_image snappy sparse spice-protocol tesseract texinfo usbredir vde vte3 zlib zstd'
+PKGS='bash bc bzip2 capstone ccache cpanminus ctags curl dbus diffutils dtc gcovr gettext git glib gnu-sed gnutls gtk+3 jemalloc jpeg-turbo libepoxy libffi libgcrypt libiscsi libnfs libpng libslirp libssh libtasn1 libusb llvm lzo make meson ncurses nettle ninja perl pixman pkg-config python3 rpm2cpio sdl2 sdl2_image snappy sparse spice-protocol tesseract texinfo usbredir vde vte3 zlib zstd'
PYPI_PKGS='PyYAML numpy pillow sphinx sphinx-rtd-theme virtualenv'
PYTHON='/usr/local/bin/python3'
- make -j$(expr $(nproc) + 1) all check-build $MAKE_CHECK_ARGS
- if grep -q "EXESUF=.exe" config-host.mak;
then make installer;
- version="$(git describe --match v[0-9]*)";
+ version="$(git describe --match v[0-9]* 2>/dev/null || git rev-parse --short HEAD)";
mv -v qemu-setup*.exe qemu-setup-${version}.exe;
fi
mingw-w64-x86_64-libssh
mingw-w64-x86_64-libtasn1
mingw-w64-x86_64-libusb
- mingw-w64-x86_64-libxml2
mingw-w64-x86_64-nettle
mingw-w64-x86_64-ninja
mingw-w64-x86_64-pixman
mingw-w64-i686-libssh
mingw-w64-i686-libtasn1
mingw-w64-i686-libusb
- mingw-w64-i686-libxml2
mingw-w64-i686-lzo2
mingw-w64-i686-ninja
mingw-w64-i686-pixman
url = https://gitlab.com/qemu-project/vbootrom.git
[submodule "tests/lcitool/libvirt-ci"]
path = tests/lcitool/libvirt-ci
- url = http://gitlab.com/libvirt/libvirt-ci
+ url = https://gitlab.com/libvirt/libvirt-ci.git
F: scripts/ci/
F: tests/docker/
F: tests/vm/
+F: tests/lcitool/
F: scripts/archive-source.sh
W: https://gitlab.com/qemu-project/qemu/pipelines
W: https://travis-ci.org/qemu/qemu
clean: recurse-clean
-$(quiet-@)test -f build.ninja && $(NINJA) $(NINJAFLAGS) -t clean || :
-$(quiet-@)test -f build.ninja && $(NINJA) $(NINJAFLAGS) clean-ctlist || :
- find . \( -name '*.so' -o -name '*.dll' -o -name '*.[oda]' \) -type f \
+ find . \( -name '*.so' -o -name '*.dll' -o \
+ -name '*.[oda]' -o -name '*.gcno' \) -type f \
! -path ./roms/edk2/ArmPkg/Library/GccLto/liblto-aarch64.a \
! -path ./roms/edk2/ArmPkg/Library/GccLto/liblto-arm.a \
-exec rm {} +
* See the COPYING file in the top-level directory.
*/
-static void atomic_trace_rmw_pre(CPUArchState *env, target_ulong addr,
- MemOpIdx oi)
-{
- CPUState *cpu = env_cpu(env);
-
- trace_guest_rmw_before_exec(cpu, addr, oi);
-}
-
static void atomic_trace_rmw_post(CPUArchState *env, target_ulong addr,
MemOpIdx oi)
{
}
#if HAVE_ATOMIC128
-static void atomic_trace_ld_pre(CPUArchState *env, target_ulong addr,
- MemOpIdx oi)
-{
- trace_guest_ld_before_exec(env_cpu(env), addr, oi);
-}
-
static void atomic_trace_ld_post(CPUArchState *env, target_ulong addr,
MemOpIdx oi)
{
qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, oi, QEMU_PLUGIN_MEM_R);
}
-static void atomic_trace_st_pre(CPUArchState *env, target_ulong addr,
- MemOpIdx oi)
-{
- trace_guest_st_before_exec(env_cpu(env), addr, oi);
-}
-
static void atomic_trace_st_post(CPUArchState *env, target_ulong addr,
MemOpIdx oi)
{
PAGE_READ | PAGE_WRITE, retaddr);
DATA_TYPE ret;
- atomic_trace_rmw_pre(env, addr, oi);
#if DATA_SIZE == 16
ret = atomic16_cmpxchg(haddr, cmpv, newv);
#else
PAGE_READ, retaddr);
DATA_TYPE val;
- atomic_trace_ld_pre(env, addr, oi);
val = atomic16_read(haddr);
ATOMIC_MMU_CLEANUP;
atomic_trace_ld_post(env, addr, oi);
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE,
PAGE_WRITE, retaddr);
- atomic_trace_st_pre(env, addr, oi);
atomic16_set(haddr, val);
ATOMIC_MMU_CLEANUP;
atomic_trace_st_post(env, addr, oi);
PAGE_READ | PAGE_WRITE, retaddr);
DATA_TYPE ret;
- atomic_trace_rmw_pre(env, addr, oi);
ret = qatomic_xchg__nocheck(haddr, val);
ATOMIC_MMU_CLEANUP;
atomic_trace_rmw_post(env, addr, oi);
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE, \
PAGE_READ | PAGE_WRITE, retaddr); \
DATA_TYPE ret; \
- atomic_trace_rmw_pre(env, addr, oi); \
ret = qatomic_##X(haddr, val); \
ATOMIC_MMU_CLEANUP; \
atomic_trace_rmw_post(env, addr, oi); \
XDATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE, \
PAGE_READ | PAGE_WRITE, retaddr); \
XDATA_TYPE cmp, old, new, val = xval; \
- atomic_trace_rmw_pre(env, addr, oi); \
smp_mb(); \
cmp = qatomic_read__nocheck(haddr); \
do { \
PAGE_READ | PAGE_WRITE, retaddr);
DATA_TYPE ret;
- atomic_trace_rmw_pre(env, addr, oi);
#if DATA_SIZE == 16
ret = atomic16_cmpxchg(haddr, BSWAP(cmpv), BSWAP(newv));
#else
PAGE_READ, retaddr);
DATA_TYPE val;
- atomic_trace_ld_pre(env, addr, oi);
val = atomic16_read(haddr);
ATOMIC_MMU_CLEANUP;
atomic_trace_ld_post(env, addr, oi);
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE,
PAGE_WRITE, retaddr);
- atomic_trace_st_pre(env, addr, oi);
val = BSWAP(val);
atomic16_set(haddr, val);
ATOMIC_MMU_CLEANUP;
PAGE_READ | PAGE_WRITE, retaddr);
ABI_TYPE ret;
- atomic_trace_rmw_pre(env, addr, oi);
ret = qatomic_xchg__nocheck(haddr, BSWAP(val));
ATOMIC_MMU_CLEANUP;
atomic_trace_rmw_post(env, addr, oi);
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE, \
PAGE_READ | PAGE_WRITE, retaddr); \
DATA_TYPE ret; \
- atomic_trace_rmw_pre(env, addr, oi); \
ret = qatomic_##X(haddr, BSWAP(val)); \
ATOMIC_MMU_CLEANUP; \
atomic_trace_rmw_post(env, addr, oi); \
XDATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE, \
PAGE_READ | PAGE_WRITE, retaddr); \
XDATA_TYPE ldo, ldn, old, new, val = xval; \
- atomic_trace_rmw_pre(env, addr, oi); \
smp_mb(); \
ldn = qatomic_read__nocheck(haddr); \
do { \
{
uint64_t ret;
- trace_guest_ld_before_exec(env_cpu(env), addr, oi);
ret = full_load(env, addr, oi, retaddr);
qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, oi, QEMU_PLUGIN_MEM_R);
return ret;
uint64_t val, MemOpIdx oi, uintptr_t ra,
FullStoreHelper *full_store)
{
- trace_guest_st_before_exec(env_cpu(env), addr, oi);
full_store(env, addr, val, oi, ra);
qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, oi, QEMU_PLUGIN_MEM_W);
}
bool plugin_gen_tb_start(CPUState *cpu, const TranslationBlock *tb, bool mem_only)
{
- struct qemu_plugin_tb *ptb = tcg_ctx->plugin_tb;
bool ret = false;
if (test_bit(QEMU_PLUGIN_EV_VCPU_TB_TRANS, cpu->plugin_mask)) {
+ struct qemu_plugin_tb *ptb = tcg_ctx->plugin_tb;
+ int i;
+
+ /* reset callbacks */
+ for (i = 0; i < PLUGIN_N_CB_SUBTYPES; i++) {
+ if (ptb->cbs[i]) {
+ g_array_set_size(ptb->cbs[i], 0);
+ }
+ }
+ ptb->n = 0;
+
ret = true;
ptb->vaddr = tb->pc;
plugin_gen_empty_callback(PLUGIN_GEN_FROM_TB);
}
+
+ tcg_ctx->plugin_insn = NULL;
+
return ret;
}
plugin_gen_empty_callback(PLUGIN_GEN_AFTER_INSN);
}
+/*
+ * There are cases where we never get to finalise a translation - for
+ * example a page fault during translation. As a result we shouldn't
+ * do any clean-up here and make sure things are reset in
+ * plugin_gen_tb_start.
+ */
void plugin_gen_tb_end(CPUState *cpu)
{
struct qemu_plugin_tb *ptb = tcg_ctx->plugin_tb;
- int i;
/* collect instrumentation requests */
qemu_plugin_tb_trans_cb(cpu, ptb);
/* inject the instrumentation at the appropriate places */
plugin_gen_inject(ptb);
-
- /* clean up */
- for (i = 0; i < PLUGIN_N_CB_SUBTYPES; i++) {
- if (ptb->cbs[i]) {
- g_array_set_size(ptb->cbs[i], 0);
- }
- }
- ptb->n = 0;
- tcg_ctx->plugin_insn = NULL;
}
uint8_t ret;
validate_memop(oi, MO_UB);
- trace_guest_ld_before_exec(env_cpu(env), addr, oi);
haddr = cpu_mmu_lookup(env, addr, oi, ra, MMU_DATA_LOAD);
ret = ldub_p(haddr);
clear_helper_retaddr();
uint16_t ret;
validate_memop(oi, MO_BEUW);
- trace_guest_ld_before_exec(env_cpu(env), addr, oi);
haddr = cpu_mmu_lookup(env, addr, oi, ra, MMU_DATA_LOAD);
ret = lduw_be_p(haddr);
clear_helper_retaddr();
uint32_t ret;
validate_memop(oi, MO_BEUL);
- trace_guest_ld_before_exec(env_cpu(env), addr, oi);
haddr = cpu_mmu_lookup(env, addr, oi, ra, MMU_DATA_LOAD);
ret = ldl_be_p(haddr);
clear_helper_retaddr();
uint64_t ret;
validate_memop(oi, MO_BEUQ);
- trace_guest_ld_before_exec(env_cpu(env), addr, oi);
haddr = cpu_mmu_lookup(env, addr, oi, ra, MMU_DATA_LOAD);
ret = ldq_be_p(haddr);
clear_helper_retaddr();
uint16_t ret;
validate_memop(oi, MO_LEUW);
- trace_guest_ld_before_exec(env_cpu(env), addr, oi);
haddr = cpu_mmu_lookup(env, addr, oi, ra, MMU_DATA_LOAD);
ret = lduw_le_p(haddr);
clear_helper_retaddr();
uint32_t ret;
validate_memop(oi, MO_LEUL);
- trace_guest_ld_before_exec(env_cpu(env), addr, oi);
haddr = cpu_mmu_lookup(env, addr, oi, ra, MMU_DATA_LOAD);
ret = ldl_le_p(haddr);
clear_helper_retaddr();
uint64_t ret;
validate_memop(oi, MO_LEUQ);
- trace_guest_ld_before_exec(env_cpu(env), addr, oi);
haddr = cpu_mmu_lookup(env, addr, oi, ra, MMU_DATA_LOAD);
ret = ldq_le_p(haddr);
clear_helper_retaddr();
void *haddr;
validate_memop(oi, MO_UB);
- trace_guest_st_before_exec(env_cpu(env), addr, oi);
haddr = cpu_mmu_lookup(env, addr, oi, ra, MMU_DATA_STORE);
stb_p(haddr, val);
clear_helper_retaddr();
void *haddr;
validate_memop(oi, MO_BEUW);
- trace_guest_st_before_exec(env_cpu(env), addr, oi);
haddr = cpu_mmu_lookup(env, addr, oi, ra, MMU_DATA_STORE);
stw_be_p(haddr, val);
clear_helper_retaddr();
void *haddr;
validate_memop(oi, MO_BEUL);
- trace_guest_st_before_exec(env_cpu(env), addr, oi);
haddr = cpu_mmu_lookup(env, addr, oi, ra, MMU_DATA_STORE);
stl_be_p(haddr, val);
clear_helper_retaddr();
void *haddr;
validate_memop(oi, MO_BEUQ);
- trace_guest_st_before_exec(env_cpu(env), addr, oi);
haddr = cpu_mmu_lookup(env, addr, oi, ra, MMU_DATA_STORE);
stq_be_p(haddr, val);
clear_helper_retaddr();
void *haddr;
validate_memop(oi, MO_LEUW);
- trace_guest_st_before_exec(env_cpu(env), addr, oi);
haddr = cpu_mmu_lookup(env, addr, oi, ra, MMU_DATA_STORE);
stw_le_p(haddr, val);
clear_helper_retaddr();
void *haddr;
validate_memop(oi, MO_LEUL);
- trace_guest_st_before_exec(env_cpu(env), addr, oi);
haddr = cpu_mmu_lookup(env, addr, oi, ra, MMU_DATA_STORE);
stl_le_p(haddr, val);
clear_helper_retaddr();
void *haddr;
validate_memop(oi, MO_LEUQ);
- trace_guest_st_before_exec(env_cpu(env), addr, oi);
haddr = cpu_mmu_lookup(env, addr, oi, ra, MMU_DATA_STORE);
stq_le_p(haddr, val);
clear_helper_retaddr();
'qed-table.c',
'qed.c',
))
-block_ss.add(when: [libxml2, 'CONFIG_PARALLELS'],
- if_true: files('parallels.c', 'parallels-ext.c'))
+block_ss.add(when: 'CONFIG_PARALLELS', if_true: files('parallels.c', 'parallels-ext.c'))
block_ss.add(when: 'CONFIG_WIN32', if_true: files('file-win32.c', 'win32-aio.c'))
block_ss.add(when: 'CONFIG_POSIX', if_true: [files('file-posix.c'), coref, iokit])
block_ss.add(when: libiscsi, if_true: files('iscsi-opts.c'))
+++ /dev/null
-TARGET_ARCH=ppc64
-TARGET_ABI32=y
-TARGET_BASE_ARCH=ppc
-TARGET_ABI_DIR=ppc
-TARGET_SYSTBL_ABI=common,nospu,32
-TARGET_SYSTBL=syscall.tbl
-TARGET_WORDS_BIGENDIAN=y
-TARGET_XML_FILES= gdb-xml/power64-core.xml gdb-xml/power-fpu.xml gdb-xml/power-altivec.xml gdb-xml/power-spe.xml gdb-xml/power-vsx.xml
fi
default_target_list=""
-deprecated_targets_list=ppc64abi32-linux-user
-deprecated_features=""
mak_wilds=""
if [ "$linux_user" != no ]; then
mak_wilds="${mak_wilds} $source_path/configs/targets/*-bsd-user.mak"
fi
-# If the user doesn't explicitly specify a deprecated target we will
-# skip it.
-if test -z "$target_list"; then
- if test -z "$target_list_exclude"; then
- target_list_exclude="$deprecated_targets_list"
- else
- target_list_exclude="$target_list_exclude,$deprecated_targets_list"
- fi
-fi
-
for config in $mak_wilds; do
target="$(basename "$config" .mak)"
if echo "$target_list_exclude" | grep -vq "$target"; then
--prefix=PREFIX install in PREFIX [$prefix]
--interp-prefix=PREFIX where to find shared libraries, etc.
use %M for cpu name [$interp_prefix]
- --target-list=LIST set target list (default: build all non-deprecated)
+ --target-list=LIST set target list (default: build all)
$(echo Available targets: $default_target_list | \
fold -s -w 53 | sed -e 's/^/ /')
-$(echo Deprecated targets: $deprecated_targets_list | \
- fold -s -w 53 | sed -e 's/^/ /')
--target-list-exclude=LIST exclude a set of targets from the default target-list
Advanced options (experts only):
done
fi
-for target in $target_list; do
- # if a deprecated target is enabled we note it here
- if echo "$deprecated_targets_list" | grep -q "$target"; then
- add_to deprecated_features $target
- fi
-done
-
# see if system emulation was really requested
case " $target_list " in
*"-softmmu "*) softmmu=yes
fi
fi
-if test -n "${deprecated_features}"; then
- echo "Warning, deprecated features enabled."
- echo "Please see docs/about/deprecated.rst"
- echo " features: ${deprecated_features}"
-fi
-
# Save the configure command line for later reuse.
cat <<EOD >config.status
#!/bin/sh
NAMES += lockstep
NAMES += hwprofile
NAMES += cache
+NAMES += drcov
SONAMES := $(addsuffix .so,$(addprefix lib,$(NAMES)))
--- /dev/null
+/*
+ * Copyright (C) 2021, Ivanov Arkady <arkadiy.ivanov@ispras.ru>
+ *
+ * Drcov - a DynamoRIO-based tool that collects coverage information
+ * from a binary. Primary goal this script is to have coverage log
+ * files that work in Lighthouse.
+ *
+ * License: GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ */
+
+#include <inttypes.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <glib.h>
+
+#include <qemu-plugin.h>
+
+QEMU_PLUGIN_EXPORT int qemu_plugin_version = QEMU_PLUGIN_VERSION;
+
+static char header[] = "DRCOV VERSION: 2\n"
+ "DRCOV FLAVOR: drcov-64\n"
+ "Module Table: version 2, count 1\n"
+ "Columns: id, base, end, entry, path\n";
+
+static FILE *fp;
+static const char *file_name = "file.drcov.trace";
+static GMutex lock;
+
+typedef struct {
+ uint32_t start;
+ uint16_t size;
+ uint16_t mod_id;
+ bool exec;
+} bb_entry_t;
+
+/* Translated blocks */
+static GPtrArray *blocks;
+
+static void printf_header(unsigned long count)
+{
+ fprintf(fp, "%s", header);
+ const char *path = qemu_plugin_path_to_binary();
+ uint64_t start_code = qemu_plugin_start_code();
+ uint64_t end_code = qemu_plugin_end_code();
+ uint64_t entry = qemu_plugin_entry_code();
+ fprintf(fp, "0, 0x%lx, 0x%lx, 0x%lx, %s\n",
+ start_code, end_code, entry, path);
+ fprintf(fp, "BB Table: %ld bbs\n", count);
+}
+
+static void printf_char_array32(uint32_t data)
+{
+ const uint8_t *bytes = (const uint8_t *)(&data);
+ fwrite(bytes, sizeof(char), sizeof(data), fp);
+}
+
+static void printf_char_array16(uint16_t data)
+{
+ const uint8_t *bytes = (const uint8_t *)(&data);
+ fwrite(bytes, sizeof(char), sizeof(data), fp);
+}
+
+
+static void printf_el(gpointer data, gpointer user_data)
+{
+ bb_entry_t *bb = (bb_entry_t *)data;
+ if (bb->exec) {
+ printf_char_array32(bb->start);
+ printf_char_array16(bb->size);
+ printf_char_array16(bb->mod_id);
+ }
+ g_free(bb);
+}
+
+static void count_block(gpointer data, gpointer user_data)
+{
+ unsigned long *count = (unsigned long *) user_data;
+ bb_entry_t *bb = (bb_entry_t *)data;
+ if (bb->exec) {
+ *count = *count + 1;
+ }
+}
+
+static void plugin_exit(qemu_plugin_id_t id, void *p)
+{
+ unsigned long count = 0;
+ g_mutex_lock(&lock);
+ g_ptr_array_foreach(blocks, count_block, &count);
+
+ /* Print function */
+ printf_header(count);
+ g_ptr_array_foreach(blocks, printf_el, NULL);
+
+ /* Clear */
+ g_ptr_array_free(blocks, true);
+
+ fclose(fp);
+
+ g_mutex_unlock(&lock);
+}
+
+static void plugin_init(void)
+{
+ fp = fopen(file_name, "wb");
+ blocks = g_ptr_array_sized_new(128);
+}
+
+static void vcpu_tb_exec(unsigned int cpu_index, void *udata)
+{
+ bb_entry_t *bb = (bb_entry_t *) udata;
+
+ g_mutex_lock(&lock);
+ bb->exec = true;
+ g_mutex_unlock(&lock);
+}
+
+static void vcpu_tb_trans(qemu_plugin_id_t id, struct qemu_plugin_tb *tb)
+{
+ uint64_t pc = qemu_plugin_tb_vaddr(tb);
+ size_t n = qemu_plugin_tb_n_insns(tb);
+
+ g_mutex_lock(&lock);
+
+ bb_entry_t *bb = g_new0(bb_entry_t, 1);
+ for (int i = 0; i < n; i++) {
+ bb->size += qemu_plugin_insn_size(qemu_plugin_tb_get_insn(tb, i));
+ }
+
+ bb->start = pc;
+ bb->mod_id = 0;
+ bb->exec = false;
+ g_ptr_array_add(blocks, bb);
+
+ g_mutex_unlock(&lock);
+ qemu_plugin_register_vcpu_tb_exec_cb(tb, vcpu_tb_exec,
+ QEMU_PLUGIN_CB_NO_REGS,
+ (void *)bb);
+
+}
+
+QEMU_PLUGIN_EXPORT
+int qemu_plugin_install(qemu_plugin_id_t id, const qemu_info_t *info,
+ int argc, char **argv)
+{
+ for (int i = 0; i < argc; i++) {
+ g_autofree char **tokens = g_strsplit(argv[i], "=", 2);
+ if (g_strcmp0(tokens[0], "filename") == 0) {
+ file_name = g_strdup(tokens[1]);
+ }
+ }
+
+ plugin_init();
+
+ qemu_plugin_register_vcpu_tb_trans_cb(id, vcpu_tb_trans);
+ qemu_plugin_register_atexit_cb(id, plugin_exit, NULL);
+
+ return 0;
+}
linux-user mode CPUs
--------------------
-``ppc64abi32`` CPUs (since 5.2)
-'''''''''''''''''''''''''''''''
-
-The ``ppc64abi32`` architecture has a number of issues which regularly
-trip up our CI testing and is suspected to be quite broken. For that
-reason the maintainers strongly suspect no one actually uses it.
-
MIPS ``I7200`` CPU (since 5.2)
''''''''''''''''''''''''''''''
there is no new Linux development taking place with this architecture. For
running the old binaries, you can use older versions of QEMU.
+``ppc64abi32`` CPUs (removed in 7.0)
+''''''''''''''''''''''''''''''''''''
+
+The ``ppc64abi32`` architecture has a number of issues which regularly
+tripped up the CI testing and was suspected to be quite broken. For that
+reason the maintainers strongly suspected no one actually used it.
+
+
+TCG introspection features
+--------------------------
+
+TCG trace-events (since 6.2)
+''''''''''''''''''''''''''''
+
+The ability to add new TCG trace points had bit rotted and as the
+feature can be replicated with TCG plugins it was removed. If
+any user is currently using this feature and needs help with
+converting to using TCG plugins they should contact the qemu-devel
+mailing list.
+
+
System emulator devices
-----------------------
Formatting and style
********************
+The repository includes a ``.editorconfig`` file which can help with
+getting the right settings for your preferred $EDITOR. See
+`<https://editorconfig.org/>`_ for details.
+
Whitespace
==========
return ptr;
}
-"tcg"
------
-
-Guest code generated by TCG can be traced by defining an event with the "tcg"
-event property. Internally, this property generates two events:
-"<eventname>_trans" to trace the event at translation time, and
-"<eventname>_exec" to trace the event at execution time.
-
-Instead of using these two events, you should instead use the function
-"trace_<eventname>_tcg" during translation (TCG code generation). This function
-will automatically call "trace_<eventname>_trans", and will generate the
-necessary TCG code to call "trace_<eventname>_exec" during guest code execution.
-
-Events with the "tcg" property can be declared in the "trace-events" file with a
-mix of native and TCG types, and "trace_<eventname>_tcg" will gracefully forward
-them to the "<eventname>_trans" and "<eventname>_exec" events. Since TCG values
-are not known at translation time, these are ignored by the "<eventname>_trans"
-event. Because of this, the entry in the "trace-events" file needs two printing
-formats (separated by a comma)::
-
- tcg foo(uint8_t a1, TCGv_i32 a2) "a1=%d", "a1=%d a2=%d"
-
-For example::
-
- #include "trace-tcg.h"
-
- void some_disassembly_func (...)
- {
- uint8_t a1 = ...;
- TCGv_i32 a2 = ...;
- trace_foo_tcg(a1, a2);
- }
-
-This will immediately call::
-
- void trace_foo_trans(uint8_t a1);
-
-and will generate the TCG code to call::
-
- void trace_foo(uint8_t a1, uint32_t a2);
-
-"vcpu"
-------
-
-Identifies events that trace vCPU-specific information. It implicitly adds a
-"CPUState*" argument, and extends the tracing print format to show the vCPU
-information. If used together with the "tcg" property, it adds a second
-"TCGv_env" argument that must point to the per-target global TCG register that
-points to the vCPU when guest code is executed (usually the "cpu_env" variable).
-
-The "tcg" and "vcpu" properties are currently only honored in the root
-./trace-events file.
-
-The following example events::
-
- foo(uint32_t a) "a=%x"
- vcpu bar(uint32_t a) "a=%x"
- tcg vcpu baz(uint32_t a) "a=%x", "a=%x"
-
-Can be used as::
-
- #include "trace-tcg.h"
-
- CPUArchState *env;
- TCGv_ptr cpu_env;
-
- void some_disassembly_func(...)
- {
- /* trace emitted at this point */
- trace_foo(0xd1);
- /* trace emitted at this point */
- trace_bar(env_cpu(env), 0xd2);
- /* trace emitted at this point (env) and when guest code is executed (cpu_env) */
- trace_baz_tcg(env_cpu(env), cpu_env, 0xd3);
- }
-
-If the translating vCPU has address 0xc1 and code is later executed by vCPU
-0xc2, this would be an example output::
-
- // at guest code translation
- foo a=0xd1
- bar cpu=0xc1 a=0xd2
- baz_trans cpu=0xc1 a=0xd3
- // at guest code execution
- baz_exec cpu=0xc2 a=0xd3
- user mode (PowerPC)
- * ``qemu-ppc64abi32`` TODO.
* ``qemu-ppc64`` TODO.
* ``qemu-ppc`` TODO.
})
#else
typedef target_ulong abi_ptr;
-#define TARGET_ABI_FMT_ptr TARGET_ABI_FMT_lx
+#define TARGET_ABI_FMT_ptr TARGET_FMT_lx
#endif
uint32_t cpu_ldub_data(CPUArchState *env, abi_ptr ptr);
}
#include "helper.h"
-#include "trace/generated-helpers.h"
-#include "trace/generated-helpers-wrappers.h"
#include "accel/tcg/tcg-runtime.h"
#include "accel/tcg/plugin-helpers.h"
#define IN_HELPER_PROTO
#include "helper.h"
-#include "trace/generated-helpers.h"
#include "accel/tcg/tcg-runtime.h"
#include "accel/tcg/plugin-helpers.h"
| dh_typemask(t5, 5) | dh_typemask(t6, 6) | dh_typemask(t7, 7) },
#include "helper.h"
-#include "trace/generated-helpers.h"
#include "accel/tcg/tcg-runtime.h"
#include "accel/tcg/plugin-helpers.h"
*/
bool qemu_plugin_bool_parse(const char *name, const char *val, bool *ret);
+/**
+ * qemu_plugin_path_to_binary() - path to binary file being executed
+ *
+ * Return a string representing the path to the binary. For user-mode
+ * this is the main executable. For system emulation we currently
+ * return NULL. The user should g_free() the string once no longer
+ * needed.
+ */
+const char *qemu_plugin_path_to_binary(void);
+
+/**
+ * qemu_plugin_start_code() - returns start of text segment
+ *
+ * Returns the nominal start address of the main text segment in
+ * user-mode. Currently returns 0 for system emulation.
+ */
+uint64_t qemu_plugin_start_code(void);
+
+/**
+ * qemu_plugin_end_code() - returns end of text segment
+ *
+ * Returns the nominal end address of the main text segment in
+ * user-mode. Currently returns 0 for system emulation.
+ */
+uint64_t qemu_plugin_end_code(void);
+
+/**
+ * qemu_plugin_entry_code() - returns start address for module
+ *
+ * Returns the nominal entry address of the main text segment in
+ * user-mode. Currently returns 0 for system emulation.
+ */
+uint64_t qemu_plugin_entry_code(void);
+
#endif /* QEMU_PLUGIN_API_H */
+++ /dev/null
-#ifndef TRACE_TCG_H
-#define TRACE_TCG_H
-
-#include "trace/generated-tcg-tracers.h"
-
-#endif /* TRACE_TCG_H */
#define ELF_MACHINE PPC_ELF_MACHINE
#define ELF_START_MMAP 0x80000000
-#if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
+#if defined(TARGET_PPC64)
#define elf_check_arch(x) ( (x) == EM_PPC64 )
static inline void init_thread(struct target_pt_regs *_regs, struct image_info *infop)
{
_regs->gpr[1] = infop->start_stack;
-#if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
+#if defined(TARGET_PPC64)
if (get_ppc64_abi(infop) < 2) {
uint64_t val;
get_user_u64(val, infop->entry + 8);
int i, err = 0;
#if defined(TARGET_PPC64)
struct target_sigcontext *sc = 0;
-#if !defined(TARGET_ABI32)
struct image_info *image = ((TaskState *)thread_cpu->opaque)->info;
-#endif
#endif
rt_sf_addr = get_sigframe(ka, env, sizeof(*rt_sf));
env->gpr[5] = (target_ulong) h2g(&rt_sf->uc);
env->gpr[6] = (target_ulong) h2g(rt_sf);
-#if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
+#if defined(TARGET_PPC64)
if (get_ppc64_abi(image) < 2) {
/* ELFv1 PPC64 function pointers are pointers to OPD entries. */
struct target_func_ptr *handler =
}
-#if !defined(TARGET_PPC64) || defined(TARGET_ABI32)
+#if !defined(TARGET_PPC64)
long do_sigreturn(CPUPPCState *env)
{
struct target_sigcontext *sc = NULL;
if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1))
goto sigsegv;
-#if defined(TARGET_PPC64)
- set.sig[0] = sc->oldmask + ((uint64_t)(sc->_unused[3]) << 32);
-#else
__get_user(set.sig[0], &sc->oldmask);
__get_user(set.sig[1], &sc->_unused[3]);
-#endif
+
target_to_host_sigset_internal(&blocked, &set);
set_sigmask(&blocked);
abi_ulong link;
abi_ulong xer;
abi_ulong ccr;
-#if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
+#if defined(TARGET_PPC64)
abi_ulong softe;
#else
abi_ulong mq; /* 601 only (not used at present) */
* flags masks
*/
-#if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
+#if defined(TARGET_PPC64)
#ifdef TARGET_WORDS_BIGENDIAN
#define UNAME_MACHINE "ppc64"
#else
struct target_stat {
abi_ulong st_dev;
abi_ulong st_ino;
-#if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
+#if defined(TARGET_PPC64)
abi_ulong st_nlink;
unsigned int st_mode;
#else
abi_ulong target_st_ctime_nsec;
abi_ulong __unused4;
abi_ulong __unused5;
-#if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
+#if defined(TARGET_PPC64)
abi_ulong __unused6;
#endif
};
-#if !defined(TARGET_PPC64) || defined(TARGET_ABI32)
+#if !defined(TARGET_PPC64)
#define TARGET_HAS_STRUCT_STAT64
struct QEMU_PACKED target_stat64 {
unsigned long long st_dev;
required: get_option('linux_io_uring'),
method: 'pkg-config', kwargs: static_kwargs)
endif
-libxml2 = not_found
-if not get_option('libxml2').auto() or have_block
- libxml2 = dependency('libxml-2.0', required: get_option('libxml2'),
- method: 'pkg-config', kwargs: static_kwargs)
-endif
libnfs = not_found
if not get_option('libnfs').auto() or have_block
libnfs = dependency('libnfs', version: '>=1.9.3',
'scripts/tracetool/backend/simple.py',
'scripts/tracetool/backend/syslog.py',
'scripts/tracetool/backend/ust.py',
- 'scripts/tracetool/format/tcg_h.py',
'scripts/tracetool/format/ust_events_c.py',
'scripts/tracetool/format/ust_events_h.py',
'scripts/tracetool/format/__init__.py',
'scripts/tracetool/format/d.py',
- 'scripts/tracetool/format/tcg_helper_c.py',
'scripts/tracetool/format/simpletrace_stap.py',
'scripts/tracetool/format/c.py',
'scripts/tracetool/format/h.py',
- 'scripts/tracetool/format/tcg_helper_h.py',
'scripts/tracetool/format/log_stap.py',
'scripts/tracetool/format/stap.py',
- 'scripts/tracetool/format/tcg_helper_wrapper_h.py',
'scripts/tracetool/__init__.py',
'scripts/tracetool/transform.py',
'scripts/tracetool/vcpu.py'
summary_info += {'lzfse support': liblzfse}
summary_info += {'zstd support': zstd}
summary_info += {'NUMA host support': config_host.has_key('CONFIG_NUMA')}
-summary_info += {'libxml2': libxml2}
summary_info += {'capstone': capstone_opt == 'internal' ? capstone_opt : capstone}
summary_info += {'libpmem support': libpmem}
summary_info += {'libdaxctl support': libdaxctl}
description: 'Use libudev to enumerate host devices')
option('libusb', type : 'feature', value : 'auto',
description: 'libusb support for USB passthrough')
-option('libxml2', type : 'feature', value : 'auto',
- description: 'libxml2 support for Parallels image format')
option('linux_aio', type : 'feature', value : 'auto',
description: 'Linux AIO support')
option('linux_io_uring', type : 'feature', value : 'auto',
#ifndef CONFIG_USER_ONLY
#include "qemu/plugin-memory.h"
#include "hw/boards.h"
+#else
+#include "qemu.h"
+#ifdef CONFIG_LINUX
+#include "loader.h"
+#endif
#endif
/* Uninstall and Reset handlers */
{
return name && value && qapi_bool_parse(name, value, ret, NULL);
}
+
+/*
+ * Binary path, start and end locations
+ */
+const char *qemu_plugin_path_to_binary(void)
+{
+ char *path = NULL;
+#ifdef CONFIG_USER_ONLY
+ TaskState *ts = (TaskState *) current_cpu->opaque;
+ path = g_strdup(ts->bprm->filename);
+#endif
+ return path;
+}
+
+uint64_t qemu_plugin_start_code(void)
+{
+ uint64_t start = 0;
+#ifdef CONFIG_USER_ONLY
+ TaskState *ts = (TaskState *) current_cpu->opaque;
+ start = ts->info->start_code;
+#endif
+ return start;
+}
+
+uint64_t qemu_plugin_end_code(void)
+{
+ uint64_t end = 0;
+#ifdef CONFIG_USER_ONLY
+ TaskState *ts = (TaskState *) current_cpu->opaque;
+ end = ts->info->end_code;
+#endif
+ return end;
+}
+
+uint64_t qemu_plugin_entry_code(void)
+{
+ uint64_t entry = 0;
+#ifdef CONFIG_USER_ONLY
+ TaskState *ts = (TaskState *) current_cpu->opaque;
+ entry = ts->info->entry;
+#endif
+ return entry;
+}
{
qemu_plugin_bool_parse;
+ qemu_plugin_end_code;
+ qemu_plugin_entry_code;
qemu_plugin_get_hwaddr;
qemu_plugin_hwaddr_device_name;
qemu_plugin_hwaddr_is_io;
qemu_plugin_n_max_vcpus;
qemu_plugin_n_vcpus;
qemu_plugin_outs;
+ qemu_plugin_path_to_binary;
qemu_plugin_register_atexit_cb;
qemu_plugin_register_flush_cb;
qemu_plugin_register_vcpu_exit_cb;
qemu_plugin_register_vcpu_tb_exec_inline;
qemu_plugin_register_vcpu_tb_trans_cb;
qemu_plugin_reset;
+ qemu_plugin_start_code;
qemu_plugin_tb_get_insn;
qemu_plugin_tb_n_insns;
qemu_plugin_tb_vaddr;
qr{target_(?:u)?long},
qr{hwaddr},
# external libraries
- qr{xml${Ident}},
qr{xen\w+_handle},
# Glib definitions
qr{gchar},
--disable-libssh \
--disable-libudev \
--disable-libusb \
---disable-libxml2 \
--disable-linux-aio \
--disable-linux-io-uring \
--disable-linux-user \
libubsan \
libudev-devel \
libusbx-devel \
- libxml2-devel \
libzstd-devel \
llvm \
lzo-devel \
--enable-libiscsi --enable-libnfs --enable-seccomp \
--enable-tpm --enable-libssh --enable-lzo --enable-snappy --enable-bzip2 \
--enable-numa --enable-rdma --enable-smartcard --enable-virglrenderer \
- --enable-mpath --enable-libxml2 --enable-glusterfs \
+ --enable-mpath --enable-glusterfs \
--enable-virtfs --enable-zstd
echo "Running cov-build..."
printf "%s\n" ' libssh ssh block device support'
printf "%s\n" ' libudev Use libudev to enumerate host devices'
printf "%s\n" ' libusb libusb support for USB passthrough'
- printf "%s\n" ' libxml2 libxml2 support for Parallels image format'
printf "%s\n" ' linux-aio Linux AIO support'
printf "%s\n" ' linux-io-uring Linux io_uring support'
printf "%s\n" ' lzfse lzfse support for DMG images'
--disable-libudev) printf "%s" -Dlibudev=disabled ;;
--enable-libusb) printf "%s" -Dlibusb=enabled ;;
--disable-libusb) printf "%s" -Dlibusb=disabled ;;
- --enable-libxml2) printf "%s" -Dlibxml2=enabled ;;
- --disable-libxml2) printf "%s" -Dlibxml2=disabled ;;
--enable-linux-aio) printf "%s" -Dlinux_aio=enabled ;;
--disable-linux-aio) printf "%s" -Dlinux_aio=disabled ;;
--enable-linux-io-uring) printf "%s" -Dlinux_io_uring=enabled ;;
"ssize_t",
"uintptr_t",
"ptrdiff_t",
- # Magic substitution is done by tracetool
- "TCGv",
]
def validate_type(name):
"(?:(?:(?P<fmt_trans>\".+),)?\s*(?P<fmt>\".+))?"
"\s*")
- _VALID_PROPS = set(["disable", "tcg", "tcg-trans", "tcg-exec", "vcpu"])
+ _VALID_PROPS = set(["disable", "vcpu"])
def __init__(self, name, props, fmt, args, lineno, filename, orig=None,
event_trans=None, event_exec=None):
fmt = [fmt_trans, fmt]
args = Arguments.build(groups["args"])
- if "tcg-trans" in props:
- raise ValueError("Invalid property 'tcg-trans'")
- if "tcg-exec" in props:
- raise ValueError("Invalid property 'tcg-exec'")
- if "tcg" not in props and not isinstance(fmt, str):
- raise ValueError("Only events with 'tcg' property can have two format strings")
- if "tcg" in props and isinstance(fmt, str):
- raise ValueError("Events with 'tcg' property must have two format strings")
-
event = Event(name, props, fmt, args, lineno, filename)
# add implicit arguments when using the 'vcpu' property
e.args = (arg0,) + e.args[1:]
raise
- # transform TCG-enabled events
- if "tcg" not in event.properties:
- events.append(event)
- else:
- event_trans = event.copy()
- event_trans.name += "_trans"
- event_trans.properties += ["tcg-trans"]
- event_trans.fmt = event.fmt[0]
- # ignore TCG arguments
- args_trans = []
- for atrans, aorig in zip(
- event_trans.transform(tracetool.transform.TCG_2_HOST).args,
- event.args):
- if atrans == aorig:
- args_trans.append(atrans)
- event_trans.args = Arguments(args_trans)
-
- event_exec = event.copy()
- event_exec.name += "_exec"
- event_exec.properties += ["tcg-exec"]
- event_exec.fmt = event.fmt[1]
- event_exec.args = event_exec.args.transform(tracetool.transform.TCG_2_HOST)
-
- new_event = [event_trans, event_exec]
- event.event_trans, event.event_exec = new_event
-
- events.extend(new_event)
+ events.append(event)
return events
+++ /dev/null
-# -*- coding: utf-8 -*-
-
-"""
-Generate .h file for TCG code generation.
-"""
-
-__author__ = "Lluís Vilanova <vilanova@ac.upc.edu>"
-__copyright__ = "Copyright 2012-2017, Lluís Vilanova <vilanova@ac.upc.edu>"
-__license__ = "GPL version 2 or (at your option) any later version"
-
-__maintainer__ = "Stefan Hajnoczi"
-__email__ = "stefanha@redhat.com"
-
-
-from tracetool import out, Arguments
-import tracetool.vcpu
-
-
-def vcpu_transform_args(args):
- assert len(args) == 1
- return Arguments([
- args,
- # NOTE: this name must be kept in sync with the one in "tcg_h"
- # NOTE: Current helper code uses TCGv_env (CPUArchState*)
- ("TCGv_env", "__tcg_" + args.names()[0]),
- ])
-
-
-def generate(events, backend, group):
- if group == "root":
- header = "trace/trace-root.h"
- else:
- header = "trace.h"
-
- out('/* This file is autogenerated by tracetool, do not edit. */',
- '/* You must include this file after the inclusion of helper.h */',
- '',
- '#ifndef TRACE_%s_GENERATED_TCG_TRACERS_H' % group.upper(),
- '#define TRACE_%s_GENERATED_TCG_TRACERS_H' % group.upper(),
- '',
- '#include "exec/helper-proto.h"',
- '#include "%s"' % header,
- '',
- )
-
- for e in events:
- # just keep one of them
- if "tcg-exec" not in e.properties:
- continue
-
- out('static inline void %(name_tcg)s(%(args)s)',
- '{',
- name_tcg=e.original.api(e.QEMU_TRACE_TCG),
- args=tracetool.vcpu.transform_args("tcg_h", e.original))
-
- if "disable" not in e.properties:
- args_trans = e.original.event_trans.args
- args_exec = tracetool.vcpu.transform_args(
- "tcg_helper_c", e.original.event_exec, "wrapper")
- if "vcpu" in e.properties:
- trace_cpu = e.args.names()[0]
- cond = "trace_event_get_vcpu_state(%(cpu)s,"\
- " TRACE_%(id)s)"\
- % dict(
- cpu=trace_cpu,
- id=e.original.event_exec.name.upper())
- else:
- cond = "true"
-
- out(' %(name_trans)s(%(argnames_trans)s);',
- ' if (%(cond)s) {',
- ' gen_helper_%(name_exec)s(%(argnames_exec)s);',
- ' }',
- name_trans=e.original.event_trans.api(e.QEMU_TRACE),
- name_exec=e.original.event_exec.api(e.QEMU_TRACE),
- argnames_trans=", ".join(args_trans.names()),
- argnames_exec=", ".join(args_exec.names()),
- cond=cond)
-
- out('}')
-
- out('',
- '#endif /* TRACE_%s_GENERATED_TCG_TRACERS_H */' % group.upper())
+++ /dev/null
-# -*- coding: utf-8 -*-
-
-"""
-Generate trace/generated-helpers.c.
-"""
-
-__author__ = "Lluís Vilanova <vilanova@ac.upc.edu>"
-__copyright__ = "Copyright 2012-2017, Lluís Vilanova <vilanova@ac.upc.edu>"
-__license__ = "GPL version 2 or (at your option) any later version"
-
-__maintainer__ = "Stefan Hajnoczi"
-__email__ = "stefanha@redhat.com"
-
-
-from tracetool import Arguments, out
-from tracetool.transform import *
-import tracetool.vcpu
-
-
-def vcpu_transform_args(args, mode):
- assert len(args) == 1
- # NOTE: this name must be kept in sync with the one in "tcg_h"
- args = Arguments([(args.types()[0], "__tcg_" + args.names()[0])])
- if mode == "code":
- return Arguments([
- # Does cast from helper requirements to tracing types
- ("CPUState *", "env_cpu(%s)" % args.names()[0]),
- ])
- else:
- args = Arguments([
- # NOTE: Current helper code uses TCGv_env (CPUArchState*)
- ("CPUArchState *", args.names()[0]),
- ])
- if mode == "header":
- return args
- elif mode == "wrapper":
- return args.transform(HOST_2_TCG)
- else:
- assert False
-
-
-def generate(events, backend, group):
- if group == "root":
- header = "trace/trace-root.h"
- else:
- header = "trace.h"
-
- events = [e for e in events
- if "disable" not in e.properties]
-
- out('/* This file is autogenerated by tracetool, do not edit. */',
- '',
- '#include "qemu/osdep.h"',
- '#include "cpu.h"',
- '#include "exec/helper-proto.h"',
- '#include "%s"' % header,
- '',
- )
-
- for e in events:
- if "tcg-exec" not in e.properties:
- continue
-
- e_args_api = tracetool.vcpu.transform_args(
- "tcg_helper_c", e.original, "header").transform(
- HOST_2_TCG_COMPAT, TCG_2_TCG_HELPER_DEF)
- e_args_call = tracetool.vcpu.transform_args(
- "tcg_helper_c", e, "code")
-
- out('void %(name_tcg)s(%(args_api)s)',
- '{',
- # NOTE: the check was already performed at TCG-generation time
- ' %(name)s(%(args_call)s);',
- '}',
- name_tcg="helper_%s_proxy" % e.api(),
- name=e.api(e.QEMU_TRACE_NOCHECK),
- args_api=e_args_api,
- args_call=", ".join(e_args_call.casted()),
- )
+++ /dev/null
-# -*- coding: utf-8 -*-
-
-"""
-Generate trace/generated-helpers.h.
-"""
-
-__author__ = "Lluís Vilanova <vilanova@ac.upc.edu>"
-__copyright__ = "Copyright 2012-2016, Lluís Vilanova <vilanova@ac.upc.edu>"
-__license__ = "GPL version 2 or (at your option) any later version"
-
-__maintainer__ = "Stefan Hajnoczi"
-__email__ = "stefanha@redhat.com"
-
-
-from tracetool import out
-from tracetool.transform import *
-import tracetool.vcpu
-
-
-def generate(events, backend, group):
- events = [e for e in events
- if "disable" not in e.properties]
-
- out('/* This file is autogenerated by tracetool, do not edit. */',
- '',
- )
-
- for e in events:
- if "tcg-exec" not in e.properties:
- continue
-
- # TCG helper proxy declaration
- fmt = "DEF_HELPER_FLAGS_%(argc)d(%(name)s, %(flags)svoid%(types)s)"
- e_args = tracetool.vcpu.transform_args("tcg_helper_c", e.original, "header")
- args = e_args.transform(HOST_2_TCG_COMPAT, HOST_2_TCG,
- TCG_2_TCG_HELPER_DECL)
- types = ", ".join(args.types())
- if types != "":
- types = ", " + types
-
- flags = "TCG_CALL_NO_RWG, "
-
- out(fmt,
- flags=flags,
- argc=len(args),
- name=e.api() + "_proxy",
- types=types,
- )
+++ /dev/null
-# -*- coding: utf-8 -*-
-
-"""
-Generate trace/generated-helpers-wrappers.h.
-"""
-
-__author__ = "Lluís Vilanova <vilanova@ac.upc.edu>"
-__copyright__ = "Copyright 2012-2016, Lluís Vilanova <vilanova@ac.upc.edu>"
-__license__ = "GPL version 2 or (at your option) any later version"
-
-__maintainer__ = "Stefan Hajnoczi"
-__email__ = "stefanha@redhat.com"
-
-
-from tracetool import out
-from tracetool.transform import *
-import tracetool.vcpu
-
-
-def generate(events, backend, group):
- events = [e for e in events
- if "disable" not in e.properties]
-
- out('/* This file is autogenerated by tracetool, do not edit. */',
- '',
- '#define tcg_temp_new_nop(v) (v)',
- '#define tcg_temp_free_nop(v)',
- '',
- )
-
- for e in events:
- if "tcg-exec" not in e.properties:
- continue
-
- # tracetool.generate always transforms types to host
- e_args = tracetool.vcpu.transform_args("tcg_helper_c", e.original, "wrapper")
-
- # mixed-type to TCG helper bridge
- args_tcg_compat = e_args.transform(HOST_2_TCG_COMPAT)
-
- code_new = [
- "%(tcg_type)s __%(name)s = %(tcg_func)s(%(name)s);" %
- {"tcg_type": transform_type(type_, HOST_2_TCG),
- "tcg_func": transform_type(type_, HOST_2_TCG_TMP_NEW),
- "name": name}
- for (type_, name) in args_tcg_compat
- ]
-
- code_free = [
- "%(tcg_func)s(__%(name)s);" %
- {"tcg_func": transform_type(type_, HOST_2_TCG_TMP_FREE),
- "name": name}
- for (type_, name) in args_tcg_compat
- ]
-
- gen_name = "gen_helper_" + e.api()
-
- out('static inline void %(name)s(%(args)s)',
- '{',
- ' %(code_new)s',
- ' %(proxy_name)s(%(tmp_names)s);',
- ' %(code_free)s',
- '}',
- name=gen_name,
- args=e_args,
- proxy_name=gen_name + "_proxy",
- code_new="\n ".join(code_new),
- code_free="\n ".join(code_free),
- tmp_names=", ".join(["__%s" % name for _, name in e_args]),
- )
def transform_event(event):
"""Transform event to comply with the 'vcpu' property (if present)."""
if "vcpu" in event.properties:
- # events with 'tcg-trans' and 'tcg-exec' are auto-generated from
- # already-patched events
- assert "tcg-trans" not in event.properties
- assert "tcg-exec" not in event.properties
-
event.args = Arguments([("void *", "__cpu"), event.args])
- if "tcg" in event.properties:
- fmt = "\"cpu=%p \""
- event.fmt = [fmt + event.fmt[0],
- fmt + event.fmt[1]]
- else:
- fmt = "\"cpu=%p \""
- event.fmt = fmt + event.fmt
+ fmt = "\"cpu=%p \""
+ event.fmt = fmt + event.fmt
return event
cs->interrupt_request &= ~(CPU_INTERRUPT_HARD |
CPU_INTERRUPT_VIRQ);
intno = cpu_get_pic_interrupt(env);
- qemu_log_mask(CPU_LOG_TB_IN_ASM,
+ qemu_log_mask(CPU_LOG_INT,
"Servicing hardware INT=0x%02x\n", intno);
do_interrupt_x86_hardirq(env, intno, 1);
break;
cpu_svm_check_intercept_param(env, SVM_EXIT_VINTR, 0, 0);
intno = x86_ldl_phys(cs, env->vm_vmcb
+ offsetof(struct vmcb, control.int_vector));
- qemu_log_mask(CPU_LOG_TB_IN_ASM,
+ qemu_log_mask(CPU_LOG_INT,
"Servicing virtual hardware INT=0x%02x\n", intno);
do_interrupt_x86_hardirq(env, intno, 1);
cs->interrupt_request &= ~CPU_INTERRUPT_VIRQ;
#include "tcg/tcg.h"
#include "tcg/tcg-op.h"
#include "tcg/tcg-mo.h"
-#include "trace-tcg.h"
#include "exec/plugin-gen.h"
/* Reduce the number of ifdefs below. This assumes that all uses of
tcg_gen_req_mo(TCG_MO_LD_LD | TCG_MO_ST_LD);
memop = tcg_canonicalize_memop(memop, 0, 0);
oi = make_memop_idx(memop, idx);
- trace_guest_ld_before_tcg(tcg_ctx->cpu, cpu_env, addr, oi);
orig_memop = memop;
if (!TCG_TARGET_HAS_MEMORY_BSWAP && (memop & MO_BSWAP)) {
tcg_gen_req_mo(TCG_MO_LD_ST | TCG_MO_ST_ST);
memop = tcg_canonicalize_memop(memop, 0, 1);
oi = make_memop_idx(memop, idx);
- trace_guest_st_before_tcg(tcg_ctx->cpu, cpu_env, addr, oi);
if (!TCG_TARGET_HAS_MEMORY_BSWAP && (memop & MO_BSWAP)) {
swap = tcg_temp_new_i32();
tcg_gen_req_mo(TCG_MO_LD_LD | TCG_MO_ST_LD);
memop = tcg_canonicalize_memop(memop, 1, 0);
oi = make_memop_idx(memop, idx);
- trace_guest_ld_before_tcg(tcg_ctx->cpu, cpu_env, addr, oi);
orig_memop = memop;
if (!TCG_TARGET_HAS_MEMORY_BSWAP && (memop & MO_BSWAP)) {
tcg_gen_req_mo(TCG_MO_LD_ST | TCG_MO_ST_ST);
memop = tcg_canonicalize_memop(memop, 1, 1);
oi = make_memop_idx(memop, idx);
- trace_guest_st_before_tcg(tcg_ctx->cpu, cpu_env, addr, oi);
if (!TCG_TARGET_HAS_MEMORY_BSWAP && (memop & MO_BSWAP)) {
swap = tcg_temp_new_i64();
ifneq ($(wildcard config-host.mak),)
export SRC_PATH
-# Get the list of all supported sysemu targets
-SYSEMU_TARGET_LIST := $(subst -softmmu.mak,,$(notdir \
- $(wildcard $(SRC_PATH)/configs/*-softmmu.mak)))
-
SPEED = quick
# Build up our target list from the filtered list of ninja targets
# THIS FILE WAS AUTO-GENERATED
#
-# $ lcitool dockerfile alpine-edge qemu
+# $ lcitool dockerfile --layers all alpine-edge qemu
#
# https://gitlab.com/libvirt/libvirt-ci
libtasn1-dev \
liburing-dev \
libusb-dev \
- libxml2-dev \
linux-pam-dev \
llvm11 \
lttng-ust-dev \
zlib-dev \
zlib-static \
zstd-dev && \
+ apk list | sort > /packages.txt && \
mkdir -p /usr/libexec/ccache-wrappers && \
ln -s /usr/bin/ccache /usr/libexec/ccache-wrappers/c++ && \
ln -s /usr/bin/ccache /usr/libexec/ccache-wrappers/cc && \
# THIS FILE WAS AUTO-GENERATED
#
-# $ lcitool dockerfile centos-8 qemu
+# $ lcitool dockerfile --layers all centos-stream-8 qemu
#
# https://gitlab.com/libvirt/libvirt-ci
-FROM docker.io/library/centos:8
+FROM quay.io/centos/centos:stream8
RUN dnf update -y && \
dnf install 'dnf-command(config-manager)' -y && \
libssh-devel \
libtasn1-devel \
libubsan \
- libudev-devel \
liburing-devel \
libusbx-devel \
- libxml2-devel \
libzstd-devel \
llvm \
lttng-ust-devel \
# Specify the cross prefix for this image (see tests/docker/common.rc)
ENV QEMU_CONFIGURE_OPTS --cross-prefix=powerpc64le-linux-gnu-
-ENV DEF_TARGET_LIST ppc64-softmmu,ppc64-linux-user,ppc64abi32-linux-user
+ENV DEF_TARGET_LIST ppc64-softmmu,ppc64-linux-user
# Install extra libraries to increase code coverage
RUN apt update && \
# THIS FILE WAS AUTO-GENERATED
#
-# $ lcitool dockerfile fedora-35 qemu
+# $ lcitool dockerfile --layers all fedora-35 qemu
#
# https://gitlab.com/libvirt/libvirt-ci
libssh-devel \
libtasn1-devel \
libubsan \
- libudev-devel \
liburing-devel \
libusbx-devel \
- libxml2-devel \
libzstd-devel \
llvm \
lttng-ust-devel \
# THIS FILE WAS AUTO-GENERATED
#
-# $ lcitool dockerfile opensuse-leap-152 qemu
+# $ lcitool dockerfile --layers all opensuse-leap-152 qemu
#
# https://gitlab.com/libvirt/libvirt-ci
libudev-devel \
liburing-devel \
libusb-1_0-devel \
- libxml2-devel \
libzstd-devel \
llvm \
lttng-ust-devel \
# THIS FILE WAS AUTO-GENERATED
#
-# $ lcitool dockerfile ubuntu-1804 qemu
+# $ lcitool dockerfile --layers all ubuntu-1804 qemu
#
# https://gitlab.com/libvirt/libvirt-ci
libglib2.0-dev \
libgnutls28-dev \
libgtk-3-dev \
+ libibumad-dev \
libibverbs-dev \
libiscsi-dev \
libjemalloc-dev \
libvirglrenderer-dev \
libvte-2.91-dev \
libxen-dev \
- libxml2-dev \
libzstd-dev \
llvm \
locales \
# THIS FILE WAS AUTO-GENERATED
#
-# $ lcitool dockerfile ubuntu-2004 qemu
+# $ lcitool dockerfile --layers all ubuntu-2004 qemu
#
# https://gitlab.com/libvirt/libvirt-ci
libglusterfs-dev \
libgnutls28-dev \
libgtk-3-dev \
+ libibumad-dev \
libibverbs-dev \
libiscsi-dev \
libjemalloc-dev \
libvirglrenderer-dev \
libvte-2.91-dev \
libxen-dev \
- libxml2-dev \
libzstd-dev \
llvm \
locales \
lcitool-help: lcitool
lcitool-refresh:
- $(call quiet-command, git submodule update --init $(SRC_PATH)/tests/lcitool/libvirt-ci)
+ $(call quiet-command, cd $(SRC_PATH) && git submodule update --init tests/lcitool/libvirt-ci)
$(call quiet-command, $(LCITOOL_REFRESH))
-Subproject commit 29cec2153b9a4dbb2e66f1cbc9866a4eff519cfd
+Subproject commit 6dd9b6fab1fe081b16bc975485d7a02c81ba5fbe
- libfdt
- libffi
- libgcrypt
+ - libibumad
- libibverbs
- libiscsi
- libjemalloc
- liburing
- libusbx
- libvdeplug
- - libxml2
- libzstd
- llvm
- lttng-ust
def generate_cirrus(target, trailer=None):
filename = Path(src_dir, ".gitlab-ci.d", "cirrus", target + ".vars")
- cmd = [lcitool_path, "variables", target, "qemu"]
+ cmd = lcitool_cmd + ["variables", target, "qemu"]
generate(filename, cmd, trailer)
ubuntu1804_skipssh = [
]
try:
- generate_dockerfile("centos8", "centos-8")
+ generate_dockerfile("centos8", "centos-stream-8")
generate_dockerfile("fedora", "fedora-35")
generate_dockerfile("ubuntu1804", "ubuntu-1804",
trailer="".join(ubuntu1804_skipssh))
QEMU_PLUGIN_EXPORT int qemu_plugin_version = QEMU_PLUGIN_VERSION;
-static uint64_t insn_count;
+#define MAX_CPUS 8 /* lets not go nuts */
+
+typedef struct {
+ uint64_t last_pc;
+ uint64_t insn_count;
+} InstructionCount;
+
+static InstructionCount counts[MAX_CPUS];
+static uint64_t inline_insn_count;
+
static bool do_inline;
static bool do_size;
static GArray *sizes;
+typedef struct {
+ char *match_string;
+ uint64_t hits[MAX_CPUS];
+ uint64_t last_hit[MAX_CPUS];
+ uint64_t total_delta[MAX_CPUS];
+ GPtrArray *history[MAX_CPUS];
+} Match;
+
+static GArray *matches;
+
+typedef struct {
+ Match *match;
+ uint64_t vaddr;
+ uint64_t hits;
+ char *disas;
+} Instruction;
+
static void vcpu_insn_exec_before(unsigned int cpu_index, void *udata)
{
- static uint64_t last_pc;
+ unsigned int i = cpu_index % MAX_CPUS;
+ InstructionCount *c = &counts[i];
uint64_t this_pc = GPOINTER_TO_UINT(udata);
- if (this_pc == last_pc) {
+ if (this_pc == c->last_pc) {
g_autofree gchar *out = g_strdup_printf("detected repeat execution @ 0x%"
PRIx64 "\n", this_pc);
qemu_plugin_outs(out);
}
- last_pc = this_pc;
- insn_count++;
+ c->last_pc = this_pc;
+ c->insn_count++;
+}
+
+static void vcpu_insn_matched_exec_before(unsigned int cpu_index, void *udata)
+{
+ unsigned int i = cpu_index % MAX_CPUS;
+ Instruction *insn = (Instruction *) udata;
+ Match *match = insn->match;
+ g_autoptr(GString) ts = g_string_new("");
+
+ insn->hits++;
+ g_string_append_printf(ts, "0x%" PRIx64 ", '%s', %"PRId64 " hits",
+ insn->vaddr, insn->disas, insn->hits);
+
+ uint64_t icount = counts[i].insn_count;
+ uint64_t delta = icount - match->last_hit[i];
+
+ match->hits[i]++;
+ match->total_delta[i] += delta;
+
+ g_string_append_printf(ts,
+ ", %"PRId64" match hits, "
+ "Δ+%"PRId64 " since last match,"
+ " %"PRId64 " avg insns/match\n",
+ match->hits[i], delta,
+ match->total_delta[i] / match->hits[i]);
+
+ match->last_hit[i] = icount;
+
+ qemu_plugin_outs(ts->str);
+
+ g_ptr_array_add(match->history[i], insn);
}
static void vcpu_tb_trans(qemu_plugin_id_t id, struct qemu_plugin_tb *tb)
if (do_inline) {
qemu_plugin_register_vcpu_insn_exec_inline(
- insn, QEMU_PLUGIN_INLINE_ADD_U64, &insn_count, 1);
+ insn, QEMU_PLUGIN_INLINE_ADD_U64, &inline_insn_count, 1);
} else {
uint64_t vaddr = qemu_plugin_insn_vaddr(insn);
qemu_plugin_register_vcpu_insn_exec_cb(
unsigned long *cnt = &g_array_index(sizes, unsigned long, sz);
(*cnt)++;
}
+
+ /*
+ * If we are tracking certain instructions we will need more
+ * information about the instruction which we also need to
+ * save if there is a hit.
+ */
+ if (matches) {
+ char *insn_disas = qemu_plugin_insn_disas(insn);
+ int j;
+ for (j = 0; j < matches->len; j++) {
+ Match *m = &g_array_index(matches, Match, j);
+ if (g_str_has_prefix(insn_disas, m->match_string)) {
+ Instruction *rec = g_new0(Instruction, 1);
+ rec->disas = g_strdup(insn_disas);
+ rec->vaddr = qemu_plugin_insn_vaddr(insn);
+ rec->match = m;
+ qemu_plugin_register_vcpu_insn_exec_cb(
+ insn, vcpu_insn_matched_exec_before,
+ QEMU_PLUGIN_CB_NO_REGS, rec);
+ }
+ }
+ g_free(insn_disas);
+ }
}
}
static void plugin_exit(qemu_plugin_id_t id, void *p)
{
g_autoptr(GString) out = g_string_new(NULL);
+ int i;
if (do_size) {
- int i;
for (i = 0; i <= sizes->len; i++) {
unsigned long *cnt = &g_array_index(sizes, unsigned long, i);
if (*cnt) {
"len %d bytes: %ld insns\n", i, *cnt);
}
}
+ } else if (do_inline) {
+ g_string_append_printf(out, "insns: %" PRIu64 "\n", inline_insn_count);
} else {
- g_string_append_printf(out, "insns: %" PRIu64 "\n", insn_count);
+ uint64_t total_insns = 0;
+ for (i = 0; i < MAX_CPUS; i++) {
+ InstructionCount *c = &counts[i];
+ if (c->insn_count) {
+ g_string_append_printf(out, "cpu %d insns: %" PRIu64 "\n",
+ i, c->insn_count);
+ total_insns += c->insn_count;
+ }
+ }
+ g_string_append_printf(out, "total insns: %" PRIu64 "\n",
+ total_insns);
}
qemu_plugin_outs(out->str);
}
+
+/* Add a match to the array of matches */
+static void parse_match(char *match)
+{
+ Match new_match = { .match_string = match };
+ int i;
+ for (i = 0; i < MAX_CPUS; i++) {
+ new_match.history[i] = g_ptr_array_new();
+ }
+ if (!matches) {
+ matches = g_array_new(false, true, sizeof(Match));
+ }
+ g_array_append_val(matches, new_match);
+}
+
QEMU_PLUGIN_EXPORT int qemu_plugin_install(qemu_plugin_id_t id,
const qemu_info_t *info,
int argc, char **argv)
fprintf(stderr, "boolean argument parsing failed: %s\n", opt);
return -1;
}
+ } else if (g_strcmp0(tokens[0], "match") == 0) {
+ parse_match(tokens[1]);
} else {
fprintf(stderr, "option parsing failed: %s\n", opt);
return -1;
"virtio-net",
test_migrate, &opts);
- /* keeps failing on build-system since Aug 15 2017 */
- if (getenv("QTEST_VHOST_USER_FIXME")) {
- opts.before = vhost_user_test_setup_reconnect;
- qos_add_test("vhost-user/reconnect", "virtio-net",
- test_reconnect, &opts);
+ opts.before = vhost_user_test_setup_reconnect;
+ qos_add_test("vhost-user/reconnect", "virtio-net",
+ test_reconnect, &opts);
- opts.before = vhost_user_test_setup_connect_fail;
- qos_add_test("vhost-user/connect-fail", "virtio-net",
- test_vhost_user_started, &opts);
+ opts.before = vhost_user_test_setup_connect_fail;
+ qos_add_test("vhost-user/connect-fail", "virtio-net",
+ test_vhost_user_started, &opts);
- opts.before = vhost_user_test_setup_flags_mismatch;
- qos_add_test("vhost-user/flags-mismatch", "virtio-net",
- test_vhost_user_started, &opts);
- }
+ opts.before = vhost_user_test_setup_flags_mismatch;
+ qos_add_test("vhost-user/flags-mismatch", "virtio-net",
+ test_vhost_user_started, &opts);
opts.before = vhost_user_test_setup_multiqueue;
opts.edge.extra_device_opts = "mq=on";
container_image=debian-nios2-cross
container_cross_cc=nios2-linux-gnu-gcc
;;
- ppc-*|ppc64abi32-*)
+ ppc-*)
container_hosts=x86_64
container_image=debian-powerpc-test-cross
container_cross_cc=powerpc-linux-gnu-gcc-10
$(call skip-test, $<, "BROKEN")
run-plugin-linux-test-with-%:
$(call skip-test, $<, "BROKEN")
+
+# This test is currently unreliable: https://gitlab.com/qemu-project/qemu/-/issues/856
+run-plugin-threadcount-with-%:
+ $(call skip-test, $<, "BROKEN")
# Targets: all
vcpu guest_cpu_reset(void)
-# tcg/tcg-op.c
-
-# @vaddr: Access' virtual address.
-# @memopidx: Access' information (see below).
-#
-# Start virtual memory access (before any potential access violation).
-# Does not include memory accesses performed by devices.
-#
-# Mode: user, softmmu
-# Targets: TCG(all)
-vcpu tcg guest_ld_before(TCGv vaddr, uint32_t memopidx) "info=%d", "vaddr=0x%016"PRIx64" memopidx=0x%x"
-vcpu tcg guest_st_before(TCGv vaddr, uint32_t memopidx) "info=%d", "vaddr=0x%016"PRIx64" memopidx=0x%x"
-vcpu tcg guest_rmw_before(TCGv vaddr, uint32_t memopidx) "info=%d", "vaddr=0x%016"PRIx64" memopidx=0x%x"
-
# include/user/syscall-trace.h
# @num: System call number.
install: true,
install_dir: qemu_datadir)
-foreach d : [
- ['generated-tcg-tracers.h', 'tcg-h'],
- ['generated-helpers.c', 'tcg-helper-c'],
- ['generated-helpers.h', 'tcg-helper-h'],
- ['generated-helpers-wrappers.h', 'tcg-helper-wrapper-h'],
-]
- gen = custom_target(d[0],
- output: d[0],
- input: meson.project_source_root() / 'trace-events',
- command: [ tracetool, '--group=root', '--format=@0@'.format(d[1]), '@INPUT@', '@OUTPUT@' ],
- depend_files: tracetool_depends)
- specific_ss.add(when: 'CONFIG_TCG', if_true: gen)
-endforeach
-
if 'ust' in get_option('trace_backends')
trace_ust_all_h = custom_target('trace-ust-all.h',
output: 'trace-ust-all.h',