這篇文章主要介紹了Android中init進程實現的C語言源碼,init屬性服務在安卓中屬于系統的底層Linux服務,需要的朋友可以參考下

概述

init是一個進程，確切的說，它是Linux系統中用戶空間的第一個進程。由于Android是基于Linux內核的，所以init也是Android系統中用戶空間的第一個進程。init的進程號是1。作為天字第一號進程，init有很多重要的工作：

init提供property service(屬性服務)來管理Android系統的屬性。

init負責創建系統中的關鍵進程，包括zygote。

以往的文章一上來就介紹init的源碼，但是我這里先從這兩個主要工作開始。搞清楚這兩個主要工作是如何實現的，我們再回頭來看init的源碼。

這篇文章主要是介紹init進程的屬性服務。

跟init屬性服務相關的源碼目錄如下：

1. system/core/init/ 
2. bionic/libc/bionic/ 
3. system/core/libcutils/ 

屬性服務

在windows平臺上有一個叫做注冊表的東西，它可以存儲一些類似key/value的鍵值對。一般而言，系統或者某些應用程序會把自己的一些屬性存儲在注冊表中，即使系統重啟或應用程序重啟，它還能根據之前在注冊表中設置的屬性值，進行相應的初始化工作。

Android系統也提供了類似的機制，稱之為屬性服務(property service)。應用程序可以通過這個服務查詢或者設置屬性。我們可以通過如下命令，獲取手機中屬性鍵值對。

1. adb shell getprop 

例如紅米Note手機的屬性值如下：

1. [ro.product.device]: [lcsh92_wet_jb9] 
2. [ro.product.locale.language]: [zh] 
3. [ro.product.locale.region]: [CN] 
4. [ro.product.manufacturer]: [Xiaomi] 

在system/core/init/init.c文件的main函數中，跟屬性服務的相關代碼如下：

1. property_init(); 
2. queue_builtin_action(property_service_init_action, "property_service_init"); 

接下來，我們分別看一下這兩處代碼的具體實現。

屬性服務初始化 創建存儲空間

首先，我們先來看一下property_init函數的源碼(/system/core/init/property_service.c)：

1. void property_init(void) 
2. { 
3. init_property_area(); 
4. } 

property_init函數中只是簡單的調用了init_property_area方法，接下來我們看一下這個方法的具體實現：

1. static int property_area_inited = 0; 
2. static workspace pa_workspace; 
3. static int init_property_area(void) 
4. { 
5. // 屬性空間是否已經初始化 
6. if (property_area_inited) 
7. return -1; 
8.  
9. if (__system_property_area_init()) 
10. return -1; 
11.  
12. if (init_workspace(&pa_workspace, 0)) 
13. return -1; 
14.  
15. fcntl(pa_workspace.fd, F_SETFD, FD_CLOEXEC); 
16.  
17. property_area_inited = 1; 
18. return 0; 
19. } 

從init_property_area函數，我們可以看出，函數首先判斷屬性內存區域是否已經初始化過，如果已經初始化，則返回-1。如果沒有初始化，我們接下來會發現有兩個關鍵函數__system_property_area_init和init_workspace應該是跟內存區域初始化相關。那我們分別分析一下這兩個函數具體實現。

1. __system_property_area_init 
2.  
3. __system_property_area_init函數位于/bionic/libc/bionic/system_properties.c文件中，具體代碼實現如下： 
4.  
5. struct prop_area { 
6. unsigned bytes_used; 
7. unsigned volatile serial; 
8. unsigned magic; 
9. unsigned version; 
10. unsigned reserved[28]; 
11. char data[0]; 
12. }; 
13. typedef struct prop_area prop_area; 
14. prop_area *__system_property_area__ = NULL; 
15.  
16. #define PROP_FILENAME "/dev/__properties__" 
17. static char property_filename[PATH_MAX] = PROP_FILENAME;  
18.  
19. #define PA_SIZE (128 * 1024) 
20.  
21.  
22. static int map_prop_area_rw() 
23. { 
24. prop_area *pa; 
25. int fd; 
26. int ret; 
27.  
28. /** 
29. * O_RDWR ==> 讀寫 
30. * O_CREAT ==> 若不存在，則創建 
31. * O_NOFOLLOW ==> 如果filename是軟鏈接，則打開失敗 
32. * O_EXCL ==> 如果使用O_CREAT是文件存在，則可返回錯誤信息 
33. */ 
34. fd = open(property_filename, O_RDWR | O_CREAT | O_NOFOLLOW | O_CLOEXEC | O_EXCL, 0444); 
35. if (fd < 0) { 
36. if (errno == EACCES) { 
37. abort(); 
38. } 
39. return -1; 
40. } 
41.  
42. ret = fcntl(fd, F_SETFD, FD_CLOEXEC); 
43. if (ret < 0) 
44. goto out; 
45.  
46. if (ftruncate(fd, PA_SIZE) < 0) 
47. goto out; 
48.  
49. pa_size = PA_SIZE; 
50. pa_data_size = pa_size - sizeof(prop_area); 
51. compat_mode = false; 
52.  
53. // mmap映射文件實現共享內存 
54. pa = mmap(NULL, pa_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); 
55. if (pa == MAP_FAILED) 
56. goto out; 
57.  
58. /*初始化內存地址中所有值為0*/ 
59. memset(pa, 0, pa_size); 
60. pa->magic = PROP_AREA_MAGIC; 
61. pa->version = PROP_AREA_VERSION; 
62. pa->bytes_used = sizeof(prop_bt); 
63.  
64. __system_property_area__ = pa; 
65.  
66. close(fd); 
67. return 0; 
68.  
69. out: 
70. close(fd); 
71. return -1; 
72. } 
73.  
74. int __system_property_area_init() 
75. { 
76. return map_prop_area_rw(); 
77. } 

