Android: 属性服务

属性服务的开始是伴随着init.c的启动就进行的。
init.c:system/core/init/init.c
具体init.c里面与属性服务有关的代码是：

queue_builtin_action(property_init_action, "property_init");
queue_builtin_action(property_service_init_action,"property_service_init");

首先先分析第一部分:属性服务初始化
system/core/init/properties_service.c

queue_builtin_action(property_init_action, "property_init");

先看property_init函数

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

static int init_property_area(void)  
{
     prop_area *pa;
    if(pa_info_array)  //pa_info_array全局指针变量、用来标志只能初始化一次
        return -1;
//#define PA_SIZE       32768
/*全局变量 static workspace pa_workspace;
    typedef struct {
    void *data;//存储空间的起始地址
    size_t size;//存储空间的大小
    int fd;//共享内存的文件描述符
} workspace;
*/
    if(init_workspace(&pa_workspace, PA_SIZE))
        return -1;
    fcntl(pa_workspace.fd, F_SETFD, FD_CLOEXEC);
//在32768个字节的存储空间中，有PA_INFO_START 1024个字节是用来存储头部信息
    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__ = pa;
    property_area_inited = 1;
    return 0;
}

system_property_area = pa;
system_property_area这个变量是bionoc libc库中输出的一个变量。虽然属性区域是由init创建的，但是android系统希望其他进程也能访问这块内存里面的数据。为了完成这一点，它做了两个工作：
1、把属性区域创建在共享内存上。这样不同的进程就可以访问了 由上面的init_workspace(&pa_workspace, PA_SIZE)函数内部完成创建过程

static int init_workspace(workspace *w, size_t size)
{
    void *data;
    int fd;

        /* dev is a tmpfs that we can use to carve a shared workspace
         * out of, so let's do that...
         */
    fd = open("/dev/__properties__", O_RDWR | O_CREAT, 0600);
    if (fd < 0)
        return -1;
    //ftruncate()会将参数fd指定的文件大小改为参数length指定的大小。
    if (ftruncate(fd, size) < 0)
        goto out;
//mmap将一个文件或者其它对象映射进内存。
/*void* mmap(void* start,size_t length,int prot,int flags,int fd,off_t offset);int munmap(void* start,size_t length);
针对这个分析  null：映射区的开始地址，设置为0时表示由系统决定映射区的起始地址。
size:映射区的长度。//长度单位是 以字节为单位，不足一内存页按一内存页处理
PROT_READ //页内容可以被读取
PROT_WRITE //页可以被写入
MAP_SHARED //与其它所有映射这个对象的进程共享映射空间。对共享区的写入，相当于输出到文件。直到msync()或者munmap()被调用，文件实际上不会被更新。
fd:有效的文件描述词。
0:被映射对象内容的起点
返回值映射区的指针
*/
    data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if(data == MAP_FAILED)
        goto out;

    close(fd);

    fd = open("/dev/__properties__", O_RDONLY);
    if (fd < 0)
        return -1;
    //unlink()删除目录相并减少一个连接数，如果链接数为0并且没有任何进程打开该文件，该文件内容才能被真正删除，但是若又进程打开了该文件，则文件暂时不删除直到所有打开该文件的进程都结束时文件才能被删除。
    unlink("/dev/__properties__");

    w->data = data;
    w->size = size;
    w->fd = fd;
    return 0;

out:
    close(fd);
    return -1;
}

2 如何让其他进程知道这个共享内存，这里利用了gcc的constructor属性–constructor属性可以使函数在main()函数之前执行，destructor属性会让函数在main()函数完成或调用exit()之后被执行。这些属性可以用来在程序运行之前初始化所需的数据，非常有用。而且这两个属性都还可以指定优先级，在android系统中，对于这个属性指明了一个__libc_prenit函数。当bionic libc库被加载的时候，将自动调用这个函数，这个函数内部将完成共享内存到本地进程的映射工作
\bionic\libc\bionic\libc_init_dynamic.c
具体代码如下

void __attribute__((constructor))__libc_preinit(void);

void __libc_preinit(void)
{
    void**      tls_area = (void**)__get_tls();
    unsigned*   elfdata   = tls_area[TLS_SLOT_BIONIC_PREINIT];

    tls_area[TLS_SLOT_BIONIC_PREINIT] = NULL;

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

    extern void malloc_debug_init(void);
    malloc_debug_init();
}

\bionic\libc\bionic\libc_init_common.c

void __libc_init_common(uintptr_t *elfdata)
{
        ........
         __system_properties_init();//初始化客户端的属性存储区域
}

\bionic\libc\bionic\system_properties.c

int __system_properties_init(void)
{
    prop_area *pa;
    int s, fd;
    unsigned sz;
    char *env;

    if(__system_property_area__ != ((void*) &dummy_props)) {
        return 0;
    }

    env = getenv("ANDROID_PROPERTY_WORKSPACE");
    if (!env) {
        return -1;
    }
    fd = atoi(env);
    env = strchr(env, ',');
    if (!env) {
        return -1;
    }
    sz = atoi(env + 1);
    //映射init创建的那块内存到本地进程空间，这样本地进程就可以使用这块内存了，映射的时候指定了PROT_READ,客户端只能读属性，不能写。
    pa = mmap(0, sz, PROT_READ, MAP_SHARED, fd, 0);

    if(pa == MAP_FAILED) {
        return -1;
    }

    if((pa->magic != PROP_AREA_MAGIC) || (pa->version != PROP_AREA_VERSION)) {
        munmap(pa, sz);
        return -1;
    }

    __system_property_area__ = pa;
    return 0;
}

