1 /*
2 * Copyright (C) 2017 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
17 #include "uevent_listener.h"
18
19 #include <fcntl.h>
20 #include <poll.h>
21 #include <string.h>
22 #include <unistd.h>
23
24 #include <memory>
25
26 #include <android-base/logging.h>
27 #include <cutils/uevent.h>
28
29 namespace android {
30 namespace init {
31
ParseEvent(const char * msg,Uevent * uevent)32 static void ParseEvent(const char* msg, Uevent* uevent) {
33 uevent->partition_num = -1;
34 uevent->major = -1;
35 uevent->minor = -1;
36 uevent->action.clear();
37 uevent->path.clear();
38 uevent->subsystem.clear();
39 uevent->driver.clear();
40 uevent->firmware.clear();
41 uevent->partition_name.clear();
42 uevent->device_name.clear();
43 uevent->modalias.clear();
44 // currently ignoring SEQNUM
45 while (*msg) {
46 if (!strncmp(msg, "ACTION=", 7)) {
47 msg += 7;
48 uevent->action = msg;
49 } else if (!strncmp(msg, "DEVPATH=", 8)) {
50 msg += 8;
51 uevent->path = msg;
52 } else if (!strncmp(msg, "SUBSYSTEM=", 10)) {
53 msg += 10;
54 uevent->subsystem = msg;
55 } else if (!strncmp(msg, "DRIVER=", 7)) {
56 msg += 7;
57 uevent->driver = msg;
58 } else if (!strncmp(msg, "FIRMWARE=", 9)) {
59 msg += 9;
60 uevent->firmware = msg;
61 } else if (!strncmp(msg, "MAJOR=", 6)) {
62 msg += 6;
63 uevent->major = atoi(msg);
64 } else if (!strncmp(msg, "MINOR=", 6)) {
65 msg += 6;
66 uevent->minor = atoi(msg);
67 } else if (!strncmp(msg, "PARTN=", 6)) {
68 msg += 6;
69 uevent->partition_num = atoi(msg);
70 } else if (!strncmp(msg, "PARTNAME=", 9)) {
71 msg += 9;
72 uevent->partition_name = msg;
73 } else if (!strncmp(msg, "PARTUUID=", 9)) {
74 msg += 9;
75 uevent->partition_uuid = msg;
76 } else if (!strncmp(msg, "DEVNAME=", 8)) {
77 msg += 8;
78 uevent->device_name = msg;
79 } else if (!strncmp(msg, "MODALIAS=", 9)) {
80 msg += 9;
81 uevent->modalias = msg;
82 }
83
84 // advance to after the next \0
85 while (*msg++)
86 ;
87 }
88
89 if (LOG_UEVENTS) {
90 LOG(INFO) << "event { '" << uevent->action << "', '" << uevent->path << "', '"
91 << uevent->subsystem << "', '" << uevent->firmware << "', " << uevent->major
92 << ", " << uevent->minor << ", " << uevent->partition_uuid << " }";
93 }
94 }
95
UeventListener(size_t uevent_socket_rcvbuf_size)96 UeventListener::UeventListener(size_t uevent_socket_rcvbuf_size) {
97 device_fd_.reset(uevent_open_socket(uevent_socket_rcvbuf_size, true));
98 if (device_fd_ == -1) {
99 LOG(FATAL) << "Could not open uevent socket";
100 }
101
102 fcntl(device_fd_.get(), F_SETFL, O_NONBLOCK);
103 }
104
ReadUevent(Uevent * uevent) const105 ReadUeventResult UeventListener::ReadUevent(Uevent* uevent) const {
106 char msg[UEVENT_MSG_LEN + 2];
107 int n = uevent_kernel_multicast_recv(device_fd_.get(), msg, UEVENT_MSG_LEN);
108 if (n <= 0) {
109 if (errno != EAGAIN && errno != EWOULDBLOCK) {
110 PLOG(ERROR) << "Error reading from Uevent Fd";
111 }
112 return ReadUeventResult::kFailed;
113 }
114 if (n >= UEVENT_MSG_LEN) {
115 LOG(ERROR) << "Uevent overflowed buffer, discarding";
116 return ReadUeventResult::kInvalid;
117 }
118
119 msg[n] = '\0';
120 msg[n + 1] = '\0';
121
122 ParseEvent(msg, uevent);
123
124 return ReadUeventResult::kSuccess;
125 }
126
127 // RegenerateUevents*() walks parts of the /sys tree and pokes the uevent files to cause the kernel
128 // to regenerate device add uevents that have already happened. This is particularly useful when
129 // starting ueventd, to regenerate all of the uevents that it had previously missed.
130 //
131 // We drain any pending events from the netlink socket every time we poke another uevent file to
132 // make sure we don't overrun the socket's buffer.
133 //
134
RegenerateUeventsForDir(DIR * d,const ListenerCallback & callback) const135 ListenerAction UeventListener::RegenerateUeventsForDir(DIR* d,
136 const ListenerCallback& callback) const {
137 int dfd = dirfd(d);
138
139 int fd = openat(dfd, "uevent", O_WRONLY | O_CLOEXEC);
140 if (fd >= 0) {
141 write(fd, "add\n", 4);
142 close(fd);
143
144 Uevent uevent;
145 ReadUeventResult result;
146 while ((result = ReadUevent(&uevent)) != ReadUeventResult::kFailed) {
147 // Skip processing the uevent if it is invalid.
148 if (result == ReadUeventResult::kInvalid) continue;
149 if (callback(uevent) == ListenerAction::kStop) return ListenerAction::kStop;
150 }
151 }
152
153 dirent* de;
154 while ((de = readdir(d)) != nullptr) {
155 if (de->d_type != DT_DIR || de->d_name[0] == '.') continue;
156
157 fd = openat(dfd, de->d_name, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
158 if (fd < 0) continue;
159
160 std::unique_ptr<DIR, decltype(&closedir)> d2(fdopendir(fd), closedir);
161 if (d2 == 0) {
162 close(fd);
163 } else {
164 if (RegenerateUeventsForDir(d2.get(), callback) == ListenerAction::kStop) {
165 return ListenerAction::kStop;
166 }
167 }
168 }
169
170 // default is always to continue looking for uevents
171 return ListenerAction::kContinue;
172 }
173
RegenerateUeventsForPath(const std::string & path,const ListenerCallback & callback) const174 ListenerAction UeventListener::RegenerateUeventsForPath(const std::string& path,
175 const ListenerCallback& callback) const {
176 std::unique_ptr<DIR, decltype(&closedir)> d(opendir(path.c_str()), closedir);
177 if (!d) return ListenerAction::kContinue;
178
179 return RegenerateUeventsForDir(d.get(), callback);
180 }
181
182 static const char* kRegenerationPaths[] = {"/sys/devices"};
183
RegenerateUevents(const ListenerCallback & callback) const184 void UeventListener::RegenerateUevents(const ListenerCallback& callback) const {
185 for (const auto path : kRegenerationPaths) {
186 if (RegenerateUeventsForPath(path, callback) == ListenerAction::kStop) return;
187 }
188 }
189
Poll(const ListenerCallback & callback,const std::optional<std::chrono::milliseconds> relative_timeout) const190 void UeventListener::Poll(const ListenerCallback& callback,
191 const std::optional<std::chrono::milliseconds> relative_timeout) const {
192 using namespace std::chrono;
193
194 pollfd ufd = {
195 .events = POLLIN,
196 .fd = device_fd_.get(),
197 };
198
199 auto start_time = steady_clock::now();
200
201 while (true) {
202 ufd.revents = 0;
203
204 int timeout_ms = -1;
205 if (relative_timeout) {
206 auto now = steady_clock::now();
207 auto time_elapsed = duration_cast<milliseconds>(now - start_time);
208 if (time_elapsed > *relative_timeout) return;
209
210 auto remaining_timeout = *relative_timeout - time_elapsed;
211 timeout_ms = remaining_timeout.count();
212 }
213
214 int nr = poll(&ufd, 1, timeout_ms);
215 if (nr == 0) return;
216 if (nr < 0) {
217 PLOG(ERROR) << "poll() of uevent socket failed, continuing";
218 continue;
219 }
220 if (ufd.revents & POLLIN) {
221 // We're non-blocking, so if we receive a poll event keep processing until
222 // we have exhausted all uevent messages.
223 Uevent uevent;
224 ReadUeventResult result;
225 while ((result = ReadUevent(&uevent)) != ReadUeventResult::kFailed) {
226 // Skip processing the uevent if it is invalid.
227 if (result == ReadUeventResult::kInvalid) continue;
228 if (callback(uevent) == ListenerAction::kStop) return;
229 }
230 }
231 }
232 }
233
234 } // namespace init
235 } // namespace android
236