代碼比較好理解，主要內容是利用mmap映射property_filename創建了一個共享內存區域，并將共享內存的首地址賦值給全局變量__system_property_area__。

關于mmap映射文件實現共享內存IPC通信機制，可以參考這篇文章：mmap實現IPC通信機制

init_workspace

接下來，我們來看一下init_workspace函數的源碼(/system/core/init/property_service.c)：

1. typedef struct { 
2. void *data; 
3. size_t size; 
4. int fd; 
5. }workspace; 
6.  
7. static int init_workspace(workspace *w, size_t size) 
8. { 
9. void *data; 
10. int fd = open(PROP_FILENAME, O_RDONLY | O_NOFOLLOW); 
11. if (fd < 0) 
12. return -1; 
13.  
14. w->size = size; 
15. w->fd = fd; 
16. return 0; 
17. } 

客戶端進程訪問屬性內存區域

雖然屬性內存區域是init進程創建的，但是Android系統希望其他進程也能夠讀取這塊內存區域里的內容。為了做到這一點，init進程在屬性區域初始化過程中做了如下兩項工作：

把屬性內存區域創建在共享內存上，而共享內存是可以跨進程的。這一點，在上述代碼中是通過mmap映射/dev/__properties__文件實現的。pa_workspace變量中的fd成員也保存了映射文件的句柄。

如何讓其他進程知道這個共享內存句柄呢?Android先將文件映射句柄賦值給__system_property_area__變量，這個變量屬于bionic_lic庫中的輸出的一個變量，然后利用了gcc的constructor屬性，這個屬性指明了一個__lib_prenit函數，當bionic_lic庫被加載時，將自動調用__libc_prenit，這個函數內部完成共享內存到本地進程的映射工作。

只講原理是不行的，我們直接來看一下__lib_prenit函數代碼的相關實現：

