一、Android4.4属性系统系列文章
Android4.4属性系统-初始化
Android4.4属性系统-系统服务
Android4.4属性系统-内存空间共享
Android4.4属性系统-属性获取
Android4.4属性系统-属性设置
Android4.4-属性的使用总结
二、写在前面-如何阅读本系列文章
本系列文章大部分是对源码的解析和注释，所以读起来枯燥无味，并且杂乱，这是阅读系统源码无法避免的，如果你有条件，可以点击下载Android4.4源码，阅读源码可以使用eclise,AndroidStudio，vim等。
文章的章节安卓是按照代码模块区分的，例如init进程代码，libcutils代码是按章节来区分，但不同模块的代码之间是有关联的，阅读时需要经常跳转，通过搜索功能进行页内搜索即可
三、属性服务解析
本章节介绍属性系统服务的详细启动过程，Android 属性系统服务实际上是由 init 进程维护的，通过创建一个 socket来监听相应的属性获取和设置的请求，最终需要由 init 进程来处理。
在Android4.4属性系统-初始化中介绍过，在init.c的main()函数中，调用了如下代码启动系统服务
//设置函数指针property_service_init_action，服务名称为"property_service_init"
queue_builtin_action(property_service_init_action, "property_service_init");
之后在for循环中执行了execute_one_command()，调用了每个ation的函数指针，property_service_init_action()也被调用，继而开始启动属性系统服务。
3.1系统服务的启动init.c
property_service_init_action开始启动属性系统服务，注释中写明在读取属性文件时会触发属性服务运行，该函数最终会调用start_property_service 运行属性服务，主要是创建一个 socket 并监听。
system/core/init/init.c
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;
}
3.2 property_service.c解析
system/core/init/property_service.c
start_property_service首先调用 load_properties_from_file 分别从 3 个文件中加载属性。PROP_PATH_SYSTEM_BUILD、PROP_PATH_SYSTEM_DEFAULT都定义在/bionic/libc/include/sys/_system_properties.h中。
void start_property_service(void)
{
int fd;
load_properties_from_file(PROP_PATH_SYSTEM_BUILD);// /system/build.prop
load_properties_from_file(PROP_PATH_SYSTEM_DEFAULT);// /system/default.prop
load_override_properties(); //加载overrides属性
/* Read persistent properties after all default values have been loaded. */
load_persistent_properties(); //加载完所有default属性后开始加载持久化属性
/*创建一个socket，create_socket定义在util.c
*参数<"property_service", scoket类型，0666 表示权限, uid, gid>
* PROP_SERVICE_NAME定义在_system_properties.h中;,对应的 socket 文件为”/dev/socket/property_service”
* uid=0,gid=0表示 root 用户和组
*/
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);
//监听创建的 socket，listen 函数定义于/bionic/libc/unistd/socketcalls.c 文件中
listen(fd, 8);
//将 property_set_fd 赋值为创建的 socket 文件描述符
property_set_fd = fd;
}
//加载可覆盖的属性，PROP_PATH_LOCAL_OVERRIDE定义在_system_properties.h
static void load_override_properties() {
#ifdef ALLOW_LOCAL_PROP_OVERRIDE
char debuggable[PROP_VALUE_MAX];
int ret;
ret = property_get("ro.debuggable", debuggable);
if (ret && (strcmp(debuggable, "1") == 0)) {
load_properties_from_file(PROP_PATH_LOCAL_OVERRIDE);// /data/local.prop
}
#endif /* ALLOW_LOCAL_PROP_OVERRIDE */
}
//从指定文件中加载属性
static void load_properties_from_file(const char *fn)
{
char *data;
unsigned sz;
//打开文件，读取内容
data = read_file(fn, &sz);
if(data != 0) {
//打开成功，加载property
load_properties(data);
//关闭文件
free(data);
}
}
//解析property数据，逐行解析
static void load_properties(char *data)
{
char *key, *value, *eol, *sol, *tmp;
sol = data; //sol指向文件开始
//char *strchr(const char *str, int c)返回在字符串 str 中第一次出现字符 c 的位置，实现逐行读取
while((eol = strchr(sol, '\n'))) { //返回换行符的指针
key = sol; //key表示行首的指针
*eol++ = 0; //相关于*eol=0; eol++; '\n'替换为0，此时eol为下一行的行首指针
sol = eol; //赋值给sol
value = strchr(key, '='); //截取一行中'='前面的字符，value指向'='
if(value == 0) continue; //如果=前面为空，跳过
*value++ = 0; //’=‘替换为0，value指向原'='后面的内容，即实际的value字节地址
while(isspace(*key)) key++; //去掉一行前面的空格
if(*key == '#') continue; //如果是'#'开头，表示注释，跳过
tmp = value - 2; //value-2为key的末尾地址
while((tmp > key) && isspace(*tmp)) *tmp-- = 0; //判断key末尾是否有空白符，如果有替换为0
while(isspace(*value)) value++; //判断value起始内容中是否有空白符，如果有替换为0
tmp = eol - 2; //判断value末尾内容中是否有空白符，如果有替换为0
while((tmp > value) && isspace(*tmp)) *tmp-- = 0;
//设置属性，关键调用
property_set(key, value);
}
}
//设置属性，参数<key,value>
int property_set(const char *name, const char *value)
{
prop_info *pi;
int ret;
size_t namelen = strlen(name); //key 长度
size_t valuelen = strlen(value); //value长度
if (!is_legal_property_name(name, namelen)) return -1; //判断prop name是否合法
if (valuelen >= PROP_VALUE_MAX) return -1; //判断value长度是否合法，PROP_VALUE_MAX=96
pi = (prop_info*) __system_property_find(name); //查询prop是否存在
if(pi != 0) { //如果系统已经存在该property
/* ro.* properties may NEVER be modified once set */
if(!strncmp(name, "ro.", 3)) return -1; //ro-read only，ro开头是不允许修改的，返回-1
__system_property_update(pi, value, valuelen); //更新property
} else { //如果系统中不存在，添加新的property
ret = __system_property_add(name, namelen, value, valuelen);
if (ret < 0) {
ERROR("Failed to set '%s'='%s'\n", name, value);
return ret;
}
}
/* If name starts with "net." treat as a DNS property. */
if (strncmp("net.", name, strlen("net.")) == 0) { //如果以net.开头
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.
*/
//'net.change'属性是一个特殊属性，用于更新任何'net.*'属性名称时的跟踪,它只能在这里更新。其值包含最后更新的'net.*'属性。
property_set("net.change", name);
} else if (persistent_properties_loaded && // persistent_properties_loaded 在执行完load_persistent_properties()后置为1
strncmp("persist.", name, strlen("persist.")) == 0) {//persist.开头的
/*
* Don't write properties to disk until after we have read all default properties
* to prevent them from being overwritten by default values.
*/
//在读取完所有的default properties之后再写入硬盘，避免它们被default 值覆盖
write_persistent_property(name, value);
} else if (strcmp("selinux.reload_policy", name) == 0 &&
strcmp("1", value) == 0) { //如果是selinux.reload_policy=1
selinux_reload_policy(); //重新加载selinux
}
property_changed(name, value); //property_changed位于init.c
return 0;
}
//判断property字符串是否合法
static bool is_legal_property_name(const char* name, size_t namelen)
{
size_t i;
bool previous_was_dot = false;
if (namelen >= PROP_NAME_MAX) return false;
if (namelen < 1) return false;
if (name[0] == '.') return false;
if (name[namelen - 1] == '.') return false;
/* Only allow alphanumeric, plus '.', '-', or '_' */
/* Don't allow ".." to appear in a property name */
for (i = 0; i < namelen; i++) {
if (name[i] == '.') {
if (previous_was_dot == true) return false;
previous_was_dot = true;
continue;
}
previous_was_dot = false;
if (name[i] == '_' || name[i] == '-') continue;
if (name[i] >= 'a' && name[i] <= 'z') continue;
if (name[i] >= 'A' && name[i] <= 'Z') continue;
if (name[i] >= '0' && name[i] <= '9') continue;
return false;
}
return true;
}
load_persistent_properties 加载持久化属性，这些属性存在于/data/property 目录下，该目录下
存放了以 persist 开头的属性文件，如系统语言、国家编码等,如下图
image.png
可以看到文件名就是属性名，文件内容就是属性的value值。
//持久化属性存储路径
#define PERSISTENT_PROPERTY_DIR "/data/property"
//加载持久化属性
static void load_persistent_properties()
{
DIR* dir = opendir(PERSISTENT_PROPERTY_DIR);
int dir_fd;
struct dirent* entry;
char value[PROP_VALUE_MAX];
int fd, length;
struct stat sb;
if (dir) {
dir_fd = dirfd(dir); //返回参数dir所指向的目录文件的文件描述符
while ((entry = readdir(dir)) != NULL) { /readdir打开目录，返回下个目录进入节点
//d_name 文件名，不是以persist.开头跳过
if (strncmp("persist.", entry->d_name, strlen("persist.")))
continue;
#if HAVE_DIRENT_D_TYPE
if (entry->d_type != DT_REG) //判断文件类型，DT_REG常规文件
continue;
#endif
/* open the file and read the property value */
//打开文件
fd = openat(dir_fd, entry->d_name, O_RDONLY | O_NOFOLLOW);
if (fd < 0) {
ERROR("Unable to open persistent property file \"%s\" errno: %d\n",
entry->d_name, errno);
continue;
}
if (fstat(fd, &sb) < 0) { //获取文件状态，写入到sb中
ERROR("fstat on property file \"%s\" failed errno: %d\n", entry->d_name, errno);
close(fd);
continue;
}
// File must not be accessible to others, be owned by root/root, and
// not be a hard link to any other file.
/*文件不允许root/root用户/组之外的用户有访问权限，也不允许硬链接
*st_mode 表示文件权限和文件类型信息
* 如果存在以下几种情况是不允许读取的
*/
if (((sb.st_mode & (S_IRWXG | S_IRWXO)) != 0) //如果属组或者其它用户有读写权限
|| (sb.st_uid != 0) //uid!=0,不是root用户
|| (sb.st_gid != 0) //不是root组
|| (sb.st_nlink != 1)) { //该文件上硬连接的个数不是1(应该只有root一个)
ERROR("skipping insecure property file %s (uid=%lu gid=%lu nlink=%d mode=%o)\n",
entry->d_name, sb.st_uid, sb.st_gid, sb.st_nlink, sb.st_mode);
close(fd);
continue;
}
length = read(fd, value, sizeof(value) - 1); //从文件中读取value值
if (length >= 0) {
value[length] = 0;
property_set(entry->d_name, value); //设置property,文件名即为属性名
} else {
ERROR("Unable to read persistent property file %s errno: %d\n",
entry->d_name, errno);
}
close(fd);
}
closedir(dir);
} else {
ERROR("Unable to open persistent property directory %s errno: %d\n", PERSISTENT_PROPERTY_DIR, errno);
}
//设置标志位为1
persistent_properties_loaded = 1;
}
system/core/init/util.c
/*
* create_socket - creates a Unix domain socket in ANDROID_SOCKET_DIR
* ("/dev/socket") as dictated in init.rc. This socket is inherited by the
* daemon. We communicate the file descriptor's value via the environment
* variable ANDROID_SOCKET_ENV_PREFIX<name> ("ANDROID_SOCKET_foo").
*/
//参数<套接字名称, socket类型，权限，用户，组>
//调用时传入参数<"property_service", SOCK_STREAM(流套接字) , 0666, 0, 0>
int create_socket(const char *name, int type, mode_t perm, uid_t uid, gid_t gid)
{
struct sockaddr_un addr;
int fd, ret;
char *secon;
//创建socket，PF_UNIX表示进程间通信，0表示自动选取使用TCP还是UDP
fd = socket(PF_UNIX, type, 0);
if (fd < 0) {
ERROR("Failed to open socket '%s': %s\n", name, strerror(errno));
return -1;
}
memset(&addr, 0 , sizeof(addr)); //初始化socket地址为0
addr.sun_family = AF_UNIX; //AF_UNIX用于同一台机器上的进程间通信，AF_INET为ipv4
snprintf(addr.sun_path, sizeof(addr.sun_path), ANDROID_SOCKET_DIR"/%s",
name);
ret = unlink(addr.sun_path);
if (ret != 0 && errno != ENOENT) {
ERROR("Failed to unlink old socket '%s': %s\n", name, strerror(errno));
goto out_close;
}
secon = NULL;
if (sehandle) {
ret = selabel_lookup(sehandle, &secon, addr.sun_path, S_IFSOCK);
if (ret == 0)
setfscreatecon(secon);
}
//对套接字进行地址和端口的绑定，才能进行数据的接收和发送操作
//位于socketcalls.c文件中
ret = bind(fd, (struct sockaddr *) &addr, sizeof (addr));
if (ret) {
ERROR("Failed to bind socket '%s': %s\n", name, strerror(errno));
goto out_unlink;
}
setfscreatecon(NULL);
freecon(secon);
chown(addr.sun_path, uid, gid); //修改用户属性
chmod(addr.sun_path, perm); //修改权限
INFO("Created socket '%s' with mode '%o', user '%d', group '%d'\n",
addr.sun_path, perm, uid, gid);
return fd;
out_unlink:
unlink(addr.sun_path);
out_close:
close(fd);
return -1;
}
3.3 bionic/libc 库
bionic/libc/include/sys/_system_properties.h
#define PROP_AREA_MAGIC 0x504f5250
#define PROP_AREA_VERSION 0xfc6ed0ab
#define PROP_AREA_VERSION_COMPAT 0x45434f76
#define PROP_PATH_RAMDISK_DEFAULT "/default.prop"
#define PROP_PATH_SYSTEM_BUILD "/system/build.prop"
#define PROP_PATH_SYSTEM_DEFAULT "/system/default.prop"
#define PROP_PATH_LOCAL_OVERRIDE "/data/local.prop"
#define PROP_PATH_FACTORY "/factory/factory.prop"
//定义映射内存空间的大小128K
#define PA_SIZE (128 * 1024)
//prop service的名称
#define PROP_SERVICE_NAME "property_service"
//prop内存映射文件
#define PROP_FILENAME "/dev/__properties__"
socketcalls.c在项目源码中没有找到，应该是被展讯做修改后，当作预置库放到源码中了。
下面是从AOSP下载的Android4.4源码
bionic/libc/unistd/socketcalls.c
//定义了SOCKET行为结构体
enum
{
SYS_SOCKET = 1,
SYS_BIND,
SYS_CONNECT,
SYS_LISTEN,
SYS_ACCEPT,
SYS_GETSOCKNAME,
SYS_GETPEERNAME,
SYS_SOCKETPAIR,
SYS_SEND,
SYS_RECV,
SYS_SENDTO,
SYS_RECVFROM,
SYS_SHUTDOWN,
SYS_SETSOCKOPT,
SYS_GETSOCKOPT,
SYS_SENDMSG,
SYS_RECVMSG
};
//socket生成函数，参数<地址域(faminly), socket类型，协议>
int socket(int domain, int type, int protocol)
{
unsigned long t[3];
t[0] = (unsigned long) domain;
t[1] = (unsigned long) type;
t[2] = (unsigned long) protocol;
return (int) __socketcall( SYS_SOCKET, t );
}
//绑定地址和端口，参数<socket, 地址和商品，地址长度>
int bind(int sockfd, const struct sockaddr *my_addr, socklen_t addrlen)
{
unsigned long t[3];
t[0] = (unsigned long) sockfd;
t[1] = (unsigned long) my_addr;
t[2] = (unsigned long) addrlen;
return (int) __socketcall( SYS_BIND, t );
}
//监听端口,参数<scoket句柄，backlog 为请求队列的最大长度>
// listen() 函数让套接字进入被动监听状态，再调用 accept() 函数，就可以随时响应客户端的请求
int listen(int s, int backlog)
{
unsigned long t[2];
t[0] = (unsigned long) s;
t[1] = (unsigned long) backlog;
return (int) __socketcall( SYS_LISTEN, t );
}
可以看到上面这几个函数调用的都是__socketcall()，而这个函数是在哪里定义的就找不到喽~有知道的大神还请指点一二, 先谢过了!
四、补充知识点
4.1 fstat函数
文中使用到的sb.st_mode解释如下：
st_mode域是需要一些宏予以配合才能使用的。其实，通俗说，这些宏就是一些特定位置为1的二进制数的外号，我们使用它们和st_mode进行”&”操作，从而就可以得到某些特定的信息。
用于解释st_mode标志的掩码包括：
S_IFMT：文件类型
S_IRWXU：属主的读/写/执行权限，可以分成S_IXUSR, S_IRUSR, S_IWUSR
S_IRWXG：属组的读/写/执行权限，可以分成S_IXGRP, S_IRGRP, S_IWGRP
S_IRWXO：其他用户的读/写/执行权限，可以分为S_IXOTH, S_IROTH, S_IWOTH
4.2 socket函数
socket函数
int socket(int af, int type, int protocol);
af 为地址族(Address Family)，也就是 IP 地址类型，比较常用的为AF_INET或AF_UNIX。AF_UNIX用于同一台机器上的进程间通信，AF_INET对于IPV4协议的TCP和UDP ,AF_INET6对应于IPV6。
AF_INET和PF_INET的值是相同的
五、总结，放一张图
property服务.png
