Matrix-IOCanary解析

// matrix/matrix-android/matrix-io-canary/src/main/cpp/core/io_canary.cc
void IOCanary::OnOpen(const char *pathname, int flags, mode_t mode,
                        int open_ret, const JavaContext& java_context) {
    collector_.OnOpen(pathname, flags, mode, open_ret, java_context);
}

// matrix/matrix-android/matrix-io-canary/src/main/cpp/core/io_info_collector.cc
void IOInfoCollector::OnOpen(const char *pathname, int flags, mode_t mode
        , int open_ret, const JavaContext& java_context) {
    //__android_log_print(ANDROID_LOG_DEBUG, kTag, "OnOpen fd:%d; path:%s", open_ret, pathname);

    if (open_ret == -1) {
        return;
    }

    if (info_map_.find(open_ret) != info_map_.end()) {
        //__android_log_print(ANDROID_LOG_WARN, kTag, "OnOpen fd:%d already in info_map_", open_ret);
        return;
    }

    std::shared_ptr<IOInfo> info = std::make_shared<IOInfo>(pathname, java_context);
    info_map_.insert(std::make_pair(open_ret, info));
}

void IOCanary::OnRead(int fd, const void *buf, size_t size,
                        ssize_t read_ret, long read_cost) {
    collector_.OnRead(fd, buf, size, read_ret, read_cost);
}

void IOInfoCollector::OnRead(int fd, const void *buf, size_t size,
                            ssize_t read_ret, long read_cost) {

    if (read_ret == -1 || read_cost < 0) {
        return;
    }

    if (info_map_.find(fd) == info_map_.end()) {
            //__android_log_print(ANDROID_LOG_DEBUG, kTag, "OnRead fd:%d not in info_map_", fd);
        return;
    }

    CountRWInfo(fd, FileOpType::kRead, size, read_cost);
}

void IOInfoCollector::CountRWInfo(int fd, const FileOpType &fileOpType, long op_size, long rw_cost) {
    if (info_map_.find(fd) == info_map_.end()) {
        return;
    }

    // 获取系统的当前时间，单位微秒(us)
    const int64_t now = GetSysTimeMicros();

    // 累计读写操作次数累加
    info_map_[fd]->op_cnt_ ++;
    // 累计buffer size
    info_map_[fd]->op_size_ += op_size;
    // 累计文件读写耗时
    info_map_[fd]->rw_cost_us_ += rw_cost;

    // 单次文件读写最大耗时
    if (rw_cost > info_map_[fd]->max_once_rw_cost_time_μs_) {
        info_map_[fd]->max_once_rw_cost_time_μs_ = rw_cost;
    }

    //__android_log_print(ANDROID_LOG_DEBUG, kTag, "CountRWInfo rw_cost:%d max_once_rw_cost_time_:%d current_continual_rw_time_:%d;max_continual_rw_cost_time_:%d; now:%lld;last:%lld",
        //      rw_cost, info_map_[fd]->max_once_rw_cost_time_μs_, info_map_[fd]->current_continual_rw_time_μs_, info_map_[fd]->max_continual_rw_cost_time_μs_, now, info_map_[fd]->last_rw_time_ms_);

    // 连续读写耗时，若两次操作超过阈值（8000us，约为一帧耗时16.6667ms的一半），则不累计
    if (info_map_[fd]->last_rw_time_μs_ > 0 && (now - info_map_[fd]->last_rw_time_μs_) < kContinualThreshold) {
        info_map_[fd]->current_continual_rw_time_μs_ += rw_cost;
    } else {
        info_map_[fd]->current_continual_rw_time_μs_ = rw_cost;
    }

    // 最大连续读写耗时
    if (info_map_[fd]->current_continual_rw_time_μs_ > info_map_[fd]->max_continual_rw_cost_time_μs_) {
        info_map_[fd]->max_continual_rw_cost_time_μs_ = info_map_[fd]->current_continual_rw_time_μs_;
    }
    // 本次读写记录的时间戳
    info_map_[fd]->last_rw_time_μs_ = now;

    // 最大读写操作buffer size
    if (info_map_[fd]->buffer_size_ < op_size) {
        info_map_[fd]->buffer_size_ = op_size;
    }

    // 读写操作类型
    if (info_map_[fd]->op_type_ == FileOpType::kInit) {
        info_map_[fd]->op_type_ = fileOpType;
    }
}