1. void __attribute__((constructor)) __libc_prenit(void); 
2. void __libc_prenit(void) 
3. { 
4. // ... 
5. __libc_init_common(elfdata); // 調用這個函數 
6. // ... 
7. } 
8.  
9.  
10. __libc_init_common函數為： 
11.  
12. void __libc_init_common(uintptr_t *elfdata) 
13. { 
14. // ... 
15. __system_properties_init(); // 初始化客戶端的屬性存儲區域 
16. } 
17.  
18.  
19. __system_properties_init函數有回到了我們熟悉的/bionic/libc/bionic/system_properties.c文件： 
20.  
21. static int get_fd_from_env(void) 
22. { 
23. char *env = getenv("ANDROID_PROPERTY_WORKSPACE"); 
24.  
25. if (! env) { 
26. return -1; 
27. } 
28.  
29. return atoi(env); 
30. } 
31.  
32. static int map_prop_area() 
33. { 
34. bool formFile = true; 
35. int result = -1; 
36. int fd; 
37. int ret; 
38.  
39. fd = open(property_filename, O_RDONLY | O_NOFOLLOW | O_CLOEXEC); 
40. if (fd >= 0) { 
41. /* For old kernels that don't support O_CLOEXEC */ 
42. ret = fcntl(fd, F_SETFD, FD_CLOEXEC); 
43. if (ret < 0) 
44. goto cleanup; 
45. } 
46.  
47. if ((fd < 0) && (error == ENOENT)) { 
48. fd = get_fd_from_env(); 
49. fromFile = false; 
50. } 
51.  
52. if (fd < 0) { 
53. return -1; 
54. } 
55.  
56. struct stat fd_stat; 
57. if (fstat(fd, &fd_stat) < 0) { 
58. goto cleanup; 
59. } 
60.  
61. if ((fd_stat.st_uid != 0) 
62. || (fd_stat.st_gid != 0) 
63. || (fd_stat.st_mode & (S_IWGRP | S_IWOTH) != 0) 
64. || (fd_stat.st_size < sizeof(prop_area))) { 
65. goto cleanup; 
66. } 
67.  
68. pa_size = fd_stat.st_size; 
69. pa_data_size = pa_size - sizeof(prop_area); 
70.  
71. /*  
72. * 映射init創建的屬性內存到本地進程空間，這樣本地進程就可以使用這塊共享內存了。 
73. * 注意：映射時制定了PROT_READ屬性，所以客戶端進程只能讀屬性，不能設置屬性。 
74. */ 
75. prop_area *pa = mmap(NULL, pa_size, PROT_READ, MAP_SHARED, fd, 0); 
76.  
77. if (pa == MAP_FAILED) { 
78. goto cleanup; 
79. } 
80.  
81. if ((pa->magic != PROP_AREA_MAGIC) || (pa->version != PROP_AREA_VERSION && pa->version != PROP_AREA_VERSION_COMPAT)) { 
82. munmap(pa, pa_size); 
83. goto cleanup; 
84. } 
85.  
86. if (pa->version == PROP_AREA_VERSION_COMPAT) { 
87. compat_mode = true; 
88. } 
89.  
90. result = 0; 
91.  
92. __system_property_area__ = pa; 
93. cleanup: 
94. if (fromFile) { 
95. close(fd); 
96. } 
97.  
98. return result; 
99. } 
100.  
101. int __system_properties_init() 
102. { 
103. return map_prop_area(); 
104. } 

通過對源碼的閱讀，可以發現，客戶端通過mmap映射，可以讀取屬性內存的內容，但是沒有權限設置屬性。那客戶端是如何設置屬性的呢?這就涉及到下面要將的屬性服務器了。

屬性服務器的分析

init進程會啟動一個屬性服務器，而客戶端只能通過與屬性服務器的交互來設置屬性。

啟動屬性服務器

先來看一下屬性服務器的內容，它由property_service_init_action函數啟動，源碼如下(/system/core/init/init.c&&property_service.c)：

