深入理解Android(04)——深入理解属性服务

1、属性服务

        在windows中，有一个名为注册表一样的东西，注册表可以存储类似key/value这样的键值对。

        一般来说，系统或者某些应用程序会把自己的一些属性存储在注册表中，即使系统重启或者应用程序重启，它还是能够根据之前在注册表中设置的属性，进行相应的初始化操作。Android平台也提供了一个类似的机制，称之为属性服务（property service）。

2、属性服务初始化

2.1 代码信息

        笔者的代码位于该位置：system/core/init/property_service.c

init.c中的代码信息：

static int property_init_action(int nargs, char **args)
{
    INFO("property init\n");
    property_init();
    return 0;
}

2.1 创建存储空间

先看property_service.c

void property_init(void)
{
	// 初始化属性存储区域
    init_property_area();
	//加载default.prop文件
    load_properties_from_file(PROP_PATH_RAMDISK_DEFAULT);
}

详细代码信息：

static int init_property_area(void)
{
    prop_area *pa;


    if(pa_info_array)
        return -1;


	/*init_workspace函数调用Android系统提供的ashmem_create_region函数创建一块共享内存。*/
    if(init_workspace(&pa_workspace, PA_SIZE))
        return -1;


    fcntl(pa_workspace.fd, F_SETFD, FD_CLOEXEC);


    pa_info_array = (void*) (((char*) pa_workspace.data) + PA_INFO_START);


    pa = pa_workspace.data;
    memset(pa, 0, PA_SIZE);
    pa->magic = PROP_AREA_MAGIC;
    pa->version = PROP_AREA_VERSION;


        /* plug into the lib property services */
	/* __system_property_area__这个变量有bionic libc库输出 */
    __system_property_area__ = pa;
    property_area_inited = 1;
    return 0;
}

主要完成了两个功能：

1）把属性区域创建在共享内存上，共享内存是可以跨进程的。

2）Android利用了gcc的constructor属性，这个属性指明了一个_libc_prenit函数。

2.2 客户端获取存储空间

代码信息位于：bionic/libc/bionic/libc_init_dynamic.c

// constructor属性指示加载器加载该库后，首先调用__libc_preinit函数。
// 这一点和windows上动态库的DllMain函数类似
void __attribute__((constructor)) __libc_preinit(void);

void __libc_preinit(void)
{
    ......

	// 调用这个函数
    __libc_init_common(elfdata);

    ......
}

void __libc_init_common(uintptr_t *elfdata)
{
    ......


	//  初始化客户端的属性存储区域
    /* setup system properties - requires environment */
    __system_properties_init();
}

3、属性服务器

3.1 启动属性服务器

       init进程会启动一个属性服务器，而客户端只能通过与属性服务器交互来设置属性。先看属性服务器的内容，它有start_property_service

源代码名称：property_service.c

void start_property_service(void)
{
    int fd;


	// 加载属性文件，其实就是解析这些文件中的属性，然后把它设置到属性空间中去
    load_properties_from_file(PROP_PATH_SYSTEM_BUILD);
    load_properties_from_file(PROP_PATH_SYSTEM_DEFAULT);
    load_properties_from_file(PROP_PATH_LOCAL_OVERRIDE);
    /* 有一些属性书需要保存到永久介质上的，这些属性文件则由下面这个函数加载 */
    load_persistent_properties();


	/*创建一个socket，用于IPC通信*/
    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;
}

属性服务中创建了一个用来接收请求的socket，这个请求是在init中的for循环中进行处理的。

3.2 处理设置属性请求

接收请求的地方在init进程中，代码如下所示：

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();
            }
        }

当属性服务器接收到客户端请求时，init会调用handle_property_set_fd进行处理。

函数代码如下：

