init.cpp revision a1f6a4b13921f61799be14a2544bdbf95958eae7 
1/*
2 * Copyright (C) 2008 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 <ctype.h>
18#include <dirent.h>
19#include <errno.h>
20#include <fcntl.h>
21#include <libgen.h>
22#include <paths.h>
23#include <signal.h>
24#include <stdarg.h>
25#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
28#include <sys/epoll.h>
29#include <sys/mount.h>
30#include <sys/socket.h>
31#include <sys/stat.h>
32#include <sys/types.h>
33#include <sys/un.h>
34#include <sys/wait.h>
35#include <termios.h>
36#include <unistd.h>
37
38#include <mtd/mtd-user.h>
39
40#include <selinux/selinux.h>
41#include <selinux/label.h>
42#include <selinux/android.h>
43
44#include <base/file.h>
45#include <base/stringprintf.h>
46#include <cutils/android_reboot.h>
47#include <cutils/fs.h>
48#include <cutils/iosched_policy.h>
49#include <cutils/list.h>
50#include <cutils/sockets.h>
51#include <private/android_filesystem_config.h>
52
53#include <memory>
54
55#include "devices.h"
56#include "init.h"
57#include "log.h"
58#include "property_service.h"
59#include "bootchart.h"
60#include "signal_handler.h"
61#include "keychords.h"
62#include "init_parser.h"
63#include "util.h"
64#include "ueventd.h"
65#include "watchdogd.h"
66
67struct selabel_handle *sehandle;
68struct selabel_handle *sehandle_prop;
69
70static int property_triggers_enabled = 0;
71
72static char qemu[32];
73
74static struct action *cur_action = NULL;
75static struct command *cur_command = NULL;
76
77static int have_console;
78static char console_name[PROP_VALUE_MAX] = "/dev/console";
79static time_t process_needs_restart;
80
81static const char *ENV[32];
82
83bool waiting_for_exec = false;
84
85static int epoll_fd = -1;
86
87void register_epoll_handler(int fd, void (*fn)()) {
88    epoll_event ev;
89    ev.events = EPOLLIN;
90    ev.data.ptr = reinterpret_cast<void*>(fn);
91    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev) == -1) {
92        ERROR("epoll_ctl failed: %s\n", strerror(errno));
93    }
94}
95
96void service::NotifyStateChange(const char* new_state) {
97    if (!properties_initialized()) {
98        // If properties aren't available yet, we can't set them.
99        return;
100    }
101
102    if ((flags & SVC_EXEC) != 0) {
103        // 'exec' commands don't have properties tracking their state.
104        return;
105    }
106
107    char prop_name[PROP_NAME_MAX];
108    if (snprintf(prop_name, sizeof(prop_name), "init.svc.%s", name) >= PROP_NAME_MAX) {
109        // If the property name would be too long, we can't set it.
110        ERROR("Property name \"init.svc.%s\" too long; not setting to %s\n", name, new_state);
111        return;
112    }
113
114    property_set(prop_name, new_state);
115}
116
117/* add_environment - add "key=value" to the current environment */
118int add_environment(const char *key, const char *val)
119{
120    size_t n;
121    size_t key_len = strlen(key);
122
123    /* The last environment entry is reserved to terminate the list */
124    for (n = 0; n < (ARRAY_SIZE(ENV) - 1); n++) {
125
126        /* Delete any existing entry for this key */
127        if (ENV[n] != NULL) {
128            size_t entry_key_len = strcspn(ENV[n], "=");
129            if ((entry_key_len == key_len) && (strncmp(ENV[n], key, entry_key_len) == 0)) {
130                free((char*)ENV[n]);
131                ENV[n] = NULL;
132            }
133        }
134
135        /* Add entry if a free slot is available */
136        if (ENV[n] == NULL) {
137            char* entry;
138            asprintf(&entry, "%s=%s", key, val);
139            ENV[n] = entry;
140            return 0;
141        }
142    }
143
144    ERROR("No env. room to store: '%s':'%s'\n", key, val);
145
146    return -1;
147}
148
149void zap_stdio(void)
150{
151    int fd;
152    fd = open("/dev/null", O_RDWR);
153    dup2(fd, 0);
154    dup2(fd, 1);
155    dup2(fd, 2);
156    close(fd);
157}
158
159static void open_console()
160{
161    int fd;
162    if ((fd = open(console_name, O_RDWR)) < 0) {
163        fd = open("/dev/null", O_RDWR);
164    }
165    ioctl(fd, TIOCSCTTY, 0);
166    dup2(fd, 0);
167    dup2(fd, 1);
168    dup2(fd, 2);
169    close(fd);
170}
171
172static void publish_socket(const char *name, int fd)
173{
174    char key[64] = ANDROID_SOCKET_ENV_PREFIX;
175    char val[64];
176
177    strlcpy(key + sizeof(ANDROID_SOCKET_ENV_PREFIX) - 1,
178            name,
179            sizeof(key) - sizeof(ANDROID_SOCKET_ENV_PREFIX));
180    snprintf(val, sizeof(val), "%d", fd);
181    add_environment(key, val);
182
183    /* make sure we don't close-on-exec */
184    fcntl(fd, F_SETFD, 0);
185}
186
187void service_start(struct service *svc, const char *dynamic_args)
188{
189    // Starting a service removes it from the disabled or reset state and
190    // immediately takes it out of the restarting state if it was in there.
191    svc->flags &= (~(SVC_DISABLED|SVC_RESTARTING|SVC_RESET|SVC_RESTART|SVC_DISABLED_START));
192    svc->time_started = 0;
193
194    // Running processes require no additional work --- if they're in the
195    // process of exiting, we've ensured that they will immediately restart
196    // on exit, unless they are ONESHOT.
197    if (svc->flags & SVC_RUNNING) {
198        return;
199    }
200
201    bool needs_console = (svc->flags & SVC_CONSOLE);
202    if (needs_console && !have_console) {
203        ERROR("service '%s' requires console\n", svc->name);
204        svc->flags |= SVC_DISABLED;
205        return;
206    }
207
208    struct stat s;
209    if (stat(svc->args[0], &s) != 0) {
210        ERROR("cannot find '%s', disabling '%s'\n", svc->args[0], svc->name);
211        svc->flags |= SVC_DISABLED;
212        return;
213    }
214
215    if ((!(svc->flags & SVC_ONESHOT)) && dynamic_args) {
216        ERROR("service '%s' must be one-shot to use dynamic args, disabling\n",
217               svc->args[0]);
218        svc->flags |= SVC_DISABLED;
219        return;
220    }
221
222    char* scon = NULL;
223    if (is_selinux_enabled() > 0) {
224        if (svc->seclabel) {
225            scon = strdup(svc->seclabel);
226            if (!scon) {
227                ERROR("Out of memory while starting '%s'\n", svc->name);
228                return;
229            }
230        } else {
231            char *mycon = NULL, *fcon = NULL;
232
233            INFO("computing context for service '%s'\n", svc->args[0]);
234            int rc = getcon(&mycon);
235            if (rc < 0) {
236                ERROR("could not get context while starting '%s'\n", svc->name);
237                return;
238            }
239
240            rc = getfilecon(svc->args[0], &fcon);
241            if (rc < 0) {
242                ERROR("could not get context while starting '%s'\n", svc->name);
243                freecon(mycon);
244                return;
245            }
246
247            rc = security_compute_create(mycon, fcon, string_to_security_class("process"), &scon);
248            if (rc == 0 && !strcmp(scon, mycon)) {
249                ERROR("Warning!  Service %s needs a SELinux domain defined; please fix!\n", svc->name);
250            }
251            freecon(mycon);
252            freecon(fcon);
253            if (rc < 0) {
254                ERROR("could not get context while starting '%s'\n", svc->name);
255                return;
256            }
257        }
258    }
259
260    NOTICE("Starting service '%s'...\n", svc->name);
261
262    pid_t pid = fork();
263    if (pid == 0) {
264        struct socketinfo *si;
265        struct svcenvinfo *ei;
266        char tmp[32];
267        int fd, sz;
268
269        umask(077);
270        if (properties_initialized()) {
271            get_property_workspace(&fd, &sz);
272            snprintf(tmp, sizeof(tmp), "%d,%d", dup(fd), sz);
273            add_environment("ANDROID_PROPERTY_WORKSPACE", tmp);
274        }
275
276        for (ei = svc->envvars; ei; ei = ei->next)
277            add_environment(ei->name, ei->value);
278
279        for (si = svc->sockets; si; si = si->next) {
280            int socket_type = (
281                    !strcmp(si->type, "stream") ? SOCK_STREAM :
282                        (!strcmp(si->type, "dgram") ? SOCK_DGRAM : SOCK_SEQPACKET));
283            int s = create_socket(si->name, socket_type,
284                                  si->perm, si->uid, si->gid, si->socketcon ?: scon);
285            if (s >= 0) {
286                publish_socket(si->name, s);
287            }
288        }
289
290        freecon(scon);
291        scon = NULL;
292
293        if (svc->ioprio_class != IoSchedClass_NONE) {
294            if (android_set_ioprio(getpid(), svc->ioprio_class, svc->ioprio_pri)) {
295                ERROR("Failed to set pid %d ioprio = %d,%d: %s\n",
296                      getpid(), svc->ioprio_class, svc->ioprio_pri, strerror(errno));
297            }
298        }
299
300        if (needs_console) {
301            setsid();
302            open_console();
303        } else {
304            zap_stdio();
305        }
306
307        if (false) {
308            for (size_t n = 0; svc->args[n]; n++) {
309                INFO("args[%zu] = '%s'\n", n, svc->args[n]);
310            }
311            for (size_t n = 0; ENV[n]; n++) {
312                INFO("env[%zu] = '%s'\n", n, ENV[n]);
313            }
314        }
315
316        setpgid(0, getpid());
317
318        // As requested, set our gid, supplemental gids, and uid.
319        if (svc->gid) {
320            if (setgid(svc->gid) != 0) {
321                ERROR("setgid failed: %s\n", strerror(errno));
322                _exit(127);
323            }
324        }
325        if (svc->nr_supp_gids) {
326            if (setgroups(svc->nr_supp_gids, svc->supp_gids) != 0) {
327                ERROR("setgroups failed: %s\n", strerror(errno));
328                _exit(127);
329            }
330        }
331        if (svc->uid) {
332            if (setuid(svc->uid) != 0) {
333                ERROR("setuid failed: %s\n", strerror(errno));
334                _exit(127);
335            }
336        }
337        if (svc->seclabel) {
338            if (is_selinux_enabled() > 0 && setexeccon(svc->seclabel) < 0) {
339                ERROR("cannot setexeccon('%s'): %s\n", svc->seclabel, strerror(errno));
340                _exit(127);
341            }
342        }
343
344        if (!dynamic_args) {
345            if (execve(svc->args[0], (char**) svc->args, (char**) ENV) < 0) {
346                ERROR("cannot execve('%s'): %s\n", svc->args[0], strerror(errno));
347            }
348        } else {
349            char *arg_ptrs[INIT_PARSER_MAXARGS+1];
350            int arg_idx = svc->nargs;
351            char *tmp = strdup(dynamic_args);
352            char *next = tmp;
353            char *bword;
354
355            /* Copy the static arguments */
356            memcpy(arg_ptrs, svc->args, (svc->nargs * sizeof(char *)));
357
358            while((bword = strsep(&next, " "))) {
359                arg_ptrs[arg_idx++] = bword;
360                if (arg_idx == INIT_PARSER_MAXARGS)
361                    break;
362            }
363            arg_ptrs[arg_idx] = NULL;
364            execve(svc->args[0], (char**) arg_ptrs, (char**) ENV);
365        }
366        _exit(127);
367    }
368
369    freecon(scon);
370
371    if (pid < 0) {
372        ERROR("failed to start '%s'\n", svc->name);
373        svc->pid = 0;
374        return;
375    }
376
377    svc->time_started = gettime();
378    svc->pid = pid;
379    svc->flags |= SVC_RUNNING;
380
381    if ((svc->flags & SVC_EXEC) != 0) {
382        INFO("SVC_EXEC pid %d (uid %d gid %d+%zu context %s) started; waiting...\n",
383             svc->pid, svc->uid, svc->gid, svc->nr_supp_gids, svc->seclabel);
384        waiting_for_exec = true;
385    }
386
387    svc->NotifyStateChange("running");
388}
389
390/* The how field should be either SVC_DISABLED, SVC_RESET, or SVC_RESTART */
391static void service_stop_or_reset(struct service *svc, int how)
392{
393    /* The service is still SVC_RUNNING until its process exits, but if it has
394     * already exited it shoudn't attempt a restart yet. */
395    svc->flags &= ~(SVC_RESTARTING | SVC_DISABLED_START);
396
397    if ((how != SVC_DISABLED) && (how != SVC_RESET) && (how != SVC_RESTART)) {
398        /* Hrm, an illegal flag.  Default to SVC_DISABLED */
399        how = SVC_DISABLED;
400    }
401        /* if the service has not yet started, prevent
402         * it from auto-starting with its class
403         */
404    if (how == SVC_RESET) {
405        svc->flags |= (svc->flags & SVC_RC_DISABLED) ? SVC_DISABLED : SVC_RESET;
406    } else {
407        svc->flags |= how;
408    }
409
410    if (svc->pid) {
411        NOTICE("Service '%s' is being killed...\n", svc->name);
412        kill(-svc->pid, SIGKILL);
413        svc->NotifyStateChange("stopping");
414    } else {
415        svc->NotifyStateChange("stopped");
416    }
417}
418
419void service_reset(struct service *svc)
420{
421    service_stop_or_reset(svc, SVC_RESET);
422}
423
424void service_stop(struct service *svc)
425{
426    service_stop_or_reset(svc, SVC_DISABLED);
427}
428
429void service_restart(struct service *svc)
430{
431    if (svc->flags & SVC_RUNNING) {
432        /* Stop, wait, then start the service. */
433        service_stop_or_reset(svc, SVC_RESTART);
434    } else if (!(svc->flags & SVC_RESTARTING)) {
435        /* Just start the service since it's not running. */
436        service_start(svc, NULL);
437    } /* else: Service is restarting anyways. */
438}
439
440void property_changed(const char *name, const char *value)
441{
442    if (property_triggers_enabled)
443        queue_property_triggers(name, value);
444}
445
446static void restart_service_if_needed(struct service *svc)
447{
448    time_t next_start_time = svc->time_started + 5;
449
450    if (next_start_time <= gettime()) {
451        svc->flags &= (~SVC_RESTARTING);
452        service_start(svc, NULL);
453        return;
454    }
455
456    if ((next_start_time < process_needs_restart) ||
457        (process_needs_restart == 0)) {
458        process_needs_restart = next_start_time;
459    }
460}
461
462static void restart_processes()
463{
464    process_needs_restart = 0;
465    service_for_each_flags(SVC_RESTARTING,
466                           restart_service_if_needed);
467}
468
469static void msg_start(const char *name)
470{
471    struct service *svc = NULL;
472    char *tmp = NULL;
473    char *args = NULL;
474
475    if (!strchr(name, ':'))
476        svc = service_find_by_name(name);
477    else {
478        tmp = strdup(name);
479        if (tmp) {
480            args = strchr(tmp, ':');
481            *args = '\0';
482            args++;
483
484            svc = service_find_by_name(tmp);
485        }
486    }
487
488    if (svc) {
489        service_start(svc, args);
490    } else {
491        ERROR("no such service '%s'\n", name);
492    }
493    if (tmp)
494        free(tmp);
495}
496
497static void msg_stop(const char *name)
498{
499    struct service *svc = service_find_by_name(name);
500
501    if (svc) {
502        service_stop(svc);
503    } else {
504        ERROR("no such service '%s'\n", name);
505    }
506}
507
508static void msg_restart(const char *name)
509{
510    struct service *svc = service_find_by_name(name);
511
512    if (svc) {
513        service_restart(svc);
514    } else {
515        ERROR("no such service '%s'\n", name);
516    }
517}
518
519void handle_control_message(const char *msg, const char *arg)
520{
521    if (!strcmp(msg,"start")) {
522        msg_start(arg);
523    } else if (!strcmp(msg,"stop")) {
524        msg_stop(arg);
525    } else if (!strcmp(msg,"restart")) {
526        msg_restart(arg);
527    } else {
528        ERROR("unknown control msg '%s'\n", msg);
529    }
530}
531
532static struct command *get_first_command(struct action *act)
533{
534    struct listnode *node;
535    node = list_head(&act->commands);
536    if (!node || list_empty(&act->commands))
537        return NULL;
538
539    return node_to_item(node, struct command, clist);
540}
541
542static struct command *get_next_command(struct action *act, struct command *cmd)
543{
544    struct listnode *node;
545    node = cmd->clist.next;
546    if (!node)
547        return NULL;
548    if (node == &act->commands)
549        return NULL;
550
551    return node_to_item(node, struct command, clist);
552}
553
554static int is_last_command(struct action *act, struct command *cmd)
555{
556    return (list_tail(&act->commands) == &cmd->clist);
557}
558
559
560void build_triggers_string(char *name_str, int length, struct action *cur_action) {
561    struct listnode *node;
562    struct trigger *cur_trigger;
563
564    list_for_each(node, &cur_action->triggers) {
565        cur_trigger = node_to_item(node, struct trigger, nlist);
566        if (node != cur_action->triggers.next) {
567            strlcat(name_str, " " , length);
568        }
569        strlcat(name_str, cur_trigger->name , length);
570    }
571}
572
573void execute_one_command() {
574    Timer t;
575
576    char cmd_str[256] = "";
577    char name_str[256] = "";
578
579    if (!cur_action || !cur_command || is_last_command(cur_action, cur_command)) {
580        cur_action = action_remove_queue_head();
581        cur_command = NULL;
582        if (!cur_action) {
583            return;
584        }
585
586        build_triggers_string(name_str, sizeof(name_str), cur_action);
587
588        INFO("processing action %p (%s)\n", cur_action, name_str);
589        cur_command = get_first_command(cur_action);
590    } else {
591        cur_command = get_next_command(cur_action, cur_command);
592    }
593
594    if (!cur_command) {
595        return;
596    }
597
598    int result = cur_command->func(cur_command->nargs, cur_command->args);
599    if (klog_get_level() >= KLOG_INFO_LEVEL) {
600        for (int i = 0; i < cur_command->nargs; i++) {
601            strlcat(cmd_str, cur_command->args[i], sizeof(cmd_str));
602            if (i < cur_command->nargs - 1) {
603                strlcat(cmd_str, " ", sizeof(cmd_str));
604            }
605        }
606        char source[256];
607        if (cur_command->filename) {
608            snprintf(source, sizeof(source), " (%s:%d)", cur_command->filename, cur_command->line);
609        } else {
610            *source = '\0';
611        }
612        INFO("Command '%s' action=%s%s returned %d took %.2fs\n",
613             cmd_str, cur_action ? name_str : "", source, result, t.duration());
614    }
615}
616
617static int wait_for_coldboot_done_action(int nargs, char **args) {
618    Timer t;
619
620    NOTICE("Waiting for %s...\n", COLDBOOT_DONE);
621    if (wait_for_file(COLDBOOT_DONE, COMMAND_RETRY_TIMEOUT)) {
622        ERROR("Timed out waiting for %s\n", COLDBOOT_DONE);
623    }
624
625    NOTICE("Waiting for %s took %.2fs.\n", COLDBOOT_DONE, t.duration());
626    return 0;
627}
628
629/*
630 * Writes 512 bytes of output from Hardware RNG (/dev/hw_random, backed
631 * by Linux kernel's hw_random framework) into Linux RNG's via /dev/urandom.
632 * Does nothing if Hardware RNG is not present.
633 *
634 * Since we don't yet trust the quality of Hardware RNG, these bytes are not
635 * mixed into the primary pool of Linux RNG and the entropy estimate is left
636 * unmodified.
637 *
638 * If the HW RNG device /dev/hw_random is present, we require that at least
639 * 512 bytes read from it are written into Linux RNG. QA is expected to catch
640 * devices/configurations where these I/O operations are blocking for a long
641 * time. We do not reboot or halt on failures, as this is a best-effort
642 * attempt.
643 */
644static int mix_hwrng_into_linux_rng_action(int nargs, char **args)
645{
646    int result = -1;
647    int hwrandom_fd = -1;
648    int urandom_fd = -1;
649    char buf[512];
650    ssize_t chunk_size;
651    size_t total_bytes_written = 0;
652
653    hwrandom_fd = TEMP_FAILURE_RETRY(
654            open("/dev/hw_random", O_RDONLY | O_NOFOLLOW | O_CLOEXEC));
655    if (hwrandom_fd == -1) {
656        if (errno == ENOENT) {
657          ERROR("/dev/hw_random not found\n");
658          /* It's not an error to not have a Hardware RNG. */
659          result = 0;
660        } else {
661          ERROR("Failed to open /dev/hw_random: %s\n", strerror(errno));
662        }
663        goto ret;
664    }
665
666    urandom_fd = TEMP_FAILURE_RETRY(
667            open("/dev/urandom", O_WRONLY | O_NOFOLLOW | O_CLOEXEC));
668    if (urandom_fd == -1) {
669        ERROR("Failed to open /dev/urandom: %s\n", strerror(errno));
670        goto ret;
671    }
672
673    while (total_bytes_written < sizeof(buf)) {
674        chunk_size = TEMP_FAILURE_RETRY(
675                read(hwrandom_fd, buf, sizeof(buf) - total_bytes_written));
676        if (chunk_size == -1) {
677            ERROR("Failed to read from /dev/hw_random: %s\n", strerror(errno));
678            goto ret;
679        } else if (chunk_size == 0) {
680            ERROR("Failed to read from /dev/hw_random: EOF\n");
681            goto ret;
682        }
683
684        chunk_size = TEMP_FAILURE_RETRY(write(urandom_fd, buf, chunk_size));
685        if (chunk_size == -1) {
686            ERROR("Failed to write to /dev/urandom: %s\n", strerror(errno));
687            goto ret;
688        }
689        total_bytes_written += chunk_size;
690    }
691
692    INFO("Mixed %zu bytes from /dev/hw_random into /dev/urandom",
693                total_bytes_written);
694    result = 0;
695
696ret:
697    if (hwrandom_fd != -1) {
698        close(hwrandom_fd);
699    }
700    if (urandom_fd != -1) {
701        close(urandom_fd);
702    }
703    return result;
704}
705
706static int keychord_init_action(int nargs, char **args)
707{
708    keychord_init();
709    return 0;
710}
711
712static int console_init_action(int nargs, char **args)
713{
714    char console[PROP_VALUE_MAX];
715    if (property_get("ro.boot.console", console) > 0) {
716        snprintf(console_name, sizeof(console_name), "/dev/%s", console);
717    }
718
719    int fd = open(console_name, O_RDWR | O_CLOEXEC);
720    if (fd >= 0)
721        have_console = 1;
722    close(fd);
723
724    fd = open("/dev/tty0", O_WRONLY | O_CLOEXEC);
725    if (fd >= 0) {
726        const char *msg;
727            msg = "\n"
728        "\n"
729        "\n"
730        "\n"
731        "\n"
732        "\n"
733        "\n"  // console is 40 cols x 30 lines
734        "\n"
735        "\n"
736        "\n"
737        "\n"
738        "\n"
739        "\n"
740        "\n"
741        "             A N D R O I D ";
742        write(fd, msg, strlen(msg));
743        close(fd);
744    }
745
746    return 0;
747}
748
749static void import_kernel_nv(char *name, int for_emulator)
750{
751    char *value = strchr(name, '=');
752    int name_len = strlen(name);
753
754    if (value == 0) return;
755    *value++ = 0;
756    if (name_len == 0) return;
757
758    if (for_emulator) {
759        /* in the emulator, export any kernel option with the
760         * ro.kernel. prefix */
761        char buff[PROP_NAME_MAX];
762        int len = snprintf( buff, sizeof(buff), "ro.kernel.%s", name );
763
764        if (len < (int)sizeof(buff))
765            property_set( buff, value );
766        return;
767    }
768
769    if (!strcmp(name,"qemu")) {
770        strlcpy(qemu, value, sizeof(qemu));
771    } else if (!strncmp(name, "androidboot.", 12) && name_len > 12) {
772        const char *boot_prop_name = name + 12;
773        char prop[PROP_NAME_MAX];
774        int cnt;
775
776        cnt = snprintf(prop, sizeof(prop), "ro.boot.%s", boot_prop_name);
777        if (cnt < PROP_NAME_MAX)
778            property_set(prop, value);
779    }
780}
781
782static void export_kernel_boot_props() {
783    struct {
784        const char *src_prop;
785        const char *dst_prop;
786        const char *default_value;
787    } prop_map[] = {
788        { "ro.boot.serialno",   "ro.serialno",   "", },
789        { "ro.boot.mode",       "ro.bootmode",   "unknown", },
790        { "ro.boot.baseband",   "ro.baseband",   "unknown", },
791        { "ro.boot.bootloader", "ro.bootloader", "unknown", },
792        { "ro.boot.hardware",   "ro.hardware",   "unknown", },
793        { "ro.boot.revision",   "ro.revision",   "0", },
794    };
795    for (size_t i = 0; i < ARRAY_SIZE(prop_map); i++) {
796        char value[PROP_VALUE_MAX];
797        int rc = property_get(prop_map[i].src_prop, value);
798        property_set(prop_map[i].dst_prop, (rc > 0) ? value : prop_map[i].default_value);
799    }
800}
801
802static void process_kernel_dt(void)
803{
804    static const char android_dir[] = "/proc/device-tree/firmware/android";
805
806    std::string file_name = android::base::StringPrintf("%s/compatible", android_dir);
807
808    std::string dt_file;
809    android::base::ReadFileToString(file_name, &dt_file);
810    if (!dt_file.compare("android,firmware")) {
811        ERROR("firmware/android is not compatible with 'android,firmware'\n");
812        return;
813    }
814
815    std::unique_ptr<DIR, int(*)(DIR*)>dir(opendir(android_dir), closedir);
816    if (!dir)
817        return;
818
819    struct dirent *dp;
820    while ((dp = readdir(dir.get())) != NULL) {
821        if (dp->d_type != DT_REG || !strcmp(dp->d_name, "compatible"))
822            continue;
823
824        file_name = android::base::StringPrintf("%s/%s", android_dir, dp->d_name);
825
826        android::base::ReadFileToString(file_name, &dt_file);
827        std::replace(dt_file.begin(), dt_file.end(), ',', '.');
828
829        std::string property_name = android::base::StringPrintf("ro.boot.%s", dp->d_name);
830        property_set(property_name.c_str(), dt_file.c_str());
831    }
832}
833
834static void process_kernel_cmdline(void)
835{
836    /* don't expose the raw commandline to nonpriv processes */
837    chmod("/proc/cmdline", 0440);
838
839    /* first pass does the common stuff, and finds if we are in qemu.
840     * second pass is only necessary for qemu to export all kernel params
841     * as props.
842     */
843    import_kernel_cmdline(0, import_kernel_nv);
844    if (qemu[0])
845        import_kernel_cmdline(1, import_kernel_nv);
846}
847
848static int queue_property_triggers_action(int nargs, char **args)
849{
850    queue_all_property_triggers();
851    /* enable property triggers */
852    property_triggers_enabled = 1;
853    return 0;
854}
855
856static void selinux_init_all_handles(void)
857{
858    sehandle = selinux_android_file_context_handle();
859    selinux_android_set_sehandle(sehandle);
860    sehandle_prop = selinux_android_prop_context_handle();
861}
862
863static bool selinux_is_disabled(void)
864{
865    if (ALLOW_DISABLE_SELINUX) {
866        if (access("/sys/fs/selinux", F_OK) != 0) {
867            // SELinux is not compiled into the kernel, or has been disabled
868            // via the kernel command line "selinux=0".
869            return true;
870        }
871
872        char tmp[PROP_VALUE_MAX];
873        if ((property_get("ro.boot.selinux", tmp) != 0) && (strcmp(tmp, "disabled") == 0)) {
874            // SELinux is compiled into the kernel, but we've been told to disable it.
875            return true;
876        }
877    }
878
879    return false;
880}
881
882static bool selinux_is_enforcing(void)
883{
884    if (ALLOW_DISABLE_SELINUX) {
885        char tmp[PROP_VALUE_MAX];
886        if (property_get("ro.boot.selinux", tmp) == 0) {
887            // Property is not set.  Assume enforcing.
888            return true;
889        }
890
891        if (strcmp(tmp, "permissive") == 0) {
892            // SELinux is in the kernel, but we've been told to go into permissive mode.
893            return false;
894        }
895
896        if (strcmp(tmp, "enforcing") != 0) {
897            ERROR("SELinux: Unknown value of ro.boot.selinux. Got: \"%s\". Assuming enforcing.\n", tmp);
898        }
899    }
900    return true;
901}
902
903int selinux_reload_policy(void)
904{
905    if (selinux_is_disabled()) {
906        return -1;
907    }
908
909    INFO("SELinux: Attempting to reload policy files\n");
910
911    if (selinux_android_reload_policy() == -1) {
912        return -1;
913    }
914
915    if (sehandle)
916        selabel_close(sehandle);
917
918    if (sehandle_prop)
919        selabel_close(sehandle_prop);
920
921    selinux_init_all_handles();
922    return 0;
923}
924
925static int audit_callback(void *data, security_class_t /*cls*/, char *buf, size_t len) {
926    snprintf(buf, len, "property=%s", !data ? "NULL" : (char *)data);
927    return 0;
928}
929
930static void security_failure() {
931    ERROR("Security failure; rebooting into recovery mode...\n");
932    android_reboot(ANDROID_RB_RESTART2, 0, "recovery");
933    while (true) { pause(); }  // never reached
934}
935
936static void selinux_initialize(bool in_kernel_domain) {
937    Timer t;
938
939    selinux_callback cb;
940    cb.func_log = selinux_klog_callback;
941    selinux_set_callback(SELINUX_CB_LOG, cb);
942    cb.func_audit = audit_callback;
943    selinux_set_callback(SELINUX_CB_AUDIT, cb);
944
945    if (selinux_is_disabled()) {
946        return;
947    }
948
949    if (in_kernel_domain) {
950        if (write_file("/sys/fs/selinux/checkreqprot", "0") == -1) {
951            ERROR("couldn't write to /sys/fs/selinux/checkreqprot: %s\n",
952                  strerror(errno));
953            security_failure();
954        }
955
956        INFO("Loading SELinux policy...\n");
957        if (selinux_android_load_policy() < 0) {
958            ERROR("failed to load policy: %s\n", strerror(errno));
959            security_failure();
960        }
961
962        bool is_enforcing = selinux_is_enforcing();
963        security_setenforce(is_enforcing);
964
965        NOTICE("(Initializing SELinux %s took %.2fs.)\n",
966               is_enforcing ? "enforcing" : "non-enforcing", t.duration());
967    } else {
968        selinux_init_all_handles();
969    }
970}
971
972int main(int argc, char** argv) {
973    if (!strcmp(basename(argv[0]), "ueventd")) {
974        return ueventd_main(argc, argv);
975    }
976
977    if (!strcmp(basename(argv[0]), "watchdogd")) {
978        return watchdogd_main(argc, argv);
979    }
980
981    // Clear the umask.
982    umask(0);
983
984    add_environment("PATH", _PATH_DEFPATH);
985
986    // Get the basic filesystem setup we need put together in the initramdisk
987    // on / and then we'll let the rc file figure out the rest.
988    mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
989    mkdir("/dev/pts", 0755);
990    mkdir("/dev/socket", 0755);
991    mount("devpts", "/dev/pts", "devpts", 0, NULL);
992    mount("proc", "/proc", "proc", 0, NULL);
993    mount("sysfs", "/sys", "sysfs", 0, NULL);
994
995    // Indicate that booting is in progress to background fw loaders, etc.
996    close(open("/dev/.booting", O_WRONLY | O_CREAT | O_CLOEXEC, 0000));
997
998    // We must have some place other than / to create the device nodes for
999    // kmsg and null, otherwise we won't be able to remount / read-only
1000    // later on. Now that tmpfs is mounted on /dev, we can actually talk
1001    // to the outside world.
1002    open_devnull_stdio();
1003    klog_init();
1004    klog_set_level(KLOG_NOTICE_LEVEL);
1005
1006    bool is_first_stage = (argc == 1) || (strcmp(argv[1], "--second-stage") != 0);
1007    NOTICE("init%s started!\n", is_first_stage ? "" : " second stage");
1008
1009    property_init();
1010
1011    // If arguments are passed both on the command line and in DT,
1012    // properties set in DT always have priority over the command-line ones.
1013    process_kernel_dt();
1014    process_kernel_cmdline();
1015
1016    // Propogate the kernel variables to internal variables
1017    // used by init as well as the current required properties.
1018    export_kernel_boot_props();
1019
1020    // Set up SELinux, including loading the SELinux policy if we're in the kernel domain.
1021    selinux_initialize(is_first_stage);
1022
1023    // If we're in the kernel domain, re-exec init to transition to the init domain now
1024    // that the SELinux policy has been loaded.
1025    if (is_first_stage) {
1026        if (restorecon("/init") == -1) {
1027            ERROR("restorecon failed: %s\n", strerror(errno));
1028            security_failure();
1029        }
1030        char* path = argv[0];
1031        char* args[] = { path, const_cast<char*>("--second-stage"), nullptr };
1032        if (execv(path, args) == -1) {
1033            ERROR("execv(\"%s\") failed: %s\n", path, strerror(errno));
1034            security_failure();
1035        }
1036    }
1037
1038    // These directories were necessarily created before initial policy load
1039    // and therefore need their security context restored to the proper value.
1040    // This must happen before /dev is populated by ueventd.
1041    INFO("Running restorecon...\n");
1042    restorecon("/dev");
1043    restorecon("/dev/socket");
1044    restorecon("/dev/__properties__");
1045    restorecon_recursive("/sys");
1046
1047    epoll_fd = epoll_create1(EPOLL_CLOEXEC);
1048    if (epoll_fd == -1) {
1049        ERROR("epoll_create1 failed: %s\n", strerror(errno));
1050        exit(1);
1051    }
1052
1053    signal_handler_init();
1054
1055    property_load_boot_defaults();
1056    start_property_service();
1057
1058    init_parse_config_file("/init.rc");
1059
1060    action_for_each_trigger("early-init", action_add_queue_tail);
1061
1062    // Queue an action that waits for coldboot done so we know ueventd has set up all of /dev...
1063    queue_builtin_action(wait_for_coldboot_done_action, "wait_for_coldboot_done");
1064    // ... so that we can start queuing up actions that require stuff from /dev.
1065    queue_builtin_action(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
1066    queue_builtin_action(keychord_init_action, "keychord_init");
1067    queue_builtin_action(console_init_action, "console_init");
1068
1069    // Trigger all the boot actions to get us started.
1070    action_for_each_trigger("init", action_add_queue_tail);
1071
1072    // Repeat mix_hwrng_into_linux_rng in case /dev/hw_random or /dev/random
1073    // wasn't ready immediately after wait_for_coldboot_done
1074    queue_builtin_action(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
1075
1076    // Don't mount filesystems or start core system services in charger mode.
1077    char bootmode[PROP_VALUE_MAX];
1078    if (property_get("ro.bootmode", bootmode) > 0 && strcmp(bootmode, "charger") == 0) {
1079        action_for_each_trigger("charger", action_add_queue_tail);
1080    } else {
1081        action_for_each_trigger("late-init", action_add_queue_tail);
1082    }
1083
1084    // Run all property triggers based on current state of the properties.
1085    queue_builtin_action(queue_property_triggers_action, "queue_property_triggers");
1086
1087    while (true) {
1088        if (!waiting_for_exec) {
1089            execute_one_command();
1090            restart_processes();
1091        }
1092
1093        int timeout = -1;
1094        if (process_needs_restart) {
1095            timeout = (process_needs_restart - gettime()) * 1000;
1096            if (timeout < 0)
1097                timeout = 0;
1098        }
1099
1100        if (!action_queue_empty() || cur_action) {
1101            timeout = 0;
1102        }
1103
1104        bootchart_sample(&timeout);
1105
1106        epoll_event ev;
1107        int nr = TEMP_FAILURE_RETRY(epoll_wait(epoll_fd, &ev, 1, timeout));
1108        if (nr == -1) {
1109            ERROR("epoll_wait failed: %s\n", strerror(errno));
1110        } else if (nr == 1) {
1111            ((void (*)()) ev.data.ptr)();
1112        }
1113    }
1114
1115    return 0;
1116}
1117