| /* |
| * Copyright (C) 2018 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <paths.h> |
| #include <stdlib.h> |
| #include <sys/mount.h> |
| #include <sys/stat.h> |
| #include <sys/sysmacros.h> |
| #include <sys/types.h> |
| #include <unistd.h> |
| |
| #include <string> |
| #include <vector> |
| |
| #include <android-base/chrono_utils.h> |
| #include <android-base/logging.h> |
| #include <cutils/android_reboot.h> |
| #include <private/android_filesystem_config.h> |
| |
| #include "first_stage_mount.h" |
| #include "reboot_utils.h" |
| #include "util.h" |
| |
| using android::base::boot_clock; |
| |
| namespace android { |
| namespace init { |
| |
| int main(int argc, char** argv) { |
| if (REBOOT_BOOTLOADER_ON_PANIC) { |
| InstallRebootSignalHandlers(); |
| } |
| |
| boot_clock::time_point start_time = boot_clock::now(); |
| |
| std::vector<std::pair<std::string, int>> errors; |
| #define CHECKCALL(x) \ |
| if (x != 0) errors.emplace_back(#x " failed", errno); |
| |
| // Clear the umask. |
| umask(0); |
| |
| CHECKCALL(clearenv()); |
| CHECKCALL(setenv("PATH", _PATH_DEFPATH, 1)); |
| // Get the basic filesystem setup we need put together in the initramdisk |
| // on / and then we'll let the rc file figure out the rest. |
| CHECKCALL(mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755")); |
| CHECKCALL(mkdir("/dev/pts", 0755)); |
| CHECKCALL(mkdir("/dev/socket", 0755)); |
| CHECKCALL(mount("devpts", "/dev/pts", "devpts", 0, NULL)); |
| #define MAKE_STR(x) __STRING(x) |
| CHECKCALL(mount("proc", "/proc", "proc", 0, "hidepid=2,gid=" MAKE_STR(AID_READPROC))); |
| #undef MAKE_STR |
| // Don't expose the raw commandline to unprivileged processes. |
| CHECKCALL(chmod("/proc/cmdline", 0440)); |
| gid_t groups[] = {AID_READPROC}; |
| CHECKCALL(setgroups(arraysize(groups), groups)); |
| CHECKCALL(mount("sysfs", "/sys", "sysfs", 0, NULL)); |
| CHECKCALL(mount("selinuxfs", "/sys/fs/selinux", "selinuxfs", 0, NULL)); |
| |
| CHECKCALL(mknod("/dev/kmsg", S_IFCHR | 0600, makedev(1, 11))); |
| |
| if constexpr (WORLD_WRITABLE_KMSG) { |
| CHECKCALL(mknod("/dev/kmsg_debug", S_IFCHR | 0622, makedev(1, 11))); |
| } |
| |
| CHECKCALL(mknod("/dev/random", S_IFCHR | 0666, makedev(1, 8))); |
| CHECKCALL(mknod("/dev/urandom", S_IFCHR | 0666, makedev(1, 9))); |
| |
| // This is needed for log wrapper, which gets called before ueventd runs. |
| CHECKCALL(mknod("/dev/ptmx", S_IFCHR | 0666, makedev(5, 2))); |
| CHECKCALL(mknod("/dev/null", S_IFCHR | 0666, makedev(1, 3))); |
| |
| // Mount staging areas for devices managed by vold |
| // See storage config details at http://source.android.com/devices/storage/ |
| CHECKCALL(mount("tmpfs", "/mnt", "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV, |
| "mode=0755,uid=0,gid=1000")); |
| // /mnt/vendor is used to mount vendor-specific partitions that can not be |
| // part of the vendor partition, e.g. because they are mounted read-write. |
| CHECKCALL(mkdir("/mnt/vendor", 0755)); |
| // /mnt/product is used to mount product-specific partitions that can not be |
| // part of the product partition, e.g. because they are mounted read-write. |
| CHECKCALL(mkdir("/mnt/product", 0755)); |
| |
| #undef CHECKCALL |
| |
| // Now that tmpfs is mounted on /dev and we have /dev/kmsg, we can actually |
| // talk to the outside world... |
| android::base::InitLogging(argv, &android::base::KernelLogger, [](const char*) { |
| RebootSystem(ANDROID_RB_RESTART2, "bootloader"); |
| }); |
| |
| if (!errors.empty()) { |
| for (const auto& [error_string, error_errno] : errors) { |
| LOG(ERROR) << error_string << " " << strerror(error_errno); |
| } |
| LOG(FATAL) << "Init encountered errors starting first stage, aborting"; |
| } |
| |
| LOG(INFO) << "init first stage started!"; |
| |
| if (!DoFirstStageMount()) { |
| LOG(FATAL) << "Failed to mount required partitions early ..."; |
| } |
| |
| SetInitAvbVersionInRecovery(); |
| |
| static constexpr uint32_t kNanosecondsPerMillisecond = 1e6; |
| uint64_t start_ms = start_time.time_since_epoch().count() / kNanosecondsPerMillisecond; |
| setenv("INIT_STARTED_AT", std::to_string(start_ms).c_str(), 1); |
| |
| const char* path = "/system/bin/init"; |
| const char* args[] = {path, nullptr}; |
| execv(path, const_cast<char**>(args)); |
| |
| // execv() only returns if an error happened, in which case we |
| // panic and never fall through this conditional. |
| PLOG(FATAL) << "execv(\"" << path << "\") failed"; |
| |
| return 1; |
| } |
| |
| } // namespace init |
| } // namespace android |
| |
| int main(int argc, char** argv) { |
| return android::init::main(argc, argv); |
| } |