客户端进程可以直接读取属性空间，但是没有权限设置属性，设置属性只能通过属性服务器交互来设置属性
属性初始化结束 ，下面是

queue_builtin_action(property_service_init_action,"property_service_init");

属性服务器
init.c:system/core/init/init.c

static int property_service_init_action(int nargs,char **args)
{
    start_property_service();
    return 0;
}

void start_property_service(void)
{
    int fd;
//加载/system/build.prop
    load_properties_from_file(PROP_PATH_SYSTEM_BUILD);
//加载/system/default.prop
    load_properties_from_file(PROP_PATH_SYSTEM_DEFAULT);
//加载/data/local.prop  
    load_properties_from_file(PROP_PATH_LOCAL_OVERRIDE);
    /* Read persistent properties after all default values have been loaded. 加载/data/property*/
    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;
}

创建了一个套接字，用来接收请求，当接收到属性方面的请求的时候，会执行

handle_property_set_fd(property_set_fd);

具体代码是在init.c中的for(;;)循环中

//等待下面的事件发生
 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())
                    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()进行处理，具体代码如下
system/core/init/properties_service.c

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

    /* Check socket options here */
    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登录后，输入setprop ctl.start bootanim就可以查看开机动画setprop ctl.stop bootanim 就可以关闭 属性“ ctrl.start ”和“ ctrl.stop ”是用来启动和停止服务。每一项服务必须在/init.rc中定义.系统启动时，与init守护进程将解析init.rc和启动属性服务。一旦收到设置“ ctrl.start ”属性的请求，属性服务将使用该属性值作为服务名找到该服务，启动该服务。这项服务的启动结果将会放入“ init.svc.<服务名>“属性中。客户端应用程序可以轮询那个属性值，以确定结果。
        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((char*) msg.name, (char*) msg.value);
            } 
            else 
            {
                ERROR("sys_prop: permission denied uid:%d  name:%s\n",cr.uid, msg.name);
            }
        }
        break;

    default:
        break;
    }
}
//检查权限问题
static int check_perms(const char *name, unsigned int uid, unsigned int gid)
{
    int i;
    if (uid == 0)/*root用户权限最高，权限设置在system/core/include/private/Android_filesystem_config.h
    #define AID_ROOT             0  /* traditional unix */
        return 1;

    if(!strncmp(name, "ro.", 3))
        name +=3;
//非root权限就要老老实实比较了
/*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 },
    { "ril.",             AID_RADIO,    0 },
    { "gsm.",             AID_RADIO,    0 },
    { "persist.radio",    AID_RADIO,    0 },
    { "net.dns",          AID_RADIO,    0 },
    { "net.",             AID_SYSTEM,   0 },
    { "dev.",             AID_SYSTEM,   0 },
    { "runtime.",         AID_SYSTEM,   0 },
    { "hw.",              AID_SYSTEM,   0 },
    { "sys.",             AID_SYSTEM,   0 },
    { "service.",         AID_SYSTEM,   0 },
    { "wlan.",            AID_SYSTEM,   0 },
    { "dhcp.",            AID_SYSTEM,   0 },
    { "dhcp.",            AID_DHCP,     0 },
    { "vpn.",             AID_SYSTEM,   0 },
    { "vpn.",             AID_VPN,      0 },
    { "debug.",           AID_SHELL,    0 },
    { "log.",             AID_SHELL,    0 },
    { "service.adb.root", AID_SHELL,    0 },
    { "persist.sys.",     AID_SYSTEM,   0 },
    { "persist.service.", AID_SYSTEM,   0 },
    { "persist.security.", AID_SYSTEM,   0 },
    { NULL, 0, 0 }
};*/
    for (i = 0; property_perms[i].prefix; i++) {
        int tmp;
        if (strncmp(property_perms[i].prefix, name,
                    strlen(property_perms[i].prefix)) == 0) {
            if ((uid && property_perms[i].uid == uid) ||
                (gid && property_perms[i].gid == gid)) {
                return 1;
            }
        }
    }

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

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

    if(namelen >= PROP_NAME_MAX) return -1;
    if(valuelen >= PROP_VALUE_MAX) return -1;
    if(namelen < 1) return -1;
//查看属性存储空间中是否已经存在该属性
    pi = (prop_info*) __system_property_find(name);

    if(pi != 0) {//找到了
        /* ro.* properties may NEVER be modified once set ro开头的只读 不能设置*/
        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 {//没有找到要增加属性，最多支持增加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);
    }
    /* 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.
         */
         //属性名以persist开头，则需要把其对应的值写进对应的文件中去 /data/property
        write_persistent_property(name, value);
    }
    property_changed(name, value);
    return 0;
}

服务器的已经结束
但是客户端是怎么设置属性的 或者说怎么发送的套接字消息
\system\core\libcutils\Properties.c

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;

    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;

    s = socket_local_client(PROP_SERVICE_NAME,                         ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM);
    if(s < 0) return -1; 
    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;
}

本人新人，有错请指正！谢谢