1. static int property_service_init_action(int nargs, char **args) 
2. { 
3. start_property_service(); 
4. return 0; 
5. } 
6.  
7. static void load_override_properties() 
8. { 
9. #ifdef ALLOW_LOCAL_PROP_OVERRIDE 
10. char debuggable[PROP_VALUE_MAX]; 
11. int ret; 
12.  
13. ret = property_get("ro.debuggable", debuggable); 
14. if (ret && (strcmp(debuggable, "1") == 0)) { 
15. load_properties_from_file(PROP_PATH_LOCAL_OVERRIDE); 
16. } 
17. #endif 
18. } 
19.  
20. static void load_properties(char *data) 
21. { 
22. char *key, *value, *eol, *sol, *tmp; 
23.  
24. sol = data; 
25. while ((eol = strchr(sol, '/n'))) { 
26. key = sol; 
27. // 賦值下一行的指針給sol 
28. *eol ++ = 0; 
29. sol = eol; 
30.  
31. value = strchr(key, '='); 
32. if (value == 0) continue; 
33. *value++ = 0; 
34.  
35. while (isspace(*key)) key ++; 
36. if (*key == '#') continue; 
37. tmp = value - 2; 
38. while ((tmp > key) && isspace(*tmp)) *tmp-- = 0; 
39.  
40. while (isspace(*value)) value ++; 
41. tmp = eol - 2; 
42. while ((tmp > value) && isspace(*tmp)) *tmp-- = 0; 
43.  
44. property_set(key, value); 
45. } 
46. } 
47.  
48. int create_socket(const char *name, int type, mode_t perm, uid_t uid, gid_t gid) 
49. { 
50. struct sockaddr_un addr; 
51. int fd, ret; 
52. char *secon; 
53.  
54. fd = socket(PF_UNIX, type, 0); 
55. if (fd < 0) { 
56. ERROR("Failed to open socket '%s': %s/n", name, strerror(errno)); 
57. return -1; 
58. } 
59.  
60. memset(&addr, 0, sizeof(addr)); 
61. addr.sun_family = AF_UNIX; 
62. snprintf(addr.sun_path, sizeof(addr.sun_path), ANDROID_SOCKET_DIR"/%s", name); 
63.  
64. ret = unlink(addr.sun_path); 
65. if (ret != 0 && errno != ENOENT) { 
66. goto out_close; 
67. } 
68.  
69. ret = bind(fd, (struct sockaddr *)&addr, sizeof(addr)); 
70. if (ret) { 
71. goto out_unlink; 
72. } 
73. chown(addr.sun_path, uid, gid); 
74. chmod(addr.sun_path, perm); 
75.  
76. return fd; 
77.  
78. out_unlink: 
79. unlink(addr.sun_path); 
80. out_close: 
81. close(fd); 
82. return -1; 
83. } 
84.  
85. #define PROP_PATH_SYSTEM_BUILD "/system/build.prop" 
86. #define PROP_PATH_SYSTEM_DEFAULT "/system/default.prop" 
87. #define PROP_PATH_LOCAL_OVERRIDE "/data/local.prop" 
88. #define PROP_PATH_FACTORY "/factory/factory.prop" 
89.  
90. void start_property_service(void) 
91. { 
92. int fd; 
93.  
94. load_properties_from_file(PROP_PATH_SYSTEM_BUILD); 
95. load_properties_from_file(PROP_PATH_SYSTEM_DEFAULT); 
96. load_override_properties(); 
97. /*Read persistent properties after all default values have been loaded.*/ 
98. load_persistent_properties(); 
99.  
100. fd = create_socket(PROP_SERVICE_NAME, SOCK_STREAM, 0666, 0, 0); 
101. if (fd < 0) return; 
102. fcntl(fd, F_SETFD, FD_CLOEXEC); 
103. fcntl(fd, F_SETFL, O_NONBLOCK); 
104.  
105. listen(fd, 8); 
106. property_set_fd = fd; 
107. } 

從上述代碼可以看到，init進程除了會預寫入指定文件(例如：system/build.prop)屬性外，還會創建一個UNIX Domain Socket，用于接受客戶端的請求，構建屬性。那這個socket請求是再哪里被處理的呢?

答案是：在init中的for循環處已經進行了相關處理。

服務端處理設置屬性請求

接收屬性設置請求的地方是在init進程中，相關代碼如下所示：

1. int main(int argc, char **argv) 
2. { 
3. // ...省略不相關代碼 
4.  
5. for (;;) { 
6. // ... 
7. for (i = 0; i < fd_count; i ++) { 
8. if (ufds[i].fd == get_property_set_fd()) 
9. handle_property_set_fd(); 
10. } 
11. } 
12. } 

從上述代碼可以看出，當屬性服務器收到客戶端請求時，init進程會調用handle_property_set_fd函數進行處理，函數位置是：system/core/init/property_service.c，我們來看一下這個函數的實現源碼：

1. void handle_property_set_fd() 
2. { 
3. prop_msg msg; 
4. int s; 
5. int r; 
6. int res; 
7. struct ucred cr; 
8. struct sockaddr_un addr; 
9. socklen_t addr_size = sizeof(addr); 
10. socklen_t cr_size = sizeof(cr); 
11. char *source_ctx = NULL; 
12.  
13. // 接收TCP連接 
14. if ((s = accept(property_set_fd, (struct sockaddr *) &addr, &addr_size)) < 0) { 
15. return; 
16. } 
17.  
18. // 接收客戶端請求數據 
19. r = TEMP_FAILURE_RETRY(recv(s, &msg, sizeof(msg), 0)); 
20. if (r != sizeof(prop_msg)) { 
21. ERROR("sys_prop: mis-match msg size received: %d expected : %d errno: %d/n", r, sizeof(prop_msg), errno); 
22. close(s); 
23. return; 
24. } 
25.  
26. switch(msg.cmd) { 
27. case PROP_MSG_SETPROP: 
28. msg.name[PROP_NAME_MAX - 1] = 0; 
29. msg.value[PROP_VALUE_MAX - 1] = 0; 
30.  
31. if (memcmp(msg.name, "ctl.", 4) == 0) { 
32. close(s); 
33. if (check_control_perms(msg.value, cr.uid, cr.gid, source_ctx)) { 
34. handle_control_message((char*) msg.name + 4, (char*) msg.value); 
35. } else { 
36. 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); 
37. } 
38. } else { 
39. if (check_perms(msg.name, cr.uid, cr.gid, source_ctx)) { 
40. property_set((char *) msg.name, (char*) msg.value); 
41. } 
42. close(s); 
43. } 
44. break; 
45. default: 
46. close(s); 
47. break; 
48. } 
49. } 

