Android源碼下載:https://mirrors.tuna.tsinghua.edu.cn/help/AOSP/

      源碼編譯可參考【牛肉面大神之作】:http://blog.csdn.net/cjpx00008/article/details/60474883

  【開篇說明】

  在【Android啟示錄】中,提到了主要的分析對象和分享內容,拋開Android內核級的知識點,學習Android第一步便是“init”,作為天字第一號進程,代碼羞澀難懂,但是也極其重要,熟悉init的原理對后面Zygote -- SystemServer -- 核心服務等一些列源碼的研究是有很大作用的,所以既然說研究Android源碼,就先拿init “庖丁解牛”!

  【正文開始】

  Init進程,它是一個由內核啟動的用戶級進程,當Linux內核啟動之后,運行的第一個進程是init,這個進程是一個守護進程,確切的說,它是Linux系統中用戶控件的第一個進程,所以它的進程號是1。它的生命周期貫穿整個linux 內核運行的始終, linux中所有其它的進程的共同始祖均為init進程,可以通過“adb shell ps | grep init”查看進程號。

  Android init進程的入口文件在system/core/init/init.cpp中,由于init是命令行程序,所以分析init.cpp首先應從main函數開始:

Java代碼
  1. int main(int argc, char** argv) {    // 入口函數main  
  2.     if (!strcmp(basename(argv[0]), "ueventd")) {  
  3.         return ueventd_main(argc, argv);  
  4.     }  
  5.   
  6.     if (!strcmp(basename(argv[0]), "watchdogd")) {  
  7.         return watchdogd_main(argc, argv);  
  8.     }  
  9.   
  10.     // Clear the umask.  
  11.     umask(0);    // 清除屏蔽字(file mode creation mask),保證新建的目錄的訪問權限不受屏蔽字影響。  
  12.     add_environment("PATH", _PATH_DEFPATH);  
  13.       
  14.     bool is_first_stage = (argc == 1) || (strcmp(argv[1], "--second-stage") != 0);    // 判斷是否是系統啟動的第一階段,只有啟動參數中有--second-stage才為第二階段  
  15.     // Get the basic filesystem setup we need put together in the initramdisk   
  16.     // on / and then we'll let the rc file figure out the rest.   
  17.     if (is_first_stage) {   
  18.         mount("tmpfs""/dev""tmpfs", MS_NOSUID, "mode=0755");                        // 掛載tmpfs文件系統   
  19.         mkdir("/dev/pts"0755);   
  20.         mkdir("/dev/socket"0755);   
  21.         mount("devpts""/dev/pts""devpts"0, NULL);                                 // 掛載devpts文件系統   
  22.         #define MAKE_STR(x) __STRING(x)   
  23.         mount("proc""/proc""proc"0"hidepid=2,gid=" MAKE_STR(AID_READPROC));     // 掛載proc文件系統   
  24.         mount("sysfs""/sys""sysfs"0, NULL);                                       // 掛載sysfs文件系統   
  25.     }  

  以上代碼主要做的工作就是:【創建文件系統目錄并掛載相關的文件系統】

Java代碼
  1. int main(int argc, char** argv) {  
  2.     /* 01. 創建文件系統目錄并掛載相關的文件系統 */  
  3.     /* 02. 屏蔽標準的輸入輸出/初始化內核log系統 */  
  4.     // We must have some place other than / to create the device nodes for  
  5.     // kmsg and null, otherwise we won't be able to remount / read-only  
  6.     // later on. Now that tmpfs is mounted on /dev, we can actually talk  
  7.     // to the outside world.  
  8.     open_devnull_stdio();    // 重定向標準輸入輸出到/dev/_null_  -->  定義在system/core/init/Util.cpp中  
  9.     // init進程通過klog_init函數,提供輸出log信息的設備  -->  定義在system/core/libcutils/Klog.c中  
  10.     klog_init();      // 對klog進行初始化           
  11.     klog_set_level(KLOG_NOTICE_LEVEL);  // NOTICE level  

  繼續分析源碼,接下來要做的就是初始化屬性域:

Java代碼
  1. int main(int argc, char** argv) {  
  2.     /* 01. 創建文件系統目錄并掛載相關的文件系統 */  
  3.     /* 02. 屏蔽標準的輸入輸出/初始化內核log系統 */  
  4.     /* 03. 初始化屬性域 */  
  5.     NOTICE("init %s started!\n", is_first_stage ? "first stage" : "second stage");  
  6.     if (!is_first_stage) {      // 引入SELinux機制后,通過is_first_stage區分init運行狀態  
  7.         // Indicate that booting is in progress to background fw loaders, etc.  
  8.         close(open("/dev/.booting", O_WRONLY | O_CREAT | O_CLOEXEC, 0000));      /* 檢測/dev/.booting文件是否可讀寫、創建等*/  
  9.         property_init();        // 初始化屬性域 --> 定義于system/core/init/Property_service.cpp  
  10.   
  11.         // If arguments are passed both on the command line and in DT,  
  12.         // properties set in DT always have priority over the command-line ones.  
  13.         process_kernel_dt();  
  14.         process_kernel_cmdline();     // 處理內核命令行  
  15.         // Propagate the kernel variables to internal variables  
  16.         // used by init as well as the current required properties.  
  17.         export_kernel_boot_props();  
  18.     }  

  看一下property_init方法:位于system/core/init/Property_service.cpp中

Java代碼
  1. void property_init() {  
  2.     if (__system_property_area_init()) {         // 調用此函數初始化屬性域  
  3.         ERROR("Failed to initialize property area\n");  
  4.         exit(1);  
  5.     }  
  6. }  

      繼續分析main函數:

Java代碼
  1. int main(int argc, char** argv) {  
  2.     /* 01. 創建文件系統目錄并掛載相關的文件系統 */  
  3.     /* 02. 屏蔽標準的輸入輸出/初始化內核log系統 */  
  4.     /* 03. 初始化屬性域 */  
  5.     /* 04. 完成SELinux相關工作 */  
  6.     // Set up SELinux, including loading the SELinux policy if we're in the kernel domain.  
  7.     selinux_initialize(is_first_stage);     // 調用selinux_initialize啟動SELinux  

  詳細看一下selinux_initialize()函數:

Java代碼
  1. static void selinux_initialize(bool in_kernel_domain) {     // 區分內核態和用戶態  
  2.     Timer t;      //使用Timer計時,計算selinux初始化耗時  
  3.   
  4.     selinux_callback cb;  
  5.     cb.func_log = selinux_klog_callback;              // 用于打印Log的回調函數  
  6.     selinux_set_callback(SELINUX_CB_LOG, cb);  
  7.     cb.func_audit = audit_callback;                    // 用于檢查權限的回調函數  
  8.     selinux_set_callback(SELINUX_CB_AUDIT, cb);  
  9.   
  10.     if (in_kernel_domain) {        // 內核態處理流程,第一階段in_kernel_domain為true    
  11.         INFO("Loading SELinux policy...\n");        // 該行log打印不出,INFO級別   
  12.         // 用于加載sepolicy文件。該函數最終將sepolicy文件傳遞給kernel,這樣kernel就有了安全策略配置文件  
  13.         if (selinux_android_load_policy() < 0) {  
  14.             ERROR("failed to load policy: %s\n", strerror(errno));  
  15.             security_failure();  
  16.         }  
  17.   
  18.         bool kernel_enforcing = (security_getenforce() == 1);      // 內核中讀取的信息  
  19.         bool is_enforcing = selinux_is_enforcing();                // 命令行中得到的信息  
  20.         if (kernel_enforcing != is_enforcing) {  
  21.         // 用于設置selinux的工作模式。selinux有兩種工作模式:  
  22.             // 1、”permissive”,所有的操作都被允許(即沒有MAC),但是如果違反權限的話,會記錄日志  
  23.             // 2、”enforcing”,所有操作都會進行權限檢查。在一般的終端中,應該工作于enforing模式  
  24.             if (security_setenforce(is_enforcing)) {        //設置selinux的模式,是開還是關  
  25.                 ERROR("security_setenforce(%s) failed: %s\n",  
  26.                       is_enforcing ? "true" : "false", strerror(errno));  
  27.                 security_failure();    // 將重啟進入recovery mode  
  28.             }  
  29.         }  
  30.   
  31.         if (write_file("/sys/fs/selinux/checkreqprot""0") == -1) {  
  32.             security_failure();  
  33.         }  
  34.   
  35.         NOTICE("(Initializing SELinux %s took %.2fs.)\n",  
  36.                is_enforcing ? "enforcing" : "non-enforcing", t.duration());   //輸出selinux的模式,與初始化耗時  
  37.     } else {   
  38.         selinux_init_all_handles(); //如果啟動第二階段,調用該函數     
  39.     }   
  40. }  

  回到main函數中繼續分析:

Java代碼
  1. int main(int argc, char** argv) {  
  2.     /* 01. 創建文件系統目錄并掛載相關的文件系統 */  
  3.     /* 02. 屏蔽標準的輸入輸出/初始化內核log系統 */  
  4.     /* 03. 初始化屬性域 */  
  5.     /* 04. 完成SELinux相關工作 */  
  6.     /* 05. 重新設置屬性 */  
  7.     // If we're in the kernel domain, re-exec init to transition to the init domain now  
  8.     // that the SELinux policy has been loaded.  
  9.     if (is_first_stage) {  
  10.         if (restorecon("/init") == -1) {    // 按selinux policy要求,重新設置init文件屬性  
  11.             ERROR("restorecon failed: %s\n", strerror(errno));  
  12.             security_failure();  
  13.         }  
  14.         char* path = argv[0];  
  15.         char* args[] = { path, const_cast<char*>("--second-stage"), nullptr };     //設置參數--second-stage  
  16.    
  17.   
  18.     if (execv(path, args) == -1) {        // 執行init進程,重新進入main函數  
  19.             ERROR("execv(\"%s\") failed: %s\n", path, strerror(errno));  
  20.             security_failure();  
  21.         }  
  22.     }  
  23.   
  24.     // These directories were necessarily created before initial policy load  
  25.     // and therefore need their security context restored to the proper value.  
  26.     // This must happen before /dev is populated by ueventd.  
  27.     NOTICE("Running restorecon...\n");  
  28.     restorecon("/dev");  
  29.     restorecon("/dev/socket");  
  30.     restorecon("/dev/__properties__");  
  31.     restorecon("/property_contexts");  
  32.   
  33.     restorecon_recursive("/sys");  
  34.   
  35.     epoll_fd = epoll_create1(EPOLL_CLOEXEC);         // 調用epoll_create1創建epoll句柄  
  36.     if (epoll_fd == -1) {  
  37.         ERROR("epoll_create1 failed: %s\n", strerror(errno));  
  38.         exit(1);  
  39.     }  

  接著往下分析:

Java代碼
  1. int main(int argc, char** argv) {  
  2.     /* 01. 創建文件系統目錄并掛載相關的文件系統 */  
  3.     /* 02. 屏蔽標準的輸入輸出/初始化內核log系統 */  
  4.     /* 03. 初始化屬性域 */  
  5.     /* 04. 完成SELinux相關工作 */·  
  6.     /* 05. 重新設置屬性 */  
  7.     /* 06. 創建epoll句柄 */  
  8.     /* 07. 裝載子進程信號處理器 */  
  9.     signal_handler_init();       // 裝載子進程信號處理器  

  Note:init是一個守護進程,為了防止init的子進程成為僵尸進程(zombie process),需要init在子進程結束時獲取子進程的結束碼,通過結束碼將程序表中的子進程移除,防止成為僵尸進程的子進程占用程序表的空間(程序表的空間達到上限時,系統就不能再啟動新的進程了,會引起嚴重的系統問題)。

  細化signal_handler_init()函數:

Java代碼
  1. void signal_handler_init() {        // 函數定位于:system/core/init/Singal_handler.cpp  
  2.     // 在linux當中,父進程是通過捕捉SIGCHLD信號來得知子進程運行結束的情況  
  3.     // Create a signalling mechanism for SIGCHLD.  
  4.     int s[2];  
  5.     // 利用socketpair創建出已經連接的兩個socket,分別作為信號的讀、寫端  
  6.     if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0, s) == -1) {  
  7.         ERROR("socketpair failed: %s\n", strerror(errno));  
  8.         exit(1);  
  9.     }  
  10.   
  11.     signal_write_fd = s[0];  
  12.     signal_read_fd = s[1];  
  13.   
  14.     // Write to signal_write_fd if we catch SIGCHLD.  
  15.     struct sigaction act;  
  16.     memset(&act, 0, sizeof(act));  
  17.     // 信號處理器為SIGCHLD_handler,其被存在sigaction結構體中,負責處理SIGCHLD消息  
  18.     act.sa_handler = SIGCHLD_handler;       // 信號處理器:SIGCHLD_handler  
  19.     act.sa_flags = SA_NOCLDSTOP;            // 僅當進程終止時才接受SIGCHLD信號  
  20.     // 調用信號安裝函數sigaction,將監聽的信號及對應的信號處理器注冊到內核中  
  21.     sigaction(SIGCHLD, &act, 0);  
  22.     // 相對于6.0的代碼,進一步作了封裝,用于終止出現問題的子進程  
  23.     ServiceManager::GetInstance().ReapAnyOutstandingChildren();  
  24.   
  25.     register_epoll_handler(signal_read_fd, handle_signal);        // 定義在system/core/init/Init.cpp  
  26. }  

  Linux進程通過互相發送接收消息來實現進程間的通信,這些消息被稱為“信號”。每個進程在處理其它進程發送的信號時都要注冊處理者,處理者被稱為信號處理器。

  注意到sigaction結構體的sa_flags為SA_NOCLDSTOP。由于系統默認在子進程暫停時也會發送信號SIGCHLD,init需要忽略子進程在暫停時發出的SIGCHLD信號,因此將act.sa_flags 置為SA_NOCLDSTOP,該標志位表示僅當進程終止時才接受SIGCHLD信號。

  觀察SIGCHLD_handler具體工作:

Java代碼
  1. static void SIGCHLD_handler(int) {  
  2.     /* init進程是所有進程的父進程,當其子進程終止產生SIGCHLD信號時,SIGCHLD_handler對signal_write_fd執行寫操作,由于socketpair的綁定關系,這將觸發信號對應的signal_read_fd收到數據。*/  
  3.     if (TEMP_FAILURE_RETRY(write(signal_write_fd, "1"1)) == -1) {  
  4.         ERROR("write(signal_write_fd) failed: %s\n", strerror(errno));  
  5.     }  
  6. }  

  在裝在信號監聽器的最后,有如下函數:register_epoll_handler(signal_read_fd, handle_signal);

Java代碼
  1. void register_epoll_handler(int fd, void (*fn)()) {        // 回到init.cpp中  
  2.     epoll_event ev;  
  3.     ev.events = EPOLLIN;  
  4.     ev.data.ptr = reinterpret_cast<void*>(fn);  
  5.     // epoll_fd增加一個監聽對象fd,fd上有數據到來時,調用fn處理  
  6.     // 當epoll句柄監聽到signal_read_fd中有數據可讀時,將調用handle_signal進行處理。  
  7.     if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev) == -1) {  
  8.         ERROR("epoll_ctl failed: %s\n", strerror(errno));  
  9.     }  
  10. }  

  【小結】

  當init進程調用signal_handler_init后,一旦收到子進程終止帶來的SIGCHLD消息后,將利用信號處理者SIGCHLD_handler向signal_write_fd寫入信息; epoll句柄監聽到signal_read_fd收消息后,將調用handle_signal進行處理。

Android啟動篇 — init原理(一)

  查看handle_signal函數:

Java代碼
  1. static void handle_signal() {      // --> 位于system/core/init/signal_handler.cpp中  
  2.     // Clear outstanding requests.  
  3.     char buf[32];  
  4.     read(signal_read_fd, buf, sizeof(buf));  
  5.   
  6.     ServiceManager::GetInstance().ReapAnyOutstandingChildren();  
  7. }  

  從代碼中可以看出,handle_signal只是清空signal_read_fd中的數據,然后調用ServiceManager::GetInstance().ReapAnyOutstandingChildren()。

  繼續分析:

Java代碼
  1. // 定義于system/core/init/service.cpp中,是一個單例對象。  
  2. ServiceManager::ServiceManager() {     // 默認private屬性  
  3. }  
  4.   
  5. ServiceManager& ServiceManager::GetInstance() {  
  6.     static ServiceManager instance;  
  7.     return instance;  
  8. }  
  9. void ServiceManager::ReapAnyOutstandingChildren() {  
  10.     while (ReapOneProcess()) {    // 實際調用了ReapOneProcess函數  
  11.     }  
  12. }  

  接下來看下ReapOneProcess這個函數:

Java代碼
  1. bool ServiceManager::ReapOneProcess() {  
  2.     int status;  
  3.     //用waitpid函數獲取狀態發生變化的子進程pid  
  4.     //waitpid的標記為WNOHANG,即非阻塞,返回為正值就說明有進程掛掉了  
  5.     pid_t pid = TEMP_FAILURE_RETRY(waitpid(-1, &status, WNOHANG));  
  6.     if (pid == 0) {  
  7.         return false;  
  8.     } else if (pid == -1) {  
  9.         ERROR("waitpid failed: %s\n", strerror(errno));  
  10.         return false;  
  11.     }  
  12.     // 利用FindServiceByPid函數,找到pid對應的服務。  
  13.     // FindServiceByPid主要通過輪詢解析init.rc生成的service_list,找到pid與參數一直的svc  
  14.     Service* svc = FindServiceByPid(pid);  
  15.       
  16.     std::string name;  
  17.     if (svc) {  
  18.         name = android::base::StringPrintf("Service '%s' (pid %d)",  
  19.                                            svc->name().c_str(), pid);  
  20.     } else {  
  21.         name = android::base::StringPrintf("Untracked pid %d", pid);  
  22.     }  
  23.   
  24.     if (WIFEXITED(status)) {  
  25.         NOTICE("%s exited with status %d\n", name.c_str(), WEXITSTATUS(status));  
  26.     } else if (WIFSIGNALED(status)) {  
  27.         NOTICE("%s killed by signal %d\n", name.c_str(), WTERMSIG(status));         // 輸出服務結束原因  
  28.     } else if (WIFSTOPPED(status)) {  
  29.         NOTICE("%s stopped by signal %d\n", name.c_str(), WSTOPSIG(status));  
  30.     } else {  
  31.         NOTICE("%s state changed", name.c_str());  
  32.     }  
  33.   
  34.     if (!svc) {  
  35.         return true;  
  36.     }  
  37.   
  38.     if (svc->Reap()) {                 // 結束服務,相對于6.0作了進一步的封裝,重啟一些子進程,不做具體分析  
  39.         waiting_for_exec = false;  
  40.         RemoveService(*svc);           // 移除服務對應的信息  
  41.     }  
  42.   
  43.     return true;  
  44. }  

  繼續分析main()函數:

Java代碼
  1. int main(int argc, char** argv) {  
  2.     /* 01. 創建文件系統目錄并掛載相關的文件系統 */  
  3.     /* 02. 屏蔽標準的輸入輸出/初始化內核log系統 */  
  4.     /* 03. 初始化屬性域 */  
  5.     /* 04. 完成SELinux相關工作 */·  
  6.     /* 05. 重新設置屬性 */  
  7.     /* 06. 創建epoll句柄 */  
  8.     /* 07. 裝載子進程信號處理器 */  
  9.     /* 08. 啟動匹配屬性的服務端*/  
  10.     property_load_boot_defaults();      // 進程調用property_load_boot_defaults進行默認屬性配置相關的工作  
  11.     export_oem_lock_status();  
  12.   
  13.     std::string bootmode = property_get("ro.bootmode");      // 獲取啟動模式  
  14.     if (strncmp(bootmode.c_str(), "ffbm"4) == 0){  
  15.     property_set("ro.logdumpd","0");  
  16.     }else{  
  17.     property_set("ro.logdumpd","1");  
  18.     }  
  19.     start_property_service();      // 啟動屬性服務  

  看下property_load_boot_defaults()函數:位于system/core/init/Property_service.cpp中

Java代碼
  1. // property_load_boot_defaults實際上就是調用load_properties_from_file解析配置文件       
  2. /* 09. 設置默認系統屬性 */  
  3. // 然后根據解析的結果,設置系統屬性  
  4. void property_load_boot_defaults() {  
  5.     load_properties_from_file(PROP_PATH_RAMDISK_DEFAULT, NULL);  
  6. }  

  接著繼續分析main:

Java代碼
  1. int main(int argc, char** argv) {  
  2.     /* 01. 創建文件系統目錄并掛載相關的文件系統 */  
  3.     /* 02. 屏蔽標準的輸入輸出/初始化內核log系統 */  
  4.     /* 03. 初始化屬性域 */  
  5.     /* 04. 完成SELinux相關工作 */·  
  6.     /* 05. 重新設置屬性 */  
  7.     /* 06. 創建epoll句柄 */  
  8.     /* 07. 裝載子進程信號處理器 */  
  9.     /* 08. 設置默認系統屬性 */  
  10.     /* 09. 啟動配置屬性的服務端 */  
  11.     /* 10. 匹配命令和函數之間的對應關系 */  
  12.     const BuiltinFunctionMap function_map;          // system/core/init/builtins.cpp  
  13.     Action::set_function_map(&function_map);        // 在Action中保存function_map對象,記錄了命令與函數之間的對應關系  

  【結尾】

  由于init涉及的知識點是相當多,代碼之間的邏輯也是極其復雜,我在看別人的博客過程中,最反感一篇博客要看很久,往往因為瑣事而放棄堅持(確切的說,隨手把網頁關掉了),所以我就分章節分析,盡量少源碼多講解。

  接下來,在Android啟動篇 — init原理(二)中將詳細分析init.rc的解析過程。

本文發布:Android開發網
本文地址:http://www.cpbsu.com/android/course/707.html
2017年8月28日
發布:雞啄米 分類:Android開發教程 瀏覽: 評論:0