blob: bef40c7b0bde2b6a15ca728f57b2524cd2f8cc17 [file] [log] [blame]
Mark Salyzyn0175b072014-02-26 09:50:16 -08001/*
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>
Mark Salyzyn11e55cb2015-03-10 16:45:17 -070020#include <poll.h>
Mark Salyzyn882f8562013-12-26 15:13:36 -080021#include <sched.h>
Mark Salyzyn11e55cb2015-03-10 16:45:17 -070022#include <semaphore.h>
23#include <signal.h>
Mark Salyzyn0175b072014-02-26 09:50:16 -080024#include <stdio.h>
25#include <stdlib.h>
26#include <string.h>
27#include <sys/capability.h>
Mark Salyzyneb06de72014-10-13 09:59:37 -070028#include <sys/klog.h>
Elliott Hughese5a0f202014-07-18 17:39:41 -070029#include <sys/prctl.h>
Riley Andrewsd98f4e82015-06-08 23:36:34 -070030#include <sys/resource.h>
Mark Salyzyn0175b072014-02-26 09:50:16 -080031#include <sys/stat.h>
32#include <sys/types.h>
Mark Salyzynccbadc62015-03-12 12:25:35 -070033#include <syslog.h>
Mark Salyzyne457b742014-02-19 17:18:31 -080034#include <unistd.h>
Mark Salyzyn0175b072014-02-26 09:50:16 -080035
William Robertsaeca97b2015-07-31 13:10:36 -070036#include <cstdbool>
Mark Salyzynd5600fd2015-06-12 14:59:42 -070037#include <memory>
38
Mark Salyzyne457b742014-02-19 17:18:31 -080039#include <cutils/properties.h>
Mark Salyzyn56ba4b52015-01-30 15:19:48 -080040#include <cutils/sched_policy.h>
Mark Salyzyn11e55cb2015-03-10 16:45:17 -070041#include <cutils/sockets.h>
Mark Salyzynff32f3c2015-04-13 14:24:45 -070042#include <log/event_tag_map.h>
William Robertsaeca97b2015-07-31 13:10:36 -070043#include <packagelistparser/packagelistparser.h>
Mark Salyzyne3aeeee2015-03-17 07:56:32 -070044#include <private/android_filesystem_config.h>
Riley Andrewsd98f4e82015-06-08 23:36:34 -070045#include <utils/threads.h>
Mark Salyzyne457b742014-02-19 17:18:31 -080046
Mark Salyzyn0175b072014-02-26 09:50:16 -080047#include "CommandListener.h"
48#include "LogBuffer.h"
49#include "LogListener.h"
William Roberts29d238d2013-02-08 09:45:26 +090050#include "LogAudit.h"
Mark Salyzyna1aacb72014-10-15 08:49:39 -070051#include "LogKlog.h"
Mark Salyzyn5ac5c6b2015-08-28 08:02:59 -070052#include "LogUtils.h"
Mark Salyzyn0175b072014-02-26 09:50:16 -080053
Mark Salyzynccbadc62015-03-12 12:25:35 -070054#define KMSG_PRIORITY(PRI) \
55 '<', \
56 '0' + LOG_MAKEPRI(LOG_DAEMON, LOG_PRI(PRI)) / 10, \
57 '0' + LOG_MAKEPRI(LOG_DAEMON, LOG_PRI(PRI)) % 10, \
58 '>'
59
Mark Salyzyndfc47e82014-03-24 10:26:47 -070060//
61// The service is designed to be run by init, it does not respond well
62// to starting up manually. When starting up manually the sockets will
63// fail to open typically for one of the following reasons:
64// EADDRINUSE if logger is running.
65// EACCESS if started without precautions (below)
66//
67// Here is a cookbook procedure for starting up logd manually assuming
68// init is out of the way, pedantically all permissions and selinux
69// security is put back in place:
70//
71// setenforce 0
72// rm /dev/socket/logd*
73// chmod 777 /dev/socket
74// # here is where you would attach the debugger or valgrind for example
75// runcon u:r:logd:s0 /system/bin/logd </dev/null >/dev/null 2>&1 &
76// sleep 1
77// chmod 755 /dev/socket
78// chown logd.logd /dev/socket/logd*
79// restorecon /dev/socket/logd*
80// setenforce 1
81//
82// If minimalism prevails, typical for debugging and security is not a concern:
83//
84// setenforce 0
85// chmod 777 /dev/socket
86// logd
87//
88
Mark Salyzyn0175b072014-02-26 09:50:16 -080089static int drop_privs() {
Mark Salyzyn882f8562013-12-26 15:13:36 -080090 struct sched_param param;
91 memset(&param, 0, sizeof(param));
92
Mark Salyzyn56ba4b52015-01-30 15:19:48 -080093 if (set_sched_policy(0, SP_BACKGROUND) < 0) {
94 return -1;
95 }
96
Mark Salyzyn882f8562013-12-26 15:13:36 -080097 if (sched_setscheduler((pid_t) 0, SCHED_BATCH, &param) < 0) {
98 return -1;
99 }
100
Riley Andrewsd98f4e82015-06-08 23:36:34 -0700101 if (setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_BACKGROUND) < 0) {
102 return -1;
103 }
104
Mark Salyzyn0175b072014-02-26 09:50:16 -0800105 if (prctl(PR_SET_KEEPCAPS, 1) < 0) {
106 return -1;
107 }
108
Nick Kralevichc39ba5a2015-11-07 16:52:17 -0800109 gid_t groups[] = { AID_READPROC };
110
111 if (setgroups(sizeof(groups) / sizeof(groups[0]), groups) == -1) {
Jeff Vander Stoep3f62a022015-07-23 15:18:36 -0700112 return -1;
113 }
114
Mark Salyzyn0175b072014-02-26 09:50:16 -0800115 if (setgid(AID_LOGD) != 0) {
116 return -1;
117 }
118
119 if (setuid(AID_LOGD) != 0) {
120 return -1;
121 }
122
123 struct __user_cap_header_struct capheader;
124 struct __user_cap_data_struct capdata[2];
125 memset(&capheader, 0, sizeof(capheader));
126 memset(&capdata, 0, sizeof(capdata));
127 capheader.version = _LINUX_CAPABILITY_VERSION_3;
128 capheader.pid = 0;
129
130 capdata[CAP_TO_INDEX(CAP_SYSLOG)].permitted = CAP_TO_MASK(CAP_SYSLOG);
William Roberts29d238d2013-02-08 09:45:26 +0900131 capdata[CAP_TO_INDEX(CAP_AUDIT_CONTROL)].permitted |= CAP_TO_MASK(CAP_AUDIT_CONTROL);
132
133 capdata[0].effective = capdata[0].permitted;
134 capdata[1].effective = capdata[1].permitted;
Mark Salyzyn0175b072014-02-26 09:50:16 -0800135 capdata[0].inheritable = 0;
136 capdata[1].inheritable = 0;
137
138 if (capset(&capheader, &capdata[0]) < 0) {
139 return -1;
140 }
141
142 return 0;
143}
144
Mark Salyzyne0fa2912014-04-28 16:39:04 -0700145// Property helper
Mark Salyzyn9c66a582015-12-14 16:40:12 -0800146static bool check_flag(const char *prop, const char *flag) {
147 const char *cp = strcasestr(prop, flag);
148 if (!cp) {
Mark Salyzyne0fa2912014-04-28 16:39:04 -0700149 return false;
150 }
Mark Salyzyn9c66a582015-12-14 16:40:12 -0800151 // We only will document comma (,)
152 static const char sep[] = ",:;|+ \t\f";
153 if ((cp != prop) && !strchr(sep, cp[-1])) {
154 return false;
155 }
156 cp += strlen(flag);
157 return !*cp || !!strchr(sep, *cp);
158}
Mark Salyzyne0fa2912014-04-28 16:39:04 -0700159
Mark Salyzyn9c66a582015-12-14 16:40:12 -0800160bool property_get_bool(const char *key, int flag) {
161 char def[PROPERTY_VALUE_MAX];
162 char property[PROPERTY_VALUE_MAX];
163 def[0] = '\0';
164 if (flag & BOOL_DEFAULT_FLAG_PERSIST) {
165 char newkey[PROPERTY_KEY_MAX];
166 snprintf(newkey, sizeof(newkey), "ro.%s", key);
167 property_get(newkey, property, "");
168 // persist properties set by /data require innoculation with
169 // logd-reinit. They may be set in init.rc early and function, but
170 // otherwise are defunct unless reset. Do not rely on persist
171 // properties for startup-only keys unless you are willing to restart
172 // logd daemon (not advised).
173 snprintf(newkey, sizeof(newkey), "persist.%s", key);
174 property_get(newkey, def, property);
175 }
176
177 property_get(key, property, def);
178
179 if (check_flag(property, "true")) {
180 return true;
181 }
182 if (check_flag(property, "false")) {
183 return false;
184 }
185 if (check_flag(property, "eng")) {
186 flag |= BOOL_DEFAULT_FLAG_ENG;
187 }
188 // this is really a "not" flag
189 if (check_flag(property, "svelte")) {
190 flag |= BOOL_DEFAULT_FLAG_SVELTE;
191 }
192
193 // Sanity Check
194 if (flag & (BOOL_DEFAULT_FLAG_SVELTE | BOOL_DEFAULT_FLAG_ENG)) {
195 flag &= ~BOOL_DEFAULT_FLAG_TRUE_FALSE;
196 flag |= BOOL_DEFAULT_TRUE;
197 }
198
199 if ((flag & BOOL_DEFAULT_FLAG_SVELTE)
200 && property_get_bool("ro.config.low_ram",
201 BOOL_DEFAULT_FALSE)) {
202 return false;
203 }
204 if (flag & BOOL_DEFAULT_FLAG_ENG) {
Mark Salyzynd1f41d62016-02-09 15:49:29 -0800205 property_get("ro.debuggable", property, "");
206 if (strcmp(property, "1")) {
Mark Salyzyn9c66a582015-12-14 16:40:12 -0800207 return false;
208 }
209 }
210
211 return (flag & BOOL_DEFAULT_FLAG_TRUE_FALSE) != BOOL_DEFAULT_FALSE;
Mark Salyzyne0fa2912014-04-28 16:39:04 -0700212}
213
Mark Salyzynccbadc62015-03-12 12:25:35 -0700214static int fdDmesg = -1;
Mark Salyzynd048f112016-02-08 10:28:12 -0800215void inline android::prdebug(const char *fmt, ...) {
216 if (fdDmesg < 0) {
217 return;
218 }
219
220 static const char message[] = {
221 KMSG_PRIORITY(LOG_DEBUG), 'l', 'o', 'g', 'd', ':', ' '
222 };
223 char buffer[256];
224 memcpy(buffer, message, sizeof(message));
225
226 va_list ap;
227 va_start(ap, fmt);
228 int n = vsnprintf(buffer + sizeof(message),
229 sizeof(buffer) - sizeof(message), fmt, ap);
230 va_end(ap);
231 if (n > 0) {
232 buffer[sizeof(buffer) - 1] = '\0';
233 if (!strchr(buffer, '\n')) {
234 buffer[sizeof(buffer) - 2] = '\0';
235 strlcat(buffer, "\n", sizeof(buffer));
236 }
237 write(fdDmesg, buffer, strlen(buffer));
238 }
239}
Mark Salyzynccbadc62015-03-12 12:25:35 -0700240
Mark Salyzyn08739ba2015-03-16 08:26:05 -0700241static sem_t uidName;
242static uid_t uid;
243static char *name;
244
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700245static sem_t reinit;
246static bool reinit_running = false;
247static LogBuffer *logBuf = NULL;
Mark Salyzyne0fa2912014-04-28 16:39:04 -0700248
William Robertsaeca97b2015-07-31 13:10:36 -0700249static bool package_list_parser_cb(pkg_info *info, void * /* userdata */) {
250
251 bool rc = true;
252 if (info->uid == uid) {
253 name = strdup(info->name);
254 // false to stop processing
255 rc = false;
256 }
257
258 packagelist_free(info);
259 return rc;
260}
261
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700262static void *reinit_thread_start(void * /*obj*/) {
263 prctl(PR_SET_NAME, "logd.daemon");
264 set_sched_policy(0, SP_BACKGROUND);
Riley Andrewsd98f4e82015-06-08 23:36:34 -0700265 setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_BACKGROUND);
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700266
Mark Salyzyn08739ba2015-03-16 08:26:05 -0700267 setgid(AID_SYSTEM);
268 setuid(AID_SYSTEM);
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700269
270 while (reinit_running && !sem_wait(&reinit) && reinit_running) {
Mark Salyzyn08739ba2015-03-16 08:26:05 -0700271
272 // uidToName Privileged Worker
273 if (uid) {
274 name = NULL;
275
William Robertsaeca97b2015-07-31 13:10:36 -0700276 packagelist_parse(package_list_parser_cb, NULL);
Mark Salyzyn08739ba2015-03-16 08:26:05 -0700277
Mark Salyzyn08739ba2015-03-16 08:26:05 -0700278 uid = 0;
279 sem_post(&uidName);
280 continue;
281 }
282
Mark Salyzynccbadc62015-03-12 12:25:35 -0700283 if (fdDmesg >= 0) {
284 static const char reinit_message[] = { KMSG_PRIORITY(LOG_INFO),
285 'l', 'o', 'g', 'd', '.', 'd', 'a', 'e', 'm', 'o', 'n', ':',
286 ' ', 'r', 'e', 'i', 'n', 'i', 't', '\n' };
287 write(fdDmesg, reinit_message, sizeof(reinit_message));
288 }
289
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700290 // Anything that reads persist.<property>
291 if (logBuf) {
292 logBuf->init();
Mark Salyzyn932f7ac2015-08-28 08:02:59 -0700293 logBuf->initPrune(NULL);
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700294 }
295 }
296
297 return NULL;
298}
299
Mark Salyzyn95108f12015-04-20 07:26:27 -0700300static sem_t sem_name;
301
Mark Salyzyn08739ba2015-03-16 08:26:05 -0700302char *android::uidToName(uid_t u) {
303 if (!u || !reinit_running) {
304 return NULL;
305 }
306
Mark Salyzyn95108f12015-04-20 07:26:27 -0700307 sem_wait(&sem_name);
308
309 // Not multi-thread safe, we use sem_name to protect
Mark Salyzyn08739ba2015-03-16 08:26:05 -0700310 uid = u;
311
312 name = NULL;
313 sem_post(&reinit);
314 sem_wait(&uidName);
Mark Salyzyn95108f12015-04-20 07:26:27 -0700315 char *ret = name;
316
317 sem_post(&sem_name);
318
319 return ret;
Mark Salyzyn08739ba2015-03-16 08:26:05 -0700320}
321
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700322// Serves as a global method to trigger reinitialization
323// and as a function that can be provided to signal().
324void reinit_signal_handler(int /*signal*/) {
325 sem_post(&reinit);
326}
327
Mark Salyzynff32f3c2015-04-13 14:24:45 -0700328// tagToName converts an events tag into a name
329const char *android::tagToName(uint32_t tag) {
330 static const EventTagMap *map;
331
332 if (!map) {
333 sem_wait(&sem_name);
334 if (!map) {
335 map = android_openEventTagMap(EVENT_TAG_MAP_FILE);
336 }
337 sem_post(&sem_name);
338 if (!map) {
339 return NULL;
340 }
341 }
342 return android_lookupEventTag(map, tag);
343}
344
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700345static void readDmesg(LogAudit *al, LogKlog *kl) {
346 if (!al && !kl) {
347 return;
348 }
349
Mark Salyzynea1a2412015-09-02 07:39:53 -0700350 int rc = klogctl(KLOG_SIZE_BUFFER, NULL, 0);
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700351 if (rc <= 0) {
352 return;
353 }
354
Mark Salyzynea1a2412015-09-02 07:39:53 -0700355 size_t len = rc + 1024; // Margin for additional input race or trailing nul
356 std::unique_ptr<char []> buf(new char[len]);
357
358 rc = klogctl(KLOG_READ_ALL, buf.get(), len);
359 if (rc <= 0) {
360 return;
361 }
362
363 if ((size_t)rc < len) {
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700364 len = rc + 1;
365 }
Mark Salyzynea1a2412015-09-02 07:39:53 -0700366 buf[--len] = '\0';
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700367
Mark Salyzynb6bee332015-09-08 08:56:32 -0700368 if (kl && kl->isMonotonic()) {
Mark Salyzyn151beac2015-09-04 11:37:42 -0700369 kl->synchronize(buf.get(), len);
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700370 }
371
Mark Salyzynea1a2412015-09-02 07:39:53 -0700372 size_t sublen;
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700373 for (char *ptr = NULL, *tok = buf.get();
Mark Salyzynea1a2412015-09-02 07:39:53 -0700374 (rc >= 0) && ((tok = log_strntok_r(tok, &len, &ptr, &sublen)));
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700375 tok = NULL) {
376 if (al) {
Mark Salyzyn151beac2015-09-04 11:37:42 -0700377 rc = al->log(tok, sublen);
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700378 }
379 if (kl) {
Mark Salyzyn151beac2015-09-04 11:37:42 -0700380 rc = kl->log(tok, sublen);
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700381 }
382 }
383}
384
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700385// Foreground waits for exit of the main persistent threads
386// that are started here. The threads are created to manage
387// UNIX domain client sockets for writing, reading and
388// controlling the user space logger, and for any additional
389// logging plugins like auditd and restart control. Additional
390// transitory per-client threads are created for each reader.
391int main(int argc, char *argv[]) {
Mark Salyzyna1aacb72014-10-15 08:49:39 -0700392 int fdPmesg = -1;
Mark Salyzyn9c66a582015-12-14 16:40:12 -0800393 bool klogd = property_get_bool("logd.kernel",
394 BOOL_DEFAULT_TRUE |
395 BOOL_DEFAULT_FLAG_PERSIST |
396 BOOL_DEFAULT_FLAG_ENG |
397 BOOL_DEFAULT_FLAG_SVELTE);
Mark Salyzyna1aacb72014-10-15 08:49:39 -0700398 if (klogd) {
399 fdPmesg = open("/proc/kmsg", O_RDONLY | O_NDELAY);
400 }
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700401 fdDmesg = open("/dev/kmsg", O_WRONLY);
402
403 // issue reinit command. KISS argument parsing.
404 if ((argc > 1) && argv[1] && !strcmp(argv[1], "--reinit")) {
405 int sock = TEMP_FAILURE_RETRY(
406 socket_local_client("logd",
407 ANDROID_SOCKET_NAMESPACE_RESERVED,
408 SOCK_STREAM));
409 if (sock < 0) {
410 return -errno;
411 }
412 static const char reinit[] = "reinit";
413 ssize_t ret = TEMP_FAILURE_RETRY(write(sock, reinit, sizeof(reinit)));
414 if (ret < 0) {
415 return -errno;
416 }
417 struct pollfd p;
418 memset(&p, 0, sizeof(p));
419 p.fd = sock;
420 p.events = POLLIN;
Mark Salyzynf011a332015-12-10 11:27:03 -0800421 ret = TEMP_FAILURE_RETRY(poll(&p, 1, 1000));
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700422 if (ret < 0) {
423 return -errno;
424 }
425 if ((ret == 0) || !(p.revents & POLLIN)) {
426 return -ETIME;
427 }
428 static const char success[] = "success";
429 char buffer[sizeof(success) - 1];
430 memset(buffer, 0, sizeof(buffer));
431 ret = TEMP_FAILURE_RETRY(read(sock, buffer, sizeof(buffer)));
432 if (ret < 0) {
433 return -errno;
434 }
435 return strncmp(buffer, success, sizeof(success) - 1) != 0;
436 }
437
438 // Reinit Thread
439 sem_init(&reinit, 0, 0);
Mark Salyzyn08739ba2015-03-16 08:26:05 -0700440 sem_init(&uidName, 0, 0);
Mark Salyzyn95108f12015-04-20 07:26:27 -0700441 sem_init(&sem_name, 0, 1);
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700442 pthread_attr_t attr;
443 if (!pthread_attr_init(&attr)) {
444 struct sched_param param;
445
446 memset(&param, 0, sizeof(param));
447 pthread_attr_setschedparam(&attr, &param);
448 pthread_attr_setschedpolicy(&attr, SCHED_BATCH);
449 if (!pthread_attr_setdetachstate(&attr,
450 PTHREAD_CREATE_DETACHED)) {
451 pthread_t thread;
452 reinit_running = true;
453 if (pthread_create(&thread, &attr, reinit_thread_start, NULL)) {
454 reinit_running = false;
455 }
456 }
457 pthread_attr_destroy(&attr);
Mark Salyzyne9bebd02014-04-03 09:55:26 -0700458 }
459
Mark Salyzyn0175b072014-02-26 09:50:16 -0800460 if (drop_privs() != 0) {
461 return -1;
462 }
463
464 // Serves the purpose of managing the last logs times read on a
465 // socket connection, and as a reader lock on a range of log
466 // entries.
467
468 LastLogTimes *times = new LastLogTimes();
469
470 // LogBuffer is the object which is responsible for holding all
471 // log entries.
472
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700473 logBuf = new LogBuffer(times);
474
475 signal(SIGHUP, reinit_signal_handler);
Mark Salyzyn0175b072014-02-26 09:50:16 -0800476
Mark Salyzyn9c66a582015-12-14 16:40:12 -0800477 if (property_get_bool("logd.statistics",
478 BOOL_DEFAULT_TRUE |
479 BOOL_DEFAULT_FLAG_PERSIST |
480 BOOL_DEFAULT_FLAG_ENG |
481 BOOL_DEFAULT_FLAG_SVELTE)) {
Mark Salyzyna1aacb72014-10-15 08:49:39 -0700482 logBuf->enableStatistics();
Mark Salyzynf5fc5092014-09-21 14:22:18 -0700483 }
Mark Salyzyne457b742014-02-19 17:18:31 -0800484
Mark Salyzyn0175b072014-02-26 09:50:16 -0800485 // LogReader listens on /dev/socket/logdr. When a client
486 // connects, log entries in the LogBuffer are written to the client.
487
488 LogReader *reader = new LogReader(logBuf);
489 if (reader->startListener()) {
490 exit(1);
491 }
492
493 // LogListener listens on /dev/socket/logdw for client
494 // initiated log messages. New log entries are added to LogBuffer
495 // and LogReader is notified to send updates to connected clients.
496
497 LogListener *swl = new LogListener(logBuf, reader);
Mark Salyzyn581edc12013-11-20 13:38:52 -0800498 // Backlog and /proc/sys/net/unix/max_dgram_qlen set to large value
Mark Salyzyn39944c82015-09-08 11:24:07 -0700499 if (swl->startListener(600)) {
Mark Salyzyn0175b072014-02-26 09:50:16 -0800500 exit(1);
501 }
502
503 // Command listener listens on /dev/socket/logd for incoming logd
504 // administrative commands.
505
506 CommandListener *cl = new CommandListener(logBuf, reader, swl);
507 if (cl->startListener()) {
508 exit(1);
509 }
510
William Roberts29d238d2013-02-08 09:45:26 +0900511 // LogAudit listens on NETLINK_AUDIT socket for selinux
512 // initiated log messages. New log entries are added to LogBuffer
513 // and LogReader is notified to send updates to connected clients.
514
Mark Salyzyn9c66a582015-12-14 16:40:12 -0800515 bool auditd = property_get_bool("logd.auditd",
516 BOOL_DEFAULT_TRUE |
517 BOOL_DEFAULT_FLAG_PERSIST);
Mark Salyzyna1aacb72014-10-15 08:49:39 -0700518 LogAudit *al = NULL;
Mark Salyzyne0fa2912014-04-28 16:39:04 -0700519 if (auditd) {
Mark Salyzyn9c66a582015-12-14 16:40:12 -0800520 al = new LogAudit(logBuf, reader,
521 property_get_bool("logd.auditd.dmesg",
522 BOOL_DEFAULT_TRUE |
523 BOOL_DEFAULT_FLAG_PERSIST)
524 ? fdDmesg
525 : -1);
Mark Salyzyna1aacb72014-10-15 08:49:39 -0700526 }
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700527
Mark Salyzyna1aacb72014-10-15 08:49:39 -0700528 LogKlog *kl = NULL;
529 if (klogd) {
530 kl = new LogKlog(logBuf, reader, fdDmesg, fdPmesg, al != NULL);
531 }
Mark Salyzyneb06de72014-10-13 09:59:37 -0700532
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700533 readDmesg(al, kl);
Mark Salyzyneb06de72014-10-13 09:59:37 -0700534
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700535 // failure is an option ... messages are in dmesg (required by standard)
Mark Salyzyneb06de72014-10-13 09:59:37 -0700536
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700537 if (kl && kl->startListener()) {
538 delete kl;
539 }
Mark Salyzyneb06de72014-10-13 09:59:37 -0700540
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700541 if (al && al->startListener()) {
542 delete al;
William Roberts29d238d2013-02-08 09:45:26 +0900543 }
544
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700545 TEMP_FAILURE_RETRY(pause());
546
Mark Salyzyn0175b072014-02-26 09:50:16 -0800547 exit(0);
548}