當客戶端的權限滿足要求時，init就調用property_set進行相關處理。property_set源碼實現如下：

1. int property_set(const char *name, const char *value) 
2. { 
3. prop_info *pi; 
4. int ret; 
5.  
6. size_t namelen = strlen(name); 
7. size_t valuelen = strlen(value); 
8.  
9. if (! is_legal_property_name(name, namelen)) return -1; 
10. if (valuelen >= PROP_VALUE_MAX) return -1; 
11.  
12. // 從屬性空間中尋找是否已經存在該屬性值 
13. pi = (prop_info*) __system_property_find(name); 
14. if (pi != 0) { 
15. // ro開頭的屬性被設置后，不允許再被修改 
16. if (! strncmp(name, "ro.", 3)) return -1; 
17.  
18. __system_property_update(pi, value, valuelen); 
19. } else { 
20. ret = __system_property_add(name, namelen, value, valuelen); 
21. } 
22.  
23. // 有一些特殊的屬性需要特殊處理，例如net.和persist.開頭的屬性 
24. if (strncmp("net.", name, strlen("net.")) == 0) { 
25. if (strcmp("net.change", name) == 0) { 
26. return 0; 
27. } 
28. property_set("net.change", name); 
29. } else if (persistent_properties_loaded && strncmp("persist.", name, strlen("persist.")) == 0) { 
30. write_persistent_property(name, value); 
31. } 
32. property_changed(name, value); 
33. return 0; 
34. } 

屬性服務器端的工作基本到這里就完成了。最后，我們來看一下客戶端是如何發送設置屬性的socket請求。

客戶端發送請求

客戶端設置屬性時是調用了property_set(“sys.istest”, “true”)方法。從上述分析可知，該方法實現跟服務器端的property_set方法不同，該方法一定是發送了socket請求，該方法源碼位置為：/system/core/libcutils/properties.c：

1. int property_set(const char *key, const char *value) 
2. { 
3. return __system_property_set(key, value); 
4. } 

可以看到，property_set調用了__system_property_set方法，這個方法位于：/bionic/libc/bionic/system_properties.c文件中：

1. struct prop_msg 
2. { 
3. unsigned cmd; 
4. char name[PROP_NAME_MAX]; 
5. char value[PROP_VALUE_MAX]; 
6. }; 
7. typedef struct prop_msg prop_msg; 
8.  
9. static int send_prop_msg(prop_msg *msg) 
10. { 
11. struct pollfd pollfds[1]; 
12. struct sockaddr_un addr; 
13. socklen_t alen; 
14. size_t namelen; 
15. int s; 
16. int r; 
17. int result = -1; 
18.  
19. s = socket(AF_LOCAL, SOCK_STREAM, 0); 
20. if (s < 0) { 
21. return result; 
22. } 
23.  
24. memset(&addr, 0, sizeof(addr)); 
25. namelen = strlen(property_service_socket); 
26. strlcpy(addr.sun_path, property_service_socket, sizeof(addr.sun_path)); 
27. addr.sun_family = AF_LOCAL; 
28. alen = namelen + offsetof(struct sockaddr_un, sun_path) + 1; 
29.  
30. if (TEMP_FAILURE_RETRY(connect(s, (struct sockaddr *) &addr, alen)) < 0) { 
31. close(s); 
32. return result; 
33. } 
34.  
35. r = TEMP_FAILURE_RETRY(send(s, msg, sizeof(prop_msg), 0)); 
36.  
37. close(s); 
38. return result; 
39. } 
40.  
41. int __system_property_set(const char *key, const char *value) 
42. { 
43. int err; 
44. prop_msg msg; 
45.  
46. if (key == 0) return -1; 
47. if (value == 0) value = ""; 
48. if (strlen(key) >= PROP_NAME_MAX) return -1; 
49. if (strlen(value) >= PROP_VALUE_MAX) return -1; 
50.  
51. memset(&msg, 0, sizeof(msg)); 
52. msg.cmd = PROP_MSG_SETPROP; 
53. strlcpy(msg.name, key, sizeof(msg.name)); 
54. strlcpy(msg.value, value, sizeof(msg.value)); 
55.  
56. err = send_prop_msg(&msg); 
57. if (err < 0) { 
58. return err; 
59. } 
60. return 0; 
61. }