// matrix/matrix-android/matrix-io-canary/src/main/cpp/core/io_canary.cc
void IOCanary::OnClose(int fd, int close_ret) {
    std::shared_ptr<IOInfo> info = collector_.OnClose(fd, close_ret);
    if (info == nullptr) {
        return;
    }

    OfferFileIOInfo(info);
}

// matrix/matrix-android/matrix-io-canary/src/main/cpp/core/io_info_collector.cc
std::shared_ptr<IOInfo> IOInfoCollector::OnClose(int fd, int close_ret) {

    if (info_map_.find(fd) == info_map_.end()) {
        //__android_log_print(ANDROID_LOG_DEBUG, kTag, "OnClose fd:%d not in info_map_", fd);
        return nullptr;
    }

    // 系统当前时间减去IOInfo对象初始化的时间，则为整个文件的生命周期时间
    info_map_[fd]->total_cost_μs_ = GetSysTimeMicros() - info_map_[fd]->start_time_μs_;
    // 通过stat函数获取文件的实际尺寸
    info_map_[fd]->file_size_ = GetFileSize(info_map_[fd]->path_.c_str());
    std::shared_ptr<IOInfo> info = info_map_[fd];
    info_map_.erase(fd);

    return info;
}

// matrix/matrix-android/matrix-io-canary/src/main/cpp/comm/io_canary_utils.cc
int GetFileSize(const char* file_path) {
    struct stat stat_buf;
    if (-1 == stat(file_path, &stat_buf)) {
        return -1;
    }
    return stat_buf.st_size;
}

// io_canary.h
class IOCanary {
    ...
private:
    ...
    std::deque<std::shared_ptr<IOInfo>> queue_;
    std::mutex queue_mutex_;
    std::condition_variable queue_cv_;
}

// io_canary.cc
// 生产者
void IOCanary::OfferFileIOInfo(std::shared_ptr<IOInfo> file_io_info) {
    std::unique_lock<std::mutex> lock(queue_mutex_);
    queue_.push_back(file_io_info);
    queue_cv_.notify_one();
    lock.unlock();
}

IOCanary::IOCanary() {
    exit_ = false;
    std::thread detect_thread(&IOCanary::Detect, this);
    detect_thread.detach();
}

void IOCanary::Detect() {
    std::vector<Issue> published_issues;
    std::shared_ptr<IOInfo> file_io_info;
    while (true) {
        published_issues.clear();

        // 阻塞直到获取到IOInfo
        int ret = TakeFileIOInfo(file_io_info);

        if (ret != 0) {
            break;
        }

        // 将IOInfo交给各个detector进行检测
        for (auto detector : detectors_) {
            detector->Detect(env_, *file_io_info, published_issues);
        }

        // 若可以上报，则进行上报
        if (issued_callback_ && !published_issues.empty()) {
            issued_callback_(published_issues);
        }

        file_io_info = nullptr;
    }
}

// 消费者
int IOCanary::TakeFileIOInfo(std::shared_ptr<IOInfo> &file_io_info) {
    std::unique_lock<std::mutex> lock(queue_mutex_);

    while (queue_.empty()) {
        queue_cv_.wait(lock);
        if (exit_) {
            return -1;
        }
    }

    file_io_info = queue_.front();
    queue_.pop_front();
    return 0;
}

void FileIOMainThreadDetector::Detect(const IOCanaryEnv &env, const IOInfo &file_io_info,
                                        std::vector<Issue>& issues) {

    //__android_log_print(ANDROID_LOG_ERROR, "FileIOMainThreadDetector", "Detect  main-thread-id：%d, thread-id:%d max_continual_rw_cost_time_μs_:%d threshold:%d"
        //      , env.GetJavaMainThreadID(), file_io_info.java_context_.thread_id_, file_io_info.max_continual_rw_cost_time_μs_, env.GetMainThreadThreshold());

    if (GetMainThreadId() == file_io_info.java_context_.thread_id_) {
        int type = 0;
        if (file_io_info.max_once_rw_cost_time_μs_ > IOCanaryEnv::kPossibleNegativeThreshold) {
            type = 1;
        }
        if(file_io_info.max_continual_rw_cost_time_μs_ > env.GetMainThreadThreshold()) {
            type |= 2;
        }

        if (type != 0) {
            Issue issue(kType, file_io_info);
            issue.repeat_read_cnt_ = type;  //use repeat to record type
            PublishIssue(issue, issues);
        }
    }
}

