front/swiftGrammar
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
swiftGrammar/Pods/FirebaseCrashlytics/Crashlytics/Crashlytics/Components/FIRCLSProcess.c
oscarz 27c160beaf firebase log level
2024-08-29 18:25:13 +08:00

841 lines
28 KiB
C
Raw Permalink Blame History

// Copyright 2019 Google
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "Crashlytics/Crashlytics/Components/FIRCLSProcess.h"
#include "Crashlytics/Crashlytics/Helpers/FIRCLSDefines.h"
#include "Crashlytics/Crashlytics/Helpers/FIRCLSFeatures.h"
#include "Crashlytics/Crashlytics/Components/FIRCLSGlobals.h"
#include "Crashlytics/Crashlytics/Helpers/FIRCLSThreadState.h"
#include "Crashlytics/Crashlytics/Unwind/FIRCLSUnwind.h"
#include "Crashlytics/Crashlytics/Helpers/FIRCLSUtility.h"
#include <dispatch/dispatch.h>
#include <objc/message.h>
#include <pthread.h>
#include <sys/sysctl.h>
#define THREAD_NAME_BUFFER_SIZE (64)
#pragma mark Prototypes
static bool FIRCLSProcessGetThreadName(FIRCLSProcess *process,
thread_t thread,
char *buffer,
size_t length);
static const char *FIRCLSProcessGetThreadDispatchQueueName(FIRCLSProcess *process, thread_t thread);
#pragma mark - API
bool FIRCLSProcessInit(FIRCLSProcess *process, thread_t crashedThread, void *uapVoid) {
if (!process) {
return false;
}
process->task = mach_task_self();
process->thisThread = mach_thread_self();
process->crashedThread = crashedThread;
process->uapVoid = uapVoid;
if (task_threads(process->task, &process->threads, &process->threadCount) != KERN_SUCCESS) {
// failed to get all threads
process->threadCount = 0;
FIRCLSSDKLog("Error: unable to get task threads\n");
return false;
}
return true;
}
// https://developer.apple.com/library/mac/#qa/qa2004/qa1361.html
bool FIRCLSProcessDebuggerAttached(void) {
int junk;
int mib[4];
struct kinfo_proc info;
size_t size;
// Initialize the flags so that, if sysctl fails for some bizarre
// reason, we get a predictable result.
info.kp_proc.p_flag = 0;
// Initialize mib, which tells sysctl the info we want, in this case
// we're looking for information about a specific process ID.
mib[0] = CTL_KERN;
mib[1] = KERN_PROC;
mib[2] = KERN_PROC_PID;
mib[3] = getpid();
// Call sysctl.
size = sizeof(info);
junk = sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, NULL, 0);
if (junk != 0) {
FIRCLSSDKLog("sysctl failed while trying to get kinfo_proc\n");
return false;
}
// We're being debugged if the P_TRACED flag is set.
return (info.kp_proc.p_flag & P_TRACED) != 0;
}
#pragma mark - Thread Support
static bool FIRCLSProcessIsCurrentThread(FIRCLSProcess *process, thread_t thread) {
return MACH_PORT_INDEX(process->thisThread) == MACH_PORT_INDEX(thread);
}
static bool FIRCLSProcessIsCrashedThread(FIRCLSProcess *process, thread_t thread) {
return MACH_PORT_INDEX(process->crashedThread) == MACH_PORT_INDEX(thread);
}
static uint32_t FIRCLSProcessGetThreadCount(FIRCLSProcess *process) {
return process->threadCount;
}
static thread_t FIRCLSProcessGetThread(FIRCLSProcess *process, uint32_t index) {
if (index >= process->threadCount) {
return MACH_PORT_NULL;
}
return process->threads[index];
}
bool FIRCLSProcessSuspendAllOtherThreads(FIRCLSProcess *process) {
mach_msg_type_number_t i;
bool success;
success = true;
for (i = 0; i < process->threadCount; ++i) {
thread_t thread;
thread = FIRCLSProcessGetThread(process, i);
if (FIRCLSProcessIsCurrentThread(process, thread)) {
continue;
}
// FIXME: workaround to get this building on watch, but we need to suspend/resume threads!
#if CLS_CAN_SUSPEND_THREADS
success = success && (thread_suspend(thread) == KERN_SUCCESS);
#endif
}
return success;
}
bool FIRCLSProcessResumeAllOtherThreads(FIRCLSProcess *process) {
mach_msg_type_number_t i;
bool success;
success = true;
for (i = 0; i < process->threadCount; ++i) {
thread_t thread;
thread = FIRCLSProcessGetThread(process, i);
if (FIRCLSProcessIsCurrentThread(process, thread)) {
continue;
}
// FIXME: workaround to get this building on watch, but we need to suspend/resume threads!
#if CLS_CAN_SUSPEND_THREADS
success = success && (thread_resume(thread) == KERN_SUCCESS);
#endif
}
return success;
}
#pragma mark - Thread Properties
void *FIRCLSThreadGetCurrentPC(void) {
return __builtin_return_address(0);
}
static bool FIRCLSProcessGetThreadState(FIRCLSProcess *process,
thread_t thread,
FIRCLSThreadContext *context) {
if (!FIRCLSIsValidPointer(context)) {
FIRCLSSDKLogError("Invalid context supplied\n");
return false;
}
// If the thread context we should use is non-NULL, then just assign it here. Otherwise,
// query the thread state
if (FIRCLSProcessIsCrashedThread(process, thread) && FIRCLSIsValidPointer(process->uapVoid)) {
*context = *((_STRUCT_UCONTEXT *)process->uapVoid)->uc_mcontext;
return true;
}
// Here's a wild trick: emulate what thread_get_state would do. It appears that
// we cannot reliably unwind out of thread_get_state. So, instead of trying, setup
// a thread context that resembles what the real thing would look like
if (FIRCLSProcessIsCurrentThread(process, thread)) {
FIRCLSSDKLog("Faking current thread\n");
memset(context, 0, sizeof(FIRCLSThreadContext));
// Compute the frame address, and then base the stack value off of that. A frame pushes
// two pointers onto the stack, so we have to offset.
const uintptr_t frameAddress = (uintptr_t)__builtin_frame_address(0);
const uintptr_t stackAddress = FIRCLSUnwindStackPointerFromFramePointer(frameAddress);
#if CLS_CPU_X86_64
context->__ss.__rip = (uintptr_t)FIRCLSThreadGetCurrentPC();
context->__ss.__rbp = frameAddress;
context->__ss.__rsp = stackAddress;
#elif CLS_CPU_I386
context->__ss.__eip = (uintptr_t)FIRCLSThreadGetCurrentPC();
context->__ss.__ebp = frameAddress;
context->__ss.__esp = stackAddress;
#elif CLS_CPU_ARM64
FIRCLSThreadContextSetPC(context, (uintptr_t)FIRCLSThreadGetCurrentPC());
FIRCLSThreadContextSetFramePointer(context, frameAddress);
FIRCLSThreadContextSetLinkRegister(context, (uintptr_t)__builtin_return_address(0));
FIRCLSThreadContextSetStackPointer(context, stackAddress);
#elif CLS_CPU_ARM
context->__ss.__pc = (uintptr_t)FIRCLSThreadGetCurrentPC();
context->__ss.__r[7] = frameAddress;
context->__ss.__lr = (uintptr_t)__builtin_return_address(0);
context->__ss.__sp = stackAddress;
#endif
return true;
}
#if !TARGET_OS_WATCH
// try to get the value by querying the thread state
mach_msg_type_number_t stateCount = FIRCLSThreadStateCount;
// For unknown reasons, thread_get_state returns this value on Rosetta,
// but still succeeds.
const int ROSETTA_SUCCESS = 268435459;
kern_return_t status = thread_get_state(thread, FIRCLSThreadState, (thread_state_t)(&(context->__ss)),
&stateCount);
if (status != KERN_SUCCESS && status != ROSETTA_SUCCESS) {
FIRCLSSDKLogError("Failed to get thread state via thread_get_state for thread: %i\n", thread);
return false;
}
return true;
#else
return false;
#endif
}
static bool FIRCLSProcessGetThreadName(FIRCLSProcess *process,
thread_t thread,
char *buffer,
size_t length) {
pthread_t pthread;
if (!buffer || length <= 0) {
return false;
}
pthread = pthread_from_mach_thread_np(thread);
return pthread_getname_np(pthread, buffer, length) == 0;
}
static const char *FIRCLSProcessGetThreadDispatchQueueName(FIRCLSProcess *process,
thread_t thread) {
thread_identifier_info_data_t info;
mach_msg_type_number_t infoCount;
dispatch_queue_t *queueAddress;
dispatch_queue_t queue;
const char *string;
infoCount = THREAD_IDENTIFIER_INFO_COUNT;
if (thread_info(thread, THREAD_IDENTIFIER_INFO, (thread_info_t)&info, &infoCount) !=
KERN_SUCCESS) {
FIRCLSSDKLog("Unable to get thread info\n");
return NULL;
}
queueAddress = (dispatch_queue_t *)info.dispatch_qaddr;
if (queueAddress == NULL) {
return "";
}
// Sometimes a queue address is invalid. I cannot explain why this is, but
// it can cause a crash.
if (!FIRCLSReadMemory((vm_address_t)queueAddress, &queue, sizeof(void *))) {
return "";
}
// here, we know it is safe to de-reference this address, so attempt to get the queue name
if (!queue) {
return "";
}
string = dispatch_queue_get_label(queue);
// but, we still don't if the entire string is valid, so check that too
if (!FIRCLSReadString((vm_address_t)string, (char **)&string, 128)) {
return "";
}
return string;
}
#pragma mark - Data Recording
static bool FIRCLSProcessRecordThreadRegisters(FIRCLSThreadContext context, FIRCLSFile *file) {
#if CLS_CPU_ARM
FIRCLSFileWriteHashEntryUint64(file, "r0", context.__ss.__r[0]);
FIRCLSFileWriteHashEntryUint64(file, "r1", context.__ss.__r[1]);
FIRCLSFileWriteHashEntryUint64(file, "r2", context.__ss.__r[2]);
FIRCLSFileWriteHashEntryUint64(file, "r3", context.__ss.__r[3]);
FIRCLSFileWriteHashEntryUint64(file, "r4", context.__ss.__r[4]);
FIRCLSFileWriteHashEntryUint64(file, "r5", context.__ss.__r[5]);
FIRCLSFileWriteHashEntryUint64(file, "r6", context.__ss.__r[6]);
FIRCLSFileWriteHashEntryUint64(file, "r7", context.__ss.__r[7]);
FIRCLSFileWriteHashEntryUint64(file, "r8", context.__ss.__r[8]);
FIRCLSFileWriteHashEntryUint64(file, "r9", context.__ss.__r[9]);
FIRCLSFileWriteHashEntryUint64(file, "r10", context.__ss.__r[10]);
FIRCLSFileWriteHashEntryUint64(file, "r11", context.__ss.__r[11]);
FIRCLSFileWriteHashEntryUint64(file, "ip", context.__ss.__r[12]);
FIRCLSFileWriteHashEntryUint64(file, "sp", context.__ss.__sp);
FIRCLSFileWriteHashEntryUint64(file, "lr", context.__ss.__lr);
FIRCLSFileWriteHashEntryUint64(file, "pc", context.__ss.__pc);
FIRCLSFileWriteHashEntryUint64(file, "cpsr", context.__ss.__cpsr);
#elif CLS_CPU_ARM64
FIRCLSFileWriteHashEntryUint64(file, "x0", context.__ss.__x[0]);
FIRCLSFileWriteHashEntryUint64(file, "x1", context.__ss.__x[1]);
FIRCLSFileWriteHashEntryUint64(file, "x2", context.__ss.__x[2]);
FIRCLSFileWriteHashEntryUint64(file, "x3", context.__ss.__x[3]);
FIRCLSFileWriteHashEntryUint64(file, "x4", context.__ss.__x[4]);
FIRCLSFileWriteHashEntryUint64(file, "x5", context.__ss.__x[5]);
FIRCLSFileWriteHashEntryUint64(file, "x6", context.__ss.__x[6]);
FIRCLSFileWriteHashEntryUint64(file, "x7", context.__ss.__x[7]);
FIRCLSFileWriteHashEntryUint64(file, "x8", context.__ss.__x[8]);
FIRCLSFileWriteHashEntryUint64(file, "x9", context.__ss.__x[9]);
FIRCLSFileWriteHashEntryUint64(file, "x10", context.__ss.__x[10]);
FIRCLSFileWriteHashEntryUint64(file, "x11", context.__ss.__x[11]);
FIRCLSFileWriteHashEntryUint64(file, "x12", context.__ss.__x[12]);
FIRCLSFileWriteHashEntryUint64(file, "x13", context.__ss.__x[13]);
FIRCLSFileWriteHashEntryUint64(file, "x14", context.__ss.__x[14]);
FIRCLSFileWriteHashEntryUint64(file, "x15", context.__ss.__x[15]);
FIRCLSFileWriteHashEntryUint64(file, "x16", context.__ss.__x[16]);
FIRCLSFileWriteHashEntryUint64(file, "x17", context.__ss.__x[17]);
FIRCLSFileWriteHashEntryUint64(file, "x18", context.__ss.__x[18]);
FIRCLSFileWriteHashEntryUint64(file, "x19", context.__ss.__x[19]);
FIRCLSFileWriteHashEntryUint64(file, "x20", context.__ss.__x[20]);
FIRCLSFileWriteHashEntryUint64(file, "x21", context.__ss.__x[21]);
FIRCLSFileWriteHashEntryUint64(file, "x22", context.__ss.__x[22]);
FIRCLSFileWriteHashEntryUint64(file, "x23", context.__ss.__x[23]);
FIRCLSFileWriteHashEntryUint64(file, "x24", context.__ss.__x[24]);
FIRCLSFileWriteHashEntryUint64(file, "x25", context.__ss.__x[25]);
FIRCLSFileWriteHashEntryUint64(file, "x26", context.__ss.__x[26]);
FIRCLSFileWriteHashEntryUint64(file, "x27", context.__ss.__x[27]);
FIRCLSFileWriteHashEntryUint64(file, "x28", context.__ss.__x[28]);
FIRCLSFileWriteHashEntryUint64(file, "fp", FIRCLSThreadContextGetFramePointer(&context));
FIRCLSFileWriteHashEntryUint64(file, "sp", FIRCLSThreadContextGetStackPointer(&context));
FIRCLSFileWriteHashEntryUint64(file, "lr", FIRCLSThreadContextGetLinkRegister(&context));
FIRCLSFileWriteHashEntryUint64(file, "pc", FIRCLSThreadContextGetPC(&context));
FIRCLSFileWriteHashEntryUint64(file, "cpsr", context.__ss.__cpsr);
#elif CLS_CPU_I386
FIRCLSFileWriteHashEntryUint64(file, "eax", context.__ss.__eax);
FIRCLSFileWriteHashEntryUint64(file, "ebx", context.__ss.__ebx);
FIRCLSFileWriteHashEntryUint64(file, "ecx", context.__ss.__ecx);
FIRCLSFileWriteHashEntryUint64(file, "edx", context.__ss.__edx);
FIRCLSFileWriteHashEntryUint64(file, "edi", context.__ss.__edi);
FIRCLSFileWriteHashEntryUint64(file, "esi", context.__ss.__esi);
FIRCLSFileWriteHashEntryUint64(file, "ebp", context.__ss.__ebp);
FIRCLSFileWriteHashEntryUint64(file, "esp", context.__ss.__esp);
FIRCLSFileWriteHashEntryUint64(file, "ss", context.__ss.__ss);
FIRCLSFileWriteHashEntryUint64(file, "eflags", context.__ss.__eflags);
FIRCLSFileWriteHashEntryUint64(file, "eip", context.__ss.__eip);
FIRCLSFileWriteHashEntryUint64(file, "cs", context.__ss.__cs);
FIRCLSFileWriteHashEntryUint64(file, "ds", context.__ss.__ds);
FIRCLSFileWriteHashEntryUint64(file, "es", context.__ss.__es);
FIRCLSFileWriteHashEntryUint64(file, "fs", context.__ss.__fs);
FIRCLSFileWriteHashEntryUint64(file, "gs", context.__ss.__gs);
// how do we get the cr2 register?
#elif CLS_CPU_X86_64
FIRCLSFileWriteHashEntryUint64(file, "rax", context.__ss.__rax);
FIRCLSFileWriteHashEntryUint64(file, "rbx", context.__ss.__rbx);
FIRCLSFileWriteHashEntryUint64(file, "rcx", context.__ss.__rcx);
FIRCLSFileWriteHashEntryUint64(file, "rdx", context.__ss.__rdx);
FIRCLSFileWriteHashEntryUint64(file, "rdi", context.__ss.__rdi);
FIRCLSFileWriteHashEntryUint64(file, "rsi", context.__ss.__rsi);
FIRCLSFileWriteHashEntryUint64(file, "rbp", context.__ss.__rbp);
FIRCLSFileWriteHashEntryUint64(file, "rsp", context.__ss.__rsp);
FIRCLSFileWriteHashEntryUint64(file, "r8", context.__ss.__r8);
FIRCLSFileWriteHashEntryUint64(file, "r9", context.__ss.__r9);
FIRCLSFileWriteHashEntryUint64(file, "r10", context.__ss.__r10);
FIRCLSFileWriteHashEntryUint64(file, "r11", context.__ss.__r11);
FIRCLSFileWriteHashEntryUint64(file, "r12", context.__ss.__r12);
FIRCLSFileWriteHashEntryUint64(file, "r13", context.__ss.__r13);
FIRCLSFileWriteHashEntryUint64(file, "r14", context.__ss.__r14);
FIRCLSFileWriteHashEntryUint64(file, "r15", context.__ss.__r15);
FIRCLSFileWriteHashEntryUint64(file, "rip", context.__ss.__rip);
FIRCLSFileWriteHashEntryUint64(file, "rflags", context.__ss.__rflags);
FIRCLSFileWriteHashEntryUint64(file, "cs", context.__ss.__cs);
FIRCLSFileWriteHashEntryUint64(file, "fs", context.__ss.__fs);
FIRCLSFileWriteHashEntryUint64(file, "gs", context.__ss.__gs);
#endif
return true;
}
static bool FIRCLSProcessRecordThread(FIRCLSProcess *process, thread_t thread, FIRCLSFile *file) {
FIRCLSUnwindContext unwindContext;
FIRCLSThreadContext context;
if (!FIRCLSProcessGetThreadState(process, thread, &context)) {
FIRCLSSDKLogError("Unable to get thread state\n");
return false;
}
if (!FIRCLSUnwindInit(&unwindContext, context)) {
FIRCLSSDKLog("Unable to init unwind context\n");
return false;
}
FIRCLSFileWriteHashStart(file);
// registers
FIRCLSFileWriteHashKey(file, "registers");
FIRCLSFileWriteHashStart(file);
FIRCLSProcessRecordThreadRegisters(context, file);
FIRCLSFileWriteHashEnd(file);
// stacktrace
FIRCLSFileWriteHashKey(file, "stacktrace");
// stacktrace is an array of integers
FIRCLSFileWriteArrayStart(file);
uint32_t repeatedPCCount = 0;
uint64_t repeatedPC = 0;
const FIRCLSInternalLogLevel level = _firclsContext.writable->internalLogging.logLevel;
while (FIRCLSUnwindNextFrame(&unwindContext)) {
const uintptr_t pc = FIRCLSUnwindGetPC(&unwindContext);
const uint32_t frameCount = FIRCLSUnwindGetFrameRepeatCount(&unwindContext);
if (repeatedPC == pc && repeatedPC != 0) {
// actively counting a recursion
repeatedPCCount = frameCount;
continue;
}
if (frameCount >= FIRCLSUnwindInfiniteRecursionCountThreshold && repeatedPC == 0) {
repeatedPC = pc;
FIRCLSSDKLogWarn("Possible infinite recursion - suppressing logging\n");
_firclsContext.writable->internalLogging.logLevel = FIRCLSInternalLogLevelWarn;
continue;
}
if (repeatedPC != 0) {
// at this point, we've recorded a repeated PC, but it is now no longer
// repeating, so we can restore the logging
_firclsContext.writable->internalLogging.logLevel = level;
}
FIRCLSFileWriteArrayEntryUint64(file, pc);
}
FIRCLSFileWriteArrayEnd(file);
// crashed?
if (FIRCLSProcessIsCrashedThread(process, thread)) {
FIRCLSFileWriteHashEntryBoolean(file, "crashed", true);
}
if (repeatedPC != 0) {
FIRCLSFileWriteHashEntryUint64(file, "repeated_pc", repeatedPC);
FIRCLSFileWriteHashEntryUint64(file, "repeat_count", repeatedPCCount);
}
// Just for extra safety, restore the logging level again. The logic
// above is fairly tricky, this is cheap, and no logging is a real pain.
_firclsContext.writable->internalLogging.logLevel = level;
// end thread info
FIRCLSFileWriteHashEnd(file);
return true;
}
bool FIRCLSProcessRecordAllThreads(FIRCLSProcess *process, FIRCLSFile *file) {
uint32_t threadCount;
uint32_t i;
threadCount = FIRCLSProcessGetThreadCount(process);
FIRCLSFileWriteSectionStart(file, "threads");
FIRCLSFileWriteArrayStart(file);
for (i = 0; i < threadCount; ++i) {
thread_t thread;
thread = FIRCLSProcessGetThread(process, i);
FIRCLSSDKLogInfo("recording thread %d data\n", i);
if (!FIRCLSProcessRecordThread(process, thread, file)) {
FIRCLSSDKLogError("Failed to record thread state. Closing threads JSON to prevent malformed crash report.\n");
FIRCLSFileWriteArrayEnd(file);
FIRCLSFileWriteSectionEnd(file);
return false;
}
}
FIRCLSFileWriteArrayEnd(file);
FIRCLSFileWriteSectionEnd(file);
FIRCLSSDKLogInfo("Completed recording all thread data\n");
return true;
}
void FIRCLSProcessRecordThreadNames(FIRCLSProcess *process, FIRCLSFile *file) {
uint32_t threadCount;
uint32_t i;
FIRCLSFileWriteSectionStart(file, "thread_names");
FIRCLSFileWriteArrayStart(file);
threadCount = FIRCLSProcessGetThreadCount(process);
for (i = 0; i < threadCount; ++i) {
thread_t thread;
char name[THREAD_NAME_BUFFER_SIZE];
thread = FIRCLSProcessGetThread(process, i);
name[0] = 0; // null-terminate, just in case nothing is written
FIRCLSProcessGetThreadName(process, thread, name, THREAD_NAME_BUFFER_SIZE);
FIRCLSFileWriteArrayEntryString(file, name);
}
FIRCLSFileWriteArrayEnd(file);
FIRCLSFileWriteSectionEnd(file);
}
void FIRCLSProcessRecordDispatchQueueNames(FIRCLSProcess *process, FIRCLSFile *file) {
uint32_t threadCount;
uint32_t i;
FIRCLSFileWriteSectionStart(file, "dispatch_queue_names");
FIRCLSFileWriteArrayStart(file);
threadCount = FIRCLSProcessGetThreadCount(process);
for (i = 0; i < threadCount; ++i) {
thread_t thread;
const char *name;
thread = FIRCLSProcessGetThread(process, i);
name = FIRCLSProcessGetThreadDispatchQueueName(process, thread);
// Apple Report Converter will fail to parse this when "name" is null,
// so we will use an empty string instead.
if (name == NULL) {
name = "";
}
FIRCLSFileWriteArrayEntryString(file, name);
}
FIRCLSFileWriteArrayEnd(file);
FIRCLSFileWriteSectionEnd(file);
}
#pragma mark - Other Process Info
bool FIRCLSProcessGetMemoryUsage(uint64_t *active,
uint64_t *inactive,
uint64_t *wired,
uint64_t *freeMem) {
mach_port_t hostPort;
mach_msg_type_number_t hostSize;
vm_size_t pageSize;
vm_statistics_data_t vmStat;
hostPort = mach_host_self();
hostSize = sizeof(vm_statistics_data_t) / sizeof(integer_t);
pageSize = _firclsContext.readonly->host.pageSize;
if (host_statistics(hostPort, HOST_VM_INFO, (host_info_t)&vmStat, &hostSize) != KERN_SUCCESS) {
FIRCLSSDKLog("Failed to get vm statistics\n");
return false;
}
if (!(active && inactive && wired && freeMem)) {
FIRCLSSDKLog("Invalid pointers\n");
return false;
}
// compute the sizes in bytes and return the values
*active = vmStat.active_count * pageSize;
*inactive = vmStat.inactive_count * pageSize;
*wired = vmStat.wire_count * pageSize;
*freeMem = vmStat.free_count * pageSize;
return true;
}
bool FIRCLSProcessGetInfo(FIRCLSProcess *process,
uint64_t *virtualSize,
uint64_t *residentSize,
time_value_t *userTime,
time_value_t *systemTime) {
struct task_basic_info_64 taskInfo;
mach_msg_type_number_t count;
count = TASK_BASIC_INFO_64_COUNT;
if (task_info(process->task, TASK_BASIC_INFO_64, (task_info_t)&taskInfo, &count) !=
KERN_SUCCESS) {
FIRCLSSDKLog("Failed to get task info\n");
return false;
}
if (!(virtualSize && residentSize && userTime && systemTime)) {
FIRCLSSDKLog("Invalid pointers\n");
return false;
}
*virtualSize = taskInfo.virtual_size;
*residentSize = taskInfo.resident_size;
*userTime = taskInfo.user_time;
*systemTime = taskInfo.system_time;
return true;
}
void FIRCLSProcessRecordStats(FIRCLSProcess *process, FIRCLSFile *file) {
uint64_t active;
uint64_t inactive;
uint64_t virtualSize;
uint64_t residentSize;
uint64_t wired;
uint64_t freeMem;
time_value_t userTime;
time_value_t systemTime;
if (!FIRCLSProcessGetMemoryUsage(&active, &inactive, &wired, &freeMem)) {
FIRCLSSDKLog("Unable to get process memory usage\n");
return;
}
if (!FIRCLSProcessGetInfo(process, &virtualSize, &residentSize, &userTime, &systemTime)) {
FIRCLSSDKLog("Unable to get process stats\n");
return;
}
FIRCLSFileWriteSectionStart(file, "process_stats");
FIRCLSFileWriteHashStart(file);
FIRCLSFileWriteHashEntryUint64(file, "active", active);
FIRCLSFileWriteHashEntryUint64(file, "inactive", inactive);
FIRCLSFileWriteHashEntryUint64(file, "wired", wired);
FIRCLSFileWriteHashEntryUint64(file, "freeMem", freeMem); // Intentionally left in, for now. Arg.
FIRCLSFileWriteHashEntryUint64(file, "free_mem", freeMem);
FIRCLSFileWriteHashEntryUint64(file, "virtual", virtualSize);
FIRCLSFileWriteHashEntryUint64(file, "resident", active);
FIRCLSFileWriteHashEntryUint64(file, "user_time",
(userTime.seconds * 1000 * 1000) + userTime.microseconds);
FIRCLSFileWriteHashEntryUint64(file, "sys_time",
(systemTime.seconds * 1000 * 1000) + systemTime.microseconds);
FIRCLSFileWriteHashEnd(file);
FIRCLSFileWriteSectionEnd(file);
}
#pragma mark - Runtime Info
#define OBJC_MSG_SEND_START ((vm_address_t)objc_msgSend)
#define OBJC_MSG_SEND_SUPER_START ((vm_address_t)objc_msgSendSuper)
#define OBJC_MSG_SEND_END (OBJC_MSG_SEND_START + 66)
#define OBJC_MSG_SEND_SUPER_END (OBJC_MSG_SEND_SUPER_START + 66)
#if !CLS_CPU_ARM64
#define OBJC_MSG_SEND_STRET_START ((vm_address_t)objc_msgSend_stret)
#define OBJC_MSG_SEND_SUPER_STRET_START ((vm_address_t)objc_msgSendSuper_stret)
#define OBJC_MSG_SEND_STRET_END (OBJC_MSG_SEND_STRET_START + 66)
#define OBJC_MSG_SEND_SUPER_STRET_END (OBJC_MSG_SEND_SUPER_STRET_START + 66)
#endif
#if CLS_CPU_X86
#define OBJC_MSG_SEND_FPRET_START ((vm_address_t)objc_msgSend_fpret)
#define OBJC_MSG_SEND_FPRET_END (OBJC_MSG_SEND_FPRET_START + 66)
#endif
static const char *FIRCLSProcessGetObjCSelectorName(FIRCLSThreadContext registers) {
void *selectorAddress;
void *selRegister;
#if !CLS_CPU_ARM64
void *stretSelRegister;
#endif
vm_address_t pc;
// First, did we crash in objc_msgSend? The two ways I can think
// of doing this are to use dladdr, and then comparing the strings to
// objc_msg*, or looking up the symbols, and guessing if we are "close enough".
selectorAddress = NULL;
#if CLS_CPU_ARM
pc = registers.__ss.__pc;
selRegister = (void *)registers.__ss.__r[1];
stretSelRegister = (void *)registers.__ss.__r[2];
#elif CLS_CPU_ARM64
pc = FIRCLSThreadContextGetPC(&registers);
selRegister = (void *)registers.__ss.__x[1];
#elif CLS_CPU_I386
pc = registers.__ss.__eip;
selRegister = (void *)registers.__ss.__ecx;
stretSelRegister = (void *)registers.__ss.__ecx;
#elif CLS_CPU_X86_64
pc = registers.__ss.__rip;
selRegister = (void *)registers.__ss.__rsi;
stretSelRegister = (void *)registers.__ss.__rdx;
#endif
if ((pc >= OBJC_MSG_SEND_START) && (pc <= OBJC_MSG_SEND_END)) {
selectorAddress = selRegister;
}
#if !CLS_CPU_ARM64
if ((pc >= OBJC_MSG_SEND_SUPER_START) && (pc <= OBJC_MSG_SEND_SUPER_END)) {
selectorAddress = selRegister;
}
if ((pc >= OBJC_MSG_SEND_STRET_START) && (pc <= OBJC_MSG_SEND_STRET_END)) {
selectorAddress = stretSelRegister;
}
if ((pc >= OBJC_MSG_SEND_SUPER_STRET_START) && (pc <= OBJC_MSG_SEND_SUPER_STRET_END)) {
selectorAddress = stretSelRegister;
}
#if CLS_CPU_X86
if ((pc >= OBJC_MSG_SEND_FPRET_START) && (pc <= OBJC_MSG_SEND_FPRET_END)) {
selectorAddress = selRegister;
}
#endif
#endif
if (!selectorAddress) {
return "";
}
if (!FIRCLSReadString((vm_address_t)selectorAddress, (char **)&selectorAddress, 128)) {
FIRCLSSDKLog("Unable to read the selector string\n");
return "";
}
return selectorAddress;
}
#define CRASH_ALIGN __attribute__((aligned(8)))
typedef struct {
unsigned version CRASH_ALIGN;
const char *message CRASH_ALIGN;
const char *signature CRASH_ALIGN;
const char *backtrace CRASH_ALIGN;
const char *message2 CRASH_ALIGN;
void *reserved CRASH_ALIGN;
void *reserved2 CRASH_ALIGN;
} crash_info_t;
static void FIRCLSProcessRecordCrashInfo(FIRCLSFile *file) {
// TODO: this should be abstracted into binary images, if possible
FIRCLSBinaryImageRuntimeNode *nodes = _firclsContext.writable->binaryImage.nodes;
if (!nodes) {
FIRCLSSDKLogError("The node structure is NULL\n");
return;
}
for (uint32_t i = 0; i < CLS_BINARY_IMAGE_RUNTIME_NODE_COUNT; ++i) {
FIRCLSBinaryImageRuntimeNode *node = &nodes[i];
if (!node->crashInfo) {
continue;
}
crash_info_t info;
if (!FIRCLSReadMemory((vm_address_t)node->crashInfo, &info, sizeof(crash_info_t))) {
continue;
}
FIRCLSSDKLogDebug("Found crash info with version %d\n", info.version);
// Currently support versions 0 through 5.
// 4 was in use for a long time, but it appears that with iOS 9 / swift 2.0, the version has
// been bumped.
if (info.version > 5) {
continue;
}
if (!info.message) {
continue;
}
#if CLS_BINARY_IMAGE_RUNTIME_NODE_RECORD_NAME
FIRCLSSDKLogInfo("Found crash info for %s\n", node->name);
#endif
FIRCLSSDKLogDebug("attempting to read crash info string\n");
char *string = NULL;
if (!FIRCLSReadString((vm_address_t)info.message, &string, 256)) {
FIRCLSSDKLogError("Failed to copy crash info string\n");
continue;
}
// The crash_info_t's message may contain the device's UDID, in this case,
// make sure that we do our best to redact that information before writing the
// rest of the message to disk. This also has the effect of not uploading that
// information in the subsequent crash report.
FIRCLSRedactUUID(string);
FIRCLSFileWriteArrayEntryHexEncodedString(file, string);
}
}
void FIRCLSProcessRecordRuntimeInfo(FIRCLSProcess *process, FIRCLSFile *file) {
FIRCLSThreadContext mcontext;
if (!FIRCLSProcessGetThreadState(process, process->crashedThread, &mcontext)) {
FIRCLSSDKLogError("unable to get crashed thread state");
}
FIRCLSFileWriteSectionStart(file, "runtime");
FIRCLSFileWriteHashStart(file);
FIRCLSFileWriteHashEntryString(file, "objc_selector", FIRCLSProcessGetObjCSelectorName(mcontext));
FIRCLSFileWriteHashKey(file, "crash_info_entries");
FIRCLSFileWriteArrayStart(file);
FIRCLSProcessRecordCrashInfo(file);
FIRCLSFileWriteArrayEnd(file);
FIRCLSFileWriteHashEnd(file);
FIRCLSFileWriteSectionEnd(file);
}
Reference in New Issue View Git Blame Copy Permalink