【systrace学习】atrace打开各系统层tag开关的原理

atrace命令可以开启trace，让系统中埋下的trace标记开始记录，这是怎么实现的呢，

我们以系统层的trace为例来查看，

atrace的代码

frameworks/native/cmds/atrace/​​​​​​atrace.cpp

/* Tracing categories */
static const TracingCategory k_categories[] = {
    { "gfx",        "Graphics",         ATRACE_TAG_GRAPHICS, {
        { OPT,      "events/mdss/enable" },
        { OPT,      "events/sde/enable" },
    } },
    { "input",      "Input",            ATRACE_TAG_INPUT, { } },
    { "view",       "View System",      ATRACE_TAG_VIEW, { } },
    { "webview",    "WebView",          ATRACE_TAG_WEBVIEW, { } },
    { "wm",         "Window Manager",   ATRACE_TAG_WINDOW_MANAGER, { } },

里面通过设置属性的值，来传递信息，即哪些tag需要进行记录

// Set the trace tags that userland tracing uses, and poke the running
// processes to pick up the new value.
static bool setTagsProperty(uint64_t tags)
{
    std::string value = android::base::StringPrintf("%#" PRIx64, tags);
    if (!android::base::SetProperty(k_traceTagsProperty, value)) {
        fprintf(stderr, "error setting trace tags system property\n");
        return false;
    }
    return true;
}

const char* k_traceTagsProperty = "debug.atrace.tags.enableflags";

执行函数由于执行的次数很多，所以没有必要每次都读取属性 debug.atrace.tags.enableflags的值来判断当前tag是否需要打印，只需要读一次，保存下来即可。

但是进程怎么知道属性值变化了呢，这里调用每个系统服务的SYSPROPS_TRANSACTION方法，来推送，

// Poke all the binder-enabled processes in the system to get them to re-read
// their system properties.
static bool pokeBinderServices()
{
    sp<IServiceManager> sm = defaultServiceManager();
    Vector<String16> services = sm->listServices();
    for (size_t i = 0; i < services.size(); i++) {
        sp<IBinder> obj = sm->checkService(services[i]);
        if (obj != NULL) {
            Parcel data;
            if (obj->transact(IBinder::SYSPROPS_TRANSACTION, data,
                    NULL, 0) != OK) {
                if (false) {
                    // XXX: For some reason this fails on tablets trying to
                    // poke the "phone" service.  It's not clear whether some
                    // are expected to fail.
                    String8 svc(services[i]);
                    fprintf(stderr, "error poking binder service %s\n",
                        svc.string());
                    return false;
                }
            }
        }
    }
    return true;
}

SYSPROPS_TRANSACTION 方法执行起来做什么？

status_t BBinder::onTransact(
    uint32_t code, const Parcel& data, Parcel* reply, uint32_t /*flags*/)
{
    switch (code) {
        ...
        case SYSPROPS_TRANSACTION: {
            report_sysprop_change();
            return NO_ERROR;
        }
        ...
    }
}
 

report_sysprop_change()方法会调用属性变化的回调函数，

void report_sysprop_change() {
   do_report_sysprop_change();

#if defined(__ANDROID__)
    // libutils.so is double loaded; from the default namespace and from the
    // 'sphal' namespace. Redirect the sysprop change event to the other instance
    // of libutils.so loaded in the 'sphal' namespace so that listeners attached
    // to that instance is also notified with this event.
    static auto func = get_report_sysprop_change_func();
    if (func != nullptr) {
        (*func)();
    }
#endif
}

所以，服务进程中写了回调函数后，就可以更新属性的值了。

这里使用了binder来进行通知。

InputDispatcher里的trace调用

void InputDispatcher::traceInboundQueueLengthLocked() {
    if (ATRACE_ENABLED()) {
        ATRACE_INT("iq", mInboundQueue.count());
    }
}

ATRACE_ENABLED

/system/core/include/cutils/
H A D	trace.h	168 #define ATRACE_ENABLED() atrace_is_tag_enabled(ATRACE_TAG)

#define ATRACE_GET_ENABLED_TAGS() atrace_get_enabled_tags()
static inline uint64_t atrace_get_enabled_tags()
{
    atrace_init();
    return atrace_enabled_tags;
}

/**
 * Test if a given tag is currently enabled.
 * Returns nonzero if the tag is enabled, otherwise zero.
 * It can be used as a guard condition around more expensive trace calculations.
 */
#define ATRACE_ENABLED() atrace_is_tag_enabled(ATRACE_TAG)
static inline uint64_t atrace_is_tag_enabled(uint64_t tag)
{
    return atrace_get_enabled_tags() & tag;
}

调用traceInit()可以设置属性变化的回调，会调用

static void traceInit() {
    ::android::add_sysprop_change_callback(atrace_update_tags, 0);
}

这里有个很有意思的知识点，在代码中搜不到traceInit的调用，只看到定义，

static void traceInit() __attribute__((constructor));

22static void traceInit() {
23    ::android::add_sysprop_change_callback(atrace_update_tags, 0);
24}

那到底是怎样设置的回调函数呢？

其实设置了  __attribute__((constructor))  这个高端写法，在main函数开始的地方，就会调用traceInit方法，我们可以搜一下  __attribute__((constructor))这个用法。也可以写个例子来验证这种调用，情况确实如此。

查看atrace_update_tags的定义，在里面读取属性"debug.atrace.tags.enableflags"的值，更新了atrace_enabled_tags的值，

98/**
99 * If tracing is ready, set atrace_enabled_tags to the system property
100 * debug.atrace.tags.enableflags. Can be used as a sysprop change callback.
101 */
102void atrace_update_tags();

在 system/core/libcutils/trace-dev.inc

里有其实现，获取了要监控的属性值

// Update tags if tracing is ready. Useful as a sysprop change callback.
void atrace_update_tags()
{
    uint64_t tags;
    if (CC_UNLIKELY(atomic_load_explicit(&atrace_is_ready, memory_order_acquire))) {
        if (atomic_load_explicit(&atrace_is_enabled, memory_order_acquire)) {
            tags = atrace_get_property();
            pthread_mutex_lock(&atrace_tags_mutex);
            atrace_enabled_tags = tags;
            pthread_mutex_unlock(&atrace_tags_mutex);
        } else {
            // Tracing is disabled for this process, so we simply don't
            // initialize the tags.
            pthread_mutex_lock(&atrace_tags_mutex);
            atrace_enabled_tags = ATRACE_TAG_NOT_READY;
            pthread_mutex_unlock(&atrace_tags_mutex);
        }
    }
}

总结：

细节很多，这里回顾一下大体过程，atrace里设置tag，标识哪些tag可以进行写trace，然后写到属性值debug.atrace.tags.enableflags里，atrace又进行了binder调用所有系统服务的SYSPROPS_TRANSACTION对应的方法，告诉它们，属性值变化了，可以调用属性变化回调函数了。

系统服务进程就调用预定的回调函数，读取debug.atrace.tags.enableflags的值，保存起来，以后就可以用这个值来和tag进行比较，判断当前的tag是否需要写trace，避免每次都属性值，那个读取代价太大。

普通应用中的trace原理类似，也是设置了属性值。

相关知识点：属性值的变化可以设置回调函数。

binder中竟然有个冷门方法SYSPROPS_TRANSACTION，通知属性值的变化。

参考资料：

[Android systrace系列] systrace的信息从哪里来 - zzc1024 - 博客园

监听SystemProperties变化_m0_52481422的博客-CSDN博客_android 监听property变化