使用效果

前言使用效果使用apiJNI的动态注册native方法动态注册

hook的实现android_dlopen_ext和dl_iterate_phdr

Android的native泄漏怎么检测下面通过研究开源项目KOOM来一探究竟。

使用效果

KOOM文档里面写着native的实现是使用了Google官方给出的libmemunreachable

参考地址https://android.googlesource.com/platform/system/memory/libmemunreachable//master/README.md

使用api

LeakMonitor.INSTANCE.start()LeakMonitor.INSTANCE.checkLeaks()LeakMonitor.INSTANCE.stop()简单行代码即可完成但是别忘了我们的目的是研究他是怎么实现的。

native方法的定义简单看方法名可以大概知道有安装监控器、卸载监控器、设置阈值和获取存储泄漏数据的容器。

但是一眼看不出来nativeGetAllocIndex的作用。

native方法

nativeInstallMonitor(selectedList:

ArrayString,

nativeUninstallMonitor()JvmStaticprivate

external

nativeSetMonitorThreshold(size:

Int)JvmStaticprivate

nativeGetLeakAllocs(leakRecordMap:

MapString,

([Ljava/lang/String;[Ljava/lang/String;Z)Z,reinterpret_castvoid

*(InstallMonitor)},{nativeUninstallMonitor,

*(UninstallMonitor)},{nativeSetMonitorThreshold,

*(SetMonitorThreshold)},{nativeGetAllocIndex,

()J,

*(GetAllocIndex)},{nativeGetLeakAllocs,

(Ljava/util/Map;)V,reinterpret_castvoid

JNIEXPORT

(vm-GetEnv(reinterpret_castvoid

**(env),

leak_monitor;FIND_CLASS(leak_monitor,

#define

(env-RegisterNatives(leak_monitor,

kLeakMonitorMethods,NELEM(kLeakMonitorMethods))

JNI_OK)

}这里进行了JNI函数的动态注册至于动态注册的优点就是可以提高一点代码性能无需通过重复查表来链接对应的native方法。

JNINativeMethod

};我们找到了对应的native方法先来看看InstallMonitor方法的实现

jni_leak_monitor.cpp

leak_record;FIND_CLASS(leak_record,

kLeakRecordFullyName);g_leak_record.global_ref

reinterpret_castjclass(env-NewGlobalRef(leak_record));if

(!CheckedClean(env,

false;}GET_METHOD_ID(g_leak_record.construct_method,

leak_record,

init,(JILjava/lang/String;[Lcom/kwai/koom/nativeoom/leakmonitor/FrameInfo;)V);jclass

frame_info;FIND_CLASS(frame_info,

kFrameInfoFullyName);g_frame_info.global_ref

reinterpret_castjclass(env-NewGlobalRef(frame_info));if

(!CheckedClean(env,

false;}GET_METHOD_ID(g_frame_info.construct_method,

frame_info,

init,(JLjava/lang/String;)V);g_enable_local_symbolic

array_to_vector

env-GetArrayLength(jobject_array);if

(length

reinterpret_castjstring(env-GetObjectArrayElement(jobject_array,

i));const

nullptr);ret.emplace_back(data);env-ReleaseStringUTFChars(str,

data);}return

std::move(ret);};std::vectorstd::string

selected_so

selected_array);std::vectorstd::string

ignore_so

LeakMonitor::GetInstance().Install(selected_so,

ignore_so));

首先定义了一个jclass变量leak_record和frame_info并通过FIND_CLASS宏查找Java类并创建全局引用。

使用GET_METHOD_ID宏获取leak_record和frame_info类的构造方法ID用于后续实例化对象。

定义了一个lambda函数array_to_vector该函数接受一个JNIEnv指针和一个jobjectArray对象作为参数将其转换为C的字符串向量。

leak_monitor.cpp

LeakMonitor::Install(std::vectorstd::string

*selected_list,std::vectorstd::string

*ignore_list)

{KCHECK(!has_install_monitor_);//

Reinstall

std::make_uniqueMemoryAnalyzer();if

NOT

{^/data/.*\\.so$};std::vectorconst

std::string

{.*/libkoom-native.so$,.*/libxhook_lib.so$};if

(ignore_list

listregister_pattern.clear();for

(std::string

{register_pattern.push_back(^/data/.*/

item

.so$);}}std::vectorstd::pairconst

std::string,

*(WRAP(malloc))),std::make_pair(realloc,

reinterpret_castvoid

*(WRAP(realloc))),std::make_pair(calloc,

reinterpret_castvoid

*(WRAP(calloc))),std::make_pair(memalign,

reinterpret_castvoid

*(WRAP(memalign))),std::make_pair(posix_memalign,reinterpret_castvoid

*(WRAP(posix_memalign))),std::make_pair(free,

reinterpret_castvoid

(HookHelper::HookMethods(register_pattern,

ignore_pattern,

true;}HookHelper::UnHookMethods();live_alloc_records_.Clear();memory_analyzer_.reset(nullptr);ALOGE(%s

Fail,

}这个函数前面通过正则表达式定义了需要hook和不需要hook的动态库。

后续就是把需要hook的系统内存管理函数put到容器里面接着传给HookHelper去实现hook。

hook_helper.cpp

HookHelper::HookMethods(std::vectorconst

std::string

register_pattern,std::vectorconst

std::string

ignore_pattern,std::vectorstd::pairconst

std::string,

std::move(register_pattern);ignore_pattern_

std::move(ignore_pattern);methods_

std::move(methods);DlopenCb::GetInstance().AddCallback(Callback);return

HookImpl();

HookHelper::Callback(std::setstd::string

int,

{pthread_mutex_lock(DlopenCb::hook_mutex);xhook_clear();for

(auto

(xhook_register(pattern.c_str(),

EXIT_SUCCESS)

pattern.c_str(),method.first.c_str());pthread_mutex_unlock(DlopenCb::hook_mutex);return

false;}}}for

pattern.c_str(),method.first.c_str());pthread_mutex_unlock(DlopenCb::hook_mutex);return

false;}}}int

xhook_refresh(0);pthread_mutex_unlock(DlopenCb::hook_mutex);return

ret

static_caststd::pairstd::setstd::string

std::setstd::string

函数是一个回调函数它用于迭代动态链接器的程序头部信息。

它的功能如下

接受三个参数struct

//一开始输出日志表示刷新操作开始。

XH_LOG_INFO(Refresh

start

集合用于存储新增的共享库。

std::setstd::string

addLibs;pthread_mutex_lock(add_lib_mutex);//获取

hooked_libs

addLibs);dl_iterate_phdr(Callback,

callbackData);pthread_mutex_unlock(add_lib_mutex);//如果

addLibs

{pthread_mutex_lock(hook_mutex);xhook_clear();//根据调试模式进行设置。

if

(is_debug)

{xhook_enable_sigsegv_protection(0);xhook_enable_debug(1);}

else

{xhook_enable_sigsegv_protection(1);}for

(const

lib.c_str();xhook_register(lib_ctr,

android_dlopen_ext,

//输出日志表示新增的共享库已添加。

XH_LOG_INFO(Refresh

new

钩子。

xhook_refresh(0);pthread_mutex_unlock(hook_mutex);//

hooked);pthread_mutex_lock(callback_mutex);//对回调函数进行通知传递新增的共享库信息。

for

(auto

loadLibName);}pthread_mutex_unlock(callback_mutex);}

else

集合为空则输出日志表示没有发现新增的共享库。

XH_LOG_INFO(Refresh

lib

dl_iterate_phdr但这两个函数的实现只是简单地返回了

API

android_dlopen_ext和dl_iterate_phdr

void*

字符串。

__flags这是一个整数用于指定加载共享库的选项标志。

__info这是一个指向

android_dlextinfo

结构体的指针该结构体用于传递扩展加载选项的详细信息。

如果不需要传递额外信息可以传入

函数返回一个

类型的指针该指针通常用于表示加载的共享库的句柄或者标识符。

在这个声明中函数总是返回

android_dlopen_ext

的函数该函数是用来迭代动态链接器的程序头部信息的。

这个函数通常在操作系统中用于获取运行时链接器Runtime

参数说明如下

这是一个函数指针指向一个函数该函数用于处理迭代过程中获取的动态链接库的信息。

它接受三个参数

struct

这是一个结构体指针用于存储动态链接库的程序头部信息。

size_t:

__data:

WRAP(function)(__VA_ARGS__)这里通过宏定义了HOOK函数把前面的系统内存分配函数进行了hook这里

std::string,

*(WRAP(malloc))),std::make_pair(realloc,

reinterpret_castvoid

*(WRAP(realloc))),std::make_pair(calloc,

reinterpret_castvoid

*(WRAP(calloc))),std::make_pair(memalign,

reinterpret_castvoid

*(WRAP(memalign))),std::make_pair(posix_memalign,reinterpret_castvoid

*(WRAP(posix_memalign))),std::make_pair(free,

reinterpret_castvoid

*(WRAP(free)))};先看下hook了malloc的实现代码

HOOK(void

malloc(size);LeakMonitor::GetInstance().OnMonitor(reinterpret_castintptr_t(result),size);CLEAR_MEMORY(result,

size);return

LeakMonitor::OnMonitor(uintptr_t

address,

alloc_threshold_.load(std::memory_order_relaxed))

{return;}RegisterAlloc(address,

size);

}这里判断了一下阈值加入达到阈值则执行RegisterAlloc

ALWAYS_INLINE

LeakMonitor::RegisterAlloc(uintptr_t

address,

kMaxBacktraceSize);};thread_local

ThreadInfo

std::make_sharedAllocRecord();alloc_record-address

CONFUSE(address);alloc_record-size

alloc_index_;memcpy(alloc_record-thread_name,

thread_info.name,

kMaxThreadNameLen);unwind_backtrace(alloc_record-backtrace,

(alloc_record-num_backtraces));live_alloc_records_.Put(CONFUSE(address),

}看下FastUnwind方法

StackTrace::FastUnwind(uintptr_t

*buf,

{pthread_once(once_control_tls,

begin

reinterpret_castuintptr_t(__builtin_frame_address(0));auto

end

reinterpret_castuintptr_t(ss.ss_sp)

ss.ss_size;}size_t

GetAdjustPC(frame-return_addr);}num_frames;if

(frame-next_frame

}这里记录了函数调用的回溯栈相关数据包括起始地址和大小。

结合前面的方法可以知道就是获取调用栈的信息然后put到live_alloc_records_里面。

nativeGetLeakAllocs

分析到这里我们回头看下外面调用的nativeGetLeakAllocs方法。

分析到这里我们可以知道它会执行到这里

std::vectorstd::shared_ptrAllocRecord

{KCHECK(has_install_monitor_);auto

unreachable_allocs

memory_analyzer_-CollectUnreachableMem();std::vectorstd::shared_ptrAllocRecord

live_allocs;std::vectorstd::shared_ptrAllocRecord

leak_allocs;//

{live_allocs.push_back(alloc_info);};live_alloc_records_.Dump(collect_func);auto

is_leak

[](decltype(unreachable_allocs)::value_type

unreachable,std::shared_ptrAllocRecord

live)

{leak_allocs.push_back(live);//

Just

firstUnregisterAlloc(CONFUSE(live-address));}}}return

leak_allocs;

}这里分为live_allocs和leak_allocs通过CollectUnreachableMem来获取不可达的内存信息并保存到leak_allocs中。

到这里核心的实现就已经走读完毕。

后续的代码就是把相关的泄漏内存信息的进行一系列业务处理和打印了。

但是思路和原理已经跃然纸上了不是吗

总体来说KOOM监控native层内存泄漏的实现原理就是通过hook。

hook住系统内存分配的api然后再api的hook方法里面调用Google的memunreachable模块对内存进行可达性分析从而获取泄漏内存的起始地址和空间大小。