blob: 1435d82ef0d13203360171cf22660c088aca3d85 [file] [log] [blame]
Colin Crossf83d0b92010-04-21 12:04:20 -07001/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Tom Cherry3f5eaae52017-04-06 16:30:22 -070017#include "ueventd.h"
18
Colin Cross44b65d02010-04-20 14:32:50 -070019#include <ctype.h>
Elliott Hughesda40c002015-03-27 23:20:44 -070020#include <fcntl.h>
Brian Swetland8d48c8e2011-03-24 15:45:30 -070021#include <signal.h>
Elliott Hughesda40c002015-03-27 23:20:44 -070022#include <stdio.h>
23#include <stdlib.h>
24#include <string.h>
Tom Cherryc5833052017-05-16 15:35:41 -070025#include <sys/wait.h>
26
27#include <set>
28#include <thread>
Brian Swetland8d48c8e2011-03-24 15:45:30 -070029
Tom Cherryede0d532017-07-06 14:20:11 -070030#include <android-base/chrono_utils.h>
Tom Cherry3f5eaae52017-04-06 16:30:22 -070031#include <android-base/logging.h>
Tom Cherryccf23532017-03-28 16:40:41 -070032#include <android-base/properties.h>
Tom Cherryc5833052017-05-16 15:35:41 -070033#include <selinux/android.h>
Elliott Hughesda40c002015-03-27 23:20:44 -070034#include <selinux/selinux.h>
Colin Crossf83d0b92010-04-21 12:04:20 -070035
Colin Crossf83d0b92010-04-21 12:04:20 -070036#include "devices.h"
Tom Cherryed506f72017-05-25 15:58:59 -070037#include "firmware_handler.h"
Tom Cherry3f5eaae52017-04-06 16:30:22 -070038#include "log.h"
Tom Cherryc3692b32017-08-10 12:22:44 -070039#include "selinux.h"
Tom Cherryed506f72017-05-25 15:58:59 -070040#include "uevent_listener.h"
41#include "ueventd_parser.h"
Tom Cherry3f5eaae52017-04-06 16:30:22 -070042#include "util.h"
Vladimir Chtchetkine2b995432011-09-28 09:55:31 -070043
Tom Cherryc5833052017-05-16 15:35:41 -070044// At a high level, ueventd listens for uevent messages generated by the kernel through a netlink
45// socket. When ueventd receives such a message it handles it by taking appropriate actions,
46// which can typically be creating a device node in /dev, setting file permissions, setting selinux
47// labels, etc.
48// Ueventd also handles loading of firmware that the kernel requests, and creates symlinks for block
49// and character devices.
50
51// When ueventd starts, it regenerates uevents for all currently registered devices by traversing
52// /sys and writing 'add' to each 'uevent' file that it finds. This causes the kernel to generate
53// and resend uevent messages for all of the currently registered devices. This is done, because
54// ueventd would not have been running when these devices were registered and therefore was unable
55// to receive their uevent messages and handle them appropriately. This process is known as
56// 'cold boot'.
57
58// 'init' currently waits synchronously on the cold boot process of ueventd before it continues
59// its boot process. For this reason, cold boot should be as quick as possible. One way to achieve
60// a speed up here is to parallelize the handling of ueventd messages, which consume the bulk of the
61// time during cold boot.
62
63// Handling of uevent messages has two unique properties:
64// 1) It can be done in isolation; it doesn't need to read or write any status once it is started.
65// 2) It uses setegid() and setfscreatecon() so either care (aka locking) must be taken to ensure
66// that no file system operations are done while the uevent process has an abnormal egid or
67// fscreatecon or this handling must happen in a separate process.
68// Given the above two properties, it is best to fork() subprocesses to handle the uevents. This
69// reduces the overhead and complexity that would be required in a solution with threads and locks.
70// In testing, a racy multithreaded solution has the same performance as the fork() solution, so
71// there is no reason to deal with the complexity of the former.
72
73// One other important caveat during the boot process is the handling of SELinux restorecon.
74// Since many devices have child devices, calling selinux_android_restorecon() recursively for each
75// device when its uevent is handled, results in multiple restorecon operations being done on a
76// given file. It is more efficient to simply do restorecon recursively on /sys during cold boot,
77// than to do restorecon on each device as its uevent is handled. This only applies to cold boot;
78// once that has completed, restorecon is done for each device as its uevent is handled.
79
80// With all of the above considered, the cold boot process has the below steps:
81// 1) ueventd regenerates uevents by doing the /sys traversal and listens to the netlink socket for
82// the generated uevents. It writes these uevents into a queue represented by a vector.
83//
84// 2) ueventd forks 'n' separate uevent handler subprocesses and has each of them to handle the
85// uevents in the queue based on a starting offset (their process number) and a stride (the total
86// number of processes). Note that no IPC happens at this point and only const functions from
87// DeviceHandler should be called from this context.
88//
89// 3) In parallel to the subprocesses handling the uevents, the main thread of ueventd calls
90// selinux_android_restorecon() recursively on /sys/class, /sys/block, and /sys/devices.
91//
92// 4) Once the restorecon operation finishes, the main thread calls waitpid() to wait for all
93// subprocess handlers to complete and exit. Once this happens, it marks coldboot as having
94// completed.
95//
96// At this point, ueventd is single threaded, poll()'s and then handles any future uevents.
97
98// Lastly, it should be noted that uevents that occur during the coldboot process are handled
99// without issue after the coldboot process completes. This is because the uevent listener is
100// paused while the uevent handler and restorecon actions take place. Once coldboot completes,
101// the uevent listener resumes in polling mode and will handle the uevents that occurred during
102// coldboot.
103
Tom Cherry81f5d3e2017-06-22 12:53:17 -0700104namespace android {
105namespace init {
106
Tom Cherryc5833052017-05-16 15:35:41 -0700107class ColdBoot {
108 public:
109 ColdBoot(UeventListener& uevent_listener, DeviceHandler& device_handler)
110 : uevent_listener_(uevent_listener),
111 device_handler_(device_handler),
112 num_handler_subprocesses_(std::thread::hardware_concurrency() ?: 4) {}
113
114 void Run();
115
116 private:
117 void UeventHandlerMain(unsigned int process_num, unsigned int total_processes);
118 void RegenerateUevents();
119 void ForkSubProcesses();
120 void DoRestoreCon();
121 void WaitForSubProcesses();
122
123 UeventListener& uevent_listener_;
124 DeviceHandler& device_handler_;
125
126 unsigned int num_handler_subprocesses_;
127 std::vector<Uevent> uevent_queue_;
128
129 std::set<pid_t> subprocess_pids_;
130};
131
132void ColdBoot::UeventHandlerMain(unsigned int process_num, unsigned int total_processes) {
133 for (unsigned int i = process_num; i < uevent_queue_.size(); i += total_processes) {
134 auto& uevent = uevent_queue_[i];
Sandeep Patilcd2ba0d2017-06-21 12:46:41 -0700135 device_handler_.HandleDeviceEvent(uevent);
Tom Cherryc5833052017-05-16 15:35:41 -0700136 }
137 _exit(EXIT_SUCCESS);
138}
139
140void ColdBoot::RegenerateUevents() {
141 uevent_listener_.RegenerateUevents([this](const Uevent& uevent) {
142 HandleFirmwareEvent(uevent);
143
Tom Cherryc5833052017-05-16 15:35:41 -0700144 uevent_queue_.emplace_back(std::move(uevent));
Sandeep Patil4cbedee2017-06-21 13:02:57 -0700145 return ListenerAction::kContinue;
Tom Cherryc5833052017-05-16 15:35:41 -0700146 });
147}
148
149void ColdBoot::ForkSubProcesses() {
150 for (unsigned int i = 0; i < num_handler_subprocesses_; ++i) {
151 auto pid = fork();
152 if (pid < 0) {
153 PLOG(FATAL) << "fork() failed!";
154 }
155
156 if (pid == 0) {
157 UeventHandlerMain(i, num_handler_subprocesses_);
158 }
159
160 subprocess_pids_.emplace(pid);
161 }
162}
163
164void ColdBoot::DoRestoreCon() {
Tom Cherryd2fd54e2017-06-07 14:32:30 -0700165 selinux_android_restorecon("/sys", SELINUX_ANDROID_RESTORECON_RECURSE);
Tom Cherryc5833052017-05-16 15:35:41 -0700166 device_handler_.set_skip_restorecon(false);
167}
168
169void ColdBoot::WaitForSubProcesses() {
170 // Treat subprocesses that crash or get stuck the same as if ueventd itself has crashed or gets
171 // stuck.
172 //
173 // When a subprocess crashes, we fatally abort from ueventd. init will restart ueventd when
174 // init reaps it, and the cold boot process will start again. If this continues to fail, then
175 // since ueventd is marked as a critical service, init will reboot to recovery.
176 //
177 // When a subprocess gets stuck, keep ueventd spinning waiting for it. init has a timeout for
178 // cold boot and will reboot to the bootloader if ueventd does not complete in time.
179 while (!subprocess_pids_.empty()) {
180 int status;
181 pid_t pid = TEMP_FAILURE_RETRY(waitpid(-1, &status, 0));
182 if (pid == -1) {
183 PLOG(ERROR) << "waitpid() failed";
184 continue;
185 }
186
187 auto it = std::find(subprocess_pids_.begin(), subprocess_pids_.end(), pid);
188 if (it == subprocess_pids_.end()) continue;
189
190 if (WIFEXITED(status)) {
191 if (WEXITSTATUS(status) == EXIT_SUCCESS) {
192 subprocess_pids_.erase(it);
193 } else {
194 LOG(FATAL) << "subprocess exited with status " << WEXITSTATUS(status);
195 }
196 } else if (WIFSIGNALED(status)) {
197 LOG(FATAL) << "subprocess killed by signal " << WTERMSIG(status);
198 }
199 }
200}
201
202void ColdBoot::Run() {
Tom Cherryede0d532017-07-06 14:20:11 -0700203 android::base::Timer cold_boot_timer;
Tom Cherryc5833052017-05-16 15:35:41 -0700204
205 RegenerateUevents();
206
207 ForkSubProcesses();
208
209 DoRestoreCon();
210
211 WaitForSubProcesses();
212
213 close(open(COLDBOOT_DONE, O_WRONLY | O_CREAT | O_CLOEXEC, 0000));
Tom Cherryede0d532017-07-06 14:20:11 -0700214 LOG(INFO) << "Coldboot took " << cold_boot_timer.duration().count() / 1000.0f << " seconds";
Tom Cherryc5833052017-05-16 15:35:41 -0700215}
216
Tom Cherryed506f72017-05-25 15:58:59 -0700217DeviceHandler CreateDeviceHandler() {
218 Parser parser;
219
220 std::vector<Subsystem> subsystems;
221 parser.AddSectionParser("subsystem", std::make_unique<SubsystemParser>(&subsystems));
222
223 using namespace std::placeholders;
224 std::vector<SysfsPermissions> sysfs_permissions;
225 std::vector<Permissions> dev_permissions;
Tom Cherryb592dd82017-08-02 17:01:36 -0700226 parser.AddSingleLineParser("/sys/",
227 std::bind(ParsePermissionsLine, _1, &sysfs_permissions, nullptr));
Tom Cherryed506f72017-05-25 15:58:59 -0700228 parser.AddSingleLineParser("/dev/",
Tom Cherryb592dd82017-08-02 17:01:36 -0700229 std::bind(ParsePermissionsLine, _1, nullptr, &dev_permissions));
Tom Cherryed506f72017-05-25 15:58:59 -0700230
231 parser.ParseConfig("/ueventd.rc");
232 parser.ParseConfig("/vendor/ueventd.rc");
233 parser.ParseConfig("/odm/ueventd.rc");
234
235 /*
236 * keep the current product name base configuration so
237 * we remain backwards compatible and allow it to override
238 * everything
239 * TODO: cleanup platform ueventd.rc to remove vendor specific
240 * device node entries (b/34968103)
241 */
242 std::string hardware = android::base::GetProperty("ro.hardware", "");
243 parser.ParseConfig("/ueventd." + hardware + ".rc");
244
245 return DeviceHandler(std::move(dev_permissions), std::move(sysfs_permissions),
Tom Cherryc5833052017-05-16 15:35:41 -0700246 std::move(subsystems), true);
Tom Cherryed506f72017-05-25 15:58:59 -0700247}
248
Tom Cherryc5833052017-05-16 15:35:41 -0700249int ueventd_main(int argc, char** argv) {
Nick Kralevich6ebf12f2012-03-26 09:09:11 -0700250 /*
251 * init sets the umask to 077 for forked processes. We need to
252 * create files with exact permissions, without modification by
253 * the umask.
254 */
255 umask(000);
256
Elliott Hughesf86b5a62016-06-24 15:12:21 -0700257 InitKernelLogging(argv);
Colin Crossf83d0b92010-04-21 12:04:20 -0700258
Elliott Hughesf86b5a62016-06-24 15:12:21 -0700259 LOG(INFO) << "ueventd started!";
Elliott Hughesda40c002015-03-27 23:20:44 -0700260
Tom Cherryc3692b32017-08-10 12:22:44 -0700261 SelinuxSetupKernelLogging();
262 SelabelInitialize();
Stephen Smalley439224e2014-06-24 13:45:43 -0400263
Tom Cherryed506f72017-05-25 15:58:59 -0700264 DeviceHandler device_handler = CreateDeviceHandler();
265 UeventListener uevent_listener;
Sandeep Patilbf298e62017-02-03 07:18:36 -0800266
Tom Cherryed506f72017-05-25 15:58:59 -0700267 if (access(COLDBOOT_DONE, F_OK) != 0) {
Tom Cherryc5833052017-05-16 15:35:41 -0700268 ColdBoot cold_boot(uevent_listener, device_handler);
269 cold_boot.Run();
Colin Crossf83d0b92010-04-21 12:04:20 -0700270 }
Elliott Hughes21457792015-02-04 10:19:50 -0800271
Tom Cherry0f296e02017-06-30 12:58:39 -0700272 // We use waitpid() in ColdBoot, so we can't ignore SIGCHLD until now.
273 signal(SIGCHLD, SIG_IGN);
274 // Reap and pending children that exited between the last call to waitpid() and setting SIG_IGN
275 // for SIGCHLD above.
276 while (waitpid(-1, nullptr, WNOHANG) > 0) {
277 }
278
Sandeep Patil4cbedee2017-06-21 13:02:57 -0700279 uevent_listener.Poll([&device_handler](const Uevent& uevent) {
Tom Cherryed506f72017-05-25 15:58:59 -0700280 HandleFirmwareEvent(uevent);
281 device_handler.HandleDeviceEvent(uevent);
Sandeep Patil4cbedee2017-06-21 13:02:57 -0700282 return ListenerAction::kContinue;
Tom Cherryed506f72017-05-25 15:58:59 -0700283 });
284
Elliott Hughes21457792015-02-04 10:19:50 -0800285 return 0;
Colin Crossf83d0b92010-04-21 12:04:20 -0700286}
Tom Cherry81f5d3e2017-06-22 12:53:17 -0700287
288} // namespace init
289} // namespace android