Android 4.4 Init进程分析六 ：属性服务

****************************************************************************

Android 4.4 init进程分析文章链接

　　Android 4.4 Init进程分析一 ：Android init进程概述

　　Android 4.4 Init进程分析二 ：Android初始化语言

　　Android 4.4 Init进程分析三：init.rc脚本文件的解析

　　Android 4.4 Init进程分析四 ：init.rc脚本文件的执行

　　Android 4.4 Init进程分析五 ：进程的终止与再启动

　　Android 4.4 Init进程分析六 ：属性服务

***************************************************************************

 

1 前言

　　1. 属性变更请求是init事件处理循环处理的另一个事件。

　　2. 在Android平台中，为了让运行中的所有进程共享系统运行时所需要的各种设置值，系统开辟了属性存储区域，并提供了访问该区域的API。

　　3. 属性又键(key)和值(value)构成，其表现形式为“键=值”。

　　4. 系统中所有运行中的进程都可以访问属性值，但仅有init进程才能修改属性值，其他进程修改属性值时，必须向init进程提出请求，最终由init进程负责修改属性值。

　　5. init进程修改属性值时，首先会先检查各属性的访问权限，而后再修改属性值。当属性值修改后，若定义在init.rc文件中的某个条件得到满足，则与此条件相匹配的动作就会发生。每个动作都有一个触发器(trigger)，他决定动作的执行时间，记录在“on property”关键字后的命令即被执行。

　　如下图，简单描述了init进程与其他进程在访问并修改属性值的大致情形：

2 属性初始化

　　在init进程的main()函数中，调用了property_init()函数，用来初始化属性域，如下代码：

http://androidxref.com/4.4_r1/xref/system/core/init/init.c#1009

int main(int argc, char **argv)
{
     ....
    property_init();
     ....  
}    

再看一下property_init()函数的定义：

http://androidxref.com/4.4_r1/xref/system/core/init/property_service.c#541

void property_init(void)
{
    init_property_area();
}

可以看到函数内调用了init_property_area()函数，如下定义

http://androidxref.com/4.4_r1/xref/system/core/init/property_service.c#133

static int init_property_area(void)
{
    if (property_area_inited)
        return -1;

    if(__system_property_area_init())
        return -1;

    if(init_workspace(&pa_workspace, 0))
        return -1;

    fcntl(pa_workspace.fd, F_SETFD, FD_CLOEXEC);

    property_area_inited = 1;
    return 0;
}

这个函数会在内存中开辟一块共享内存区域，而后将其用作ashmem（Android Shared Memory），并生成属性域。外部进程可以访问这块共享内存区域，获得属性值，但它们不能通过直接访问共享内存区域的方式更改属性值。

init_property_area()函数执行后所创建的属性域被初始化。

在属性域完成初始化之后，就会从指定的文件中读取初始值，并设置为属性值。可以在main()函数中看到：

http://androidxref.com/4.4_r1/xref/system/core/init/init.c#1035

    if (!is_charger)
        property_load_boot_defaults();

property_load_boot_defaults()函数定义：

http://androidxref.com/4.4_r1/xref/system/core/init/property_service.c#546

void property_load_boot_defaults(void)
{
    load_properties_from_file(PROP_PATH_RAMDISK_DEFAULT);
}

PROP_PATH_RAMDISK_DEFAULT定义为：

#define PROP_PATH_RAMDISK_DEFAULT "/default.prop" 

load_properties_from_file()函数定义为：

static void load_properties_from_file(const char *fn)
{
    char *data;
    unsigned sz;

    data = read_file(fn, &sz);

    if(data != 0) {
        load_properties(data);
        free(data);
    }
}

load_properties_from_file()函数读取指定的property file内容到内存，然后调用load_properties()：

http://androidxref.com/4.4_r1/xref/system/core/init/property_service.c#440

