1b44e34b18
Add one new flag, dealloc_align_mismatch that turns on/off alignment checks. Add three new config parameters, one for deallocate type mismatch (such as abort on new/free if true), one for checking if the size parameter matches on dealloc and one for checking if the alignment is correct on a dealloc. Add extra flags to be passed for to indicate to do an align/size check. Update report functions to better indicate the errors. Add unit tests for all of these. This is based on these upstream cls by jcking: https://github.com/llvm/llvm-project/pull/147735 https://github.com/llvm/llvm-project/pull/146556
118 lines
5.3 KiB
C++
118 lines
5.3 KiB
C++
//===-- report_test.cpp -----------------------------------------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "tests/scudo_unit_test.h"
|
|
|
|
#include "chunk.h"
|
|
#include "report.h"
|
|
|
|
TEST(ScudoReportDeathTest, Check) {
|
|
CHECK_LT(-1, 1);
|
|
EXPECT_DEATH(CHECK_GT(-1, 1),
|
|
"\\(-1\\) > \\(1\\) \\(\\(u64\\)op1=18446744073709551615, "
|
|
"\\(u64\\)op2=1");
|
|
}
|
|
|
|
TEST(ScudoReportDeathTest, Generic) {
|
|
// Potentially unused if EXPECT_DEATH isn't defined.
|
|
UNUSED void *P = reinterpret_cast<void *>(0x42424242U);
|
|
UNUSED scudo::Chunk::PackedHeader Header = {};
|
|
EXPECT_DEATH(scudo::reportError("TEST123"), "Scudo ERROR.*TEST123");
|
|
EXPECT_DEATH(scudo::reportInvalidFlag("ABC", "DEF"), "Scudo ERROR.*ABC.*DEF");
|
|
EXPECT_DEATH(scudo::reportHeaderCorruption(&Header, P),
|
|
"Scudo ERROR.*42424242");
|
|
EXPECT_DEATH(scudo::reportSanityCheckError("XYZ"), "Scudo ERROR.*XYZ");
|
|
EXPECT_DEATH(scudo::reportAlignmentTooBig(123, 456), "Scudo ERROR.*123.*456");
|
|
EXPECT_DEATH(scudo::reportAllocationSizeTooBig(123, 456, 789),
|
|
"Scudo ERROR.*123.*456.*789");
|
|
EXPECT_DEATH(scudo::reportOutOfMemory(4242), "Scudo ERROR.*4242");
|
|
EXPECT_DEATH(
|
|
scudo::reportInvalidChunkState(scudo::AllocatorAction::Recycling, P),
|
|
"Scudo ERROR.*recycling.*42424242");
|
|
EXPECT_DEATH(
|
|
scudo::reportInvalidChunkState(scudo::AllocatorAction::Sizing, P),
|
|
"Scudo ERROR.*sizing.*42424242");
|
|
EXPECT_DEATH(
|
|
scudo::reportMisalignedPointer(scudo::AllocatorAction::Deallocating, P),
|
|
"Scudo ERROR.*deallocating.*42424242");
|
|
EXPECT_DEATH(
|
|
scudo::reportDeallocTypeMismatch(scudo::AllocatorAction::Reallocating, P,
|
|
scudo::Chunk::Origin::New,
|
|
scudo::Chunk::Origin::Memalign),
|
|
"Scudo ERROR.*reallocating.*42424242.*\\(new vs aligned malloc\\)");
|
|
EXPECT_DEATH(scudo::reportDeallocTypeMismatch(
|
|
scudo::AllocatorAction::Deallocating, P,
|
|
scudo::Chunk::Origin::Memalign, scudo::Chunk::Origin::New),
|
|
"Scudo ERROR.*deallocating.*\\(aligned malloc vs new\\)");
|
|
EXPECT_DEATH(scudo::reportDeallocTypeMismatch(
|
|
scudo::AllocatorAction::Deallocating, P,
|
|
scudo::Chunk::Origin::Malloc | scudo::Chunk::Origin::Size,
|
|
scudo::Chunk::Origin::NewArray | scudo::Chunk::Origin::Size |
|
|
scudo::Chunk::Origin::Align),
|
|
"Scudo ERROR.*deallocating.*\\(sized malloc vs sized aligned "
|
|
"new\\[\\]\\)");
|
|
EXPECT_DEATH(scudo::reportDeleteSizeMismatch(P, 123, 456),
|
|
"Scudo ERROR.*42424242.*\\(123 vs 456\\)");
|
|
EXPECT_DEATH(scudo::reportDeleteSizeMismatch(P, 123, 456, 789),
|
|
"Scudo ERROR.*42424242.*\\(123 vs 456 or 789\\)");
|
|
EXPECT_DEATH(
|
|
scudo::reportDeleteAlignmentMismatch(reinterpret_cast<void *>(0x80),
|
|
0x100),
|
|
"Scudo ERROR.*invalid aligned delete.*\\(7 bit align vs 8 bit align\\)");
|
|
}
|
|
|
|
TEST(ScudoReportDeathTest, CSpecific) {
|
|
EXPECT_DEATH(scudo::reportAlignmentNotPowerOfTwo(123), "Scudo ERROR.*123");
|
|
EXPECT_DEATH(scudo::reportCallocOverflow(123, 456), "Scudo ERROR.*123.*456");
|
|
EXPECT_DEATH(scudo::reportReallocarrayOverflow(123, 456),
|
|
"Scudo ERROR.*reallocarray parameters.*123.*456");
|
|
EXPECT_DEATH(scudo::reportInvalidPosixMemalignAlignment(789),
|
|
"Scudo ERROR.*789");
|
|
EXPECT_DEATH(scudo::reportPvallocOverflow(123), "Scudo ERROR.*123");
|
|
EXPECT_DEATH(scudo::reportInvalidAlignedAllocAlignment(123, 456),
|
|
"Scudo ERROR.*123.*456");
|
|
}
|
|
|
|
TEST(ScudoReportDeathTest, HeaderCorruption) {
|
|
UNUSED void *P = reinterpret_cast<void *>(0x42424242U);
|
|
UNUSED scudo::Chunk::PackedHeader Header = {};
|
|
EXPECT_DEATH(scudo::reportHeaderCorruption(&Header, P),
|
|
"Scudo ERROR.*corrupted chunk header at address 0x.*42424242: "
|
|
"chunk header is zero and might indicate memory "
|
|
"corruption or a double free");
|
|
Header = 10U;
|
|
EXPECT_DEATH(scudo::reportHeaderCorruption(&Header, P),
|
|
"Scudo ERROR.*corrupted chunk header at address 0x.*42424242: "
|
|
"most likely due to memory corruption");
|
|
}
|
|
|
|
#if SCUDO_LINUX || SCUDO_TRUSTY || SCUDO_ANDROID
|
|
#include "report_linux.h"
|
|
|
|
#include <errno.h>
|
|
#include <sys/mman.h>
|
|
|
|
TEST(ScudoReportDeathTest, Linux) {
|
|
errno = ENOMEM;
|
|
EXPECT_DEATH(scudo::reportMapError(),
|
|
"Scudo ERROR:.*internal map failure \\(error desc=.*\\)");
|
|
errno = ENOMEM;
|
|
EXPECT_DEATH(scudo::reportMapError(1024U),
|
|
"Scudo ERROR:.*internal map failure \\(error desc=.*\\) "
|
|
"requesting 1KB");
|
|
errno = ENOMEM;
|
|
EXPECT_DEATH(scudo::reportUnmapError(0x1000U, 100U),
|
|
"Scudo ERROR:.*internal unmap failure \\(error desc=.*\\) Addr "
|
|
"0x1000 Size 100");
|
|
errno = ENOMEM;
|
|
EXPECT_DEATH(scudo::reportProtectError(0x1000U, 100U, PROT_READ),
|
|
"Scudo ERROR:.*internal protect failure \\(error desc=.*\\) "
|
|
"Addr 0x1000 Size 100 Prot 1");
|
|
}
|
|
#endif
|