1 /*
2 * Copyright (C) 2007-2016 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 "logd_reader.h"
18
19 #include <errno.h>
20 #include <fcntl.h>
21 #include <inttypes.h>
22 #include <poll.h>
23 #include <stdarg.h>
24 #include <stdatomic.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <sys/param.h>
29 #include <sys/socket.h>
30 #include <sys/stat.h>
31 #include <sys/types.h>
32 #include <sys/un.h>
33 #include <time.h>
34 #include <unistd.h>
35
36 #include <string>
37
38 #include <android-base/parseint.h>
39 #include <private/android_logger.h>
40
41 #include "logger.h"
42
43 // Connects to /dev/socket/<name> and returns the associated fd or returns -1 on error.
44 // O_CLOEXEC is always set.
socket_local_client(const std::string & name,int type,bool timeout)45 static int socket_local_client(const std::string& name, int type, bool timeout) {
46 sockaddr_un addr = {.sun_family = AF_LOCAL};
47
48 std::string path = "/dev/socket/" + name;
49 if (path.size() + 1 > sizeof(addr.sun_path)) {
50 return -1;
51 }
52 strlcpy(addr.sun_path, path.c_str(), sizeof(addr.sun_path));
53
54 int fd = socket(AF_LOCAL, type | SOCK_CLOEXEC, 0);
55 if (fd == -1) {
56 return -1;
57 }
58
59 if (timeout) {
60 // Sending and receiving messages should be instantaneous, but we don't want to wait forever if
61 // logd is hung, so we set a gracious 2s timeout.
62 struct timeval t = {2, 0};
63 if (setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &t, sizeof(t)) == -1) {
64 return -1;
65 }
66 if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &t, sizeof(t)) == -1) {
67 return -1;
68 }
69 }
70
71 if (connect(fd, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) == -1) {
72 close(fd);
73 return -1;
74 }
75
76 return fd;
77 }
78
79 /* worker for sending the command to the logger */
SendLogdControlMessage(char * buf,size_t buf_size)80 ssize_t SendLogdControlMessage(char* buf, size_t buf_size) {
81 ssize_t ret;
82 size_t len;
83 char* cp;
84 int errno_save = 0;
85 int sock = socket_local_client("logd", SOCK_STREAM, true);
86 if (sock < 0) {
87 return sock;
88 }
89
90 len = strlen(buf) + 1;
91 ret = TEMP_FAILURE_RETRY(write(sock, buf, len));
92 if (ret <= 0) {
93 goto done;
94 }
95
96 len = buf_size;
97 cp = buf;
98 while ((ret = TEMP_FAILURE_RETRY(read(sock, cp, len))) > 0) {
99 if (((size_t)ret == len) || (buf_size < PAGE_SIZE)) {
100 break;
101 }
102
103 len -= ret;
104 cp += ret;
105
106 // Give other side 20ms to refill pipe.
107 struct pollfd p = {.fd = sock, .events = POLLIN};
108 ret = TEMP_FAILURE_RETRY(poll(&p, 1, 20));
109
110 if (ret <= 0) {
111 break;
112 }
113
114 if (!(p.revents & POLLIN)) {
115 ret = 0;
116 break;
117 }
118 }
119
120 if (ret >= 0) {
121 ret += buf_size - len;
122 }
123
124 done:
125 if ((ret == -1) && errno) {
126 errno_save = errno;
127 }
128 close(sock);
129 if (errno_save) {
130 errno = errno_save;
131 }
132 return ret;
133 }
134
check_log_success(char * buf,ssize_t ret)135 static int check_log_success(char* buf, ssize_t ret) {
136 if (ret < 0) {
137 return ret;
138 }
139
140 if (strncmp(buf, "success", 7)) {
141 errno = EINVAL;
142 return -1;
143 }
144
145 return 0;
146 }
147
android_logger_clear(struct logger * logger)148 int android_logger_clear(struct logger* logger) {
149 if (!android_logger_is_logd(logger)) {
150 return -EINVAL;
151 }
152 uint32_t log_id = android_logger_get_id(logger);
153 char buf[512];
154 snprintf(buf, sizeof(buf), "clear %" PRIu32, log_id);
155
156 return check_log_success(buf, SendLogdControlMessage(buf, sizeof(buf)));
157 }
158
159 enum class LogSizeType : uint32_t {
160 kAllotted = 0,
161 kReadable,
162 kConsumed,
163 };
164
GetLogSize(struct logger * logger,LogSizeType type)165 static long GetLogSize(struct logger* logger, LogSizeType type) {
166 if (!android_logger_is_logd(logger)) {
167 return -EINVAL;
168 }
169
170 uint32_t log_id = android_logger_get_id(logger);
171 char buf[512];
172 switch (type) {
173 case LogSizeType::kAllotted:
174 snprintf(buf, sizeof(buf), "getLogSize %" PRIu32, log_id);
175 break;
176 case LogSizeType::kReadable:
177 snprintf(buf, sizeof(buf), "getLogSizeReadable %" PRIu32, log_id);
178 break;
179 case LogSizeType::kConsumed:
180 snprintf(buf, sizeof(buf), "getLogSizeUsed %" PRIu32, log_id);
181 break;
182 default:
183 abort();
184 }
185
186 ssize_t ret = SendLogdControlMessage(buf, sizeof(buf));
187 if (ret < 0) {
188 return ret;
189 }
190
191 long size;
192 if (!android::base::ParseInt(buf, &size)) {
193 return -1;
194 }
195
196 return size;
197 }
198
android_logger_get_log_size(struct logger * logger)199 long android_logger_get_log_size(struct logger* logger) {
200 return GetLogSize(logger, LogSizeType::kAllotted);
201 }
202
android_logger_get_log_readable_size(struct logger * logger)203 long android_logger_get_log_readable_size(struct logger* logger) {
204 return GetLogSize(logger, LogSizeType::kReadable);
205 }
206
android_logger_get_log_consumed_size(struct logger * logger)207 long android_logger_get_log_consumed_size(struct logger* logger) {
208 return GetLogSize(logger, LogSizeType::kConsumed);
209 }
210
android_logger_set_log_size(struct logger * logger,unsigned long size)211 int android_logger_set_log_size(struct logger* logger, unsigned long size) {
212 if (!android_logger_is_logd(logger)) {
213 return -EINVAL;
214 }
215
216 uint32_t log_id = android_logger_get_id(logger);
217 char buf[512];
218 snprintf(buf, sizeof(buf), "setLogSize %" PRIu32 " %lu", log_id, size);
219
220 return check_log_success(buf, SendLogdControlMessage(buf, sizeof(buf)));
221 }
222
android_logger_get_log_version(struct logger *)223 int android_logger_get_log_version(struct logger*) {
224 return 4;
225 }
226
android_logger_get_statistics(struct logger_list * logger_list,char * buf,size_t len)227 ssize_t android_logger_get_statistics(struct logger_list* logger_list, char* buf, size_t len) {
228 if (logger_list->mode & ANDROID_LOG_PSTORE) {
229 return -EINVAL;
230 }
231
232 char* cp = buf;
233 size_t remaining = len;
234 size_t n;
235
236 n = snprintf(cp, remaining, "getStatistics");
237 n = MIN(n, remaining);
238 remaining -= n;
239 cp += n;
240
241 for (size_t log_id = 0; log_id < LOG_ID_MAX; ++log_id) {
242 if ((1 << log_id) & logger_list->log_mask) {
243 n = snprintf(cp, remaining, " %zu", log_id);
244 n = MIN(n, remaining);
245 remaining -= n;
246 cp += n;
247 }
248 }
249
250 if (logger_list->pid) {
251 snprintf(cp, remaining, " pid=%u", logger_list->pid);
252 }
253
254 return SendLogdControlMessage(buf, len);
255 }
android_logger_get_prune_list(struct logger_list * logger_list,char * buf,size_t len)256 ssize_t android_logger_get_prune_list(struct logger_list* logger_list, char* buf, size_t len) {
257 if (logger_list->mode & ANDROID_LOG_PSTORE) {
258 return -EINVAL;
259 }
260
261 snprintf(buf, len, "getPruneList");
262 return SendLogdControlMessage(buf, len);
263 }
264
android_logger_set_prune_list(struct logger_list * logger_list,const char * buf,size_t len)265 int android_logger_set_prune_list(struct logger_list* logger_list, const char* buf, size_t len) {
266 if (logger_list->mode & ANDROID_LOG_PSTORE) {
267 return -EINVAL;
268 }
269
270 std::string cmd = "setPruneList " + std::string{buf, len};
271
272 return check_log_success(cmd.data(), SendLogdControlMessage(cmd.data(), cmd.size()));
273 }
274
logdOpen(struct logger_list * logger_list)275 static int logdOpen(struct logger_list* logger_list) {
276 char buffer[256], *cp, c;
277 int ret, remaining, sock;
278
279 sock = atomic_load(&logger_list->fd);
280 if (sock > 0) {
281 return sock;
282 }
283
284 sock = socket_local_client("logdr", SOCK_SEQPACKET, false);
285 if (sock <= 0) {
286 if ((sock == -1) && errno) {
287 return -errno;
288 }
289 return sock;
290 }
291
292 strcpy(buffer, (logger_list->mode & ANDROID_LOG_NONBLOCK) ? "dumpAndClose" : "stream");
293 cp = buffer + strlen(buffer);
294
295 strcpy(cp, " lids");
296 cp += 5;
297 c = '=';
298 remaining = sizeof(buffer) - (cp - buffer);
299
300 for (size_t log_id = 0; log_id < LOG_ID_MAX; ++log_id) {
301 if ((1 << log_id) & logger_list->log_mask) {
302 ret = snprintf(cp, remaining, "%c%zu", c, log_id);
303 ret = MIN(ret, remaining);
304 remaining -= ret;
305 cp += ret;
306 c = ',';
307 }
308 }
309
310 if (logger_list->tail) {
311 ret = snprintf(cp, remaining, " tail=%u", logger_list->tail);
312 ret = MIN(ret, remaining);
313 remaining -= ret;
314 cp += ret;
315 }
316
317 if (logger_list->start.tv_sec || logger_list->start.tv_nsec) {
318 if (logger_list->mode & ANDROID_LOG_WRAP) {
319 // ToDo: alternate API to allow timeout to be adjusted.
320 ret = snprintf(cp, remaining, " timeout=%u", ANDROID_LOG_WRAP_DEFAULT_TIMEOUT);
321 ret = MIN(ret, remaining);
322 remaining -= ret;
323 cp += ret;
324 }
325 ret = snprintf(cp, remaining, " start=%" PRIu32 ".%09" PRIu32, logger_list->start.tv_sec,
326 logger_list->start.tv_nsec);
327 ret = MIN(ret, remaining);
328 remaining -= ret;
329 cp += ret;
330 }
331
332 if (logger_list->pid) {
333 ret = snprintf(cp, remaining, " pid=%u", logger_list->pid);
334 ret = MIN(ret, remaining);
335 cp += ret;
336 }
337
338 ret = TEMP_FAILURE_RETRY(write(sock, buffer, cp - buffer));
339 int write_errno = errno;
340
341 if (ret <= 0) {
342 close(sock);
343 if (ret == -1) {
344 return -write_errno;
345 }
346 if (ret == 0) {
347 return -EIO;
348 }
349 return ret;
350 }
351
352 ret = atomic_exchange(&logger_list->fd, sock);
353 if ((ret > 0) && (ret != sock)) {
354 close(ret);
355 }
356 return sock;
357 }
358
359 /* Read from the selected logs */
LogdRead(struct logger_list * logger_list,struct log_msg * log_msg)360 int LogdRead(struct logger_list* logger_list, struct log_msg* log_msg) {
361 int ret = logdOpen(logger_list);
362 if (ret < 0) {
363 return ret;
364 }
365
366 /* NOTE: SOCK_SEQPACKET guarantees we read exactly one full entry */
367 ret = TEMP_FAILURE_RETRY(recv(ret, log_msg, LOGGER_ENTRY_MAX_LEN, 0));
368 if ((logger_list->mode & ANDROID_LOG_NONBLOCK) && ret == 0) {
369 return -EAGAIN;
370 }
371
372 if (ret == -1) {
373 return -errno;
374 }
375 return ret;
376 }
377
378 /* Close all the logs */
LogdClose(struct logger_list * logger_list)379 void LogdClose(struct logger_list* logger_list) {
380 int sock = atomic_exchange(&logger_list->fd, -1);
381 if (sock > 0) {
382 close(sock);
383 }
384 }
385