为什么监控文件读写

在Linux中，一切皆文件，那么对于进程的运行，就是不停的文件IO来维持的对吗？因此处理好磁盘的读写, 能够提升应用整体的流畅度，所以如果我们能监控一些耗时的文件读写，针对性的优化，是不是就可以提高用户体验呢，答案肯定是可以

如何能监控文件的读写呢

两种思路：Java hook 、Native hook，我们先来看Java hook如何实现。

Java Hook

我们可以通过代码插桩和动态代理两种方式实现
插桩 ：无法覆盖所有的 IO 操作, 大量系统代码也存在 IO 操作
动态代理 ：不同的 Android 版本, Java 层的API变更比较大, 有大量的版本适配性工作，且很多系统级的 IO 操作, 是直接调用 native 层的函数, 因此只做 java 层的 hook, 无法覆盖所有场景，所以我们就只剩一条路，对native 进程hook

Native Hook

其实Java中的IO操作都会最终调用Linux的open/read/write/close

  1. int open(const char *pathname, int flags, mode_t mode);
  2. ssize_t read(int fd, void *buf, size_t size);
  3. ssize_t write(int fd, const void *buf, size_t size); write_cuk
  4. int close(int fd);

这些函数的实现, 分别在 libopenjdkjvm.so, libjavacore.so 和 libopenjdk.so 中, 覆盖所有的 java 层 IO 调用，具体可以参考io_canary_jni.cc，所以hook住这些代码，就可以对所有的IO操作了如指掌。

直接看Matrix如何hook的

先看下整个项目的结构，分为两部分，一部分java实现，一部分c++实现
image.png

java部分

  1.     @Override
  2.     public void init(Application app, PluginListener listener) {
  3.         super.init(app, listener);
  4.         IOCanaryUtil.setPackageName(app);
  5.         mCore = new IOCanaryCore(this);
  6.     }

通过初始化，我们看到IOCanaryCore类，这个就是核心的类，直接看它的start函数

  1.    public void start() {
  2.         initDetectorsAndHookers(mIOConfig);
  3.         synchronized (this) {
  4.             mIsStart = true;
  5.         }
  6.     }
  7. // 开始hook逻辑
  8.   private void initDetectorsAndHookers(IOConfig ioConfig) {
  9.         assert ioConfig != null;
  10.         // 如果配置中，允许检测文件主线程IO或者允许检测缓冲区或者允许重复读取相同文件
  11.         if (ioConfig.isDetectFileIOInMainThread()
  12.             || ioConfig.isDetectFileIOBufferTooSmall()
  13.             || ioConfig.isDetectFileIORepeatReadSameFile()) {
  14.             IOCanaryJniBridge.install(ioConfig, this);
  15.         }
  16.         // 如果只检测可关闭的泄漏，使用closeguarhooker比较好
  17.         //if only detect io closeable leak use CloseGuardHooker is Better
  18.         if (ioConfig.isDetectIOClosableLeak()) {
  19.             mCloseGuardHooker = new CloseGuardHooker(this);
  20.             mCloseGuardHooker.hook();
  21.         }
  22.     }
  23.     // IOCanaryJniBridge.install
  24.     public static void install(IOConfig config, OnJniIssuePublishListener listener) {
  25.         MatrixLog.v(TAG, "install sIsTryInstall:%b", sIsTryInstall);
  26.         if (sIsTryInstall) {
  27.             return;
  28.         }
  29.         // 加载 io-canary so库
  30.         //load lib
  31.         if (!loadJni()) {
  32.             MatrixLog.e(TAG, "install loadJni failed");
  33.             return;
  34.         }
  36.         //set listener
  37.         sOnIssuePublishListener = listener;
  39.         try {
  40.             //set config
  41.             if (config != null) {
  42.                 if (config.isDetectFileIOInMainThread()) {
  43.                     //  static native void enableDetector() native方法
  44.                     enableDetector(DetectorType.MAIN_THREAD_IO);
  45.                     // ms to μs
  46.                     setConfig(ConfigKey.MAIN_THREAD_THRESHOLD, config.getFileMainThreadTriggerThreshold() * 1000L);
  47.                 }
  49.                 if (config.isDetectFileIOBufferTooSmall()) {
  50.                     enableDetector(DetectorType.SMALL_BUFFER);
  51.                     setConfig(ConfigKey.SMALL_BUFFER_THRESHOLD, config.getFileBufferSmallThreshold());
  52.                 }
  54.                 if (config.isDetectFileIORepeatReadSameFile()) {
  55.                     enableDetector(DetectorType.REPEAT_READ);
  56.                     setConfig(ConfigKey.REPEAT_READ_THRESHOLD, config.getFileRepeatReadThreshold());
  57.                 }
  58.             }
  60.             //hook
  61.             //重点hook来了
  62.             doHook();
  64.             sIsTryInstall = true;
  65.         } catch (Error e) {
  66.             MatrixLog.printErrStackTrace(TAG, e, "call jni method error");
  67.         }
  68.     }

hoot通过JNI调用

  1. static native boolean doHook()