void handle_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);


	// 先接收TCP连接
    if ((s = accept(property_set_fd, (struct sockaddr *) &addr, &addr_size)) < 0) {
        return;
    }


    /* 取出客户端进程的权限等属性 */
    if (getsockopt(s, SOL_SOCKET, SO_PEERCRED, &cr, &cr_size) < 0) {
        close(s);
        ERROR("Unable to recieve socket options\n");
        return;
    }


	/* 接收请求数据 */
    r = recv(s, &msg, sizeof(msg), 0);
    close(s);
    if(r != sizeof(prop_msg)) {
        ERROR("sys_prop: mis-match msg size recieved: %d expected: %d\n",
              r, sizeof(prop_msg));
        return;
    }


    switch(msg.cmd) {
    case PROP_MSG_SETPROP:
        msg.name[PROP_NAME_MAX-1] = 0;
        msg.value[PROP_VALUE_MAX-1] = 0;
		
		/* 如果时ctl开头的消息，则认为时控制消息，控制消息用来执行一些命令，例如用adb shell登录之后，输入一些命令就可以馋看开机动画了。 */
        if(memcmp(msg.name,"ctl.",4) == 0) {
            if (check_control_perms(msg.value, cr.uid, cr.gid)) {
                handle_control_message((char*) msg.name + 4, (char*) msg.value);
            } else {
                ERROR("sys_prop: Unable to %s service ctl [%s] uid: %d pid:%d\n",
                        msg.name + 4, msg.value, cr.uid, cr.pid);
            }
        } else {
		/* 检查客户端进程是否由足够的权限 */
            if (check_perms(msg.name, cr.uid, cr.gid)) {
				/* 然后调用property_set设置 */
                property_set((char*) msg.name, (char*) msg.value);
            } else {
                ERROR("sys_prop: permission denied uid:%d  name:%s\n",
                      cr.uid, msg.name);
            }
        }
        break;


    default:
        break;
    }
}

当客户端的权限满足要求的时候，init就要调用property_set进行相关设置：

int property_set(const char *name, const char *value)
{
    prop_area *pa;
    prop_info *pi;


    int namelen = strlen(name);
    int valuelen = strlen(value);


    ......
	// 从属性存储空间中寻找是否已经存在该属性。
    pi = (prop_info*) __system_property_find(name);


    if(pi != 0) {
	    /* ro.* 属性表示一次设置，从此不可改，只能读，直接返回 */
        /* ro.* properties may NEVER be modified once set */
        if(!strncmp(name, "ro.", 3)) return -1;


        pa = __system_property_area__;
		/* 更新该属性的值 */
        update_prop_info(pi, value, valuelen);
        pa->serial++;
        __futex_wake(&pa->serial, INT32_MAX);
    } else {
		/* 如果没有找到相应的属性，则认为时增加属性，所以需要新创建一项。
		Android最多支持247项属性，如果目前属性空间已经存在247项，则直接返回
		 */
        pa = __system_property_area__;
        if(pa->count == PA_COUNT_MAX) return -1;


        pi = pa_info_array + pa->count;
        pi->serial = (valuelen << 24);
        memcpy(pi->name, name, namelen + 1);
        memcpy(pi->value, value, valuelen + 1);


        pa->toc[pa->count] =
            (namelen << 24) | (((unsigned) pi) - ((unsigned) pa));


        pa->count++;
        pa->serial++;
        __futex_wake(&pa->serial, INT32_MAX);
    }
	// 有一些特殊的属性需要特殊处理，这里主要net开头的属性
    /* If name starts with "net." treat as a DNS property. */
    if (strncmp("net.", name, strlen("net.")) == 0)  {
        if (strcmp("net.change", name) == 0) {
            return 0;
        }
       /*
        * The 'net.change' property is a special property used track when any
        * 'net.*' property name is updated. It is _ONLY_ updated here. Its value
        * contains the last updated 'net.*' property.
        */
        property_set("net.change", name);
    } else if (persistent_properties_loaded &&
            strncmp("persist.", name, strlen("persist.")) == 0) {
        /*
         * Don't write properties to disk until after we have read all default properties
         * to prevent them from being overwritten by default values.
         */
		// 如果属性名以persistent开头，则需要把这些值写到相应的文件中去
        write_persistent_property(name, value);
    }
    property_changed(name, value);
    return 0;
}

3.3 客户端发送请求

客户端通过property_set发送请求，property_set由libcutils库提供，代码如下：

int property_set(const char *key, const char *value)
{
    prop_msg msg;
    unsigned resp;


    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;
    
	// 设置消息码为PROP_MSG_SETPROP
    msg.cmd = PROP_MSG_SETPROP;
    strcpy((char*) msg.name, key);
    strcpy((char*) msg.value, value);


	// 发送请求
    return send_prop_msg(&msg);
}


static int send_prop_msg(prop_msg *msg)
{
    int s;
    int r;
    
	// 建立和属性服务器的socket连接
    s = socket_local_client(PROP_SERVICE_NAME, 
                            ANDROID_SOCKET_NAMESPACE_RESERVED,
                            SOCK_STREAM);
    if(s < 0) return -1;
    
	// 通过socket发送出去
    while((r = send(s, msg, sizeof(prop_msg), 0)) < 0) {
        if((errno == EINTR) || (errno == EAGAIN)) continue;
        break;
    }


    if(r == sizeof(prop_msg)) {
        r = 0;
    } else {
        r = -1;
    }


    close(s);
    return r;
}