從0構建APM系統-Crash&OOM監控

......

Exception Type: EXC_CRASH (SIGABRT)

Exception Codes: 0x0000000000000000, 0x0000000000000000

Exception Note: EXC_CORPSE_NOTIFY

Triggered by Thread: 0

Last Exception Backtrace:

0 CoreFoundation 0x1843765ac __exceptionPreprocess + 220 (NSException.m:199)

1 libobjc.A.dylib 0x1983f042c objc_exception_throw + 60 (objc-exception.mm:565)

......

static bool installExceptionHandler()

{

......

//獲取當前task

const task_t thisTask = mach_task_self();

exception_mask_t mask = EXC_MASK_BAD_ACCESS |

EXC_MASK_BAD_INstructION |

EXC_MASK_ARITHMETIC |

EXC_MASK_SOFTWARE |

EXC_MASK_BREAKPOINT;

//獲取當前task所有的異常埠並保存在kr屬性中

kr = task_get_exception_ports(thisTask,

mask,

g_previousExceptionPorts.masks,

&g_previousExceptionPorts.count,

g_previousExceptionPorts.ports,

g_previousExceptionPorts.behaviors,

g_previousExceptionPorts.flavors);

if(kr != KERN_SUCCESS)

{

KSLOG_ERROR("task_get_exception_ports: %s", mach_error_string(kr));

goto failed;

}

if(g_exceptionPort == MACH_PORT_NULL)

{

KSLOG_DEBUG("Allocating new port with receive rights.");

//申請一個異常埠

kr = mach_port_allocate(thisTask,

MACH_PORT_RIGHT_RECEIVE,

&g_exceptionPort);

if(kr != KERN_SUCCESS)

{

KSLOG_ERROR("mach_port_allocate: %s", mach_error_string(kr));

goto failed;

}

KSLOG_DEBUG("Adding send rights to port.");

//設置埠許可權

kr = mach_port_insert_right(thisTask,

g_exceptionPort,

g_exceptionPort,

MACH_MSG_TYPE_MAKE_SEND);

if(kr != KERN_SUCCESS)

{

KSLOG_ERROR("mach_port_insert_right: %s", mach_error_string(kr));

goto failed;

}

}

......

//創建對應的線程，捕獲異常

error = pthread_create(&g_secondaryPThread,

&attr,

&handleExceptions,

kThreadSecondary);

......

static bool installSignalHandler()

{

KSLOG_DEBUG("Installing signal handler.");

#if KSCRASH_HAS_SIGNAL_STACK

// 在堆上分配一塊內存，

if(g_signalStack.ss_size == 0)

{

KSLOG_DEBUG("Allocating signal stack area.");

g_signalStack.ss_size = SIGSTKSZ;

g_signalStack.ss_sp = malloc(g_signalStack.ss_size);

}

KSLOG_DEBUG("Setting signal stack area.");

// 信號處理函數的棧挪到堆中，不和進程共用一塊棧區

if(sigaltstack(&g_signalStack, NULL) != 0)

{

KSLOG_ERROR("signalstack: %s", strerror(errno));

goto failed;

}

#endif

const int* fatalSignals = kssignal_fatalSignals();

int fatalSignalsCount = kssignal_numFatalSignals();

if(g_previousSignalHandlers == NULL)

{

KSLOG_DEBUG("Allocating memory to store previous signal handlers.");

g_previousSignalHandlers = malloc(sizeof(*g_previousSignalHandlers)

* (unsigned)fatalSignalsCount);

}

// 設置信號處理函數 sigaction 的第二個參數，類型為 sigaction 結構體

struct sigaction action = {{0}};

action.sa_flags = SA_SIGINFO | SA_ONSTACK;

#if KSCRASH_HOST_APPLE && defined(__LP64__)

action.sa_flags |= SA_64REGSET;

#endif

sigemptyset(&action.sa_mask);

action.sa_sigaction = &handleSignal;

for(int i = 0; i < fatalSignalsCount; i++)

{

KSLOG_DEBUG("Assigning handler for signal %d", fatalSignals[i]);

// 將每個信號的處理函數綁定到上面聲明的 action 去，另外用 g_previousSignalHandlers 保存當前信號的處理函數

if(sigaction(fatalSignals[i], &action, &g_previousSignalHandlers[i]) != 0)

{

char sigNameBuff[30];

const char* sigName = kssignal_signalName(fatalSignals[i]);

if(sigName == NULL)

{

snprintf(sigNameBuff, sizeof(sigNameBuff), "%d", fatalSignals[i]);

sigName = sigNameBuff;

}

KSLOG_ERROR("sigaction (%s): %s", sigName, strerror(errno));

// Try to reverse the damage

for(i--;i >= 0; i--)

{

sigaction(fatalSignals[i], &g_previousSignalHandlers[i], NULL);

}

goto failed;

}

}

KSLOG_DEBUG("Signal handlers installed.");

return true;

failed:

KSLOG_DEBUG("Failed to install signal handlers.");

return false;

}

......

static void CPPExceptionTerminate(void)

{

......

// 之前判斷是否是cpp exception的條件，繼承自NSException的NSException會被當做cpp exception處理

// if (name == NULL || strcmp(name, "NSException") != 0

if (g_capturedStackCursor && (name == NULL || strcmp(name, "NSException") != 0))

{

kscm_notifyFatalExceptionCaptured(false);

KSCrash_MonitorContext* crashContext = &g_monitorContext;

memset(crashContext, 0, sizeof(*crashContext));

char descriptionBuff[DESCRIPTION_BUFFER_LENGTH];

const char* description = descriptionBuff;

descriptionBuff[0] = 0;

KSLOG_DEBUG("Discovering what kind of exception was thrown.");

g_captureNextStackTrace = false;

try

{

throw;

}

catch(std::exception& exc)

{

strncpy(descriptionBuff, exc.what(), sizeof(descriptionBuff));

}

......

{

"uuid" : "a02fb850-9725-4051-817a-8a5dc0950872",

"states" : [

"frontmost" //應用狀態：前台運行

],

"lifetimeMax" : 92802,

"purgeable" : 0,

"coalition" : 68,

"rpages" : 92802, //佔用內存頁

"reason" : "per-process-limit", //崩潰原因：超過單進程上限

"name" : "MyCoolApp"

}

kern_return_t task_info

(

task_name_t target_task,

task_flavor_t flavor,

task_info_t task_info_out,

mach_msg_type_number_t *task_info_outCnt

);

int64_t memoryUsageInByte = 0;

task_vm_info_data_t vmInfo;

mach_msg_type_number_t count = TASK_VM_INFO_COUNT;

kern_return_t kernelReturn = task_info(mach_task_self(), TASK_VM_INFO, (task_info_t) &vmInfo, &count);

if(kernelReturn == KERN_SUCCESS) {

memoryUsageInByte = (int64_t) vmInfo.phys_footprint;

}

-(void)saveLastSingleLoginMaxMemory{

if(_hasUpoad){

NSString* currentMemory = [NSString stringWithFormat:@"%f", _singleLoginMaxMemory];

NSString* overflowMemoryLimit =[NSString stringWithFormat:@"%f", overflow_limit];

if(_singleLoginMaxMemory > overflow_limit){

static BOOL isFirst = YES;

if(isFirst){

_firstOOMTime = [[NSDate date] timeIntervalSince1970];

isFirst = NO;

}

}

NSDictionary *minidumpdata = [NSDictionary dictionaryWithObjectsAndKeys:currentMemory,@"singleMemory",overflowMemoryLimit,@"threshold",[NSString stringWithFormat: @"%.2lf", _firstOOMTime],@"LaunchTime",nil];

NSString *fileDir = [self singleLoginMaxMemoryDir];

if (![[NSFileManager defaultManager] fileExistsAtPath:fileDir])

{

[[NSFileManager defaultManager] createDirectoryAtPath:fileDir withIntermediateDirectories:YES attributes:nil error:nil];

}

NSString *filePath = [fileDir stringByAppendingString:@"/apmLastMaxMemory.plist"];

if(minidumpdata != nil){

if([[NSFileManager defaultManager] fileExistsAtPath:filePath]){

[[NSFileManager defaultManager] removeItemAtPath:filePath error:nil];

}

[minidumpdata writeToFile:filePath atomically:YES];

}

}

}

-(NSDictionary *)parseFoomData:(NSDictionary *)foomDict

{

......

if(appState == APPENTERFORGROUND){

BOOL isExit = [[foomDict objectForKey:@"isExit"] boolValue];

BOOL isDeadLock = [[foomDict objectForKey:@"isDeadLock"] boolValue];

NSString *lastSysVersion = [foomDict objectForKey:@"systemVersion"];

NSString *lastAppVersion = [foomDict objectForKey:@"appVersion"];

if(!isCrashed && !isExit && [_systemVersion isEqualToString:lastSysVersion] && [_appVersion isEqualToString:lastAppVersion]){

if(isDeadLock){

OOM_Log("The app ocurred deadlock lastTime,detail info:%s",[[foomDict description] UTF8String]);

[result setObject:@deadlock_crash forKey:@"crash_type"];

NSDictionary *stack = [foomDict objectForKey:@"deadlockStack"];

if(stack && stack.count > 0){

[result setObject:stack forKey:@"stack_deadlock"];

OOM_Log("The app deadlock stack:%s",[[stack description] UTF8String]);

}

}

else {

OOM_Log("The app ocurred foom lastTime,detail info:%s",[[foomDict description] UTF8String]);

[result setObject:@foom_crash forKey:@"crash_type"];

NSString *uuid = [foomDict objectForKey:@"uuid"];

NSArray *oomStack = [[OOMDetector getInstance] getOOMDataByUUID:uuid];

if(oomStack && oomStack.count > 0)

{

NSData *oomData = [NSJSONSerialization dataWithJSONObject:oomStack options:0 error:nil];

if(oomData.length > 0){

// NSString *stackStr = [NSString stringWithUTF8String:(const char *)oomData.bytes];

OOM_Log("The app foom stack:%s",[[oomStack description] UTF8String]);

}

[result setObject:[self getAPMOOMStack:oomStack] forKey:@"stack_oom"];

}

}

return result;

}

}

......

}

void VMRegionCollect::startCollet() {

......

while (1) {

struct vm_region_submap_info_64 info;

mach_msg_type_number_t count = VM_REGION_SUBMAP_INFO_COUNT_64;

krc = vm_region_recurse_64(mach_task_self(), &address, &size, &depth, (vm_region_info_64_t)&info, &count);

if (krc == KERN_INVALID_ADDRESS){

break;

}

if (info.is_submap){

depth++;

} else {

//do stuff

proc_regionfilename(pid, address, buf, sizeof(buf));

printf("Found VM Region: %08x to %08x (depth=%d) user_tag:%s name:%s\n", (uint32_t)address, (uint32_t)(address+size), depth, [visualMemoryTypeString(info.user_tag) cStringUsingEncoding:NSUTF8StringEncoding], buf);

address += size;

}

}

}

static void range_callback(task_t task, void *context, unsigned type, vm_range_t *ranges, unsigned rangeCount) {

if (!context) {

return;

}

for (unsigned int i = 0; i < rangeCount; i++) {

vm_range_t range = ranges[i];

flex_maybe_object_t *tryObject = (flex_maybe_object_t *)range.address;

Class tryClass = NULL;

#ifdef __arm64__

// See http://www.sealiesoftware.com/blog/archive/2013/09/24/objc_explain_Non-pointer_isa.html

extern uint64_t objc_debug_isa_class_mask WEAK_IMPORT_ATTRIBUTE;

tryClass = (__bridge Class)((void *)((uint64_t)tryObject->isa & objc_debug_isa_class_mask));

#else

tryClass = tryObject->isa;

#endif

// If the class pointer matches one in our set of class pointers from the runtime, then we should have an object.

if (CFSetContainsValue(registeredClasses, (__bridge const void *)(tryClass))) {

(*(object_enumeration_block_t __unsafe_unretained *)context)((__bridge id)tryObject, tryClass);

}

}

}

static kern_return_t reader(__unused task_t remote_task, vm_address_t remote_address, __unused vm_size_t size, void **local_memory) {

*local_memory = (void *)remote_address;

return KERN_SUCCESS;

}

+ (void)enumerateLiveObjectsUsingBlock:(object_enumeration_block_t)block {

if (!block) {

return;

}

[self updateRegisteredClasses];

vm_address_t *zones = NULL;

unsigned int zoneCount = 0;

kern_return_t result = malloc_get_all_zones(TASK_NULL, reader, &zones, &zoneCount);

if (result == KERN_SUCCESS) {

for (unsigned int i = 0; i < zoneCount; i++) {

malloc_zone_t *zone = (malloc_zone_t *)zones[i];

malloc_introspection_t *introspection = zone->introspect;

if (!introspection) {

continue;

}

void (*lock_zone)(malloc_zone_t *zone) = introspection->force_lock;

void (*unlock_zone)(malloc_zone_t *zone) = introspection->force_unlock;

object_enumeration_block_t callback = ^(__unsafe_unretained id object, __unsafe_unretained Class actualClass) {

unlock_zone(zone);

block(object, actualClass);

lock_zone(zone);

};

BOOL lockZoneValid = PointerIsReadable(lock_zone);

BOOL unlockZoneValid = PointerIsReadable(unlock_zone);

if (introspection->enumerator && lockZoneValid && unlockZoneValid) {

lock_zone(zone);

introspection->enumerator(TASK_NULL, (void *)&callback, MALLOC_PTR_IN_USE_RANGE_TYPE, (vm_address_t)zone, reader, &range_callback);

unlock_zone(zone);

}

}

}

}