3party/crashpad
0
0
Fork 0
mirror of https://github.com/chromium/crashpad.git synced 2025-03-09 22:26:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

mac: Crashpad for macOS on arm64, phase 2: build tests

Browse Source 
This gets all tests building. They don’t all pass, and there aren’t any
guarantees that anything else works yet, either.

This is mostly a lot of CPU context shuffling.

Bug: crashpad:345
Change-Id: I684017a5816f44917392964d7fb6d08083770b38
Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/2285962
Reviewed-by: Robert Sesek <rsesek@chromium.org>
Commit-Queue: Mark Mentovai <mark@chromium.org>
This commit is contained in:
Mark Mentovai 2020-07-07 23:43:46 -04:00 committed by Commit Bot
parent 809939c9d1
commit 0c3f50c8e1
7 changed files with 189 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
client/simulate_crash_mac_test.cc
View File

@ -200,6 +200,28 @@ class TestSimulateCrashMac final : public MachMultiprocess,
case x86_DEBUG_STATE64:
EXPECT_EQ(old_state_count, x86_DEBUG_STATE64_COUNT);
break;
#elif defined(ARCH_CPU_ARM64)
case ARM_UNIFIED_THREAD_STATE: {
EXPECT_EQ(old_state_count, ARM_UNIFIED_THREAD_STATE_COUNT);
const arm_unified_thread_state* state =
reinterpret_cast<const arm_unified_thread_state*>(old_state);
EXPECT_EQ(state->ash.flavor,
implicit_cast<uint32_t>(ARM_THREAD_STATE64));
if (state->ash.flavor == ARM_THREAD_STATE64) {
EXPECT_EQ(state->ash.count,
implicit_cast<uint32_t>(ARM_THREAD_STATE64_COUNT));
}
break;
}
case ARM_THREAD_STATE64:
EXPECT_EQ(old_state_count, ARM_THREAD_STATE64_COUNT);
break;
case ARM_NEON_STATE64:
EXPECT_EQ(old_state_count, ARM_NEON_STATE64_COUNT);
break;
case ARM_DEBUG_STATE64:
EXPECT_EQ(old_state_count, ARM_DEBUG_STATE64_COUNT);
break;
#else
#error Port to your CPU architecture
#endif
@ -326,18 +348,23 @@ TEST(SimulateCrash, SimulateCrash) {
static constexpr thread_state_flavor_t kFlavors[] = {
#if defined(ARCH_CPU_X86_FAMILY)
x86_THREAD_STATE,
x86_FLOAT_STATE,
x86_DEBUG_STATE,
x86_THREAD_STATE,
x86_FLOAT_STATE,
x86_DEBUG_STATE,
#if defined(ARCH_CPU_X86)
x86_THREAD_STATE32,
x86_FLOAT_STATE32,
x86_DEBUG_STATE32,
x86_THREAD_STATE32,
x86_FLOAT_STATE32,
x86_DEBUG_STATE32,
#elif defined(ARCH_CPU_X86_64)
x86_THREAD_STATE64,
x86_FLOAT_STATE64,
x86_DEBUG_STATE64,
x86_THREAD_STATE64,
x86_FLOAT_STATE64,
x86_DEBUG_STATE64,
#endif
#elif defined(ARCH_CPU_ARM64)
ARM_UNIFIED_THREAD_STATE,
ARM_THREAD_STATE64,
ARM_NEON_STATE64,
ARM_DEBUG_STATE64,
#else
#error Port to your CPU architecture
#endif

2
snapshot/mac/mach_o_image_reader_test.cc
View File

@ -68,6 +68,8 @@ using Nlist = struct nlist;
constexpr int kCPUType = CPU_TYPE_X86_64;
#elif defined(ARCH_CPU_X86)
constexpr int kCPUType = CPU_TYPE_X86;
#elif defined(ARCH_CPU_ARM64)
constexpr int kCPUType = CPU_TYPE_ARM64;
#endif
// Verifies that |expect_section| and |actual_section| agree.

4
snapshot/mac/system_snapshot_mac_test.cc
View File

@ -69,6 +69,8 @@ TEST_F(SystemSnapshotMacTest, GetCPUArchitecture) {
EXPECT_EQ(cpu_architecture, kCPUArchitectureX86);
#elif defined(ARCH_CPU_X86_64)
EXPECT_EQ(cpu_architecture, kCPUArchitectureX86_64);
#elif defined(ARCH_CPU_ARM64)
EXPECT_EQ(cpu_architecture, kCPUArchitectureARM64);
#else
#error port to your architecture
#endif
@ -87,6 +89,8 @@ TEST_F(SystemSnapshotMacTest, CPUVendor) {
if (cpu_vendor != "GenuineIntel" && cpu_vendor != "AuthenticAMD") {
FAIL() << "cpu_vendor " << cpu_vendor;
}
#elif defined(ARCH_CPU_ARM64)
EXPECT_EQ(cpu_vendor, "Apple processor");
#else
#error port to your architecture
#endif

74
util/mach/exc_server_variants_test.cc
View File

@ -1143,43 +1143,47 @@ TEST(ExcServerVariants, ThreadStates) {
mach_msg_type_number_t count;
} test_data[] = {
#if defined(ARCH_CPU_X86_FAMILY)
// For the x86 family, exception handlers can only properly receive the
// thread, float, and exception state flavors. There’s a bug in the kernel
// that causes it to call thread_getstatus() (a wrapper for the more
// familiar thread_get_state()) with an incorrect state buffer size
// parameter when delivering an exception. 10.9.4
// xnu-2422.110.17/osfmk/kern/exception.c exception_deliver() uses the
// _MachineStateCount[] array indexed by the flavor number to obtain the
// buffer size. 10.9.4 xnu-2422.110.17/osfmk/i386/pcb.c contains the
// definition of this array for the x86 family. The slots corresponding to
// thread, float, and exception state flavors in both native-width (32-
// and 64-bit) and universal are correct, but the remaining elements in
// the array are not. This includes elements that would correspond to
// debug and AVX state flavors, so these cannot be tested here.
//
// When machine_thread_get_state() (the machine-specific implementation of
// thread_get_state()) encounters an undersized buffer as reported by the
// buffer size parameter, it returns KERN_INVALID_ARGUMENT, which causes
// exception_deliver() to not actually deliver the exception and instead
// return that error code to exception_triage() as well.
//
// This bug is filed as radar 18312067.
//
// Additionaly, the AVX state flavors are also not tested because they’re
// not available on all CPUs and OS versions.
// For the x86 family, exception handlers can only properly receive the
// thread, float, and exception state flavors. There’s a bug in the kernel
// that causes it to call thread_getstatus() (a wrapper for the more
// familiar thread_get_state()) with an incorrect state buffer size
// parameter when delivering an exception. 10.9.4
// xnu-2422.110.17/osfmk/kern/exception.c exception_deliver() uses the
// _MachineStateCount[] array indexed by the flavor number to obtain the
// buffer size. 10.9.4 xnu-2422.110.17/osfmk/i386/pcb.c contains the
// definition of this array for the x86 family. The slots corresponding to
// thread, float, and exception state flavors in both native-width (32- and
// 64-bit) and universal are correct, but the remaining elements in the
// array are not. This includes elements that would correspond to debug and
// AVX state flavors, so these cannot be tested here.
//
// When machine_thread_get_state() (the machine-specific implementation of
// thread_get_state()) encounters an undersized buffer as reported by the
// buffer size parameter, it returns KERN_INVALID_ARGUMENT, which causes
// exception_deliver() to not actually deliver the exception and instead
// return that error code to exception_triage() as well.
//
// This bug is filed as radar 18312067.
//
// Additionaly, the AVX state flavors are also not tested because they’re
// not available on all CPUs and OS versions.
{x86_THREAD_STATE, x86_THREAD_STATE_COUNT},
{x86_FLOAT_STATE, x86_FLOAT_STATE_COUNT},
{x86_EXCEPTION_STATE, x86_EXCEPTION_STATE_COUNT},
#if defined(ARCH_CPU_X86)
{x86_THREAD_STATE32, x86_THREAD_STATE32_COUNT},
{x86_FLOAT_STATE32, x86_FLOAT_STATE32_COUNT},
{x86_EXCEPTION_STATE32, x86_EXCEPTION_STATE32_COUNT},
{x86_THREAD_STATE32, x86_THREAD_STATE32_COUNT},
{x86_FLOAT_STATE32, x86_FLOAT_STATE32_COUNT},
{x86_EXCEPTION_STATE32, x86_EXCEPTION_STATE32_COUNT},
#elif defined(ARCH_CPU_X86_64)
{x86_THREAD_STATE64, x86_THREAD_STATE64_COUNT},
{x86_FLOAT_STATE64, x86_FLOAT_STATE64_COUNT},
{x86_EXCEPTION_STATE64, x86_EXCEPTION_STATE64_COUNT},
#endif
#if defined(ARCH_CPU_X86_64)
{x86_THREAD_STATE64, x86_THREAD_STATE64_COUNT},
{x86_FLOAT_STATE64, x86_FLOAT_STATE64_COUNT},
{x86_EXCEPTION_STATE64, x86_EXCEPTION_STATE64_COUNT},
#endif
{x86_THREAD_STATE, x86_THREAD_STATE_COUNT},
{x86_FLOAT_STATE, x86_FLOAT_STATE_COUNT},
{x86_EXCEPTION_STATE, x86_EXCEPTION_STATE_COUNT},
#elif defined(ARCH_CPU_ARM64)
{ARM_UNIFIED_THREAD_STATE, ARM_UNIFIED_THREAD_STATE_COUNT},
{ARM_THREAD_STATE64, ARM_THREAD_STATE64_COUNT},
{ARM_NEON_STATE64, ARM_NEON_STATE64_COUNT},
{ARM_EXCEPTION_STATE64, ARM_EXCEPTION_STATE64_COUNT},
#else
#error Port this test to your CPU architecture.
#endif

197
util/mach/exception_types_test.cc
View File

@ -37,34 +37,37 @@ TEST(ExceptionTypes, ExcCrashRecoverOriginalException) {
mach_exception_code_t original_code_0;
int signal;
} kTestData[] = {
{0xb100001, EXC_BAD_ACCESS, KERN_INVALID_ADDRESS, SIGSEGV},
{0xb100002, EXC_BAD_ACCESS, KERN_PROTECTION_FAILURE, SIGSEGV},
{0xa100002, EXC_BAD_ACCESS, KERN_PROTECTION_FAILURE, SIGBUS},
{0xa100005, EXC_BAD_ACCESS, VM_PROT_READ | VM_PROT_EXECUTE, SIGBUS},
{0xa10000d, EXC_BAD_ACCESS, EXC_I386_GPFLT, SIGBUS},
{0x9100032, EXC_BAD_ACCESS, KERN_CODESIGN_ERROR, SIGKILL},
{0x4200001, EXC_BAD_INSTRUCTION, EXC_I386_INVOP, SIGILL},
{0x420000b, EXC_BAD_INSTRUCTION, EXC_I386_SEGNPFLT, SIGILL},
{0x420000c, EXC_BAD_INSTRUCTION, EXC_I386_STKFLT, SIGILL},
{0x8300001, EXC_ARITHMETIC, EXC_I386_DIV, SIGFPE},
{0x8300002, EXC_ARITHMETIC, EXC_I386_INTO, SIGFPE},
{0x8300005, EXC_ARITHMETIC, EXC_I386_EXTERR, SIGFPE},
{0x8300008, EXC_ARITHMETIC, EXC_I386_SSEEXTERR, SIGFPE},
{0x5500007, EXC_SOFTWARE, EXC_I386_BOUND, SIGTRAP},
{0x5600001, EXC_BREAKPOINT, EXC_I386_SGL, SIGTRAP},
{0x5600002, EXC_BREAKPOINT, EXC_I386_BPT, SIGTRAP},
{0x0700080, EXC_SYSCALL, 128, 0},
{0x0706000, EXC_SYSCALL, 0x6000, 0},
{0x3000000, 0, 0, SIGQUIT},
{0x4000000, 0, 0, SIGILL},
{0x5000000, 0, 0, SIGTRAP},
{0x6000000, 0, 0, SIGABRT},
{0x7000000, 0, 0, SIGEMT},
{0x8000000, 0, 0, SIGFPE},
{0xa000000, 0, 0, SIGBUS},
{0xb000000, 0, 0, SIGSEGV},
{0xc000000, 0, 0, SIGSYS},
{0, 0, 0, 0},
{0xb100001, EXC_BAD_ACCESS, KERN_INVALID_ADDRESS, SIGSEGV},
{0xb100002, EXC_BAD_ACCESS, KERN_PROTECTION_FAILURE, SIGSEGV},
{0xa100002, EXC_BAD_ACCESS, KERN_PROTECTION_FAILURE, SIGBUS},
{0xa100005, EXC_BAD_ACCESS, VM_PROT_READ | VM_PROT_EXECUTE, SIGBUS},
{0x9100032, EXC_BAD_ACCESS, KERN_CODESIGN_ERROR, SIGKILL},
{0x0700080, EXC_SYSCALL, 128, 0},
{0x0706000, EXC_SYSCALL, 0x6000, 0},
{0x3000000, 0, 0, SIGQUIT},
{0x4000000, 0, 0, SIGILL},
{0x5000000, 0, 0, SIGTRAP},
{0x6000000, 0, 0, SIGABRT},
{0x7000000, 0, 0, SIGEMT},
{0x8000000, 0, 0, SIGFPE},
{0xa000000, 0, 0, SIGBUS},
{0xb000000, 0, 0, SIGSEGV},
{0xc000000, 0, 0, SIGSYS},
{0, 0, 0, 0},
#if defined(ARCH_CPU_X86_FAMILY)
{0xa10000d, EXC_BAD_ACCESS, EXC_I386_GPFLT, SIGBUS},
{0x4200001, EXC_BAD_INSTRUCTION, EXC_I386_INVOP, SIGILL},
{0x420000b, EXC_BAD_INSTRUCTION, EXC_I386_SEGNPFLT, SIGILL},
{0x420000c, EXC_BAD_INSTRUCTION, EXC_I386_STKFLT, SIGILL},
{0x8300001, EXC_ARITHMETIC, EXC_I386_DIV, SIGFPE},
{0x8300002, EXC_ARITHMETIC, EXC_I386_INTO, SIGFPE},
{0x8300005, EXC_ARITHMETIC, EXC_I386_EXTERR, SIGFPE},
{0x8300008, EXC_ARITHMETIC, EXC_I386_SSEEXTERR, SIGFPE},
{0x5500007, EXC_SOFTWARE, EXC_I386_BOUND, SIGTRAP},
{0x5600001, EXC_BREAKPOINT, EXC_I386_SGL, SIGTRAP},
{0x5600002, EXC_BREAKPOINT, EXC_I386_BPT, SIGTRAP},
#endif
// TODO(macos_arm64): Add arm64 test data.
};
for (size_t index = 0; index < base::size(kTestData); ++index) {
@ -139,23 +142,26 @@ TEST(ExceptionTypes, ExceptionCodeForMetrics) {
} kTestData[] = {
#define ENCODE_EXC(type, code_0) \
{ (type), (code_0), ((type) << 16) | (code_0) }
ENCODE_EXC(EXC_BAD_ACCESS, KERN_INVALID_ADDRESS),
ENCODE_EXC(EXC_BAD_ACCESS, KERN_PROTECTION_FAILURE),
ENCODE_EXC(EXC_BAD_ACCESS, VM_PROT_READ | VM_PROT_EXECUTE),
ENCODE_EXC(EXC_BAD_ACCESS, EXC_I386_GPFLT),
ENCODE_EXC(EXC_BAD_ACCESS, KERN_CODESIGN_ERROR),
ENCODE_EXC(EXC_BAD_INSTRUCTION, EXC_I386_INVOP),
ENCODE_EXC(EXC_BAD_INSTRUCTION, EXC_I386_SEGNPFLT),
ENCODE_EXC(EXC_BAD_INSTRUCTION, EXC_I386_STKFLT),
ENCODE_EXC(EXC_ARITHMETIC, EXC_I386_DIV),
ENCODE_EXC(EXC_ARITHMETIC, EXC_I386_INTO),
ENCODE_EXC(EXC_ARITHMETIC, EXC_I386_EXTERR),
ENCODE_EXC(EXC_ARITHMETIC, EXC_I386_SSEEXTERR),
ENCODE_EXC(EXC_SOFTWARE, EXC_I386_BOUND),
ENCODE_EXC(EXC_BREAKPOINT, EXC_I386_SGL),
ENCODE_EXC(EXC_BREAKPOINT, EXC_I386_BPT),
ENCODE_EXC(EXC_SYSCALL, 128),
ENCODE_EXC(EXC_SYSCALL, 0x6000),
ENCODE_EXC(EXC_BAD_ACCESS, KERN_INVALID_ADDRESS),
ENCODE_EXC(EXC_BAD_ACCESS, KERN_PROTECTION_FAILURE),
ENCODE_EXC(EXC_BAD_ACCESS, VM_PROT_READ | VM_PROT_EXECUTE),
ENCODE_EXC(EXC_BAD_ACCESS, KERN_CODESIGN_ERROR),
ENCODE_EXC(EXC_SYSCALL, 128),
ENCODE_EXC(EXC_SYSCALL, 0x6000),
#if defined(ARCH_CPU_X86_FAMILY)
ENCODE_EXC(EXC_BAD_ACCESS, EXC_I386_GPFLT),
ENCODE_EXC(EXC_BAD_INSTRUCTION, EXC_I386_INVOP),
ENCODE_EXC(EXC_BAD_INSTRUCTION, EXC_I386_SEGNPFLT),
ENCODE_EXC(EXC_BAD_INSTRUCTION, EXC_I386_STKFLT),
ENCODE_EXC(EXC_ARITHMETIC, EXC_I386_DIV),
ENCODE_EXC(EXC_ARITHMETIC, EXC_I386_INTO),
ENCODE_EXC(EXC_ARITHMETIC, EXC_I386_EXTERR),
ENCODE_EXC(EXC_ARITHMETIC, EXC_I386_SSEEXTERR),
ENCODE_EXC(EXC_SOFTWARE, EXC_I386_BOUND),
ENCODE_EXC(EXC_BREAKPOINT, EXC_I386_SGL),
ENCODE_EXC(EXC_BREAKPOINT, EXC_I386_BPT),
#endif
// TODO(macos_arm64): Add arm64 test data.
#undef ENCODE_EXC
#define ENCODE_EXC_CRASH(type, code_0) \
@ -163,36 +169,39 @@ TEST(ExceptionTypes, ExceptionCodeForMetrics) {
EXC_CRASH, (((type) & 0xf) << 20) | ((code_0) & 0xfffff), \
((type) << 16) | (code_0) \
}
ENCODE_EXC_CRASH(EXC_BAD_ACCESS, KERN_INVALID_ADDRESS),
ENCODE_EXC_CRASH(EXC_BAD_ACCESS, KERN_PROTECTION_FAILURE),
ENCODE_EXC_CRASH(EXC_BAD_ACCESS, VM_PROT_READ | VM_PROT_EXECUTE),
ENCODE_EXC_CRASH(EXC_BAD_ACCESS, EXC_I386_GPFLT),
ENCODE_EXC_CRASH(EXC_BAD_ACCESS, KERN_CODESIGN_ERROR),
ENCODE_EXC_CRASH(EXC_BAD_INSTRUCTION, EXC_I386_INVOP),
ENCODE_EXC_CRASH(EXC_BAD_INSTRUCTION, EXC_I386_SEGNPFLT),
ENCODE_EXC_CRASH(EXC_BAD_INSTRUCTION, EXC_I386_STKFLT),
ENCODE_EXC_CRASH(EXC_ARITHMETIC, EXC_I386_DIV),
ENCODE_EXC_CRASH(EXC_ARITHMETIC, EXC_I386_INTO),
ENCODE_EXC_CRASH(EXC_ARITHMETIC, EXC_I386_EXTERR),
ENCODE_EXC_CRASH(EXC_ARITHMETIC, EXC_I386_SSEEXTERR),
ENCODE_EXC_CRASH(EXC_SOFTWARE, EXC_I386_BOUND),
ENCODE_EXC_CRASH(EXC_BREAKPOINT, EXC_I386_SGL),
ENCODE_EXC_CRASH(EXC_BREAKPOINT, EXC_I386_BPT),
ENCODE_EXC_CRASH(EXC_SYSCALL, 128),
ENCODE_EXC_CRASH(EXC_SYSCALL, 0x6000),
ENCODE_EXC_CRASH(EXC_BAD_ACCESS, KERN_INVALID_ADDRESS),
ENCODE_EXC_CRASH(EXC_BAD_ACCESS, KERN_PROTECTION_FAILURE),
ENCODE_EXC_CRASH(EXC_BAD_ACCESS, VM_PROT_READ | VM_PROT_EXECUTE),
ENCODE_EXC_CRASH(EXC_BAD_ACCESS, KERN_CODESIGN_ERROR),
ENCODE_EXC_CRASH(EXC_SYSCALL, 128),
ENCODE_EXC_CRASH(EXC_SYSCALL, 0x6000),
#if defined(ARCH_CPU_X86_FAMILY)
ENCODE_EXC_CRASH(EXC_BAD_ACCESS, EXC_I386_GPFLT),
ENCODE_EXC_CRASH(EXC_BAD_INSTRUCTION, EXC_I386_INVOP),
ENCODE_EXC_CRASH(EXC_BAD_INSTRUCTION, EXC_I386_SEGNPFLT),
ENCODE_EXC_CRASH(EXC_BAD_INSTRUCTION, EXC_I386_STKFLT),
ENCODE_EXC_CRASH(EXC_ARITHMETIC, EXC_I386_DIV),
ENCODE_EXC_CRASH(EXC_ARITHMETIC, EXC_I386_INTO),
ENCODE_EXC_CRASH(EXC_ARITHMETIC, EXC_I386_EXTERR),
ENCODE_EXC_CRASH(EXC_ARITHMETIC, EXC_I386_SSEEXTERR),
ENCODE_EXC_CRASH(EXC_SOFTWARE, EXC_I386_BOUND),
ENCODE_EXC_CRASH(EXC_BREAKPOINT, EXC_I386_SGL),
ENCODE_EXC_CRASH(EXC_BREAKPOINT, EXC_I386_BPT),
#endif
// TODO(macos_arm64): Add arm64 test data.
#undef ENCODE_EXC_CRASH
#define ENCODE_EXC_CRASH_SIGNAL(signal) \
{ EXC_CRASH, (((signal) & 0xff) << 24), (EXC_CRASH << 16) | (signal) }
ENCODE_EXC_CRASH_SIGNAL(SIGQUIT),
ENCODE_EXC_CRASH_SIGNAL(SIGILL),
ENCODE_EXC_CRASH_SIGNAL(SIGTRAP),
ENCODE_EXC_CRASH_SIGNAL(SIGABRT),
ENCODE_EXC_CRASH_SIGNAL(SIGEMT),
ENCODE_EXC_CRASH_SIGNAL(SIGFPE),
ENCODE_EXC_CRASH_SIGNAL(SIGBUS),
ENCODE_EXC_CRASH_SIGNAL(SIGSEGV),
ENCODE_EXC_CRASH_SIGNAL(SIGSYS),
ENCODE_EXC_CRASH_SIGNAL(SIGQUIT),
ENCODE_EXC_CRASH_SIGNAL(SIGILL),
ENCODE_EXC_CRASH_SIGNAL(SIGTRAP),
ENCODE_EXC_CRASH_SIGNAL(SIGABRT),
ENCODE_EXC_CRASH_SIGNAL(SIGEMT),
ENCODE_EXC_CRASH_SIGNAL(SIGFPE),
ENCODE_EXC_CRASH_SIGNAL(SIGBUS),
ENCODE_EXC_CRASH_SIGNAL(SIGSEGV),
ENCODE_EXC_CRASH_SIGNAL(SIGSYS),
#undef ENCODE_EXC_CRASH_SIGNAL
#define ENCODE_EXC_RESOURCE(type, flavor) \
@ -200,12 +209,12 @@ TEST(ExceptionTypes, ExceptionCodeForMetrics) {
EXC_RESOURCE, EXC_RESOURCE_ENCODE_TYPE_FLAVOR((type), (flavor)), \
(EXC_RESOURCE << 16) | ((type) << 8) | (flavor) \
}
ENCODE_EXC_RESOURCE(RESOURCE_TYPE_CPU, FLAVOR_CPU_MONITOR),
ENCODE_EXC_RESOURCE(RESOURCE_TYPE_CPU, FLAVOR_CPU_MONITOR_FATAL),
ENCODE_EXC_RESOURCE(RESOURCE_TYPE_WAKEUPS, FLAVOR_WAKEUPS_MONITOR),
ENCODE_EXC_RESOURCE(RESOURCE_TYPE_MEMORY, FLAVOR_HIGH_WATERMARK),
ENCODE_EXC_RESOURCE(RESOURCE_TYPE_IO, FLAVOR_IO_PHYSICAL_WRITES),
ENCODE_EXC_RESOURCE(RESOURCE_TYPE_IO, FLAVOR_IO_LOGICAL_WRITES),
ENCODE_EXC_RESOURCE(RESOURCE_TYPE_CPU, FLAVOR_CPU_MONITOR),
ENCODE_EXC_RESOURCE(RESOURCE_TYPE_CPU, FLAVOR_CPU_MONITOR_FATAL),
ENCODE_EXC_RESOURCE(RESOURCE_TYPE_WAKEUPS, FLAVOR_WAKEUPS_MONITOR),
ENCODE_EXC_RESOURCE(RESOURCE_TYPE_MEMORY, FLAVOR_HIGH_WATERMARK),
ENCODE_EXC_RESOURCE(RESOURCE_TYPE_IO, FLAVOR_IO_PHYSICAL_WRITES),
ENCODE_EXC_RESOURCE(RESOURCE_TYPE_IO, FLAVOR_IO_LOGICAL_WRITES),
#undef ENCODE_EXC_RESOURCE
#define ENCODE_EXC_GUARD(type, flavor) \
@ -216,26 +225,26 @@ TEST(ExceptionTypes, ExceptionCodeForMetrics) {
(static_cast<uint64_t>((1 << (flavor)) & 0x1ffffffff) << 32), \
(EXC_GUARD << 16) | ((type) << 8) | (flavor) \
}
ENCODE_EXC_GUARD(GUARD_TYPE_MACH_PORT, 0), // kGUARD_EXC_DESTROY
ENCODE_EXC_GUARD(GUARD_TYPE_MACH_PORT, 1), // kGUARD_EXC_MOD_REFS
ENCODE_EXC_GUARD(GUARD_TYPE_MACH_PORT, 2), // kGUARD_EXC_SET_CONTEXT
ENCODE_EXC_GUARD(GUARD_TYPE_MACH_PORT, 3), // kGUARD_EXC_UNGUARDED
ENCODE_EXC_GUARD(GUARD_TYPE_MACH_PORT, 4), // kGUARD_EXC_INCORRECT_GUARD
ENCODE_EXC_GUARD(GUARD_TYPE_MACH_PORT, 0), // kGUARD_EXC_DESTROY
ENCODE_EXC_GUARD(GUARD_TYPE_MACH_PORT, 1), // kGUARD_EXC_MOD_REFS
ENCODE_EXC_GUARD(GUARD_TYPE_MACH_PORT, 2), // kGUARD_EXC_SET_CONTEXT
ENCODE_EXC_GUARD(GUARD_TYPE_MACH_PORT, 3), // kGUARD_EXC_UNGUARDED
ENCODE_EXC_GUARD(GUARD_TYPE_MACH_PORT, 4), // kGUARD_EXC_INCORRECT_GUARD
// 2 is GUARD_TYPE_FD from 10.12.2 xnu-3789.31.2/bsd/sys/guarded.h.
ENCODE_EXC_GUARD(2, 0), // kGUARD_EXC_CLOSE
ENCODE_EXC_GUARD(2, 1), // kGUARD_EXC_DUP
ENCODE_EXC_GUARD(2, 2), // kGUARD_EXC_NOCLOEXEC
ENCODE_EXC_GUARD(2, 3), // kGUARD_EXC_SOCKET_IPC
ENCODE_EXC_GUARD(2, 4), // kGUARD_EXC_FILEPORT
ENCODE_EXC_GUARD(2, 5), // kGUARD_EXC_MISMATCH
ENCODE_EXC_GUARD(2, 6), // kGUARD_EXC_WRITE
// 2 is GUARD_TYPE_FD from 10.12.2 xnu-3789.31.2/bsd/sys/guarded.h.
ENCODE_EXC_GUARD(2, 0), // kGUARD_EXC_CLOSE
ENCODE_EXC_GUARD(2, 1), // kGUARD_EXC_DUP
ENCODE_EXC_GUARD(2, 2), // kGUARD_EXC_NOCLOEXEC
ENCODE_EXC_GUARD(2, 3), // kGUARD_EXC_SOCKET_IPC
ENCODE_EXC_GUARD(2, 4), // kGUARD_EXC_FILEPORT
ENCODE_EXC_GUARD(2, 5), // kGUARD_EXC_MISMATCH
ENCODE_EXC_GUARD(2, 6), // kGUARD_EXC_WRITE
#undef ENCODE_EXC_GUARD
// Test that overflow saturates.
{0x00010000, 0x00001000, static_cast<int32_t>(0xffff1000)},
{0x00001000, 0x00010000, 0x1000ffff},
{0x00010000, 0x00010000, static_cast<int32_t>(0xffffffff)},
// Test that overflow saturates.
{0x00010000, 0x00001000, static_cast<int32_t>(0xffff1000)},
{0x00001000, 0x00010000, 0x1000ffff},
{0x00010000, 0x00010000, static_cast<int32_t>(0xffffffff)},
};
for (size_t index = 0; index < base::size(kTestData); ++index) {

2
util/mach/mach_message_server_test.cc
View File

@ -309,7 +309,7 @@ class TestMachMessageServer : public MachMessageServer::Interface,
// ensure that whatever buffer was allocated to receive a RequestMessage is
// not large enough to receive a LargeRequestMessage.
struct LargeRequestMessage : public RequestMessage {
uint8_t data[4 * PAGE_SIZE];
uint8_t data[4 * PAGE_MAX_SIZE];
};
struct ReplyMessage : public mig_reply_error_t {

8
util/process/process_memory_mac_test.cc
View File

@ -33,7 +33,7 @@ namespace {
TEST(ProcessMemoryMac, ReadMappedSelf) {
vm_address_t address = 0;
constexpr vm_size_t kSize = 4 * PAGE_SIZE;
const vm_size_t kSize = 4 * PAGE_SIZE;
kern_return_t kr =
vm_allocate(mach_task_self(), &address, kSize, VM_FLAGS_ANYWHERE);
ASSERT_EQ(kr, KERN_SUCCESS) << MachErrorMessage(kr, "vm_allocate");
@ -88,7 +88,7 @@ TEST(ProcessMemoryMac, ReadMappedSelf) {
TEST(ProcessMemoryMac, ReadSelfUnmapped) {
vm_address_t address = 0;
constexpr vm_size_t kSize = 2 * PAGE_SIZE;
const vm_size_t kSize = 2 * PAGE_SIZE;
kern_return_t kr =
vm_allocate(mach_task_self(), &address, kSize, VM_FLAGS_ANYWHERE);
ASSERT_EQ(kr, KERN_SUCCESS) << MachErrorMessage(kr, "vm_allocate");
@ -150,7 +150,7 @@ TEST(ProcessMemoryMac, ReadSelfUnmapped) {
TEST(ProcessMemoryMac, ReadCStringSelfUnmapped) {
vm_address_t address = 0;
constexpr vm_size_t kSize = 2 * PAGE_SIZE;
const vm_size_t kSize = 2 * PAGE_SIZE;
kern_return_t kr =
vm_allocate(mach_task_self(), &address, kSize, VM_FLAGS_ANYWHERE);
ASSERT_EQ(kr, KERN_SUCCESS) << MachErrorMessage(kr, "vm_allocate");
@ -259,7 +259,7 @@ TEST(ProcessMemoryMac, MappedMemoryDeallocates) {
// This is the same but with a big buffer that’s definitely larger than a
// single page. This makes sure that the whole mapped region winds up being
// deallocated.
constexpr size_t kBigSize = 4 * PAGE_SIZE;
const size_t kBigSize = 4 * PAGE_SIZE;
std::unique_ptr<char[]> big_buffer(new char[kBigSize]);
test_address = FromPointerCast<mach_vm_address_t>(&big_buffer[0]);
ASSERT_TRUE((mapped = memory.ReadMapped(test_address, kBigSize)));