直接转C层实现

  2.         JNIEXPORT jboolean JNICALL
  3.         Java_com_tencent_matrix_iocanary_core_IOCanaryJniBridge_doHook(JNIEnv *env, jclass type) {
  4.             // Android日志
  5.             __android_log_print(ANDROID_LOG_INFO, kTag, "doHook");
  7.             for (int i = 0; i < TARGET_MODULE_COUNT; ++i) {
  8.                 //   "libopenjdkjvm.so","libjavacore.so","libopenjdk.so"
  9.                 //  拿到上面其中一个
  10.                 const char* so_name = TARGET_MODULES[i];
  11.                 // 打印日志
  12.                 __android_log_print(ANDROID_LOG_INFO, kTag, "try to hook function in %s.", so_name);
  13.                 // 打开so库，获取相关信息
  14.                 void* soinfo = xhook_elf_open(so_name);
  15.                 if (!soinfo) {
  16.                     __android_log_print(ANDROID_LOG_WARN, kTag, "Failure to open %s, try next.", so_name);
  17.                     continue;
  18.                 }
  19.                 // hook open函数 替换为ProxyOpen函数
  20.                 xhook_hook_symbol(soinfo, "open", (void*)ProxyOpen, (void**)&original_open);
  21.                 xhook_hook_symbol(soinfo, "open64", (void*)ProxyOpen64, (void**)&original_open64);
  23.                 bool is_libjavacore = (strstr(so_name, "libjavacore.so") != nullptr);
  24.                 if (is_libjavacore) {
  25.                     // hook read函数
  26.                     if (xhook_hook_symbol(soinfo, "read", (void*)ProxyRead, (void**)&original_read) != 0) {
  27.                         __android_log_print(ANDROID_LOG_WARN, kTag, "doHook hook read failed, try __read_chk");
  28.                         if (xhook_hook_symbol(soinfo, "__read_chk", (void*)ProxyReadChk, (void**)&original_read_chk) != 0) {
  29.                             __android_log_print(ANDROID_LOG_WARN, kTag, "doHook hook failed: __read_chk");
  30.                             xhook_elf_close(soinfo);
  31.                             return JNI_FALSE;
  32.                         }
  33.                     }
  34.                     // hook write函数
  35.                     if (xhook_hook_symbol(soinfo, "write", (void*)ProxyWrite, (void**)&original_write) != 0) {
  36.                         __android_log_print(ANDROID_LOG_WARN, kTag, "doHook hook write failed, try __write_chk");
  37.                         if (xhook_hook_symbol(soinfo, "__write_chk", (void*)ProxyWriteChk, (void**)&original_write_chk) != 0) {
  38.                             __android_log_print(ANDROID_LOG_WARN, kTag, "doHook hook failed: __write_chk");
  39.                             xhook_elf_close(soinfo);
  40.                             return JNI_FALSE;
  41.                         }
  42.                     }
  43.                 }
  44.                 // hook close函数
  45.                 xhook_hook_symbol(soinfo, "close", (void*)ProxyClose, (void**)&original_close);
  47.                 xhook_elf_close(soinfo);
  48.             }
  50.             __android_log_print(ANDROID_LOG_INFO, kTag, "doHook done.");
  51.             return JNI_TRUE;
  52.         }

来看一个hook函数

  1.         ssize_t ProxyRead(int fd, void *buf, size_t size) {
  2.             //  如果不是主线程, 则直接调用原始方法
  3.             if(!IsMainThread()) {
  4.                 return original_read(fd, buf, size);
  5.             }
  6.             // 开始时间
  7.             int64_t start = GetTickCountMicros();
  8.             // 调用原始方法
  9.             size_t ret = original_read(fd, buf, size);
  10.             // 结束时间
  11.             long read_cost_us = GetTickCountMicros() - start;
  13.             //__android_log_print(ANDROID_LOG_DEBUG, kTag, "ProxyRead fd:%d buf:%p size:%d ret:%d cost:%d", fd, buf, size, ret, read_cost_us);
  14.             iocanary::IOCanary::Get().OnRead(fd, buf, size, ret, read_cost_us);
  16.             return ret;
  17.         }

是不是跟java字节码插桩的时候一样，在原始的函数调用前后插入代码来计算时间。这里面有个优化点是只做了主线程的计算，如果子线程中没有耗时操作，那么就跟什么都没发生一样。你是还想知道数据在哪里处理的呢？

  1.     // 其实每当文件close之后会调用OnClose，然后调用下面方法OfferFileIOInfo
  2.     // 将文件io的信息加入到一个队列中queue_
  3.     void IOCanary::OfferFileIOInfo(std::shared_ptr<IOInfo> file_io_info) {
  4.         std::unique_lock<std::mutex> lock(queue_mutex_);
  5.         queue_.push_back(file_io_info);
  6.         queue_cv_.notify_one();
  7.         lock.unlock();
  8.     }

在Detect方法中，不断的从队列中取出file_io_info。

  1. void IOCanary::Detect() {
  2.         std::vector<Issue> published_issues;
  3.         std::shared_ptr<IOInfo> file_io_info;
  4.         // 循环启动
  5.         while (true) {
  6.             published_issues.clear();
  8.             int ret = TakeFileIOInfo(file_io_info);
  10.             if (ret != 0) {
  11.                 break;
  12.             }
  14.             for (auto detector : detectors_) {
  15.                 detector->Detect(env_, *file_io_info, published_issues);
  16.             }
  18.             if (issued_callback_ && !published_issues.empty()) {
  19.                 // 如果检测出的问题不为空，回调给java层
  20.                 issued_callback_(published_issues);
  21.             }
  23.             file_io_info = nullptr;
  24.         }
  25.     }
  26.     // Detect 在IOCanary对象创建的时候就开启，不断的从队列中取出数据，检测，然后上报。
  27.    IOCanary::IOCanary() {
  28.         exit_ = false;
  29.         std::thread detect_thread(&IOCanary::Detect, this);
  30.         detect_thread.detach();
  31.     }

到目前，大致逻辑已经搞明白了。

总结

简单做个总结：

  • 只在主线程中检测IO操作，保证主线程中IO操作处于正常范围。
  • 接触了新的c++代码hook技术，xhook 官方地址：https://github.com/iqiyi/xHook