property_set的整体过程--以reboot和bootanim为例

前记

         最近看到surfaceflinger在初始化结束后会通过property_set的方式启动开机动画，这种情形很像之前reboot命令中看见的，因此按照之前的分析来分析bootanim，但是发现分析错误，后来深入去了解，才发现我之前分析错了，因此写下这份文档纠正自己的错误，以便以后的学习。

1. Property_set的整个过程

 我先纠正一下reboot命令的分析，reboot的源码比较简单，在system/core/reboot/reboot.c中：

ret = property_set(ANDROID_RB_PROPERTY,property_val);

         reboot是通过property_set的方式触发propertychange事件，然后才会去真正执行reboot操作。而之前分析错误的原因主要就是property_set的定位出错。

 利用SourceInsight进行代码搜索，可以发现有两个地方定义了property_set，分析是在system/core/libcutils/properties.c和system/core/init/property_service.c。当时由于主观臆想定位出错了，现在分析一下如何正确地定位是在哪个源文件实现：

         Reboot目录下的Android.mk中是如下定义的：

LOCAL_PATH:= $(call my-dir)

include $(CLEAR_VARS)

LOCAL_SRC_FILES:= reboot.c

LOCAL_SHARED_LIBRARIES:= libcutils        

LOCAL_MODULE:= reboot

include $(BUILD_EXECUTABLE)

         reboot只包含了libcutils这个动态库，因此property_set就应该是在这里所实现的。而从这个库的名字就可以猜测其是在system/core/libcutils中，我们验证一下；

         从system/core/libcutils/Android.mk中可以看到，property_set就是该目录下的properties.c中定义的。

         在properties.c中有三个property_set的定义：

#ifdef HAVE_LIBC_SYSTEM_PROPERTIES        /*如果有定义libc，也就是bionic*/

int property_set(const char *key, const char*value)

{

    return__system_property_set(key, value);

}

#elif defined(HAVE_SYSTEM_PROPERTY_SERVER)     /*如果定义了property_server*/

int property_set(const char *key, const char*value)

{

    charsendBuf[1+PROPERTY_KEY_MAX+PROPERTY_VALUE_MAX];

    charrecvBuf[1];

    intresult = -1;

   //ALOGV("PROPERTY SET [%s]: [%s]\n", key, value);

   pthread_once(&gInitOnce, init);

    if(gPropFd < 0)

       return -1;

    if(strlen(key) >= PROPERTY_KEY_MAX) return -1;

    if(strlen(value) >= PROPERTY_VALUE_MAX) return -1;

   memset(sendBuf, 0xdd, sizeof(sendBuf));    // placate valgrind

   sendBuf[0] = (char) kSystemPropertySet;

   strcpy(sendBuf+1, key);

   strcpy(sendBuf+1+PROPERTY_KEY_MAX, value);

pthread_mutex_lock(&gPropertyFdLock);

/*通过socket -- /tmp/android-sysprop */

    if(write(gPropFd, sendBuf, sizeof(sendBuf)) != sizeof(sendBuf)){

       pthread_mutex_unlock(&gPropertyFdLock);

       return -1;

    }

    if(read(gPropFd, recvBuf, sizeof(recvBuf)) != sizeof(recvBuf)) {

       pthread_mutex_unlock(&gPropertyFdLock);

       return -1;

    }

   pthread_mutex_unlock(&gPropertyFdLock);

    if(recvBuf[0] != 1)

       return -1;

    return0;

}

#else

int property_set(const char *key, const char*value)

{

    charename[PROPERTY_KEY_MAX + 6];

    char*p;

    intlen;

    int r;

   if(strlen(value) >= PROPERTY_VALUE_MAX) return -1;

    len =strlen(key);

    if(len>= PROPERTY_KEY_MAX) return -1;

   memcpy(ename, "PROP_", 5);

    memcpy(ename+ 5, key, len + 1);

mutex_lock(&env_lock);

/*通过env*/

#ifdef HAVE_MS_C_RUNTIME

    {

       char  temp[256];

       snprintf( temp, sizeof(temp), "%s=%s", ename, value);

       putenv(temp);

        r= 0;

    }

#else   

    r =setenv(ename, value, 1);

#endif   

   mutex_unlock(&env_lock);

    returnr;

}

#endif

         Property_set在Libcutils中有三种方式，可以通过配置进行选择，而通过grep可以知道使用的是libc的方式：

./build/core/combo/include/arch/linux-arm/AndroidConfig.h:249:#defineHAVE_LIBC_SYSTEM_PROPERTIES 1

         __system_property_set是在bionic/libc/bionic/system_properties.c中定义的：

int __system_property_set(const char *key, constchar *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;

    }

    return0;

}

static int send_prop_msg(prop_msg *msg)

