RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2025-04-04 00:31:54 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Revert "[LibFuzzer] Split FuzzerUtil for Posix and Windows."

Browse Source 
This reverts commit r288529, as it seems to introduce some
problems on the Linux bots.

llvm-svn: 288533
This commit is contained in:
Zachary Turner 2016-12-02 20:54:56 +00:00
parent 3266499f15
commit 1c51c497d8
8 changed files with 113 additions and 328 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/Fuzzer/CMakeLists.txt
View File

@ -25,8 +25,6 @@ if( LLVM_USE_SANITIZE_COVERAGE )
FuzzerUtil.cpp FuzzerUtil.cpp
FuzzerUtilDarwin.cpp FuzzerUtilDarwin.cpp
FuzzerUtilLinux.cpp FuzzerUtilLinux.cpp
FuzzerUtilPosix.cpp
FuzzerUtilWindows.cpp
) )
add_library(LLVMFuzzerNoMain STATIC add_library(LLVMFuzzerNoMain STATIC
$<TARGET_OBJECTS:LLVMFuzzerNoMainObjects> $<TARGET_OBJECTS:LLVMFuzzerNoMainObjects>

3
lib/Fuzzer/FuzzerDriver.cpp
View File

@ -23,6 +23,7 @@
#include <mutex> #include <mutex>
#include <string> #include <string>
#include <thread> #include <thread>
#include <unistd.h>
// This function should be present in the libFuzzer so that the client // This function should be present in the libFuzzer so that the client
// binary can test for its existence. // binary can test for its existence.
@ -441,7 +442,7 @@ int FuzzerDriver(int *argc, char ***argv, UserCallback Callback) {
// Initialize Seed. // Initialize Seed.
if (Seed == 0) if (Seed == 0)
Seed = (std::chrono::system_clock::now().time_since_epoch().count() << 10) + Seed = (std::chrono::system_clock::now().time_since_epoch().count() << 10) +
GetPid(); getpid();
if (Flags.verbosity) if (Flags.verbosity)
Printf("INFO: Seed: %u\n", Seed); Printf("INFO: Seed: %u\n", Seed);

2
lib/Fuzzer/FuzzerMutate.cpp
View File

@ -221,7 +221,7 @@ DictionaryEntry MutationDispatcher::MakeDictionaryEntryFromCMP(
size_t NumPositions = 0; size_t NumPositions = 0;
for (const uint8_t *Cur = Data; for (const uint8_t *Cur = Data;
Cur < End && NumPositions < kMaxNumPositions; Cur++) { Cur < End && NumPositions < kMaxNumPositions; Cur++) {
Cur = (uint8_t *)SearchMemory(Cur, End - Cur, &ExistingBytes, sizeof(T)); Cur = (uint8_t *)memmem(Cur, End - Cur, &ExistingBytes, sizeof(T));
if (!Cur) break; if (!Cur) break;
Positions[NumPositions++] = Cur - Data; Positions[NumPositions++] = Cur - Data;
} }

4
lib/Fuzzer/FuzzerTraceState.cpp
View File

@ -157,7 +157,7 @@ int TraceState::TryToAddDesiredData(uint64_t PresentData, uint64_t DesiredData,
const uint8_t *Beg = UnitData; const uint8_t *Beg = UnitData;
const uint8_t *End = Beg + UnitSize; const uint8_t *End = Beg + UnitSize;
for (const uint8_t *Cur = Beg; Cur < End; Cur++) { for (const uint8_t *Cur = Beg; Cur < End; Cur++) {
Cur = (uint8_t *)SearchMemory(Cur, End - Cur, &PresentData, DataSize); Cur = (uint8_t *)memmem(Cur, End - Cur, &PresentData, DataSize);
if (!Cur) if (!Cur)
break; break;
size_t Pos = Cur - Beg; size_t Pos = Cur - Beg;
@ -181,7 +181,7 @@ int TraceState::TryToAddDesiredData(const uint8_t *PresentData,
const uint8_t *Beg = UnitData; const uint8_t *Beg = UnitData;
const uint8_t *End = Beg + UnitSize; const uint8_t *End = Beg + UnitSize;
for (const uint8_t *Cur = Beg; Cur < End; Cur++) { for (const uint8_t *Cur = Beg; Cur < End; Cur++) {
Cur = (uint8_t *)SearchMemory(Cur, End - Cur, PresentData, DataSize); Cur = (uint8_t *)memmem(Cur, End - Cur, PresentData, DataSize);
if (!Cur) if (!Cur)
break; break;
size_t Pos = Cur - Beg; size_t Pos = Cur - Beg;

121
lib/Fuzzer/FuzzerUtil.cpp
View File

@ -10,16 +10,22 @@
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "FuzzerUtil.h" #include "FuzzerUtil.h"
#include "FuzzerIO.h"
#include "FuzzerInternal.h" #include "FuzzerInternal.h"
#include "FuzzerIO.h"
#include <sstream>
#include <iomanip>
#include <sys/resource.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/syscall.h>
#include <cassert> #include <cassert>
#include <chrono> #include <chrono>
#include <cstring> #include <cstring>
#include <errno.h> #include <stdio.h>
#include <signal.h> #include <signal.h>
#include <sstream> #include <sstream>
#include <stdio.h> #include <unistd.h>
#include <sys/types.h> #include <errno.h>
#include <thread> #include <thread>
namespace fuzzer { namespace fuzzer {
@ -56,6 +62,80 @@ void PrintASCII(const Unit &U, const char *PrintAfter) {
PrintASCII(U.data(), U.size(), PrintAfter); PrintASCII(U.data(), U.size(), PrintAfter);
} }
static void AlarmHandler(int, siginfo_t *, void *) {
Fuzzer::StaticAlarmCallback();
}
static void CrashHandler(int, siginfo_t *, void *) {
Fuzzer::StaticCrashSignalCallback();
}
static void InterruptHandler(int, siginfo_t *, void *) {
Fuzzer::StaticInterruptCallback();
}
static void SetSigaction(int signum,
void (*callback)(int, siginfo_t *, void *)) {
struct sigaction sigact;
memset(&sigact, 0, sizeof(sigact));
sigact.sa_sigaction = callback;
if (sigaction(signum, &sigact, 0)) {
Printf("libFuzzer: sigaction failed with %d\n", errno);
exit(1);
}
}
void SetTimer(int Seconds) {
struct itimerval T {{Seconds, 0}, {Seconds, 0}};
if (setitimer(ITIMER_REAL, &T, nullptr)) {
Printf("libFuzzer: setitimer failed with %d\n", errno);
exit(1);
}
SetSigaction(SIGALRM, AlarmHandler);
}
void SetSigSegvHandler() { SetSigaction(SIGSEGV, CrashHandler); }
void SetSigBusHandler() { SetSigaction(SIGBUS, CrashHandler); }
void SetSigAbrtHandler() { SetSigaction(SIGABRT, CrashHandler); }
void SetSigIllHandler() { SetSigaction(SIGILL, CrashHandler); }
void SetSigFpeHandler() { SetSigaction(SIGFPE, CrashHandler); }
void SetSigIntHandler() { SetSigaction(SIGINT, InterruptHandler); }
void SetSigTermHandler() { SetSigaction(SIGTERM, InterruptHandler); }
int NumberOfCpuCores() {
const char *CmdLine = nullptr;
if (LIBFUZZER_LINUX) {
CmdLine = "nproc";
} else if (LIBFUZZER_APPLE) {
CmdLine = "sysctl -n hw.ncpu";
} else {
assert(0 && "NumberOfCpuCores() is not implemented for your platform");
}
FILE *F = popen(CmdLine, "r");
int N = 1;
if (!F || fscanf(F, "%d", &N) != 1) {
Printf("WARNING: Failed to parse output of command \"%s\" in %s(). "
"Assuming CPU count of 1.\n",
CmdLine, __func__);
N = 1;
}
if (pclose(F)) {
Printf("WARNING: Executing command \"%s\" failed in %s(). "
"Assuming CPU count of 1.\n",
CmdLine, __func__);
N = 1;
}
if (N < 1) {
Printf("WARNING: Reported CPU count (%d) from command \"%s\" was invalid "
"in %s(). Assuming CPU count of 1.\n",
N, CmdLine, __func__);
N = 1;
}
return N;
}
bool ToASCII(uint8_t *Data, size_t Size) { bool ToASCII(uint8_t *Data, size_t Size) {
bool Changed = false; bool Changed = false;
for (size_t i = 0; i < Size; i++) { for (size_t i = 0; i < Size; i++) {
@ -151,6 +231,12 @@ bool ParseDictionaryFile(const std::string &Text, std::vector<Unit> *Units) {
return true; return true;
} }
void SleepSeconds(int Seconds) {
sleep(Seconds); // Use C API to avoid coverage from instrumented libc++.
}
int GetPid() { return getpid(); }
std::string Base64(const Unit &U) { std::string Base64(const Unit &U) {
static const char Table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" static const char Table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz" "abcdefghijklmnopqrstuvwxyz"
@ -179,6 +265,21 @@ std::string Base64(const Unit &U) {
return Res; return Res;
} }
size_t GetPeakRSSMb() {
struct rusage usage;
if (getrusage(RUSAGE_SELF, &usage))
return 0;
if (LIBFUZZER_LINUX) {
// ru_maxrss is in KiB
return usage.ru_maxrss >> 10;
} else if (LIBFUZZER_APPLE) {
// ru_maxrss is in bytes
return usage.ru_maxrss >> 20;
}
assert(0 && "GetPeakRSSMb() is not implemented for your platform");
return 0;
}
std::string DescribePC(const char *SymbolizedFMT, uintptr_t PC) { std::string DescribePC(const char *SymbolizedFMT, uintptr_t PC) {
if (!EF->__sanitizer_symbolize_pc) return "<can not symbolize>"; if (!EF->__sanitizer_symbolize_pc) return "<can not symbolize>";
char PcDescr[1024]; char PcDescr[1024];
@ -195,18 +296,8 @@ void PrintPC(const char *SymbolizedFMT, const char *FallbackFMT, uintptr_t PC) {
Printf(FallbackFMT, PC); Printf(FallbackFMT, PC);
} }
int NumberOfCpuCores() {
unsigned N = std::thread::hardware_concurrency();
if (!N) {
Printf("WARNING: std::thread::hardware_concurrency not well defined for "
"your platform. Assuming CPU count of 1.\n");
N = 1;
}
return N;
}
bool ExecuteCommandAndReadOutput(const std::string &Command, std::string *Out) { bool ExecuteCommandAndReadOutput(const std::string &Command, std::string *Out) {
FILE *Pipe = OpenProcessPipe(Command.c_str(), "r"); FILE *Pipe = popen(Command.c_str(), "r");
if (!Pipe) return false; if (!Pipe) return false;
char Buff[1024]; char Buff[1024];
size_t N; size_t N;

9
lib/Fuzzer/FuzzerUtil.h
View File

@ -40,8 +40,6 @@ std::string DescribePC(const char *SymbolizedFMT, uintptr_t PC);
int NumberOfCpuCores(); int NumberOfCpuCores();
bool ExecuteCommandAndReadOutput(const std::string &Command, std::string *Out);
// Platform specific functions. // Platform specific functions.
void SetTimer(int Seconds); void SetTimer(int Seconds);
@ -59,12 +57,9 @@ int GetPid();
size_t GetPeakRSSMb(); size_t GetPeakRSSMb();
bool ExecuteCommandAndReadOutput(const std::string &Command, std::string *Out);
int ExecuteCommand(const std::string &Command); int ExecuteCommand(const std::string &Command);
FILE *OpenProcessPipe(const char *Command, const char *Mode);
const void *SearchMemory(const void *haystack, size_t haystacklen,
const void *needle, size_t needlelen);
} // namespace fuzzer } // namespace fuzzer
#endif // LLVM_FUZZER_UTIL_H #endif // LLVM_FUZZER_UTIL_H

106
lib/Fuzzer/FuzzerUtilPosix.cpp
View File

@ -1,106 +0,0 @@
//===- FuzzerUtilPosix.cpp - Misc utils for Posix. ------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// Misc utils implementation using Posix API.
//===----------------------------------------------------------------------===//
#include "FuzzerDefs.h"
#if LIBFUZZER_POSIX
#include "FuzzerIO.h"
#include "FuzzerInternal.h"
#include <cassert>
#include <chrono>
#include <cstring>
#include <errno.h>
#include <iomanip>
#include <signal.h>
#include <sstream>
#include <stdio.h>
#include <sys/resource.h>
#include <sys/syscall.h>
#include <sys/time.h>
#include <sys/types.h>
#include <thread>
#include <unistd.h>
namespace fuzzer {
static void AlarmHandler(int, siginfo_t *, void *) {
Fuzzer::StaticAlarmCallback();
}
static void CrashHandler(int, siginfo_t *, void *) {
Fuzzer::StaticCrashSignalCallback();
}
static void InterruptHandler(int, siginfo_t *, void *) {
Fuzzer::StaticInterruptCallback();
}
static void SetSigaction(int signum,
void (*callback)(int, siginfo_t *, void *)) {
struct sigaction sigact;
memset(&sigact, 0, sizeof(sigact));
sigact.sa_sigaction = callback;
if (sigaction(signum, &sigact, 0)) {
Printf("libFuzzer: sigaction failed with %d\n", errno);
exit(1);
}
}
void SetTimer(int Seconds) {
struct itimerval T {
{Seconds, 0}, { Seconds, 0 }
};
if (setitimer(ITIMER_REAL, &T, nullptr)) {
Printf("libFuzzer: setitimer failed with %d\n", errno);
exit(1);
}
SetSigaction(SIGALRM, AlarmHandler);
}
void SetSigSegvHandler() { SetSigaction(SIGSEGV, CrashHandler); }
void SetSigBusHandler() { SetSigaction(SIGBUS, CrashHandler); }
void SetSigAbrtHandler() { SetSigaction(SIGABRT, CrashHandler); }
void SetSigIllHandler() { SetSigaction(SIGILL, CrashHandler); }
void SetSigFpeHandler() { SetSigaction(SIGFPE, CrashHandler); }
void SetSigIntHandler() { SetSigaction(SIGINT, InterruptHandler); }
void SetSigTermHandler() { SetSigaction(SIGTERM, InterruptHandler); }
void SleepSeconds(int Seconds) {
sleep(Seconds); // Use C API to avoid coverage from instrumented libc++.
}
int GetPid() { return getpid(); }
size_t GetPeakRSSMb() {
struct rusage usage;
if (getrusage(RUSAGE_SELF, &usage))
return 0;
if (LIBFUZZER_LINUX) {
// ru_maxrss is in KiB
return usage.ru_maxrss >> 10;
} else if (LIBFUZZER_APPLE) {
// ru_maxrss is in bytes
return usage.ru_maxrss >> 20;
}
assert(0 && "GetPeakRSSMb() is not implemented for your platform");
return 0;
}
FILE *OpenProcessPipe(const char *Command, const char *Mode) {
return popen(Command, Mode);
}
const void *SearchMemory(const void *Data, size_t DataLen, const void *Patt,
size_t PattLen) {
return memmem(Data, DataLen, Patt, PattLen);
}
} // namespace fuzzer
#endif // LIBFUZZER_POSIX

194
lib/Fuzzer/FuzzerUtilWindows.cpp
View File

@ -1,194 +0,0 @@
//===- FuzzerUtilWindows.cpp - Misc utils for Windows. --------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// Misc utils implementation for Windows.
//===----------------------------------------------------------------------===//
#include "FuzzerDefs.h"
#if LIBFUZZER_WINDOWS
#include "FuzzerIO.h"
#include "FuzzerInternal.h"
#include <Psapi.h>
#include <cassert>
#include <chrono>
#include <cstring>
#include <errno.h>
#include <iomanip>
#include <signal.h>
#include <sstream>
#include <stdio.h>
#include <sys/types.h>
#include <windows.h>
namespace fuzzer {
LONG WINAPI SEGVHandler(PEXCEPTION_POINTERS ExceptionInfo) {
switch (ExceptionInfo->ExceptionRecord->ExceptionCode) {
case EXCEPTION_ACCESS_VIOLATION:
case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
case EXCEPTION_STACK_OVERFLOW:
Fuzzer::StaticCrashSignalCallback();
break;
}
return EXCEPTION_CONTINUE_SEARCH;
}
LONG WINAPI BUSHandler(PEXCEPTION_POINTERS ExceptionInfo) {
switch (ExceptionInfo->ExceptionRecord->ExceptionCode) {
case EXCEPTION_DATATYPE_MISALIGNMENT:
case EXCEPTION_IN_PAGE_ERROR:
Fuzzer::StaticCrashSignalCallback();
break;
}
return EXCEPTION_CONTINUE_SEARCH;
}
LONG WINAPI ILLHandler(PEXCEPTION_POINTERS ExceptionInfo) {
switch (ExceptionInfo->ExceptionRecord->ExceptionCode) {
case EXCEPTION_ILLEGAL_INSTRUCTION:
case EXCEPTION_PRIV_INSTRUCTION:
Fuzzer::StaticCrashSignalCallback();
break;
}
return EXCEPTION_CONTINUE_SEARCH;
}
LONG WINAPI FPEHandler(PEXCEPTION_POINTERS ExceptionInfo) {
switch (ExceptionInfo->ExceptionRecord->ExceptionCode) {
case EXCEPTION_FLT_DENORMAL_OPERAND:
case EXCEPTION_FLT_DIVIDE_BY_ZERO:
case EXCEPTION_FLT_INEXACT_RESULT:
case EXCEPTION_FLT_INVALID_OPERATION:
case EXCEPTION_FLT_OVERFLOW:
case EXCEPTION_FLT_STACK_CHECK:
case EXCEPTION_FLT_UNDERFLOW:
case EXCEPTION_INT_DIVIDE_BY_ZERO:
case EXCEPTION_INT_OVERFLOW:
Fuzzer::StaticCrashSignalCallback();
break;
}
return EXCEPTION_CONTINUE_SEARCH;
}
BOOL WINAPI INTHandler(DWORD dwCtrlType) {
switch (dwCtrlType) {
case CTRL_C_EVENT:
Fuzzer::StaticInterruptCallback();
return TRUE;
default:
return FALSE;
}
}
BOOL WINAPI TERMHandler(DWORD dwCtrlType) {
switch (dwCtrlType) {
case CTRL_BREAK_EVENT:
Fuzzer::StaticInterruptCallback();
return TRUE;
default:
return FALSE;
}
}
void SetTimer(int Seconds) {
// TODO: Complete this implementation.
return;
}
void SetSigSegvHandler() {
if (!AddVectoredExceptionHandler(1, SEGVHandler)) {
Printf("libFuzzer: AddVectoredExceptionHandler failed.\n");
exit(1);
}
}
void SetSigBusHandler() {
if (!AddVectoredExceptionHandler(1, BUSHandler)) {
Printf("libFuzzer: AddVectoredExceptionHandler failed.\n");
exit(1);
}
}
static void CrashHandler(int) { Fuzzer::StaticCrashSignalCallback(); }
void SetSigAbrtHandler() { signal(SIGABRT, CrashHandler); }
void SetSigIllHandler() {
if (!AddVectoredExceptionHandler(1, ILLHandler)) {
Printf("libFuzzer: AddVectoredExceptionHandler failed.\n");
exit(1);
}
}
void SetSigFpeHandler() {
if (!AddVectoredExceptionHandler(1, FPEHandler)) {
Printf("libFuzzer: AddVectoredExceptionHandler failed.\n");
exit(1);
}
}
void SetSigIntHandler() {
if (!SetConsoleCtrlHandler(INTHandler, TRUE)) {
DWORD LastError = GetLastError();
Printf("libFuzzer: SetConsoleCtrlHandler failed (Error code: %lu).\n",
LastError);
exit(1);
}
}
void SetSigTermHandler() {
if (!SetConsoleCtrlHandler(TERMHandler, TRUE)) {
DWORD LastError = GetLastError();
Printf("libFuzzer: SetConsoleCtrlHandler failed (Error code: %lu).\n",
LastError);
exit(1);
}
}
void SleepSeconds(int Seconds) { Sleep(Seconds * 1000); }
int GetPid() { return GetCurrentProcessId(); }
size_t GetPeakRSSMb() {
PROCESS_MEMORY_COUNTERS info;
if (!GetProcessMemoryInfo(GetCurrentProcess(), &info, sizeof(info)))
return 0;
return info.PeakWorkingSetSize >> 20;
}
FILE *OpenProcessPipe(const char *Command, const char *Mode) {
return _popen(Command, Mode);
}
int ExecuteCommand(const std::string &Command) {
return system(Command.c_str());
}
const void *SearchMemory(const void *Data, size_t DataLen, const void *Patt,
size_t PattLen) {
// TODO: make this implementation more efficient.
const char *Cdata = (const char *)Data;
const char *Cpatt = (const char *)Patt;
if (!Data || !Patt || DataLen == 0 || PattLen == 0 || DataLen < PattLen)
return NULL;
if (PattLen == 1)
return memchr(Data, *Cpatt, DataLen);
const char *End = Cdata + DataLen - PattLen;
for (const char *It = Cdata; It < End; ++It)
if (It[0] == Cpatt[0] && memcmp(It, Cpatt, PattLen) == 0)
return It;
return NULL;
}
} // namespace fuzzer
#endif // LIBFUZZER_WINDOWS