Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2012-2013 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 <dirent.h> |
| 18 | #include <errno.h> |
| 19 | #include <fcntl.h> |
Tom Cherry | 0b2a011 | 2019-06-06 13:41:20 -0700 | [diff] [blame] | 20 | #include <linux/capability.h> |
Mark Salyzyn | 11e55cb | 2015-03-10 16:45:17 -0700 | [diff] [blame] | 21 | #include <poll.h> |
Mark Salyzyn | 882f856 | 2013-12-26 15:13:36 -0800 | [diff] [blame] | 22 | #include <sched.h> |
Mark Salyzyn | 11e55cb | 2015-03-10 16:45:17 -0700 | [diff] [blame] | 23 | #include <semaphore.h> |
| 24 | #include <signal.h> |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 25 | #include <stdio.h> |
| 26 | #include <stdlib.h> |
| 27 | #include <string.h> |
| 28 | #include <sys/capability.h> |
Mark Salyzyn | eb06de7 | 2014-10-13 09:59:37 -0700 | [diff] [blame] | 29 | #include <sys/klog.h> |
Elliott Hughes | e5a0f20 | 2014-07-18 17:39:41 -0700 | [diff] [blame] | 30 | #include <sys/prctl.h> |
Riley Andrews | d98f4e8 | 2015-06-08 23:36:34 -0700 | [diff] [blame] | 31 | #include <sys/resource.h> |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 32 | #include <sys/stat.h> |
| 33 | #include <sys/types.h> |
Mark Salyzyn | ccbadc6 | 2015-03-12 12:25:35 -0700 | [diff] [blame] | 34 | #include <syslog.h> |
Mark Salyzyn | e457b74 | 2014-02-19 17:18:31 -0800 | [diff] [blame] | 35 | #include <unistd.h> |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 36 | |
Mark Salyzyn | d5600fd | 2015-06-12 14:59:42 -0700 | [diff] [blame] | 37 | #include <memory> |
| 38 | |
Tom Cherry | f93b400 | 2020-06-03 09:23:49 -0700 | [diff] [blame] | 39 | #include <android-base/logging.h> |
Jorge Lucangeli Obes | 2bbdbe8 | 2016-07-15 13:57:08 -0400 | [diff] [blame] | 40 | #include <android-base/macros.h> |
Tom Cherry | c1edd66 | 2020-07-14 09:52:24 -0700 | [diff] [blame] | 41 | #include <android-base/properties.h> |
Tom Cherry | f93b400 | 2020-06-03 09:23:49 -0700 | [diff] [blame] | 42 | #include <android-base/stringprintf.h> |
Mark Salyzyn | 52bd37e | 2016-11-07 09:39:30 -0800 | [diff] [blame] | 43 | #include <cutils/android_get_control_file.h> |
Mark Salyzyn | 11e55cb | 2015-03-10 16:45:17 -0700 | [diff] [blame] | 44 | #include <cutils/sockets.h> |
Mark Salyzyn | ff32f3c | 2015-04-13 14:24:45 -0700 | [diff] [blame] | 45 | #include <log/event_tag_map.h> |
William Roberts | aeca97b | 2015-07-31 13:10:36 -0700 | [diff] [blame] | 46 | #include <packagelistparser/packagelistparser.h> |
Mark Salyzyn | e3aeeee | 2015-03-17 07:56:32 -0700 | [diff] [blame] | 47 | #include <private/android_filesystem_config.h> |
Mark Salyzyn | 5740a46 | 2016-03-28 15:42:08 -0700 | [diff] [blame] | 48 | #include <private/android_logger.h> |
Suren Baghdasaryan | 0284333 | 2018-12-21 12:30:16 -0800 | [diff] [blame] | 49 | #include <processgroup/sched_policy.h> |
Riley Andrews | d98f4e8 | 2015-06-08 23:36:34 -0700 | [diff] [blame] | 50 | #include <utils/threads.h> |
Mark Salyzyn | e457b74 | 2014-02-19 17:18:31 -0800 | [diff] [blame] | 51 | |
Tom Cherry | d5b3838 | 2020-05-12 13:16:41 -0700 | [diff] [blame] | 52 | #include "ChattyLogBuffer.h" |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 53 | #include "CommandListener.h" |
William Roberts | 29d238d | 2013-02-08 09:45:26 +0900 | [diff] [blame] | 54 | #include "LogAudit.h" |
Mark Salyzyn | 501c373 | 2017-03-10 14:31:54 -0800 | [diff] [blame] | 55 | #include "LogBuffer.h" |
Mark Salyzyn | a1aacb7 | 2014-10-15 08:49:39 -0700 | [diff] [blame] | 56 | #include "LogKlog.h" |
Mark Salyzyn | 501c373 | 2017-03-10 14:31:54 -0800 | [diff] [blame] | 57 | #include "LogListener.h" |
Tom Cherry | 283c9a1 | 2020-05-14 19:25:05 -0700 | [diff] [blame] | 58 | #include "LogReader.h" |
Tom Cherry | 64e9016 | 2020-05-07 14:44:43 -0700 | [diff] [blame] | 59 | #include "LogStatistics.h" |
Tom Cherry | 1a12ae3 | 2020-05-01 16:13:18 -0700 | [diff] [blame] | 60 | #include "LogTags.h" |
Mark Salyzyn | 5ac5c6b | 2015-08-28 08:02:59 -0700 | [diff] [blame] | 61 | #include "LogUtils.h" |
Tom Cherry | 1a796bc | 2020-05-13 09:28:37 -0700 | [diff] [blame] | 62 | #include "SerializedLogBuffer.h" |
Tom Cherry | 8f61346 | 2020-05-12 12:46:43 -0700 | [diff] [blame] | 63 | #include "SimpleLogBuffer.h" |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 64 | |
Tom Cherry | 68261ee | 2020-07-28 09:51:54 -0700 | [diff] [blame] | 65 | using android::base::GetBoolProperty; |
Tom Cherry | c1edd66 | 2020-07-14 09:52:24 -0700 | [diff] [blame] | 66 | using android::base::GetProperty; |
Tom Cherry | 68261ee | 2020-07-28 09:51:54 -0700 | [diff] [blame] | 67 | using android::base::SetProperty; |
Tom Cherry | c1edd66 | 2020-07-14 09:52:24 -0700 | [diff] [blame] | 68 | |
Mark Salyzyn | 501c373 | 2017-03-10 14:31:54 -0800 | [diff] [blame] | 69 | #define KMSG_PRIORITY(PRI) \ |
| 70 | '<', '0' + LOG_MAKEPRI(LOG_DAEMON, LOG_PRI(PRI)) / 10, \ |
| 71 | '0' + LOG_MAKEPRI(LOG_DAEMON, LOG_PRI(PRI)) % 10, '>' |
Mark Salyzyn | ccbadc6 | 2015-03-12 12:25:35 -0700 | [diff] [blame] | 72 | |
Tom Cherry | 0b2a011 | 2019-06-06 13:41:20 -0700 | [diff] [blame] | 73 | // The service is designed to be run by init, it does not respond well to starting up manually. Init |
| 74 | // has a 'sigstop' feature that sends SIGSTOP to a service immediately before calling exec(). This |
| 75 | // allows debuggers, etc to be attached to logd at the very beginning, while still having init |
| 76 | // handle the user, groups, capabilities, files, etc setup. |
Tom Cherry | 54b00a9 | 2020-06-22 10:15:04 -0700 | [diff] [blame] | 77 | static void DropPrivs(bool klogd, bool auditd) { |
Mark Salyzyn | 56ba4b5 | 2015-01-30 15:19:48 -0800 | [diff] [blame] | 78 | if (set_sched_policy(0, SP_BACKGROUND) < 0) { |
Tom Cherry | 54b00a9 | 2020-06-22 10:15:04 -0700 | [diff] [blame] | 79 | PLOG(FATAL) << "failed to set background scheduling policy"; |
Mark Salyzyn | 56ba4b5 | 2015-01-30 15:19:48 -0800 | [diff] [blame] | 80 | } |
| 81 | |
Tom Cherry | 54b00a9 | 2020-06-22 10:15:04 -0700 | [diff] [blame] | 82 | sched_param param = {}; |
Mark Salyzyn | 501c373 | 2017-03-10 14:31:54 -0800 | [diff] [blame] | 83 | if (sched_setscheduler((pid_t)0, SCHED_BATCH, ¶m) < 0) { |
Tom Cherry | 54b00a9 | 2020-06-22 10:15:04 -0700 | [diff] [blame] | 84 | PLOG(FATAL) << "failed to set batch scheduler"; |
Mark Salyzyn | 882f856 | 2013-12-26 15:13:36 -0800 | [diff] [blame] | 85 | } |
| 86 | |
Tom Cherry | 68261ee | 2020-07-28 09:51:54 -0700 | [diff] [blame] | 87 | if (!GetBoolProperty("ro.debuggable", false)) { |
| 88 | if (prctl(PR_SET_DUMPABLE, 0) == -1) { |
| 89 | PLOG(FATAL) << "failed to clear PR_SET_DUMPABLE"; |
| 90 | } |
Mark Salyzyn | 6a70ded | 2016-10-28 14:49:53 -0700 | [diff] [blame] | 91 | } |
| 92 | |
Tom Cherry | 0b2a011 | 2019-06-06 13:41:20 -0700 | [diff] [blame] | 93 | std::unique_ptr<struct _cap_struct, int (*)(void*)> caps(cap_init(), cap_free); |
| 94 | if (cap_clear(caps.get()) < 0) { |
Tom Cherry | 54b00a9 | 2020-06-22 10:15:04 -0700 | [diff] [blame] | 95 | PLOG(FATAL) << "cap_clear() failed"; |
Mark Salyzyn | 501c373 | 2017-03-10 14:31:54 -0800 | [diff] [blame] | 96 | } |
Tom Cherry | 0b2a011 | 2019-06-06 13:41:20 -0700 | [diff] [blame] | 97 | if (klogd) { |
Tom Cherry | 54b00a9 | 2020-06-22 10:15:04 -0700 | [diff] [blame] | 98 | cap_value_t cap_syslog = CAP_SYSLOG; |
| 99 | if (cap_set_flag(caps.get(), CAP_PERMITTED, 1, &cap_syslog, CAP_SET) < 0 || |
| 100 | cap_set_flag(caps.get(), CAP_EFFECTIVE, 1, &cap_syslog, CAP_SET) < 0) { |
| 101 | PLOG(FATAL) << "Failed to set CAP_SYSLOG"; |
| 102 | } |
Tom Cherry | 0b2a011 | 2019-06-06 13:41:20 -0700 | [diff] [blame] | 103 | } |
| 104 | if (auditd) { |
Tom Cherry | 54b00a9 | 2020-06-22 10:15:04 -0700 | [diff] [blame] | 105 | cap_value_t cap_audit_control = CAP_AUDIT_CONTROL; |
| 106 | if (cap_set_flag(caps.get(), CAP_PERMITTED, 1, &cap_audit_control, CAP_SET) < 0 || |
| 107 | cap_set_flag(caps.get(), CAP_EFFECTIVE, 1, &cap_audit_control, CAP_SET) < 0) { |
| 108 | PLOG(FATAL) << "Failed to set CAP_AUDIT_CONTROL"; |
| 109 | } |
Mark Salyzyn | 501c373 | 2017-03-10 14:31:54 -0800 | [diff] [blame] | 110 | } |
Mark Salyzyn | f0b8e1b | 2016-10-28 14:49:53 -0700 | [diff] [blame] | 111 | if (cap_set_proc(caps.get()) < 0) { |
Tom Cherry | 54b00a9 | 2020-06-22 10:15:04 -0700 | [diff] [blame] | 112 | PLOG(FATAL) << "cap_set_proc() failed"; |
Mark Salyzyn | f0b8e1b | 2016-10-28 14:49:53 -0700 | [diff] [blame] | 113 | } |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 114 | } |
| 115 | |
Tom Cherry | 68261ee | 2020-07-28 09:51:54 -0700 | [diff] [blame] | 116 | // GetBoolProperty that defaults to true if `ro.debuggable == true && ro.config.low_rawm == false`. |
| 117 | static bool GetBoolPropertyEngSvelteDefault(const std::string& name) { |
| 118 | bool default_value = |
| 119 | GetBoolProperty("ro.debuggable", false) && !GetBoolProperty("ro.config.low_ram", false); |
| 120 | |
| 121 | return GetBoolProperty(name, default_value); |
| 122 | } |
| 123 | |
Mark Salyzyn | 501c373 | 2017-03-10 14:31:54 -0800 | [diff] [blame] | 124 | char* android::uidToName(uid_t u) { |
Tom Cherry | 36f5399 | 2017-09-06 10:07:37 -0700 | [diff] [blame] | 125 | struct Userdata { |
| 126 | uid_t uid; |
| 127 | char* name; |
| 128 | } userdata = { |
| 129 | .uid = u, |
| 130 | .name = nullptr, |
| 131 | }; |
Mark Salyzyn | 08739ba | 2015-03-16 08:26:05 -0700 | [diff] [blame] | 132 | |
Tom Cherry | 36f5399 | 2017-09-06 10:07:37 -0700 | [diff] [blame] | 133 | packagelist_parse( |
| 134 | [](pkg_info* info, void* callback_parameter) { |
| 135 | auto userdata = reinterpret_cast<Userdata*>(callback_parameter); |
| 136 | bool result = true; |
| 137 | if (info->uid == userdata->uid) { |
| 138 | userdata->name = strdup(info->name); |
| 139 | // false to stop processing |
| 140 | result = false; |
| 141 | } |
| 142 | packagelist_free(info); |
| 143 | return result; |
| 144 | }, |
| 145 | &userdata); |
Mark Salyzyn | 95108f1 | 2015-04-20 07:26:27 -0700 | [diff] [blame] | 146 | |
Tom Cherry | 36f5399 | 2017-09-06 10:07:37 -0700 | [diff] [blame] | 147 | return userdata.name; |
Mark Salyzyn | 08739ba | 2015-03-16 08:26:05 -0700 | [diff] [blame] | 148 | } |
| 149 | |
Mark Salyzyn | 501c373 | 2017-03-10 14:31:54 -0800 | [diff] [blame] | 150 | static void readDmesg(LogAudit* al, LogKlog* kl) { |
Mark Salyzyn | d5600fd | 2015-06-12 14:59:42 -0700 | [diff] [blame] | 151 | if (!al && !kl) { |
| 152 | return; |
| 153 | } |
| 154 | |
Mark Salyzyn | 0484b3b | 2016-08-11 08:02:06 -0700 | [diff] [blame] | 155 | int rc = klogctl(KLOG_SIZE_BUFFER, nullptr, 0); |
Mark Salyzyn | d5600fd | 2015-06-12 14:59:42 -0700 | [diff] [blame] | 156 | if (rc <= 0) { |
| 157 | return; |
| 158 | } |
| 159 | |
Mark Salyzyn | 0484b3b | 2016-08-11 08:02:06 -0700 | [diff] [blame] | 160 | // Margin for additional input race or trailing nul |
| 161 | ssize_t len = rc + 1024; |
Mark Salyzyn | 501c373 | 2017-03-10 14:31:54 -0800 | [diff] [blame] | 162 | std::unique_ptr<char[]> buf(new char[len]); |
Mark Salyzyn | ea1a241 | 2015-09-02 07:39:53 -0700 | [diff] [blame] | 163 | |
| 164 | rc = klogctl(KLOG_READ_ALL, buf.get(), len); |
| 165 | if (rc <= 0) { |
| 166 | return; |
| 167 | } |
| 168 | |
Mark Salyzyn | 0484b3b | 2016-08-11 08:02:06 -0700 | [diff] [blame] | 169 | if (rc < len) { |
Mark Salyzyn | d5600fd | 2015-06-12 14:59:42 -0700 | [diff] [blame] | 170 | len = rc + 1; |
| 171 | } |
Mark Salyzyn | ea1a241 | 2015-09-02 07:39:53 -0700 | [diff] [blame] | 172 | buf[--len] = '\0'; |
Mark Salyzyn | d5600fd | 2015-06-12 14:59:42 -0700 | [diff] [blame] | 173 | |
Mark Salyzyn | 0484b3b | 2016-08-11 08:02:06 -0700 | [diff] [blame] | 174 | ssize_t sublen; |
| 175 | for (char *ptr = nullptr, *tok = buf.get(); |
| 176 | (rc >= 0) && !!(tok = android::log_strntok_r(tok, len, ptr, sublen)); |
| 177 | tok = nullptr) { |
| 178 | if ((sublen <= 0) || !*tok) continue; |
Mark Salyzyn | d5600fd | 2015-06-12 14:59:42 -0700 | [diff] [blame] | 179 | if (al) { |
Mark Salyzyn | 151beac | 2015-09-04 11:37:42 -0700 | [diff] [blame] | 180 | rc = al->log(tok, sublen); |
Mark Salyzyn | d5600fd | 2015-06-12 14:59:42 -0700 | [diff] [blame] | 181 | } |
| 182 | if (kl) { |
Mark Salyzyn | 151beac | 2015-09-04 11:37:42 -0700 | [diff] [blame] | 183 | rc = kl->log(tok, sublen); |
Mark Salyzyn | d5600fd | 2015-06-12 14:59:42 -0700 | [diff] [blame] | 184 | } |
| 185 | } |
| 186 | } |
| 187 | |
Mark Salyzyn | d8f0180 | 2016-10-31 13:49:44 -0700 | [diff] [blame] | 188 | static int issueReinit() { |
Mark Salyzyn | 501c373 | 2017-03-10 14:31:54 -0800 | [diff] [blame] | 189 | int sock = TEMP_FAILURE_RETRY(socket_local_client( |
| 190 | "logd", ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM)); |
Mark Salyzyn | d8f0180 | 2016-10-31 13:49:44 -0700 | [diff] [blame] | 191 | if (sock < 0) return -errno; |
| 192 | |
| 193 | static const char reinitStr[] = "reinit"; |
| 194 | ssize_t ret = TEMP_FAILURE_RETRY(write(sock, reinitStr, sizeof(reinitStr))); |
| 195 | if (ret < 0) return -errno; |
| 196 | |
| 197 | struct pollfd p; |
| 198 | memset(&p, 0, sizeof(p)); |
| 199 | p.fd = sock; |
| 200 | p.events = POLLIN; |
| 201 | ret = TEMP_FAILURE_RETRY(poll(&p, 1, 1000)); |
| 202 | if (ret < 0) return -errno; |
| 203 | if ((ret == 0) || !(p.revents & POLLIN)) return -ETIME; |
| 204 | |
| 205 | static const char success[] = "success"; |
| 206 | char buffer[sizeof(success) - 1]; |
| 207 | memset(buffer, 0, sizeof(buffer)); |
| 208 | ret = TEMP_FAILURE_RETRY(read(sock, buffer, sizeof(buffer))); |
| 209 | if (ret < 0) return -errno; |
| 210 | |
| 211 | return strncmp(buffer, success, sizeof(success) - 1) != 0; |
| 212 | } |
| 213 | |
Mark Salyzyn | 11e55cb | 2015-03-10 16:45:17 -0700 | [diff] [blame] | 214 | // Foreground waits for exit of the main persistent threads |
| 215 | // that are started here. The threads are created to manage |
| 216 | // UNIX domain client sockets for writing, reading and |
| 217 | // controlling the user space logger, and for any additional |
| 218 | // logging plugins like auditd and restart control. Additional |
| 219 | // transitory per-client threads are created for each reader. |
Mark Salyzyn | 501c373 | 2017-03-10 14:31:54 -0800 | [diff] [blame] | 220 | int main(int argc, char* argv[]) { |
Tom Cherry | 2b3ebaf | 2020-07-31 15:21:54 -0700 | [diff] [blame] | 221 | // We want EPIPE when a reader disconnects, not to terminate logd. |
| 222 | signal(SIGPIPE, SIG_IGN); |
Hidehiko Abe | 352476e | 2017-03-29 17:41:17 +0900 | [diff] [blame] | 223 | // logd is written under the assumption that the timezone is UTC. |
| 224 | // If TZ is not set, persist.sys.timezone is looked up in some time utility |
| 225 | // libc functions, including mktime. It confuses the logd time handling, |
| 226 | // so here explicitly set TZ to UTC, which overrides the property. |
| 227 | setenv("TZ", "UTC", 1); |
Mark Salyzyn | 11e55cb | 2015-03-10 16:45:17 -0700 | [diff] [blame] | 228 | // issue reinit command. KISS argument parsing. |
| 229 | if ((argc > 1) && argv[1] && !strcmp(argv[1], "--reinit")) { |
Mark Salyzyn | d8f0180 | 2016-10-31 13:49:44 -0700 | [diff] [blame] | 230 | return issueReinit(); |
Mark Salyzyn | 11e55cb | 2015-03-10 16:45:17 -0700 | [diff] [blame] | 231 | } |
| 232 | |
Tom Cherry | f93b400 | 2020-06-03 09:23:49 -0700 | [diff] [blame] | 233 | android::base::InitLogging( |
| 234 | argv, [](android::base::LogId log_id, android::base::LogSeverity severity, |
| 235 | const char* tag, const char* file, unsigned int line, const char* message) { |
| 236 | if (tag && strcmp(tag, "logd") != 0) { |
| 237 | auto prefixed_message = android::base::StringPrintf("%s: %s", tag, message); |
| 238 | android::base::KernelLogger(log_id, severity, "logd", file, line, |
| 239 | prefixed_message.c_str()); |
| 240 | } else { |
| 241 | android::base::KernelLogger(log_id, severity, "logd", file, line, message); |
| 242 | } |
| 243 | }); |
| 244 | |
Mark Salyzyn | e0b8ccd | 2016-10-27 08:21:35 -0700 | [diff] [blame] | 245 | static const char dev_kmsg[] = "/dev/kmsg"; |
Tom Cherry | f93b400 | 2020-06-03 09:23:49 -0700 | [diff] [blame] | 246 | int fdDmesg = android_get_control_file(dev_kmsg); |
Mark Salyzyn | e0b8ccd | 2016-10-27 08:21:35 -0700 | [diff] [blame] | 247 | if (fdDmesg < 0) { |
| 248 | fdDmesg = TEMP_FAILURE_RETRY(open(dev_kmsg, O_WRONLY | O_CLOEXEC)); |
| 249 | } |
| 250 | |
| 251 | int fdPmesg = -1; |
Tom Cherry | 68261ee | 2020-07-28 09:51:54 -0700 | [diff] [blame] | 252 | bool klogd = GetBoolPropertyEngSvelteDefault("ro.logd.kernel"); |
Mark Salyzyn | e0b8ccd | 2016-10-27 08:21:35 -0700 | [diff] [blame] | 253 | if (klogd) { |
Tom Cherry | 68261ee | 2020-07-28 09:51:54 -0700 | [diff] [blame] | 254 | SetProperty("ro.logd.kernel", "true"); |
Mark Salyzyn | e0b8ccd | 2016-10-27 08:21:35 -0700 | [diff] [blame] | 255 | static const char proc_kmsg[] = "/proc/kmsg"; |
| 256 | fdPmesg = android_get_control_file(proc_kmsg); |
| 257 | if (fdPmesg < 0) { |
Mark Salyzyn | 501c373 | 2017-03-10 14:31:54 -0800 | [diff] [blame] | 258 | fdPmesg = TEMP_FAILURE_RETRY( |
| 259 | open(proc_kmsg, O_RDONLY | O_NDELAY | O_CLOEXEC)); |
Mark Salyzyn | e0b8ccd | 2016-10-27 08:21:35 -0700 | [diff] [blame] | 260 | } |
Tom Cherry | f93b400 | 2020-06-03 09:23:49 -0700 | [diff] [blame] | 261 | if (fdPmesg < 0) PLOG(ERROR) << "Failed to open " << proc_kmsg; |
Mark Salyzyn | e0b8ccd | 2016-10-27 08:21:35 -0700 | [diff] [blame] | 262 | } |
| 263 | |
Tom Cherry | 68261ee | 2020-07-28 09:51:54 -0700 | [diff] [blame] | 264 | bool auditd = GetBoolProperty("ro.logd.auditd", true); |
Tom Cherry | 54b00a9 | 2020-06-22 10:15:04 -0700 | [diff] [blame] | 265 | DropPrivs(klogd, auditd); |
Tom Cherry | 0b2a011 | 2019-06-06 13:41:20 -0700 | [diff] [blame] | 266 | |
Tom Cherry | 1a12ae3 | 2020-05-01 16:13:18 -0700 | [diff] [blame] | 267 | // A cache of event log tags |
| 268 | LogTags log_tags; |
Tom Cherry | 68630a0 | 2020-05-11 16:29:29 -0700 | [diff] [blame] | 269 | |
Tom Cherry | 5a3db39 | 2020-05-01 17:03:20 -0700 | [diff] [blame] | 270 | // Pruning configuration. |
| 271 | PruneList prune_list; |
Tom Cherry | 68630a0 | 2020-05-11 16:29:29 -0700 | [diff] [blame] | 272 | |
Tom Cherry | bc72197 | 2020-07-22 15:30:02 -0700 | [diff] [blame] | 273 | std::string buffer_type = GetProperty("logd.buffer_type", "serialized"); |
Tom Cherry | c1edd66 | 2020-07-14 09:52:24 -0700 | [diff] [blame] | 274 | |
Tom Cherry | 64e9016 | 2020-05-07 14:44:43 -0700 | [diff] [blame] | 275 | // Partial (required for chatty) or full logging statistics. |
Tom Cherry | 68261ee | 2020-07-28 09:51:54 -0700 | [diff] [blame] | 276 | LogStatistics log_statistics(GetBoolPropertyEngSvelteDefault("logd.statistics"), |
| 277 | buffer_type == "serialized"); |
Tom Cherry | 1a12ae3 | 2020-05-01 16:13:18 -0700 | [diff] [blame] | 278 | |
Tom Cherry | c1edd66 | 2020-07-14 09:52:24 -0700 | [diff] [blame] | 279 | // Serves the purpose of managing the last logs times read on a socket connection, and as a |
| 280 | // reader lock on a range of log entries. |
Tom Cherry | 68630a0 | 2020-05-11 16:29:29 -0700 | [diff] [blame] | 281 | LogReaderList reader_list; |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 282 | |
Tom Cherry | 8f61346 | 2020-05-12 12:46:43 -0700 | [diff] [blame] | 283 | // LogBuffer is the object which is responsible for holding all log entries. |
Tom Cherry | c1edd66 | 2020-07-14 09:52:24 -0700 | [diff] [blame] | 284 | LogBuffer* log_buffer = nullptr; |
| 285 | if (buffer_type == "chatty") { |
| 286 | log_buffer = new ChattyLogBuffer(&reader_list, &log_tags, &prune_list, &log_statistics); |
| 287 | } else if (buffer_type == "serialized") { |
| 288 | log_buffer = new SerializedLogBuffer(&reader_list, &log_tags, &log_statistics); |
| 289 | } else if (buffer_type == "simple") { |
| 290 | log_buffer = new SimpleLogBuffer(&reader_list, &log_tags, &log_statistics); |
Tom Cherry | 8f61346 | 2020-05-12 12:46:43 -0700 | [diff] [blame] | 291 | } else { |
Tom Cherry | c1edd66 | 2020-07-14 09:52:24 -0700 | [diff] [blame] | 292 | LOG(FATAL) << "buffer_type must be one of 'chatty', 'serialized', or 'simple'"; |
Tom Cherry | 8f61346 | 2020-05-12 12:46:43 -0700 | [diff] [blame] | 293 | } |
Mark Salyzyn | e457b74 | 2014-02-19 17:18:31 -0800 | [diff] [blame] | 294 | |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 295 | // LogReader listens on /dev/socket/logdr. When a client |
| 296 | // connects, log entries in the LogBuffer are written to the client. |
Tom Cherry | c1edd66 | 2020-07-14 09:52:24 -0700 | [diff] [blame] | 297 | LogReader* reader = new LogReader(log_buffer, &reader_list); |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 298 | if (reader->startListener()) { |
Elliott Hughes | cef62b4 | 2018-06-13 10:33:45 -0700 | [diff] [blame] | 299 | return EXIT_FAILURE; |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 300 | } |
| 301 | |
| 302 | // LogListener listens on /dev/socket/logdw for client |
| 303 | // initiated log messages. New log entries are added to LogBuffer |
| 304 | // and LogReader is notified to send updates to connected clients. |
Tom Cherry | c1edd66 | 2020-07-14 09:52:24 -0700 | [diff] [blame] | 305 | LogListener* swl = new LogListener(log_buffer); |
Tom Cherry | c64dd8e | 2020-05-06 12:04:09 -0700 | [diff] [blame] | 306 | if (!swl->StartListener()) { |
Elliott Hughes | cef62b4 | 2018-06-13 10:33:45 -0700 | [diff] [blame] | 307 | return EXIT_FAILURE; |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 308 | } |
| 309 | |
| 310 | // Command listener listens on /dev/socket/logd for incoming logd |
| 311 | // administrative commands. |
Tom Cherry | c1edd66 | 2020-07-14 09:52:24 -0700 | [diff] [blame] | 312 | CommandListener* cl = new CommandListener(log_buffer, &log_tags, &prune_list, &log_statistics); |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 313 | if (cl->startListener()) { |
Elliott Hughes | cef62b4 | 2018-06-13 10:33:45 -0700 | [diff] [blame] | 314 | return EXIT_FAILURE; |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 315 | } |
| 316 | |
William Roberts | 29d238d | 2013-02-08 09:45:26 +0900 | [diff] [blame] | 317 | // LogAudit listens on NETLINK_AUDIT socket for selinux |
| 318 | // initiated log messages. New log entries are added to LogBuffer |
| 319 | // and LogReader is notified to send updates to connected clients. |
Mark Salyzyn | 0484b3b | 2016-08-11 08:02:06 -0700 | [diff] [blame] | 320 | LogAudit* al = nullptr; |
Sami Tolvanen | a742d10 | 2016-06-14 18:04:43 +0000 | [diff] [blame] | 321 | if (auditd) { |
Tom Cherry | 68261ee | 2020-07-28 09:51:54 -0700 | [diff] [blame] | 322 | int dmesg_fd = GetBoolProperty("ro.logd.auditd.dmesg", true) ? fdDmesg : -1; |
Tom Cherry | c1edd66 | 2020-07-14 09:52:24 -0700 | [diff] [blame] | 323 | al = new LogAudit(log_buffer, dmesg_fd, &log_statistics); |
Sami Tolvanen | a742d10 | 2016-06-14 18:04:43 +0000 | [diff] [blame] | 324 | } |
Mark Salyzyn | 11e55cb | 2015-03-10 16:45:17 -0700 | [diff] [blame] | 325 | |
Mark Salyzyn | 0484b3b | 2016-08-11 08:02:06 -0700 | [diff] [blame] | 326 | LogKlog* kl = nullptr; |
Mark Salyzyn | a1aacb7 | 2014-10-15 08:49:39 -0700 | [diff] [blame] | 327 | if (klogd) { |
Tom Cherry | c1edd66 | 2020-07-14 09:52:24 -0700 | [diff] [blame] | 328 | kl = new LogKlog(log_buffer, fdDmesg, fdPmesg, al != nullptr, &log_statistics); |
Mark Salyzyn | a1aacb7 | 2014-10-15 08:49:39 -0700 | [diff] [blame] | 329 | } |
Mark Salyzyn | eb06de7 | 2014-10-13 09:59:37 -0700 | [diff] [blame] | 330 | |
Sami Tolvanen | a742d10 | 2016-06-14 18:04:43 +0000 | [diff] [blame] | 331 | readDmesg(al, kl); |
Mark Salyzyn | eb06de7 | 2014-10-13 09:59:37 -0700 | [diff] [blame] | 332 | |
Mark Salyzyn | d5600fd | 2015-06-12 14:59:42 -0700 | [diff] [blame] | 333 | // failure is an option ... messages are in dmesg (required by standard) |
Mark Salyzyn | d5600fd | 2015-06-12 14:59:42 -0700 | [diff] [blame] | 334 | if (kl && kl->startListener()) { |
| 335 | delete kl; |
| 336 | } |
Mark Salyzyn | eb06de7 | 2014-10-13 09:59:37 -0700 | [diff] [blame] | 337 | |
Sami Tolvanen | a742d10 | 2016-06-14 18:04:43 +0000 | [diff] [blame] | 338 | if (al && al->startListener()) { |
| 339 | delete al; |
William Roberts | 29d238d | 2013-02-08 09:45:26 +0900 | [diff] [blame] | 340 | } |
| 341 | |
Mark Salyzyn | 11e55cb | 2015-03-10 16:45:17 -0700 | [diff] [blame] | 342 | TEMP_FAILURE_RETRY(pause()); |
| 343 | |
Elliott Hughes | cef62b4 | 2018-06-13 10:33:45 -0700 | [diff] [blame] | 344 | return EXIT_SUCCESS; |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 345 | } |