blob: 1ac1415eda6539a7705dbb9fbf5b242964a7fc06 [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
Jorge Lucangeli Obes2bbdbe82016-07-15 13:57:08 -040039#include <android-base/macros.h>
Mark Salyzyne457b742014-02-19 17:18:31 -080040#include <cutils/properties.h>
Mark Salyzyn56ba4b52015-01-30 15:19:48 -080041#include <cutils/sched_policy.h>
Mark Salyzyn11e55cb2015-03-10 16:45:17 -070042#include <cutils/sockets.h>
Jorge Lucangeli Obes2bbdbe82016-07-15 13:57:08 -040043#include <libminijail.h>
Mark Salyzynff32f3c2015-04-13 14:24:45 -070044#include <log/event_tag_map.h>
William Robertsaeca97b2015-07-31 13:10:36 -070045#include <packagelistparser/packagelistparser.h>
Mark Salyzyne3aeeee2015-03-17 07:56:32 -070046#include <private/android_filesystem_config.h>
Mark Salyzyn5740a462016-03-28 15:42:08 -070047#include <private/android_logger.h>
Jorge Lucangeli Obes2bbdbe82016-07-15 13:57:08 -040048#include <scoped_minijail.h>
Riley Andrewsd98f4e82015-06-08 23:36:34 -070049#include <utils/threads.h>
Mark Salyzyne457b742014-02-19 17:18:31 -080050
Mark Salyzyn0175b072014-02-26 09:50:16 -080051#include "CommandListener.h"
52#include "LogBuffer.h"
53#include "LogListener.h"
William Roberts29d238d2013-02-08 09:45:26 +090054#include "LogAudit.h"
Mark Salyzyna1aacb72014-10-15 08:49:39 -070055#include "LogKlog.h"
Mark Salyzyn5ac5c6b2015-08-28 08:02:59 -070056#include "LogUtils.h"
Mark Salyzyn0175b072014-02-26 09:50:16 -080057
Mark Salyzynccbadc62015-03-12 12:25:35 -070058#define KMSG_PRIORITY(PRI) \
59 '<', \
60 '0' + LOG_MAKEPRI(LOG_DAEMON, LOG_PRI(PRI)) / 10, \
61 '0' + LOG_MAKEPRI(LOG_DAEMON, LOG_PRI(PRI)) % 10, \
62 '>'
63
Mark Salyzyndfc47e82014-03-24 10:26:47 -070064//
Jorge Lucangeli Obes2bbdbe82016-07-15 13:57:08 -040065// The service is designed to be run by init, it does not respond well
Mark Salyzyndfc47e82014-03-24 10:26:47 -070066// to starting up manually. When starting up manually the sockets will
67// fail to open typically for one of the following reasons:
68// EADDRINUSE if logger is running.
69// EACCESS if started without precautions (below)
70//
71// Here is a cookbook procedure for starting up logd manually assuming
Jorge Lucangeli Obes2bbdbe82016-07-15 13:57:08 -040072// init is out of the way, pedantically all permissions and SELinux
Mark Salyzyndfc47e82014-03-24 10:26:47 -070073// security is put back in place:
74//
75// setenforce 0
76// rm /dev/socket/logd*
77// chmod 777 /dev/socket
78// # here is where you would attach the debugger or valgrind for example
79// runcon u:r:logd:s0 /system/bin/logd </dev/null >/dev/null 2>&1 &
80// sleep 1
81// chmod 755 /dev/socket
82// chown logd.logd /dev/socket/logd*
83// restorecon /dev/socket/logd*
84// setenforce 1
85//
86// If minimalism prevails, typical for debugging and security is not a concern:
87//
88// setenforce 0
89// chmod 777 /dev/socket
90// logd
91//
92
Mark Salyzyn0175b072014-02-26 09:50:16 -080093static int drop_privs() {
Mark Salyzyn882f8562013-12-26 15:13:36 -080094 struct sched_param param;
95 memset(&param, 0, sizeof(param));
96
Mark Salyzyn56ba4b52015-01-30 15:19:48 -080097 if (set_sched_policy(0, SP_BACKGROUND) < 0) {
98 return -1;
99 }
100
Mark Salyzyn882f8562013-12-26 15:13:36 -0800101 if (sched_setscheduler((pid_t) 0, SCHED_BATCH, &param) < 0) {
102 return -1;
103 }
104
Riley Andrewsd98f4e82015-06-08 23:36:34 -0700105 if (setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_BACKGROUND) < 0) {
106 return -1;
107 }
108
Mark Salyzyn6a70ded2016-10-28 14:49:53 -0700109 if (prctl(PR_SET_DUMPABLE, 0) < 0) {
110 android::prdebug("failed to clear PR_SET_DUMPABLE");
111 return -1;
112 }
113
Nick Kralevichc39ba5a2015-11-07 16:52:17 -0800114 gid_t groups[] = { AID_READPROC };
Jorge Lucangeli Obes2bbdbe82016-07-15 13:57:08 -0400115 ScopedMinijail j(minijail_new());
116 minijail_set_supplementary_gids(j.get(), arraysize(groups), groups);
117 minijail_change_uid(j.get(), AID_LOGD);
118 minijail_change_gid(j.get(), AID_LOGD);
119 minijail_use_caps(j.get(), CAP_TO_MASK(CAP_SYSLOG) | CAP_TO_MASK(CAP_AUDIT_CONTROL));
120 minijail_enter(j.get());
Mark Salyzyn0175b072014-02-26 09:50:16 -0800121 return 0;
122}
123
Mark Salyzyne0fa2912014-04-28 16:39:04 -0700124// Property helper
Mark Salyzyn9c66a582015-12-14 16:40:12 -0800125static bool check_flag(const char *prop, const char *flag) {
126 const char *cp = strcasestr(prop, flag);
127 if (!cp) {
Mark Salyzyne0fa2912014-04-28 16:39:04 -0700128 return false;
129 }
Mark Salyzyn9c66a582015-12-14 16:40:12 -0800130 // We only will document comma (,)
131 static const char sep[] = ",:;|+ \t\f";
132 if ((cp != prop) && !strchr(sep, cp[-1])) {
133 return false;
134 }
135 cp += strlen(flag);
136 return !*cp || !!strchr(sep, *cp);
137}
Mark Salyzyne0fa2912014-04-28 16:39:04 -0700138
Mark Salyzynccbadc62015-03-12 12:25:35 -0700139static int fdDmesg = -1;
Mark Salyzyn36a87112016-07-15 09:55:41 -0700140void android::prdebug(const char *fmt, ...) {
Mark Salyzynd048f112016-02-08 10:28:12 -0800141 if (fdDmesg < 0) {
142 return;
143 }
144
145 static const char message[] = {
146 KMSG_PRIORITY(LOG_DEBUG), 'l', 'o', 'g', 'd', ':', ' '
147 };
148 char buffer[256];
149 memcpy(buffer, message, sizeof(message));
150
151 va_list ap;
152 va_start(ap, fmt);
153 int n = vsnprintf(buffer + sizeof(message),
154 sizeof(buffer) - sizeof(message), fmt, ap);
155 va_end(ap);
156 if (n > 0) {
157 buffer[sizeof(buffer) - 1] = '\0';
158 if (!strchr(buffer, '\n')) {
159 buffer[sizeof(buffer) - 2] = '\0';
160 strlcat(buffer, "\n", sizeof(buffer));
161 }
162 write(fdDmesg, buffer, strlen(buffer));
163 }
164}
Mark Salyzynccbadc62015-03-12 12:25:35 -0700165
Mark Salyzyn08739ba2015-03-16 08:26:05 -0700166static sem_t uidName;
167static uid_t uid;
168static char *name;
169
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700170static sem_t reinit;
171static bool reinit_running = false;
172static LogBuffer *logBuf = NULL;
Mark Salyzyne0fa2912014-04-28 16:39:04 -0700173
William Robertsaeca97b2015-07-31 13:10:36 -0700174static bool package_list_parser_cb(pkg_info *info, void * /* userdata */) {
175
176 bool rc = true;
177 if (info->uid == uid) {
178 name = strdup(info->name);
179 // false to stop processing
180 rc = false;
181 }
182
183 packagelist_free(info);
184 return rc;
185}
186
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700187static void *reinit_thread_start(void * /*obj*/) {
188 prctl(PR_SET_NAME, "logd.daemon");
189 set_sched_policy(0, SP_BACKGROUND);
Riley Andrewsd98f4e82015-06-08 23:36:34 -0700190 setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_BACKGROUND);
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700191
Mark Salyzyn07522c62016-03-02 07:51:48 -0800192 // If we are AID_ROOT, we should drop to AID_SYSTEM, if we are anything
193 // else, we have even lesser privileges and accept our fate. Not worth
194 // checking for error returns setting this thread's privileges.
195 (void)setgid(AID_SYSTEM);
196 (void)setuid(AID_SYSTEM);
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700197
198 while (reinit_running && !sem_wait(&reinit) && reinit_running) {
Mark Salyzyn08739ba2015-03-16 08:26:05 -0700199
200 // uidToName Privileged Worker
201 if (uid) {
202 name = NULL;
203
William Robertsaeca97b2015-07-31 13:10:36 -0700204 packagelist_parse(package_list_parser_cb, NULL);
Mark Salyzyn08739ba2015-03-16 08:26:05 -0700205
Mark Salyzyn08739ba2015-03-16 08:26:05 -0700206 uid = 0;
207 sem_post(&uidName);
208 continue;
209 }
210
Mark Salyzynccbadc62015-03-12 12:25:35 -0700211 if (fdDmesg >= 0) {
212 static const char reinit_message[] = { KMSG_PRIORITY(LOG_INFO),
213 'l', 'o', 'g', 'd', '.', 'd', 'a', 'e', 'm', 'o', 'n', ':',
214 ' ', 'r', 'e', 'i', 'n', 'i', 't', '\n' };
215 write(fdDmesg, reinit_message, sizeof(reinit_message));
216 }
217
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700218 // Anything that reads persist.<property>
219 if (logBuf) {
220 logBuf->init();
Mark Salyzyn932f7ac2015-08-28 08:02:59 -0700221 logBuf->initPrune(NULL);
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700222 }
223 }
224
225 return NULL;
226}
227
Mark Salyzyn95108f12015-04-20 07:26:27 -0700228static sem_t sem_name;
229
Mark Salyzyn08739ba2015-03-16 08:26:05 -0700230char *android::uidToName(uid_t u) {
231 if (!u || !reinit_running) {
232 return NULL;
233 }
234
Mark Salyzyn95108f12015-04-20 07:26:27 -0700235 sem_wait(&sem_name);
236
237 // Not multi-thread safe, we use sem_name to protect
Mark Salyzyn08739ba2015-03-16 08:26:05 -0700238 uid = u;
239
240 name = NULL;
241 sem_post(&reinit);
242 sem_wait(&uidName);
Mark Salyzyn95108f12015-04-20 07:26:27 -0700243 char *ret = name;
244
245 sem_post(&sem_name);
246
247 return ret;
Mark Salyzyn08739ba2015-03-16 08:26:05 -0700248}
249
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700250// Serves as a global method to trigger reinitialization
251// and as a function that can be provided to signal().
252void reinit_signal_handler(int /*signal*/) {
253 sem_post(&reinit);
254}
255
Mark Salyzynff32f3c2015-04-13 14:24:45 -0700256// tagToName converts an events tag into a name
Mark Salyzyn807e40e2016-09-22 09:56:51 -0700257const char *android::tagToName(size_t *len, uint32_t tag) {
Mark Salyzynff32f3c2015-04-13 14:24:45 -0700258 static const EventTagMap *map;
259
260 if (!map) {
261 sem_wait(&sem_name);
262 if (!map) {
263 map = android_openEventTagMap(EVENT_TAG_MAP_FILE);
264 }
265 sem_post(&sem_name);
266 if (!map) {
Mark Salyzyn807e40e2016-09-22 09:56:51 -0700267 if (len) len = 0;
Mark Salyzynff32f3c2015-04-13 14:24:45 -0700268 return NULL;
269 }
270 }
Mark Salyzyn807e40e2016-09-22 09:56:51 -0700271 return android_lookupEventTag_len(map, len, tag);
Mark Salyzynff32f3c2015-04-13 14:24:45 -0700272}
273
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700274static void readDmesg(LogAudit *al, LogKlog *kl) {
275 if (!al && !kl) {
276 return;
277 }
278
Mark Salyzynea1a2412015-09-02 07:39:53 -0700279 int rc = klogctl(KLOG_SIZE_BUFFER, NULL, 0);
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700280 if (rc <= 0) {
281 return;
282 }
283
Mark Salyzynea1a2412015-09-02 07:39:53 -0700284 size_t len = rc + 1024; // Margin for additional input race or trailing nul
285 std::unique_ptr<char []> buf(new char[len]);
286
287 rc = klogctl(KLOG_READ_ALL, buf.get(), len);
288 if (rc <= 0) {
289 return;
290 }
291
292 if ((size_t)rc < len) {
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700293 len = rc + 1;
294 }
Mark Salyzynea1a2412015-09-02 07:39:53 -0700295 buf[--len] = '\0';
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700296
Mark Salyzynb6bee332015-09-08 08:56:32 -0700297 if (kl && kl->isMonotonic()) {
Mark Salyzyn151beac2015-09-04 11:37:42 -0700298 kl->synchronize(buf.get(), len);
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700299 }
300
Mark Salyzynea1a2412015-09-02 07:39:53 -0700301 size_t sublen;
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700302 for (char *ptr = NULL, *tok = buf.get();
Mark Salyzynea1a2412015-09-02 07:39:53 -0700303 (rc >= 0) && ((tok = log_strntok_r(tok, &len, &ptr, &sublen)));
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700304 tok = NULL) {
305 if (al) {
Mark Salyzyn151beac2015-09-04 11:37:42 -0700306 rc = al->log(tok, sublen);
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700307 }
308 if (kl) {
Mark Salyzyn151beac2015-09-04 11:37:42 -0700309 rc = kl->log(tok, sublen);
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700310 }
311 }
312}
313
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700314// Foreground waits for exit of the main persistent threads
315// that are started here. The threads are created to manage
316// UNIX domain client sockets for writing, reading and
317// controlling the user space logger, and for any additional
318// logging plugins like auditd and restart control. Additional
319// transitory per-client threads are created for each reader.
320int main(int argc, char *argv[]) {
Mark Salyzyna1aacb72014-10-15 08:49:39 -0700321 int fdPmesg = -1;
Mark Salyzynf10e2732016-09-27 13:08:23 -0700322 bool klogd = __android_logger_property_get_bool("logd.kernel",
323 BOOL_DEFAULT_TRUE |
324 BOOL_DEFAULT_FLAG_PERSIST |
325 BOOL_DEFAULT_FLAG_ENG |
326 BOOL_DEFAULT_FLAG_SVELTE);
Mark Salyzyna1aacb72014-10-15 08:49:39 -0700327 if (klogd) {
328 fdPmesg = open("/proc/kmsg", O_RDONLY | O_NDELAY);
329 }
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700330 fdDmesg = open("/dev/kmsg", O_WRONLY);
331
332 // issue reinit command. KISS argument parsing.
333 if ((argc > 1) && argv[1] && !strcmp(argv[1], "--reinit")) {
334 int sock = TEMP_FAILURE_RETRY(
335 socket_local_client("logd",
336 ANDROID_SOCKET_NAMESPACE_RESERVED,
337 SOCK_STREAM));
338 if (sock < 0) {
339 return -errno;
340 }
341 static const char reinit[] = "reinit";
342 ssize_t ret = TEMP_FAILURE_RETRY(write(sock, reinit, sizeof(reinit)));
343 if (ret < 0) {
344 return -errno;
345 }
346 struct pollfd p;
347 memset(&p, 0, sizeof(p));
348 p.fd = sock;
349 p.events = POLLIN;
Mark Salyzynf011a332015-12-10 11:27:03 -0800350 ret = TEMP_FAILURE_RETRY(poll(&p, 1, 1000));
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700351 if (ret < 0) {
352 return -errno;
353 }
354 if ((ret == 0) || !(p.revents & POLLIN)) {
355 return -ETIME;
356 }
357 static const char success[] = "success";
358 char buffer[sizeof(success) - 1];
359 memset(buffer, 0, sizeof(buffer));
360 ret = TEMP_FAILURE_RETRY(read(sock, buffer, sizeof(buffer)));
361 if (ret < 0) {
362 return -errno;
363 }
364 return strncmp(buffer, success, sizeof(success) - 1) != 0;
365 }
366
367 // Reinit Thread
368 sem_init(&reinit, 0, 0);
Mark Salyzyn08739ba2015-03-16 08:26:05 -0700369 sem_init(&uidName, 0, 0);
Mark Salyzyn95108f12015-04-20 07:26:27 -0700370 sem_init(&sem_name, 0, 1);
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700371 pthread_attr_t attr;
372 if (!pthread_attr_init(&attr)) {
373 struct sched_param param;
374
375 memset(&param, 0, sizeof(param));
376 pthread_attr_setschedparam(&attr, &param);
377 pthread_attr_setschedpolicy(&attr, SCHED_BATCH);
378 if (!pthread_attr_setdetachstate(&attr,
379 PTHREAD_CREATE_DETACHED)) {
380 pthread_t thread;
381 reinit_running = true;
382 if (pthread_create(&thread, &attr, reinit_thread_start, NULL)) {
383 reinit_running = false;
384 }
385 }
386 pthread_attr_destroy(&attr);
Mark Salyzyne9bebd02014-04-03 09:55:26 -0700387 }
388
Mark Salyzyn0175b072014-02-26 09:50:16 -0800389 if (drop_privs() != 0) {
390 return -1;
391 }
392
393 // Serves the purpose of managing the last logs times read on a
394 // socket connection, and as a reader lock on a range of log
395 // entries.
396
397 LastLogTimes *times = new LastLogTimes();
398
399 // LogBuffer is the object which is responsible for holding all
400 // log entries.
401
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700402 logBuf = new LogBuffer(times);
403
404 signal(SIGHUP, reinit_signal_handler);
Mark Salyzyn0175b072014-02-26 09:50:16 -0800405
Mark Salyzynf10e2732016-09-27 13:08:23 -0700406 if (__android_logger_property_get_bool("logd.statistics",
407 BOOL_DEFAULT_TRUE |
408 BOOL_DEFAULT_FLAG_PERSIST |
409 BOOL_DEFAULT_FLAG_ENG |
410 BOOL_DEFAULT_FLAG_SVELTE)) {
Mark Salyzyna1aacb72014-10-15 08:49:39 -0700411 logBuf->enableStatistics();
Mark Salyzynf5fc5092014-09-21 14:22:18 -0700412 }
Mark Salyzyne457b742014-02-19 17:18:31 -0800413
Mark Salyzyn0175b072014-02-26 09:50:16 -0800414 // LogReader listens on /dev/socket/logdr. When a client
415 // connects, log entries in the LogBuffer are written to the client.
416
417 LogReader *reader = new LogReader(logBuf);
418 if (reader->startListener()) {
419 exit(1);
420 }
421
422 // LogListener listens on /dev/socket/logdw for client
423 // initiated log messages. New log entries are added to LogBuffer
424 // and LogReader is notified to send updates to connected clients.
425
426 LogListener *swl = new LogListener(logBuf, reader);
Mark Salyzyn581edc12013-11-20 13:38:52 -0800427 // Backlog and /proc/sys/net/unix/max_dgram_qlen set to large value
Mark Salyzyn39944c82015-09-08 11:24:07 -0700428 if (swl->startListener(600)) {
Mark Salyzyn0175b072014-02-26 09:50:16 -0800429 exit(1);
430 }
431
432 // Command listener listens on /dev/socket/logd for incoming logd
433 // administrative commands.
434
435 CommandListener *cl = new CommandListener(logBuf, reader, swl);
436 if (cl->startListener()) {
437 exit(1);
438 }
439
William Roberts29d238d2013-02-08 09:45:26 +0900440 // LogAudit listens on NETLINK_AUDIT socket for selinux
441 // initiated log messages. New log entries are added to LogBuffer
442 // and LogReader is notified to send updates to connected clients.
443
Mark Salyzynf10e2732016-09-27 13:08:23 -0700444 bool auditd = __android_logger_property_get_bool("logd.auditd",
445 BOOL_DEFAULT_TRUE |
446 BOOL_DEFAULT_FLAG_PERSIST);
Sami Tolvanena742d102016-06-14 18:04:43 +0000447 LogAudit *al = NULL;
448 if (auditd) {
449 al = new LogAudit(logBuf, reader,
Mark Salyzynf10e2732016-09-27 13:08:23 -0700450 __android_logger_property_get_bool(
451 "logd.auditd.dmesg",
452 BOOL_DEFAULT_TRUE | BOOL_DEFAULT_FLAG_PERSIST)
453 ? fdDmesg
454 : -1);
Sami Tolvanena742d102016-06-14 18:04:43 +0000455 }
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700456
Mark Salyzyna1aacb72014-10-15 08:49:39 -0700457 LogKlog *kl = NULL;
458 if (klogd) {
Sami Tolvanena742d102016-06-14 18:04:43 +0000459 kl = new LogKlog(logBuf, reader, fdDmesg, fdPmesg, al != NULL);
Mark Salyzyna1aacb72014-10-15 08:49:39 -0700460 }
Mark Salyzyneb06de72014-10-13 09:59:37 -0700461
Sami Tolvanena742d102016-06-14 18:04:43 +0000462 readDmesg(al, kl);
Mark Salyzyneb06de72014-10-13 09:59:37 -0700463
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700464 // failure is an option ... messages are in dmesg (required by standard)
Mark Salyzyneb06de72014-10-13 09:59:37 -0700465
Mark Salyzynd5600fd2015-06-12 14:59:42 -0700466 if (kl && kl->startListener()) {
467 delete kl;
468 }
Mark Salyzyneb06de72014-10-13 09:59:37 -0700469
Sami Tolvanena742d102016-06-14 18:04:43 +0000470 if (al && al->startListener()) {
471 delete al;
William Roberts29d238d2013-02-08 09:45:26 +0900472 }
473
Mark Salyzyn11e55cb2015-03-10 16:45:17 -0700474 TEMP_FAILURE_RETRY(pause());
475
Mark Salyzyn0175b072014-02-26 09:50:16 -0800476 exit(0);
477}