void FileIOSmallBufferDetector::Detect(const IOCanaryEnv &env, const IOInfo &file_io_info,
                                        std::vector<Issue>& issues) {
    //__android_log_print(ANDROID_LOG_ERROR, "FileIOSmallBufferDetector", "Detect buffer_size:%d threshold:%d op_cnt:%d rw_cost:%d",
        //                  file_io_info.buffer_size_, env.GetSmallBufferThreshold(), file_io_info.op_cnt_, file_io_info.max_continual_rw_cost_time_μs_);

    if (file_io_info.op_cnt_ > env.kSmallBufferOpTimesThreshold && (file_io_info.op_size_ / file_io_info.op_cnt_) < env.GetSmallBufferThreshold()
            && file_io_info.max_continual_rw_cost_time_μs_ >= env.kPossibleNegativeThreshold) {

        PublishIssue(Issue(kType, file_io_info), issues);
    }
}

RepeatReadInfo::RepeatReadInfo(const std::string &path, const std::string &java_stack,
                                long java_thread_id, long op_size,
                                int file_size) : path_(path), java_stack_(java_stack), java_thread_id_(java_thread_id) ,
                                                                op_size_(op_size), file_size_(file_size), op_timems(GetTickCount()) {
    repeat_cnt_ = 1;
}

bool RepeatReadInfo::operator==(const RepeatReadInfo &target) const {
    return target.path_ == path_
        && target.java_thread_id_ == java_thread_id_
        && target.java_stack_ == java_stack_
        && target.file_size_ == file_size_
        && target.op_size_ == op_size_;
}

void RepeatReadInfo::IncRepeatReadCount() {
    repeat_cnt_ ++;
}

int RepeatReadInfo::GetRepeatReadCount() {
    return repeat_cnt_;
}

std::string RepeatReadInfo::GetStack() {
    return java_stack_;
}

// 检测函数入口
void FileIORepeatReadDetector::Detect(const IOCanaryEnv &env,
                                        const IOInfo &file_io_info,
                                        std::vector<Issue>& issues) {

    // 若没有发现操作记录且最大连续读写耗时小于13ms则直接return；否则以path作为key保存重复读的记录  
    const std::string& path = file_io_info.path_;
    if (observing_map_.find(path) == observing_map_.end()) {
        if (file_io_info.max_continual_rw_cost_time_μs_ < env.kPossibleNegativeThreshold) {
            return;
        }

        observing_map_.insert(std::make_pair(path, std::vector<RepeatReadInfo>()));
    }

    std::vector<RepeatReadInfo>& repeat_infos = observing_map_[path];
    // 若当前文件操作为写操作，则不构成读，更不用说重复读了。清空key对应的数组
    if (file_io_info.op_type_ == FileOpType::kWrite) {
        repeat_infos.clear();
        return;
    }

    // 构造RepeatReadInfo对象
    RepeatReadInfo repeat_read_info(file_io_info.path_, file_io_info.java_context_.stack_, file_io_info.java_context_.thread_id_,
                                    file_io_info.op_size_, file_io_info.file_size_);

    // 若key对应的数组为空数组，则说明是首次读操作，肯定不会有重复，直接push后结束  
    if (repeat_infos.size() == 0) {
        repeat_infos.push_back(repeat_read_info);
        return;
    }

    // 检查当前时间与栈顶元素的构造时间进行比较，若时间只差超过17ms，则说明不构成重复读操作，清除数组。  
    if((GetTickCount() - repeat_infos[repeat_infos.size() - 1].op_timems) > 17) {   //17ms todo astrozhou add to params
        repeat_infos.clear();
    }

    // 从栈中找到与当前对象相等的info，累加重复读次数
    // 注意这里重载了RepeatIOInfo的==操作，java_stack字段也参与了判定，也就是说同一文件不同的使用位置不认为是同一个相等的对象
    bool found = false;
    int repeatCnt;
    for (auto& info : repeat_infos) {
        if (info == repeat_read_info) {
            found = true;

            info.IncRepeatReadCount();

            repeatCnt = info.GetRepeatReadCount();
            break;
        }
    }

    // 若找不到相等对象，则push进数组
    if (!found) {
        repeat_infos.push_back(repeat_read_info);
        return;
    }

    // 检查重复读次数是否超过阈值（5），若超过则进行上报
    if (repeatCnt >= env.GetRepeatReadThreshold()) {
        Issue issue(kType, file_io_info);
        issue.repeat_read_cnt_ = repeatCnt;
        issue.stack = repeat_read_info.GetStack();
        PublishIssue(issue, issues);
    }
}