commit 93b7a21f5b02dde6fba6b038483b3ddc8d5b1cb8c988ee690e45a999bec5620f Author: Adrian Schröter Date: Sat May 4 01:42:45 2024 +0200 Sync from SUSE:SLFO:Main valgrind revision 3a670794dd8824014aae82f2385a6959 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..9b03811 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,23 @@ +## Default LFS +*.7z filter=lfs diff=lfs merge=lfs -text +*.bsp filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +*.gem filter=lfs diff=lfs merge=lfs -text +*.gz filter=lfs diff=lfs merge=lfs -text +*.jar filter=lfs diff=lfs merge=lfs -text +*.lz filter=lfs diff=lfs merge=lfs -text +*.lzma filter=lfs diff=lfs merge=lfs -text +*.obscpio filter=lfs diff=lfs merge=lfs -text +*.oxt filter=lfs diff=lfs merge=lfs -text +*.pdf filter=lfs diff=lfs merge=lfs -text +*.png filter=lfs diff=lfs merge=lfs -text +*.rpm filter=lfs diff=lfs merge=lfs -text +*.tbz filter=lfs diff=lfs merge=lfs -text +*.tbz2 filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.ttf filter=lfs diff=lfs merge=lfs -text +*.txz filter=lfs diff=lfs merge=lfs -text +*.whl filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zst filter=lfs diff=lfs merge=lfs -text diff --git a/VEX-x86-pinsrd.patch b/VEX-x86-pinsrd.patch new file mode 100644 index 0000000..8380286 --- /dev/null +++ b/VEX-x86-pinsrd.patch @@ -0,0 +1,67 @@ +Index: valgrind-3.21.0/VEX/priv/guest_x86_toIR.c +=================================================================== +--- valgrind-3.21.0.orig/VEX/priv/guest_x86_toIR.c ++++ valgrind-3.21.0/VEX/priv/guest_x86_toIR.c +@@ -12921,6 +12921,62 @@ DisResult disInstr_X86_WRK ( + /* --- start of the SSE4 decoder --- */ + /* ---------------------------------------------------- */ + ++ /* 66 0F 3A 22 /r ib = PINSRD xmm1, r/m32, imm8 ++ Extract Doubleword int from gen.reg/mem32 and insert into xmm1 */ ++ if ( sz == 2 ++ && insn[0] == 0x0F && insn[1] == 0x3A && insn[2] == 0x22 ) { ++ ++ Int imm8_10; ++ IRTemp src_elems = newTemp(Ity_I32); ++ IRTemp src_vec = newTemp(Ity_V128); ++ IRTemp z32 = newTemp(Ity_I32); ++ ++ modrm = insn[3]; ++ ++ if ( epartIsReg( modrm ) ) { ++ imm8_10 = (Int)(insn[3+1] & 3); ++ assign( src_elems, getIReg( 4, eregOfRM(modrm) ) ); ++ delta += 3+1+1; ++ DIP( "pinsrd $%d, %s,%s\n", imm8_10, ++ nameIReg( 4, eregOfRM(modrm) ), ++ nameXMMReg( gregOfRM(modrm) ) ); ++ } else { ++ addr = disAMode( &alen, sorb, delta+3, dis_buf ); ++ imm8_10 = (Int)(insn[3+alen] & 3); ++ assign( src_elems, loadLE( Ity_I32, mkexpr(addr) ) ); ++ delta += 3+alen+1; ++ DIP( "pinsrd $%d, %s,%s\n", ++ imm8_10, dis_buf, nameXMMReg( gregOfRM(modrm) ) ); ++ } ++ ++ assign(z32, mkU32(0)); ++ ++ UShort mask = 0; ++ switch (imm8_10) { ++ case 3: mask = 0x0FFF; ++ assign(src_vec, mk128from32s(src_elems, z32, z32, z32)); ++ break; ++ case 2: mask = 0xF0FF; ++ assign(src_vec, mk128from32s(z32, src_elems, z32, z32)); ++ break; ++ case 1: mask = 0xFF0F; ++ assign(src_vec, mk128from32s(z32, z32, src_elems, z32)); ++ break; ++ case 0: mask = 0xFFF0; ++ assign(src_vec, mk128from32s(z32, z32, z32, src_elems)); ++ break; ++ default: vassert(0); ++ } ++ ++ putXMMReg( gregOfRM(modrm), ++ binop( Iop_OrV128, mkexpr(src_vec), ++ binop( Iop_AndV128, ++ getXMMReg( gregOfRM(modrm) ), ++ mkV128(mask) ) ) ); ++ ++ goto decode_success; ++ } ++ + /* 66 0F 3A 0B /r ib = ROUNDSD imm8, xmm2/m64, xmm1 + (Partial implementation only -- only deal with cases where + the rounding mode is specified directly by the immediate byte.) diff --git a/_multibuild b/_multibuild new file mode 100644 index 0000000..19d41ea --- /dev/null +++ b/_multibuild @@ -0,0 +1,3 @@ + + client-headers + diff --git a/armv6-support.diff b/armv6-support.diff new file mode 100644 index 0000000..45036ff --- /dev/null +++ b/armv6-support.diff @@ -0,0 +1,11 @@ +--- a/configure.ac ++++ b/configure.ac +@@ -252,7 +252,7 @@ case "${host_cpu}" in + ARCH_MAX="s390x" + ;; + +- armv7*) ++ armv6*|armv7*) + AC_MSG_RESULT([ok (${host_cpu})]) + ARCH_MAX="arm" + ;; diff --git a/dhat-use-datadir.patch b/dhat-use-datadir.patch new file mode 100644 index 0000000..13963bb --- /dev/null +++ b/dhat-use-datadir.patch @@ -0,0 +1,13 @@ +Index: valgrind-3.17.0/dhat/Makefile.am +=================================================================== +--- valgrind-3.17.0.orig/dhat/Makefile.am ++++ valgrind-3.17.0/dhat/Makefile.am +@@ -10,7 +10,7 @@ pkginclude_HEADERS = \ + dhat.h + + # Ensure the viewer components get copied into the install tree. +-dhatdir = $(pkglibexecdir) ++dhatdir = $(pkgdatadir) + dhat_DATA = dh_view.html dh_view.css dh_view.js + + #---------------------------------------------------------------------------- diff --git a/parallel-lto.patch b/parallel-lto.patch new file mode 100644 index 0000000..22f3337 --- /dev/null +++ b/parallel-lto.patch @@ -0,0 +1,26 @@ +Index: valgrind-3.20.0/configure +=================================================================== +--- valgrind-3.20.0.orig/configure ++++ valgrind-3.20.0/configure +@@ -10983,7 +10983,7 @@ if test "x${vg_cv_lto}" != "xno" -a "x${ + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if toolchain accepts lto" >&5 + printf %s "checking if toolchain accepts lto... " >&6; } + safe_CFLAGS=$CFLAGS +-TEST_LTO_CFLAGS="-flto -flto-partition=one -fuse-linker-plugin" ++TEST_LTO_CFLAGS="-flto=auto" + # Note : using 'one' partition is giving a slightly smaller/faster memcheck + # and ld/lto-trans1 still needs a reasonable memory (about 0.5GB) when linking. + CFLAGS="$TEST_LTO_CFLAGS -Werror" +Index: valgrind-3.20.0/configure.ac +=================================================================== +--- valgrind-3.20.0.orig/configure.ac ++++ valgrind-3.20.0/configure.ac +@@ -2448,7 +2448,7 @@ AC_CACHE_CHECK([for using the link time + if test "x${vg_cv_lto}" != "xno" -a "x${LTO_AR}" != "x" -a "x${LTO_RANLIB}" != "x"; then + AC_MSG_CHECKING([if toolchain accepts lto]) + safe_CFLAGS=$CFLAGS +-TEST_LTO_CFLAGS="-flto -flto-partition=one -fuse-linker-plugin" ++TEST_LTO_CFLAGS="-flto=auto" + # Note : using 'one' partition is giving a slightly smaller/faster memcheck + # and ld/lto-trans1 still needs a reasonable memory (about 0.5GB) when linking. + CFLAGS="$TEST_LTO_CFLAGS -Werror" diff --git a/valgrind-3.21.0.tar.bz2 b/valgrind-3.21.0.tar.bz2 new file mode 100644 index 0000000..f9fc90b --- /dev/null +++ b/valgrind-3.21.0.tar.bz2 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10ce1618bb3e33fad16eb79552b0a3e1211762448a0d7fce11c8a6243b9ac971 +size 17449484 diff --git a/valgrind.changes b/valgrind.changes new file mode 100644 index 0000000..6a0ac19 --- /dev/null +++ b/valgrind.changes @@ -0,0 +1,1510 @@ +------------------------------------------------------------------- +Wed Nov 15 10:09:48 UTC 2023 - Dirk Müller + +- remove 32bit support for ALP + +------------------------------------------------------------------- +Tue Nov 14 08:42:52 UTC 2023 - Dirk Müller + +- add VEX-x86-pinsrd.patch (bko#276780) + +------------------------------------------------------------------- +Wed Oct 25 19:02:01 UTC 2023 - Dirk Müller + +- remove buildrequires on 32bit packages + +------------------------------------------------------------------- +Mon Oct 23 13:47:24 UTC 2023 - Dirk Müller + +- update filelist for 32bit disabled projects + +------------------------------------------------------------------- +Mon Aug 7 08:27:39 UTC 2023 - Dirk Müller + +- use boolean / extended requires for glibc requires + +------------------------------------------------------------------- +Thu May 18 12:19:20 UTC 2023 - Dirk Müller + +- update to 3.21.0: + * When GDB is used to debug a program running under valgrind + using the valgrind gdbserver, GDB will automatically load some + python code provided in valgrind defining GDB front end + commands corresponding to the valgrind monitor commands. + * These GDB front end commands accept the same format as + the monitor commands directly sent to the Valgrind + gdbserver. + These GDB front end commands provide a better integration + in the GDB command line interface, so as to use for example + GDB auto-completion, command specific help, searching for + a command or command help matching a regexp, ... + For relevant monitor commands, GDB will evaluate arguments + to make the use of monitor commands easier. + For example, instead of having to print the address of a + variable to pass it to a subsequent monitor command, the + GDB front end command will evaluate the address argument. + * The vgdb utility now supports extended-remote protocol when + invoked with --multi. In this mode the GDB run command is + supported. Which means you don't need to run gdb and + valgrind from different terminals. + * The behaviour of realloc with a size of zero can now + be changed for tools that intercept malloc. Those + tools are memcheck, helgrind, drd, massif and dhat. + Realloc implementations generally do one of two things + - free the memory like free() and return NULL + (GNU libc and ptmalloc). + - either free the memory and then allocate a + minimum sized block or just return the + original pointer. Return NULL if the + allocation of the minimum sized block fails + (jemalloc, musl, snmalloc, Solaris, macOS). + * When Valgrind is configured and built it will + try to match the OS and libc behaviour. However + if you are using a non-default library to replace + malloc and family (e.g., musl on a glibc Linux or + tcmalloc on FreeBSD) then you can use a command line + option to change the behaviour of Valgrind: + --realloc-zero-bytes-frees=yes|no [yes on Linux glibc, no + otherwise] + * ==================== FIXED BUGS ==================== + * 241072 List tools in --help output + * 327548 false positive while destroying mutex + * 382034 Testcases build fixes for musl + * 351857 confusing error message about valid command line + option + * 374596 inconsistent RDTSCP support on x86_64 + * 392331 Spurious lock not held error from inside + pthread_cond_timedwait + * 397083 Likely false positive "uninitialised value(s)" for + __wmemchr_avx2 and __wmemcmp_avx2_movbe + * 400793 pthread_rwlock_timedwrlock false positive + * 419054 Unhandled syscall getcpu on arm32 + * 433873 openat2 syscall unimplemented on Linux + * 434057 Add stdio mode to valgrind's gdbserver + * 435441 valgrind fails to interpose malloc on musl 1.2.2 due + to weak symbol name and no libc soname + * 436413 Warn about realloc of size zero + * 439685 compiler warning in callgrind/main.c + * 444110 priv/guest_ppc_toIR.c:36198:31: warning: duplicated + 'if' condition. + * 444487 hginfo test detects an extra lock inside data symbol + "_rtld_local" + * 444488 Use glibc.pthread.stack_cache_size tunable + * 444568 drd/tests/pth_barrier_thr_cr fails on Fedora 38 + * 445743 "The impossible happened: mutex is locked + simultaneously by two threads" + * while using mutexes with priority inheritance and + signals + * 449309 Missing loopback device ioctl(s) + * 459476 vgdb: allow address reuse to avoid "address already + in use" errorsuse" errors + * 460356 s390: Sqrt32Fx4 -- cannot reduce tree + * 462830 WARNING: unhandled amd64-freebsd syscall: 474 + * 463027 broken check for MPX instruction support in assembler + * 464103 Enhancement: add a client request to DHAT to mark + memory to be histogrammed + * 464476 Firefox fails to start under Valgrind + * 464609 Valgrind memcheck should support Linux pidfd_open + * 464680 Show issues caused by memory policies like selinux + deny_execmem + * 464859 Build failures with GCC-13 (drd tsan_unittest) + * 464969 D language demangling + * 465435 m_libcfile.c:66 (vgPlain_safe_fd): Assertion 'newfd + >= VG_(fd_hard_limit)' failed. + * 466104 aligned_alloc problems, part 1 + * 467036 Add time cost statistics for Regtest + * 467482 Build failure on aarch64 Alpine + * 467714 fdleak_* and rlimit tests fail when parent process + has more than + * 64 descriptors opened + * 467839 Gdbserver: Improve compatibility of library directory + name + * 468401 [PATCH] Add a style file for clang-format + * 468556 Build failure for vgdb + * 468606 build: remove "Valgrind relies on GCC" check/output + * 469097 ppc64(be) doesn't support SCV syscall instruction + * n-i-bz FreeBSD rfork syscall fail with EINVAL or ENOSYS + rather than VG_(unimplemented) +- disable LTO on ppc64 (bsc#1205923) + +------------------------------------------------------------------- +Wed Mar 29 08:17:25 UTC 2023 - Fabian Vogt + +- Build without -z now (bsc#1208407) + +------------------------------------------------------------------- +Wed Oct 26 09:40:36 UTC 2022 - Dirk Müller + +- update to 3.20.0: + * The option "--vgdb-stop-at=event1,event2,..." accepts the new value abexit. + This indicates to invoke gdbserver when your program exits abnormally + (i.e. with a non zero exit code). + * Fix Rust v0 name demangling. + * The Linux rseq syscall is now implemented as (silently) returning ENOSYS. + * Add FreeBSD syscall wrappers for __specialfd and __realpathat. + * Remove FreeBSD dependencies on COMPAT10, which fixes compatibility with + HardenedBSD + * The option --enable-debuginfod= [default: yes] has been added on + Linux. + * More DWARF5 support as generated by clang14. + +------------------------------------------------------------------- +Wed Aug 3 15:20:42 UTC 2022 - Dirk Müller + +- exclude client-headers from building for non-supported architectures + +------------------------------------------------------------------- +Wed Apr 20 09:39:21 UTC 2022 - Adam Majer + +- fix build on SLE12 + +------------------------------------------------------------------- +Wed Apr 13 15:17:54 UTC 2022 - Dirk Müller + +- spec-cleaner suggested cleanups +- drop unnecessary procps buildrequires + +------------------------------------------------------------------- +Tue Apr 12 19:27:44 UTC 2022 - Dirk Müller + +- update to 3.19.0 (bsc#1204685): + * obsoletes backport 0001-arm64-Mismatch-detected-between-RDMA-and-atomics-fea.patch + on older distributions + * Fix Rust v0 name demangling. + * The Linux rseq syscall is now implemented as (silently) returning ENOSYS. + * Add FreeBSD syscall wrappers for __specialfd and __realpathat. + * Remove FreeBSD dependencies on COMPAT10, which fixes compatibility with HardenedBSD + * see https://valgrind.org/docs/manual/dist.news.html for list of bugfixes +- drop handle-rseq-syscall.patch: upstream + +------------------------------------------------------------------- +Wed Mar 9 10:31:07 UTC 2022 - Dirk Müller + +- add upstream handle-rseq-syscall.patch to fix run with glibc 2.35 + +------------------------------------------------------------------- +Tue Nov 9 00:27:36 UTC 2021 - Chris Bradbury + +- update to 3.18.1 (jsc#SLE-18639): + * 3.18.1 fixes a number of bugs and adds support for glibc-2.34, and for new + platforms x86/FreeBSD and amd64/FreeBSD. Debuginfo reading is faster, and + Rust demangling has been improved. For PPC64, ISA 3.1 support has been + completed, and some newer ARM64 and S390 instructions are also supported. + +------------------------------------------------------------------- +Sat Mar 20 17:27:44 UTC 2021 - Dirk Müller + +- update to 3.17.0 (jsc#SLE-18713): + * 3.17.0 fixes a number of bugs and adds some functional changes: support for GCC + 11, Clang 11, DWARF5 debuginfo, the 'debuginfod' debuginfo server, and + some new instructions for Arm64, S390 and POWER. There are also some tool + updates. +- drop s390x-z14-vector-support.patch + 0001-lmw-lswi-and-related-PowerPC-insns-aren-t-allowed-on.patch: upstream + +------------------------------------------------------------------- +Mon Jan 11 14:20:28 UTC 2021 - Dirk Müller + +- add 0001-lmw-lswi-and-related-PowerPC-insns-aren-t-allowed-on.patch (bsc#1180412) + +------------------------------------------------------------------- +Mon Jan 4 10:55:18 UTC 2021 - Dirk Müller + +- add s390x-z14-vector-support.patch (bsc#1180511) + +------------------------------------------------------------------- +Sun Aug 16 01:22:44 UTC 2020 - Dirk Mueller + +- update to 3.16.1 (jsc#SLE-13769): + * PPC sync instruction L field should only be 2 bits in ISA 3.0 + * vex: the `impossible' happened: expr_is_guardable: unhandled expr +- remove 0001-Power-PC-Fix-extraction-of-the-L-field-for-sync-inst.patch (upstream) + +------------------------------------------------------------------- +Fri Jun 19 08:14:24 UTC 2020 - Michal Suchanek + +- Use autopatch + - Change armv6-support.diff to a/b format + +------------------------------------------------------------------- +Fri Jun 19 07:55:22 UTC 2020 - Dirk Mueller + +- update to 3.16.0: + * Many bugfixes, too many to list here, see NEWS file + - The implicit memcpy done by each call to realloc now counts towards the + read and write counts of resized heap blocks, making those counts higher + and more accurate. + - cg_annotate's --auto and --show-percs options now default to 'yes', because + they are usually wanted. + - callgrind_annotate's --auto and --show-percs options now default to 'yes', + because they are usually wanted. + - The command option --collect-systime has been enhanced to specify + the unit used to record the elapsed time spent during system calls. + The command option now accepts the values no|yes|msec|usec|nsec, + where yes is a synonym of msec. When giving the value nsec, the + system cpu time of system calls is also recorded. + - Several memcheck options are now dynamically changeable. + Use valgrind --help-dyn-options to list them. + - The release 3.15 introduced a backward incompatible change for + some suppression entries related to preadv and pwritev syscalls. + When reading a suppression entry using the unsupported 3.14 format, + valgrind will now produce a warning to say the suppression entry will not + work, and suggest the needed change. + - Significantly fewer false positive errors on optimised code generated by + Clang and GCC. In particular, Memcheck now deals better with the + situation where the compiler will transform C-level "A && B" into "B && A" + under certain circumstances (in which the transformation is valid). + Handling of integer equality/non-equality checks on partially defined + values is also improved on some architectures. + - The exprimental Stack and Global Array Checking tool has been removed. + It only ever worked on x86 and amd64, and even on those it had a + high false positive rate and was slow. An alternative for detecting + stack and global array overruns is using the AddressSanitizer (ASAN) + facility of the GCC and Clang compilers, which require you to rebuild + your code with -fsanitize=address. + - Option -T tells vgdb to output a timestamp in the vgdb information messages. + - The gdbserver monitor commands that require an address and an optional + length argument now accepts the alternate 'C like' syntax "address[length]". + For example, the memcheck command "monitor who_points_at 0x12345678 120" + can now also be given as "monitor who_points_at 0x12345678[120]". + - 001-Add-newer-constants-for-prctl-syscall.patch + 0001-Fix-makefile-consistency-check.patch + 0001-s390x-Add-CPU-model-for-z15.patch + 0001-s390x-Add-models-z14-and-z14-ZR1.patch + 0001-s390x-Clean-up-s390-check-opcodes.pl.patch + 0001-Add-newer-constants-for-prctl-syscall.patch + 0002-Add-support-for-PR_CAPBSET_READ-and-_DROP-syscalls.patch: + dropped as those patches were from upstream and are already in 3.16.0 + - add 0001-Power-PC-Fix-extraction-of-the-L-field-for-sync-inst.patch (bsc#1173135) + +------------------------------------------------------------------- +Mon May 11 12:14:25 UTC 2020 - Dirk Mueller + +- add dhat-use-datadir.patch: + * move the dhat* scripts to datadir + +------------------------------------------------------------------- +Wed Mar 25 12:15:59 UTC 2020 - Martin Liška + +- Add parallel-lto.patch in order to make LTO LTRANS phase + parallel. It will significantly improve build time. + +------------------------------------------------------------------- +Thu Mar 12 08:56:24 UTC 2020 - Dirk Mueller + +- add 0001-Fix-makefile-consistency-check.patch + 0001-s390x-Add-models-z14-and-z14-ZR1.patch + 0001-s390x-Clean-up-s390-check-opcodes.pl.patch + 0001-s390x-Add-CPU-model-for-z15.patch (bsc#1165834) + +------------------------------------------------------------------- +Tue Jan 28 14:02:04 UTC 2020 - Guillaume GARDET + +- Disable %check on %arm as it never passed - boo#1130395 + +------------------------------------------------------------------- +Sun Jan 19 15:43:47 UTC 2020 - Stefan Brüns + +- Add support for PR_CAPBSET_READ/DROP syscalls. Fixes false + error messages with latest libcap 2.30. + * 0001-Add-newer-constants-for-prctl-syscall.patch + * 0002-Add-support-for-PR_CAPBSET_READ-and-_DROP-syscalls.patch + +------------------------------------------------------------------- +Wed Nov 27 14:17:11 UTC 2019 - Dirk Mueller + +- remove jit-register-unregister.diff (fails patch not applied check) + +------------------------------------------------------------------- +Tue Oct 29 12:10:39 UTC 2019 - Dirk Mueller + +- move s390-*xml files to main package (bsc#1147071) + +------------------------------------------------------------------- +Tue Oct 22 16:46:06 UTC 2019 - Stefan Brüns + +- Use _multibuild for creating the client-headers subpackage. As + the headers are just copied over, the package has no substantial + build dependencies. + +------------------------------------------------------------------- +Thu Oct 17 22:43:21 UTC 2019 - Stefan Brüns + +- Move the BSD-style licensed client headers to a subpackage. + Packages only requiring e.g. valgrind.h during build no longer + need the full valgrind and valgrind-devel packages then. +- Clean up documentation a bit: + + use %build_cond, drop unused docbook_4 BuildRequires + + remove the Postscript Valgrind manual in favor of the PDF one. +- Add GFDL-1.2 to the License, relevant for man pages and Valgrind + PDF/HTML manual. + +------------------------------------------------------------------- +Wed May 8 15:36:12 UTC 2019 - Dirk Mueller + +- update to 3.15.0 (fate#327402) (jira SLE-5861): + 3.15.0 is a feature release with many improvements and the usual collection of + bug fixes. + + This release supports X86/Linux, AMD64/Linux, ARM32/Linux, ARM64/Linux, + PPC32/Linux, PPC64BE/Linux, PPC64LE/Linux, S390X/Linux, MIPS32/Linux, + MIPS64/Linux, ARM/Android, ARM64/Android, MIPS32/Android, X86/Android, + X86/Solaris, AMD64/Solaris and AMD64/MacOSX 10.12. There is also preliminary + support for X86/macOS 10.13 and AMD64/macOS 10.13. + + * ==================== CORE CHANGES =================== + + * The XTree Massif output format now makes use of the information obtained + when specifying --read-inline-info=yes. + + * amd64 (x86_64): the RDRAND and F16C insn set extensions are now supported. + + * ==================== TOOL CHANGES ==================== + + * DHAT: + + - DHAT been thoroughly overhauled, improved, and given a GUI. As a result, + it has been promoted from an experimental tool to a regular tool. Run it + with --tool=dhat instead of --tool=exp-dhat. + + - DHAT now prints only minimal data when the program ends, instead writing + the bulk of the profiling data to a file. As a result, the --show-top-n + and --sort-by options have been removed. + + - Profile results can be viewed with the new viewer, dh_view.html. When + a run ends, a short message is printed, explaining how to view the result. + + - See the documentation for more details. + + * Cachegrind: + + - cg_annotate has a new option, --show-percs, which prints percentages next + to all event counts. + + * Callgrind: + + - callgrind_annotate has a new option, --show-percs, which prints percentages + next to all event counts. + + - callgrind_annotate now inserts commas in call counts, and + sort the caller/callee lists in the call tree. + + * Massif: + + - The default value for --read-inline-info is now "yes" on + Linux/Android/Solaris. It is still "no" on other OS. + + * Memcheck: + + - The option --xtree-leak=yes (to output leak result in xtree format) + automatically activates the option --show-leak-kinds=all, as xtree + visualisation tools such as kcachegrind can in any case select what kind + of leak to visualise. + + - There has been further work to avoid false positives. In particular, + integer equality on partially defined inputs (C == and !=) is now handled + better. + +- remove 0001-Bug-385411-s390x-Add-z13-vector-floating-point-suppo.patch + 0001-Bug-385411-s390x-Tests-and-internals-for-z13-vector-.patch + 0001-Bug-397187-s390x-Add-vector-register-support-for-vgd.patch + 0001-Bug-399444-s390x-Drop-unnecessary-check-in-s390_irge.patch + 0001-Bug-400490-s390x-Fix-register-allocation-for-VRs-vs-.patch + 0001-Bug-400491-s390x-Sign-extend-immediate-operand-of-LO.patch + 0001-Bug-402519-POWER-3.0-addex-instruction-incorrectly-i.patch + 0001-Bug-403552-s390x-Fix-vector-facility-bit-number.patch + 0001-s390x-more-fixes.patch + Implement-emulated-system-registers.-Fixes-392146.patch (all upstream) + +------------------------------------------------------------------- +Wed Apr 24 17:43:06 UTC 2019 - Martin Liška + +- Disable LTO (boo#1133288). + +------------------------------------------------------------------- +Tue Feb 19 21:54:58 UTC 2019 - Dirk Mueller + +- add 0001-Bug-385411-s390x-Add-z13-vector-floating-point-suppo.patch + 0001-Bug-385411-s390x-Tests-and-internals-for-z13-vector-.patch + 0001-Bug-399444-s390x-Drop-unnecessary-check-in-s390_irge.patch + 0001-Bug-403552-s390x-Fix-vector-facility-bit-number.patch (bsc#1124111) + +------------------------------------------------------------------- +Sat Feb 9 08:41:25 UTC 2019 - schwab@suse.de + +- Don't package files twice on ppc64 + +------------------------------------------------------------------- +Wed Jan 16 16:23:35 UTC 2019 - Michal Suchanek + +- Fix POWER9 addex instruction emulation (bsc#1121025). + 0001-Bug-402519-POWER-3.0-addex-instruction-incorrectly-i.patch + +------------------------------------------------------------------- +Fri Jan 11 12:30:42 UTC 2019 - Dirk Mueller + +- split into a -32bit subpackage, fix buildrequires for older distros + +------------------------------------------------------------------- +Thu Dec 6 02:53:30 UTC 2018 - Bernhard Wiedemann + +- drop unreproducible unused .a files to make the package build + reproducible (boo#1118163) + +------------------------------------------------------------------- +Sun Nov 25 21:06:20 UTC 2018 - olaf@aepfle.de + +- update valgrind.xen.patch to branch bug390553-20181125-ddfc274b2 + +------------------------------------------------------------------- +Thu Nov 22 09:21:45 UTC 2018 - Dirk Mueller + +- build against Toolchain module for SLE12 +- add 0001-Bug-397187-s390x-Add-vector-register-support-for-vgd.patch + 0001-Bug-400490-s390x-Fix-register-allocation-for-VRs-vs-.patch, + 0001-Bug-400491-s390x-Sign-extend-immediate-operand-of-LO.patch, + 0001-s390x-more-fixes.patch, + Implement-emulated-system-registers.-Fixes-392146.patch (FATE#326355) +- enable check (poo#36751) + +------------------------------------------------------------------- +Wed Nov 21 11:51:45 UTC 2018 - Dirk Mueller + +- update to 3.14.0 (bsc#1114575, FATE#326355): + see http://www.valgrind.org/docs/manual/dist.news.html + * The new option --keep-debuginfo=no|yes (default no) can be used to retain + debug info for unloaded code. This allows saved stack traces (e.g. for + memory leaks) to include file/line info for code that has been dlclose'd (or + similar). See the user manual for more information and known limitations. + * Ability to specify suppressions based on source file name and line number. + * Majorly overhauled register allocator. No end-user changes, but the JIT + generates code a bit more quickly now. + * Preliminary support for macOS 10.13 has been added. + * mips: support for MIPS32/MIPS64 Revision 6 has been added. + * mips: support for MIPS SIMD architecture (MSA) has been added. + * mips: support for MIPS N32 ABI has been added. + * s390: partial support for vector instructions (integer and string) has been + added. + * Helgrind: Addition of a flag + --delta-stacktrace=no|yes [yes on linux amd64/x86] + which specifies how full history stack traces should be computed. + Setting this to =yes can speed up Helgrind by 25% when using + --history-level=full. + * Memcheck: reduced false positive rate for optimised code created by Clang 6 + / LLVM 6 on x86, amd64 and arm64. In particular, Memcheck analyses code + blocks more carefully to determine where it can avoid expensive definedness + checks without loss of precision. This is controlled by the flag + --expensive-definedness-checks=no|auto|yes [auto]. + * Valgrind is now buildable with link-time optimisation (LTO). A new + configure option --enable-lto=yes allows building Valgrind with LTO. If the + toolchain supports it, this produces a smaller/faster Valgrind (up to 10%). + Note that if you are doing Valgrind development, --enable-lto=yes massively + slows down the build process. +- remove epoll-wait-fix.patch, + Fix-access-to-time-base-register-to-return-64-bits.patch, + 0001-Accept-read-only-PT_LOAD-segments-and-.rodata.patch (upstream), + +------------------------------------------------------------------- +Tue Sep 25 16:32:22 UTC 2018 - Michal Suchanek + +- valgrind truncates powerpc timebase to 32-bits (bsc#1109589). + Fix-access-to-time-base-register-to-return-64-bits.patch + +------------------------------------------------------------------- +Thu Sep 13 05:08:58 UTC 2018 - dmueller@suse.com + +- valgrind.xen.patch: refresh + +------------------------------------------------------------------- +Tue Aug 28 19:39:14 UTC 2018 - stefan.bruens@rwth-aachen.de + +- Filter out -m64 from optflags, breaks build of 32 bit parts +- Cleanup, remove suse_version < 1100 conditionals +- Use %license for COPYING, COPYING.DOCS + +------------------------------------------------------------------- +Mon Aug 27 22:22:17 UTC 2018 - stefan.bruens@rwth-aachen.de + +- Fix missing debuginfo with current binutils, boo#1103239 + 0001-Accept-read-only-PT_LOAD-segments-and-.rodata.patch + +------------------------------------------------------------------- +Fri Jun 8 08:07:03 UTC 2018 - mbrugger@suse.com + +- ad Implement-emulated-system-registers.-Fixes-392146.patch (bsc#1086543) + +------------------------------------------------------------------- +Thu Feb 22 13:07:05 UTC 2018 - olaf@aepfle.de + +- add valgrind.xen.patch to handle Xen 4.10 (fate#321394, fate#322686) + +------------------------------------------------------------------- +Mon Oct 30 11:00:12 UTC 2017 - dmueller@suse.com + +- add epoll-wait-fix.patch (bsc#1064958) + +------------------------------------------------------------------- +Sun Jun 25 11:06:19 UTC 2017 - dmueller@suse.com + +- update to 3.13.0 (fate#321455): + - remove fix-ppcl64-clobber-list.patch + 3.13.0 is a feature release with many improvements and the + usual collection of bug fixes. + See http://valgrind.org/docs/manual/dist.news.html + +------------------------------------------------------------------- +Tue Apr 25 07:57:46 UTC 2017 - mliska@suse.cz + +- Add fix-ppcl64-clobber-list.patch: fix clobber list on ppcl64le, + it's backport of upstream patch. + +------------------------------------------------------------------- +Tue Dec 27 21:48:56 UTC 2016 - foss@grueninger.de + +- update to 3.12.0 (bsc#1017016, FATE#321455, bsc#987635, CVE-2016-6131) + * 3.12.0 is a feature release with many improvements and the usual + collection of bug fixes. The full changelog can be found at + http://valgrind.org/docs/manual/dist.news.html + or + /usr/share/doc/packages/valgrind/NEWS +- droped patches which are part of the release: + gcc5.patch, r15702.diff, r15792.diff, r15802.diff, svn-r15766.patch, + vex-r3197.diff, vex-r3210.diff, vex-r3213.diff + +------------------------------------------------------------------- +Thu Oct 20 00:42:48 UTC 2016 - stefan.bruens@rwth-aachen.de + +- add vex-r3213.diff (kde#356393) + +------------------------------------------------------------------- +Sat May 28 11:01:13 UTC 2016 - dmueller@suse.com + +- add vex-r3197.diff (bsc#981447) + +------------------------------------------------------------------- +Wed Apr 20 09:13:09 UTC 2016 - jslaby@suse.com + +- The previous did not help, remove -strong first. + +------------------------------------------------------------------- +Tue Apr 19 09:49:36 UTC 2016 - meissner@suse.com + +- also remove -fstack-protector-strong from the CFLAGS + +------------------------------------------------------------------- +Fri Apr 1 10:37:37 UTC 2016 - dmueller@suse.com + +- add r15702.diff, r15792.diff, vex-r3210.diff, r15802.diff (fate#319608) + +------------------------------------------------------------------- +Mon Feb 22 14:21:40 UTC 2016 - schwab@suse.de + +- glibc-version.patch: removed, no longer needed + +------------------------------------------------------------------- +Mon Feb 15 16:04:59 UTC 2016 - dmueller@suse.com + +- update to 3.11.0 (fate#319608): + * 3.11.0 is a feature release with many improvements and the usual + collection of bug fixes. +- replace gcc-version.patch with gcc5.patch: This is the upstream + version +- drop valgrind-linux-4.0.patch: merged upstream +- add svn-r15766.patch: Fix valgrind with recent kernels +- jit-register-unregister.diff commented out, needs porting + +------------------------------------------------------------------- +Thu Aug 6 12:09:47 UTC 2015 - schwab@suse.de + +- glibc-version.patch: Add support for glibc 2.22. + +------------------------------------------------------------------- +Fri Apr 24 07:08:01 UTC 2015 - dimstar@opensuse.org + +- Add valgrind-linux-4.0.patch: Fix build with linux kernel 4.0+. + Taken from svn, rev 14955. + +------------------------------------------------------------------- +Thu Apr 2 18:07:55 UTC 2015 - mpluskal@suse.com + +- Cleanup spec file with spec-cleaner +- Update to 3.10.1 + * bugfix release (for full list of solved issues see NEWS file) + +------------------------------------------------------------------- +Thu Feb 12 11:46:20 UTC 2015 - rguenther@suse.com + +- gcc-version.patch: Add support for GCC 5. + +------------------------------------------------------------------- +Mon Feb 9 13:41:38 UTC 2015 - schwab@suse.de + +- glibc-version.patch: Add support for glibc 2.21. + +------------------------------------------------------------------- +Tue Sep 16 15:39:34 UTC 2014 - schwab@suse.de + +- glibc-2.19.patch: already upstream, so remove +- Fix file list + +------------------------------------------------------------------- +Tue Sep 16 15:27:20 UTC 2014 - dmueller@suse.com + +- update to 3.10.0: + * Support for the 64-bit ARM Architecture (AArch64 ARMv8). This port + is mostly complete, and is usable, but some SIMD instructions are as + yet unsupported. + * Support for little-endian variant of the 64-bit POWER architecture. + * Support for Android on MIPS32. + * Support for 64bit FPU on MIPS32 platforms. + * Both 32- and 64-bit executables are supported on MacOSX 10.8 and 10.9. + * Configuration for and running on Android targets has changed. + See README.android in the source tree for details. + - drop VEX-r2803.diff, VEX-r2808.diff, VEX-r2816.diff, VEX-r2858.diff, + VEX-r2904.diff, VEX-r2910.diff, VEX-r2914.diff, VEX-r2915.diff, + VEX-r2916.diff, aarch64-VEX-support.diff, aarch64-support.diff, + r13767.diff, r13770.diff, r14184.diff, r14238.diff, r14239.diff, + r14240.diff, r14246.diff, r2798.diff, valgrind-r13948.diff + +------------------------------------------------------------------- +Sun Aug 17 21:46:19 UTC 2014 - dmueller@suse.com + +- update for ppc64le support (bnc#880334): + - drop: valgrind-3.9.0-merge.patches.from.Paul.McKenney.patch, + valgrind-3.9.0-ppc64le-abiv2.patch + + - add: VEX-r2803.diff, VEX-r2808.diff, VEX-r2816.diff + VEX-r2904.diff, VEX-r2910.diff, VEX-r2914.diff, VEX-r2915.diff, + VEX-r2916.diff, r13767.diff, r13770.diff, r14184.diff, r14238.diff, + r14239.diff, r14240.diff, r14246.diff + +------------------------------------------------------------------- +Sat Jul 26 18:02:35 UTC 2014 - schwab@suse.de + +- Fix patch conflicts. + +------------------------------------------------------------------- +Wed Jun 18 15:08:53 UTC 2014 - dmueller@suse.com + +- add VEX-r2858.diff, valgrind-r13948.diff for (bnc#883157) + +------------------------------------------------------------------- +Sun May 18 12:34:01 UTC 2014 - schwab@suse.de + +- Update aarch64-support.diff, aarch64-VEX-support.diff from svn + +------------------------------------------------------------------- +Thu Apr 24 08:45:51 UTC 2014 - dmueller@suse.com + +- add aarch64-support.diff, aarch64-VEX-support.diff: aarch64 support + +------------------------------------------------------------------- +Tue Feb 18 14:33:22 UTC 2014 - dmueller@suse.com + +- added patches: + * r2798.diff + +------------------------------------------------------------------- +Tue Feb 11 11:28:45 UTC 2014 - schwab@suse.de + +- glibc-2.19.patch: add support for glibc 2.19 + +------------------------------------------------------------------- +Mon Jan 13 09:12:21 UTC 2014 - normand@linux.vnet.ibm.com + +- add support of ppc64le architecture + +- added patches: + * valgrind-3.9.0-merge.patches.from.Paul.McKenney.patch + * valgrind-3.9.0-ppc64le-abiv2.patch + +------------------------------------------------------------------- +Fri Jan 3 19:26:23 UTC 2014 - dmueller@suse.com + +- add armv6-support.diff: Add support for armv6hl + +------------------------------------------------------------------- +Wed Nov 6 19:43:17 UTC 2013 - burnus@net-b.de + +- update to 3.9.0: +* Support for Intel AVX2 instructions. This is available only on 64 + bit code. +* Support for POWER8 (Power ISA 2.07) instructions. +* Initial support for Intel Transactional Synchronization Extensions, + both RTM and HLE. +* Initial support for Hardware Transactional Memory on POWER. +* Improvements in handling of vectorised code, leading to + significantly fewer false error reports. You need to use the flag + --partial-loads-ok=yes to get the benefits of these changes. +* Better control over the leak checker. It is now possible to + specify which leak kinds (definite/indirect/possible/reachable) + should be displayed. +* Reduced "possible leak" reports from the leak checker by the use + of better heuristics. +* Better control of stacktrace acquisition for heap-allocated + blocks. +* Better reporting of leak suppression usage. +* New and modified GDB server monitor features. +* New flag --sigill-diagnostics to control whether a diagnostic + message is printed when the JIT encounters an instruction it can't + translate. +* The maximum amount of memory that Valgrind can use on 64 bit + targets has been increased from 32GB to 64GB. +* Additional smaller new features and many bug fixes. +- Remove obsolete raise-segnames-limit.diff, + valgrind-glibc-2.17.patch and valgrind-glibc-2.18.patch. + +------------------------------------------------------------------- +Tue Aug 13 15:13:20 UTC 2013 - schwab@suse.de + +- valgrind-glibc-2.18.patch: add support for glibc 2.18 + +------------------------------------------------------------------- +Fri Apr 5 09:56:57 UTC 2013 - idonmez@suse.com + +- Add Source URL, see https://en.opensuse.org/SourceUrls + +------------------------------------------------------------------- +Mon Dec 31 14:26:31 UTC 2012 - idonmez@suse.com + +- Fix last patch + +------------------------------------------------------------------- +Mon Dec 31 09:12:06 UTC 2012 - idonmez@suse.com + +- Add valgrind-glibc-2.17.patch to fix compilation with glibc 2.17 + +------------------------------------------------------------------- +Thu Oct 4 11:36:36 UTC 2012 - dmueller@suse.com + +- raise seglimit to make it more useful for some apps + +------------------------------------------------------------------- +Thu Sep 20 16:34:47 UTC 2012 - burnus@net-b.de + +- update to 3.8.1 (bnc#776211): +* Fixes some assertion failures. +* Support for some missing instructions on ARM. +* Support instructions MOVAPS and TZCNT. +* Bug fixes. + +------------------------------------------------------------------- +Wed Sep 5 15:19:09 UTC 2012 - dmueller@suse.com + +- update to 3.8.0 (FATE#314090): +* Support for MIPS32 platforms running Linux. Valgrind has been + tested on MIPS32 and MIPS32r2 platforms running different Debian + Squeeze and MeeGo distributions. Both little-endian and big-endian + cores are supported. The tools Memcheck, Massif and Lackey have + been tested and are known to work. See README.mips for more details. + +* Preliminary support for Android running on x86. + +* Preliminary (as-yet largely unusable) support for MacOSX 10.8. + +* Support for Intel AVX instructions and for AES instructions. This + support is available only for 64 bit code. + +* Support for POWER Decimal Floating Point instructions. + +* Non-libc malloc implementations are now supported. This is useful + for tools that replace malloc (Memcheck, Massif, DRD, Helgrind). + Using the new option --soname-synonyms, such tools can be informed + that the malloc implementation is either linked statically into the + executable, or is present in some other shared library different + from libc.so. This makes it possible to process statically linked + programs, and programs using other malloc libraries, for example + TCMalloc or JEMalloc. + +* For tools that provide their own replacement for malloc et al, the + option --redzone-size= allows users to specify the size of + the padding blocks (redzones) added before and after each client + allocated block. Smaller redzones decrease the memory needed by + Valgrind. Bigger redzones increase the chance to detect blocks + overrun or underrun. Prior to this change, the redzone size was + hardwired to 16 bytes in Memcheck. +* Memcheck: + + - The leak_check GDB server monitor command now can + control the maximum nr of loss records to output. + + - Reduction of memory use for applications allocating + many blocks and/or having many partially defined bytes. + + - Addition of GDB server monitor command 'block_list' that lists + the addresses/sizes of the blocks of a leak search loss record. + + - Addition of GDB server monitor command 'who_points_at' that lists + the locations pointing at a block. + + - If a redzone size > 0 is given, VALGRIND_MALLOCLIKE_BLOCK now will + detect an invalid access of these redzones, by marking them + noaccess. Similarly, if a redzone size is given for a memory + pool, VALGRIND_MEMPOOL_ALLOC will mark the redzones no access. + This still allows to find some bugs if the user has forgotten to + mark the pool superblock noaccess. + + - Performance of memory leak check has been improved, especially in + cases where there are many leaked blocks and/or many suppression + rules used to suppress leak reports. + + - Reduced noise (false positive) level on MacOSX 10.6/10.7, due to + more precise analysis, which is important for LLVM/Clang + generated code. This is at the cost of somewhat reduced + performance. Note there is no change to analysis precision or + costs on Linux targets. + +* DRD: + + - Added even more facilities that can help finding the cause of a data + race, namely the command-line option --ptrace-addr and the macro + DRD_STOP_TRACING_VAR(x). More information can be found in the manual. + + - Fixed a subtle bug that could cause false positive data race reports. + +* The C++ demangler has been updated so as to work well with C++ + compiled by up to at least g++ 4.6. + +* Tool developers can make replacement/wrapping more flexible thanks + to the new option --soname-synonyms. This was reported above, but + in fact is very general and applies to all function + replacement/wrapping, not just to malloc-family functions. + +* Round-robin scheduling of threads can be selected, using the new + option --fair-sched= yes. Prior to this change, the pipe-based + thread serialisation mechanism (which is still the default) could + give very unfair scheduling. --fair-sched=yes improves + responsiveness of interactive multithreaded applications, and + improves repeatability of results from the thread checkers Helgrind + and DRD. + +* For tool developers: support to run Valgrind on Valgrind has been + improved. We can now routinely Valgrind on Helgrind or Memcheck. + +* gdbserver now shows the float shadow registers as integer + rather than float values, as the shadow values are mostly + used as bit patterns. + +* Increased limit for the --num-callers command line flag to 500. + +* Performance improvements for error matching when there are many + suppression records in use. + +* Improved support for DWARF4 debugging information (bug 284184). + +* Initial support for DWZ compressed Dwarf debug info. + +* Improved control over the IR optimiser's handling of the tradeoff + between performance and precision of exceptions. Specifically, + --vex-iropt-precise-memory-exns has been removed and replaced by + --vex-iropt-register-updates, with extended functionality. This + allows the Valgrind gdbserver to always show up to date register + values to GDB. + +* Modest performance gains through the use of translation chaining for + JIT-generated code. + +------------------------------------------------------------------- +Fri Aug 17 09:39:39 UTC 2012 - burnus@net-b.de + +- Support TZCNT/LZCNT instructions, generated by GCC 4.8, + by falling back to BSF/BSR. (bnc#776211) + +------------------------------------------------------------------- +Sun Jul 22 06:31:31 UTC 2012 - aj@suse.de + +- Support glibc 2.16. + +------------------------------------------------------------------- +Mon Jun 4 17:38:56 UTC 2012 - dmueller@suse.com + +- arch is now armv7hl + +------------------------------------------------------------------- +Tue May 15 12:46:38 UTC 2012 - sndirsch@suse.com + +- add "BuildRequires: pkgconfig" so the provides for + "pkgconfig(valgrind)" gets created again + +------------------------------------------------------------------- +Thu May 10 11:26:37 UTC 2012 - vuntz@opensuse.org + +- Remove xorg-x11-devel BuildRequires: I can only guess it was + there to make sure the xfree supp files are used, but they are + used anyway by default. This helps resolve a build loop between + libdrm and valgrind. + +------------------------------------------------------------------- +Thu Apr 26 17:41:44 UTC 2012 - joop.boonen@opensuse.org + +- Added patch valgrind-3.7.0-automake-1.11.2.patch to fix automake issue + * See https://bugs.kde.org/show_bug.cgi?id=290719 + +------------------------------------------------------------------- +Thu Dec 29 09:33:04 CET 2011 - dmueller@suse.de + +- fix build against glibc 2.15 + +------------------------------------------------------------------- +Mon Dec 19 06:53:32 UTC 2011 - adrian@suse.de + +- build only on armv7l, not armv5 + +------------------------------------------------------------------- +Wed Nov 30 10:25:38 UTC 2011 - coolo@suse.com + +- add automake as buildrequire to avoid implicit dependency + +------------------------------------------------------------------- +Wed Nov 9 20:01:00 CET 2011 - dmueller@suse.de + +- update to 3.7.0 (bnc#724215): + * Support for IBM z/Architecture (s390x) running Linux. Valgrind can + analyse 64-bit programs running on z/Architecture. Most user space + instructions up to and including z10 are supported. + See README.s390 for more details. + * Support for the IBM Power ISA 2.06 (Power7 instructions) + * Further solidification of support for SSE 4.2 in 64-bit mode + * Memcheck: + * - reduction of memory use in some circumstances + * - improved handling of freed memory for finding more errors + * - fix of a longstanding bug that could cause false negatives + * Helgrind: + * - Helgrind: performance improvements and major memory use reductions + * GDB server: Valgrind now has an embedded GDB server. That means it + is possible to control a Valgrind run from GDB, doing all the usual + things that GDB can do (single stepping, breakpoints, examining + data, etc). Tool-specific functionality is also available. + * Over 160 bugs have been fixed. + +------------------------------------------------------------------- +Tue Oct 25 01:14:42 CEST 2011 - ro@suse.de + +- fix build on ppc (32bit) + +------------------------------------------------------------------- +Sun Oct 2 17:50:41 CEST 2011 - dmueller@suse.de + +- enable build on %%arm + +------------------------------------------------------------------- +Fri Aug 19 19:24:37 CEST 2011 - dmueller@suse.de + +- fix build against glibc 2.14 +- require the right version of glibc at runtime (part of fix for bnc#700362) + +------------------------------------------------------------------- +Tue Jul 5 13:09:46 UTC 2011 - aj@suse.de + +- Support Linux kernel 3.x (bnc#724215) + +------------------------------------------------------------------- +Wed Jun 22 18:54:13 UTC 2011 - dmueller@suse.de + +- fix merge error + +------------------------------------------------------------------- +Sat Jun 18 17:09:08 UTC 2011 - dmueller@suse.de + +- Improve Valgrind POWER6 and POWER7/P7 support (bnc#700358) + +------------------------------------------------------------------- +Tue May 17 11:46:04 UTC 2011 - stefan.bruens@rwth-aachen.de + +- revert removal for gcc-32bit requirement, breaks valgrinding + 32bit code on 64bit archs (bnc#705405) + +------------------------------------------------------------------- +Mon Apr 11 13:11:43 CEST 2011 - dmueller@suse.de + +- fix testsuite for s390 (kde#264800, kde#265762, kde#253206) +- Add folding rules for Clz32 and Clz64 (kde#243404) +- Refresh s390x port (kde#243404) + +------------------------------------------------------------------- +Wed Mar 16 11:23:54 CET 2011 - dmueller@suse.de + +- update to 3.6.1 (bnc#679106): + 3.6.1 is a bug fix release. It adds support for some SSE4 + instructions that were omitted in 3.6.0 due to lack of time. Initial + support for glibc-2.13 has been added. A number of bugs causing + crashing or assertion failures have been fixed. + +------------------------------------------------------------------- +Fri Oct 22 09:59:53 CEST 2010 - dmueller@suse.de + +- update to 3.6.0: + 3.6.0 is a feature release with many significant improvements and the + usual collection of bug fixes. See the NEWS file for details. + +------------------------------------------------------------------- +Thu Oct 21 13:17:43 CEST 2010 - dmueller@suse.de + +- apparently gcc-32bit does not exist on old code streams, but + it seems to work without it as well + +------------------------------------------------------------------- +Wed Oct 20 19:38:57 CEST 2010 - dmueller@suse.de + +- disable building docs until I find a way to build them without + network access + +------------------------------------------------------------------- +Wed Oct 13 13:42:05 CEST 2010 - dmueller@suse.de + +- add s390x port (FATE#310036) + +- update to 3.6.0 snapshot: + - Valgrind runs much faster when the --smc-check=all option is given. + + - Cachegrind has a new processing script, cg_diff, which finds the + difference between two profiles. It's very useful for evaluating the + performance effects of a change in a program. + + Related to this change, the meaning of cg_annotate's (rarely-used) + --threshold option has changed; this is unlikely to affect many people, if + you do use it please see the user manual for details. + + - Callgrind now can do branch prediction simulation, similar to Cachegrind. + In addition, it optionally can count the number of executed global bus events. + Both can be used for a better approximation of a "Cycle Estimation" as + derived event (you need to update the event formula in KCachegrind yourself). + + - Cachegrind and Callgrind now refer to the LL (last-level) cache rather + than the L2 cache. This is to accommodate machines with three levels of + caches -- if Cachegrind/Callgrind auto-detects the cache configuration of + such a machine it will run the simulation as if the L2 cache isn't + present. This means the results are less likely to match the true result + for the machine, but Cachegrind/Callgrind's results are already only + approximate, and should not be considered authoritative. The results are + still useful for giving a general idea about a program's locality. + + - Massif has a new option, --pages-as-heap, which is disabled by default. + When enabled, instead of tracking allocations at the level of heap blocks + (as allocated with malloc/new/new[]), it instead tracks memory allocations + at the level of memory pages (as mapped by mmap, brk, etc). Each mapped + page is treated as its own block. Interpreting the page-level output is + harder than the heap-level output, but this option is useful if you want + to account for every byte of memory used by a program. + + - Added new memcheck command-line option --show-possibly-lost. + + - Support for analyzing programs running under Wine with has been improved. + The header files , and + can now be used in Windows-programs compiled with MinGW + or one of the Microsoft Visual Studio compilers. + + - DRD does now have two new command-line options: --free-is-write and + --trace-alloc. The former allows to detect reading from already freed + memory, and the latter allows to trace all memory allocations and + deallocations. + + - Several new annotations have been added in DRD: custom barrier + implementations can now be annotated and benign races on static variables + too. + + - The happens before / happens after annotations in DRD have been made more + powerful such that these can now also be used to annotate e.g. a smart + pointer implementation. + +------------------------------------------------------------------- +Thu Sep 23 13:16:16 CEST 2010 - dmueller@suse.de + +- increase stack size (bnc#640793) + +------------------------------------------------------------------- +Fri May 7 13:44:18 CEST 2010 - dmueller@suse.de + +- fix build for ppc64 + +------------------------------------------------------------------- +Mon Apr 26 16:14:02 CEST 2010 - dmueller@suse.de + +- handle pthread apps better (bnc#599585) +- prefer CFI for better stack unwinding (bnc#559061) + +------------------------------------------------------------------- +Fri Mar 26 13:56:19 CET 2010 - dmueller@suse.de + +- handle inotify_init1 (bnc#558964) + +------------------------------------------------------------------- +Wed Jan 6 17:54:54 CET 2010 - dmueller@suse.de + +- fix build against glibc 2.11 + +------------------------------------------------------------------- +Wed Dec 2 22:25:34 CET 2009 - dmueller@suse.de + +- update and reenable jit-register-unregister.diff + +------------------------------------------------------------------- +Tue Nov 3 19:09:50 UTC 2009 - coolo@novell.com + +- updated patches to apply with fuzz=0 + +------------------------------------------------------------------- +Tue Sep 8 09:34:49 CEST 2009 - dmueller@suse.de + +- update to 3.5.0: + * Support for glibc 2.10, gcc 4.5 has been added. + * Improvements and simplifications to Memcheck's leak checker. + * Clarification and simplifications in various aspects of Valgrind's + text output. + * XML output for Helgrind and Ptrcheck. + * Performance and stability improvements for Helgrind and DRD. + * Genuinely atomic support for x86/amd64/ppc atomic instructions. + * A new experimental tool, BBV, useful for computer architecture + research. + * Improved Wine support, including ability to read Windows PDB + debuginfo. + +------------------------------------------------------------------- +Fri Mar 13 01:52:58 CET 2009 - dmueller@suse.de + +- update to 3.4.1 (bnc#479701): + * 3.4.1 is a bug-fix release that fixes some regressions and + assertion failures in debug info reading in 3.4.0, most notably + incorrect stack traces on amd64-linux on older (glibc-2.3 based) + systems. Various other debug info problems are also fixed. A + number of bugs in the exp-ptrcheck tool introduced in 3.4.0 + have been fixed. + +------------------------------------------------------------------- +Fri Jan 23 01:52:58 CET 2009 - dmueller@suse.de + +- update to 3.4.0: + * http://www.valgrind.org/docs/manual/dist.news.html + +------------------------------------------------------------------- +Sun Nov 23 00:45:36 CET 2008 - dmueller@suse.de + +- update suppressions + +------------------------------------------------------------------- +Thu Nov 20 00:32:49 CET 2008 - dmueller@suse.de + +- fix .valgrindrc reading vulnerability (CVE-2008-4865, bnc#445013) +- add support for glibc 2.9 + +------------------------------------------------------------------- +Wed Nov 5 13:58:49 CET 2008 - dmueller@suse.de + +- add syscall wrappers for pipe2 + +------------------------------------------------------------------- +Tue Jun 24 20:42:50 CEST 2008 - schwab@suse.de + +- Add fadvice64 wrapper. + +------------------------------------------------------------------- +Sun Jun 22 21:27:30 CEST 2008 - dmueller@suse.de + +- update to 3.3.1: + n-i-bz Massif segfaults at exit + n-i-bz Memcheck asserts on Altivec code + n-i-bz fix sizeof bug in Helgrind + n-i-bz check fd on sys_llseek + n-i-bz update syscall lists to kernel 2.6.23.1 + n-i-bz support sys_sync_file_range + n-i-bz handle sys_sysinfo, sys_getresuid, sys_getresgid on ppc64-linux + n-i-bz intercept memcpy in 64-bit ld.so's + n-i-bz Fix wrappers for sys_{futimesat,utimensat} + n-i-bz Minor false-error avoidance fixes for Memcheck + n-i-bz libmpiwrap.c: add a wrapper for MPI_Waitany + n-i-bz helgrind support for glibc-2.8 + n-i-bz partial fix for mc_leakcheck.c:698 assert: + 'lc_shadows[i]->data + lc_shadows[i] ... + n-i-bz Massif/Cachegrind output corruption when programs fork + n-i-bz register allocator fix: handle spill stores correctly + n-i-bz add support for PA6T PowerPC CPUs + 126389 vex x86->IR: 0xF 0xAE (FXRSTOR) + 158525 ==126389 + 152818 vex x86->IR: 0xF3 0xAC (repz lodsb) + 153196 vex x86->IR: 0xF2 0xA6 (repnz cmpsb) + 155011 vex x86->IR: 0xCF (iret) + 155091 Warning [...] unhandled DW_OP_ opcode 0x23 + 156960 ==155901 + 155528 support Core2/SSSE3 insns on x86/amd64 + 155929 ms_print fails on massif outputs containing long lines + 157665 valgrind fails on shmdt(0) after shmat to 0 + 157748 support x86 PUSHFW/POPFW + 158212 helgrind: handle pthread_rwlock_try{rd,wr}lock. + 158425 sys_poll incorrectly emulated when RES==0 + 158744 vex amd64->IR: 0xF0 0x41 0xF 0xC0 (xaddb) + 160907 Support for a couple of recent Linux syscalls + 161285 Patch -- support for eventfd() syscall + 161378 illegal opcode in debug libm (FUCOMPP) + 160136 ==161378 + 161487 number of suppressions files is limited to 10 + 162386 ms_print typo in milliseconds time unit for massif + 161036 exp-drd: client allocated memory was never freed + 162663 signalfd_wrapper fails on 64bit linux + +------------------------------------------------------------------- +Mon Apr 28 00:33:35 CEST 2008 - dmueller@suse.de + +- update glibc 2.8 support + +------------------------------------------------------------------- +Sun Dec 16 15:52:17 CET 2007 - dmueller@suse.de + +- readd deprecated #define's (#348337) + +------------------------------------------------------------------- +Wed Dec 12 00:19:19 CET 2007 - dmueller@suse.de + +- update to 3.3.0 (final): + * last minute bugfixes + +------------------------------------------------------------------- +Thu Dec 6 02:05:38 CET 2007 - dmueller@suse.de + +- update jit-support patch + +------------------------------------------------------------------- +Mon Dec 3 21:37:39 CET 2007 - dmueller@suse.de + +- update to 3.3.0 RC1: + - Helgrind works again + - Massif has been majorly overhauled + - Cachegrind now does branch-prediction profiling + - New experimental tools Omega and DRD + - Many small refinements to stability, scalability and performance + - Somewhat restructured documentation + - Many bug fixes + +------------------------------------------------------------------ +Mon Nov 26 16:14:00 CET 2007 - dmueller@suse.de + +- fix build against glibc 2.7 + +------------------------------------------------------------------- +Fri Sep 14 11:09:27 CEST 2007 - dmueller@suse.de + +- fix divisions by zero in massif (#310234) + +------------------------------------------------------------------- +Wed Sep 12 15:26:43 CEST 2007 - dmueller@suse.de + +- fix build on ppc64 again +- update suppressions + +------------------------------------------------------------------- +Fri Aug 24 15:28:26 CEST 2007 - dmueller@suse.de + +- fix valgrind on x86_64 (#296803) + +------------------------------------------------------------------- +Tue Aug 21 22:29:36 CEST 2007 - dmueller@suse.de + +- suppression update + +------------------------------------------------------------------- +Tue Jul 24 01:33:09 CEST 2007 - dmueller@suse.de + +- update suppression file + +------------------------------------------------------------------- +Mon Jul 9 17:50:59 CEST 2007 - dmueller@suse.de + +- support JIT runtimes (#289490) + +------------------------------------------------------------------- +Tue Jul 3 12:38:13 CEST 2007 - dmueller@suse.de + +- update suppression file (#287090) + +------------------------------------------------------------------- +Wed May 23 19:34:13 CEST 2007 - dmueller@suse.de + +- build against glibc 2.6 + +------------------------------------------------------------------- +Thu Apr 5 16:09:51 CEST 2007 - dmueller@suse.de + +- split into -devel subpackage + +------------------------------------------------------------------- +Fri Mar 30 11:41:19 CEST 2007 - dmueller@suse.de + +- add patch to track undefinedness in environment (#249676) + +------------------------------------------------------------------- +Tue Jan 30 14:22:31 CET 2007 - dmueller@suse.de + +- update to 3.2.3: + * fixes two serious regressions introduced in 3.2.2 + * intercept stpcpy_chk (#234247) +- fix openat syscall wrapper (#240225) + +------------------------------------------------------------------- +Thu Jan 25 15:08:36 CET 2007 - dmueller@suse.de + +- intercept stpcpy_chk and memrchr as well (#234347) + +------------------------------------------------------------------- +Tue Jan 23 10:59:24 CET 2007 - dmueller@suse.de + +- switch to gcc-32bit on x86_64 + +------------------------------------------------------------------- +Mon Jan 22 17:07:04 CET 2007 - dmueller@suse.de + +- update to 3.2.2: + * many fixes for ppc 32/64 (#fate 301640) + +------------------------------------------------------------------- +Tue Oct 17 11:09:11 CEST 2006 - dmueller@suse.de + +- disable omega plugin for ppc/ppc64 + +------------------------------------------------------------------- +Mon Oct 16 19:34:44 CEST 2006 - dmueller@suse.de + +- update to 3.2 BRANCH: + * support glibc 2.5 + * update suppressions +- add omega plugin + +------------------------------------------------------------------- +Sat Sep 16 01:28:38 CEST 2006 - dmueller@suse.de + +- update to 3.2.1: + * suppresion updates + +------------------------------------------------------------------- +Fri Sep 15 14:09:05 CEST 2006 - dmueller@suse.de + +- update to 3.2.1rc1: + * about 36 bugfixes + +------------------------------------------------------------------- +Wed Sep 13 17:26:19 CEST 2006 - stbinner@suse.de + +- fix build with < Factory + +------------------------------------------------------------------- +Mon Aug 28 13:37:11 CEST 2006 - dmueller@suse.de + +- fix suppressions +- update drd plugin + +------------------------------------------------------------------- +Thu Aug 24 14:52:38 CEST 2006 - dmueller@suse.de + +- add experimental drd plugin +- fix build on x86_64 + +------------------------------------------------------------------- +Wed Aug 2 14:47:08 CEST 2006 - dmueller@suse.de + +- also fix multibyte NOP parsing for x86_64 + +------------------------------------------------------------------- +Tue Aug 1 03:18:28 CEST 2006 - dmueller@suse.de + +- add patch to handle multibyte NOPs as generated by + recent binutils + +------------------------------------------------------------------- +Wed Jun 7 11:26:29 CEST 2006 - dmueller@suse.de + +- update to 3.2.0 final + * only marginal changes since rc1 + +------------------------------------------------------------------- +Tue May 30 16:23:03 CEST 2006 - dmueller@suse.de + +- update to 3.2.0 rc1: + * ppc64 support + * callgrind now integrated part + * massive performance improvements + * lots of emulation fixlets + +------------------------------------------------------------------- +Thu Mar 16 10:30:52 CET 2006 - dmueller@suse.de + +- update to 3.1.1 (FATE #300493) + +------------------------------------------------------------------- +Wed Mar 6 16:31:21 CET 2006 - dmueller@suse.de + +- various updates from branch to fix PPC32 support + +------------------------------------------------------------------- +Mon Feb 6 19:49:33 CET 2006 - dmueller@suse.de + +- Fix GDB support + +------------------------------------------------------------------- +Mon Feb 6 10:19:24 CET 2006 - dmueller@suse.de + +- Reduce BuildRequires + +------------------------------------------------------------------- +Wed Jan 25 21:42:29 CET 2006 - mls@suse.de + +- converted neededforbuild to BuildRequires + +------------------------------------------------------------------- +Wed Jan 4 15:43:14 CET 2006 - dmueller@suse.de + +- update to 3.1 branch + +------------------------------------------------------------------- +Fri Dec 9 19:08:38 CET 2005 - dmueller@suse.de + +- fix strict-aliasing issue + +------------------------------------------------------------------- +Mon Nov 28 11:13:31 CET 2005 - dmueller@suse.de + +- 3.1.0 final update + +------------------------------------------------------------------- +Mon Nov 21 10:53:55 CET 2005 - dmueller@suse.de + +- 3.1.0 RC1 update + +------------------------------------------------------------------- +Thu Nov 10 02:05:13 CET 2005 - dmueller@suse.de + +- update to 3.1 SVN + +------------------------------------------------------------------- +Tue Nov 8 18:29:27 CET 2005 - dmueller@suse.de + +- add hack to make valgrind work with apps that require executable stack + +------------------------------------------------------------------- +Thu Sep 15 12:26:01 CEST 2005 - dmueller@suse.de + +- update 3.0.1 final + +------------------------------------------------------------------- +Thu Aug 25 01:52:35 CEST 2005 - dmueller@suse.de + +- make massif work again + +------------------------------------------------------------------- +Sun Aug 21 03:36:37 CEST 2005 - dmueller@suse.de + +- fix trace-children=yes failure +- add default suppressions for SL 10 + +------------------------------------------------------------------- +Mon Aug 15 02:42:20 CEST 2005 - dmueller@suse.de + +- regenerate VEX offset headers, otherwise it just hangs + +------------------------------------------------------------------- +Fri Aug 12 12:54:17 CEST 2005 - dmueller@suse.de + +- update to 3.0 branch to make it work on non-SSE platforms (#104181) + +------------------------------------------------------------------- +Fri Aug 5 15:14:00 CEST 2005 - dmueller@suse.de + +- initial package of 3.0 + diff --git a/valgrind.spec b/valgrind.spec new file mode 100644 index 0000000..4fb522c --- /dev/null +++ b/valgrind.spec @@ -0,0 +1,388 @@ +# +# spec file +# +# Copyright (c) 2023 SUSE LLC +# +# All modifications and additions to the file contributed by third parties +# remain the property of their copyright owners, unless otherwise agreed +# upon. The license for this file, and modifications and additions to the +# file, is the same license as for the pristine package itself (unless the +# license for the pristine package is not an Open Source License, in which +# case the license is the MIT License). An "Open Source License" is a +# license that conforms to the Open Source Definition (Version 1.9) +# published by the Open Source Initiative. + +# Please submit bugfixes or comments via https://bugs.opensuse.org/ +# + + +%if 0%{?!make_build:1} +%define make_build make -O %{?_smp_mflags} V=1 VERBOSE=1 +%endif + +# during building the major version of glibc is built into the suppression file +%define glibc_main_version %(getconf GNU_LIBC_VERSION | cut -d' ' -f2 | cut -d. -f1) +%define glibc_major_version %(getconf GNU_LIBC_VERSION | cut -d' ' -f2 | cut -d. -f2) +%global flavor @BUILD_FLAVOR@%{nil} +%if "%{flavor}" == "client-headers" +%define psuffix -client-headers-source +%endif +%bcond_without docs +Name: valgrind%{?psuffix} +Version: 3.21.0 +Release: 0 +Summary: Memory Management Debugger +License: GFDL-1.2-only AND GPL-2.0-or-later +Group: Development/Tools/Debuggers +URL: https://valgrind.org/ +Source0: https://sourceware.org/pub/valgrind/valgrind-%{version}.tar.bz2 +# https://bugs.kde.org/show_bug.cgi?id=390553 +# https://github.com/olafhering/valgrind/compare/olh-base-master...olh-fixes-master +Patch0: valgrind.xen.patch +# bko#276780 missing implementation for PINSRD +Patch1: VEX-x86-pinsrd.patch +Patch2: armv6-support.diff +Patch9: parallel-lto.patch +Patch10: dhat-use-datadir.patch +BuildRequires: automake +BuildRequires: pkgconfig +%if %{suse_version} == 1600 && !0%{?is_opensuse} +ExclusiveArch: aarch64 x86_64 ppc64le s390x +%else +ExclusiveArch: aarch64 %{ix86} x86_64 ppc ppc64 ppc64le s390x armv7l armv7hl armv6l armv6hl +%endif +%if "%{flavor}" == "" +Requires: (glibc >= %{glibc_main_version}.%{glibc_major_version} with glibc < %{glibc_main_version}.%{lua:print(rpm.expand("%{glibc_major_version}")+1)}) +Provides: callgrind = %{version} +Obsoletes: callgrind < %{version} +%if %{with docs} +BuildRequires: docbook-xsl-stylesheets +BuildRequires: libxslt +%endif +%if 0%{?suse_version} < 1500 +BuildRequires: gcc8-c++ +%global cpp_version -8 +%else +BuildRequires: gcc-c++ +%endif +%if !0%{?disable_32bit} +%ifarch x86_64 ppc64 +BuildRequires: glibc-devel-32bit +%if 0%{?suse_version} < 1500 +BuildRequires: gcc8-c++-32bit +%else +BuildRequires: gcc-c++-32bit +%endif +%endif +%endif +%endif + +%description +Valgrind checks all memory operations in an application, like read, +write, malloc, new, free, and delete. Valgrind can find uses of +uninitialized memory, access to already freed memory, overflows, +illegal stack operations, memory leaks, and any illegal +new/malloc/free/delete commands. Another program in the package is +"cachegrind," a profiler based on the valgrind engine. + +To use valgrind you should compile your application with "-g -O0" +compiler options. Afterwards you can use it with: + +valgrind --tool=memcheck --sloppy-malloc=yes --leak-check=yes +--db-attach=yes my_application, for example. + +More valgrind options can be listed via "valgrind --help". There is +also complete documentation in the %{_docdir}/valgrind/ +directory. A debugged application runs slower and needs much more +memory, but is usually still usable. Valgrind is still in development, +but it has been successfully used to optimize several KDE applications. + +%package devel +Summary: Header files for for Valgrind +License: GPL-2.0-or-later +Group: Development/Tools/Debuggers +Requires: %{name} = %{version} +Requires: %{name}-client-headers = %{version} + +%description devel +This package contains the Valgrind header files. + +%package -n valgrind-client-headers +Summary: Header files for for Valgrind +# The client headers are permissively licensed under a BSD-style +# license. SPDX License Request filed. +# License: BSD-3-Clause +License: GFDL-1.2-only AND GPL-2.0-or-later +Group: Development/Tools/Debuggers +Provides: valgrind-devel:%{_includedir}/valgrind/valgrind.h +BuildArch: noarch + +%description -n valgrind-client-headers +This package contains the BSD-style licensed Valgrind header +files for inclusion into regular programs. The program can +detect if it is running under Valgrind and interact with the +Valgrind core and plugins. + +%ifarch x86_64 ppc64 s390x +%package 32bit +Summary: Memory Management Debugger +License: GPL-2.0-or-later +Group: Development/Tools/Debuggers +Requires: %{name} = %{version} +Provides: valgrind:%{_libdir}/valgrind/32bit-core.xml + +%description 32bit +Valgrind checks all memory operations in an application, like read, +write, malloc, new, free, and delete. Valgrind can find uses of +uninitialized memory, access to already freed memory, overflows, +illegal stack operations, memory leaks, and any illegal +new/malloc/free/delete commands. Another program in the package is +"cachegrind," a profiler based on the valgrind engine. + +To use valgrind you should compile your application with "-g -O0" +compiler options. Afterwards you can use it with: + +valgrind --tool=memcheck --sloppy-malloc=yes --leak-check=yes +--db-attach=yes my_application, for example. + +More valgrind options can be listed via "valgrind --help". There is +also complete documentation in the %{_docdir}/valgrind/ +directory. A debugged application runs slower and needs much more +memory, but is usually still usable. Valgrind is still in development, +but it has been successfully used to optimize several KDE applications. + +%endif + +%prep +%autosetup -p1 -n valgrind-%{version} + +%build +%define _lto_cflags %{nil} +# The preloaded libs for intercepting rely on lazy binding (bsc#1208407) +export SUSE_ZNOW=0 +export FLAGS="%{optflags}" +# not a good idea to build valgrind with fortify, as it does not link glibc +FLAGS="${FLAGS/-D_FORTIFY_SOURCE=2/}" +FLAGS="${FLAGS/-D_FORTIFY_SOURCE=3/}" +FLAGS="${FLAGS/-fstack-protector-strong/}" +FLAGS="${FLAGS/-fstack-protector/}" +# -m64 / -m32 is set explicitly everywhere, do not override it +FLAGS="${FLAGS/-m64/}" +export CFLAGS="$FLAGS" +export CXXFLAGS="$FLAGS" +export FFLAGS="$FLAGS" +export CXX="g++%{?cpp_version}" +export CC="gcc%{?cpp_version}" +autoreconf -fi + +export GDB=%{_bindir}/gdb +%configure \ +%ifnarch ppc64 + --enable-lto=yes \ +%endif +%ifarch aarch64 + --enable-only64bit \ +%endif + %{nil} + +%if "%{flavor}" == "" +%make_build +%if %{with docs} +pushd docs + #make all-docs + # building the docs needs network access at the moment :-( + %make_build FAQ.txt man-pages html-docs +popd +%endif +%endif + +%install +%if "%{flavor}" == "" +%make_install +rm %{buildroot}/%{_libdir}/valgrind/lib*.a # drop unreproducible unused files to fix boo#1118163 + +mkdir -p %{buildroot}/%{_defaultdocdir} +if test -d %{buildroot}%{_datadir}/doc/valgrind; then + # Remove Postscript manual (20 MByte), there are PDF and HTML versions + rm %{buildroot}%{_datadir}/doc/valgrind/valgrind_manual.ps + mv %{buildroot}%{_datadir}/doc/valgrind %{buildroot}/%{_defaultdocdir} +fi +mkdir -p %{buildroot}%{_docdir}/%{name} + +rm %{buildroot}/%{_includedir}/valgrind/{valgrind,callgrind,dhat,drd,helgrind,memcheck}.h + +%else +install -m 755 -d %{buildroot}/%{_includedir}/valgrind +install -m 644 -t %{buildroot}/%{_includedir}/valgrind \ + include/valgrind.h \ + callgrind/callgrind.h \ + dhat/dhat.h \ + drd/drd.h \ + helgrind/helgrind.h \ + memcheck/memcheck.h +%endif + +%check +%if "%{flavor}" == "" +# OBS doesn't have a z13 +%ifnarch s390x %{arm} +# has too many spurious failures +# make %{?_smp_mflags} regtest +#patent pending self test +VALGRIND_LIB=$PWD/.in_place VALGRIND_LIB_INNER=$PWD/.in_place ./coregrind/valgrind %{_bindir}/perl -wc tests/vg_regtest +%endif +%endif + +%if "%{flavor}" == "" +%files devel +%dir %{_includedir}/valgrind +%{_includedir}/valgrind/config.h +%{_includedir}/valgrind/vki +%{_includedir}/valgrind/libvex*.h +%{_includedir}/valgrind/pub_tool*.h +%{_libdir}/pkgconfig/valgrind.pc + +%files -n valgrind +%license COPYING COPYING.DOCS +%{_bindir}/* +%doc README* NEWS AUTHORS +%doc %{_defaultdocdir}/%{name}/* +%{_mandir}/*/* +%dir %{_libexecdir}/valgrind +%ifarch aarch64 +%{_libexecdir}/valgrind/*-arm64-linux +%endif +%ifarch x86_64 +%{_libexecdir}/valgrind/*-amd64-linux +%endif +%ifarch %{ix86} +%{_libexecdir}/valgrind/*-x86-linux +%endif +%ifarch ppc +%{_libexecdir}/valgrind/*-ppc32-linux +%endif +%ifarch ppc64 +%{_libexecdir}/valgrind/*-ppc64be-linux +%endif +%ifarch ppc64le +%{_libexecdir}/valgrind/*-ppc64le-linux +%endif +%ifarch s390x +%{_libexecdir}/valgrind/*-s390x-linux +%endif +%ifarch %{arm} +%{_libexecdir}/valgrind/*-arm-linux +%endif +%dir %{_datadir}/valgrind +%{_datadir}/valgrind/dh_view* +%{_libexecdir}/valgrind/*-linux.so +%{_libexecdir}/valgrind/*.supp +%{_libexecdir}/valgrind/valgrind-monitor-def.py +%{_libexecdir}//valgrind/valgrind-monitor.py +%{_libexecdir}/valgrind/64bit-core.xml +%{_libexecdir}/valgrind/64bit-linux.xml +%{_libexecdir}/valgrind/64bit-sse.xml +%{_libexecdir}/valgrind/64bit-core-valgrind-s*.xml +%{_libexecdir}/valgrind/64bit-linux-valgrind-s*.xml +%{_libexecdir}/valgrind/64bit-sse-valgrind-s*.xml +%{_libexecdir}/valgrind/amd64-coresse-valgrind.xml +%{_libexecdir}/valgrind/amd64-linux-valgrind.xml +%{_libexecdir}/valgrind/power64-core-valgrind-s*.xml +%{_libexecdir}/valgrind/power64-core.xml +%{_libexecdir}/valgrind/power64-core2-valgrind-s*.xml +%{_libexecdir}/valgrind/power64-linux-valgrind-s*.xml +%{_libexecdir}/valgrind/power64-linux.xml +%{_libexecdir}/valgrind/64bit-avx-valgrind-s*.xml +%{_libexecdir}/valgrind/64bit-avx.xml +%{_libexecdir}/valgrind/amd64-avx-coresse-valgrind.xml +%{_libexecdir}/valgrind/amd64-avx-coresse.xml +%{_libexecdir}/valgrind/amd64-avx-linux-valgrind.xml +%{_libexecdir}/valgrind/amd64-avx-linux.xml +%{_libexecdir}/valgrind/mips64-cp0-valgrind-s*.xml +%{_libexecdir}/valgrind/mips64-cp0.xml +%{_libexecdir}/valgrind/mips64-cpu-valgrind-s*.xml +%{_libexecdir}/valgrind/mips64-cpu.xml +%{_libexecdir}/valgrind/mips64-fpu-valgrind-s*.xml +%{_libexecdir}/valgrind/mips64-fpu.xml +%{_libexecdir}/valgrind/mips64-linux-valgrind.xml +%{_libexecdir}/valgrind/mips64-linux.xml +%{_libexecdir}/valgrind/power-core-valgrind-s*.xml +%{_libexecdir}/valgrind/s390x-core64-valgrind-s*.xml +%{_libexecdir}/valgrind/s390x-core64.xml +%{_libexecdir}/valgrind/s390x-generic-valgrind.xml +%{_libexecdir}/valgrind/s390x-generic.xml +%{_libexecdir}/valgrind/s390x-linux64-valgrind-s*.xml +%{_libexecdir}/valgrind/s390x-linux64.xml +%{_libexecdir}/valgrind/s390x-vx-linux-valgrind.xml +%{_libexecdir}/valgrind/s390x-vx-linux.xml +# See https://bugzilla.suse.com/show_bug.cgi?id=1147071#c0 +%{_libexecdir}/valgrind/s390-acr-valgrind-s*.xml +%{_libexecdir}/valgrind/s390-acr.xml +%{_libexecdir}/valgrind/s390-fpr-valgrind-s*.xml +%{_libexecdir}/valgrind/s390-fpr.xml +%{_libexecdir}/valgrind/s390-vx-valgrind-s*.xml +%{_libexecdir}/valgrind/s390-vx.xml + +%ifarch x86_64 ppc64 s390x +%files 32bit +%endif + +%ifarch %{ix86} x86_64 +%if !0%{?disable_32bit} +%{_libexecdir}/valgrind/*-x86-linux +%endif +%endif + +%ifarch ppc ppc64 +%{_libexecdir}/valgrind/*-ppc32-linux +%endif +%{_libexecdir}/valgrind/mips-cp0-valgrind-s*.xml +%{_libexecdir}/valgrind/mips-cp0.xml +%{_libexecdir}/valgrind/mips-cpu-valgrind-s*.xml +%{_libexecdir}/valgrind/mips-cpu.xml +%{_libexecdir}/valgrind/mips-fpu-valgrind-s*.xml +%{_libexecdir}/valgrind/mips-fpu.xml +%{_libexecdir}/valgrind/mips-linux-valgrind.xml +%{_libexecdir}/valgrind/mips-linux.xml +%{_libexecdir}/valgrind/32bit-core.xml +%{_libexecdir}/valgrind/32bit-linux.xml +%{_libexecdir}/valgrind/32bit-sse.xml +%{_libexecdir}/valgrind/arm-core-valgrind-s*.xml +%{_libexecdir}/valgrind/arm-core.xml +%{_libexecdir}/valgrind/arm-vfpv3-valgrind-s*.xml +%{_libexecdir}/valgrind/arm-vfpv3.xml +%{_libexecdir}/valgrind/arm-with-vfpv3-valgrind.xml +%{_libexecdir}/valgrind/arm-with-vfpv3.xml +%{_libexecdir}/valgrind/32bit-core-valgrind-s*.xml +%{_libexecdir}/valgrind/32bit-linux-valgrind-s*.xml +%{_libexecdir}/valgrind/32bit-sse-valgrind-s*.xml +%{_libexecdir}/valgrind/i386-coresse-valgrind.xml +%{_libexecdir}/valgrind/i386-linux-valgrind.xml +%{_libexecdir}/valgrind/power-altivec-valgrind-s*.xml +%{_libexecdir}/valgrind/power-altivec.xml +%{_libexecdir}/valgrind/power-core.xml +%{_libexecdir}/valgrind/power-fpu-valgrind-s*.xml +%{_libexecdir}/valgrind/power-fpu.xml +%{_libexecdir}/valgrind/power-linux-valgrind-s*.xml +%{_libexecdir}/valgrind/power-linux.xml +%{_libexecdir}/valgrind/power-vsx-valgrind-s1.xml +%{_libexecdir}/valgrind/power-vsx-valgrind-s2.xml +%{_libexecdir}/valgrind/power-vsx.xml +%{_libexecdir}/valgrind/powerpc-altivec32l-valgrind.xml +%{_libexecdir}/valgrind/powerpc-altivec32l.xml +%{_libexecdir}/valgrind/powerpc-altivec64l-valgrind.xml +%{_libexecdir}/valgrind/powerpc-altivec64l.xml + +%else + +%files -n valgrind-client-headers +%dir %{_includedir}/valgrind +%{_includedir}/valgrind/callgrind.h +%{_includedir}/valgrind/dhat.h +%{_includedir}/valgrind/drd.h +%{_includedir}/valgrind/helgrind.h +%{_includedir}/valgrind/memcheck.h +%{_includedir}/valgrind/valgrind.h +%endif + +%changelog diff --git a/valgrind.xen.patch b/valgrind.xen.patch new file mode 100644 index 0000000..ac38dfd --- /dev/null +++ b/valgrind.xen.patch @@ -0,0 +1,2767 @@ +From 2cfbb502504f7c19c0e528d94b7372d1b052ca8b Mon Sep 17 00:00:00 2001 +From: Olaf Hering +Date: Wed, 26 Feb 2020 15:27:42 +0100 +Subject: [PATCH 001/112] track xenversion for unversioned interfaces + +Only domctl and sysctl contain a version info. Other interfaces lack +this essential info. But their layout of arguments may change across Xen +versions. + +Track the current Xen version based on info obtained from domctl and +sysctl calls. In case these versioned interfaces are called prior calls +to unversioned interfaces, valgrind will have a chance to guess the +correct layout of arguments. + +Upcoming changes will start to make use of this interface. + +bz#390553 +--- + coregrind/m_syswrap/syswrap-xen.c | 71 +++++++++++++++++++++++++++++++ + 1 file changed, 71 insertions(+) + +Index: valgrind-3.16.0/coregrind/m_syswrap/syswrap-xen.c +=================================================================== +--- valgrind-3.16.0.orig/coregrind/m_syswrap/syswrap-xen.c ++++ valgrind-3.16.0/coregrind/m_syswrap/syswrap-xen.c +@@ -60,6 +60,57 @@ + + #include + ++typedef enum { ++ vki_xenversion_unset = 0, ++ vki_xenversion_401, ++ vki_xenversion_402, ++ /* value shared between 4.3 and 4.4 */ ++ vki_xenversion_404, ++ vki_xenversion_405, ++ vki_xenversion_406_or_407, ++ vki_xenversion_406, ++ vki_xenversion_407, ++ vki_xenversion_408, ++ vki_xenversion_409, ++ vki_xenversion_410, ++ vki_xenversion_4101, ++ vki_xenversion_411, ++ vki_xenversion_412_or_413, ++ vki_xenversion_412, ++ vki_xenversion_413, ++ vki_xenversion_414, ++} vki_assumed_xenversion_t; ++static vki_assumed_xenversion_t vki_assumed_xenversion; ++ ++/* ++ * Some of the interfaces to Xen are versioned, like domctl and sysctl. ++ * Other interfaces lack a version number to derive the layout of arguments. ++ * Track the assumed Xen version for them, based on prior domctl or sysctl. ++ */ ++static void vki_set_assumed_xenversion(vki_assumed_xenversion_t v) ++{ ++ switch (vki_assumed_xenversion) { ++ case vki_xenversion_unset: ++ vki_assumed_xenversion = v; ++ break; ++ case vki_xenversion_406_or_407: ++ if (v == vki_xenversion_406 || v == vki_xenversion_407) ++ vki_assumed_xenversion = v; ++ break; ++ case vki_xenversion_412_or_413: ++ if (v == vki_xenversion_412 || v == vki_xenversion_413) ++ vki_assumed_xenversion = v; ++ break; ++ default: ++ break; ++ } ++} ++ ++static void vki_report_unknown_xenversion(const char *str) ++{ ++ VG_(dmsg)("WARNING: %s prior domctl/sysctl. Assuming latest interface version.\n", str); ++} ++ + #define PRE(name) static DEFN_PRE_TEMPLATE(xen, name) + #define POST(name) static DEFN_POST_TEMPLATE(xen, name) + +@@ -232,6 +283,16 @@ PRE(memory_op) + case VKI_XENMEM_get_sharing_shared_pages: + break; + ++ case VKI_XENMEM_get_pod_target: ++ case VKI_XENMEM_set_pod_target: { ++ struct vki_xen_pod_target *arg = ++ (struct vki_xen_pod_target *)ARG2; ++ PRE_MEM_READ("XENMEM_set_pod_target target_pages", ++ (Addr)&arg->target_pages, sizeof(arg->target_pages)); ++ PRE_MEM_READ("XENMEM_set_pod_target domid", ++ (Addr)&arg->domid, sizeof(arg->domid)); ++ break; ++ } + case VKI_XENMEM_access_op: { + struct vki_xen_mem_event_op *arg = + (struct vki_xen_mem_event_op *)ARG2; +@@ -530,6 +591,7 @@ PRE(xen_version) + case VKI_XENVER_pagesize: + case VKI_XENVER_guest_handle: + case VKI_XENVER_commandline: ++ case VKI_XENVER_build_id: + /* No inputs */ + break; + +@@ -579,16 +641,40 @@ PRE(sysctl) { + switch (sysctl->interface_version) + { + case 0x00000008: ++ vki_set_assumed_xenversion(vki_xenversion_401); ++ break; + case 0x00000009: ++ vki_set_assumed_xenversion(vki_xenversion_402); ++ break; + case 0x0000000a: ++ vki_set_assumed_xenversion(vki_xenversion_404); ++ break; + case 0x0000000b: ++ vki_set_assumed_xenversion(vki_xenversion_405); ++ break; + case 0x0000000c: ++ vki_set_assumed_xenversion(vki_xenversion_406); ++ break; + case 0x0000000d: ++ vki_set_assumed_xenversion(vki_xenversion_407); ++ break; + case 0x0000000e: ++ vki_set_assumed_xenversion(vki_xenversion_408); ++ break; + case 0x0000000f: ++ vki_set_assumed_xenversion(vki_xenversion_409); ++ break; + case 0x00000010: ++ vki_set_assumed_xenversion(vki_xenversion_410); ++ break; + case 0x00000011: ++ vki_set_assumed_xenversion(vki_xenversion_411); ++ break; + case 0x00000012: ++ vki_set_assumed_xenversion(vki_xenversion_412_or_413); ++ break; ++ case 0x00000013: ++ vki_set_assumed_xenversion(vki_xenversion_414); + break; + default: + bad_intf_version(tid, layout, arrghs, status, flags, +@@ -617,35 +703,53 @@ PRE(sysctl) { + break; + + case VKI_XEN_SYSCTL_getdomaininfolist: +- switch (sysctl->interface_version) +- { ++ switch (sysctl->interface_version) { ++ case 0x00000007: ++ PRE_XEN_SYSCTL_READ(getdomaininfolist_00000007, first_domain); ++ PRE_XEN_SYSCTL_READ(getdomaininfolist_00000007, max_domains); ++ PRE_XEN_SYSCTL_READ(getdomaininfolist_00000007, buffer); ++ break; + case 0x00000008: +- PRE_XEN_SYSCTL_READ(getdomaininfolist_00000008, first_domain); +- PRE_XEN_SYSCTL_READ(getdomaininfolist_00000008, max_domains); +- PRE_XEN_SYSCTL_READ(getdomaininfolist_00000008, buffer); +- break; ++ PRE_XEN_SYSCTL_READ(getdomaininfolist_00000008, first_domain); ++ PRE_XEN_SYSCTL_READ(getdomaininfolist_00000008, max_domains); ++ PRE_XEN_SYSCTL_READ(getdomaininfolist_00000008, buffer); ++ break; + case 0x00000009: +- PRE_XEN_SYSCTL_READ(getdomaininfolist_00000009, first_domain); +- PRE_XEN_SYSCTL_READ(getdomaininfolist_00000009, max_domains); +- PRE_XEN_SYSCTL_READ(getdomaininfolist_00000009, buffer); +- break; + case 0x0000000a: + case 0x0000000b: + case 0x0000000c: + case 0x0000000d: + case 0x0000000e: ++ PRE_XEN_SYSCTL_READ(getdomaininfolist_00000009, first_domain); ++ PRE_XEN_SYSCTL_READ(getdomaininfolist_00000009, max_domains); ++ PRE_XEN_SYSCTL_READ(getdomaininfolist_00000009, buffer); ++ break; + case 0x0000000f: +- PRE_XEN_SYSCTL_READ(getdomaininfolist_0000000a, first_domain); +- PRE_XEN_SYSCTL_READ(getdomaininfolist_0000000a, max_domains); +- PRE_XEN_SYSCTL_READ(getdomaininfolist_0000000a, buffer); +- break; + case 0x00000010: + case 0x00000011: + case 0x00000012: +- PRE_XEN_SYSCTL_READ(getdomaininfolist_00000010, first_domain); +- PRE_XEN_SYSCTL_READ(getdomaininfolist_00000010, max_domains); +- PRE_XEN_SYSCTL_READ(getdomaininfolist_00000010, buffer); +- break; ++ case 0x00000013: ++ switch (vki_assumed_xenversion) { ++ case vki_xenversion_412: ++ PRE_XEN_SYSCTL_READ(getdomaininfolist_0000000f, first_domain); ++ PRE_XEN_SYSCTL_READ(getdomaininfolist_0000000f, max_domains); ++ PRE_XEN_SYSCTL_READ(getdomaininfolist_0000000f, buffer); ++ break; ++ case vki_xenversion_unset: ++ case vki_xenversion_412_or_413: ++ vki_report_unknown_xenversion("VKI_XEN_SYSCTL_getdomaininfolist"); ++ /* fallthrough */ ++ case vki_xenversion_413: ++ default: ++ PRE_XEN_SYSCTL_READ(getdomaininfolist_00000012, first_domain); ++ PRE_XEN_SYSCTL_READ(getdomaininfolist_00000012, max_domains); ++ PRE_XEN_SYSCTL_READ(getdomaininfolist_00000012, buffer); ++ break; ++ } ++ PRE_XEN_SYSCTL_READ(getdomaininfolist_0000000f, first_domain); ++ PRE_XEN_SYSCTL_READ(getdomaininfolist_0000000f, max_domains); ++ PRE_XEN_SYSCTL_READ(getdomaininfolist_0000000f, buffer); ++ break; + default: + VG_(dmsg)("WARNING: XEN_SYSCTL_getdomaininfolist for sysctl version " + "%"PRIx32" not implemented yet\n", +@@ -696,18 +800,103 @@ PRE(sysctl) { + /* No input params */ + break; + +- case VKI_XEN_SYSCTL_topologyinfo: +- PRE_XEN_SYSCTL_READ(topologyinfo, max_cpu_index); +- PRE_XEN_SYSCTL_READ(topologyinfo, cpu_to_core); +- PRE_XEN_SYSCTL_READ(topologyinfo, cpu_to_socket); +- PRE_XEN_SYSCTL_READ(topologyinfo, cpu_to_node); ++ case VKI_XEN_SYSCTL_topologyinfo | VKI_XEN_SYSCTL_cputopoinfo: ++ switch (sysctl->interface_version) ++ { ++ case 0x00000007: ++ case 0x00000008: ++ case 0x00000009: ++ case 0x0000000a: ++ case 0x0000000b: ++ PRE_XEN_SYSCTL_READ(topologyinfo, max_cpu_index); ++ PRE_XEN_SYSCTL_READ(topologyinfo, cpu_to_core); ++ PRE_XEN_SYSCTL_READ(topologyinfo, cpu_to_socket); ++ PRE_XEN_SYSCTL_READ(topologyinfo, cpu_to_node); ++ break; ++ case 0x0000000c: ++ case 0x0000000d: ++ case 0x0000000e: ++ case 0x0000000f: ++ case 0x00000010: ++ case 0x00000011: ++ case 0x00000012: ++ case 0x00000013: ++ PRE_XEN_SYSCTL_READ(cputopoinfo_0000000c, num_cpus); ++ PRE_XEN_SYSCTL_READ(cputopoinfo_0000000c, cputopo); ++ break; ++ } + break; + + case VKI_XEN_SYSCTL_numainfo: +- PRE_XEN_SYSCTL_READ(numainfo, max_node_index); +- PRE_XEN_SYSCTL_READ(numainfo, node_to_memsize); +- PRE_XEN_SYSCTL_READ(numainfo, node_to_memfree); +- PRE_XEN_SYSCTL_READ(numainfo, node_to_node_distance); ++ switch (sysctl->interface_version) ++ { ++ case 0x00000008: ++ case 0x00000009: ++ case 0x0000000a: ++ case 0x0000000b: ++ PRE_XEN_SYSCTL_READ(numainfo_00000008, max_node_index); ++ PRE_XEN_SYSCTL_READ(numainfo_00000008, node_to_memsize); ++ PRE_XEN_SYSCTL_READ(numainfo_00000008, node_to_memfree); ++ PRE_XEN_SYSCTL_READ(numainfo_00000008, node_to_node_distance); ++ break; ++ case 0x0000000c: ++ case 0x0000000d: ++ case 0x0000000e: ++ case 0x0000000f: ++ case 0x00000010: ++ case 0x00000011: ++ case 0x00000012: ++ case 0x00000013: ++ PRE_XEN_SYSCTL_READ(numainfo_0000000c, num_nodes); ++ PRE_XEN_SYSCTL_READ(numainfo_0000000c, meminfo); ++ PRE_XEN_SYSCTL_READ(numainfo_0000000c, distance); ++ break; ++ } ++ break; ++ ++ case VKI_XEN_SYSCTL_pcitopoinfo: ++ switch (sysctl->interface_version) ++ { ++ case 0x0000000c: ++ case 0x0000000d: ++ case 0x0000000e: ++ case 0x0000000f: ++ case 0x00000010: ++ case 0x00000011: ++ case 0x00000012: ++ case 0x00000013: ++ PRE_XEN_SYSCTL_READ(pcitopoinfo_0000000c, num_devs); ++ PRE_XEN_SYSCTL_READ(pcitopoinfo_0000000c, devs); ++ break; ++ } ++ break; ++ ++ case VKI_XEN_SYSCTL_get_cpu_featureset: ++ switch (sysctl->interface_version) ++ { ++ case 0x0000000d: ++ case 0x0000000e: ++ case 0x0000000f: ++ case 0x00000010: ++ case 0x00000011: ++ case 0x00000012: ++ case 0x00000013: ++ PRE_XEN_SYSCTL_READ(cpu_featureset_0000000d, index); ++ PRE_XEN_SYSCTL_READ(cpu_featureset_0000000d, nr_features); ++ break; ++ } ++ break; ++ ++ case VKI_XEN_SYSCTL_get_cpu_policy: ++ switch (sysctl->interface_version) ++ { ++ case 0x00000012: ++ PRE_XEN_SYSCTL_READ(get_cpu_policy_00000012, index); ++ PRE_XEN_SYSCTL_READ(get_cpu_policy_00000012, nr_leaves); ++ PRE_XEN_SYSCTL_READ(get_cpu_policy_00000012, nr_msrs); ++ PRE_XEN_SYSCTL_READ(get_cpu_policy_00000012, _rsvd); ++ break; ++ } + break; + + default: +@@ -741,16 +930,40 @@ PRE(domctl) + switch (domctl->interface_version) + { + case 0x00000007: ++ vki_set_assumed_xenversion(vki_xenversion_401); ++ break; + case 0x00000008: ++ vki_set_assumed_xenversion(vki_xenversion_402); ++ break; + case 0x00000009: ++ vki_set_assumed_xenversion(vki_xenversion_404); ++ break; + case 0x0000000a: ++ vki_set_assumed_xenversion(vki_xenversion_405); ++ break; + case 0x0000000b: ++ vki_set_assumed_xenversion(vki_xenversion_406_or_407); ++ break; + case 0x0000000c: ++ vki_set_assumed_xenversion(vki_xenversion_408); ++ break; + case 0x0000000d: ++ vki_set_assumed_xenversion(vki_xenversion_409); ++ break; ++ case 0x0000000e: ++ vki_set_assumed_xenversion(vki_xenversion_410); ++ break; + case 0x0000000f: ++ vki_set_assumed_xenversion(vki_xenversion_4101); ++ break; + case 0x00000010: ++ vki_set_assumed_xenversion(vki_xenversion_411); ++ break; + case 0x00000011: ++ vki_set_assumed_xenversion(vki_xenversion_412); ++ break; + case 0x00000012: ++ vki_set_assumed_xenversion(vki_xenversion_413); + break; + default: + bad_intf_version(tid, layout, arrghs, status, flags, +@@ -774,13 +987,95 @@ PRE(domctl) + case VKI_XEN_DOMCTL_getdomaininfo: + case VKI_XEN_DOMCTL_unpausedomain: + case VKI_XEN_DOMCTL_resumedomain: ++ case VKI_XEN_DOMCTL_soft_reset: + /* No input fields. */ + break; + + case VKI_XEN_DOMCTL_createdomain: +- PRE_XEN_DOMCTL_READ(createdomain, ssidref); +- PRE_XEN_DOMCTL_READ(createdomain, handle); +- PRE_XEN_DOMCTL_READ(createdomain, flags); ++ switch (domctl->interface_version) { ++ case 0x00000007: ++ case 0x00000008: ++ case 0x00000009: ++ case 0x0000000a: ++ PRE_XEN_DOMCTL_READ(createdomain_00000004, ssidref); ++ PRE_XEN_DOMCTL_READ(createdomain_00000004, handle); ++ PRE_XEN_DOMCTL_READ(createdomain_00000004, flags); ++ break; ++ case 0x0000000b: ++ case 0x0000000c: ++ case 0x0000000d: ++ case 0x0000000e: ++ case 0x0000000f: ++ case 0x00000010: ++ switch (vki_assumed_xenversion) { ++ case vki_xenversion_406: ++ PRE_XEN_DOMCTL_READ(createdomain_0000000b, ssidref); ++ PRE_XEN_DOMCTL_READ(createdomain_0000000b, handle); ++ PRE_XEN_DOMCTL_READ(createdomain_0000000b, flags); ++#if defined(__i386__) || defined(__x86_64__) ++ __PRE_XEN_DOMCTL_READ(createdomain_0000000b, createdomain_0000000b, config.dummy); ++#endif ++#if defined(__arm__) || defined(__aarch64__) ++ __PRE_XEN_DOMCTL_READ(createdomain_0000000b, createdomain_0000000b, config.gic_version); ++ __PRE_XEN_DOMCTL_READ(createdomain_0000000b, createdomain_0000000b, config.nr_spis); ++ __PRE_XEN_DOMCTL_READ(createdomain_0000000b, createdomain_0000000b, config.clock_frequency); ++#endif ++ break; ++ case vki_xenversion_unset: ++ case vki_xenversion_406_or_407: ++ vki_report_unknown_xenversion("VKI_XEN_DOMCTL_createdomain"); ++ /* fallthrough */ ++ case vki_xenversion_407: ++ default: ++ PRE_XEN_DOMCTL_READ(createdomain_0000000c, ssidref); ++ PRE_XEN_DOMCTL_READ(createdomain_0000000c, handle); ++ PRE_XEN_DOMCTL_READ(createdomain_0000000c, flags); ++#if defined(__i386__) || defined(__x86_64__) ++ __PRE_XEN_DOMCTL_READ(createdomain_0000000c, createdomain_0000000c, config.emulation_flags); ++#endif ++#if defined(__arm__) || defined(__aarch64__) ++ __PRE_XEN_DOMCTL_READ(createdomain_0000000c, createdomain_0000000c, config.gic_version); ++ __PRE_XEN_DOMCTL_READ(createdomain_0000000c, createdomain_0000000c, config.nr_spis); ++ __PRE_XEN_DOMCTL_READ(createdomain_0000000c, createdomain_0000000c, config.clock_frequency); ++#endif ++ break; ++ } ++ break; ++ case 0x00000011: ++ PRE_XEN_DOMCTL_READ(createdomain_00000011, ssidref); ++ PRE_XEN_DOMCTL_READ(createdomain_00000011, handle); ++ PRE_XEN_DOMCTL_READ(createdomain_00000011, flags); ++ PRE_XEN_DOMCTL_READ(createdomain_00000011, max_vcpus); ++ PRE_XEN_DOMCTL_READ(createdomain_00000011, max_evtchn_port); ++ PRE_XEN_DOMCTL_READ(createdomain_00000011, max_maptrack_frames); ++#if defined(__i386__) || defined(__x86_64__) ++ __PRE_XEN_DOMCTL_READ(createdomain_00000011, createdomain_00000011, config.emulation_flags); ++#endif ++#if defined(__arm__) || defined(__aarch64__) ++ __PRE_XEN_DOMCTL_READ(createdomain_00000011, createdomain_00000011, config.gic_version); ++ __PRE_XEN_DOMCTL_READ(createdomain_00000011, createdomain_00000011, config.nr_spis); ++ __PRE_XEN_DOMCTL_READ(createdomain_00000011, createdomain_00000011, config.clock_frequency); ++#endif ++ break; ++ case 0x00000012: ++ PRE_XEN_DOMCTL_READ(createdomain_00000012, ssidref); ++ PRE_XEN_DOMCTL_READ(createdomain_00000012, handle); ++ PRE_XEN_DOMCTL_READ(createdomain_00000012, flags); ++ PRE_XEN_DOMCTL_READ(createdomain_00000012, iommu_opts); ++ PRE_XEN_DOMCTL_READ(createdomain_00000012, max_vcpus); ++ PRE_XEN_DOMCTL_READ(createdomain_00000012, max_evtchn_port); ++ PRE_XEN_DOMCTL_READ(createdomain_00000012, max_maptrack_frames); ++#if defined(__i386__) || defined(__x86_64__) ++ __PRE_XEN_DOMCTL_READ(createdomain_00000012, createdomain_00000012, config.emulation_flags); ++#endif ++#if defined(__arm__) || defined(__aarch64__) ++ __PRE_XEN_DOMCTL_READ(createdomain_00000012, createdomain_00000012, config.gic_version); ++ __PRE_XEN_DOMCTL_READ(createdomain_00000012, createdomain_00000012, config.tee_type); ++ __PRE_XEN_DOMCTL_READ(createdomain_00000012, createdomain_00000012, config.nr_spis); ++ __PRE_XEN_DOMCTL_READ(createdomain_00000012, createdomain_00000012, config.clock_frequency); ++#endif ++ break; ++ } + break; + + case VKI_XEN_DOMCTL_gethvmcontext: +@@ -801,30 +1096,66 @@ PRE(domctl) + break; + + case VKI_XEN_DOMCTL_gethvmcontext_partial: +- __PRE_XEN_DOMCTL_READ(gethvmcontext_partial, hvmcontext_partial_00000007, type); +- __PRE_XEN_DOMCTL_READ(gethvmcontext_partial, hvmcontext_partial_00000007, instance); +- __PRE_XEN_DOMCTL_READ(gethvmcontext_partial, hvmcontext_partial_00000007, buffer); +- +- switch (domctl->u.hvmcontext_partial_00000007.type) { +- case VKI_HVM_SAVE_CODE(CPU): +- if ( domctl->u.hvmcontext_partial_00000007.buffer.p ) +- PRE_MEM_WRITE("XEN_DOMCTL_gethvmcontext_partial *buffer", +- (Addr)domctl->u.hvmcontext_partial_00000007.buffer.p, +- VKI_HVM_SAVE_LENGTH(CPU)); +- break; +- case VKI_HVM_SAVE_CODE(MTRR): +- if ( domctl->u.hvmcontext_partial_00000007.buffer.p ) +- PRE_MEM_WRITE("XEN_DOMCTL_gethvmcontext_partial *buffer", +- (Addr)domctl->u.hvmcontext_partial_00000007.buffer.p, +- VKI_HVM_SAVE_LENGTH(MTRR)); +- break; +- default: +- bad_subop(tid, layout, arrghs, status, flags, +- "__HYPERVISOR_domctl_gethvmcontext_partial type", +- domctl->u.hvmcontext_partial_00000007.type); +- break; +- } +- break; ++ switch (domctl->interface_version) { ++ case 0x00000007: ++ case 0x00000008: ++ case 0x00000009: ++ case 0x0000000a: ++ case 0x0000000b: ++ case 0x0000000c: ++ case 0x0000000d: ++ __PRE_XEN_DOMCTL_READ(gethvmcontext_partial, hvmcontext_partial_00000005, type); ++ __PRE_XEN_DOMCTL_READ(gethvmcontext_partial, hvmcontext_partial_00000005, instance); ++ __PRE_XEN_DOMCTL_READ(gethvmcontext_partial, hvmcontext_partial_00000005, buffer); ++ ++ switch (domctl->u.hvmcontext_partial_00000005.type) { ++ case VKI_HVM_SAVE_CODE(CPU): ++ if ( domctl->u.hvmcontext_partial_00000005.buffer.p ) ++ PRE_MEM_WRITE("XEN_DOMCTL_gethvmcontext_partial *buffer", ++ (Addr)domctl->u.hvmcontext_partial_00000005.buffer.p, ++ VKI_HVM_SAVE_LENGTH(CPU)); ++ break; ++ case VKI_HVM_SAVE_CODE(MTRR): ++ if ( domctl->u.hvmcontext_partial_00000005.buffer.p ) ++ PRE_MEM_WRITE("XEN_DOMCTL_gethvmcontext_partial *buffer", ++ (Addr)domctl->u.hvmcontext_partial_00000005.buffer.p, ++ VKI_HVM_SAVE_LENGTH(MTRR)); ++ break; ++ default: ++ bad_subop(tid, layout, arrghs, status, flags, ++ "__HYPERVISOR_domctl_gethvmcontext_partial type", ++ domctl->u.hvmcontext_partial_00000005.type); ++ break; ++ } ++ break; ++ case 0x0000000e: ++ case 0x0000000f: ++ case 0x00000010: ++ case 0x00000011: ++ case 0x00000012: ++ __PRE_XEN_DOMCTL_READ(gethvmcontext_partial, hvmcontext_partial_0000000e, type); ++ __PRE_XEN_DOMCTL_READ(gethvmcontext_partial, hvmcontext_partial_0000000e, instance); ++ __PRE_XEN_DOMCTL_READ(gethvmcontext_partial, hvmcontext_partial_0000000e, bufsz); ++ __PRE_XEN_DOMCTL_READ(gethvmcontext_partial, hvmcontext_partial_0000000e, buffer); ++ ++ switch (domctl->u.hvmcontext_partial_0000000e.type) { ++ case VKI_HVM_SAVE_CODE(CPU): ++ if ( domctl->u.hvmcontext_partial_0000000e.buffer.p ) ++ PRE_MEM_WRITE("XEN_DOMCTL_gethvmcontext_partial *buffer", (Addr)domctl->u.hvmcontext_partial_0000000e.buffer.p, VKI_HVM_SAVE_LENGTH(CPU)); ++ break; ++ case VKI_HVM_SAVE_CODE(MTRR): ++ if ( domctl->u.hvmcontext_partial_0000000e.buffer.p ) ++ PRE_MEM_WRITE("XEN_DOMCTL_gethvmcontext_partial *buffer", (Addr)domctl->u.hvmcontext_partial_0000000e.buffer.p, VKI_HVM_SAVE_LENGTH(MTRR)); ++ break; ++ default: ++ bad_subop(tid, layout, arrghs, status, flags, ++ "__HYPERVISOR_domctl_gethvmcontext_partial type", ++ domctl->u.hvmcontext_partial_0000000e.type); ++ break; ++ } ++ break; ++ } ++ break; + + case VKI_XEN_DOMCTL_max_mem: + PRE_XEN_DOMCTL_READ(max_mem, max_memkb); +@@ -836,7 +1167,7 @@ PRE(domctl) + + case VKI_XEN_DOMCTL_test_assign_device: + switch (domctl->interface_version) { +- case 0x00000007: /* pre-4.6 */ ++ case 0x00000007: + case 0x00000008: + case 0x00000009: + case 0x0000000a: +@@ -845,11 +1176,6 @@ PRE(domctl) + case 0x0000000b: + case 0x0000000c: + case 0x0000000d: +- case 0x0000000e: +- case 0x0000000f: +- case 0x00000010: +- case 0x00000011: +- case 0x00000012: + __PRE_XEN_DOMCTL_READ(test_assign_device, assign_device_0000000b, dev); + __PRE_XEN_DOMCTL_READ(test_assign_device, assign_device_0000000b, flag); + switch (domctl->u.assign_device_0000000b.dev) { +@@ -869,11 +1195,35 @@ PRE(domctl) + break; + } + break; ++ case 0x0000000e: ++ case 0x0000000f: ++ case 0x00000010: ++ case 0x00000011: ++ case 0x00000012: ++ __PRE_XEN_DOMCTL_READ(test_assign_device, assign_device_0000000e, dev); ++ __PRE_XEN_DOMCTL_READ(test_assign_device, assign_device_0000000e, flags); ++ switch (domctl->u.assign_device_0000000e.dev) { ++ case VKI_XEN_DOMCTL_DEV_PCI: ++ __PRE_XEN_DOMCTL_READ(test_assign_device, assign_device_0000000e, u.pci); ++ break; ++ case VKI_XEN_DOMCTL_DEV_DT: ++ __PRE_XEN_DOMCTL_READ(test_assign_device, assign_device_0000000e, u.dt); ++ PRE_MEM_READ("XEN_DOMTCL_test_assign_device.dt", ++ (Addr)domctl->u.assign_device_0000000e.u.dt.path.p, ++ domctl->u.assign_device_0000000e.u.dt.size); ++ break; ++ default: ++ bad_subop(tid, layout, arrghs, status, flags, ++ "__HYPERVISOR_domctl_test_assign_device dev", ++ domctl->u.assign_device_0000000e.dev); ++ break; ++ } ++ break; + } + break; + case VKI_XEN_DOMCTL_assign_device: + switch (domctl->interface_version) { +- case 0x00000007: /* pre-4.6 */ ++ case 0x00000007: + case 0x00000008: + case 0x00000009: + case 0x0000000a: +@@ -882,11 +1232,6 @@ PRE(domctl) + case 0x0000000b: + case 0x0000000c: + case 0x0000000d: +- case 0x0000000e: +- case 0x0000000f: +- case 0x00000010: +- case 0x00000011: +- case 0x00000012: + __PRE_XEN_DOMCTL_READ(assign_device, assign_device_0000000b, dev); + __PRE_XEN_DOMCTL_READ(assign_device, assign_device_0000000b, flag); + switch (domctl->u.assign_device_0000000b.dev) { +@@ -906,11 +1251,30 @@ PRE(domctl) + break; + } + break; ++ case 0x0000000e: ++ case 0x0000000f: ++ case 0x00000010: ++ case 0x00000011: ++ case 0x00000012: ++ __PRE_XEN_DOMCTL_READ(assign_device, assign_device_0000000e, dev); ++ __PRE_XEN_DOMCTL_READ(assign_device, assign_device_0000000e, flags); ++ switch (domctl->u.assign_device_0000000e.dev) { ++ case VKI_XEN_DOMCTL_DEV_PCI: ++ __PRE_XEN_DOMCTL_READ(assign_device, assign_device_0000000e, u.pci); ++ break; ++ case VKI_XEN_DOMCTL_DEV_DT: ++ __PRE_XEN_DOMCTL_READ(assign_device, assign_device_0000000e, u.dt); ++ PRE_MEM_READ("XEN_DOMTCL_assign_device.dt", ++ (Addr)domctl->u.assign_device_0000000e.u.dt.path.p, ++ domctl->u.assign_device_0000000e.u.dt.size); ++ break; ++ } ++ break; + } + break; + case VKI_XEN_DOMCTL_deassign_device: + switch (domctl->interface_version) { +- case 0x00000007: /* pre-4.6 */ ++ case 0x00000007: + case 0x00000008: + case 0x00000009: + case 0x0000000a: +@@ -919,11 +1283,6 @@ PRE(domctl) + case 0x0000000b: + case 0x0000000c: + case 0x0000000d: +- case 0x0000000e: +- case 0x0000000f: +- case 0x00000010: +- case 0x00000011: +- case 0x00000012: + __PRE_XEN_DOMCTL_READ(deassign_device, assign_device_0000000b, dev); + __PRE_XEN_DOMCTL_READ(deassign_device, assign_device_0000000b, flag); + switch (domctl->u.assign_device_0000000b.dev) { +@@ -943,12 +1302,31 @@ PRE(domctl) + break; + } + break; ++ case 0x0000000e: ++ case 0x0000000f: ++ case 0x00000010: ++ case 0x00000011: ++ case 0x00000012: ++ __PRE_XEN_DOMCTL_READ(deassign_device, assign_device_0000000e, dev); ++ __PRE_XEN_DOMCTL_READ(deassign_device, assign_device_0000000e, flags); ++ switch (domctl->u.assign_device_0000000e.dev) { ++ case VKI_XEN_DOMCTL_DEV_PCI: ++ __PRE_XEN_DOMCTL_READ(deassign_device, assign_device_0000000e, u.pci); ++ break; ++ case VKI_XEN_DOMCTL_DEV_DT: ++ __PRE_XEN_DOMCTL_READ(deassign_device, assign_device_0000000e, u.dt); ++ PRE_MEM_READ("XEN_DOMTCL_assign_device.dt", ++ (Addr)domctl->u.assign_device_0000000e.u.dt.path.p, ++ domctl->u.assign_device_0000000e.u.dt.size); ++ break; ++ } ++ break; + } + break; + + case VKI_XEN_DOMCTL_settscinfo: + switch (domctl->interface_version) { +- case 0x00000007: /* pre-4.6 */ ++ case 0x00000007: + case 0x00000008: + case 0x00000009: + case 0x0000000a: +@@ -995,8 +1373,25 @@ PRE(domctl) + break; + + case VKI_XEN_DOMCTL_settimeoffset: +- PRE_XEN_DOMCTL_READ(settimeoffset, time_offset_seconds); +- break; ++ switch (domctl->interface_version) { ++ case 0x00000007: ++ case 0x00000008: ++ case 0x00000009: ++ case 0x0000000a: ++ PRE_XEN_DOMCTL_READ(settimeoffset_00000001, time_offset_seconds); ++ break; ++ case 0x0000000b: ++ case 0x0000000c: ++ case 0x0000000d: ++ case 0x0000000e: ++ case 0x0000000f: ++ case 0x00000010: ++ case 0x00000011: ++ case 0x00000012: ++ PRE_XEN_DOMCTL_READ(settimeoffset_0000000b, time_offset_seconds); ++ break; ++ } ++ break; + + case VKI_XEN_DOMCTL_getvcpuinfo: + PRE_XEN_DOMCTL_READ(getvcpuinfo, vcpu); +@@ -1320,16 +1715,18 @@ PRE(domctl) + PRE_XEN_DOMCTL_READ(access_required, access_required); + break; + +- case VKI_XEN_DOMCTL_mem_event_op: +- //case VKI_XEN_DOMCTL_vm_event_op: /* name change in 4.6 */ ++ case VKI_XEN_DOMCTL_mem_event_op | VKI_XEN_DOMCTL_vm_event_op: + switch (domctl->interface_version) { +- case 0x00000007: /* pre-4.6 */ +- case 0x00000008: +- case 0x00000009: +- case 0x0000000a: ++ case 0x00000007: + __PRE_XEN_DOMCTL_READ(mem_event_op, mem_event_op_00000007, op); + __PRE_XEN_DOMCTL_READ(mem_event_op, mem_event_op_00000007, mode); ++ __PRE_XEN_DOMCTL_READ(mem_event_op, mem_event_op_00000007, shared_addr); ++ __PRE_XEN_DOMCTL_READ(mem_event_op, mem_event_op_00000007, ring_addr); ++ __PRE_XEN_DOMCTL_READ(mem_event_op, mem_event_op_00000007, gfn); + break; ++ case 0x00000008: ++ case 0x00000009: ++ case 0x0000000a: + case 0x0000000b: + case 0x0000000c: + case 0x0000000d: +@@ -1337,8 +1734,8 @@ PRE(domctl) + case 0x0000000f: + case 0x00000010: + case 0x00000011: +- __PRE_XEN_DOMCTL_READ(vm_event_op, vm_event_op_0000000b, op); +- __PRE_XEN_DOMCTL_READ(vm_event_op, vm_event_op_0000000b, mode); ++ __PRE_XEN_DOMCTL_READ(mem_event_op, vm_event_op_00000008, op); ++ __PRE_XEN_DOMCTL_READ(mem_event_op, vm_event_op_00000008, mode); + break; + case 0x00000012: + __PRE_XEN_DOMCTL_READ(vm_event_op, vm_event_op_00000012, op); +@@ -1371,12 +1768,7 @@ PRE(domctl) + + case VKI_XEN_DOMCTL_monitor_op: + switch (domctl->interface_version) { +- case 0x000000b: +- case 0x000000c: +- case 0x000000d: +- case 0x000000e: +- case 0x000000f: +- case 0x0000010: ++ case 0x0000000b: + if (domctl->u.monitor_op_0000000b.op == VKI_XEN_DOMCTL_MONITOR_OP_ENABLE || + domctl->u.monitor_op_0000000b.op == VKI_XEN_DOMCTL_MONITOR_OP_DISABLE) { + switch (domctl->u.monitor_op_0000000b.event) { +@@ -1389,31 +1781,105 @@ PRE(domctl) + case VKI_XEN_DOMCTL_MONITOR_EVENT_GUEST_REQUEST: + __PRE_XEN_DOMCTL_READ(monitor_op, monitor_op_0000000b, u.guest_request); + break; +- case VKI_XEN_DOMCTL_MONITOR_OP_GET_CAPABILITIES: ++ } ++ } ++ ++ break; ++ case 0x0000000c: ++ case 0x0000000d: ++ if (domctl->u.monitor_op_0000000c.op == VKI_XEN_DOMCTL_MONITOR_OP_ENABLE || ++ domctl->u.monitor_op_0000000c.op == VKI_XEN_DOMCTL_MONITOR_OP_DISABLE) { ++ switch (domctl->u.monitor_op_0000000c.event) { ++ case VKI_XEN_DOMCTL_MONITOR_EVENT_WRITE_CTRLREG: ++ __PRE_XEN_DOMCTL_READ(monitor_op, monitor_op_0000000c, u.mov_to_cr); ++ break; ++ case VKI_XEN_DOMCTL_MONITOR_EVENT_MOV_TO_MSR: ++ __PRE_XEN_DOMCTL_READ(monitor_op, monitor_op_0000000c, u.mov_to_msr); ++ break; ++ case VKI_XEN_DOMCTL_MONITOR_EVENT_GUEST_REQUEST: ++ __PRE_XEN_DOMCTL_READ(monitor_op, monitor_op_0000000c, u.guest_request); ++ break; ++ case VKI_XEN_DOMCTL_MONITOR_EVENT_DEBUG_EXCEPTION: ++ __PRE_XEN_DOMCTL_READ(monitor_op, monitor_op_0000000c, u.debug_exception); ++ break; ++ } ++ } ++ break; ++ case 0x0000000e: ++ case 0x0000000f: ++ if (domctl->u.monitor_op_0000000e.op == VKI_XEN_DOMCTL_MONITOR_OP_ENABLE || ++ domctl->u.monitor_op_0000000e.op == VKI_XEN_DOMCTL_MONITOR_OP_DISABLE) { ++ switch (domctl->u.monitor_op_0000000e.event) { ++ case VKI_XEN_DOMCTL_MONITOR_EVENT_WRITE_CTRLREG: ++ __PRE_XEN_DOMCTL_READ(monitor_op, monitor_op_0000000e, u.mov_to_cr); ++ break; ++ case VKI_XEN_DOMCTL_MONITOR_EVENT_MOV_TO_MSR: ++ __PRE_XEN_DOMCTL_READ(monitor_op, monitor_op_0000000e, u.mov_to_msr); ++ break; ++ case VKI_XEN_DOMCTL_MONITOR_EVENT_GUEST_REQUEST: ++ __PRE_XEN_DOMCTL_READ(monitor_op, monitor_op_0000000e, u.guest_request); ++ break; ++ case VKI_XEN_DOMCTL_MONITOR_EVENT_DEBUG_EXCEPTION: ++ __PRE_XEN_DOMCTL_READ(monitor_op, monitor_op_0000000e, u.debug_exception); + break; + } + } + + break; ++ case 0x00000010: + case 0x0000011: + case 0x0000012: +- if (domctl->u.monitor_op_00000011.op == VKI_XEN_DOMCTL_MONITOR_OP_ENABLE || +- domctl->u.monitor_op_00000011.op == VKI_XEN_DOMCTL_MONITOR_OP_DISABLE) { +- switch (domctl->u.monitor_op_00000011.event) { ++ if (domctl->u.monitor_op_00000010.op == VKI_XEN_DOMCTL_MONITOR_OP_ENABLE || ++ domctl->u.monitor_op_00000010.op == VKI_XEN_DOMCTL_MONITOR_OP_DISABLE) { ++ switch (domctl->u.monitor_op_00000010.event) { + case VKI_XEN_DOMCTL_MONITOR_EVENT_WRITE_CTRLREG: +- __PRE_XEN_DOMCTL_READ(monitor_op, monitor_op_00000011, u.mov_to_cr); ++ __PRE_XEN_DOMCTL_READ(monitor_op, monitor_op_00000010, u.mov_to_cr); + break; + case VKI_XEN_DOMCTL_MONITOR_EVENT_MOV_TO_MSR: +- __PRE_XEN_DOMCTL_READ(monitor_op, monitor_op_00000011, u.mov_to_msr); ++ __PRE_XEN_DOMCTL_READ(monitor_op, monitor_op_00000010, u.mov_to_msr); + break; + case VKI_XEN_DOMCTL_MONITOR_EVENT_GUEST_REQUEST: +- __PRE_XEN_DOMCTL_READ(monitor_op, monitor_op_00000011, u.guest_request); ++ __PRE_XEN_DOMCTL_READ(monitor_op, monitor_op_00000010, u.guest_request); + break; +- case VKI_XEN_DOMCTL_MONITOR_OP_GET_CAPABILITIES: ++ case VKI_XEN_DOMCTL_MONITOR_EVENT_DEBUG_EXCEPTION: ++ __PRE_XEN_DOMCTL_READ(monitor_op, monitor_op_00000010, u.debug_exception); + break; + } + } ++ break; ++ } ++ break; ++ ++ case VKI_XEN_DOMCTL_set_gnttab_limits: ++ PRE_XEN_DOMCTL_READ(set_gnttab_limits_0000000e, grant_frames); ++ PRE_XEN_DOMCTL_READ(set_gnttab_limits_0000000e, maptrack_frames); ++ break; + ++ case VKI_XEN_DOMCTL_get_cpu_policy: ++ switch (domctl->interface_version) { ++ case 0x00000011: ++ case 0x00000012: ++ PRE_XEN_DOMCTL_READ(cpu_policy_00000011, nr_leaves); ++ PRE_XEN_DOMCTL_READ(cpu_policy_00000011, nr_msrs); ++ break; ++ } ++ break; ++ ++ case VKI_XEN_DOMCTL_set_cpu_policy: ++ switch (domctl->interface_version) { ++ case 0x00000012: ++ PRE_XEN_DOMCTL_READ(cpu_policy_00000012, nr_leaves); ++ PRE_XEN_DOMCTL_READ(cpu_policy_00000012, nr_msrs); ++ if (domctl->u.cpu_policy_00000012.cpuid_policy.p) ++ PRE_MEM_READ("XEN_DOMCTL_set_cpu_policy_00000012 *u.cpu_policy_00000012.cpuid_policy.p", ++ (Addr)domctl->u.cpu_policy_00000012.cpuid_policy.p, ++ sizeof(vki_xen_cpuid_leaf_00000012_t) * ++ domctl->u.cpu_policy_00000012.nr_leaves); ++ if (domctl->u.cpu_policy_00000012.msr_policy.p) ++ PRE_MEM_READ("XEN_DOMCTL_set_cpu_policy_00000012 *u.cpu_policy_00000012.msr_policy.p", ++ (Addr)domctl->u.cpu_policy_00000012.msr_policy.p, ++ sizeof(vki_xen_msr_entry_00000012_t) * ++ domctl->u.cpu_policy_00000012.nr_msrs); + break; + } + break; +@@ -1511,13 +1977,28 @@ PRE(hvm_op) + break; + + case VKI_XEN_HVMOP_inject_trap: +- PRE_XEN_HVMOP_READ(inject_trap, domid); +- PRE_XEN_HVMOP_READ(inject_trap, vcpuid); +- PRE_XEN_HVMOP_READ(inject_trap, vector); +- PRE_XEN_HVMOP_READ(inject_trap, type); +- PRE_XEN_HVMOP_READ(inject_trap, error_code); +- PRE_XEN_HVMOP_READ(inject_trap, insn_len); +- PRE_XEN_HVMOP_READ(inject_trap, cr2); ++ switch (vki_assumed_xenversion) { ++ case vki_xenversion_401: ++ PRE_XEN_HVMOP_READ(inject_trap_0401, domid); ++ PRE_XEN_HVMOP_READ(inject_trap_0401, vcpuid); ++ PRE_XEN_HVMOP_READ(inject_trap_0401, trap); ++ PRE_XEN_HVMOP_READ(inject_trap_0401, error_code); ++ PRE_XEN_HVMOP_READ(inject_trap_0401, cr2); ++ break; ++ case vki_xenversion_unset: ++ vki_report_unknown_xenversion("VKI_XEN_HVMOP_inject_trap"); ++ /* fallthrough */ ++ case vki_xenversion_402: ++ default: ++ PRE_XEN_HVMOP_READ(inject_trap_0402, domid); ++ PRE_XEN_HVMOP_READ(inject_trap_0402, vcpuid); ++ PRE_XEN_HVMOP_READ(inject_trap_0402, vector); ++ PRE_XEN_HVMOP_READ(inject_trap_0402, type); ++ PRE_XEN_HVMOP_READ(inject_trap_0402, error_code); ++ PRE_XEN_HVMOP_READ(inject_trap_0402, insn_len); ++ PRE_XEN_HVMOP_READ(inject_trap_0402, cr2); ++ break; ++ } + break; + + case VKI_XEN_HVMOP_altp2m: { +@@ -1616,6 +2097,16 @@ PRE(tmem_op) + #undef __PRE_XEN_TMEMOP_READ + } + ++PRE(dm_op) ++{ ++ unsigned int domid = ARG1, num = ARG2; ++ struct vki_xen_privcmd_dm_op_buf *args = (void *)(ARG3); ++ ++ PRINT("__HYPERVISOR_dm_op ( %u, %u, %p )", domid, num, args); ++ ++ PRE_MEM_READ("__HYPERVISOR_dm_op ubuf", (Addr)args, sizeof(*args) * num); ++} ++ + POST(memory_op) + { + switch (ARG1) { +@@ -1625,6 +2116,7 @@ POST(memory_op) + case VKI_XENMEM_claim_pages: + case VKI_XENMEM_maximum_gpfn: + case VKI_XENMEM_remove_from_physmap: ++ case VKI_XENMEM_set_pod_target: + case VKI_XENMEM_access_op: + /* No outputs */ + break; +@@ -1669,6 +2161,15 @@ POST(memory_op) + case VKI_XENMEM_get_sharing_shared_pages: + /* No outputs */ + break; ++ case VKI_XENMEM_get_pod_target: { ++ struct vki_xen_pod_target *arg = ++ (struct vki_xen_pod_target *)ARG2; ++ POST_MEM_WRITE((Addr)&arg->tot_pages, sizeof(arg->tot_pages)); ++ POST_MEM_WRITE((Addr)&arg->pod_cache_pages, sizeof(arg->pod_cache_pages)); ++ POST_MEM_WRITE((Addr)&arg->pod_entries, sizeof(arg->pod_entries)); ++ } ++ break; ++ + } + } + +@@ -1794,6 +2295,9 @@ POST(xen_version) + case VKI_XENVER_commandline: + POST_MEM_WRITE((Addr)ARG2, sizeof(vki_xen_commandline_t)); + break; ++ case VKI_XENVER_build_id: ++ POST_MEM_WRITE((Addr)ARG2, sizeof(struct vki_xen_build_id)); ++ break; + } + } + +@@ -1830,6 +2334,7 @@ POST(sysctl) + case 0x00000010: + case 0x00000011: + case 0x00000012: ++ case 0x00000013: + break; + default: + return; +@@ -1848,39 +2353,58 @@ POST(sysctl) + break; + + case VKI_XEN_SYSCTL_getdomaininfolist: +- switch (sysctl->interface_version) +- { ++ switch (sysctl->interface_version) { ++ case 0x00000007: ++ POST_XEN_SYSCTL_WRITE(getdomaininfolist_00000007, num_domains); ++ if (sysctl->u.getdomaininfolist_00000007.num_domains > 0) ++ POST_MEM_WRITE((Addr)sysctl->u.getdomaininfolist_00000007.buffer.p, ++ sizeof(*sysctl->u.getdomaininfolist_00000007.buffer.p) * ++ sysctl->u.getdomaininfolist_00000007.num_domains); ++ break; + case 0x00000008: +- POST_XEN_SYSCTL_WRITE(getdomaininfolist_00000008, num_domains); +- POST_MEM_WRITE((Addr)sysctl->u.getdomaininfolist_00000008.buffer.p, +- sizeof(*sysctl->u.getdomaininfolist_00000008.buffer.p) +- * sysctl->u.getdomaininfolist_00000008.num_domains); +- break; ++ POST_XEN_SYSCTL_WRITE(getdomaininfolist_00000008, num_domains); ++ if (sysctl->u.getdomaininfolist_00000008.num_domains > 0) ++ POST_MEM_WRITE((Addr)sysctl->u.getdomaininfolist_00000008.buffer.p, ++ sizeof(*sysctl->u.getdomaininfolist_00000008.buffer.p) * ++ sysctl->u.getdomaininfolist_00000008.num_domains); ++ break; + case 0x00000009: +- POST_XEN_SYSCTL_WRITE(getdomaininfolist_00000009, num_domains); +- POST_MEM_WRITE((Addr)sysctl->u.getdomaininfolist_00000009.buffer.p, +- sizeof(*sysctl->u.getdomaininfolist_00000009.buffer.p) +- * sysctl->u.getdomaininfolist_00000009.num_domains); +- break; + case 0x0000000a: + case 0x0000000b: + case 0x0000000c: + case 0x0000000d: + case 0x0000000e: ++ POST_XEN_SYSCTL_WRITE(getdomaininfolist_00000009, num_domains); ++ if (sysctl->u.getdomaininfolist_00000009.num_domains > 0) ++ POST_MEM_WRITE((Addr)sysctl->u.getdomaininfolist_00000009.buffer.p, ++ sizeof(*sysctl->u.getdomaininfolist_00000009.buffer.p) * ++ sysctl->u.getdomaininfolist_00000009.num_domains); ++ break; + case 0x0000000f: +- POST_XEN_SYSCTL_WRITE(getdomaininfolist_0000000a, num_domains); +- POST_MEM_WRITE((Addr)sysctl->u.getdomaininfolist_0000000a.buffer.p, +- sizeof(*sysctl->u.getdomaininfolist_0000000a.buffer.p) +- * sysctl->u.getdomaininfolist_0000000a.num_domains); +- break; + case 0x00000010: + case 0x00000011: + case 0x00000012: +- POST_XEN_SYSCTL_WRITE(getdomaininfolist_00000010, num_domains); +- POST_MEM_WRITE((Addr)sysctl->u.getdomaininfolist_00000010.buffer.p, +- sizeof(*sysctl->u.getdomaininfolist_00000010.buffer.p) +- * sysctl->u.getdomaininfolist_00000010.num_domains); +- break; ++ case 0x00000013: ++ switch (vki_assumed_xenversion) { ++ case vki_xenversion_412: ++ POST_XEN_SYSCTL_WRITE(getdomaininfolist_0000000f, num_domains); ++ if (sysctl->u.getdomaininfolist_0000000f.num_domains > 0) ++ POST_MEM_WRITE((Addr)sysctl->u.getdomaininfolist_0000000f.buffer.p, ++ sizeof(*sysctl->u.getdomaininfolist_0000000f.buffer.p) * ++ sysctl->u.getdomaininfolist_0000000f.num_domains); ++ break; ++ case vki_xenversion_unset: ++ case vki_xenversion_412_or_413: ++ case vki_xenversion_413: ++ default: ++ POST_XEN_SYSCTL_WRITE(getdomaininfolist_00000012, num_domains); ++ if (sysctl->u.getdomaininfolist_00000012.num_domains > 0) ++ POST_MEM_WRITE((Addr)sysctl->u.getdomaininfolist_00000012.buffer.p, ++ sizeof(*sysctl->u.getdomaininfolist_00000012.buffer.p) * ++ sysctl->u.getdomaininfolist_00000012.num_domains); ++ break; ++ } ++ break; + } + break; + +@@ -1942,6 +2466,7 @@ POST(sysctl) + case 0x00000010: + case 0x00000011: + case 0x00000012: ++ case 0x00000013: + POST_XEN_SYSCTL_WRITE(physinfo_00000010, threads_per_core); + POST_XEN_SYSCTL_WRITE(physinfo_00000010, cores_per_socket); + POST_XEN_SYSCTL_WRITE(physinfo_00000010, nr_cpus); +@@ -1959,27 +2484,124 @@ POST(sysctl) + } + break; + +- case VKI_XEN_SYSCTL_topologyinfo: +- POST_XEN_SYSCTL_WRITE(topologyinfo, max_cpu_index); +- if (sysctl->u.topologyinfo.cpu_to_core.p) +- POST_MEM_WRITE((Addr)sysctl->u.topologyinfo.cpu_to_core.p, +- sizeof(uint32_t) * sysctl->u.topologyinfo.max_cpu_index); +- if (sysctl->u.topologyinfo.cpu_to_socket.p) +- POST_MEM_WRITE((Addr)sysctl->u.topologyinfo.cpu_to_socket.p, +- sizeof(uint32_t) * sysctl->u.topologyinfo.max_cpu_index); +- if (sysctl->u.topologyinfo.cpu_to_node.p) +- POST_MEM_WRITE((Addr)sysctl->u.topologyinfo.cpu_to_node.p, +- sizeof(uint32_t) * sysctl->u.topologyinfo.max_cpu_index); ++ case VKI_XEN_SYSCTL_topologyinfo | VKI_XEN_SYSCTL_cputopoinfo: ++ switch (sysctl->interface_version) ++ { ++ case 0x00000007: ++ case 0x00000008: ++ case 0x00000009: ++ case 0x0000000a: ++ case 0x0000000b: ++ POST_XEN_SYSCTL_WRITE(topologyinfo, max_cpu_index); ++ if (sysctl->u.topologyinfo.cpu_to_core.p) ++ POST_MEM_WRITE((Addr)sysctl->u.topologyinfo.cpu_to_core.p, ++ sizeof(uint32_t) * sysctl->u.topologyinfo.max_cpu_index); ++ if (sysctl->u.topologyinfo.cpu_to_socket.p) ++ POST_MEM_WRITE((Addr)sysctl->u.topologyinfo.cpu_to_socket.p, ++ sizeof(uint32_t) * sysctl->u.topologyinfo.max_cpu_index); ++ if (sysctl->u.topologyinfo.cpu_to_node.p) ++ POST_MEM_WRITE((Addr)sysctl->u.topologyinfo.cpu_to_node.p, ++ sizeof(uint32_t) * sysctl->u.topologyinfo.max_cpu_index); ++ break; ++ case 0x0000000c: ++ case 0x0000000d: ++ case 0x0000000e: ++ case 0x0000000f: ++ case 0x00000010: ++ case 0x00000011: ++ case 0x00000012: ++ case 0x00000013: ++ POST_XEN_SYSCTL_WRITE(cputopoinfo_0000000c, num_cpus); ++ if (sysctl->u.cputopoinfo_0000000c.cputopo.p) ++ POST_MEM_WRITE((Addr)sysctl->u.cputopoinfo_0000000c.cputopo.p, ++ sizeof(vki_xen_sysctl_cputopo_0000000c_t) * sysctl->u.cputopoinfo_0000000c.num_cpus); ++ break; ++ } + break; + + case VKI_XEN_SYSCTL_numainfo: +- POST_XEN_SYSCTL_WRITE(numainfo, max_node_index); +- POST_MEM_WRITE((Addr)sysctl->u.numainfo.node_to_memsize.p, +- sizeof(uint64_t) * sysctl->u.numainfo.max_node_index); +- POST_MEM_WRITE((Addr)sysctl->u.numainfo.node_to_memfree.p, +- sizeof(uint64_t) * sysctl->u.numainfo.max_node_index); +- POST_MEM_WRITE((Addr)sysctl->u.numainfo.node_to_node_distance.p, +- sizeof(uint32_t) * sysctl->u.numainfo.max_node_index); ++ switch (sysctl->interface_version) ++ { ++ case 0x00000008: ++ case 0x00000009: ++ case 0x0000000a: ++ case 0x0000000b: ++ POST_XEN_SYSCTL_WRITE(numainfo_00000008, max_node_index); ++ POST_MEM_WRITE((Addr)sysctl->u.numainfo_00000008.node_to_memsize.p, ++ sizeof(uint64_t) * sysctl->u.numainfo_00000008.max_node_index); ++ POST_MEM_WRITE((Addr)sysctl->u.numainfo_00000008.node_to_memfree.p, ++ sizeof(uint64_t) * sysctl->u.numainfo_00000008.max_node_index); ++ POST_MEM_WRITE((Addr)sysctl->u.numainfo_00000008.node_to_node_distance.p, ++ sizeof(uint32_t) * ++ (sysctl->u.numainfo_00000008.max_node_index * sysctl->u.numainfo_00000008.max_node_index)); ++ break; ++ case 0x0000000c: ++ case 0x0000000d: ++ case 0x0000000e: ++ case 0x0000000f: ++ case 0x00000010: ++ case 0x00000011: ++ case 0x00000012: ++ case 0x00000013: ++ POST_XEN_SYSCTL_WRITE(numainfo_0000000c, num_nodes); ++ POST_MEM_WRITE((Addr)sysctl->u.numainfo_0000000c.meminfo.p, ++ sizeof(uint64_t) * sysctl->u.numainfo_0000000c.num_nodes); ++ POST_MEM_WRITE((Addr)sysctl->u.numainfo_0000000c.distance.p, ++ sizeof(uint32_t) * ++ (sysctl->u.numainfo_0000000c.num_nodes * sysctl->u.numainfo_0000000c.num_nodes)); ++ break; ++ } ++ break; ++ ++ case VKI_XEN_SYSCTL_pcitopoinfo: ++ switch (sysctl->interface_version) ++ { ++ case 0x0000000c: ++ case 0x0000000d: ++ case 0x0000000e: ++ case 0x0000000f: ++ case 0x00000010: ++ case 0x00000011: ++ case 0x00000012: ++ case 0x00000013: ++ POST_XEN_SYSCTL_WRITE(pcitopoinfo_0000000c, num_devs); ++ POST_MEM_WRITE((Addr)sysctl->u.pcitopoinfo_0000000c.nodes.p, ++ sizeof(uint32_t) * sysctl->u.pcitopoinfo_0000000c.num_devs); ++ break; ++ } ++ break; ++ ++ case VKI_XEN_SYSCTL_get_cpu_featureset: ++ switch (sysctl->interface_version) ++ { ++ case 0x0000000d: ++ case 0x0000000e: ++ case 0x0000000f: ++ case 0x00000010: ++ case 0x00000011: ++ case 0x00000012: ++ case 0x00000013: ++ POST_XEN_SYSCTL_WRITE(cpu_featureset_0000000d, nr_features); ++ POST_MEM_WRITE((Addr)sysctl->u.cpu_featureset_0000000d.features.p, ++ sizeof(uint32_t) * sysctl->u.cpu_featureset_0000000d.nr_features); ++ break; ++ } ++ break; ++ ++ case VKI_XEN_SYSCTL_get_cpu_policy: ++ switch (sysctl->interface_version) ++ { ++ case 0x00000012: ++ POST_XEN_SYSCTL_WRITE(get_cpu_policy_00000012, index); ++ POST_XEN_SYSCTL_WRITE(get_cpu_policy_00000012, nr_leaves); ++ POST_XEN_SYSCTL_WRITE(get_cpu_policy_00000012, nr_msrs); ++ POST_XEN_SYSCTL_WRITE(get_cpu_policy_00000012, _rsvd); ++ POST_MEM_WRITE((Addr)sysctl->u.get_cpu_policy_00000012.cpuid_policy.p, ++ sizeof(vki_xen_cpuid_leaf_00000012_t) * sysctl->u.get_cpu_policy_00000012.nr_leaves); ++ POST_MEM_WRITE((Addr)sysctl->u.get_cpu_policy_00000012.msr_policy.p, ++ sizeof(vki_xen_msr_entry_00000012_t) * sysctl->u.get_cpu_policy_00000012.nr_msrs); ++ break; ++ } + break; + + /* No outputs */ +@@ -2045,6 +2667,7 @@ POST(domctl){ + case VKI_XEN_DOMCTL_resumedomain: + case VKI_XEN_DOMCTL_set_vcpu_msrs: + case VKI_XEN_DOMCTL_set_access_required: ++ case VKI_XEN_DOMCTL_soft_reset: + /* No output fields */ + break; + +@@ -2058,7 +2681,7 @@ POST(domctl){ + + case VKI_XEN_DOMCTL_gettscinfo: + switch (domctl->interface_version) { +- case 0x00000007: /* pre-4.6 */ ++ case 0x00000007: + case 0x00000008: + case 0x00000009: + case 0x0000000a: +@@ -2102,14 +2725,34 @@ POST(domctl){ + break; + + case VKI_XEN_DOMCTL_gethvmcontext_partial: +- switch (domctl->u.hvmcontext_partial_00000007.type) { +- case VKI_HVM_SAVE_CODE(CPU): +- if ( domctl->u.hvmcontext_partial_00000007.buffer.p ) +- POST_MEM_WRITE((Addr)domctl->u.hvmcontext_partial_00000007.buffer.p, +- VKI_HVM_SAVE_LENGTH(CPU)); +- break; +- } +- break; ++ switch (domctl->interface_version) { ++ case 0x00000007: ++ case 0x00000008: ++ case 0x00000009: ++ case 0x0000000a: ++ case 0x0000000b: ++ case 0x0000000c: ++ case 0x0000000d: ++ switch (domctl->u.hvmcontext_partial_00000005.type) { ++ case VKI_HVM_SAVE_CODE(CPU): ++ if ( domctl->u.hvmcontext_partial_00000005.buffer.p ) ++ POST_MEM_WRITE((Addr)domctl->u.hvmcontext_partial_00000005.buffer.p, VKI_HVM_SAVE_LENGTH(CPU)); ++ break; ++ } ++ break; ++ case 0x0000000e: ++ case 0x0000000f: ++ case 0x00000011: ++ case 0x00000012: ++ switch (domctl->u.hvmcontext_partial_0000000e.type) { ++ case VKI_HVM_SAVE_CODE(CPU): ++ if ( domctl->u.hvmcontext_partial_0000000e.buffer.p ) ++ POST_MEM_WRITE((Addr)domctl->u.hvmcontext_partial_0000000e.buffer.p, VKI_HVM_SAVE_LENGTH(CPU)); ++ break; ++ } ++ break; ++ } ++ break; + + case VKI_XEN_DOMCTL_scheduler_op: + if ( domctl->u.scheduler_op.cmd == VKI_XEN_DOMCTL_SCHEDOP_getinfo ) { +@@ -2209,10 +2852,6 @@ POST(domctl){ + case 0x0000000c: + case 0x0000000d: + case 0x0000000e: +- case 0x0000000f: +- case 0x00000010: +- case 0x00000011: +- case 0x00000012: + POST_XEN_DOMCTL_WRITE(getdomaininfo_00000009, domain); + POST_XEN_DOMCTL_WRITE(getdomaininfo_00000009, flags); + POST_XEN_DOMCTL_WRITE(getdomaininfo_00000009, tot_pages); +@@ -2228,6 +2867,34 @@ POST(domctl){ + POST_XEN_DOMCTL_WRITE(getdomaininfo_00000009, handle); + POST_XEN_DOMCTL_WRITE(getdomaininfo_00000009, cpupool); + break; ++ case 0x0000000f: ++ case 0x00000010: ++ case 0x00000011: ++ case 0x00000012: ++ POST_XEN_DOMCTL_WRITE(getdomaininfo_0000000f, domain); ++ POST_XEN_DOMCTL_WRITE(getdomaininfo_0000000f, flags); ++ POST_XEN_DOMCTL_WRITE(getdomaininfo_0000000f, tot_pages); ++ POST_XEN_DOMCTL_WRITE(getdomaininfo_0000000f, max_pages); ++ POST_XEN_DOMCTL_WRITE(getdomaininfo_0000000f, outstanding_pages); ++ POST_XEN_DOMCTL_WRITE(getdomaininfo_0000000f, shr_pages); ++ POST_XEN_DOMCTL_WRITE(getdomaininfo_0000000f, paged_pages); ++ POST_XEN_DOMCTL_WRITE(getdomaininfo_0000000f, shared_info_frame); ++ POST_XEN_DOMCTL_WRITE(getdomaininfo_0000000f, cpu_time); ++ POST_XEN_DOMCTL_WRITE(getdomaininfo_0000000f, nr_online_vcpus); ++ POST_XEN_DOMCTL_WRITE(getdomaininfo_0000000f, max_vcpu_id); ++ POST_XEN_DOMCTL_WRITE(getdomaininfo_0000000f, ssidref); ++ POST_XEN_DOMCTL_WRITE(getdomaininfo_0000000f, handle); ++ POST_XEN_DOMCTL_WRITE(getdomaininfo_0000000f, cpupool); ++ POST_XEN_DOMCTL_WRITE(getdomaininfo_0000000f, arch); ++#if defined(__i386__) || defined(__x86_64__) ++ __POST_XEN_DOMCTL_WRITE(getdomaininfo_0000000f, getdomaininfo_0000000f, arch.emulation_flags); ++#endif ++#if defined(__arm__) || defined(__aarch64__) ++ __POST_XEN_DOMCTL_WRITE(getdomaininfo_0000000f, getdomaininfo_0000000f, arch.gic_version); ++ __POST_XEN_DOMCTL_WRITE(getdomaininfo_0000000f, getdomaininfo_0000000f, arch.nr_spis); ++ __POST_XEN_DOMCTL_WRITE(getdomaininfo_0000000f, getdomaininfo_0000000f, arch.clock_frequency); ++#endif ++ break; + } + break; + case VKI_XEN_DOMCTL_getvcpucontext: +@@ -2265,6 +2932,14 @@ POST(domctl){ + break; + + case 0x00000009: ++ case 0x0000000a: ++ case 0x0000000b: ++ case 0x0000000c: ++ case 0x0000000d: ++ case 0x0000000e: ++ case 0x0000000f: ++ case 0x00000011: ++ case 0x00000012: + __POST_XEN_DOMCTL_WRITE(get_ext_vcpucontext, ext_vcpucontext_00000009, size); + #if defined(__i386__) || defined(__x86_64__) + __POST_XEN_DOMCTL_WRITE(get_ext_vcpucontext, ext_vcpucontext_00000009, +@@ -2331,15 +3006,13 @@ POST(domctl){ + domctl->u.vcpu_msrs.msr_count); + break; + +- case VKI_XEN_DOMCTL_mem_event_op: +- //case VKI_XEN_DOMCTL_vm_event_op: /* name change in 4.6 */ ++ case VKI_XEN_DOMCTL_mem_event_op | VKI_XEN_DOMCTL_vm_event_op: + switch (domctl->interface_version) { +- case 0x00000007: /* pre-4.6 */ ++ case 0x00000007: ++ break; + case 0x00000008: + case 0x00000009: + case 0x0000000a: +- __POST_XEN_DOMCTL_WRITE(mem_event_op, mem_event_op_00000007, port); +- break; + case 0x0000000b: + case 0x0000000c: + case 0x0000000d: +@@ -2347,7 +3020,7 @@ POST(domctl){ + case 0x0000000f: + case 0x00000010: + case 0x00000011: +- __POST_XEN_DOMCTL_WRITE(vm_event_op, vm_event_op_0000000b, port); ++ __POST_XEN_DOMCTL_WRITE(mem_event_op, vm_event_op_00000008, port); + break; + case 0x00000012: + __POST_XEN_DOMCTL_WRITE(vm_event_op, vm_event_op_00000012, u.enable.port); +@@ -2357,7 +3030,7 @@ POST(domctl){ + + case VKI_XEN_DOMCTL_monitor_op: + switch (domctl->interface_version) { +- case 0x000000b: ++ case 0x0000000b: + if (domctl->u.monitor_op_0000000b.op == VKI_XEN_DOMCTL_MONITOR_OP_GET_CAPABILITIES) { + switch(domctl->u.monitor_op_0000000b.event) { + case VKI_XEN_DOMCTL_MONITOR_EVENT_WRITE_CTRLREG: +@@ -2371,26 +3044,103 @@ POST(domctl){ + break; + } + } ++ break; ++ case 0x0000000c: ++ case 0x0000000d: ++ if (domctl->u.monitor_op_0000000c.op == VKI_XEN_DOMCTL_MONITOR_OP_GET_CAPABILITIES) { ++ switch(domctl->u.monitor_op_0000000c.event) { ++ case VKI_XEN_DOMCTL_MONITOR_EVENT_WRITE_CTRLREG: ++ __POST_XEN_DOMCTL_WRITE(monitor_op, monitor_op_0000000c, u.mov_to_cr); ++ break; ++ case VKI_XEN_DOMCTL_MONITOR_EVENT_MOV_TO_MSR: ++ __POST_XEN_DOMCTL_WRITE(monitor_op, monitor_op_0000000c, u.mov_to_msr); ++ break; ++ case VKI_XEN_DOMCTL_MONITOR_EVENT_GUEST_REQUEST: ++ __POST_XEN_DOMCTL_WRITE(monitor_op, monitor_op_0000000c, u.guest_request); ++ break; ++ case VKI_XEN_DOMCTL_MONITOR_EVENT_DEBUG_EXCEPTION: ++ __POST_XEN_DOMCTL_WRITE(monitor_op, monitor_op_0000000c, u.debug_exception); ++ break; ++ } ++ } ++ break; ++ case 0x0000000e: ++ case 0x0000000f: ++ if (domctl->u.monitor_op_0000000e.op == VKI_XEN_DOMCTL_MONITOR_OP_GET_CAPABILITIES) { ++ switch(domctl->u.monitor_op_0000000e.event) { ++ case VKI_XEN_DOMCTL_MONITOR_EVENT_WRITE_CTRLREG: ++ __POST_XEN_DOMCTL_WRITE(monitor_op, monitor_op_0000000e, u.mov_to_cr); ++ break; ++ case VKI_XEN_DOMCTL_MONITOR_EVENT_MOV_TO_MSR: ++ __POST_XEN_DOMCTL_WRITE(monitor_op, monitor_op_0000000e, u.mov_to_msr); ++ break; ++ case VKI_XEN_DOMCTL_MONITOR_EVENT_GUEST_REQUEST: ++ __POST_XEN_DOMCTL_WRITE(monitor_op, monitor_op_0000000e, u.guest_request); ++ break; ++ case VKI_XEN_DOMCTL_MONITOR_EVENT_DEBUG_EXCEPTION: ++ __POST_XEN_DOMCTL_WRITE(monitor_op, monitor_op_0000000e, u.debug_exception); ++ break; ++ } ++ } + + break; ++ case 0x0000010: + case 0x0000011: +- if (domctl->u.monitor_op_00000011.op == VKI_XEN_DOMCTL_MONITOR_OP_GET_CAPABILITIES) { +- switch(domctl->u.monitor_op_00000011.event) { ++ case 0x00000012: ++ if (domctl->u.monitor_op_00000010.op == VKI_XEN_DOMCTL_MONITOR_OP_GET_CAPABILITIES) { ++ switch(domctl->u.monitor_op_00000010.event) { + case VKI_XEN_DOMCTL_MONITOR_EVENT_WRITE_CTRLREG: +- __POST_XEN_DOMCTL_WRITE(monitor_op, monitor_op_00000011, u.mov_to_cr); ++ __POST_XEN_DOMCTL_WRITE(monitor_op, monitor_op_00000010, u.mov_to_cr); + break; + case VKI_XEN_DOMCTL_MONITOR_EVENT_MOV_TO_MSR: +- __POST_XEN_DOMCTL_WRITE(monitor_op, monitor_op_00000011, u.mov_to_msr); ++ __POST_XEN_DOMCTL_WRITE(monitor_op, monitor_op_00000010, u.mov_to_msr); + break; + case VKI_XEN_DOMCTL_MONITOR_EVENT_GUEST_REQUEST: +- __POST_XEN_DOMCTL_WRITE(monitor_op, monitor_op_00000011, u.guest_request); ++ __POST_XEN_DOMCTL_WRITE(monitor_op, monitor_op_00000010, u.guest_request); + break; ++ case VKI_XEN_DOMCTL_MONITOR_EVENT_DEBUG_EXCEPTION: ++ __POST_XEN_DOMCTL_WRITE(monitor_op, monitor_op_00000010, u.debug_exception); ++ break; + } + } + + break; + } + break; ++ case VKI_XEN_DOMCTL_get_cpu_policy: ++ switch (domctl->interface_version) { ++ case 0x00000011: ++ case 0x00000012: ++ POST_XEN_DOMCTL_WRITE(cpu_policy_00000011, nr_leaves); ++ POST_XEN_DOMCTL_WRITE(cpu_policy_00000011, nr_msrs); ++ if (domctl->u.cpu_policy_00000011.cpuid_policy.p) ++ POST_MEM_WRITE((Addr)domctl->u.cpu_policy_00000011.cpuid_policy.p, ++ domctl->u.cpu_policy_00000011.nr_leaves); ++ if (domctl->u.cpu_policy_00000011.msr_policy.p) ++ POST_MEM_WRITE((Addr)domctl->u.cpu_policy_00000011.msr_policy.p, ++ domctl->u.cpu_policy_00000011.nr_msrs); ++ break; ++ } ++ break; ++ case VKI_XEN_DOMCTL_set_cpu_policy: ++ switch (domctl->interface_version) { ++ case 0x00000012: ++ POST_XEN_DOMCTL_WRITE(cpu_policy_00000012, nr_leaves); ++ POST_XEN_DOMCTL_WRITE(cpu_policy_00000012, nr_msrs); ++ POST_XEN_DOMCTL_WRITE(cpu_policy_00000012, err_leaf); ++ POST_XEN_DOMCTL_WRITE(cpu_policy_00000012, err_subleaf); ++ POST_XEN_DOMCTL_WRITE(cpu_policy_00000012, err_msr); ++ if (domctl->u.cpu_policy_00000012.cpuid_policy.p) ++ POST_MEM_WRITE((Addr)domctl->u.cpu_policy_00000012.cpuid_policy.p, ++ sizeof(vki_xen_cpuid_leaf_00000012_t) * ++ domctl->u.cpu_policy_00000012.nr_leaves); ++ if (domctl->u.cpu_policy_00000012.msr_policy.p) ++ POST_MEM_WRITE((Addr)domctl->u.cpu_policy_00000012.msr_policy.p, ++ sizeof(vki_xen_msr_entry_00000012_t) * ++ domctl->u.cpu_policy_00000012.nr_msrs); ++ break; ++ } ++ break; + } + + #undef POST_XEN_DOMCTL_WRITE +@@ -2449,6 +3199,14 @@ POST(tmem_op) + } + } + ++POST(dm_op) ++{ ++ unsigned int num = ARG2; ++ struct vki_xen_privcmd_dm_op_buf *args = (void *)(ARG3); ++ ++ POST_MEM_WRITE((Addr) args, sizeof(*args) * num); ++} ++ + typedef + struct { + SyscallTableEntry entry; +@@ -2510,6 +3268,8 @@ static XenHypercallTableEntry hypercall_ + HYPXY(__VKI_XEN_domctl, domctl, 1), // 36 + // __VKI_XEN_kexec_op // 37 + HYPXY(__VKI_XEN_tmem_op, tmem_op, 1), // 38 ++ // __VKI_XEN_xenpmu_op // 40 ++ HYPXY(__VKI_XEN_dm_op, dm_op, 3), // 41 + }; + + static void bad_before ( ThreadId tid, +Index: valgrind-3.16.0/include/vki/vki-xen-domctl.h +=================================================================== +--- valgrind-3.16.0.orig/include/vki/vki-xen-domctl.h ++++ valgrind-3.16.0/include/vki/vki-xen-domctl.h +@@ -28,21 +28,31 @@ + + /* + * The domctl interface is versioned via the interface_version +- * field. This structures in this header supports domctl interfaces: ++ * field. The structures in this header supports domctl interfaces: + * ++ * - 0x00000003: Xen 3.0.3 (unhandled) ++ * - 0x00000004: Xen 3.0.4 (unhandled) ++ * - 0x00000005: Xen 3.1 (unhandled) ++ * - 0x00000006: Xen 4.0 (unhandled) + * - 0x00000007: Xen 4.1 + * - 0x00000008: Xen 4.2 + * - 0x00000009: Xen 4.3 & 4.4 + * - 0x0000000a: Xen 4.5 +- * - 0x0000000b: Xen 4.6 +- * - 0x0000000c: Xen 4.7 ++ * - 0x0000000b: Xen 4.6 & 4.7 ++ * - 0x0000000c: Xen 4.8 ++ * - 0x0000000d: Xen 4.9 ++ * - 0x0000000e: Xen 4.10 ++ * - 0x0000000f: Xen 4.10.1 ++ * - 0x00000010: Xen 4.11 ++ * - 0x00000011: Xen 4.12 ++ * - 0x00000012: Xen 4.13 + * + * When adding a new subop be sure to include the variants used by all + * of the above, both here and in syswrap-xen.c + * + * Structs which are identical in all supported versions have no + * version suffix. Structs which do differ are defined multiple times +- * and use the suffix of the latest version to contain that particular ++ * and use the suffix of the earliest version to contain that particular + * variant. + */ + +@@ -91,11 +101,11 @@ + #define VKI_XEN_DOMCTL_set_target 46 + #define VKI_XEN_DOMCTL_deassign_device 47 + #define VKI_XEN_DOMCTL_unbind_pt_irq 48 +-#define VKI_XEN_DOMCTL_set_cpuid 49 ++#define VKI_XEN_DOMCTL_set_cpuid 49 /* Obsolete in 4.13 */ + #define VKI_XEN_DOMCTL_get_device_group 50 +-#define VKI_XEN_DOMCTL_set_machine_address_size 51 +-#define VKI_XEN_DOMCTL_get_machine_address_size 52 +-#define VKI_XEN_DOMCTL_suppress_spurious_page_faults 53 ++#define VKI_XEN_DOMCTL_set_machine_address_size 51 /* Obsolete in 4.13 */ ++#define VKI_XEN_DOMCTL_get_machine_address_size 52 /* Obsolete in 4.13 */ ++#define VKI_XEN_DOMCTL_suppress_spurious_page_faults 53 /* Obsolete in 4.13 */ + #define VKI_XEN_DOMCTL_debug_op 54 + #define VKI_XEN_DOMCTL_gethvmcontext_partial 55 + #define VKI_XEN_DOMCTL_mem_event_op 56 +@@ -117,19 +127,111 @@ + #define VKI_XEN_DOMCTL_cacheflush 71 + #define VKI_XEN_DOMCTL_get_vcpu_msrs 72 + #define VKI_XEN_DOMCTL_set_vcpu_msrs 73 ++#define VKI_XEN_DOMCTL_setvnumainfo 74 ++#define VKI_XEN_DOMCTL_psr_cmt_op 75 ++#define VKI_XEN_DOMCTL_arm_configure_domain 76 + #define VKI_XEN_DOMCTL_monitor_op 77 /* new in 4.6 */ ++#define VKI_XEN_DOMCTL_psr_cat_op 78 ++#define VKI_XEN_DOMCTL_soft_reset 79 ++#define VKI_XEN_DOMCTL_set_gnttab_limits 80 ++#define VKI_XEN_DOMCTL_vuart_op 81 ++#define VKI_XEN_DOMCTL_get_cpu_policy 82 ++#define VKI_XEN_DOMCTL_set_cpu_policy 83 + #define VKI_XEN_DOMCTL_gdbsx_guestmemio 1000 + #define VKI_XEN_DOMCTL_gdbsx_pausevcpu 1001 + #define VKI_XEN_DOMCTL_gdbsx_unpausevcpu 1002 + #define VKI_XEN_DOMCTL_gdbsx_domstatus 1003 + +-struct vki_xen_domctl_createdomain { ++struct vki_xen_domctl_createdomain_00000004 { + /* IN parameters */ + vki_uint32_t ssidref; + vki_xen_domain_handle_t handle; + vki_uint32_t flags; + }; + ++struct vki_xen_arch_domainconfig_0000000b { ++#if defined(__i386__) || defined(__x86_64__) ++ vki_uint8_t dummy; ++#endif ++#if defined(__arm__) || defined(__aarch64__) ++ /* IN/OUT */ ++ vki_uint8_t gic_version; ++ /* IN */ ++ vki_uint32_t nr_spis; ++ vki_uint32_t clock_frequency; ++#endif ++}; ++ ++/* The layout changed in 4.07, which shares domctl with 4.06 */ ++struct vki_xen_arch_domainconfig_0000000c { ++#if defined(__i386__) || defined(__x86_64__) ++ vki_uint32_t emulation_flags; ++#endif ++#if defined(__arm__) || defined(__aarch64__) ++ /* IN/OUT */ ++ vki_uint8_t gic_version; ++ /* IN */ ++ vki_uint32_t nr_spis; ++ vki_uint32_t clock_frequency; ++#endif ++}; ++ ++struct vki_xen_arch_domainconfig_00000012 { ++#if defined(__i386__) || defined(__x86_64__) ++ vki_uint32_t emulation_flags; ++#endif ++#if defined(__arm__) || defined(__aarch64__) ++ /* IN/OUT */ ++ vki_uint8_t gic_version; ++ /* IN */ ++ vki_uint16_t tee_type; ++ /* IN */ ++ vki_uint32_t nr_spis; ++ vki_uint32_t clock_frequency; ++#endif ++}; ++ ++struct vki_xen_domctl_createdomain_0000000b { ++ /* IN parameters */ ++ vki_uint32_t ssidref; ++ vki_xen_domain_handle_t handle; ++ vki_uint32_t flags; ++ struct vki_xen_arch_domainconfig_0000000b config; ++}; ++ ++struct vki_xen_domctl_createdomain_0000000c { ++ /* IN parameters */ ++ vki_uint32_t ssidref; ++ vki_xen_domain_handle_t handle; ++ vki_uint32_t flags; ++ struct vki_xen_arch_domainconfig_0000000c config; ++}; ++ ++struct vki_xen_domctl_createdomain_00000011 { ++ /* IN parameters */ ++ vki_uint32_t ssidref; ++ vki_xen_domain_handle_t handle; ++ vki_uint32_t flags; ++ vki_uint32_t max_vcpus; ++ vki_uint32_t max_evtchn_port; ++ vki_uint32_t max_grant_frames; ++ vki_uint32_t max_maptrack_frames; ++ struct vki_xen_arch_domainconfig_0000000c config; ++}; ++ ++struct vki_xen_domctl_createdomain_00000012 { ++ /* IN parameters */ ++ vki_uint32_t ssidref; ++ vki_xen_domain_handle_t handle; ++ vki_uint32_t flags; ++ vki_uint32_t iommu_opts; ++ vki_uint32_t max_vcpus; ++ vki_uint32_t max_evtchn_port; ++ vki_uint32_t max_grant_frames; ++ vki_uint32_t max_maptrack_frames; ++ struct vki_xen_arch_domainconfig_00000012 config; ++}; ++ + struct vki_xen_domctl_getdomaininfo_00000007 { + /* OUT variables. */ + vki_xen_domid_t domain; +@@ -137,7 +239,6 @@ struct vki_xen_domctl_getdomaininfo_0000 + vki_xen_uint64_aligned_t tot_pages; + vki_xen_uint64_aligned_t max_pages; + vki_xen_uint64_aligned_t shr_pages; +- vki_xen_uint64_aligned_t paged_pages; + vki_xen_uint64_aligned_t shared_info_frame; + vki_xen_uint64_aligned_t cpu_time; + vki_uint32_t nr_online_vcpus; +@@ -188,12 +289,28 @@ struct vki_xen_domctl_getdomaininfo_0000 + typedef struct vki_xen_domctl_getdomaininfo_00000009 vki_xen_domctl_getdomaininfo_00000009_t; + DEFINE_VKI_XEN_GUEST_HANDLE(vki_xen_domctl_getdomaininfo_00000009_t); + +-// x86 version only for now +-struct vki_xen_arch_domainconfig_00000010 { +- vki_uint32_t emulation_flags; ++struct vki_xen_domctl_getdomaininfo_0000000f { ++ /* OUT variables. */ ++ vki_xen_domid_t domain; ++ vki_uint32_t flags; ++ vki_xen_uint64_aligned_t tot_pages; ++ vki_xen_uint64_aligned_t max_pages; ++ vki_xen_uint64_aligned_t outstanding_pages; ++ vki_xen_uint64_aligned_t shr_pages; ++ vki_xen_uint64_aligned_t paged_pages; ++ vki_xen_uint64_aligned_t shared_info_frame; ++ vki_xen_uint64_aligned_t cpu_time; ++ vki_uint32_t nr_online_vcpus; ++ vki_uint32_t max_vcpu_id; ++ vki_uint32_t ssidref; ++ vki_xen_domain_handle_t handle; ++ vki_uint32_t cpupool; ++ struct vki_xen_arch_domainconfig_0000000c arch; + }; ++typedef struct vki_xen_domctl_getdomaininfo_0000000f vki_xen_domctl_getdomaininfo_0000000f_t; ++DEFINE_VKI_XEN_GUEST_HANDLE(vki_xen_domctl_getdomaininfo_0000000f_t); + +-struct vki_xen_domctl_getdomaininfo_00000010 { ++struct vki_xen_domctl_getdomaininfo_00000012 { + /* OUT variables. */ + vki_xen_domid_t domain; + vki_uint32_t flags; +@@ -209,12 +326,10 @@ struct vki_xen_domctl_getdomaininfo_0000 + vki_uint32_t ssidref; + vki_xen_domain_handle_t handle; + vki_uint32_t cpupool; +- struct vki_xen_arch_domainconfig_00000010 arch; ++ struct vki_xen_arch_domainconfig_00000012 arch; + }; +-typedef struct vki_xen_domctl_getdomaininfo_00000010 vki_xen_domctl_getdomaininfo_00000010_t; +-DEFINE_VKI_XEN_GUEST_HANDLE(vki_xen_domctl_getdomaininfo_00000010_t); +- +-/* vki_xen_domctl_getdomaininfo_0000000a is the same as 00000009 */ ++typedef struct vki_xen_domctl_getdomaininfo_00000012 vki_xen_domctl_getdomaininfo_00000012_t; ++DEFINE_VKI_XEN_GUEST_HANDLE(vki_xen_domctl_getdomaininfo_00000012_t); + + /* Get/set the NUMA node(s) with which the guest has affinity with. */ + /* XEN_DOMCTL_setnodeaffinity */ +@@ -239,6 +354,7 @@ struct vki_xen_domctl_vcpuaffinity_00000 + vki_uint32_t vcpu; /* IN */ + #define VKI_XEN_VCPUAFFINITY_HARD (1U<<0) + #define VKI_XEN_VCPUAFFINITY_SOFT (1U<<1) ++#define VKI_XEN_VCPUAFFINITY_FORCE (1U<<2) + vki_uint32_t flags; /* IN */ + struct vki_xenctl_bitmap cpumap_hard; /* IN/OUT */ + struct vki_xenctl_bitmap cpumap_soft; /* IN/OUT */ +@@ -306,9 +422,12 @@ struct vki_xen_domctl_scheduler_op { + #define VKI_XEN_SCHEDULER_CREDIT2 6 + #define VKI_XEN_SCHEDULER_ARINC653 7 + #define VKI_XEN_SCHEDULER_RTDS 8 ++#define VKI_XEN_SCHEDULER_NULL 9 + vki_uint32_t cmd; /* VKI_XEN_DOMCTL_SCHEDOP_* */ + #define VKI_XEN_DOMCTL_SCHEDOP_putinfo 0 + #define VKI_XEN_DOMCTL_SCHEDOP_getinfo 1 ++#define VKI_XEN_DOMCTL_SCHEDOP_putvcpuinfo 2 ++#define VKI_XEN_DOMCTL_SCHEDOP_getvcpuinfo 3 + union { + struct xen_domctl_sched_sedf { + vki_xen_uint64_aligned_t period; +@@ -357,10 +476,14 @@ struct vki_xen_domctl_hypercall_init { + vki_xen_uint64_aligned_t gmfn; /* GMFN to be initialised */ + }; + +-struct vki_xen_domctl_settimeoffset { ++struct vki_xen_domctl_settimeoffset_00000001 { + vki_int32_t time_offset_seconds; + }; + ++struct vki_xen_domctl_settimeoffset_0000000b { ++ vki_int64_t time_offset_seconds; ++}; ++ + struct vki_xen_domctl_cpuid { + vki_uint32_t input[2]; + vki_uint32_t eax; +@@ -402,13 +525,13 @@ struct vki_xen_domctl_hvmcontext { + typedef struct vki_xen_domctl_hvmcontext vki_xen_domctl_hvmcontext_t; + DEFINE_VKI_XEN_GUEST_HANDLE(vki_xen_domctl_hvmcontext_t); + +-struct vki_xen_domctl_hvmcontext_partial_00000007 { ++struct vki_xen_domctl_hvmcontext_partial_00000005 { + vki_uint32_t type; /* IN */ + vki_uint32_t instance; /* IN */ + VKI_XEN_GUEST_HANDLE_64(vki_uint8) buffer; /* IN/OUT buffer */ + }; +-typedef struct vki_xen_domctl_hvmcontext_partial_00000007 vki_xen_domctl_hvmcontext_partial_00000007_t; +-DEFINE_VKI_XEN_GUEST_HANDLE(vki_xen_domctl_hvmcontext_partial_00000007_t); ++typedef struct vki_xen_domctl_hvmcontext_partial_00000005 vki_xen_domctl_hvmcontext_partial_00000005_t; ++DEFINE_VKI_XEN_GUEST_HANDLE(vki_xen_domctl_hvmcontext_partial_00000005_t); + + struct vki_xen_domctl_hvmcontext_partial_0000000e { + vki_uint32_t type; /* IN */ +@@ -496,6 +619,20 @@ struct vki_xen_domctl_assign_device_0000 + vki_uint32_t flag; /* flag of assigned device */ + }; + ++struct vki_xen_domctl_assign_device_0000000e { ++ vki_uint32_t dev; /* XEN_DOMCTL_DEV_* */ ++ vki_uint32_t flags; ++ union { ++ struct { ++ vki_uint32_t machine_sbdf; /* machine PCI ID of assigned device */ ++ } pci; ++ struct { ++ vki_uint32_t size; /* Length of the path */ ++ VKI_XEN_GUEST_HANDLE_64(vki_uint8) path; /* path to the device tree node */ ++ } dt; ++ } u; ++}; ++ + struct vki_xen_domctl_debug_op { + vki_uint32_t op; /* IN */ + vki_uint32_t vcpu; /* IN */ +@@ -505,11 +642,16 @@ typedef struct vki_xen_domctl_debug_op v + struct vki_xen_domctl_mem_event_op_00000007 { + vki_uint32_t op; /* IN */ + vki_uint32_t mode; /* IN */ +- vki_uint32_t port; /* OUT */ ++ __vki_aligned_u64 shared_addr; /* IN */ ++ __vki_aligned_u64 ring_addr; /* IN */ ++ __vki_aligned_u64 gfn; /* IN */ + }; + +-/* only a name change in 4.6 */ +-typedef struct vki_xen_domctl_mem_event_op_00000007 vki_xen_domctl_vm_event_op_0000000b; ++struct vki_xen_domctl_vm_event_op_00000008 { ++ vki_uint32_t op; /* IN */ ++ vki_uint32_t mode; /* IN */ ++ vki_uint32_t port; /* OUT */ ++}; + + struct vki_xen_domctl_vm_event_op_00000012 { + vki_uint32_t op; /* IN */ +@@ -606,66 +748,113 @@ struct vki_xen_domctl_monitor_op_0000000 + } u; + }; + +-struct vki_xen_domctl_monitor_op_00000011 { ++struct vki_xen_domctl_monitor_op_0000000c { + vki_uint32_t op; /* vki_xen_DOMCTL_MONITOR_OP_* */ +- +- /* +- * When used with ENABLE/DISABLE this has to be set to +- * the requested vki_xen_DOMCTL_MONITOR_EVENT_* value. +- * With GET_CAPABILITIES this field returns a bitmap of +- * events supported by the platform, in the format +- * (1 << vki_xen_DOMCTL_MONITOR_EVENT_*). +- */ + vki_uint32_t event; ++ union { ++ struct { ++ vki_uint8_t index; ++ vki_uint8_t sync; ++ vki_uint8_t onchangeonly; ++ } mov_to_cr; ++ struct { ++ vki_uint32_t msr; ++ } mov_to_msr; ++ struct { ++ vki_uint8_t sync; ++ } guest_request; ++ struct { ++ vki_uint8_t sync; ++ } debug_exception; ++ } u; ++}; + +- /* +- * Further options when issuing vki_xen_DOMCTL_MONITOR_OP_ENABLE. +- */ ++struct vki_xen_domctl_monitor_op_0000000e { ++ vki_uint32_t op; /* vki_xen_DOMCTL_MONITOR_OP_* */ ++ vki_uint32_t event; + union { + struct { +- /* Which control register */ + vki_uint8_t index; +- /* Pause vCPU until response */ + vki_uint8_t sync; +- /* Send event only on a change of value */ + vki_uint8_t onchangeonly; +- /* Allignment padding */ + vki_uint8_t pad1; + vki_uint32_t pad2; +- /* +- * Send event only if the changed bit in the control register +- * is not masked. +- */ + vki_xen_uint64_aligned_t bitmask; + } mov_to_cr; ++ struct { ++ vki_uint32_t msr; ++ } mov_to_msr; ++ struct { ++ vki_uint8_t sync; ++ vki_uint8_t allow_userspace; ++ } guest_request; ++ struct { ++ vki_uint8_t sync; ++ } debug_exception; ++ } u; ++}; + ++struct vki_xen_domctl_monitor_op_00000010 { ++ vki_uint32_t op; /* vki_xen_DOMCTL_MONITOR_OP_* */ ++ vki_uint32_t event; ++ union { ++ struct { ++ vki_uint8_t index; ++ vki_uint8_t sync; ++ vki_uint8_t onchangeonly; ++ vki_uint8_t pad1; ++ vki_uint32_t pad2; ++ vki_xen_uint64_aligned_t bitmask; ++ } mov_to_cr; + struct { + vki_uint32_t msr; + vki_uint8_t onchangeonly; + } mov_to_msr; +- + struct { +- /* Pause vCPU until response */ + vki_uint8_t sync; + vki_uint8_t allow_userspace; + } guest_request; +- + struct { +- /* Pause vCPU until response */ + vki_uint8_t sync; + } debug_exception; + } u; + }; + ++struct vki_xen_domctl_set_gnttab_limits_0000000e { ++ vki_uint32_t grant_frames; ++ vki_uint32_t maptrack_frames; ++}; ++ ++struct vki_xen_domctl_cpu_policy_00000011 { ++ vki_uint32_t nr_leaves; ++ vki_uint32_t nr_msrs; ++ VKI_XEN_GUEST_HANDLE_64(vki_xen_cpuid_leaf_00000012_t) cpuid_policy; ++ VKI_XEN_GUEST_HANDLE_64(vki_xen_msr_entry_00000012_t) msr_policy; ++}; ++ ++struct vki_xen_domctl_cpu_policy_00000012 { ++ vki_uint32_t nr_leaves; ++ vki_uint32_t nr_msrs; ++ VKI_XEN_GUEST_HANDLE_64(vki_xen_cpuid_leaf_00000012_t) cpuid_policy; ++ VKI_XEN_GUEST_HANDLE_64(vki_xen_msr_entry_00000012_t) msr_policy; ++ vki_uint32_t err_leaf, err_subleaf, err_msr; ++}; ++ + struct vki_xen_domctl { + vki_uint32_t cmd; + vki_uint32_t interface_version; /* XEN_DOMCTL_INTERFACE_VERSION */ + vki_xen_domid_t domain; + union { +- struct vki_xen_domctl_createdomain createdomain; ++ struct vki_xen_domctl_createdomain_00000004 createdomain_00000004; ++ struct vki_xen_domctl_createdomain_0000000b createdomain_0000000b; ++ struct vki_xen_domctl_createdomain_0000000c createdomain_0000000c; ++ struct vki_xen_domctl_createdomain_00000011 createdomain_00000011; ++ struct vki_xen_domctl_createdomain_00000012 createdomain_00000012; + struct vki_xen_domctl_getdomaininfo_00000007 getdomaininfo_00000007; + struct vki_xen_domctl_getdomaininfo_00000008 getdomaininfo_00000008; + struct vki_xen_domctl_getdomaininfo_00000009 getdomaininfo_00000009; ++ struct vki_xen_domctl_getdomaininfo_0000000f getdomaininfo_0000000f; ++ struct vki_xen_domctl_getdomaininfo_00000012 getdomaininfo_00000012; + //struct vki_xen_domctl_getmemlist getmemlist; + //struct vki_xen_domctl_getpageframeinfo getpageframeinfo; + //struct vki_xen_domctl_getpageframeinfo2 getpageframeinfo2; +@@ -686,19 +875,21 @@ struct vki_xen_domctl { + struct vki_xen_domctl_ioport_permission ioport_permission; + struct vki_xen_domctl_hypercall_init hypercall_init; + //struct vki_xen_domctl_arch_setup arch_setup; +- struct vki_xen_domctl_settimeoffset settimeoffset; ++ struct vki_xen_domctl_settimeoffset_00000001 settimeoffset_00000001; ++ struct vki_xen_domctl_settimeoffset_0000000b settimeoffset_0000000b; + //struct vki_xen_domctl_disable_migrate disable_migrate; + struct vki_xen_domctl_tsc_info_00000007 tsc_info_00000007; + struct vki_xen_domctl_tsc_info_0000000b tsc_info_0000000b; + //struct vki_xen_domctl_real_mode_area real_mode_area; + struct vki_xen_domctl_hvmcontext hvmcontext; +- struct vki_xen_domctl_hvmcontext_partial_0000000e hvmcontext_partial_00000007; ++ struct vki_xen_domctl_hvmcontext_partial_00000005 hvmcontext_partial_00000005; + struct vki_xen_domctl_hvmcontext_partial_0000000e hvmcontext_partial_0000000e; + struct vki_xen_domctl_address_size address_size; + //struct vki_xen_domctl_sendtrigger sendtrigger; + //struct vki_xen_domctl_get_device_group get_device_group; + struct vki_xen_domctl_assign_device_00000007 assign_device_00000007; + struct vki_xen_domctl_assign_device_0000000b assign_device_0000000b; ++ struct vki_xen_domctl_assign_device_0000000e assign_device_0000000e; + //struct vki_xen_domctl_bind_pt_irq bind_pt_irq; + //struct vki_xen_domctl_memory_mapping memory_mapping; + //struct vki_xen_domctl_ioport_mapping ioport_mapping; +@@ -709,7 +900,7 @@ struct vki_xen_domctl { + //struct vki_xen_domctl_subscribe subscribe; + struct vki_xen_domctl_debug_op debug_op; + struct vki_xen_domctl_mem_event_op_00000007 mem_event_op_00000007; +- vki_xen_domctl_vm_event_op_0000000b vm_event_op_0000000b; ++ struct vki_xen_domctl_vm_event_op_00000008 vm_event_op_00000008; + struct vki_xen_domctl_vm_event_op_00000012 vm_event_op_00000012; + //struct vki_xen_domctl_mem_sharing_op mem_sharing_op; + #if defined(__i386__) || defined(__x86_64__) +@@ -727,7 +918,17 @@ struct vki_xen_domctl { + //struct vki_xen_domctl_gdbsx_pauseunp_vcpu gdbsx_pauseunp_vcpu; + //struct vki_xen_domctl_gdbsx_domstatus gdbsx_domstatus; + struct vki_xen_domctl_monitor_op_0000000b monitor_op_0000000b; +- struct vki_xen_domctl_monitor_op_00000011 monitor_op_00000011; ++ struct vki_xen_domctl_monitor_op_0000000c monitor_op_0000000c; ++ struct vki_xen_domctl_monitor_op_0000000e monitor_op_0000000e; ++ struct vki_xen_domctl_monitor_op_00000010 monitor_op_00000010; ++ //struct vki_xen_domctl_vnuma vnuma; ++ //struct vki_xen_domctl_psr_cmt_op psr_cmt_op; ++ //struct vki_xen_domctl_psr_cat_op psr_cat_op; ++ //struct vki_xen_domctl_arm_configuredomain configuredomain; ++ struct vki_xen_domctl_set_gnttab_limits_0000000e set_gnttab_limits_0000000e; ++ //struct vki_xen_domctl_vuart_op vuart_op; ++ struct vki_xen_domctl_cpu_policy_00000011 cpu_policy_00000011; ++ struct vki_xen_domctl_cpu_policy_00000012 cpu_policy_00000012; + vki_uint8_t pad[128]; + } u; + }; +Index: valgrind-3.16.0/include/vki/vki-xen-sysctl.h +=================================================================== +--- valgrind-3.16.0.orig/include/vki/vki-xen-sysctl.h ++++ valgrind-3.16.0/include/vki/vki-xen-sysctl.h +@@ -3,19 +3,31 @@ + + /* + * The sysctl interface is versioned via the interface_version +- * field. This structures in this header supports sysctl interfaces: ++ * field. The structures in this header supports sysctl interfaces: + * ++ * - 0x00000002: Xen 3.0.3 (unhandled) ++ * - 0x00000003: Xen 3.1.0 (unhandled) ++ * - 0x00000006: Xen 3.2 (unhandled) ++ * - 0x00000007: Xen 4.0 (unhandled) + * - 0x00000008: Xen 4.1 + * - 0x00000009: Xen 4.2 + * - 0x0000000a: Xen 4.3 & 4.4 + * - 0x0000000b: Xen 4.5 ++ * - 0x0000000c: Xen 4.6 ++ * - 0x0000000d: Xen 4.7 ++ * - 0x0000000e: Xen 4.8 ++ * - 0x0000000f: Xen 4.9 ++ * - 0x00000010: Xen 4.10 ++ * - 0x00000011: Xen 4.11 ++ * - 0x00000012: Xen 4.12 & 4.13 ++ * - 0x00000013: Xen 4.14 + * + * When adding a new subop be sure to include the variants used by all + * of the above, both here and in syswrap-xen.c + * + * Structs which are identical in all supported versions have no + * version suffix. Structs which do differ are defined multiple times +- * and use the suffix of the latest version to contain that particular ++ * and use the suffix of the earliest version to contain that particular + * variant. + */ + +@@ -34,10 +46,21 @@ + #define VKI_XEN_SYSCTL_page_offline_op 14 + #define VKI_XEN_SYSCTL_lockprof_op 15 + #define VKI_XEN_SYSCTL_topologyinfo 16 ++#define VKI_XEN_SYSCTL_cputopoinfo 16 /* Since xen-4.6 */ + #define VKI_XEN_SYSCTL_numainfo 17 + #define VKI_XEN_SYSCTL_cpupool_op 18 + #define VKI_XEN_SYSCTL_scheduler_op 19 + #define VKI_XEN_SYSCTL_coverage_op 20 ++#define VKI_XEN_SYSCTL_gcov_op 20 /* Since xen-4.9 */ ++#define VKI_XEN_SYSCTL_psr_cmt_op 21 ++#define VKI_XEN_SYSCTL_pcitopoinfo 22 ++#define VKI_XEN_SYSCTL_psr_cat_op 23 ++#define VKI_XEN_SYSCTL_tmem_op 24 ++#define VKI_XEN_SYSCTL_get_cpu_levelling_caps 25 ++#define VKI_XEN_SYSCTL_get_cpu_featureset 26 ++#define VKI_XEN_SYSCTL_livepatch_op 27 ++#define VKI_XEN_SYSCTL_set_parameter 28 ++#define VKI_XEN_SYSCTL_get_cpu_policy 29 + + struct vki_xen_sysctl_readconsole { + /* IN */ +@@ -60,7 +83,7 @@ struct vki_xen_sysctl_readconsole { + vki_uint32_t count; + }; + +-struct vki_xen_sysctl_getdomaininfolist_00000008 { ++struct vki_xen_sysctl_getdomaininfolist_00000007 { + /* IN variables. */ + vki_xen_domid_t first_domain; + vki_uint32_t max_domains; +@@ -68,8 +91,7 @@ struct vki_xen_sysctl_getdomaininfolist_ + /* OUT variables. */ + vki_uint32_t num_domains; + }; +- +-struct vki_xen_sysctl_getdomaininfolist_00000009 { ++struct vki_xen_sysctl_getdomaininfolist_00000008 { + /* IN variables. */ + vki_xen_domid_t first_domain; + vki_uint32_t max_domains; +@@ -78,7 +100,7 @@ struct vki_xen_sysctl_getdomaininfolist_ + vki_uint32_t num_domains; + }; + +-struct vki_xen_sysctl_getdomaininfolist_0000000a { ++struct vki_xen_sysctl_getdomaininfolist_00000009 { + /* IN variables. */ + vki_xen_domid_t first_domain; + vki_uint32_t max_domains; +@@ -87,16 +109,23 @@ struct vki_xen_sysctl_getdomaininfolist_ + vki_uint32_t num_domains; + }; + +-struct vki_xen_sysctl_getdomaininfolist_00000010 { ++struct vki_xen_sysctl_getdomaininfolist_0000000f { + /* IN variables. */ + vki_xen_domid_t first_domain; + vki_uint32_t max_domains; +- VKI_XEN_GUEST_HANDLE_64(vki_xen_domctl_getdomaininfo_00000010_t) buffer; ++ VKI_XEN_GUEST_HANDLE_64(vki_xen_domctl_getdomaininfo_0000000f_t) buffer; + /* OUT variables. */ + vki_uint32_t num_domains; + }; + +-/* vki_xen_sysctl_getdomaininfolist_0000000b is the same as 0000000a */ ++struct vki_xen_sysctl_getdomaininfolist_00000012 { ++ /* IN variables. */ ++ vki_xen_domid_t first_domain; ++ vki_uint32_t max_domains; ++ VKI_XEN_GUEST_HANDLE_64(vki_xen_domctl_getdomaininfo_00000012_t) buffer; ++ /* OUT variables. */ ++ vki_uint32_t num_domains; ++}; + + #define VKI_XEN_SYSCTL_CPUPOOL_OP_CREATE 1 /* C */ + #define VKI_XEN_SYSCTL_CPUPOOL_OP_DESTROY 2 /* D */ +@@ -129,12 +158,45 @@ struct vki_xen_sysctl_topologyinfo { + VKI_XEN_GUEST_HANDLE_64(vki_uint32) cpu_to_node; + }; + +-struct vki_xen_sysctl_numainfo { ++struct vki_xen_sysctl_cputopo_0000000c { ++ vki_uint32_t core; ++ vki_uint32_t socket; ++ vki_uint32_t node; ++}; ++typedef struct vki_xen_sysctl_cputopo_0000000c vki_xen_sysctl_cputopo_0000000c_t; ++DEFINE_VKI_XEN_GUEST_HANDLE(vki_xen_sysctl_cputopo_0000000c_t); ++ ++struct vki_xen_sysctl_cputopoinfo_0000000c { ++ vki_uint32_t num_cpus; ++ VKI_XEN_GUEST_HANDLE_64(vki_xen_sysctl_cputopo_0000000c_t) cputopo; ++}; ++ ++struct vki_xen_sysctl_pcitopoinfo_0000000c { ++ vki_uint32_t num_devs; ++ VKI_XEN_GUEST_HANDLE_64(vki_physdev_pci_device_t) devs; ++ VKI_XEN_GUEST_HANDLE_64(vki_uint32) nodes; ++}; ++ ++struct vki_xen_sysctl_numainfo_00000008 { + vki_uint32_t max_node_index; + VKI_XEN_GUEST_HANDLE_64(vki_uint64) node_to_memsize; + VKI_XEN_GUEST_HANDLE_64(vki_uint64) node_to_memfree; + VKI_XEN_GUEST_HANDLE_64(vki_uint32) node_to_node_distance; + }; ++ ++struct vki_xen_xen_sysctl_meminfo_0000000c { ++ vki_uint64_t memsize; ++ vki_uint64_t memfree; ++}; ++typedef struct vki_xen_xen_sysctl_meminfo_0000000c vki_xen_xen_sysctl_meminfo_0000000c_t; ++DEFINE_VKI_XEN_GUEST_HANDLE(vki_xen_xen_sysctl_meminfo_0000000c_t); ++ ++struct vki_xen_sysctl_numainfo_0000000c { ++ vki_uint32_t num_nodes; ++ VKI_XEN_GUEST_HANDLE_64(vki_xen_xen_sysctl_meminfo_0000000c_t) meminfo; ++ VKI_XEN_GUEST_HANDLE_64(vki_uint32) distance; ++}; ++ + struct vki_xen_sysctl_physinfo_00000008 { + vki_uint32_t threads_per_core; + vki_uint32_t cores_per_socket; +@@ -191,6 +253,21 @@ struct vki_xen_sysctl_sched_id { + vki_uint32_t sched_id; + }; + ++struct vki_xen_sysctl_cpu_featureset_0000000d { ++ vki_uint32_t index; ++ vki_uint32_t nr_features; ++ VKI_XEN_GUEST_HANDLE_64(vki_uint32) features; ++}; ++ ++struct vki_xen_sysctl_get_cpu_policy_00000012 { ++ vki_uint32_t index; ++ vki_uint32_t nr_leaves; ++ vki_uint64_t nr_msrs; ++ vki_uint64_t _rsvd; ++ VKI_XEN_GUEST_HANDLE_64(vki_xen_cpuid_leaf_00000012_t) cpuid_policy; ++ VKI_XEN_GUEST_HANDLE_64(vki_xen_msr_entry_00000012_t) msr_policy; ++}; ++ + struct vki_xen_sysctl { + vki_uint32_t cmd; + vki_uint32_t interface_version; /* XEN_SYSCTL_INTERFACE_VERSION */ +@@ -201,13 +278,18 @@ struct vki_xen_sysctl { + struct vki_xen_sysctl_physinfo_0000000a physinfo_0000000a; + struct vki_xen_sysctl_physinfo_00000010 physinfo_00000010; + struct vki_xen_sysctl_topologyinfo topologyinfo; +- struct vki_xen_sysctl_numainfo numainfo; ++ struct vki_xen_sysctl_cputopoinfo_0000000c cputopoinfo_0000000c; ++ struct vki_xen_sysctl_pcitopoinfo_0000000c pcitopoinfo_0000000c; ++ struct vki_xen_sysctl_numainfo_00000008 numainfo_00000008; ++ struct vki_xen_sysctl_numainfo_0000000c numainfo_0000000c; + struct vki_xen_sysctl_sched_id sched_id; + //struct vki_xen_sysctl_perfc_op perfc_op; ++ /* getdomaininfolist (sysctl) suffix is the getdomaininfo (domctl) suffix */ ++ struct vki_xen_sysctl_getdomaininfolist_00000007 getdomaininfolist_00000007; + struct vki_xen_sysctl_getdomaininfolist_00000008 getdomaininfolist_00000008; + struct vki_xen_sysctl_getdomaininfolist_00000009 getdomaininfolist_00000009; +- struct vki_xen_sysctl_getdomaininfolist_0000000a getdomaininfolist_0000000a; +- struct vki_xen_sysctl_getdomaininfolist_00000010 getdomaininfolist_00000010; ++ struct vki_xen_sysctl_getdomaininfolist_0000000f getdomaininfolist_0000000f; ++ struct vki_xen_sysctl_getdomaininfolist_00000012 getdomaininfolist_00000012; + struct vki_xen_sysctl_debug_keys debug_keys; + //struct vki_xen_sysctl_getcpuinfo getcpuinfo; + //struct vki_xen_sysctl_availheap availheap; +@@ -219,6 +301,15 @@ struct vki_xen_sysctl { + struct vki_xen_sysctl_cpupool_op cpupool_op; + //struct vki_xen_sysctl_scheduler_op scheduler_op; + //struct vki_xen_sysctl_coverage_op coverage_op; ++ //struct vki_xen_sysctl_gcov_op gcov_op; ++ //struct vki_xen_sysctl_psr_cmt_op psr_cmt_op; ++ //struct vki_xen_sysctl_psr_cat_op psr_cat_op; ++ //struct vki_xen_sysctl_tmem_op tmem_op; ++ //struct vki_xen_sysctl_cpu_levelling_caps cpu_levelling_caps; ++ struct vki_xen_sysctl_cpu_featureset_0000000d cpu_featureset_0000000d; ++ //struct vki_xen_sysctl_livepatch_op livepatch; ++ //struct vki_xen_sysctl_set_parameter set_parameter; ++ struct vki_xen_sysctl_get_cpu_policy_00000012 get_cpu_policy_00000012; + + vki_uint8_t pad[128]; + } u; +Index: valgrind-3.16.0/include/vki/vki-xen-hvm.h +=================================================================== +--- valgrind-3.16.0.orig/include/vki/vki-xen-hvm.h ++++ valgrind-3.16.0/include/vki/vki-xen-hvm.h +@@ -95,7 +95,16 @@ struct vki_xen_hvm_get_mem_access { + typedef struct vki_xen_hvm_get_mem_access vki_xen_hvm_get_mem_access_t; + + #define VKI_XEN_HVMOP_inject_trap 14 +-struct vki_xen_hvm_inject_trap { ++struct vki_xen_hvm_inject_trap_0401 { ++ vki_xen_domid_t domid; ++ vki_uint32_t vcpuid; ++ vki_uint32_t trap; ++ vki_uint32_t error_code; ++ vki_uint64_t cr2; ++}; ++typedef struct vki_xen_hvm_inject_trap_0401 vki_xen_hvm_inject_trap_0401_t; ++ ++struct vki_xen_hvm_inject_trap_0402 { + vki_xen_domid_t domid; + vki_uint32_t vcpuid; + vki_uint32_t vector; +@@ -104,7 +113,7 @@ struct vki_xen_hvm_inject_trap { + vki_uint32_t insn_len; + vki_uint64_t cr2; + }; +-typedef struct vki_xen_hvm_inject_trap vki_xen_hvm_inject_trap_t; ++typedef struct vki_xen_hvm_inject_trap_0402 vki_xen_hvm_inject_trap_0402_t; + + #define VKI_XEN_HVMOP_altp2m 25 + #define VKI_XEN_HVMOP_altp2m_get_domain_state 1 +Index: valgrind-3.16.0/include/vki/vki-xen.h +=================================================================== +--- valgrind-3.16.0.orig/include/vki/vki-xen.h ++++ valgrind-3.16.0/include/vki/vki-xen.h +@@ -67,6 +67,8 @@ + #define __VKI_XEN_kexec_op 37 + #define __VKI_XEN_tmem_op 38 + #define __VKI_XEN_xc_reserved_op 39 /* reserved for XenClient */ ++#define __VKI_XEN_xenpmu_op 40 ++#define __VKI_XEN_dm_op 41 + + #define __DEFINE_VKI_XEN_GUEST_HANDLE(name, type) \ + ___DEFINE_VKI_XEN_GUEST_HANDLE(name, type); \ +@@ -102,6 +104,7 @@ struct vki_xenctl_bitmap { + vki_uint32_t nr_bits; + }; + ++#include + #include + #include + #include +@@ -113,7 +116,6 @@ struct vki_xenctl_bitmap { + #include + #include + #include +-#include + + #endif // __VKI_XEN_H + +Index: valgrind-3.16.0/coregrind/m_syswrap/syswrap-linux.c +=================================================================== +--- valgrind-3.16.0.orig/coregrind/m_syswrap/syswrap-linux.c ++++ valgrind-3.16.0/coregrind/m_syswrap/syswrap-linux.c +@@ -8904,6 +8904,38 @@ PRE(sys_ioctl) + (Addr)args->arr, sizeof(*(args->arr)) * args->num); + break; + } ++ case VKI_XEN_IOCTL_PRIVCMD_DM_OP: { ++ struct vki_xen_privcmd_dm_op *args = ++ (struct vki_xen_privcmd_dm_op *)(ARG3); ++ PRE_MEM_READ("VKI_XEN_IOCTL_PRIVCMD_DM_OP(dom)", ++ (Addr)&args->dom, sizeof(args->dom)); ++ PRE_MEM_READ("VKI_XEN_IOCTL_PRIVCMD_DM_OP(num)", ++ (Addr)&args->num, sizeof(args->num)); ++ PRE_MEM_READ("VKI_XEN_IOCTL_PRIVCMD_DM_OP(ubufs)", ++ (Addr)args->ubufs, sizeof(*(args->ubufs)) * args->num); ++ break; ++ } ++ case VKI_XEN_IOCTL_PRIVCMD_RESTRICT: ++ break; ++ case VKI_XEN_IOCTL_PRIVCMD_MMAP_RESOURCE: { ++ struct vki_xen_privcmd_mmap_resource *args = ++ (struct vki_xen_privcmd_mmap_resource *)(ARG3); ++ PRE_MEM_READ("VKI_XEN_IOCTL_PRIVCMD_MMAP_RESOURCE(dom)", ++ (Addr)&args->dom, sizeof(args->dom)); ++ PRE_MEM_READ("VKI_XEN_IOCTL_PRIVCMD_MMAP_RESOURCE(type)", ++ (Addr)&args->type, sizeof(args->type)); ++ PRE_MEM_READ("VKI_XEN_IOCTL_PRIVCMD_MMAP_RESOURCE(id)", ++ (Addr)&args->id, sizeof(args->id)); ++ PRE_MEM_READ("VKI_XEN_IOCTL_PRIVCMD_MMAP_RESOURCE(idx)", ++ (Addr)&args->idx, sizeof(args->idx)); ++ PRE_MEM_READ("VKI_XEN_IOCTL_PRIVCMD_MMAP_RESOURCE(num)", ++ (Addr)&args->num, sizeof(args->num)); ++ PRE_MEM_READ("VKI_XEN_IOCTL_PRIVCMD_MMAP_RESOURCE(addr)", ++ (Addr)&args->addr, sizeof(args->addr)); ++ break; ++ } ++ case VKI_XEN_IOCTL_PRIVCMD_UNIMPLEMENTED: ++ break; + + case VKI_XEN_IOCTL_EVTCHN_BIND_VIRQ: { + struct vki_xen_ioctl_evtchn_bind_virq *args = +@@ -8945,6 +8977,80 @@ PRE(sys_ioctl) + case VKI_XEN_IOCTL_EVTCHN_RESET: + /* No input*/ + break; ++ case VKI_XEN_IOCTL_GNTDEV_MAP_GRANT_REF: { ++ struct vki_xen_ioctl_gntdev_map_grant_ref *args = ++ (struct vki_xen_ioctl_gntdev_map_grant_ref*)(Addr)(ARG3); ++ PRE_MEM_READ("VKI_XEN_IOCTL_GNTDEV_map_grant_ref(count)", ++ (Addr)&args->count, sizeof(args->count)); ++ PRE_MEM_READ("VKI_XEN_IOCTL_GNTDEV_map_grant_ref(refs)", ++ (Addr)args->refs, sizeof(*(args->refs)) * args->count); ++ } ++ break; ++ case VKI_XEN_IOCTL_GNTDEV_UNMAP_GRANT_REF: { ++ struct vki_xen_ioctl_gntdev_map_grant_ref *args = ++ (struct vki_xen_ioctl_gntdev_map_grant_ref*)(Addr)(ARG3); ++ PRE_MEM_READ("VKI_XEN_IOCTL_GNTDEV_map_grant_ref(index)", ++ (Addr)&args->index, sizeof(args->index)); ++ PRE_MEM_READ("VKI_XEN_IOCTL_GNTDEV_map_grant_ref(count)", ++ (Addr)&args->count, sizeof(args->count)); ++ PRE_MEM_READ("VKI_XEN_IOCTL_GNTDEV_map_grant_ref(pad)", ++ (Addr)&args->pad, sizeof(args->pad)); ++ } ++ break; ++ case VKI_XEN_IOCTL_GNTDEV_GET_OFFSET_FOR_VADDR: { ++ struct vki_xen_ioctl_gntdev_get_offset_for_vaddr *args = ++ (struct vki_xen_ioctl_gntdev_get_offset_for_vaddr*)(Addr)(ARG3); ++ PRE_MEM_READ("VKI_XEN_IOCTL_GNTDEV_map_grant_ref(vaddr)", ++ (Addr)&args->vaddr, sizeof(args->vaddr)); ++ } ++ break; ++ case VKI_XEN_IOCTL_GNTDEV_SET_MAX_GRANTS: { ++ struct vki_xen_ioctl_gntdev_set_max_grants *args = ++ (struct vki_xen_ioctl_gntdev_set_max_grants*)(Addr)(ARG3); ++ PRE_MEM_READ("VKI_XEN_IOCTL_GNTDEV_set_max_grants(count)", ++ (Addr)&args->count, sizeof(args->count)); ++ } ++ break; ++ case VKI_XEN_IOCTL_GNTALLOC_ALLOC_GREF: { ++ struct vki_xen_ioctl_gntalloc_alloc_gref *args = ++ (struct vki_xen_ioctl_gntalloc_alloc_gref*)(Addr)(ARG3); ++ PRE_MEM_READ("VKI_XEN_IOCTL_GNTALLOC_alloc_gref(domid)", ++ (Addr)&args->domid, sizeof(args->domid)); ++ PRE_MEM_READ("VKI_XEN_IOCTL_GNTALLOC_alloc_gref(flags)", ++ (Addr)&args->flags, sizeof(args->flags)); ++ PRE_MEM_READ("VKI_XEN_IOCTL_GNTALLOC_alloc_gref(count)", ++ (Addr)&args->count, sizeof(args->count)); ++ } ++ break; ++ case VKI_XEN_IOCTL_GNTALLOC_DEALLOC_GREF: { ++ struct vki_xen_ioctl_gntalloc_dealloc_gref *args = ++ (struct vki_xen_ioctl_gntalloc_dealloc_gref*)(Addr)(ARG3); ++ PRE_MEM_READ("VKI_XEN_IOCTL_GNTALLOC_dealloc_gref(index)", ++ (Addr)&args->index, sizeof(args->index)); ++ PRE_MEM_READ("VKI_XEN_IOCTL_GNTALLOC_dealloc_gref(count)", ++ (Addr)&args->count, sizeof(args->count)); ++ } ++ break; ++ case VKI_XEN_IOCTL_GNTALLOC_SET_UNMAP_NOTIFY: { ++ struct vki_xen_ioctl_gntalloc_set_unmap_notify *args = ++ (struct vki_xen_ioctl_gntalloc_set_unmap_notify*)(Addr)(ARG3); ++ PRE_MEM_READ("VKI_XEN_IOCTL_GNTALLOC_set_unmap_notify(index)", ++ (Addr)&args->index, sizeof(args->index)); ++ PRE_MEM_READ("VKI_XEN_IOCTL_GNTALLOC_set_unmap_notify(action)", ++ (Addr)&args->action, sizeof(args->action)); ++ PRE_MEM_READ("VKI_XEN_IOCTL_GNTALLOC_set_unmap_notify(event_channel_port)", ++ (Addr)&args->event_channel_port, sizeof(args->event_channel_port)); ++ } ++ break; ++ case VKI_XEN_IOCTL_GNTDEV_GRANT_COPY: { ++ struct vki_xen_ioctl_gntdev_grant_copy *args = ++ (struct vki_xen_ioctl_gntdev_grant_copy*)(Addr)(ARG3); ++ PRE_MEM_READ("VKI_XEN_IOCTL_GNTDEV_grant_copy(count)", ++ (Addr)&args->count, sizeof(args->count)); ++ PRE_MEM_READ("VKI_XEN_IOCTL_GNTDEV_grant_copy(segments)", ++ (Addr)args->segments, sizeof(*(args->segments)) * args->count); ++ } ++ break; + #endif + + /* Lustre */ +@@ -11542,6 +11648,16 @@ POST(sys_ioctl) + POST_MEM_WRITE((Addr)args->err, sizeof(*(args->err)) * args->num); + } + break; ++ case VKI_XEN_IOCTL_PRIVCMD_DM_OP: { ++ struct vki_xen_privcmd_dm_op *args = ++ (struct vki_xen_privcmd_dm_op *)(ARG3); ++ POST_MEM_WRITE((Addr)args->ubufs, sizeof(*(args->ubufs)) * args->num); ++ } ++ break; ++ case VKI_XEN_IOCTL_PRIVCMD_RESTRICT: ++ case VKI_XEN_IOCTL_PRIVCMD_MMAP_RESOURCE: ++ case VKI_XEN_IOCTL_PRIVCMD_UNIMPLEMENTED: ++ break; + + case VKI_XEN_IOCTL_EVTCHN_BIND_VIRQ: + case VKI_XEN_IOCTL_EVTCHN_BIND_INTERDOMAIN: +@@ -11551,6 +11667,44 @@ POST(sys_ioctl) + case VKI_XEN_IOCTL_EVTCHN_RESET: + /* No output */ + break; ++ case VKI_XEN_IOCTL_GNTDEV_MAP_GRANT_REF: { ++ struct vki_xen_ioctl_gntdev_map_grant_ref *args = ++ (struct vki_xen_ioctl_gntdev_map_grant_ref*)(Addr)(ARG3); ++ POST_FIELD_WRITE(args->index); ++ } ++ break; ++ case VKI_XEN_IOCTL_GNTDEV_UNMAP_GRANT_REF: ++ /* No output */ ++ break; ++ case VKI_XEN_IOCTL_GNTDEV_GET_OFFSET_FOR_VADDR: { ++ struct vki_xen_ioctl_gntdev_get_offset_for_vaddr *args = ++ (struct vki_xen_ioctl_gntdev_get_offset_for_vaddr*)(Addr)(ARG3); ++ POST_FIELD_WRITE(args->count); ++ POST_FIELD_WRITE(args->offset); ++ } ++ break; ++ case VKI_XEN_IOCTL_GNTDEV_SET_MAX_GRANTS: ++ /* No output */ ++ break; ++ case VKI_XEN_IOCTL_GNTALLOC_ALLOC_GREF: { ++ struct vki_xen_ioctl_gntalloc_alloc_gref *args = ++ (struct vki_xen_ioctl_gntalloc_alloc_gref*)(Addr)(ARG3); ++ POST_FIELD_WRITE(args->index); ++ POST_FIELD_WRITE(args->count); ++ POST_MEM_WRITE((Addr)&args->gref_ids, ++ sizeof(args->gref_ids) * sizeof(args->count)); ++ } ++ break; ++ case VKI_XEN_IOCTL_GNTALLOC_DEALLOC_GREF: ++ case VKI_XEN_IOCTL_GNTALLOC_SET_UNMAP_NOTIFY: ++ /* No output */ ++ break; ++ case VKI_XEN_IOCTL_GNTDEV_GRANT_COPY: { ++ struct vki_xen_ioctl_gntdev_grant_copy *args = ++ (struct vki_xen_ioctl_gntdev_grant_copy*)(Addr)(ARG3); ++ POST_MEM_WRITE((Addr)args->segments, sizeof(*(args->segments)) * args->count); ++ } ++ break; + #endif + + /* Lustre */ +Index: valgrind-3.16.0/include/vki/vki-linux.h +=================================================================== +--- valgrind-3.16.0.orig/include/vki/vki-linux.h ++++ valgrind-3.16.0/include/vki/vki-linux.h +@@ -3457,12 +3457,37 @@ struct vki_xen_privcmd_mmapbatch_v2 { + int __user *err; /* array of error codes */ + }; + ++struct vki_xen_privcmd_dm_op_buf { ++ void __user *uptr; ++ __vki_kernel_size_t size; ++}; ++ ++struct vki_xen_privcmd_dm_op { ++ __vki_u16 dom; ++ __vki_u16 num; ++ const struct vki_xen_privcmd_dm_op_buf __user *ubufs; ++}; ++ ++struct vki_xen_privcmd_mmap_resource { ++ __vki_u16 dom; ++ __vki_u32 type; ++ __vki_u32 id; ++ __vki_u32 idx; ++ __vki_u64 num; ++ __vki_u64 addr; ++}; ++ + #define VKI_XEN_IOCTL_PRIVCMD_HYPERCALL _VKI_IOC(_VKI_IOC_NONE, 'P', 0, sizeof(struct vki_xen_privcmd_hypercall)) + #define VKI_XEN_IOCTL_PRIVCMD_MMAP _VKI_IOC(_VKI_IOC_NONE, 'P', 2, sizeof(struct vki_xen_privcmd_mmap)) + + #define VKI_XEN_IOCTL_PRIVCMD_MMAPBATCH _VKI_IOC(_VKI_IOC_NONE, 'P', 3, sizeof(struct vki_xen_privcmd_mmapbatch)) + #define VKI_XEN_IOCTL_PRIVCMD_MMAPBATCH_V2 _VKI_IOC(_VKI_IOC_NONE, 'P', 4, sizeof(struct vki_xen_privcmd_mmapbatch_v2)) + ++#define VKI_XEN_IOCTL_PRIVCMD_DM_OP _VKI_IOC(_VKI_IOC_NONE, 'P', 5, sizeof(struct vki_xen_privcmd_dm_op)) ++#define VKI_XEN_IOCTL_PRIVCMD_RESTRICT _VKI_IOC(_VKI_IOC_NONE, 'P', 6, sizeof(__vki_u16)) ++#define VKI_XEN_IOCTL_PRIVCMD_MMAP_RESOURCE _VKI_IOC(_VKI_IOC_NONE, 'P', 7, sizeof(struct vki_xen_privcmd_mmap_resource)) ++#define VKI_XEN_IOCTL_PRIVCMD_UNIMPLEMENTED _VKI_IOC(_VKI_IOC_NONE, 'P', 0xff, 0) ++ + //---------------------------------------------------------------------- + // Xen evtchn IOCTL + //---------------------------------------------------------------------- +@@ -3501,6 +3526,91 @@ struct vki_xen_ioctl_evtchn_notify { + #define VKI_XEN_IOCTL_EVTCHN_RESET \ + _VKI_IOC(_VKI_IOC_NONE, 'E', 5, 0) + ++//---------------------------------------------------------------------- ++// Xen gnttdev IOCTL ++//---------------------------------------------------------------------- ++ ++#define VKI_XEN_IOCTL_GNTDEV_MAP_GRANT_REF \ ++ _VKI_IOC(_VKI_IOC_NONE, 'G', 0, sizeof(struct vki_xen_ioctl_gntdev_map_grant_ref)) ++struct vki_xen_ioctl_gntdev_grant_ref { ++ vki_u32 domid; ++ vki_u32 ref; ++}; ++struct vki_xen_ioctl_gntdev_map_grant_ref { ++ vki_u32 count; ++ vki_u32 pad; ++ __vki_u64 index; ++ struct vki_xen_ioctl_gntdev_grant_ref refs[1]; ++}; ++ ++#define VKI_XEN_IOCTL_GNTDEV_UNMAP_GRANT_REF \ ++ _VKI_IOC(_VKI_IOC_NONE, 'G', 1, sizeof(struct vki_xen_ioctl_gntdev_unmap_grant_ref)) ++struct vki_xen_ioctl_gntdev_unmap_grant_ref { ++ __vki_u64 index; ++ vki_u32 count; ++ vki_u32 pad; ++}; ++ ++#define VKI_XEN_IOCTL_GNTDEV_GET_OFFSET_FOR_VADDR \ ++ _VKI_IOC(_VKI_IOC_NONE, 'G', 2, sizeof(struct vki_xen_ioctl_gntdev_get_offset_for_vaddr)) ++struct vki_xen_ioctl_gntdev_get_offset_for_vaddr { ++ __vki_u64 vaddr; ++ __vki_u64 offset; ++ vki_u32 count; ++ vki_u32 pad; ++}; ++ ++#define VKI_XEN_IOCTL_GNTDEV_SET_MAX_GRANTS \ ++ _VKI_IOC(_VKI_IOC_NONE, 'G', 3, sizeof(struct vki_xen_ioctl_gntdev_set_max_grants)) ++struct vki_xen_ioctl_gntdev_set_max_grants { ++ vki_u32 count; ++}; ++ ++#define VKI_XEN_IOCTL_GNTALLOC_ALLOC_GREF \ ++ _VKI_IOC(_VKI_IOC_NONE, 'G', 5, sizeof(struct vki_xen_ioctl_gntalloc_alloc_gref)) ++struct vki_xen_ioctl_gntalloc_alloc_gref { ++ vki_u16 domid; ++ vki_u16 flags; ++ vki_u32 count; ++ __vki_u64 index; ++ vki_u32 gref_ids[1]; ++}; ++ ++#define VKI_XEN_IOCTL_GNTALLOC_DEALLOC_GREF \ ++ _VKI_IOC(_VKI_IOC_NONE, 'G', 6, sizeof(struct vki_xen_ioctl_gntalloc_dealloc_gref)) ++struct vki_xen_ioctl_gntalloc_dealloc_gref { ++ __vki_u64 index; ++ vki_u32 count; ++}; ++ ++#define VKI_XEN_IOCTL_GNTALLOC_SET_UNMAP_NOTIFY \ ++ _VKI_IOC(_VKI_IOC_NONE, 'G', 7, sizeof(struct vki_xen_ioctl_gntalloc_set_unmap_notify)) ++struct vki_xen_ioctl_gntalloc_set_unmap_notify { ++ __vki_u64 index; ++ vki_u32 action; ++ vki_u32 event_channel_port; ++}; ++ ++#define VKI_XEN_IOCTL_GNTDEV_GRANT_COPY \ ++ _VKI_IOC(_VKI_IOC_NONE, 'G', 8, sizeof(struct vki_xen_ioctl_gntdev_grant_copy)) ++struct vki_xen_gntdev_grant_copy_segment { ++ union { ++ void *virt; ++ struct { ++ vki_u32 ref; /* grant_ref_t */ ++ vki_u16 offset; ++ vki_u16 domid; /* domid_t */ ++ } foreign; ++ } source, dest; ++ vki_u16 len; ++ vki_u16 flags; /* GNTCOPY_* */ ++ __vki_s16 status; /* GNTST_* */ ++}; ++ ++struct vki_xen_ioctl_gntdev_grant_copy { ++ vki_uint32_t count; ++ struct vki_xen_gntdev_grant_copy_segment *segments; ++}; + + //---------------------------------------------------------------------- + // From linux-3.4.0/include/linux/fs.h +Index: valgrind-3.16.0/include/vki/vki-xen-memory.h +=================================================================== +--- valgrind-3.16.0.orig/include/vki/vki-xen-memory.h ++++ valgrind-3.16.0/include/vki/vki-xen-memory.h +@@ -45,9 +45,14 @@ + #define VKI_XENMEM_get_pod_target 17 + #define VKI_XENMEM_get_sharing_freed_pages 18 + #define VKI_XENMEM_get_sharing_shared_pages 19 ++#define VKI_XENMEM_paging_op 20 + #define VKI_XENMEM_access_op 21 ++#define VKI_XENMEM_sharing_op 22 ++#define VKI_XENMEM_add_to_physmap_batch 23 + #define VKI_XENMEM_claim_pages 24 + #define VKI_XENMEM_machphys_compat_mfn_list 25 ++#define VKI_XENMEM_get_vnumainfo 26 ++#define VKI_XENMEM_reserved_device_memory_map 27 + + struct vki_xen_memory_map { + unsigned int nr_entries; +@@ -93,6 +98,14 @@ struct vki_xen_remove_from_physmap { + vki_xen_pfn_t gpfn; + }; + ++struct vki_xen_pod_target { ++ vki_uint64_t target_pages; ++ vki_uint64_t tot_pages; ++ vki_uint64_t pod_cache_pages; ++ vki_uint64_t pod_entries; ++ vki_xen_domid_t domid; ++}; ++ + struct vki_xen_mem_event_op { + vki_uint8_t op; + vki_xen_domid_t domain; +Index: valgrind-3.16.0/include/vki/vki-xen-gnttab.h +=================================================================== +--- valgrind-3.16.0.orig/include/vki/vki-xen-gnttab.h ++++ valgrind-3.16.0/include/vki/vki-xen-gnttab.h +@@ -40,6 +40,7 @@ typedef vki_uint32_t vki_xen_grant_ref_t + #define VKI_XEN_GNTTABOP_get_status_frames 9 + #define VKI_XEN_GNTTABOP_get_version 10 + #define VKI_XEN_GNTTABOP_swap_grant_ref 11 ++#define VKI_XEN_GNTTABOP_cache_flush 12 + + struct vki_xen_gnttab_setup_table { + /* IN parameters. */ +Index: valgrind-3.16.0/include/vki/vki-xen-physdev.h +=================================================================== +--- valgrind-3.16.0.orig/include/vki/vki-xen-physdev.h ++++ valgrind-3.16.0/include/vki/vki-xen-physdev.h +@@ -58,6 +58,15 @@ struct vki_xen_physdev_unmap_pirq { + int pirq; + }; + ++struct vki_physdev_pci_device { ++ /* IN */ ++ vki_uint16_t seg; ++ vki_uint8_t bus; ++ vki_uint8_t devfn; ++}; ++typedef struct vki_physdev_pci_device vki_physdev_pci_device_t; ++DEFINE_VKI_XEN_GUEST_HANDLE(vki_physdev_pci_device_t); ++ + #endif // __VKI_XEN_PHYSDEV_H + + /*--------------------------------------------------------------------*/ +Index: valgrind-3.16.0/include/vki/vki-xen-schedop.h +=================================================================== +--- valgrind-3.16.0.orig/include/vki/vki-xen-schedop.h ++++ valgrind-3.16.0/include/vki/vki-xen-schedop.h +@@ -45,4 +45,6 @@ typedef struct vki_xen_remote_shutdown v + + #define VKI_XEN_SCHEDOP_watchdog 6 + ++#define VKI_XEN_SCHEDOP_pin_override 7 ++ + #endif /* __VKI_XEN_SCHED_OP_H */ +Index: valgrind-3.16.0/include/vki/vki-xen-version.h +=================================================================== +--- valgrind-3.16.0.orig/include/vki/vki-xen-version.h ++++ valgrind-3.16.0/include/vki/vki-xen-version.h +@@ -36,6 +36,7 @@ + #define VKI_XENVER_pagesize 7 + #define VKI_XENVER_guest_handle 8 + #define VKI_XENVER_commandline 9 ++#define VKI_XENVER_build_id 10 + + typedef char vki_xen_extraversion_t[16]; + +@@ -61,6 +62,16 @@ struct vki_xen_feature_info { + + typedef char vki_xen_commandline_t[1024]; + ++struct vki_xen_build_id { ++ unsigned int len; /* IN: size of buf[]. */ ++#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L ++ unsigned char buf[]; ++#elif defined(__GNUC__) ++ unsigned char buf[1]; /* OUT: Variable length buffer with build_id. */ ++#endif ++ ++}; ++ + #endif // __VKI_XEN_VERSION_H + + /*--------------------------------------------------------------------*/ +Index: valgrind-3.16.0/include/vki/vki-xen-x86.h +=================================================================== +--- valgrind-3.16.0.orig/include/vki/vki-xen-x86.h ++++ valgrind-3.16.0/include/vki/vki-xen-x86.h +@@ -281,6 +281,20 @@ struct vki_hvm_hw_mtrr { + + VKI_DECLARE_HVM_SAVE_TYPE(MTRR, 14, struct vki_hvm_hw_mtrr); + ++struct vki_xen_cpuid_leaf_00000012 { ++ vki_uint32_t leaf, subleaf; ++ vki_uint32_t a, b, c, d; ++}; ++typedef struct vki_xen_cpuid_leaf_00000012 vki_xen_cpuid_leaf_00000012_t; ++DEFINE_VKI_XEN_GUEST_HANDLE(vki_xen_cpuid_leaf_00000012_t); ++ ++struct vki_xen_msr_entry_00000012 { ++ vki_uint32_t leaf, subleaf; ++ vki_uint32_t a, b, c, d; ++}; ++typedef struct vki_xen_msr_entry_00000012 vki_xen_msr_entry_00000012_t; ++DEFINE_VKI_XEN_GUEST_HANDLE(vki_xen_msr_entry_00000012_t); ++ + #endif // __VKI_XEN_H + + /*--------------------------------------------------------------------*/