int main(void)
{
int count = 15;
mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
mount("sysfs", "/sys", "sysfs", 0, NULL);
klog_init();
klog_set_level(8);
while (1) {
if (!mount_device())
break;
if (count--) {
sleep(2);
dbg("Iago media not found, trying again...\n");
continue;
}
KLOG_ERROR("Iago", "Couldn't find installation media!\n");
exit(1); /* will result in kernel panic */
}
umount("/dev");
umount("/sys");
/* ok, start the real init */
dbg("Installation media mounted, now starting Android init\n");
execl("/init2", "init", NULL);
KLOG_ERROR("Iago", "Failed to execl() Android init: %s\n", strerror(errno));
return EXIT_FAILURE;
}
void klog_vwrite(int level, const char *fmt, va_list ap)
{
char buf[LOG_BUF_MAX];
if (level > klog_level) return;
if (klog_fd < 0) klog_init();
if (klog_fd < 0) return;
vsnprintf(buf, LOG_BUF_MAX, fmt, ap);
buf[LOG_BUF_MAX - 1] = 0;
write(klog_fd, buf, strlen(buf));
}
int ueventd_main(int argc, char **argv)
{
/*
* init sets the umask to 077 for forked processes. We need to
* create files with exact permissions, without modification by
* the umask.
*/
umask(000);
/* Prevent fire-and-forget children from becoming zombies.
* If we should need to wait() for some children in the future
* (as opposed to none right now), double-forking here instead
* of ignoring SIGCHLD may be the better solution.
*/
signal(SIGCHLD, SIG_IGN);
open_devnull_stdio();
klog_init();
klog_set_level(KLOG_NOTICE_LEVEL);
NOTICE("ueventd started!\n");
selinux_callback cb;
cb.func_log = selinux_klog_callback;
selinux_set_callback(SELINUX_CB_LOG, cb);
std::string hardware = property_get("ro.hardware");
ueventd_parse_config_file("/ueventd.rc");
ueventd_parse_config_file(android::base::StringPrintf("/ueventd.%s.rc", hardware.c_str()).c_str());
device_init();
pollfd ufd;
ufd.events = POLLIN;
ufd.fd = get_device_fd();
while (true) {
ufd.revents = 0;
int nr = poll(&ufd, 1, -1);
if (nr <= 0) {
continue;
}
if (ufd.revents & POLLIN) {
handle_device_fd();
}
}
return 0;
}
void klog_write(int level, const char *fmt, ...)
{
char buf[LOG_BUF_MAX];
va_list ap;
if (level > klog_level) return;
if (klog_fd < 0) klog_init();
va_start(ap, fmt);
vsnprintf(buf, LOG_BUF_MAX, fmt, ap);
buf[LOG_BUF_MAX - 1] = 0;
va_end(ap);
write(klog_fd, buf, strlen(buf));
}
int watchdogd_main(int argc, char **argv)
{
int fd;
int ret;
int interval = 10;
int margin = 10;
int timeout;
open_devnull_stdio();
klog_init();
INFO("Starting watchdogd\n");
if (argc >= 2)
interval = atoi(argv[1]);
if (argc >= 3)
margin = atoi(argv[2]);
timeout = interval + margin;
fd = open(DEV_NAME, O_RDWR|O_CLOEXEC);
if (fd < 0) {
ERROR("watchdogd: Failed to open %s: %s\n", DEV_NAME, strerror(errno));
return 1;
}
ret = ioctl(fd, WDIOC_SETTIMEOUT, &timeout);
if (ret) {
ERROR("watchdogd: Failed to set timeout to %d: %s\n", timeout, strerror(errno));
ret = ioctl(fd, WDIOC_GETTIMEOUT, &timeout);
if (ret) {
ERROR("watchdogd: Failed to get timeout: %s\n", strerror(errno));
} else {
if (timeout > margin)
interval = timeout - margin;
else
interval = 1;
ERROR("watchdogd: Adjusted interval to timeout returned by driver: timeout %d, interval %d, margin %d\n",
timeout, interval, margin);
}
}
while(1) {
write(fd, "", 1);
sleep(interval);
}
}
int main(int argc, char *argv[])
{
int i;
for(i = 1; i < argc; ++i)
{
if(strcmp(argv[i], "-v") == 0)
{
printf("%d%s\n", VERSION_MULTIROM, VERSION_DEV_FIX);
return 0;
}
}
srand(time(0));
klog_init();
// output all messages to dmesg,
// but it is possible to filter out INFO messages
klog_set_level(6);
ERROR("Running MultiROM v%d%s\n", VERSION_MULTIROM, VERSION_DEV_FIX);
int exit = multirom();
if(exit >= 0)
{
if(exit & EXIT_REBOOT_MASK)
{
do_reboot(exit);
return 0;
}
if(exit & EXIT_KEXEC)
{
do_kexec();
return 0;
}
// indicates trampoline to keep /realdata mounted
if(!(exit & EXIT_UMOUNT))
close(open(KEEP_REALDATA, O_WRONLY | O_CREAT, 0000));
}
vt_set_mode(0);
return 0;
}
int main(int argc, char *argv[])
{
klog_init(0, argc, argv);
__g_mque = kmque_new();
/* mentry_post(__g_mque, worker, NULL, "0", "0"); */
/* mentry_post(__g_mque, worker, NULL, "1", "1"); */
/* mentry_post(__g_mque, worker, NULL, "2", "2"); */
mentry_post(__g_mque, worker, NULL, "post:388", "call worker");
mentry_post(__g_mque, call_sender, NULL, "post:389", "call call_sender");
mentry_post(__g_mque, worker, NULL, "post:390", "call worker");
mentry_dpc_add(__g_mque, worker, NULL, "dpc:1", "call worker", 4000);
kmque_run(__g_mque);
kmque_del(__g_mque);
return 0;
}
int ueventd_main(int argc, char **argv)
{
struct pollfd ufd;
int nr;
char tmp[32];
/* Prevent fire-and-forget children from becoming zombies.
* If we should need to wait() for some children in the future
* (as opposed to none right now), double-forking here instead
* of ignoring SIGCHLD may be the better solution.
*/
signal(SIGCHLD, SIG_IGN);
open_devnull_stdio();
klog_init();
INFO("starting ueventd\n");
/* Respect hardware passed in through the kernel cmd line. Here we will look
* for androidboot.hardware param in kernel cmdline, and save its value in
* hardware[]. */
import_kernel_cmdline(0, import_kernel_nv);
get_hardware_name(hardware, &revision);
ueventd_parse_config_file("/ueventd.rc");
snprintf(tmp, sizeof(tmp), "/ueventd.%s.rc", hardware);
ueventd_parse_config_file(tmp);
device_init();
ufd.events = POLLIN;
ufd.fd = get_device_fd();
while(1) {
ufd.revents = 0;
nr = poll(&ufd, 1, -1);
if (nr <= 0)
continue;
if (ufd.revents == POLLIN)
handle_device_fd();
}
}
static int __init crt_init(void)
{
int err = -EINVAL;
printk("nkfs_crt: initing\n");
err = klog_init();
if (err)
goto out;
err = crt_random_init();
if (err) {
goto rel_klog;
}
crt_wq = alloc_workqueue("crt_wq",
WQ_MEM_RECLAIM|WQ_UNBOUND, 1);
if (!crt_wq) {
KLOG(KL_ERR, "cant create wq");
err = -ENOMEM;
goto rel_rnd;
}
KLOG(KL_INF, "nk8 initing");
err = nk8_init();
if (err) {
KLOG(KL_ERR, "nk8 init err %d", err);
goto del_wq;
}
KLOG(KL_INF, "inited");
return 0;
del_wq:
destroy_workqueue(crt_wq);
rel_rnd:
crt_random_release();
rel_klog:
klog_release();
out:
return err;
}
static int __init ct_modules_init(void)
{
int ret = 0;
ct_klog_fd = klog_init("ntrack", 0x0e, 0);
if(!ct_klog_fd) {
return -ENOMEM;
}
nt_info("init nf hooks.\n");
ret = nf_register_hooks(ntrack_nf_hook_ops, ARRAY_SIZE(ntrack_nf_hook_ops));
if (ret) {
goto __err;
}
return 0;
__err:
if(ct_klog_fd) {
klog_fini(ct_klog_fd);
}
return ret;
}
int main(int argc, char *argv[])
{
char *s = "";
int i = 0;
klog_init(argc, argv);
klog_add_logger(logger_stdout);
kopt_init(argc, argv);
kopt_rpc_server_init(9000, argc, argv);
kopt_setfile("/tmp/myproj.opt");
kopt_add_s("b:/sys/admin/xxx/enable", OA_DFT, NULL, NULL);
kopt_setint("b:/sys/admin/xxx/enable", 1);
kopt_add_s("s:/sys/usr/xxx/passwd", OA_DFT, NULL, NULL);
kopt_setstr("s:/sys/usr/xxx/passwd", "xxx");
kopt_add_s("p:/env/log/cc", OA_GET, NULL, NULL);
kopt_setptr("p:/env/log/cc", 0);
kopt_add_s("s:/sys/proc/uptime", OA_GET, NULL, og_uptime);
kopt_add_s("b:/wushan/cmd/login", OA_DFT, os_login, NULL);
for (;;) {
klog("xxxxxxxxx\n");
kerror("Error ...... \n");
kopt_getstr("s:/a/b/c", &s);
klog("SSSS: %s\n", s);
kopt_getint("i:/a/b/c", &i);
klog("IIII: %d\n", i);
sleep(1);
}
}
int main(int argc, const char *argv[])
{
int i;
const char *rom_to_boot = NULL;
for(i = 1; i < argc; ++i)
{
if(strcmp(argv[i], "-v") == 0)
{
printf("%d%s apkL%d\n", VERSION_MULTIROM, VERSION_DEV_FIX, VERSION_APKL);
fflush(stdout);
return 0;
}
else if(strcmp(argv[i], "-apkL") == 0)
{
// Return all (internal and external) installed ROMs needed for the MultiROM Manager app
// external partitions will be mounted to /mnt/mrom/APK and kept mounted so the app
// can manipulate them, use "multirom -apkU" to unmount them when no longer needed
// unmount everything in /mnt/mrom/APK first
//multirom_apk_umount_usb();
int i;
struct multirom_status s;
memset(&s, 0, sizeof(struct multirom_status));
multirom_apk_get_roms(&s);
for(i = 0; s.roms && s.roms[i]; ++i)
{
if (!s.roms[i]->partition)
{
// Internal ROMs
printf("ROM: name=%s base=%s icon=%s\n",
s.roms[i]->name, s.roms[i]->base_path, s.roms[i]->icon_path);
}
else
{
// External ROMs
printf("ROM: name=%s base=%s icon=%s part_name=%s part_mount=%s part_uuid=%s part_fs=%s\n",
s.roms[i]->name, s.roms[i]->base_path, s.roms[i]->icon_path,
s.roms[i]->partition->name, s.roms[i]->partition->mount_path, s.roms[i]->partition->uuid, s.roms[i]->partition->fs);
}
}
fflush(stdout);
multirom_free_status(&s);
return 0;
}
else if(strcmp(argv[i], "-apkU") == 0)
{
// Unmount all partitions mounted in /mnt/mrom/APK
multirom_apk_umount_usb();
return 0;
}
else if(strncmp(argv[i], "--boot-rom=", sizeof("--boot-rom")) == 0)
{
rom_to_boot = argv[i] + sizeof("--boot-rom");
}
}
srand(time(0));
klog_init();
// output all messages to dmesg,
// but it is possible to filter out INFO messages
klog_set_level(6);
mrom_set_log_tag("multirom");
ERROR("Running MultiROM v%d%s\n", VERSION_MULTIROM, VERSION_DEV_FIX);
// root is mounted read only in android and MultiROM uses
// it to store some temp files, so remount it.
// Yes, there is better solution to this.
if(rom_to_boot)
mount(NULL, "/", NULL, MS_REMOUNT, NULL);
int exit = multirom(rom_to_boot);
if(rom_to_boot)
mount(NULL, "/", NULL, MS_RDONLY | MS_REMOUNT, NULL);
if(exit >= 0)
{
if(exit & EXIT_REBOOT_RECOVERY)
do_reboot(REBOOT_RECOVERY);
else if(exit & EXIT_REBOOT_BOOTLOADER)
do_reboot(REBOOT_BOOTLOADER);
else if(exit & EXIT_SHUTDOWN)
do_reboot(REBOOT_SHUTDOWN);
else if(exit & EXIT_REBOOT)
do_reboot(REBOOT_SYSTEM);
if(exit & EXIT_KEXEC)
{
do_kexec();
return 0;
}
// indicates trampoline to keep /realdata mounted
if(!(exit & EXIT_UMOUNT))
close(open(KEEP_REALDATA, O_WRONLY | O_CREAT, 0000));
}
return 0;
}
int main(int argc, char *argv[])
{
int i, res;
static char *const cmd[] = { "/init", NULL };
struct fstab *fstab = NULL;
for(i = 1; i < argc; ++i)
{
if(strcmp(argv[i], "-v") == 0)
{
printf("%d\n", VERSION_TRAMPOLINE);
fflush(stdout);
return 0;
}
}
umask(000);
// Init only the little we need, leave the rest for real init
mkdir("/dev", 0755);
mkdir("/dev/pts", 0755);
mkdir("/dev/socket", 0755);
mkdir("/proc", 0755);
mkdir("/sys", 0755);
mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
mount("devpts", "/dev/pts", "devpts", 0, NULL);
mount("proc", "/proc", "proc", 0, NULL);
mount("sysfs", "/sys", "sysfs", 0, NULL);
klog_init();
ERROR("Running trampoline v%d\n", VERSION_TRAMPOLINE);
if(is_charger_mode())
{
ERROR("Charger mode detected, skipping multirom\n");
goto run_main_init;
}
#if MR_DEVICE_HOOKS >= 3
tramp_hook_before_device_init();
#endif
ERROR("Initializing devices...");
devices_init();
ERROR("Done initializing");
if(wait_for_file("/dev/graphics/fb0", 5) < 0)
{
ERROR("Waiting too long for fb0");
goto exit;
}
fstab = fstab_auto_load();
if(!fstab)
goto exit;
#if 0
fstab_dump(fstab); //debug
#endif
// mount and run multirom from sdcard
mount_and_run(fstab);
exit:
if(fstab)
fstab_destroy(fstab);
// close and destroy everything
devices_close();
run_main_init:
if(access(KEEP_REALDATA, F_OK) < 0)
{
umount(REALDATA);
umount("/dev/pts");
umount("/dev");
rmdir("/dev/pts");
rmdir("/dev/socket");
rmdir("/dev");
rmdir(REALDATA);
}
umount("/proc");
umount("/sys");
rmdir("/proc");
rmdir("/sys");
ERROR("Running main_init\n");
fixup_symlinks();
chmod("/main_init", EXEC_MASK);
rename("/main_init", "/init");
res = execve(cmd[0], cmd, NULL);
ERROR("execve returned %d %d %s\n", res, errno, strerror(errno));
return 0;
}
int main(int argc, char **argv)
{
int fd_count = 0;
struct pollfd ufds[4];
char *tmpdev;
char* debuggable;
char tmp[32];
int property_set_fd_init = 0;
int signal_fd_init = 0;
int keychord_fd_init = 0;
if (!strcmp(basename(argv[0]), "ueventd"))
return ueventd_main(argc, argv);
/* clear the umask */
umask(0);
/* 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.
*/
mkdir("/dev", 0755);
mkdir("/proc", 0755);
mkdir("/sys", 0755);
mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
mkdir("/dev/pts", 0755);
mkdir("/dev/socket", 0755);
mount("devpts", "/dev/pts", "devpts", 0, NULL);
mount("proc", "/proc", "proc", 0, NULL);
mount("sysfs", "/sys", "sysfs", 0, NULL);
/* indicate that booting is in progress to background fw loaders, etc */
close(open("/dev/.booting", O_WRONLY | O_CREAT, 0000));
/* We must have some place other than / to create the
* device nodes for kmsg and null, otherwise we won't
* be able to remount / read-only later on.
* Now that tmpfs is mounted on /dev, we can actually
* talk to the outside world.
*/
open_devnull_stdio();
klog_init();
INFO("reading config file\n");
if (!charging_mode_booting())
init_parse_config_file("/init.rc");
else
init_parse_config_file("/lpm.rc");
/* pull the kernel commandline and ramdisk properties file in */
import_kernel_cmdline(0, import_kernel_nv);
/* don't expose the raw commandline to nonpriv processes */
chmod("/proc/cmdline", 0440);
if (!charging_mode_booting()) {
get_hardware_name(hardware, &revision);
snprintf(tmp, sizeof(tmp), "/init.%s.rc", hardware);
init_parse_config_file(tmp);
}
/* Check for a target specific initialisation file and read if present */
if (access("/init.target.rc", R_OK) == 0) {
INFO("Reading target specific config file");
init_parse_config_file("/init.target.rc");
}
action_for_each_trigger("early-init", action_add_queue_tail);
queue_builtin_action(wait_for_coldboot_done_action, "wait_for_coldboot_done");
queue_builtin_action(property_init_action, "property_init");
queue_builtin_action(keychord_init_action, "keychord_init");
queue_builtin_action(console_init_action, "console_init");
queue_builtin_action(set_init_properties_action, "set_init_properties");
/* execute all the boot actions to get us started */
action_for_each_trigger("init", action_add_queue_tail);
/* skip mounting filesystems in charger mode */
if (strcmp(bootmode, "charger") != 0 || strcmp(battchg_pause, "true") != 0) {
action_for_each_trigger("early-fs", action_add_queue_tail);
if(emmc_boot) {
action_for_each_trigger("emmc-fs", action_add_queue_tail);
} else {
action_for_each_trigger("fs", action_add_queue_tail);
}
action_for_each_trigger("post-fs", action_add_queue_tail);
action_for_each_trigger("post-fs-data", action_add_queue_tail);
}
queue_builtin_action(property_service_init_action, "property_service_init");
queue_builtin_action(signal_init_action, "signal_init");
queue_builtin_action(check_startup_action, "check_startup");
if (!strcmp(bootmode, "charger") || !strcmp(battchg_pause, "true")) {
action_for_each_trigger("charger", action_add_queue_tail);
} else {
action_for_each_trigger("early-boot", action_add_queue_tail);
action_for_each_trigger("boot", action_add_queue_tail);
}
/* run all property triggers based on current state of the properties */
queue_builtin_action(queue_property_triggers_action, "queue_propety_triggers");
#if BOOTCHART
queue_builtin_action(bootchart_init_action, "bootchart_init");
#endif
for(;;) {
int nr, i, timeout = -1;
execute_one_command();
restart_processes();
if (!property_set_fd_init && get_property_set_fd() > 0) {
ufds[fd_count].fd = get_property_set_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
property_set_fd_init = 1;
}
if (!signal_fd_init && get_signal_fd() > 0) {
ufds[fd_count].fd = get_signal_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
signal_fd_init = 1;
}
if (!keychord_fd_init && get_keychord_fd() > 0) {
ufds[fd_count].fd = get_keychord_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
keychord_fd_init = 1;
}
if (process_needs_restart) {
timeout = (process_needs_restart - gettime()) * 1000;
if (timeout < 0)
timeout = 0;
}
if (!action_queue_empty() || cur_action)
timeout = 0;
#if BOOTCHART
if (bootchart_count > 0) {
if (timeout < 0 || timeout > BOOTCHART_POLLING_MS)
timeout = BOOTCHART_POLLING_MS;
if (bootchart_step() < 0 || --bootchart_count == 0) {
bootchart_finish();
bootchart_count = 0;
}
}
#endif
nr = poll(ufds, fd_count, timeout);
if (nr <= 0)
continue;
for (i = 0; i < fd_count; i++) {
if (ufds[i].revents == POLLIN) {
if (ufds[i].fd == get_property_set_fd())
handle_property_set_fd();
else if (ufds[i].fd == get_keychord_fd())
handle_keychord();
else if (ufds[i].fd == get_signal_fd())
handle_signal();
}
}
}
return 0;
}
int main(int argc, char** argv) {
if (!strcmp(basename(argv[0]), "ueventd")) {
return ueventd_main(argc, argv);
}
if (!strcmp(basename(argv[0]), "watchdogd")) {
return watchdogd_main(argc, argv);
}
// Clear the umask.
umask(0);
add_environment("PATH", _PATH_DEFPATH);
bool is_first_stage = (argc == 1) || (strcmp(argv[1], "--second-stage") != 0);
// 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.
if (is_first_stage) {
mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
mkdir("/dev/pts", 0755);
mkdir("/dev/socket", 0755);
mount("devpts", "/dev/pts", "devpts", 0, NULL);
#define MAKE_STR(x) __STRING(x)
mount("proc", "/proc", "proc", 0, "hidepid=2,gid=" MAKE_STR(AID_READPROC));
mount("sysfs", "/sys", "sysfs", 0, NULL);
mount("selinuxfs", "/sys/fs/selinux", "selinuxfs", 0, NULL);
}
// We must have some place other than / to create the device nodes for
// kmsg and null, otherwise we won't be able to remount / read-only
// later on. Now that tmpfs is mounted on /dev, we can actually talk
// to the outside world.
open_devnull_stdio();
klog_init();
klog_set_level(KLOG_NOTICE_LEVEL);
NOTICE("init %s started!\n", is_first_stage ? "first stage" : "second stage");
if (!is_first_stage) {
// Indicate that booting is in progress to background fw loaders, etc.
close(open("/dev/.booting", O_WRONLY | O_CREAT | O_CLOEXEC, 0000));
property_init();
// If arguments are passed both on the command line and in DT,
// properties set in DT always have priority over the command-line ones.
process_kernel_dt();
process_kernel_cmdline();
// Propagate the kernel variables to internal variables
// used by init as well as the current required properties.
export_kernel_boot_props();
}
// Set up SELinux, including loading the SELinux policy if we're in the kernel domain.
selinux_initialize(is_first_stage);
// If we're in the kernel domain, re-exec init to transition to the init domain now
// that the SELinux policy has been loaded.
if (is_first_stage) {
if (restorecon("/init") == -1) {
ERROR("restorecon failed: %s\n", strerror(errno));
security_failure();
}
char* path = argv[0];
char* args[] = { path, const_cast<char*>("--second-stage"), nullptr };
if (execv(path, args) == -1) {
ERROR("execv(\"%s\") failed: %s\n", path, strerror(errno));
security_failure();
}
}
// These directories were necessarily created before initial policy load
// and therefore need their security context restored to the proper value.
// This must happen before /dev is populated by ueventd.
NOTICE("Running restorecon...\n");
restorecon("/dev");
restorecon("/dev/socket");
restorecon("/dev/__properties__");
restorecon("/property_contexts");
restorecon_recursive("/sys");
epoll_fd = epoll_create1(EPOLL_CLOEXEC);
if (epoll_fd == -1) {
ERROR("epoll_create1 failed: %s\n", strerror(errno));
exit(1);
}
signal_handler_init();
property_load_boot_defaults();
export_oem_lock_status();
start_property_service();
const BuiltinFunctionMap function_map;
Action::set_function_map(&function_map);
Parser& parser = Parser::GetInstance();
parser.AddSectionParser("service",std::make_unique<ServiceParser>());
parser.AddSectionParser("on", std::make_unique<ActionParser>());
parser.AddSectionParser("import", std::make_unique<ImportParser>());
parser.ParseConfig("/init.rc");
ActionManager& am = ActionManager::GetInstance();
am.QueueEventTrigger("early-init");
// Queue an action that waits for coldboot done so we know ueventd has set up all of /dev...
am.QueueBuiltinAction(wait_for_coldboot_done_action, "wait_for_coldboot_done");
// ... so that we can start queuing up actions that require stuff from /dev.
am.QueueBuiltinAction(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
am.QueueBuiltinAction(keychord_init_action, "keychord_init");
am.QueueBuiltinAction(console_init_action, "console_init");
// Trigger all the boot actions to get us started.
am.QueueEventTrigger("init");
// Repeat mix_hwrng_into_linux_rng in case /dev/hw_random or /dev/random
// wasn't ready immediately after wait_for_coldboot_done
am.QueueBuiltinAction(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
// Don't mount filesystems or start core system services in charger mode.
std::string bootmode = property_get("ro.bootmode");
if (bootmode == "charger") {
am.QueueEventTrigger("charger");
} else {
am.QueueEventTrigger("late-init");
}
// Run all property triggers based on current state of the properties.
am.QueueBuiltinAction(queue_property_triggers_action, "queue_property_triggers");
while (true) {
if (!waiting_for_exec) {
am.ExecuteOneCommand();
restart_processes();
}
int timeout = -1;
if (process_needs_restart) {
timeout = (process_needs_restart - gettime()) * 1000;
if (timeout < 0)
timeout = 0;
}
if (am.HasMoreCommands()) {
timeout = 0;
}
bootchart_sample(&timeout);
epoll_event ev;
int nr = TEMP_FAILURE_RETRY(epoll_wait(epoll_fd, &ev, 1, timeout));
if (nr == -1) {
ERROR("epoll_wait failed: %s\n", strerror(errno));
} else if (nr == 1) {
((void (*)()) ev.data.ptr)();
}
}
return 0;
}
int main(int argc, char **argv)
{
int fd_count = 0;
struct pollfd ufds[4];
char *tmpdev;
char* debuggable;
char tmp[32];
int property_set_fd_init = 0;
int signal_fd_init = 0;
int keychord_fd_init = 0;
bool is_charger = false;
#ifdef MTK_INIT
int mt_boot_mode = 0;
klog_set_level(6);
#endif
if (!strcmp(basename(argv[0]), "ueventd"))
return ueventd_main(argc, argv);
if (!strcmp(basename(argv[0]), "watchdogd"))
return watchdogd_main(argc, argv);
/* clear the umask */
umask(0);
/* 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.
*/
mkdir("/dev", 0755);
mkdir("/proc", 0755);
mkdir("/sys", 0755);
mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
mkdir("/dev/pts", 0755);
mkdir("/dev/socket", 0755);
mount("devpts", "/dev/pts", "devpts", 0, NULL);
mount("proc", "/proc", "proc", 0, NULL);
mount("sysfs", "/sys", "sysfs", 0, NULL);
#ifdef INIT_ENG_BUILD
mount("debugfs", "/sys/kernel/debug", "debugfs", 0, NULL);
#endif
/* indicate that booting is in progress to background fw loaders, etc */
close(open("/dev/.booting", O_WRONLY | O_CREAT, 0000));
/* We must have some place other than / to create the
* device nodes for kmsg and null, otherwise we won't
* be able to remount / read-only later on.
* Now that tmpfs is mounted on /dev, we can actually
* talk to the outside world.
*/
open_devnull_stdio();
klog_init();
property_init();
get_hardware_name(hardware, &revision);
process_kernel_cmdline();
union selinux_callback cb;
cb.func_log = log_callback;
selinux_set_callback(SELINUX_CB_LOG, cb);
cb.func_audit = audit_callback;
selinux_set_callback(SELINUX_CB_AUDIT, cb);
selinux_initialize();
/* These directories were necessarily created before initial policy load
* and therefore need their security context restored to the proper value.
* This must happen before /dev is populated by ueventd.
*/
restorecon("/dev");
restorecon("/dev/socket");
restorecon("/dev/__properties__");
restorecon_recursive("/sys");
is_charger = !strcmp(bootmode, "charger");
INFO("property init\n");
property_load_boot_defaults();
#ifndef INIT_ENG_BUILD
property_set("ro.mtprof.disable", "1");
#endif
INFO("reading config file\n");
#ifdef MTK_INIT
/* NEW FEATURE: multi-boot mode */
mt_boot_mode = get_boot_mode();
if ( (mt_boot_mode == MT_FACTORY_BOOT) || (mt_boot_mode == MT_ATE_FACTORY_BOOT) ) {
printf("Factory Mode Booting.....\n");
property_set("sys.mtk.no.factoryimage","1");
init_parse_config_file("/factory_init.rc");
init_parse_config_file("/factory_init.project.rc");
}
else if ( mt_boot_mode == MT_META_BOOT ) {
printf("META Mode Booting.....\n");
init_parse_config_file("/meta_init.rc");
init_parse_config_file("/meta_init.project.rc");
}
else
{
#endif // MTK_INIT
init_parse_config_file("/init.rc");
#ifdef MTK_INIT
}
#endif
#ifdef MTK_INIT
if ( (mt_boot_mode == MT_FACTORY_BOOT) || (mt_boot_mode == MT_ATE_FACTORY_BOOT) ) {
NOTICE("No need modem.rc for factory mode\n");
}
else if ( mt_boot_mode == MT_META_BOOT ) {
init_parse_config_file("/meta_init.modem.rc");
}else {
init_parse_config_file("/init.modem.rc");
}
#endif // MTK_INIT
/**** End of Parsing .rc files ****/
action_for_each_trigger("early-init", action_add_queue_tail);
queue_builtin_action(wait_for_coldboot_done_action, "wait_for_coldboot_done");
queue_builtin_action(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
queue_builtin_action(keychord_init_action, "keychord_init");
queue_builtin_action(console_init_action, "console_init");
/* execute all the boot actions to get us started */
action_for_each_trigger("init", action_add_queue_tail);
/* Repeat mix_hwrng_into_linux_rng in case /dev/hw_random or /dev/random
* wasn't ready immediately after wait_for_coldboot_done
*/
queue_builtin_action(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
queue_builtin_action(property_service_init_action, "property_service_init");
queue_builtin_action(signal_init_action, "signal_init");
/* Don't mount filesystems or start core system services if in charger mode. */
if (is_charger) {
action_for_each_trigger("charger", action_add_queue_tail);
}
else
{
action_for_each_trigger("late-init", action_add_queue_tail);
}
/* run all property triggers based on current state of the properties */
queue_builtin_action(queue_property_triggers_action, "queue_property_triggers");
#if BOOTCHART
queue_builtin_action(bootchart_init_action, "bootchart_init");
#endif
for(;;) {
int nr, i, timeout = -1;
execute_one_command();
restart_processes();
if (!property_set_fd_init && get_property_set_fd() > 0) {
ufds[fd_count].fd = get_property_set_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
property_set_fd_init = 1;
}
if (!signal_fd_init && get_signal_fd() > 0) {
ufds[fd_count].fd = get_signal_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
signal_fd_init = 1;
}
if (!keychord_fd_init && get_keychord_fd() > 0) {
ufds[fd_count].fd = get_keychord_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
keychord_fd_init = 1;
}
if (process_needs_restart) {
timeout = (process_needs_restart - gettime()) * 1000;
if (timeout < 0)
timeout = 0;
}
if (!action_queue_empty() || cur_action)
timeout = 0;
#if BOOTCHART
if (bootchart_count > 0) {
if (timeout < 0 || timeout > BOOTCHART_POLLING_MS)
timeout = BOOTCHART_POLLING_MS;
if (bootchart_step() < 0 || --bootchart_count == 0) {
bootchart_finish();
bootchart_count = 0;
}
}
#endif
nr = poll(ufds, fd_count, timeout);
if (nr <= 0)
continue;
for (i = 0; i < fd_count; i++) {
if (ufds[i].revents & POLLIN) {
if (ufds[i].fd == get_property_set_fd())
handle_property_set_fd();
else if (ufds[i].fd == get_keychord_fd())
handle_keychord();
else if (ufds[i].fd == get_signal_fd())
handle_signal();
}
}
}
return 0;
}
int main(int argc, char **argv)
{
int alarm_time = 5;
int count = -1;
bool abort_on_failure = false;
while (1) {
const static struct option long_options[] = {
{"abort", no_argument, 0, 'a'},
{"count", required_argument, 0, 'c'},
{"time", required_argument, 0, 't'},
};
int c = getopt_long(argc, argv, "ac:t:", long_options, NULL);
if (c < 0) {
break;
}
switch (c) {
case 'a':
abort_on_failure = true;
break;
case 'c':
count = strtoul(optarg, NULL, 0);
break;
case 't':
alarm_time = strtoul(optarg, NULL, 0);
break;
case '?':
usage();
exit(EXIT_FAILURE);
default:
abort();
}
}
klog_init();
klog_set_level(KLOG_INFO_LEVEL);
if (optind < argc) {
fprintf(stderr, "Unexpected argument: %s\n", argv[optind]);
usage();
exit(EXIT_FAILURE);
}
int fd = timerfd_create(CLOCK_BOOTTIME_ALARM, 0);
if (fd < 0) {
perror("timerfd_create failed");
exit(EXIT_FAILURE);
}
struct itimerspec delay = itimerspec();
delay.it_value.tv_sec = alarm_time;
int i = 0;
int epoll_fd = epoll_create(1);
if (epoll_fd < 0) {
perror("epoll_create failed");
exit(EXIT_FAILURE);
}
struct epoll_event ev = epoll_event();
ev.events = EPOLLIN | EPOLLWAKEUP;
int ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev);
if (ret < 0) {
perror("epoll_ctl failed");
exit(EXIT_FAILURE);
}
while (count != 0) {
struct timespec expected_time;
struct timespec actual_time;
uint64_t fired = 0;
ret = timerfd_settime(fd, 0, &delay, NULL);
if (ret < 0) {
perror("timerfd_settime failed");
exit(EXIT_FAILURE);
}
ret = clock_gettime(CLOCK_BOOTTIME, &expected_time);
if (ret < 0) {
perror("failed to get time");
exit(EXIT_FAILURE);
}
expected_time.tv_sec += alarm_time;
ret = 0;
while (ret != 1) {
struct epoll_event out_ev;
ret = epoll_wait(epoll_fd, &out_ev, 1, -1);
if (ret < 0 && errno != EINTR) {
perror("epoll_wait failed");
exit(EXIT_FAILURE);
}
}
ssize_t bytes = read(fd, &fired, sizeof(fired));
if (bytes < 0) {
perror("read from timer fd failed");
exit(EXIT_FAILURE);
} else if (bytes < (ssize_t)sizeof(fired)) {
fprintf(stderr, "unexpected read from timer fd: %zd\n", bytes);
}
if (fired != 1) {
fprintf(stderr, "unexpected timer fd fired count: %" PRIu64 "\n", fired);
}
ret = clock_gettime(CLOCK_BOOTTIME, &actual_time);
if (ret < 0) {
perror("failed to get time");
exit(EXIT_FAILURE);
}
long long diff = timediff_ns(&actual_time, &expected_time);
if (llabs(diff) > NSEC_PER_SEC) {
fprintf(stderr, "alarm arrived %lld.%03lld seconds %s\n",
llabs(diff) / NSEC_PER_SEC,
(llabs(diff) / NSEC_PER_MSEC) % MSEC_PER_SEC,
diff > 0 ? "late" : "early");
KLOG_ERROR("suspend_stress", "alarm arrived %lld.%03lld seconds %s\n",
llabs(diff) / NSEC_PER_SEC,
(llabs(diff) / NSEC_PER_MSEC) % MSEC_PER_SEC,
diff > 0 ? "late" : "early");
if (abort_on_failure) {
exit(EXIT_FAILURE);
}
}
time_t t = time(NULL);
i += fired;
printf("timer fired: %d at boottime %lld.%.3ld, %s", i,
(long long)actual_time.tv_sec,
actual_time.tv_nsec / NSEC_PER_MSEC,
ctime(&t));
KLOG_INFO("suspend_stress", "timer fired: %d at boottime %lld.%.3ld, %s", i,
(long long)actual_time.tv_sec,
actual_time.tv_nsec / NSEC_PER_MSEC,
ctime(&t));
if (count > 0)
count--;
}
return 0;
}
int main(int argc, char **argv)
{
int fd_count = 0;
struct pollfd ufds[4];
char *tmpdev;
char* debuggable;
char tmp[32];
int property_set_fd_init = 0;
int signal_fd_init = 0;
int keychord_fd_init = 0;
bool is_charger = false;
klog_set_level(LOG_DEFAULT_LEVEL);
if (!strcmp(basename(argv[0]), "ueventd"))
return ueventd_main(argc, argv);
if (!strcmp(basename(argv[0]), "watchdogd"))
return watchdogd_main(argc, argv);
/* clear the umask */
umask(0);
/* 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.
*/
mkdir("/dev", 0755);
mkdir("/proc", 0755);
mkdir("/sys", 0755);
mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
mkdir("/dev/pts", 0755);
mkdir("/dev/socket", 0755);
mount("devpts", "/dev/pts", "devpts", 0, NULL);
mount("proc", "/proc", "proc", 0, NULL);
mount("sysfs", "/sys", "sysfs", 0, NULL);
#ifdef INIT_ENG_BUILD
mount("debugfs", "/sys/kernel/debug", "debugfs", 0, NULL);
#endif
/* indicate that booting is in progress to background fw loaders, etc */
close(open("/dev/.booting", O_WRONLY | O_CREAT, 0000));
/* We must have some place other than / to create the
* device nodes for kmsg and null, otherwise we won't
* be able to remount / read-only later on.
* Now that tmpfs is mounted on /dev, we can actually
* talk to the outside world.
*/
//open_devnull_stdio();
klog_init();
property_init();
get_hardware_name(hardware, &revision);
process_kernel_cmdline();
#ifdef HAVE_SELINUX
union selinux_callback cb;
cb.func_log = klog_write;
selinux_set_callback(SELINUX_CB_LOG, cb);
cb.func_audit = audit_callback;
selinux_set_callback(SELINUX_CB_AUDIT, cb);
INFO("loading selinux policy\n");
if (selinux_enabled) {
if (selinux_android_load_policy() < 0) {
selinux_enabled = 0;
INFO("SELinux: Disabled due to failed policy load\n");
} else {
selinux_init_all_handles();
}
} else {
INFO("SELinux: Disabled by command line option\n");
}
/* These directories were necessarily created before initial policy load
* and therefore need their security context restored to the proper value.
* This must happen before /dev is populated by ueventd.
*/
restorecon("/dev");
restorecon("/dev/socket");
#endif
is_charger = !strcmp(bootmode, "charger");
INFO("property init\n");
if (!is_charger)
property_load_boot_defaults();
#ifdef HAVE_AEE_FEATURE
INFO("reading AEE config file\n");
#ifndef PARTIAL_BUILD
init_parse_config_file("/init.aee.mtk.rc");
#else
init_parse_config_file("/init.aee.customer.rc");
#endif // PARTIAL_BUILD
#endif // HAVE_AEE_FEATURE
INFO("reading config file\n");
#ifdef USE_BUILT_IN_FACTORY
ERROR("USE_BUILT_IN_FACTORY");
if (is_factory_boot())
{
ERROR("This is factory boot");
property_set("sys.mtk.no.factoryimage","1");
init_parse_config_file("/factory_init.rc");
INFO("reading project config file\n");
init_parse_config_file("/factory_init.project.rc");
}
else
{
if(is_meta_boot())
{
ERROR("Parsing meta_init.rc ...\n");
init_parse_config_file("/meta_init.rc");
INFO("reading project config file\n");
init_parse_config_file("/meta_init.project.rc");
init_parse_config_file("/meta_init.modem.rc");
}
else if(is_advanced_meta_boot())
{
ERROR("Parsing advanced_meta_init.rc ...\n");
init_parse_config_file("/advanced_meta_init.rc");
INFO("reading project config file\n");
init_parse_config_file("/advanced_meta_init.project.rc");
#ifdef MTK_FAT_ON_NAND
printf("reading init.fon.rc file\n");
init_parse_config_file("/init.fon.rc");
#endif
}
#if defined (MTK_KERNEL_POWER_OFF_CHARGING_SUPPORT)
else if (is_kernel_power_off_charging_boot())
{
ERROR("Parsing init.charging.rc ...\n");
if (init_parse_config_file("/init.charging.rc") < 0)
{
init_parse_config_file("/init.rc");
INFO("reading project config file\n");
init_parse_config_file("/init.project.rc");
init_parse_config_file("/init.modem.rc");
}
}
#endif
else
{
printf("Parsing init.rc ...\n");
init_parse_config_file("/init.rc");
INFO("reading project config file\n");
init_parse_config_file("/init.project.rc");
init_parse_config_file("/init.modem.rc");
#ifdef MTK_FAT_ON_NAND
printf("reading init.fon.rc file\n");
init_parse_config_file("/init.fon.rc");
#endif
}
}
#else
if(is_meta_boot())
{
ERROR("Parsing meta_init.rc ...\n");
init_parse_config_file("/meta_init.rc");
INFO("reading project config file\n");
init_parse_config_file("/meta_init.project.rc");
init_parse_config_file("/meta_init.modem.rc");
}
else if(is_advanced_meta_boot())
{
ERROR("Parsing advanced_meta_init.rc ...\n");
init_parse_config_file("/advanced_meta_init.rc");
INFO("reading project config file\n");
init_parse_config_file("/advanced_meta_init.project.rc");
}
else
{
printf("Parsing init.rc ...\n");
init_parse_config_file("/init.rc");
INFO("reading project config file\n");
init_parse_config_file("/init.project.rc");
init_parse_config_file("/init.modem.rc");
}
#endif
#ifdef MTK_SHARED_SDCARD
if(is_support_sdcard_share_boot())
{
#ifdef MTK_2SDCARD_SWAP
printf("Parsing init.ssd_sdswap.rc ...\n");
init_parse_config_file("/init.ssd_nomuser.rc");
#else
printf("Parsing init.ssd.rc ...\n");
init_parse_config_file("/init.ssd.rc");
#endif
}
else
{
printf("Parsing init.no_ssd.rc ...\n");
init_parse_config_file("/init.no_ssd.rc");
}
#else
printf("Parsing init.no_ssd.rc ...\n");
init_parse_config_file("/init.no_ssd.rc");
#endif
#ifndef INIT_ENG_BUILD
property_set("ro.mtprof.disable", "1");
#endif
if(is_support_protected_data_boot())
{
printf("Parsing init.protect.rc ...\n");
init_parse_config_file("/init.protect.rc");
}
snprintf(tmp, sizeof(tmp), "/init.%s.rc", hardware);
init_parse_config_file(tmp);
action_for_each_trigger("early-init", action_add_queue_tail);
queue_builtin_action(wait_for_coldboot_done_action, "wait_for_coldboot_done");
queue_builtin_action(keychord_init_action, "keychord_init");
queue_builtin_action(console_init_action, "console_init");
/* execute all the boot actions to get us started */
action_for_each_trigger("init", action_add_queue_tail);
/* skip mounting filesystems in charger mode */
if (!is_charger) {
queue_builtin_action(queue_fs_property_triggers_action, "queue_fs_propety_triggers");
action_for_each_trigger("early-fs", action_add_queue_tail);
action_for_each_trigger("fs", action_add_queue_tail);
action_for_each_trigger("post-fs", action_add_queue_tail);
action_for_each_trigger("post-fs-data", action_add_queue_tail);
}
queue_builtin_action(property_service_init_action, "property_service_init");
queue_builtin_action(signal_init_action, "signal_init");
queue_builtin_action(check_startup_action, "check_startup");
queue_builtin_action(queue_early_property_triggers_action, "queue_early_propety_triggers");
if (is_charger) {
action_for_each_trigger("charger", action_add_queue_tail);
}
#if defined (MTK_KERNEL_POWER_OFF_CHARGING_SUPPORT)
else if (is_kernel_power_off_charging_boot()){
action_for_each_trigger("ipo", action_add_queue_tail);
}
#endif
else {
action_for_each_trigger("early-boot", action_add_queue_tail);
action_for_each_trigger("boot", action_add_queue_tail);
}
/* run all property triggers based on current state of the properties */
queue_builtin_action(queue_property_triggers_action, "queue_property_triggers");
/* change USB function by meta_com_id */
#ifdef USE_BUILT_IN_FACTORY
if (is_meta_boot() || is_factory_boot()) {
queue_builtin_action(queue_com_triggers_action, "queue_com_triggers");
}
#else
if (is_meta_boot()) {
queue_builtin_action(queue_com_triggers_action, "queue_com_triggers");
}
#endif
#if BOOTCHART
queue_builtin_action(bootchart_init_action, "bootchart_init");
#endif
for(;;) {
int nr, i, timeout = -1;
execute_one_command();
restart_processes();
if (!property_set_fd_init && get_property_set_fd() > 0) {
ufds[fd_count].fd = get_property_set_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
property_set_fd_init = 1;
}
if (!signal_fd_init && get_signal_fd() > 0) {
ufds[fd_count].fd = get_signal_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
signal_fd_init = 1;
}
if (!keychord_fd_init && get_keychord_fd() > 0) {
ufds[fd_count].fd = get_keychord_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
keychord_fd_init = 1;
}
if (process_needs_restart) {
timeout = (process_needs_restart - gettime()) * 1000;
if (timeout < 0)
timeout = 0;
}
if (!action_queue_empty() || cur_action)
timeout = 0;
#if BOOTCHART
if (bootchart_count > 0) {
if (timeout < 0 || timeout > BOOTCHART_POLLING_MS)
timeout = BOOTCHART_POLLING_MS;
if (bootchart_step() < 0 || --bootchart_count == 0) {
bootchart_finish();
bootchart_count = 0;
}
}
#endif
nr = poll(ufds, fd_count, timeout);
if (nr <= 0)
continue;
for (i = 0; i < fd_count; i++) {
if (ufds[i].revents == POLLIN) {
if (ufds[i].fd == get_property_set_fd())
handle_property_set_fd();
else if (ufds[i].fd == get_keychord_fd())
handle_keychord();
else if (ufds[i].fd == get_signal_fd())
handle_signal();
}
}
}
return 0;
}
int main(int argc, char **argv)
{
int fd_count = 0;
struct pollfd ufds[4];
char *tmpdev;
char* debuggable;
char tmp[32];
int property_set_fd_init = 0;
int signal_fd_init = 0;
int keychord_fd_init = 0;
bool is_charger = false;
if (!strcmp(basename(argv[0]), "ueventd"))
return ueventd_main(argc, argv);
if (!strcmp(basename(argv[0]), "watchdogd"))
return watchdogd_main(argc, argv);
/* clear the umask */
umask(0);
/* 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.
*/
/* Don't repeat the setup of these filesystems,
* it creates double mount points with an unknown effect
* on the system. This init file is for 2nd-init anyway.
*/
#ifndef NO_DEVFS_SETUP
mkdir("/dev", 0755);
mkdir("/proc", 0755);
mkdir("/sys", 0755);
mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
mkdir("/dev/pts", 0755);
mkdir("/dev/socket", 0755);
mount("devpts", "/dev/pts", "devpts", 0, NULL);
mount("proc", "/proc", "proc", 0, NULL);
mount("sysfs", "/sys", "sysfs", 0, NULL);
/* indicate that booting is in progress to background fw loaders, etc */
close(open("/dev/.booting", O_WRONLY | O_CREAT, 0000));
/* We must have some place other than / to create the
* device nodes for kmsg and null, otherwise we won't
* be able to remount / read-only later on.
* Now that tmpfs is mounted on /dev, we can actually
* talk to the outside world.
*/
open_devnull_stdio();
klog_init();
#endif
property_init();
get_hardware_name(hardware, &revision);
process_kernel_cmdline();
union selinux_callback cb;
cb.func_log = klog_write;
selinux_set_callback(SELINUX_CB_LOG, cb);
cb.func_audit = audit_callback;
selinux_set_callback(SELINUX_CB_AUDIT, cb);
selinux_initialize();
/* These directories were necessarily created before initial policy load
* and therefore need their security context restored to the proper value.
* This must happen before /dev is populated by ueventd.
*/
restorecon("/dev");
restorecon("/dev/socket");
restorecon("/dev/__properties__");
restorecon_recursive("/sys");
is_charger = !strcmp(bootmode, "charger");
INFO("property init\n");
if (!is_charger)
property_load_boot_defaults();
INFO("reading config file\n");
if (!charging_mode_booting())
init_parse_config_file("/init.rc");
else
init_parse_config_file("/lpm.rc");
/* Check for an emmc initialisation file and read if present */
if (emmc_boot && access("/init.emmc.rc", R_OK) == 0) {
INFO("Reading emmc config file");
init_parse_config_file("/init.emmc.rc");
}
/* Check for a target specific initialisation file and read if present */
if (access("/init.target.rc", R_OK) == 0) {
INFO("Reading target specific config file");
init_parse_config_file("/init.target.rc");
}
action_for_each_trigger("early-init", action_add_queue_tail);
queue_builtin_action(wait_for_coldboot_done_action, "wait_for_coldboot_done");
queue_builtin_action(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
queue_builtin_action(keychord_init_action, "keychord_init");
queue_builtin_action(console_init_action, "console_init");
/* execute all the boot actions to get us started */
action_for_each_trigger("init", action_add_queue_tail);
if (!is_charger) {
action_for_each_trigger("early-fs", action_add_queue_tail);
if(emmc_boot) {
action_for_each_trigger("emmc-fs", action_add_queue_tail);
} else {
action_for_each_trigger("fs", action_add_queue_tail);
}
action_for_each_trigger("post-fs", action_add_queue_tail);
action_for_each_trigger("post-fs-data", action_add_queue_tail);
} else {
action_for_each_trigger("charger-fs", action_add_queue_tail);
}
/* Repeat mix_hwrng_into_linux_rng in case /dev/hw_random or /dev/random
* wasn't ready immediately after wait_for_coldboot_done
*/
queue_builtin_action(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
queue_builtin_action(property_service_init_action, "property_service_init");
queue_builtin_action(signal_init_action, "signal_init");
queue_builtin_action(check_startup_action, "check_startup");
/* Older bootloaders use non-standard charging modes. Check for
* those now, after mounting the filesystems */
if (strcmp(battchg_pause, BOARD_CHARGING_CMDLINE_VALUE) == 0)
is_charger = 1;
if (is_charger) {
action_for_each_trigger("charger", action_add_queue_tail);
} else {
action_for_each_trigger("early-boot", action_add_queue_tail);
action_for_each_trigger("boot", action_add_queue_tail);
}
/* run all property triggers based on current state of the properties */
queue_builtin_action(queue_property_triggers_action, "queue_property_triggers");
#if BOOTCHART
queue_builtin_action(bootchart_init_action, "bootchart_init");
#endif
for(;;) {
int nr, i, timeout = -1;
execute_one_command();
restart_processes();
if (!property_set_fd_init && get_property_set_fd() > 0) {
ufds[fd_count].fd = get_property_set_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
property_set_fd_init = 1;
}
if (!signal_fd_init && get_signal_fd() > 0) {
ufds[fd_count].fd = get_signal_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
signal_fd_init = 1;
}
if (!keychord_fd_init && get_keychord_fd() > 0) {
ufds[fd_count].fd = get_keychord_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
keychord_fd_init = 1;
}
if (process_needs_restart) {
timeout = (process_needs_restart - gettime()) * 1000;
if (timeout < 0)
timeout = 0;
}
if (!action_queue_empty() || cur_action)
timeout = 0;
#if BOOTCHART
if (bootchart_count > 0) {
if (timeout < 0 || timeout > BOOTCHART_POLLING_MS)
timeout = BOOTCHART_POLLING_MS;
if (bootchart_step() < 0 || --bootchart_count == 0) {
bootchart_finish();
bootchart_count = 0;
}
}
#endif
nr = poll(ufds, fd_count, timeout);
if (nr <= 0)
continue;
for (i = 0; i < fd_count; i++) {
if (ufds[i].revents & POLLIN) {
if (ufds[i].fd == get_property_set_fd())
handle_property_set_fd();
else if (ufds[i].fd == get_keychord_fd())
handle_keychord();
else if (ufds[i].fd == get_signal_fd())
handle_signal();
}
}
}
return 0;
}
int main(int argc, char *argv[])
{
int i, res;
static char *const cmd[] = { "/init", NULL };
struct fstab *fstab = NULL;
char *inject_path = NULL;
char *mrom_dir = NULL;
int force_inject = 0;
for(i = 1; i < argc; ++i)
{
if(strcmp(argv[i], "-v") == 0)
{
printf("%d\n", VERSION_TRAMPOLINE);
fflush(stdout);
return 0;
}
else if(strstartswith(argv[i], "--inject="))
inject_path = argv[i] + strlen("--inject=");
else if(strstartswith(argv[i], "--mrom_dir="))
mrom_dir = argv[i] + strlen("--mrom_dir=");
else if(strcmp(argv[i], "-f") == 0)
force_inject = 1;
}
if(inject_path)
{
if(!mrom_dir)
{
printf("--mrom_dir=[path to multirom's data dir] needs to be specified!\n");
fflush(stdout);
return 1;
}
mrom_set_dir(mrom_dir);
mrom_set_log_tag("trampoline_inject");
return inject_bootimg(inject_path, force_inject);
}
umask(000);
// Init only the little we need, leave the rest for real init
mkdir("/dev", 0755);
mkdir("/dev/pts", 0755);
mkdir("/dev/socket", 0755);
mkdir("/proc", 0755);
mkdir("/sys", 0755);
mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
mount("devpts", "/dev/pts", "devpts", 0, NULL);
mount("proc", "/proc", "proc", 0, NULL);
mount("sysfs", "/sys", "sysfs", 0, NULL);
mount("pstore", "/sys/fs/pstore", "pstore", 0, NULL);
#if MR_USE_DEBUGFS_MOUNT
// Mount the debugfs kernel sysfs
mkdir("/sys/kernel/debug", 0755);
mount("debugfs", "/sys/kernel/debug", "debugfs", 0, NULL);
#endif
klog_init();
// output all messages to dmesg,
// but it is possible to filter out INFO messages
klog_set_level(6);
mrom_set_log_tag("trampoline");
INFO("Running trampoline v%d\n", VERSION_TRAMPOLINE);
if(is_charger_mode())
{
INFO("Charger mode detected, skipping multirom\n");
goto run_main_init;
}
#if MR_DEVICE_HOOKS >= 3
tramp_hook_before_device_init();
#endif
INFO("Initializing devices...\n");
devices_init();
INFO("Done initializing\n");
if(wait_for_file("/dev/graphics/fb0", 5) < 0)
{
ERROR("Waiting too long for fb0");
goto exit;
}
#ifdef MR_POPULATE_BY_NAME_PATH
//nkk71 M7 hack
Populate_ByName_using_emmc();
#endif
fstab = fstab_auto_load();
if(!fstab)
goto exit;
#if 0
fstab_dump(fstab); //debug
#endif
// mount and run multirom from sdcard
if(mount_and_run(fstab) < 0 && mrom_is_second_boot())
{
ERROR("This is second boot and we couldn't mount /data, reboot!\n");
sync();
android_reboot(ANDROID_RB_RESTART, 0, 0);
while(1)
sleep(1);
}
exit:
if(fstab)
fstab_destroy(fstab);
// close and destroy everything
devices_close();
run_main_init:
umount("/dev/pts");
rmdir("/dev/pts");
rmdir("/dev/socket");
if(access(KEEP_REALDATA, F_OK) < 0)
{
umount(REALDATA);
umount("/dev");
rmdir(REALDATA);
encryption_destroy();
}
encryption_cleanup();
#if MR_USE_DEBUGFS_MOUNT
umount("/sys/kernel/debug");
#endif
umount("/proc");
umount("/sys/fs/pstore");
umount("/sys");
INFO("Running main_init\n");
fixup_symlinks();
chmod("/main_init", EXEC_MASK);
rename("/main_init", "/init");
res = execve(cmd[0], cmd, NULL);
ERROR("execve returned %d %d %s\n", res, errno, strerror(errno));
return 0;
}
int main(int argc, char *argv[]) {
int print_cmd = 0;
int config_cmd = 0;
int add_cmd = 0;
int del_cmd = 0;
int sync_cmd = 0;
int c;
const char *new_partition = NULL;
const char *old_partition = NULL;
const char *type_guid = NULL;
const char *partition_guid = NULL;
unsigned gpt_location = 1;
klog_init();
klog_set_level(6);
const struct option longopts[] = {
{"print", no_argument, 0, 'p'},
{"config-print", no_argument, 0, 'c'},
{"add", no_argument, 0, 'a'},
{"del", no_argument, 0, 'd'},
{"new", required_argument, 0, 'n'},
{"old", required_argument, 0, 'o'},
{"type", required_argument, 0, 't'},
{"sync", required_argument, 0, 's'},
{"guid", required_argument, 0, 'g'},
{"location", required_argument, 0, 'l'},
{0, 0, 0, 0}
};
while (1) {
c = getopt_long(argc, argv, "pcadt:g:n:o:sl:", longopts, NULL);
/* Alphabetical cases */
if (c < 0)
break;
switch (c) {
case 'p':
print_cmd = 1;
break;
case 'c':
config_cmd = 1;
break;
case 'a':
add_cmd = 1;
break;
case 'd':
del_cmd = 1;
break;
case 'n':
new_partition = optarg;
break;
case 'o':
old_partition = optarg;
break;
case 't':
type_guid = optarg;
case 'g':
partition_guid = optarg;
break;
case 's':
sync_cmd = 1;
break;
case 'l':
gpt_location = strtoul(optarg, NULL, 10);
fprintf(stderr, "Got offset as %d", gpt_location);
break;
case '?':
return 1;
default:
abort();
}
}
argc -= optind;
argv += optind;
if (argc < 1) {
usage();
return 1;
}
const char *path = argv[0];
struct GPT_entry_table *table = GPT_get_device(path, gpt_location);
if (table == NULL) {
fprintf(stderr, "unable to get GPT table from %s\n", path);
return 1;
}
if (add_cmd)
addGPT(table, new_partition, partition_guid, type_guid);
if (del_cmd)
deleteGPT(table, old_partition);
if (print_cmd)
printGPT(table);
if (config_cmd)
configPrintGPT(table);
if (sync_cmd)
GPT_sync(table);
GPT_release_device(table);
return 0;
}
int main(int argc, char **argv)
{
int fd_count = 0;
struct pollfd ufds[4];
char *tmpdev;
char* debuggable;
char tmp[32];
int property_set_fd_init = 0;
int signal_fd_init = 0;
int keychord_fd_init = 0;
bool is_charger = false;
if (!strcmp(basename(argv[0]), "ueventd"))
return ueventd_main(argc, argv);
if (!strcmp(basename(argv[0]), "watchdogd"))
return watchdogd_main(argc, argv);
/* clear the umask */
umask(0);
/* 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.
*/
mkdir("/dev", 0755);
mkdir("/proc", 0755);
mkdir("/sys", 0755);
mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
mkdir("/dev/pts", 0755);
mkdir("/dev/socket", 0755);
mount("devpts", "/dev/pts", "devpts", 0, NULL);
mount("proc", "/proc", "proc", 0, NULL);
mount("sysfs", "/sys", "sysfs", 0, NULL);
/* indicate that booting is in progress to background fw loaders, etc */
close(open("/dev/.booting", O_WRONLY | O_CREAT, 0000));
/* We must have some place other than / to create the
* device nodes for kmsg and null, otherwise we won't
* be able to remount / read-only later on.
* Now that tmpfs is mounted on /dev, we can actually
* talk to the outside world.
*/
open_devnull_stdio();
klog_init();
property_init();
get_hardware_name(hardware, &revision);
process_kernel_cmdline();
#ifdef HAVE_SELINUX
union selinux_callback cb;
cb.func_log = klog_write;
selinux_set_callback(SELINUX_CB_LOG, cb);
cb.func_audit = audit_callback;
selinux_set_callback(SELINUX_CB_AUDIT, cb);
INFO("loading selinux policy\n");
if (selinux_enabled) {
if (selinux_android_load_policy() < 0) {
selinux_enabled = 0;
INFO("SELinux: Disabled due to failed policy load\n");
} else {
selinux_init_all_handles();
}
} else {
INFO("SELinux: Disabled by command line option\n");
}
/* These directories were necessarily created before initial policy load
* and therefore need their security context restored to the proper value.
* This must happen before /dev is populated by ueventd.
*/
restorecon("/dev");
restorecon("/dev/socket");
#endif
is_charger = !strcmp(bootmode, "charger");
INFO("property init\n");
if (!is_charger)
property_load_boot_defaults();
INFO("reading config file\n");
init_parse_config_file("/init.rc");
action_for_each_trigger("early-init", action_add_queue_tail);
queue_builtin_action(wait_for_coldboot_done_action, "wait_for_coldboot_done");
queue_builtin_action(keychord_init_action, "keychord_init");
//queue_builtin_action(console_init_action, "console_init");
/* execute all the boot actions to get us started */
action_for_each_trigger("init", action_add_queue_tail);
/* skip mounting filesystems in charger mode */
if (!is_charger) {
action_for_each_trigger("early-fs", action_add_queue_tail);
queue_builtin_action(console_init_action, "console_init");
action_for_each_trigger("fs", action_add_queue_tail);
action_for_each_trigger("post-fs", action_add_queue_tail);
action_for_each_trigger("post-fs-data", action_add_queue_tail);
}
queue_builtin_action(property_service_init_action, "property_service_init");
queue_builtin_action(signal_init_action, "signal_init");
queue_builtin_action(check_startup_action, "check_startup");
if (is_charger) {
action_for_each_trigger("charger", action_add_queue_tail);
} else {
action_for_each_trigger("early-boot", action_add_queue_tail);
action_for_each_trigger("boot", action_add_queue_tail);
}
/* run all property triggers based on current state of the properties */
queue_builtin_action(queue_property_triggers_action, "queue_property_triggers");
#if BOOTCHART
queue_builtin_action(bootchart_init_action, "bootchart_init");
#endif
for(;;) {
int nr, i, timeout = -1;
execute_one_command();
restart_processes();
if (!property_set_fd_init && get_property_set_fd() > 0) {
ufds[fd_count].fd = get_property_set_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
property_set_fd_init = 1;
}
if (!signal_fd_init && get_signal_fd() > 0) {
ufds[fd_count].fd = get_signal_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
signal_fd_init = 1;
}
if (!keychord_fd_init && get_keychord_fd() > 0) {
ufds[fd_count].fd = get_keychord_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
keychord_fd_init = 1;
}
if (process_needs_restart) {
timeout = (process_needs_restart - gettime()) * 1000;
if (timeout < 0)
timeout = 0;
}
if (!action_queue_empty() || cur_action)
timeout = 0;
#if BOOTCHART
if (bootchart_count > 0) {
if (timeout < 0 || timeout > BOOTCHART_POLLING_MS)
timeout = BOOTCHART_POLLING_MS;
if (bootchart_step() < 0 || --bootchart_count == 0) {
bootchart_finish();
bootchart_count = 0;
}
}
#endif
nr = poll(ufds, fd_count, timeout);
if (nr <= 0)
continue;
for (i = 0; i < fd_count; i++) {
if (ufds[i].revents == POLLIN) {
if (ufds[i].fd == get_property_set_fd())
handle_property_set_fd();
else if (ufds[i].fd == get_keychord_fd())
handle_keychord();
else if (ufds[i].fd == get_signal_fd())
handle_signal();
}
}
}
return 0;
}
int ueventd_main(int argc, char **argv)
{
struct pollfd ufd;
int nr;
char tmp[32];
/*
* init sets the umask to 077 for forked processes. We need to
* create files with exact permissions, without modification by
* the umask.
*/
umask(000);
/* Prevent fire-and-forget children from becoming zombies.
* If we should need to wait() for some children in the future
* (as opposed to none right now), double-forking here instead
* of ignoring SIGCHLD may be the better solution.
*/
signal(SIGCHLD, SIG_IGN);
open_devnull_stdio();
klog_init();
#if LOG_UEVENTS
/* Ensure we're at a logging level that will show the events */
if (klog_get_level() < KLOG_INFO_LEVEL) {
klog_set_level(KLOG_INFO_LEVEL);
}
#endif
union selinux_callback cb;
cb.func_log = log_callback;
selinux_set_callback(SELINUX_CB_LOG, cb);
INFO("starting ueventd\n");
/* Respect hardware passed in through the kernel cmd line. Here we will look
* for androidboot.hardware param in kernel cmdline, and save its value in
* hardware[]. */
import_kernel_cmdline(0, import_kernel_nv);
get_hardware_name(hardware, &revision);
ueventd_parse_config_file("/ueventd.rc");
snprintf(tmp, sizeof(tmp), "/ueventd.%s.rc", hardware);
ueventd_parse_config_file(tmp);
device_init();
ufd.events = POLLIN;
ufd.fd = get_device_fd();
while(1) {
ufd.revents = 0;
nr = poll(&ufd, 1, -1);
if (nr <= 0)
continue;
if (ufd.revents & POLLIN)
handle_device_fd();
}
}
int main(int argc, char **argv)
{
int fd_count = 0;
struct pollfd ufds[4];
char *tmpdev;
char* debuggable;
char tmp[32];
int property_set_fd_init = 0;
int signal_fd_init = 0;
int keychord_fd_init = 0;
bool is_charger = false; // 判断是否是在充电
char* args_swapon[2];
args_swapon[0] = "swapon_all";;
args_swapon[1] = "/fstab.sun8i";;
char* args_write[3];
args_write[0] = "write";
args_write[1] = "/proc/sys/vm/page-cluster";
args_write[2] = "0";
if (!strcmp(basename(argv[0]), "ueventd"))
return ueventd_main(argc, argv);
if (!strcmp(basename(argv[0]), "watchdogd"))
return watchdogd_main(argc, argv);
/* clear the umask */
umask(0);
/* 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.
*/
// 创建设备节点
mkdir("/dev", 0755);
mkdir("/proc", 0755);
mkdir("/sys", 0755);
mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
mkdir("/dev/pts", 0755);
mkdir("/dev/socket", 0755);
mount("devpts", "/dev/pts", "devpts", 0, NULL);
mount("proc", "/proc", "proc", 0, NULL);
mount("sysfs", "/sys", "sysfs", 0, NULL);
/* indicate that booting is in progress to background fw loaders, etc */
close(open("/dev/.booting", O_WRONLY | O_CREAT, 0000));
/* We must have some place other than / to create the
* device nodes for kmsg and null, otherwise we won't
* be able to remount / read-only later on.
* Now that tmpfs is mounted on /dev, we can actually
* talk to the outside world.
*/
open_devnull_stdio(); // stdio/stdout/stderr都指向__null__设备
klog_init(); // 从这里创建__kmsg__设备
property_init(); // 1. 完成property的环境变量初始化等动作
get_hardware_name(hardware, &revision);
process_kernel_cmdline(); // 属性初始设置
union selinux_callback cb;
cb.func_log = klog_write;
selinux_set_callback(SELINUX_CB_LOG, cb);
cb.func_audit = audit_callback;
selinux_set_callback(SELINUX_CB_AUDIT, cb);
selinux_initialize();
/* These directories were necessarily created before initial policy load
* and therefore need their security context restored to the proper value.
* This must happen before /dev is populated by ueventd.
*/
restorecon("/dev");
restorecon("/dev/socket");
restorecon("/dev/__properties__");
restorecon_recursive("/sys");
is_charger = !strcmp(bootmode, "charger"); // 从bootloader中获取是否在充电的信息
usb_charge_flag = is_charger;
INFO("property init\n");
if (!is_charger)
property_load_boot_defaults();
get_kernel_cmdline_partitions();
get_kernel_cmdline_signature();
INFO("reading config file\n");
init_parse_config_file("/init.rc");
action_for_each_trigger("early-init", action_add_queue_tail);
queue_builtin_action(wait_for_coldboot_done_action, "wait_for_coldboot_done");
queue_builtin_action(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
queue_builtin_action(keychord_init_action, "keychord_init");
/* execute all the boot actions to get us started */
action_for_each_trigger("init", action_add_queue_tail);
action_for_each_trigger("early-fs", action_add_queue_tail);
/* skip mounting filesystems in charger mode */
if (!is_charger) {
// 显示initlog.rle，也就是android第二张图片
queue_builtin_action(console_init_action, "console_init");
action_for_each_trigger("fs", action_add_queue_tail);
action_for_each_trigger("post-fs", action_add_queue_tail);
action_for_each_trigger("post-fs-data", action_add_queue_tail);
//SWAP TO ZRAM if low mem devices
if (!(get_dram_size() > 512)) {
char trigger[] = {"early-fs"};
ERROR("***************************LOW MEM DEVICE DETECT");
add_command(trigger, 2, args_swapon);
char trigger2[] = {"post-fs-data"};
add_command(trigger2, 3, args_write);
}
}
/* Repeat mix_hwrng_into_linux_rng in case /dev/hw_random or /dev/random
* wasn't ready immediately after wait_for_coldboot_done
*/
queue_builtin_action(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
queue_builtin_action(property_service_init_action, "property_service_init");
queue_builtin_action(signal_init_action, "signal_init");
queue_builtin_action(check_startup_action, "check_startup");
if (is_charger) {
// 如果是charger模式，则调用charger.c
queue_builtin_action(console_init_action, "console_init");
action_for_each_trigger("charger", action_add_queue_tail);
} else {
action_for_each_trigger("early-boot", action_add_queue_tail);
action_for_each_trigger("boot", action_add_queue_tail);
}
/* run all property triggers based on current state of the properties */
queue_builtin_action(queue_property_triggers_action, "queue_property_triggers");
#if BOOTCHART
queue_builtin_action(bootchart_init_action, "bootchart_init");
#endif
for(;;) { // 监视事件 事件处理循环
int nr, i, timeout = -1;
execute_one_command();
restart_processes();
if (!property_set_fd_init && get_property_set_fd() > 0) { // 通过套接字传递信息
ufds[fd_count].fd = get_property_set_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
property_set_fd_init = 1;
}
if (!signal_fd_init && get_signal_fd() > 0) {
ufds[fd_count].fd = get_signal_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
signal_fd_init = 1;
}
if (!keychord_fd_init && get_keychord_fd() > 0) {
ufds[fd_count].fd = get_keychord_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
keychord_fd_init = 1;
}
if (process_needs_restart) {
timeout = (process_needs_restart - gettime()) * 1000;
if (timeout < 0)
timeout = 0;
}
if (!action_queue_empty() || cur_action)
timeout = 0;
#if BOOTCHART
if (bootchart_count > 0) {
if (timeout < 0 || timeout > BOOTCHART_POLLING_MS)
timeout = BOOTCHART_POLLING_MS;
if (bootchart_step() < 0 || --bootchart_count == 0) {
bootchart_finish();
bootchart_count = 0;
}
}
#endif
nr = poll(ufds, fd_count, timeout); // 获取事件（热插拔检测）
if (nr <= 0)
continue;
for (i = 0; i < fd_count; i++) { // 处理套接字传回的信息
if (ufds[i].revents & POLLIN) {
if (ufds[i].fd == get_property_set_fd()) // 处理属性变更
handle_property_set_fd();
else if (ufds[i].fd == get_keychord_fd())
handle_keychord();
else if (ufds[i].fd == get_signal_fd()) // 处理子进程传回的信息
handle_signal();
}
}
}
return 0;
}
int ueventd_main(int argc, char **argv)
{
struct pollfd ufd;
int nr;
char tmp[32];
/*
* init sets the umask to 077 for forked processes. We need to
* create files with exact permissions, without modification by
* the umask.
*/
umask(000);
/* Prevent fire-and-forget children from becoming zombies.
* If we should need to wait() for some children in the future
* (as opposed to none right now), double-forking here instead
* of ignoring SIGCHLD may be the better solution.
*/
signal(SIGCHLD, SIG_IGN);
open_devnull_stdio();
klog_init();
INFO("starting ueventd\n");
/* Respect hardware passed in through the kernel cmd line. Here we will look
* for androidboot.hardware param in kernel cmdline, and save its value in
* hardware[]. */
import_kernel_cmdline(0, import_kernel_nv);
get_hardware_name(hardware, &revision);
ueventd_parse_config_file("/ueventd.rc");
snprintf(tmp, sizeof(tmp), "/ueventd.%s.rc", hardware);
ueventd_parse_config_file(tmp);
/* aosp-hybris move original ramdisk files to /android dir, so we
* also need to parse this dirs.
*/
ueventd_parse_config_file("/android/ueventd.rc");
snprintf(tmp, sizeof(tmp), "/android/ueventd.%s.rc", hardware);
ueventd_parse_config_file(tmp);
device_init();
ufd.events = POLLIN;
ufd.fd = get_device_fd();
while(1) {
ufd.revents = 0;
nr = poll(&ufd, 1, -1);
if (nr <= 0)
continue;
if (ufd.revents & POLLERR) {
ERROR("got POLLERR, terminating ueventd\n");
exit(1);
}
if (ufd.revents == POLLIN)
handle_device_fd();
}
}
int ueventd_main(int argc, char **argv)
{
struct pollfd ufd;
int nr;
char tmp[32];
/* kernel will launch a program in user space to load
* modules, by default it is modprobe.
* Kernel doesn't send module parameters, so we don't
* need to support them.
* No deferred loading in this case.
*/
if (!strcmp(basename(argv[0]), "modprobe")) {
if (argc >= 4
&& argv[3] != NULL
&& *argv[3] != '\0') {
uid_t uid;
/* We only accept requests from root user (kernel) */
uid = getuid();
if (uid)
return -EPERM;
return module_probe(argv[3]);
} else {
/* modprobe is called without enough arguments */
return -EINVAL;
}
}
/*
* init sets the umask to 077 for forked processes. We need to
* create files with exact permissions, without modification by
* the umask.
*/
umask(000);
/* Prevent fire-and-forget children from becoming zombies.
* If we should need to wait() for some children in the future
* (as opposed to none right now), double-forking here instead
* of ignoring SIGCHLD may be the better solution.
*/
signal(SIGCHLD, SIG_IGN);
open_devnull_stdio();
klog_init();
INFO("starting ueventd\n");
/* Respect hardware passed in through the kernel cmd line. Here we will look
* for androidboot.hardware param in kernel cmdline, and save its value in
* hardware[]. */
import_kernel_cmdline(0, import_kernel_nv);
get_hardware_name(hardware, &revision);
ueventd_parse_config_file("/ueventd.rc");
snprintf(tmp, sizeof(tmp), "/ueventd.%s.rc", hardware);
ueventd_parse_config_file(tmp);
device_init();
ufd.events = POLLIN;
ufd.fd = get_device_fd();
while(1) {
ufd.revents = 0;
nr = poll(&ufd, 1, -1);
if (nr <= 0)
continue;
if (ufd.revents == POLLIN)
handle_device_fd();
}
}
int main(int argc, char *argv[])
{
if (argc > 1)
return do_cmdline(argc, argv);
int res;
static char *const cmd[] = { "/init", NULL };
umask(000);
// Init only the little we need, leave the rest for real init
mkdir("/dev", 0755);
mkdir("/dev/pts", 0755);
mkdir("/dev/socket", 0755);
mkdir("/proc", 0755);
mkdir("/sys", 0755);
mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
mount("devpts", "/dev/pts", "devpts", 0, NULL);
mount("proc", "/proc", "proc", 0, NULL);
mount("sysfs", "/sys", "sysfs", 0, NULL);
mount("pstore", "/sys/fs/pstore", "pstore", 0, NULL);
#if MR_USE_DEBUGFS_MOUNT
// Mount the debugfs kernel sysfs
mkdir("/sys/kernel/debug", 0755);
mount("debugfs", "/sys/kernel/debug", "debugfs", 0, NULL);
#endif
klog_init();
// output all messages to dmesg,
// but it is possible to filter out INFO messages
klog_set_level(6);
mrom_set_log_tag("trampoline");
INFO("Running trampoline v%d\n", VERSION_TRAMPOLINE);
if(is_charger_mode())
{
INFO("Charger mode detected, skipping multirom\n");
goto run_main_init;
}
#if MR_DEVICE_HOOKS >= 3
tramp_hook_before_device_init();
#endif
INFO("Initializing devices...\n");
devices_init();
INFO("Done initializing\n");
run_core();
// close and destroy everything
devices_close();
run_main_init:
umount("/dev/pts");
rmdir("/dev/pts");
rmdir("/dev/socket");
if(access(KEEP_REALDATA, F_OK) < 0) {
umount("/dev");
}
#if MR_USE_DEBUGFS_MOUNT
umount("/sys/kernel/debug");
#endif
umount("/proc");
umount("/sys/fs/pstore");
umount("/sys");
INFO("Running main_init\n");
fixup_symlinks();
chmod("/main_init", EXEC_MASK);
rename("/main_init", "/init");
res = execve(cmd[0], cmd, NULL);
ERROR("execve returned %d %d %s\n", res, errno, strerror(errno));
return 0;
}
int main(int argc, char **argv)
{
int fd_count = 0;
struct pollfd ufds[4];
int property_set_fd_init = 0;
int signal_fd_init = 0;
int keychord_fd_init = 0;
bool is_charger = false;
if (!strcmp(basename(argv[0]), "ueventd"))
return ueventd_main(argc, argv);
if (!strcmp(basename(argv[0]), "watchdogd"))
return watchdogd_main(argc, argv);
/* clear the umask */
umask(0);
/* 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.
*/
mkdir("/dev", 0755);
mkdir("/proc", 0755);
mkdir("/sys", 0755);
mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
mkdir("/dev/pts", 0755);
mkdir("/dev/socket", 0755);
mount("devpts", "/dev/pts", "devpts", 0, NULL);
mount("proc", "/proc", "proc", 0, NULL);
mount("sysfs", "/sys", "sysfs", 0, NULL);
/* indicate that booting is in progress to background fw loaders, etc */
close(open("/dev/.booting", O_WRONLY | O_CREAT, 0000));
/* We must have some place other than / to create the
* device nodes for kmsg and null, otherwise we won't
* be able to remount / read-only later on.
* Now that tmpfs is mounted on /dev, we can actually
* talk to the outside world.
*/
open_devnull_stdio();
klog_init();
property_init();
get_hardware_name(hardware, &revision);
process_kernel_cmdline();
union selinux_callback cb;
cb.func_log = log_callback;
selinux_set_callback(SELINUX_CB_LOG, cb);
cb.func_audit = audit_callback;
selinux_set_callback(SELINUX_CB_AUDIT, cb);
selinux_initialize();
/* These directories were necessarily created before initial policy load
* and therefore need their security context restored to the proper value.
* This must happen before /dev is populated by ueventd.
*/
restorecon("/dev");
restorecon("/dev/socket");
restorecon("/dev/__properties__");
restorecon_recursive("/sys");
is_charger = !strcmp(bootmode, "charger");
INFO("property init\n");
property_load_boot_defaults();
INFO("reading config file\n");
init_parse_config_file("/init.rc");
action_for_each_trigger("early-init", action_add_queue_tail);
queue_builtin_action(wait_for_coldboot_done_action, "wait_for_coldboot_done");
queue_builtin_action(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
queue_builtin_action(keychord_init_action, "keychord_init");
queue_builtin_action(console_init_action, "console_init");
/* execute all the boot actions to get us started */
action_for_each_trigger("init", action_add_queue_tail);
/* Repeat mix_hwrng_into_linux_rng in case /dev/hw_random or /dev/random
* wasn't ready immediately after wait_for_coldboot_done
*/
queue_builtin_action(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
queue_builtin_action(property_service_init_action, "property_service_init");
queue_builtin_action(signal_init_action, "signal_init");
/* Don't mount filesystems or start core system services if in charger mode. */
if (is_charger) {
action_for_each_trigger("charger", action_add_queue_tail);
} else {
action_for_each_trigger("late-init", action_add_queue_tail);
}
/* run all property triggers based on current state of the properties */
queue_builtin_action(queue_property_triggers_action, "queue_property_triggers");
#if BOOTCHART
queue_builtin_action(bootchart_init_action, "bootchart_init");
#endif
for(;;) {
int nr, i, timeout = -1;
execute_one_command();
restart_processes();
if (!property_set_fd_init && get_property_set_fd() > 0) {
ufds[fd_count].fd = get_property_set_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
property_set_fd_init = 1;
}
if (!signal_fd_init && get_signal_fd() > 0) {
ufds[fd_count].fd = get_signal_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
signal_fd_init = 1;
}
if (!keychord_fd_init && get_keychord_fd() > 0) {
ufds[fd_count].fd = get_keychord_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
keychord_fd_init = 1;
}
if (process_needs_restart) {
timeout = (process_needs_restart - gettime()) * 1000;
if (timeout < 0)
timeout = 0;
}
if (!action_queue_empty() || cur_action)
timeout = 0;
#if BOOTCHART
if (bootchart_count > 0) {
long long current_time;
int elapsed_time, remaining_time;
current_time = bootchart_gettime();
elapsed_time = current_time - bootchart_time;
if (elapsed_time >= BOOTCHART_POLLING_MS) {
/* count missed samples */
while (elapsed_time >= BOOTCHART_POLLING_MS) {
elapsed_time -= BOOTCHART_POLLING_MS;
bootchart_count--;
}
/* count may be negative, take a sample anyway */
bootchart_time = current_time;
if (bootchart_step() < 0 || bootchart_count <= 0) {
bootchart_finish();
bootchart_count = 0;
}
}
if (bootchart_count > 0) {
remaining_time = BOOTCHART_POLLING_MS - elapsed_time;
if (timeout < 0 || timeout > remaining_time)
timeout = remaining_time;
}
}
#endif
nr = poll(ufds, fd_count, timeout);
if (nr <= 0)
continue;
for (i = 0; i < fd_count; i++) {
if (ufds[i].revents & POLLIN) {
if (ufds[i].fd == get_property_set_fd())
handle_property_set_fd();
else if (ufds[i].fd == get_keychord_fd())
handle_keychord();
else if (ufds[i].fd == get_signal_fd())
handle_signal();
}
}
}
return 0;
}
int main (int argc, char *argv[])
{
errcode_t retval = 0, retval2 = 0, orig_retval = 0;
int exit_value = FSCK_OK;
ext2_filsys fs = 0;
io_manager io_ptr;
struct ext2_super_block *sb;
const char *lib_ver_date;
int my_ver, lib_ver;
e2fsck_t ctx;
blk_t orig_superblock;
struct problem_context pctx;
int flags, run_result;
int journal_size;
int sysval, sys_page_size = 4096;
__u32 features[3];
char *cp;
klog_init();
E2F_DBG_INFO("e2fsck start...");
#ifdef E2FSCK_PIPE_DEBUG_
memset(pipe_msg_temp, 0, MSG_LEN);
memcpy(pipe_msg_temp, argv[2], strlen(argv[2]));
pipe_open();
pipe_write(C_IN_START);
#endif
clear_problem_context(&pctx);
#ifdef MTRACE
mtrace();
#endif
#ifdef MCHECK
mcheck(0);
#endif
#ifdef ENABLE_NLS
setlocale(LC_MESSAGES, "");
setlocale(LC_CTYPE, "");
bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
textdomain(NLS_CAT_NAME);
#endif
my_ver = ext2fs_parse_version_string(my_ver_string);
lib_ver = ext2fs_get_library_version(0, &lib_ver_date);
if (my_ver > lib_ver) {
fprintf( stderr, _("Error: ext2fs library version "
"out of date!\n"));
show_version_only++;
}
retval = PRS(argc, argv, &ctx);
if (retval) {
com_err("e2fsck", retval,
_("while trying to initialize program"));
exit(FSCK_ERROR);
}
reserve_stdio_fds();
init_resource_track(&ctx->global_rtrack, NULL);
if (!(ctx->options & E2F_OPT_PREEN) || show_version_only)
fprintf(stderr, "e2fsck %s (%s)\n", my_ver_string,
my_ver_date);
if (show_version_only) {
fprintf(stderr, _("\tUsing %s, %s\n"),
error_message(EXT2_ET_BASE), lib_ver_date);
exit(FSCK_OK);
}
check_mount(ctx);
if (!(ctx->options & E2F_OPT_PREEN) &&
!(ctx->options & E2F_OPT_NO) &&
!(ctx->options & E2F_OPT_YES)) {
if (!ctx->interactive)
fatal_error(ctx,
_("need terminal for interactive repairs"));
}
ctx->superblock = ctx->use_superblock;
restart:
#ifdef CONFIG_TESTIO_DEBUG
if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_BLOCK")) {
io_ptr = test_io_manager;
test_io_backing_manager = unix_io_manager;
} else
#endif
io_ptr = unix_io_manager;
flags = EXT2_FLAG_NOFREE_ON_ERROR;
if ((ctx->options & E2F_OPT_READONLY) == 0)
flags |= EXT2_FLAG_RW;
if ((ctx->mount_flags & EXT2_MF_MOUNTED) == 0)
flags |= EXT2_FLAG_EXCLUSIVE;
retval = try_open_fs(ctx, flags, io_ptr, &fs);
if (!ctx->superblock && !(ctx->options & E2F_OPT_PREEN) &&
!(ctx->flags & E2F_FLAG_SB_SPECIFIED) &&
((retval == EXT2_ET_BAD_MAGIC) ||
(retval == EXT2_ET_CORRUPT_SUPERBLOCK) ||
((retval == 0) && (retval2 = ext2fs_check_desc(fs))))) {
if (retval2 == ENOMEM) {
retval = retval2;
goto failure;
}
if (fs->flags & EXT2_FLAG_NOFREE_ON_ERROR) {
ext2fs_free(fs);
fs = NULL;
}
if (!fs || (fs->group_desc_count > 1)) {
printf(_("%s: %s trying backup blocks...\n"),
ctx->program_name,
retval ? _("Superblock invalid,") :
_("Group descriptors look bad..."));
orig_superblock = ctx->superblock;
get_backup_sb(ctx, fs, ctx->filesystem_name, io_ptr);
if (fs)
ext2fs_close(fs);
orig_retval = retval;
retval = try_open_fs(ctx, flags, io_ptr, &fs);
if ((orig_retval == 0) && retval != 0) {
if (fs)
ext2fs_close(fs);
com_err(ctx->program_name, retval,
"when using the backup blocks");
printf(_("%s: going back to original "
"superblock\n"), ctx->program_name);
ctx->superblock = orig_superblock;
retval = try_open_fs(ctx, flags, io_ptr, &fs);
}
}
}
if (((retval == EXT2_ET_UNSUPP_FEATURE) ||
(retval == EXT2_ET_RO_UNSUPP_FEATURE)) &&
fs && fs->super) {
sb = fs->super;
features[0] = (sb->s_feature_compat &
~EXT2_LIB_FEATURE_COMPAT_SUPP);
features[1] = (sb->s_feature_incompat &
~EXT2_LIB_FEATURE_INCOMPAT_SUPP);
features[2] = (sb->s_feature_ro_compat &
~EXT2_LIB_FEATURE_RO_COMPAT_SUPP);
if (features[0] || features[1] || features[2])
goto print_unsupp_features;
}
failure:
if (retval) {
if (orig_retval)
retval = orig_retval;
com_err(ctx->program_name, retval, _("while trying to open %s"),
ctx->filesystem_name);
if (retval == EXT2_ET_REV_TOO_HIGH) {
printf(_("The filesystem revision is apparently "
"too high for this version of e2fsck.\n"
"(Or the filesystem superblock "
"is corrupt)\n\n"));
fix_problem(ctx, PR_0_SB_CORRUPT, &pctx);
} else if (retval == EXT2_ET_SHORT_READ)
printf(_("Could this be a zero-length partition?\n"));
else if ((retval == EPERM) || (retval == EACCES))
printf(_("You must have %s access to the "
"filesystem or be root\n"),
(ctx->options & E2F_OPT_READONLY) ?
"r/o" : "r/w");
else if (retval == ENXIO)
printf(_("Possibly non-existent or swap device?\n"));
else if (retval == EBUSY)
printf(_("Filesystem mounted or opened exclusively "
"by another program?\n"));
else if (retval == ENOENT)
printf(_("Possibly non-existent device?\n"));
#ifdef EROFS
else if (retval == EROFS)
printf(_("Disk write-protected; use the -n option "
"to do a read-only\n"
"check of the device.\n"));
#endif
else
fix_problem(ctx, PR_0_SB_CORRUPT, &pctx);
fatal_error(ctx, 0);
}
/*
* We only update the master superblock because (a) paranoia;
* we don't want to corrupt the backup superblocks, and (b) we
* don't need to update the mount count and last checked
* fields in the backup superblock (the kernel doesn't update
* the backup superblocks anyway). With newer versions of the
* library this flag is set by ext2fs_open2(), but we set this
* here just to be sure. (No, we don't support e2fsck running
* with some other libext2fs than the one that it was shipped
* with, but just in case....)
*/
fs->flags |= EXT2_FLAG_MASTER_SB_ONLY;
if (!(ctx->flags & E2F_FLAG_GOT_DEVSIZE)) {
__u32 blocksize = EXT2_BLOCK_SIZE(fs->super);
int need_restart = 0;
pctx.errcode = ext2fs_get_device_size2(ctx->filesystem_name,
blocksize,
&ctx->num_blocks);
/*
* The floppy driver refuses to allow anyone else to
* open the device if has been opened with O_EXCL;
* this is unlike other block device drivers in Linux.
* To handle this, we close the filesystem and then
* reopen the filesystem after we get the device size.
*/
if (pctx.errcode == EBUSY) {
ext2fs_close(fs);
need_restart++;
pctx.errcode =
ext2fs_get_device_size2(ctx->filesystem_name,
blocksize,
&ctx->num_blocks);
}
if (pctx.errcode == EXT2_ET_UNIMPLEMENTED)
ctx->num_blocks = 0;
else if (pctx.errcode) {
fix_problem(ctx, PR_0_GETSIZE_ERROR, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
fatal_error(ctx, 0);
}
ctx->flags |= E2F_FLAG_GOT_DEVSIZE;
if (need_restart)
goto restart;
}
ctx->fs = fs;
fs->priv_data = ctx;
fs->now = ctx->now;
sb = fs->super;
if (sb->s_rev_level > E2FSCK_CURRENT_REV) {
com_err(ctx->program_name, EXT2_ET_REV_TOO_HIGH,
_("while trying to open %s"),
ctx->filesystem_name);
get_newer:
fatal_error(ctx, _("Get a newer version of e2fsck!"));
}
/*
* Set the device name, which is used whenever we print error
* or informational messages to the user.
*/
if (ctx->device_name == 0 &&
(sb->s_volume_name[0] != 0)) {
ctx->device_name = string_copy(ctx, sb->s_volume_name,
sizeof(sb->s_volume_name));
}
if (ctx->device_name == 0)
ctx->device_name = string_copy(ctx, ctx->filesystem_name, 0);
for (cp = ctx->device_name; *cp; cp++)
if (isspace(*cp) || *cp == ':')
*cp = '_';
ehandler_init(fs->io);
if ((ctx->mount_flags & EXT2_MF_MOUNTED) &&
!(sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER))
goto skip_journal;
/*
* Make sure the ext3 superblock fields are consistent.
*/
retval = e2fsck_check_ext3_journal(ctx);
if (retval) {
com_err(ctx->program_name, retval,
_("while checking ext3 journal for %s"),
ctx->device_name);
fatal_error(ctx, 0);
}
/*
* Check to see if we need to do ext3-style recovery. If so,
* do it, and then restart the fsck.
*/
if (sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) {
if (ctx->options & E2F_OPT_READONLY) {
printf(_("Warning: skipping journal recovery "
"because doing a read-only filesystem "
"check.\n"));
io_channel_flush(ctx->fs->io);
} else {
if (ctx->flags & E2F_FLAG_RESTARTED) {
/*
* Whoops, we attempted to run the
* journal twice. This should never
* happen, unless the hardware or
* device driver is being bogus.
*/
com_err(ctx->program_name, 0,
_("unable to set superblock flags on %s\n"), ctx->device_name);
fatal_error(ctx, 0);
}
retval = e2fsck_run_ext3_journal(ctx);
if (retval) {
com_err(ctx->program_name, retval,
_("while recovering ext3 journal of %s"),
ctx->device_name);
fatal_error(ctx, 0);
}
ext2fs_close(ctx->fs);
ctx->fs = 0;
ctx->flags |= E2F_FLAG_RESTARTED;
goto restart;
}
}
skip_journal:
/*
* Check for compatibility with the feature sets. We need to
* be more stringent than ext2fs_open().
*/
features[0] = sb->s_feature_compat & ~EXT2_LIB_FEATURE_COMPAT_SUPP;
features[1] = sb->s_feature_incompat & ~EXT2_LIB_FEATURE_INCOMPAT_SUPP;
features[2] = (sb->s_feature_ro_compat &
~EXT2_LIB_FEATURE_RO_COMPAT_SUPP);
print_unsupp_features:
if (features[0] || features[1] || features[2]) {
int i, j;
__u32 *mask = features, m;
fprintf(stderr, _("%s has unsupported feature(s):"),
ctx->filesystem_name);
for (i=0; i <3; i++,mask++) {
for (j=0,m=1; j < 32; j++, m<<=1) {
if (*mask & m)
fprintf(stderr, " %s",
e2p_feature2string(i, m));
}
}
putc('\n', stderr);
goto get_newer;
}
#ifdef ENABLE_COMPRESSION
if (sb->s_feature_incompat & EXT2_FEATURE_INCOMPAT_COMPRESSION)
com_err(ctx->program_name, 0,
_("Warning: compression support is experimental.\n"));
#endif
#ifndef ENABLE_HTREE
if (sb->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) {
com_err(ctx->program_name, 0,
_("E2fsck not compiled with HTREE support,\n\t"
"but filesystem %s has HTREE directories.\n"),
ctx->device_name);
goto get_newer;
}
#endif
/*
* If the user specified a specific superblock, presumably the
* master superblock has been trashed. So we mark the
* superblock as dirty, so it can be written out.
*/
if (ctx->superblock &&
!(ctx->options & E2F_OPT_READONLY))
ext2fs_mark_super_dirty(fs);
/*
* Calculate the number of filesystem blocks per pagesize. If
* fs->blocksize > page_size, set the number of blocks per
* pagesize to 1 to avoid division by zero errors.
*/
#ifdef _SC_PAGESIZE
sysval = sysconf(_SC_PAGESIZE);
if (sysval > 0)
sys_page_size = sysval;
#endif /* _SC_PAGESIZE */
ctx->blocks_per_page = sys_page_size / fs->blocksize;
if (ctx->blocks_per_page == 0)
ctx->blocks_per_page = 1;
if (ctx->superblock)
set_latch_flags(PR_LATCH_RELOC, PRL_LATCHED, 0);
ext2fs_mark_valid(fs);
check_super_block(ctx);
if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
fatal_error(ctx, 0);
check_if_skip(ctx);
check_resize_inode(ctx);
if (bad_blocks_file)
read_bad_blocks_file(ctx, bad_blocks_file, replace_bad_blocks);
else if (cflag)
read_bad_blocks_file(ctx, 0, !keep_bad_blocks); /* Test disk */
if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
fatal_error(ctx, 0);
/*
* Mark the system as valid, 'til proven otherwise
*/
ext2fs_mark_valid(fs);
retval = ext2fs_read_bb_inode(fs, &fs->badblocks);
if (retval) {
com_err(ctx->program_name, retval,
_("while reading bad blocks inode"));
preenhalt(ctx);
printf(_("This doesn't bode well,"
" but we'll try to go on...\n"));
}
/*
* Save the journal size in megabytes.
* Try and use the journal size from the backup else let e2fsck
* find the default journal size.
*/
if (sb->s_jnl_backup_type == EXT3_JNL_BACKUP_BLOCKS)
journal_size = sb->s_jnl_blocks[16] >> 20;
else
int main(int argc, const char *argv[])
{
int i;
const char *rom_to_boot = NULL;
for(i = 1; i < argc; ++i)
{
if(strcmp(argv[i], "-v") == 0)
{
printf("%d%s\n", VERSION_MULTIROM, VERSION_DEV_FIX);
fflush(stdout);
return 0;
}
else if(strncmp(argv[i], "--boot-rom=", sizeof("--boot-rom")) == 0)
{
rom_to_boot = argv[i] + sizeof("--boot-rom");
}
}
srand(time(0));
klog_init();
// output all messages to dmesg,
// but it is possible to filter out INFO messages
klog_set_level(6);
mrom_set_log_tag("multirom");
ERROR("Running MultiROM v%d%s\n", VERSION_MULTIROM, VERSION_DEV_FIX);
// root is mounted read only in android and MultiROM uses
// it to store some temp files, so remount it.
// Yes, there is better solution to this.
if(rom_to_boot)
mount(NULL, "/", NULL, MS_REMOUNT, NULL);
int exit = multirom(rom_to_boot);
if(rom_to_boot)
mount(NULL, "/", NULL, MS_RDONLY | MS_REMOUNT, NULL);
if(exit >= 0)
{
if(exit & EXIT_REBOOT_RECOVERY)
do_reboot(REBOOT_RECOVERY);
else if(exit & EXIT_REBOOT_BOOTLOADER)
do_reboot(REBOOT_BOOTLOADER);
else if(exit & EXIT_SHUTDOWN)
do_reboot(REBOOT_SHUTDOWN);
else if(exit & EXIT_REBOOT)
do_reboot(REBOOT_SYSTEM);
if(exit & EXIT_KEXEC)
{
do_kexec();
return 0;
}
// indicates trampoline to keep /realdata mounted
if(!(exit & EXIT_UMOUNT))
close(open(KEEP_REALDATA, O_WRONLY | O_CREAT, 0000));
}
vt_set_mode(0);
return 0;
}
