1 概述
init是一個進程，確切地說，它是Linux系統(tǒng)中用戶空間的第一個進程。由于Android是基于Linux內核的，所以init也是Android系統(tǒng)中用戶空間的第一個進程，它的進程號是1
職責:
- init進程負責創(chuàng)建系統(tǒng)中的幾個關鍵進程，尤其是Zygote，它更是Java世界的開創(chuàng)者。
- Android系統(tǒng)有很多屬性，于是init就提供了一個propertyService（屬性服務）來管理它們。
2 init分析
init進程入口:
system/core/init/init.cpp
int main(int argc, char** argv) {
// 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) {
...
//創(chuàng)建一些文件夾
mkdir("/dev/pts", 0755);
mkdir("/dev/socket", 0755);
//掛載linux系統(tǒng)文件
mount("devpts", "/dev/pts", "devpts", 0, NULL);
...
early_mount();
}
//重定向標準輸入，標準輸出，標準錯誤輸出到 /dev/null
InitKernelLogging(argv);
if (!is_first_stage) {
// Indicate that booting is in progress to background fw loaders, etc.
//在/dev目錄創(chuàng)建一個空文件.booting來表示正在執(zhí)行初始化
close(open("/dev/.booting", O_WRONLY | O_CREAT | O_CLOEXEC, 0000));
//初始化和屬性相關的資源
property_init();
// 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();
}
// Set up SELinux, including loading the SELinux policy if we're in the kernel domain.
//加載SELinux策略， 后面有一些初始化文件上下文的操作等
selinux_initialize(is_first_stage);
...
//初始化子進程退出的信號處理過程
signal_handler_init();
//加載/default.prop文件
property_load_boot_defaults();
export_oem_lock_status();
//啟動屬性服務器(通過socket通信)
start_property_service();
set_usb_controller();
//為Action設置<command>處理函數(shù)
const BuiltinFunctionMap function_map;
Action::set_function_map(&function_map);
//解析init.rc文件
Parser& parser = Parser::GetInstance();
//設置對應的解析函數(shù) “service”塊以關鍵字“service”開始，表示啟動某個進程的方式和參數(shù)
parser.AddSectionParser("service",std::make_unique<ServiceParser>());
//“action”塊以關鍵字“on”開始，表示一堆命令的集合
parser.AddSectionParser("on", std::make_unique<ActionParser>());
//“import”是用來引入一個init配置文件，來擴展當前配置的
parser.AddSectionParser("import", std::make_unique<ImportParser>());
parser.ParseConfig("/init.rc");
//actionManager
ActionManager& am = ActionManager::GetInstance();
am.QueueEventTrigger("early-init"); //earkay-init trigger
// Queue an action that waits for coldboot done so we know ueventd has set up all of /dev...
am.QueueBuiltinAction(wait_for_coldboot_done_action, "wait_for_coldboot_done");
// ... so that we can start queuing up actions that require stuff from /dev.
am.QueueBuiltinAction(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
am.QueueBuiltinAction(keychord_init_action, "keychord_init");
am.QueueBuiltinAction(console_init_action, "console_init");
// Trigger all the boot actions to get us started.
am.QueueEventTrigger("init"); // init trigger
// Repeat mix_hwrng_into_linux_rng in case /dev/hw_random or /dev/random
// wasn't ready immediately after wait_for_coldboot_done
am.QueueBuiltinAction(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
// Don't mount filesystems or start core system services in charger mode.充電模式下不加載系統(tǒng)服務
std::string bootmode = property_get("ro.bootmode");
if (bootmode == "charger") {
am.QueueEventTrigger("charger");
} else {
am.QueueEventTrigger("late-init");
}
// Run all property triggers based on current state of the properties.
am.QueueBuiltinAction(queue_property_triggers_action, "queue_property_triggers");
while (true) {
//判斷是否有事件需要處理
if (!waiting_for_exec) {
//依次執(zhí)行每個action中攜帶command對應的執(zhí)行函數(shù)
am.ExecuteOneCommand();
//重啟一些掛掉的進程
restart_processes();
}
//以下決定timeout的時間，將影響while循環(huán)的間隔
int timeout = -1;
//有進程需要重啟時，等待該進程重啟
if (process_needs_restart) {
timeout = (process_needs_restart - gettime()) * 1000;
if (timeout < 0)
timeout = 0;
}
//有action待處理，不等待
if (am.HasMoreCommands()) {
timeout = 0;
}
//bootchart_sample應該是進行性能數(shù)據采樣
bootchart_sample(&timeout);
epoll_event ev;
//沒有事件到來的話，最多阻塞timeout時間
int nr = TEMP_FAILURE_RETRY(epoll_wait(epoll_fd, &ev, 1, timeout));
if (nr == -1) {
PLOG(ERROR) << "epoll_wait failed";
} else if (nr == 1) {
//有事件到來，執(zhí)行對應處理函數(shù)
//根據上文知道，epoll句柄（即epoll_fd）主要監(jiān)聽子進程結束，及其它進程設置系統(tǒng)屬性的請求。
((void (*)()) ev.data.ptr)();
}
}
}
Android在init過程中分別掛載了tmpfs，devpts，proc，sysfs這4類文件系統(tǒng)。
2.1 配置文件解析
system/core/rootdir/init.rc
其中init.rc文件在Android系統(tǒng)運行過程中用于通用的環(huán)境設置與進程相關的定義，init.{hardware}.rc（例如，高通有init.qcom.rc，MTK有init.mediatek.rc）用于定義Android在不同平臺下的特定進程和環(huán)境設置等。此處解析函數(shù)傳入的參數(shù)為“/init.rc”，解析的是運行時與init進程同在根目錄下的init.rc文件。
主要有兩部分：
- on
on <trigger>
<command>
<command>
<command>
Action其實就是一序列的Commands。Action都有一個trigger，它被用于決定action的執(zhí)行時間。當一個符合action觸發(fā)條件的事件發(fā)生時，action會被加入到執(zhí)行隊列的末尾。
隊列中的每一個action都會被提取出，而這個action中的每個command都將被依次執(zhí)行。Init在這些命令的執(zhí)行期間還控制著其他的活動
on early-init
//Set init and its forked children's oom_adj.
write /proc/1/oom_score_adj -1000
...
start ueventd
- service
service <name> <pathname> [ <argument> ]*
Services是一個程序，他在初始化時啟動，并在退出時重啟（可選）。
service ueventd /sbin/ueventd
class core
critical
seclabel u:r:ueventd:s0
借助系統(tǒng)環(huán)境變量或Linux命令，on列表用于創(chuàng)建所需目錄，以及為某些特定文件指定權限，而服務列表用來記錄init進程需要啟動的一些子進程。如上面代碼所示，service關鍵字后的第一個字符串表示服務（子進程）的名稱，第二個字符串表示服務的執(zhí)行路徑。
2.1.1 解析init.rc
system/core/inti/inti_pareser.cpp
bool Parser::ParseConfig(const std::string& path) {
if (is_dir(path.c_str())) {
return ParseConfigDir(path);
}
//init.cpp中傳入的是"/init.rc"是文件
return ParseConfigFile(path);
}
Parser::ParseConfigFile(const std::string& path) {
Timer t;
std::string data;
//讀取指定文件的內容，以string保存
if (!read_file(path.c_str(), &data)) {
return false;
}
...
ParseData(path, data);
...
}
Parser::ParseData(const std::string& filename, const std::string& data)根據關鍵字解析出服務和動作。動作與服務會分別放在了Action::ActionManager.actions_和Service::ServiceManager.services_中
bool Parser::ParseConfig(const std::string& path) {
if (is_dir(path.c_str())) {
return ParseConfigDir(path);
}
//init.cpp中傳入的是"/init.rc"是文件
return ParseConfigFile(path);
}
Parser::ParseConfigFile(const std::string& path) {
Timer t;
std::string data;
//讀取指定文件的內容，以string保存
if (!read_file(path.c_str(), &data)) {
return false;
}
...
ParseData(path, data);
...
}
Parser::ParseData(const std::string& filename, const std::string& data)根據關鍵字解析出服務和動作。動作與服務會分別放在了Action::ActionManager.actions_和Service::ServiceManager.services_中
void Parser::ParseData(const std::string& filename, const std::string& data) {
std::vector<char> data_copy(data.begin(), data.end());
data_copy.push_back('\0');
parse_state state;
...
SectionParser* section_parser = nullptr;
std::vector<std::string> args;
for (;;) {
//next_token以行為單位分割參數(shù)傳遞過來的字符串
//最先走到T_TEXT分支
switch (next_token(&state)) {
case T_EOF:
if (section_parser) {
//EOF,解析結束
section_parser->EndSection();
}
return;
case T_NEWLINE:
state.line++;
if (args.empty()) {
break;
}
//在init.cpp::main()創(chuàng)建parser時，為service，on，import定義了對應的parser
//這里就是根據第一個參數(shù)，判斷是否有對應的parser
if (section_parsers_.count(args[0])) {
if (section_parser) {
//結束上一個parser的工作，將構造出的對象加入到對應的service_list與action_list中
section_parser->EndSection();
}
//獲取參數(shù)對應的parser
section_parser = section_parsers_[args[0]].get();
std::string ret_err;
//調用實際parser的ParseSection函數(shù)
if (!section_parser->ParseSection(args, &ret_err)) {
parse_error(&state, "%s\n", ret_err.c_str());
section_parser = nullptr;
}
} else if (section_parser) {
//如果第一個參數(shù)不是service，on，import
//則調用前一個parser的ParseLineSection函數(shù)
//這里相當于解析一個參數(shù)塊的子項
std::string ret_err;
if (!section_parser->ParseLineSection(args, state.filename,state.line, &ret_err)) {
parse_error(&state, "%s\n", ret_err.c_str());
}
}
args.clear();
break;
case T_TEXT:
//將本次解析的內容寫入到args中
args.emplace_back(state.text);
break;
}
}
}
2.1.2 解析Service
system/core/init/service.cpp
從上面代碼可知解析init.rc時section_parser->ParseSection(args, &ret_err)來接解析，在之前為每種section都設置了解析函數(shù)，service對應的解析函數(shù)就service.cpp::ServiceParser::ParseSection(onst std::vector<std::string>& args, std::string* err)
bool ServiceParser::ParseSection(const std::vector<std::string>& args,std::string* err) {
...
const std::string& name = args[1];
...
//service section 對應為"service ueventd /sbin/ueventd...",下面就是講name后的參數(shù)全部放在一個vector中
std::vector<std::string> str_args(args.begin() + 2, args.end());
//構造一個service對象
service_ = std::make_unique<Service>(name, "default", str_args);
return true;
}
在解析將一個section解析結束后會調用ServiceParser::EndSection()
void ServiceParser::EndSection() {
if (service_) {
ServiceManager::GetInstance().AddService(std::move(service_));
}
}
//
void ServiceManager::AddService(std::unique_ptr<Service> service) {
Service* old_service = FindServiceByName(service->name());
if (old_service) {
return;
}
//添加到services_中 （`ServicePaser::ServiceManager`中的一個vector）
services_.emplace_back(std::move(service));
}
2.1.3 解析action
ActionParser定義于system/core/init/action.cpp中。Action的解析過程，其實與Service差不多
//解析 on <trigger>
bool ActionParser::ParseSection(const std::vector<std::string>& args, std::string* err) {
std::vector<std::string> triggers(args.begin() + 1, args.end());
...
auto action = std::make_unique<Action>(false);
//根據參數(shù)，填充action的trigger域
if (!action->InitTriggers(triggers, err)) {
return false;
}
action_ = std::move(action);
return true;
}
//解析 <command>
bool ActionParser::ParseLineSection(const std::vector<std::string>& args, const std::string& filename, int line, std::string* err) const {
return action_ ? action_->AddCommand(args, filename, line, err) : false;
}
bool Action::AddCommand(const std::vector<std::string>& args,const std::string& filename, int line, std::string* err) {
...
//找出action對應的執(zhí)行函數(shù)
auto function = function_map_->FindFunction(args[0], args.size() - 1, err);
...
AddCommand(function, args, filename, line);
return true;
}
//構造出command，加入到action對象的commands_中
void Action::AddCommand(BuiltinFunction f,const std::vector<std::string>& args, const std::string& filename, int line) {
commands_.emplace_back(f, args, filename, line);
}
//完成一次action解析
void ActionParser::EndSection() {
if (action_ && action_->NumCommands() > 0) {
ActionManager::GetInstance().AddAction(std::move(action_));
}
}
2.1.4 init控制service
啟動zygote
在action為 on late-init中會執(zhí)行 triger boot,on boot下有個class_start core 的commond，對應的處理函數(shù)式Builtins::do_class_start(const std::vector<std::string>& args)
system/core/init/Builtins.cpp
static int do_class_start(const std::vector<std::string>& args) {
/* Starting a class does not start services
* which are explicitly disabled. They must
* be started individually.
*/
//傳遞一個匿名函數(shù)，在找到對應的service后執(zhí)行StartIfNotDisabled()
ServiceManager::GetInstance().ForEachServiceInClass(args[1], [] (Service* s) { s->StartIfNotDisabled(); });
return 0;
}
//init.${zygote}.rc中 zygote class main
//以下在/system/core/init/service.cpp中
void ServiceManager::ForEachServiceInClass(const std::string& classname, void (*func)(Service* svc)) const {
for (const auto& s : services_) {
if (classname == s->classname()) {
func(s.get());
}
}
}
bool Service::StartIfNotDisabled() {
if (!(flags_ & SVC_DISABLED)) {
return Start();
} else {
flags_ |= SVC_DISABLED_START;
}
return true;
}
bool Service::Start() {
...
//已經在運行了，不處理
if (flags_ & SVC_RUNNING) {
return false;
}
...
//判斷可執(zhí)行文件是否存在
//zygote對應的可執(zhí)行文件是/system/bin/app_process
if (stat(args_[0].c_str(), &sb) == -1) {
flags_ |= SVC_DISABLED;
return false;
}
...
//fork 子進程
if (namespace_flags_) {
...
} else {
pid = fork();
}
if (pid == 0) {
//pid為零，我們在子進程中
//添加環(huán)境變量信息
for (const auto& ei : envvars_) {
add_environment(ei.name.c_str(), ei.value.c_str());
}
//創(chuàng)建sokcet
CreateSockets(scon);
//設置一些參數(shù)，uid,gid,寫入文件等
...
/*執(zhí)行/system/bin/app_process，這樣就進入到app_process的main函數(shù)中了。fork、execve這兩個函數(shù)都是Linux系統(tǒng)上常用的系統(tǒng)調用。*/
if (execve(strs[0], (char**) &strs[0], (char**) ENV) < 0) {
...
}
}
//父進程init的處理，設置service信息，如啟動時間進程號，以及狀態(tài)等
...
}
fork,execve拓展閱讀
linux c語言 fork() 和 exec 函數(shù)的簡介和用法
Linux下Fork與Exec使用
重啟zygote
2.1.5 注冊子進程信號處理器
signal_handler_init()次函數(shù)在解析init.rc前先被調用。
system/core/init/Signal_Handler.cpp
void signal_handler_init() {
// Create a signalling mechanism for SIGCHLD.
int s[2];
//通過socketpair創(chuàng)建兩個socket，分別負責讀寫
if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0, s) == -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"的消息的函數(shù)
act.sa_handler = SIGCHLD_handler;
act.sa_flags = SA_NOCLDSTOP;
//信號注冊，將監(jiān)聽及對應的信號處理注冊到內核
sigaction(SIGCHLD, &act, 0);
ServiceManager::GetInstance().ReapAnyOutstandingChildren();
register_epoll_handler(signal_read_fd, handle_signal);
}
sigaction注冊到內核，監(jiān)聽SIGCHLD信號，交由SIGCHLD_handler處理，SIGCHLD_handler通過signal_wirte_fd寫入信息
//[system/core/init/Signal_Handler.cpp]
static void SIGCHLD_handler(int) {
if (TEMP_FAILURE_RETRY(write(signal_write_fd, "1", 1)) == -1)
...
}
sinal_read_fd和signal_wirte_fd是一組，所以sinal_read_fd能接收到write的信息，在signal_handler_init的最后調用了register_epoll_handler(signal_read_fd, handle_signal)來注冊處理signal_read_fd的處理函數(shù)，為handle_signal()
//[system/core/init/init.cpp]
void register_epoll_handler(int fd, void (*fn)()) {
epoll_event ev;
ev.events = EPOLLIN;
ev.data.ptr = reinterpret_cast<void*>(fn);
//epoll_fd增加一個監(jiān)聽對象fd,fd上有數(shù)據到來時，調用fn處理
if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev) == -1)
...
}
//[system/core/init/Signal_handler.cpp]
static void handle_signal() {
// Clear outstanding requests.
char buf[32];
read(signal_read_fd, buf, sizeof(buf));
//調用ReapAnyOutstandingChildren做真正的子線程處理
ServiceManager::GetInstance().ReapAnyOutstandingChildren();
}
20160807170210926.png
//[system/core/init/service.cpp]
void ServiceManager::ReapAnyOutstandingChildren() {
while (ReapOneProcess()) {
}
}
bool ServiceManager::ReapOneProcess() {
int status;
//用waitpid函數(shù)獲取狀態(tài)發(fā)生變化的子進程pid
//waitpid的標記為WNOHANG，即非阻塞，返回為正值就說明有進程掛掉了
pid_t pid = TEMP_FAILURE_RETRY(waitpid(-1, &status, WNOHANG));
if (pid == 0) return false;
else if (pid == -1) return false;
...
//利用FindServiceByPid函數(shù)，找到pid對應的服務。
Service* svc = FindServiceByPid(pid);
//調用Reap()處理，判斷service是否需要移除
if (svc->Reap()) {
waiting_for_exec = false;
//移除服務
RemoveService(*svc);
}
return true;
}
bool Service::Reap() {
//清理未攜帶SVC_ONESHOT 或 攜帶了SVC_RESTART標志的子進程
if (!(flags_ & SVC_ONESHOT) || (flags_ & SVC_RESTART){
KillProcessGroup(SIGKILL);
}
// Remove any sockets we may have created.
//移除service中創(chuàng)建的socket
for (const auto& si : sockets_) {
unlink(tmp.c_str());
}
...
pid_ = 0;
flags_ &= (~SVC_RUNNING);
// Oneshot processes go into the disabled state on exit,
// except when manually restarted.
//對于攜帶了SVC_ONESHOT并且未攜帶SVC_RESTART的service，將這類服務的標志置為SVC_DISABLED，不再啟動
if ((flags_ & SVC_ONESHOT) && !(flags_ & SVC_RESTART)) {
flags_ |= SVC_DISABLED;
}
// Disabled and reset processes do not get restarted automatically.
if (flags_ & (SVC_DISABLED | SVC_RESET)) {
NotifyStateChange("stopped");
return false;
}
time_t now = gettime();
//未攜帶SVC_RESTART的SVG_CRITICAL（重要的）服務，在規(guī)定的間隔內，crash字數(shù)過多時，會導致整機重啟；
if ((flags_ & SVC_CRITICAL) && !(flags_ & SVC_RESTART)) {
if (time_crashed_ + CRITICAL_CRASH_WINDOW >= now) {
if (++nr_crashed_ > CRITICAL_CRASH_THRESHOLD) {
android_reboot(ANDROID_RB_RESTART2, 0, "recovery");
return false;
}
} else {
time_crashed_ = now;
nr_crashed_ = 1;
}
}
//將待重啟service的標志位置為SVC_RESTARTING（init進程將根據該標志位，重啟服務）
flags_ &= (~SVC_RESTART);
flags_ |= SVC_RESTARTING;
// Execute all onrestart commands for this service.
//執(zhí)行在init.rc文件中service下面所有onrestart選項
onrestart_.ExecuteAllCommands();
NotifyStateChange("restarting");
return false;
}
被標記為SVC_RESTARTING的service將在init中的restart_processes()中重啟，所以zygote能在此被重啟
流程可簡化為：
20160807172447044.png
2.1.6 總結
整體流程和《深入理解Android卷I》是一樣的，只是更好的面向對象去處理,封裝更好。還有就是I/O方式變了，epoll更加靈活，沒有描述符限制,更多可參考
IO多路復用之epoll總結
Linux IO模式及 select、poll、epoll詳解
2.2 屬性服務
2.2.1 初始化
在Init.cpp的main函數(shù)中執(zhí)行了property_init()進行初始化
//[system/core/init/Property_service.cpp]
void property_init() {
if (__system_property_area_init()) {
exit(1);
}
}
//[bionic/libc/inlcude/System_properties.cpp]
int __system_property_area_init()
{
free_and_unmap_contexts();
mkdir(property_filename, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
if (!initialize_properties()) {
return -1;
}
...
//分配內存
if (open_failed || !map_system_property_area(true, &fsetxattr_failed)) {
...
}
initialized = true;
return fsetxattr_failed ? -2 : 0;
}
//[bionic/libc/inlcude/System_properties.cpp]
static bool map_system_property_area(bool access_rw, bool* fsetxattr_failed) {
...
if (access_rw) {
//這里才是真正分配內存的地方，大小為 [128 * 1024]
//prop_area也改為了class
__system_property_area__ = map_prop_area_rw(filename, "u:object_r:properties_serial:s0", fsetxattr_failed);
}
...
return __system_property_area__;
}
在書中說將pa賦值__system_property_area__是為了完成內存共享，這7.0這部分改動很大，有點看不明白，大致流程和卷一的流程是一樣的。網上這部分的資料也沒找到，還有就是property_init()是在!is_first_stage情況下執(zhí)行的,那么property_load_boot_defaults()第一次執(zhí)行加載的放在哪里？希望有前輩指教。
不過好像也不影響我們理解:創(chuàng)建一個文件句柄，分配一個匿名共享內存區(qū)用于存放屬性.
2.2.2 啟動屬性服務
在執(zhí)行property_load_boot_defaults()，Init.cpp::main中接著執(zhí)行了start_property_service()
//[system/core/init/Property_service.cpp]
void start_property_service() {
//創(chuàng)建socket
property_set_fd = create_socket(PROP_SERVICE_NAME, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,0666, 0, 0, NULL);
...
listen(property_set_fd, 8);
//注冊處理函數(shù)
register_epoll_handler(property_set_fd, handle_property_set_fd);
}
在Init::main()在的最后又這么一段斷碼,通過取出注冊的處理函數(shù)，然后處理消息。
epoll_event ev;
int nr = TEMP_FAILURE_RETRY(epoll_wait(epoll_fd, &ev, 1, timeout));
...
else if (nr == 1) {
((void (*)()) ev.data.ptr)();
}
所以響應設置屬性的請求就在handle_property_set_fd()中執(zhí)行。
2.2.3 處理屬性設置
//[system/core/init/Property_service.cpp]
static void handle_property_set_fd()
{
...
//接受連接
int s = accept(property_set_fd, nullptr, nullptr);
...
//取出客戶端進程的權限等
if (getsockopt(s, SOL_SOCKET, SO_PEERCRED, &cr, &cr_size) < 0)
...
//接受請求數(shù)據
r = TEMP_FAILURE_RETRY(recv(s, &msg, sizeof(msg), MSG_DONTWAIT));
switch(msg.cmd) {
case PROP_MSG_SETPROP:
msg.name[PROP_NAME_MAX-1] = 0;
msg.value[PROP_VALUE_MAX-1] = 0;
...
//如果是ctl開頭的消息，則認為是控制消息，控制消息用來執(zhí)行一些命令，例如用adb shell登錄后，輸入setprop ctl.start bootanim就可以查看開機動畫了，關閉的話就輸入setpropctl.stop bootanim
if(memcmp(msg.name,"ctl.",4) == 0) {
// Keep the old close-socket-early behavior when handling
// ctl.* properties.
close(s);
if (check_control_mac_perms(msg.value, source_ctx, &cr)) {
handle_control_message((char*) msg.name + 4, (char*) msg.value);
}
...
}else {
//檢查客戶端進程是否有足夠的權限
if (check_mac_perms(msg.name, source_ctx, &cr)) {
//設置屬性
property_set((char*) msg.name, (char*) msg.value);
}
...
}
...
}
//設置
int property_set(const char* name, const char* value) {
int rc = property_set_impl(name, value);
...
return rc;
}
static int property_set_impl(const char* name, const char* value) {
//更具不同的屬性名稱進行各種處理
...
//這個函數(shù)將觸發(fā) init.rc中的trigger 以執(zhí)行command
/*
on property:persist.service.adb.enable=1
start adb
當persist.service.adb.enable屬性置為1后，就會執(zhí)行start adbd這個command，這是通過property_changed函數(shù)來完成的
*/
property_changed(name, value);
return 0;
}
2.2.4 客戶端發(fā)送設置請求
客戶端通過property_set發(fā)送請求，property_set由libcutils庫提供
//[system/core/libcutils/Properties.c]
int property_set(const char *key, const char *value)
{
return __system_property_set(key, value);
}
//[bionic/libc/System_properties.cpp]
int __system_property_set(const char *key, const char *value)
{
...
const int err = send_prop_msg(&msg);
...
}
//[bionic/libc/System_properties.cpp]
static int send_prop_msg(const prop_msg *msg){
...
sockaddr_un addr;
memset(&addr, 0, sizeof(addr));
strlcpy(addr.sun_path, property_service_socket, sizeof(addr.sun_path));
addr.sun_family = AF_LOCAL;
socklen_t alen = namelen + offsetof(sockaddr_un, sun_path) + 1;
//建立和屬性服務器的socket連接
if (TEMP_FAILURE_RETRY(connect(fd, reinterpret_cast<sockaddr*>(&addr), alen)) < 0) {
close(fd);
return -1;
}
//通過socket發(fā)送出去
const int num_bytes = TEMP_FAILURE_RETRY(send(fd, msg, sizeof(prop_msg), 0));
}
3 總結
總體來說流程和原書是一致的，只是在實現(xiàn)采用了面向對象，通信方式也采用了更加高效的方式，加入了SELinux的東西，對屬性初始化那一部分還有點迷惑。但是更具原書的流程走，也不是很費力。其中的一些細節(jié)，后面再去填坑。
感謝以下博文的幫助：
Android系統(tǒng)啟動-init篇
Android7.0 init進程源碼分析
Android的init進程啟動過程
