***************************************************************************         ***************************************************************************

***************************************************************************         ***************************************************************************

【開篇說明】

　　在【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函式開始：

int main(int argc, char** argv) {    // 入口函式main
    if (!strcmp(basename(argv[0]), "ueventd")) {
        return ueventd_main(argc, argv);
    }

    if (!strcmp(basename(argv[0]), "watchdogd")) {
        return watchdogd_main(argc, argv);
    }

    // Clear the umask.
    umask(0);    // 清除遮蔽字(file mode creation mask)，保證新建的目錄的訪問許可權不受遮蔽字影響。
 

    add_environment("PATH", _PATH_DEFPATH);
    
    bool is_first_stage = (argc == 1) || (strcmp(argv[1], "--second-stage") != 0);    // 判斷是否是系統啟動的第一階段，只有啟動引數中有--second-stage才為第二階段

    // Get the basic filesystem setup we need put together in the initramdisk 
    // on / and then we'll let the rc file figure out the rest. 
    if (is_first_stage) { 
        mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");                        // 掛載tmpfs檔案系統 
        mkdir("/dev/pts", 0755); 
        mkdir("/dev/socket", 0755); 
        mount("devpts", "/dev/pts", "devpts", 0, NULL);                                 // 掛載devpts檔案系統 
        #define MAKE_STR(x) __STRING(x) 
        mount("proc", "/proc", "proc", 0, "hidepid=2,gid=" MAKE_STR(AID_READPROC));     // 掛載proc檔案系統 
        mount("sysfs", "/sys", "sysfs", 0, NULL);                                       // 掛載sysfs檔案系統 
    }

　　以上程式碼主要做的工作就是：【建立檔案系統目錄並掛載相關的檔案系統】

int main(int argc, char** argv) {
    /* 01. 建立檔案系統目錄並掛載相關的檔案系統 */
    /* 02. 遮蔽標準的輸入輸出/初始化核心log系統 */
    // We must have some place other than / to create the device nodes for
    // kmsg and null, otherwise we won't be able to remount / read-only
    // later on. Now that tmpfs is mounted on /dev, we can actually talk
    // to the outside world.
    open_devnull_stdio();    // 重定向標準輸入輸出到/dev/_null_  -->  定義在system/core/init/Util.cpp中
    // init程序通過klog_init函式，提供輸出log資訊的裝置  -->  定義在system/core/libcutils/Klog.c中
    klog_init();      // 對klog進行初始化         
    klog_set_level(KLOG_NOTICE_LEVEL);  // NOTICE level

　　繼續分析原始碼，接下來要做的就是初始化屬性域：

int main(int argc, char** argv) {
    /* 01. 建立檔案系統目錄並掛載相關的檔案系統 */
    /* 02. 遮蔽標準的輸入輸出/初始化核心log系統 */
    /* 03. 初始化屬性域 */
    NOTICE("init %s started!\n", is_first_stage ? "first stage" : "second stage");
    if (!is_first_stage) {      // 引入SELinux機制後，通過is_first_stage區分init執行狀態
        // Indicate that booting is in progress to background fw loaders, etc.
        close(open("/dev/.booting", O_WRONLY | O_CREAT | O_CLOEXEC, 0000));      /* 檢測/dev/.booting檔案是否可讀寫、建立等*/

        property_init();        // 初始化屬性域 --> 定義於system/core/init/Property_service.cpp

        // If arguments are passed both on the command line and in DT,
        // properties set in DT always have priority over the command-line ones.
        process_kernel_dt();
        process_kernel_cmdline();     // 處理核心命令列
        // Propagate the kernel variables to internal variables
        // used by init as well as the current required properties.
        export_kernel_boot_props();
    }

　　看一下property_init方法：位於system/core/init/Property_service.cpp中

void property_init() {
    if (__system_property_area_init()) {         // 呼叫此函式初始化屬性域
        ERROR("Failed to initialize property area\n");
        exit(1);
    }
}

　　繼續分析main函式：

int main(int argc, char** argv) {
    /* 01. 建立檔案系統目錄並掛載相關的檔案系統 */
    /* 02. 遮蔽標準的輸入輸出/初始化核心log系統 */
    /* 03. 初始化屬性域 */
    /* 04. 完成SELinux相關工作 */
    // Set up SELinux, including loading the SELinux policy if we're in the kernel domain.
    selinux_initialize(is_first_stage);     // 呼叫selinux_initialize啟動SELinux

　　詳細看一下selinux_initialize()函式：

static void selinux_initialize(bool in_kernel_domain) {     // 區分核心態和使用者態
    Timer t;      //使用Timer計時，計算selinux初始化耗時

    selinux_callback cb;
    cb.func_log = selinux_klog_callback;              // 用於列印Log的回撥函式
    selinux_set_callback(SELINUX_CB_LOG, cb);
    cb.func_audit = audit_callback;                    // 用於檢查許可權的回撥函式
    selinux_set_callback(SELINUX_CB_AUDIT, cb);

    if (in_kernel_domain) {        // 核心態處理流程，第一階段in_kernel_domain為true  
        INFO("Loading SELinux policy...\n");        // 該行log打印不出，INFO級別 
        // 用於載入sepolicy檔案。該函式最終將sepolicy檔案傳遞給kernel，這樣kernel就有了安全策略配置檔案
        if (selinux_android_load_policy() < 0) {
            ERROR("failed to load policy: %s\n", strerror(errno));
            security_failure();
        }

        bool kernel_enforcing = (security_getenforce() == 1);      // 核心中讀取的資訊
        bool is_enforcing = selinux_is_enforcing();                // 命令列中得到的資訊
        if (kernel_enforcing != is_enforcing) {
        // 用於設定selinux的工作模式。selinux有兩種工作模式：
            // 1、”permissive”，所有的操作都被允許（即沒有MAC），但是如果違反許可權的話，會記錄日誌
            // 2、”enforcing”，所有操作都會進行許可權檢查。在一般的終端中，應該工作於enforing模式
            if (security_setenforce(is_enforcing)) {        //設定selinux的模式，是開還是關
                ERROR("security_setenforce(%s) failed: %s\n",
                      is_enforcing ? "true" : "false", strerror(errno));
                security_failure();    // 將重啟進入recovery mode
            }
        }

        if (write_file("/sys/fs/selinux/checkreqprot", "0") == -1) {
            security_failure();
        }

        NOTICE("(Initializing SELinux %s took %.2fs.)\n",
               is_enforcing ? "enforcing" : "non-enforcing", t.duration());   //輸出selinux的模式，與初始化耗時

    } else { 
        selinux_init_all_handles(); //如果啟動第二階段，呼叫該函式   
    } 
}

 　　回到main函式中繼續分析：

int main(int argc, char** argv) {
    /* 01. 建立檔案系統目錄並掛載相關的檔案系統 */
    /* 02. 遮蔽標準的輸入輸出/初始化核心log系統 */
    /* 03. 初始化屬性域 */
    /* 04. 完成SELinux相關工作 */
    /* 05. 重新設定屬性 */
    // If we're in the kernel domain, re-exec init to transition to the init domain now
    // that the SELinux policy has been loaded.
    if (is_first_stage) {
        if (restorecon("/init") == -1) {    // 按selinux policy要求，重新設定init檔案屬性

            ERROR("restorecon failed: %s\n", strerror(errno));
            security_failure();
        }
        char* path = argv[0];
        char* args[] = { path, const_cast<char*>("--second-stage"), nullptr };     //設定引數--second-stage

    if (execv(path, args) == -1) {        // 執行init程序，重新進入main函式
            ERROR("execv(\"%s\") failed: %s\n", path, strerror(errno));
            security_failure();
        }
    }

    // These directories were necessarily created before initial policy load
    // and therefore need their security context restored to the proper value.
    // This must happen before /dev is populated by ueventd.
    NOTICE("Running restorecon...\n");
    restorecon("/dev");
    restorecon("/dev/socket");
    restorecon("/dev/__properties__");
    restorecon("/property_contexts");

    restorecon_recursive("/sys");

    epoll_fd = epoll_create1(EPOLL_CLOEXEC);         // 呼叫epoll_create1建立epoll控制代碼
    if (epoll_fd == -1) {
        ERROR("epoll_create1 failed: %s\n", strerror(errno));
        exit(1);
    }

　　接著往下分析：

int main(int argc, char** argv) {
    /* 01. 建立檔案系統目錄並掛載相關的檔案系統 */
    /* 02. 遮蔽標準的輸入輸出/初始化核心log系統 */
    /* 03. 初始化屬性域 */
    /* 04. 完成SELinux相關工作 */·
    /* 05. 重新設定屬性 */
    /* 06. 建立epoll控制代碼 */
    /* 07. 裝載子程序訊號處理器 */
    signal_handler_init();       // 裝載子程序訊號處理器

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

　　細化signal_handler_init()函式：

void signal_handler_init() {        // 函式定位於：system/core/init/Singal_handler.cpp
    // 在linux當中，父程序是通過捕捉SIGCHLD訊號來得知子程序執行結束的情況
    // Create a signalling mechanism for SIGCHLD.
    int s[2];
    // 利用socketpair創建出已經連線的兩個socket，分別作為訊號的讀、寫端
    if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0, s) == -1) {
        ERROR("socketpair failed: %s\n", strerror(errno));
        exit(1);
    }

    signal_write_fd = s[0];
    signal_read_fd = s[1];

    // Write to signal_write_fd if we catch SIGCHLD.
    struct sigaction act;
    memset(&act, 0, sizeof(act));
    // 訊號處理器為SIGCHLD_handler，其被存在sigaction結構體中，負責處理SIGCHLD訊息
    act.sa_handler = SIGCHLD_handler;       // 訊號處理器：SIGCHLD_handler
    act.sa_flags = SA_NOCLDSTOP;            // 僅當程序終止時才接受SIGCHLD訊號
    // 呼叫訊號安裝函式sigaction，將監聽的訊號及對應的訊號處理器註冊到核心中
    sigaction(SIGCHLD, &act, 0);
    // 相對於6.0的程式碼，進一步作了封裝，用於終止出現問題的子程序
    ServiceManager::GetInstance().ReapAnyOutstandingChildren();

    register_epoll_handler(signal_read_fd, handle_signal);        // 定義在system/core/init/Init.cpp
}

　　Linux程序通過互相傳送接收訊息來實現程序間的通訊，這些訊息被稱為“訊號”。每個程序在處理其它程序傳送的訊號時都要註冊處理者，處理者被稱為訊號處理器。

　　注意到sigaction結構體的sa_flags為SA_NOCLDSTOP。由於系統預設在子程序暫停時也會發送訊號SIGCHLD，init需要忽略子程序在暫停時發出的SIGCHLD訊號，因此將act.sa_flags 置為SA_NOCLDSTOP，該標誌位表示僅當程序終止時才接受SIGCHLD訊號。

　　觀察SIGCHLD_handler具體工作：

static void SIGCHLD_handler(int) {
    /* init程序是所有程序的父程序，當其子程序終止產生SIGCHLD訊號時，SIGCHLD_handler對signal_write_fd執行寫操作，由於socketpair的繫結關係，這將觸發訊號對應的signal_read_fd收到資料。*/
    if (TEMP_FAILURE_RETRY(write(signal_write_fd, "1", 1)) == -1) {
        ERROR("write(signal_write_fd) failed: %s\n", strerror(errno));
    }
}

　　在裝在訊號監聽器的最後，有如下函式：register_epoll_handler(signal_read_fd, handle_signal);

void register_epoll_handler(int fd, void (*fn)()) {        // 回到init.cpp中
    epoll_event ev;
    ev.events = EPOLLIN;
    ev.data.ptr = reinterpret_cast<void*>(fn);
    // epoll_fd增加一個監聽物件fd,fd上有資料到來時，呼叫fn處理
    // 當epoll控制代碼監聽到signal_read_fd中有資料可讀時，將呼叫handle_signal進行處理。
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev) == -1) {
        ERROR("epoll_ctl failed: %s\n", strerror(errno));
    }
}

【小結】

　　當init程序呼叫signal_handler_init後，一旦收到子程序終止帶來的SIGCHLD訊息後，將利用訊號處理者SIGCHLD_handler向signal_write_fd寫入資訊； epoll控制代碼監聽到signal_read_fd收訊息後，將呼叫handle_signal進行處理。

　　檢視handle_signal函式：

static void handle_signal() {      // --> 位於system/core/init/signal_handler.cpp中
    // Clear outstanding requests.
    char buf[32];
    read(signal_read_fd, buf, sizeof(buf));

    ServiceManager::GetInstance().ReapAnyOutstandingChildren();
}

　　從程式碼中可以看出，handle_signal只是清空signal_read_fd中的資料，然後呼叫ServiceManager::GetInstance().ReapAnyOutstandingChildren()。

　　繼續分析：

// 定義於system/core/init/service.cpp中，是一個單例物件。
ServiceManager::ServiceManager() {     // 預設private屬性
}

ServiceManager& ServiceManager::GetInstance() {
    static ServiceManager instance;
    return instance;
}
void ServiceManager::ReapAnyOutstandingChildren() {
    while (ReapOneProcess()) {    // 實際呼叫了ReapOneProcess函式
    }
}

　　接下來看下ReapOneProcess這個函式：

bool ServiceManager::ReapOneProcess() {
    int status;
    //用waitpid函式獲取狀態發生變化的子程序pid
    //waitpid的標記為WNOHANG，即非阻塞，返回為正值就說明有程序掛掉了
    pid_t pid = TEMP_FAILURE_RETRY(waitpid(-1, &status, WNOHANG));
    if (pid == 0) {
        return false;
    } else if (pid == -1) {
        ERROR("waitpid failed: %s\n", strerror(errno));
        return false;
    }
    // 利用FindServiceByPid函式，找到pid對應的服務。
    // FindServiceByPid主要通過輪詢解析init.rc生成的service_list，找到pid與引數一直的svc
    Service* svc = FindServiceByPid(pid);
    
    std::string name;
    if (svc) {
        name = android::base::StringPrintf("Service '%s' (pid %d)",
                                           svc->name().c_str(), pid);
    } else {
        name = android::base::StringPrintf("Untracked pid %d", pid);
    }

    if (WIFEXITED(status)) {
        NOTICE("%s exited with status %d\n", name.c_str(), WEXITSTATUS(status));
    } else if (WIFSIGNALED(status)) {
        NOTICE("%s killed by signal %d\n", name.c_str(), WTERMSIG(status));         // 輸出服務結束原因
    } else if (WIFSTOPPED(status)) {
        NOTICE("%s stopped by signal %d\n", name.c_str(), WSTOPSIG(status));
    } else {
        NOTICE("%s state changed", name.c_str());
    }

    if (!svc) {
        return true;
    }

    if (svc->Reap()) {                 // 結束服務，相對於6.0作了進一步的封裝，重啟一些子程序，不做具體分析
        waiting_for_exec = false;
        RemoveService(*svc);           // 移除服務對應的資訊
    }

    return true;
}

　　繼續分析main()函式：

int main(int argc, char** argv) {
    /* 01. 建立檔案系統目錄並掛載相關的檔案系統 */
    /* 02. 遮蔽標準的輸入輸出/初始化核心log系統 */
    /* 03. 初始化屬性域 */
    /* 04. 完成SELinux相關工作 */·
    /* 05. 重新設定屬性 */
    /* 06. 建立epoll控制代碼 */
    /* 07. 裝載子程序訊號處理器 */
    /* 08. 啟動匹配屬性的服務端*/
    property_load_boot_defaults();      // 程序呼叫property_load_boot_defaults進行預設屬性配置相關的工作
    export_oem_lock_status();

    std::string bootmode = property_get("ro.bootmode");      // 獲取啟動模式
    if (strncmp(bootmode.c_str(), "ffbm", 4) == 0){
    property_set("ro.logdumpd","0");
    }else{
    property_set("ro.logdumpd","1");
    }
    start_property_service();      // 啟動屬性服務

　　看下property_load_boot_defaults()函式：位於system/core/init/Property_service.cpp中

// property_load_boot_defaults實際上就是呼叫load_properties_from_file解析配置檔案       /* 09. 設定預設系統屬性 */
// 然後根據解析的結果，設定系統屬性
void property_load_boot_defaults() {
    load_properties_from_file(PROP_PATH_RAMDISK_DEFAULT, NULL);
}

　　接著繼續分析main：

int main(int argc, char** argv) {
    /* 01. 建立檔案系統目錄並掛載相關的檔案系統 */
    /* 02. 遮蔽標準的輸入輸出/初始化核心log系統 */
    /* 03. 初始化屬性域 */
    /* 04. 完成SELinux相關工作 */·
    /* 05. 重新設定屬性 */
    /* 06. 建立epoll控制代碼 */
    /* 07. 裝載子程序訊號處理器 */
    /* 08. 設定預設系統屬性 */
    /* 09. 啟動配置屬性的服務端 */
    /* 10. 匹配命令和函式之間的對應關係 */

    const BuiltinFunctionMap function_map;          // system/core/init/builtins.cpp
    Action::set_function_map(&function_map);        // 在Action中儲存function_map物件，記錄了命令與函式之間的對應關係

【結尾】

　　由於init涉及的知識點是相當多，程式碼之間的邏輯也是極其複雜，我在看別人的部落格過程中，最反感一篇部落格要看很久，往往因為瑣事而放棄堅持（確切的說，隨手把網頁關掉了），所以我就分章節分析，儘量少原始碼多講解。

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