{

    structpollfd pollfds[1];

    structsockaddr_un addr;

   socklen_t alen;

    size_tnamelen;

    int s;

    int r;

    intresult = -1;

    s =socket(AF_LOCAL, SOCK_STREAM, 0);

    if(s< 0) {

       return result;

    }

   memset(&addr, 0, sizeof(addr));

namelen= strlen(property_service_socket);

/*

PROP_SERVICE_NAME=property_server

staticconst char property_service_socket[] = "/dev/socket/"PROP_SERVICE_NAME;

*/

   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)) {

       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 {

           result = 0;

        }

    }

   close(s);

    returnresult;

}

         也就是说，propert_set最终会通过socket(IPC)来通知server处理，那必然会有一个server在接收数据进行处理，而这个server在init进程中：

<system/core/init/init.c>

queue_builtin_action(property_service_init_action,"property_service_init");

static intproperty_service_init_action(int nargs, char **args)

{

    start_property_service();

    return 0;

}

voidstart_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 alldefault values have been loaded. */

load_persistent_properties();

/*创建socket接收数据*/

    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;

}

<main>

for(;;) {

        int nr, i, timeout = -1;

        execute_one_command();

        restart_processes();

        if (!property_set_fd_init &&get_property_set_fd() > 0) {

            ufds[fd_count].fd =get_property_set_fd();   /*监听property_set_fd*/

            ufds[fd_count].events = POLLIN;

            ufds[fd_count].revents = 0;

            fd_count++;

            property_set_fd_init = 1;

        }

        if (!signal_fd_init &&get_signal_fd() > 0) {

            ufds[fd_count].fd =get_signal_fd();

            ufds[fd_count].events = POLLIN;

            ufds[fd_count].revents = 0;

            fd_count++;

            signal_fd_init = 1;

        }

        if (!keychord_fd_init &&get_keychord_fd() > 0) {

            ufds[fd_count].fd =get_keychord_fd();

            ufds[fd_count].events = POLLIN;

            ufds[fd_count].revents = 0;

            fd_count++;

            keychord_fd_init = 1;

        }

        if (process_needs_restart) {

            timeout = (process_needs_restart -gettime()) * 1000;

            if (timeout < 0)

                timeout = 0;

        }

        if (!action_queue_empty() ||cur_action)

            timeout = 0;

#ifBOOTCHART

        if (bootchart_count > 0) {

            if (timeout < 0 || timeout >BOOTCHART_POLLING_MS)

                timeout = BOOTCHART_POLLING_MS;

            if (bootchart_step() < 0 ||--bootchart_count == 0) {

                bootchart_finish();

                bootchart_count = 0;

            }

        }

#endif

        nr = poll(ufds, fd_count, timeout);

        if (nr <= 0)

            continue;

        for (i = 0; i < fd_count; i++) {

            if (ufds[i].revents == POLLIN) {

                if (ufds[i].fd ==get_property_set_fd())   /*如果property_set_fd有POLLIN事件*/

                    handle_property_set_fd();

                else if (ufds[i].fd ==get_keychord_fd())

                    handle_keychord();

                else if (ufds[i].fd ==get_signal_fd())

                    handle_signal();

            }

        }

}

<property_service.c>

voidhandle_property_set_fd()

{

    prop_msg msg;

    int s;

    int r;

    int res;

    struct ucred cr;

    struct sockaddr_un addr;

    socklen_t addr_size = sizeof(addr);

    socklen_t cr_size = sizeof(cr);

char * source_ctx = NULL;

/*接收property_set的数据*/

    if ((s = accept(property_set_fd, (structsockaddr *) &addr, &addr_size)) < 0) {

        return;

    }

    /* Check socket options here */

    if (getsockopt(s, SOL_SOCKET, SO_PEERCRED,&cr, &cr_size) < 0) {

        close(s);

        ERROR("Unable to receive socketoptions\n");

        return;

    }

    r = TEMP_FAILURE_RETRY(recv(s, &msg,sizeof(msg), 0));

    if(r != sizeof(prop_msg)) {

        close(s);

        return;

    }

    switch(msg.cmd) {

    case PROP_MSG_SETPROP:

       msg.name[PROP_NAME_MAX-1] = 0;

        msg.value[PROP_VALUE_MAX-1] = 0;

        /*校验property是否合法的属性*/

        if (!is_legal_property_name(msg.name,strlen(msg.name))) {

            ERROR("sys_prop: illegalproperty name. Got: \"%s\"\n", msg.name);

            close(s);

            return;

        }

        getpeercon(s, &source_ctx);

        /*如果是带有”ctl.”开头的属性，是具有控制操作的，另作处理，这就是bootanim的处理过程*/

        if(memcmp(msg.name,"ctl.",4)== 0) {

            close(s);

            if (check_control_perms(msg.value,cr.uid, cr.gid, source_ctx)) {

                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\n",

                        msg.name + 4,msg.value, cr.uid, cr.gid, cr.pid);

            }

        } else {  /*其他属性*/

            if (check_perms(msg.name, cr.uid,cr.gid, source_ctx)) {

             /*当初定位错误就是在这里，分析reboot的时候直接跳到这一步*/

                property_set((char*)msg.name, (char*) msg.value);

            } else {

            }

            close(s);

        }

        freecon(source_ctx);

        break;

    default:

        close(s);

        break;

    }

}

1.1 reboot的处理