static void load_properties(char *data)
{
    char *key, *value, *eol, *sol, *tmp;

    sol = data;
    while((eol = strchr(sol, '
'))) {
        key = sol;
        *eol++ = 0;
        sol = eol;

        value = strchr(key, '=');
        if(value == 0) continue;
        *value++ = 0;

        while(isspace(*key)) key++;
        if(*key == '#') continue;
        tmp = value - 2;
        while((tmp > key) && isspace(*tmp)) *tmp-- = 0;

        while(isspace(*value)) value++;
        tmp = eol - 2;
        while((tmp > value) && isspace(*tmp)) *tmp-- = 0;

        property_set(key, value);
    }
}

在load_properties()函数中分析得到key and value,并调用property_set(key, value);将属性值写入共享内存。

******************************************

再回到main()函数继续执行，可以看到如下语句：

http://androidxref.com/4.4_r1/xref/system/core/init/init.c#1064

queue_builtin_action(property_service_init_action, "property_service_init");

这个动作执行时，会去调用property_service_init_action()函数：

http://androidxref.com/4.4_r1/xref/system/core/init/init.c#789

static int property_service_init_action(int nargs, char **args)
{
    /* read any property files on system or data and
     * fire up the property service.  This must happen
     * after the ro.foo properties are set above so
     * that /data/local.prop cannot interfere with them.
     */
    start_property_service();
    return 0;
}

进而调用了start_property_service()函数。用于创建启动属性服务所需要的Unix域套接字，并保存套接字描述符，如下函数定义：

http://androidxref.com/4.4_r1/xref/system/core/init/property_service.c#581

void start_property_service(void)
{
    int fd;

    load_properties_from_file(PROP_PATH_SYSTEM_BUILD);
    load_properties_from_file(PROP_PATH_SYSTEM_DEFAULT);
    load_override_properties();
    /* Read persistent properties after all default values have been loaded. */
    load_persistent_properties();

    fd = create_socket(PROP_SERVICE_NAME, SOCK_STREAM, 0666, 0, 0);
    if(fd < 0) return;
    fcntl(fd, F_SETFD, FD_CLOEXEC);
    fcntl(fd, F_SETFL, O_NONBLOCK);

    listen(fd, 8);
    property_set_fd = fd;
}

start_property_service()函数在创建套接字之前，先读取存储在各个文件中的基本设置值，将它们设置为属性值，如上函数定义会读取以下文件：

//文件
#define PROP_PATH_SYSTEM_BUILD     "/system/build.prop"
#define PROP_PATH_SYSTEM_DEFAULT   "/system/default.prop"
#define PROP_PATH_LOCAL_OVERRIDE   "/data/local.prop"

当所有系统初始值设置完毕后，开始读取保存在/data/property目录中的属性值：

load_persistent_properties();

==>>>

static void load_persistent_properties()
{
    DIR* dir = opendir(PERSISTENT_PROPERTY_DIR);
    ....
}

==>>>

#define PERSISTENT_PROPERTY_DIR  "/data/property"

在/data/property目录中保存着系统运行中其他进程新生成的属性值或更改的属性值，属性的key被用作文件名，value被保存在文件中。

在属性初始值设置完毕后，就会创建名称为  /dev/socket/property_service  的Unix域套接字。

上述过程我们大体可以总结如下图所示：

 

3 属性变更请求处理

3.1 其他进程请求变更属性值

 其他进程设置属性时是调用了libcutils函数库中的property_set()方法，该方法的定义去下：

http://androidxref.com/4.4_r1/xref/system/core/libcutils/properties.c#34

int property_set(const char *key, const char *value)
{
    return __system_property_set(key, value);
}

可以看到，property_set调用了__system_property_set方法，这个方法位于：/bionic/libc/bionic/system_properties.c文件中：

http://androidxref.com/4.4_r1/xref/bionic/libc/bionic/system_properties.c#540

int __system_property_set(const char *key, const char *value)
{
    int err;
    prop_msg msg;

    if(key == 0) return -1;
    if(value == 0) value = "";
    if(strlen(key) >= PROP_NAME_MAX) return -1;
    if(strlen(value) >= PROP_VALUE_MAX) return -1;

    memset(&msg, 0, sizeof msg);
    msg.cmd = PROP_MSG_SETPROP;
    strlcpy(msg.name, key, sizeof msg.name);
    strlcpy(msg.value, value, sizeof msg.value);

    err = send_prop_msg(&msg);
    if(err < 0) {
        return err;
    }

    return 0;
}

上述方法最终调用到send_prop_msg()函数：

http://androidxref.com/4.4_r1/xref/bionic/libc/bionic/system_properties.c#send_prop_msg

static int send_prop_msg(prop_msg *msg)
{
    struct pollfd pollfds[1];
    struct sockaddr_un addr;
    socklen_t alen;
    size_t namelen;
    int s;
    int r;
    int result = -1;

    s = socket(AF_LOCAL, SOCK_STREAM, 0);
    if(s < 0) {
        return result;
    }

    memset(&addr, 0, sizeof(addr));
    namelen = strlen(property_service_socket);
    strlcpy(addr.sun_path, property_service_socket, sizeof addr.sun_path);
    addr.sun_family = AF_LOCAL;
    alen = namelen + offsetof(struct sockaddr_un, sun_path) + 1;

    if(TEMP_FAILURE_RETRY(connect(s, (struct sockaddr *) &addr, alen)) < 0) {
        close(s);
        return result;
    }

    r = TEMP_FAILURE_RETRY(send(s, msg, sizeof(prop_msg), 0));

    if(r == sizeof(prop_msg)) {
        // We successfully wrote to the property server but now we
        // wait for the property server to finish its work.  It
        // acknowledges its completion by closing the socket so we
        // poll here (on nothing), waiting for the socket to close.
        // If you 'adb shell setprop foo bar' you'll see the POLLHUP
        // once the socket closes.  Out of paranoia we cap our poll
        // at 250 ms.
        pollfds[0].fd = s;
        pollfds[0].events = 0;
        r = TEMP_FAILURE_RETRY(poll(pollfds, 1, 250 /* ms */));
        if (r == 1 && (pollfds[0].revents & POLLHUP) != 0) {
            result = 0;
        } else {
            // Ignore the timeout and treat it like a success anyway.
            // The init process is single-threaded and its property
            // service is sometimes slow to respond (perhaps it's off
            // starting a child process or something) and thus this
            // times out and the caller thinks it failed, even though
            // it's still getting around to it.  So we fake it here,
            // mostly for ctl.* properties, but we do try and wait 250
            // ms so callers who do read-after-write can reliably see
            // what they've written.  Most of the time.
            // TODO: fix the system properties design.
            result = 0;
        }
    }

    close(s);
    return result;
}

send_prop_msg()函数可以看到：建立与属性服务/dev/socket/property_service 的socket连接，并发送要修改的属性信息。

3.2 init进程处理属性变更

　　init进程就收到属性变更请求后，init进程就会调用handle_property_set_fd()函数：

int main(int argc, char **argv)
{  
    ....
      for (i = 0; i < fd_count; i++) {
            if (ufds[i].revents == POLLIN) {
                if (ufds[i].fd == get_property_set_fd())
                    handle_property_set_fd();// 处理属性变更请求
                else if (ufds[i].fd == get_keychord_fd())
                    handle_keychord();
                else if (ufds[i].fd == get_signal_fd())
                    handle_signal();
            }
        }
    ....
}

我们来看一下handle_property_set_fd()函数的定义：

http://androidxref.com/4.4_r1/xref/system/core/init/property_service.c#358

void handle_property_set_fd()
{
    ....

    /* Check socket options here */
    if (getsockopt(s, SOL_SOCKET, SO_PEERCRED, &cr, &cr_size) < 0) { //分析1
        close(s);
        ERROR("Unable to receive socket options
");
        return;
    }

    ....
    switch(msg.cmd) {
    case PROP_MSG_SETPROP:
        msg.name[PROP_NAME_MAX-1] = 0;
        msg.value[PROP_VALUE_MAX-1] = 0;
        ...
        if(memcmp(msg.name,"ctl.",4) == 0) {
            // Keep the old close-socket-early behavior when handling
            // ctl.* properties.
            close(s);
            if (check_control_perms(msg.value, cr.uid, cr.gid, source_ctx)) { //分析2
                handle_control_message((char*) msg.name + 4, (char*) msg.value);
            } else {
                ERROR("sys_prop: Unable to %s service ctl [%s] uid:%d gid:%d pid:%d
",
                        msg.name + 4, msg.value, cr.uid, cr.gid, cr.pid);
            }
        } else {
            if (check_perms(msg.name, cr.uid, cr.gid, source_ctx)) { //分析3
                property_set((char*) msg.name, (char*) msg.value); //分析4
            } else {
                ERROR("sys_prop: permission denied uid:%d  name:%s
",
                      cr.uid, msg.name);
            }

            // Note: bionic's property client code assumes that the
            // property server will not close the socket until *AFTER*
            // the property is written to memory.
            close(s);
        }
    ...
    }
}

分析1：执行handle_property_set_fd()函数时，会先从套接字获取SO_PEERCRED值，以便检查传递信息的进程的访问权限。在struct ucred结构体中，存储着传递信息的进程uid、pid和gid值。通过此结构体中的值，以及消息的类型，检查进程的访问权限。

分析2：在属性消息中，以“ctl”开头的消息并非请求更改系统属性值的消息，而是请求进程启动与终止的消息。在代码中调用check_control_perms()函数检查访问权限，仅有system server、root、以及相关进程才能使用ctl消息，终止或启动进程

分析3：其他消息都被用来更改系统属性值，调用check_perms()函数检查访问权限。各属性的访问权限采用Linux的uid进程区分，其定义如下代码所示。若在系统运行中变更属性设置，应充分考虑各属性的访问权限。

http://androidxref.com/4.4_r1/xref/system/core/init/property_service.c#60

struct {
    const char *prefix;
    unsigned int uid;
    unsigned int gid;
} property_perms[] = {
    { "net.rmnet0.",      AID_RADIO,    0 },
    { "net.gprs.",        AID_RADIO,    0 },
    { "net.ppp",          AID_RADIO,    0 },
    { "net.qmi",          AID_RADIO,    0 },
    { "net.lte",          AID_RADIO,    0 },
    { "net.cdma",         AID_RADIO,    0 },
    { "ril.",             AID_RADIO,    0 },
    { "gsm.",             AID_RADIO,    0 },
    { "persist.radio",    AID_RADIO,    0 },
    { "net.dns",          AID_RADIO,    0 },
    { "sys.usb.config",   AID_RADIO,    0 },
    { "net.",             AID_SYSTEM,   0 },
    { "dev.",             AID_SYSTEM,   0 },
    { "runtime.",         AID_SYSTEM,   0 },
    { "hw.",              AID_SYSTEM,   0 },
    { "sys.",             AID_SYSTEM,   0 },
    { "sys.powerctl",     AID_SHELL,    0 },
    { "service.",         AID_SYSTEM,   0 },
    { "wlan.",            AID_SYSTEM,   0 },
    { "bluetooth.",       AID_BLUETOOTH,   0 },
    { "dhcp.",            AID_SYSTEM,   0 },
    { "dhcp.",            AID_DHCP,     0 },
    { "debug.",           AID_SYSTEM,   0 },
    { "debug.",           AID_SHELL,    0 },
    { "log.",             AID_SHELL,    0 },
    { "service.adb.root", AID_SHELL,    0 },
    { "service.adb.tcp.port", AID_SHELL,    0 },
    { "persist.sys.",     AID_SYSTEM,   0 },
    { "persist.service.", AID_SYSTEM,   0 },
    { "persist.security.", AID_SYSTEM,   0 },
    { "persist.service.bdroid.", AID_BLUETOOTH,   0 },
    { "selinux."         , AID_SYSTEM,   0 },
    { NULL, 0, 0 }
};

分析4：最后调用property_set()函数更改属性值。若没有问题，接着调用property_changed()函数。

property_changed()函数的定义如下：

http://androidxref.com/4.4_r1/xref/system/core/init/init.c#412

void property_changed(const char *name, const char *value)
{
    if (property_triggers_enabled)
        queue_property_triggers(name, value);
}

http://androidxref.com/4.4_r1/xref/system/core/init/init_parser.c#517

void queue_property_triggers(const char *name, const char *value)
{
    struct listnode *node;
    struct action *act;
    list_for_each(node, &action_list) {
        act = node_to_item(node, struct action, alist);
        if (!strncmp(act->name, "property:", strlen("property:"))) {
            const char *test = act->name + strlen("property:");
            int name_length = strlen(name);

            if (!strncmp(name, test, name_length) &&
                    test[name_length] == '=' &&
                    (!strcmp(test + name_length + 1, value) ||
                     !strcmp(test + name_length + 1, "*"))) {
                action_add_queue_tail(act);
            }
        }
    }
}

queue_property_triggers()函数中，去action_list中检索出与这个属性值相关的action加入到action_queue，等待执行。

在init.rc脚本文件中，记录着某个属性改变后要采取的动作，动作执行的条件以“on property：<key> = <value>”形式给出。当某个条件相关的键值被设定后，与该条件相关的触发器就会被触发。比如：

# adbd on at boot in emulator
on property:ro.kernel.qemu=1
    start adbd

当ro.kernel.qemu属性值被设置为1时，adbd服务就会启动。

 到这里属性变更的处理就分析完了！

 大体过程如下：

========

88888888

========