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