对于reboot的处理，就是第二分支，调用了property_set来进行处理，而这个property_set与在reboot.c中调用的property_set并不是同一个，这个后者是在libc定义的，前者是在property_service中定义的。

<system/core/init/property_service.c>

int property_set(const char *name, const char*value)

{

   prop_info *pi;

    intret;

    size_tnamelen = strlen(name);

    size_tvaluelen = strlen(value);

    if(!is_legal_property_name(name, namelen)) return -1;

    if(valuelen >= PROP_VALUE_MAX) return -1;

    pi =(prop_info*) __system_property_find(name);

    if(pi!= 0) {

        /*ro.* properties may NEVER be modified once set */

       if(!strncmp(name, "ro.", 3)) return -1;

       __system_property_update(pi, value, valuelen);   /*更新到property的内存区域中*/

    } else{

       ret = __system_property_add(name, namelen, value, valuelen);  /*新增一个属性*/

        if(ret < 0) {

           ERROR("Failed to set '%s'='%s'\n", name, value);

           return ret;

        }

    }

    /* Ifname starts with "net." treat as a DNS property. */

    if(strncmp("net.", name, strlen("net.")) == 0)  {

        if(strcmp("net.change", name) == 0) {

           return 0;

        }

       property_set("net.change", name);

    } elseif (persistent_properties_loaded &&

           strncmp("persist.", name, strlen("persist.")) == 0){

       write_persistent_property(name, value);

    } elseif (strcmp("selinux.reload_policy", name) == 0 &&

              strcmp("1", value) == 0) {

       selinux_reload_policy();

    }

    property_changed(name, value);

    #ifdefAW_BOOSTUP_ENABLE

    aw_boost_up_perf(name,value);

    #endif

    return0;

}

void property_changed(const char *name, constchar *value)

{

    if(property_triggers_enabled)

       queue_property_triggers(name, value);

}

void queue_property_triggers(const char *name,const char *value)

{

    structlistnode *node;

structaction *act;

/*遍历所有注册的action*/

   list_for_each(node, &action_list) {

       act = node_to_item(node, struct action, alist);

        /*匹配带有property的action，直到与property_set的属性相同的action，然后执行相应操作*/

        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);   /*添加到action队列中，等待init进程执行*/

           }

        }

    }

}

         Reboot的propert_set对应的命令是：

#define ANDROID_RB_PROPERTY"sys.powerctl"

         Init.rc中对应的sys.powerctlaction是如下定义的：

on property:sys.powerctl=*

   powerctl ${sys.powerctl}

         无论powerctl为何值，都会执行{powerctl${sys.powerctl}}这个操作，powerctl对应的函数在keyword.h中有定义—do_powerctl，这里就不进行分析了。

1.2 bootanim的处理

Bootanim对应于第一个分支，我们可以看看surfaceflinger是如何启动bootanim的：

void SurfaceFlinger::startBootAnim() {

    //start boot animation

   property_set("service.bootanim.exit", "0");

    property_set("ctl.start","bootanim");   /*主要是这一个操作*/

}

<init.rc>

service bootanim /system/bin/bootanimation

    classmain

    usersystem

    groupsystem

    disabled      /*在init.rc中bootanim是disable的，因为需要等待surfaceflinger的初始化完成*/

   oneshot

         当startBootAnim()后，就可以运行开机动画了。我们看一下property_service是如何实现的：

void handle_control_message(const char *msg,const char *arg)

{

    if(!strcmp(msg,"start")) {   /*ctl后带的是start*/

        msg_start(arg);

    } elseif (!strcmp(msg,"stop")) {

       msg_stop(arg);

    } elseif (!strcmp(msg,"restart")) {

       msg_restart(arg);

    } else{

       ERROR("unknown control msg '%s'\n", msg);

    }

}

static void msg_start(const char *name)

{

    structservice *svc = NULL;

    char*tmp = NULL;

    char*args = NULL;

 

    if(!strchr(name, ':'))

       svc = service_find_by_name(name);

    else {

       tmp = strdup(name);

        if(tmp) {

           args = strchr(tmp, ':');

           *args = '\0';

           args++;

           svc = service_find_by_name(tmp);

        }

    }

    if(svc) {

        service_start(svc, args);

    } else{

       ERROR("no such service '%s'\n", name);

    }

    if(tmp)

       free(tmp);

}

         Property_service在收到ctl族的property后，先去找到这个service，然后启动它。

struct service *service_find_by_name(const char*name)

{

    structlistnode *node;

structservice *svc;

/*service_list 就是保存了init.rc中使用service声明的action，bootanim就是一个service*/

   list_for_each(node, &service_list) {

       svc = node_to_item(node, struct service, slist);

        if(!strcmp(svc->name, name)) {

           return svc;

        }

    }

    return0;

}

         Service_start比较复杂，就不展开说明了，其实主要就是解析init.rc的配置，通过fork创建一个新进程，然后加载其elf文件运行。

         Property_set的整个过程就是如此简单，不过当初的武断差点走了歪路，不过现在已经搞清楚整个过程了。