static void process_kernel_cmdline() { // Don't expose the raw commandline to unprivileged processes. chmod("/proc/cmdline", 0440); // The first pass does the common stuff, and finds if we are in qemu. // The second pass is only necessary for qemu to export all kernel params // as properties. import_kernel_cmdline(false, import_kernel_nv); if (qemu[0]) import_kernel_cmdline(true, import_kernel_nv); }
static int set_init_properties_action(int nargs, char **args) { char tmp[PROP_VALUE_MAX]; if (qemu[0]) import_kernel_cmdline(1, import_kernel_nv); if (!strcmp(bootmode,"factory")) property_set("ro.factorytest", "1"); else if (!strcmp(bootmode,"factory2")) property_set("ro.factorytest", "2"); else property_set("ro.factorytest", "0"); property_set("ro.serialno", serialno[0] ? serialno : ""); property_set("ro.bootmode", bootmode[0] ? bootmode : "unknown"); property_set("ro.baseband", baseband[0] ? baseband : "unknown"); property_set("ro.carrier", carrier[0] ? carrier : "unknown"); property_set("ro.bootloader", bootloader[0] ? bootloader : "unknown"); property_set("ro.hardware", hardware); snprintf(tmp, PROP_VALUE_MAX, "%d", revision); property_set("ro.revision", tmp); property_set("ro.emmc",emmc_boot ? "1" : "0"); return 0; }
static void process_kernel_cmdline(void) { /* don't expose the raw commandline to nonpriv processes */ chmod("/proc/cmdline", 0440); /* first pass does the common stuff, and finds if we are in qemu. * second pass is only necessary for qemu to export all kernel params * as props. */ import_kernel_cmdline(0, import_kernel_nv); if (qemu[0]) import_kernel_cmdline(1, import_kernel_nv); /* now propogate the info given on command line to internal variables * used by init as well as the current required properties */ export_kernel_boot_props(); }
static selinux_enforcing_status selinux_status_from_cmdline() { selinux_enforcing_status status = SELINUX_ENFORCING; import_kernel_cmdline(false, [&](const std::string& key, const std::string& value, bool in_qemu) { if (key == "androidboot.selinux" && value == "permissive") { status = SELINUX_PERMISSIVE; } }); return status; }
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(); } }
void vendor_load_properties() { import_kernel_cmdline(0, import_kernel_nv); }
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 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 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) { pthread_t t_auto, t_input, t_uevent, t_sighandler; //Volume *vol; int ret; char *disk_conf; void (*ui_update)(void *) = NULL; sigset_t set; /* block signals for all theads */ sigemptyset(&set); sigaddset(&set, SIGPIPE); sigaddset(&set, SIGALRM); if (pthread_sigmask(SIG_BLOCK, &set, NULL)) pr_critial("block signal failed.\n"); /* create a dedicate thread to handle signals */ if (pthread_create(&t_sighandler, NULL, sig_handler, &set)) pr_critial("create signal handler thread failed.\n"); if (argc > 1) ret = load_config(argv[1]); else ret = load_config(NULL); /* currently, missing config file is not critical */ if (ret) pr_warning("can't load tboot configuration.\n"); if (ret = tboot_ui_init(tboot_config_get(UI_CONF_KEY))) pr_error("UI crashed!\n"); tboot_config_set(UI_CONF_KEY, tboot_ui_getconfpath()); ev_init(input_callback, NULL); display_sysinfo(ret); if (!ret) { ui_update = ui_callback; } pr_info(" -- preos v%s for %s --\n", preos_version, DEVICE_NAME); import_kernel_cmdline(parse_cmdline_option); disk_conf = tboot_config_get(DISK_CONFIG_KEY); if (!disk_conf) { pr_error("Invalid tboot config disk_conf.\n"); die(); } setup_disk_information(disk_conf); aboot_register_commands(); register_tboot_plugins(); if (pthread_create(&t_input, NULL, input_listener_thread, NULL)) { pr_perror("pthread_create"); die(); } lcd_state_init(); if (pthread_create(&t_uevent, NULL, uevent_thread, ui_update)) { pr_perror("pthread_create t_uevent"); die(); } /* vol = volume_for_path(SDCARD_VOLUME); if (vol) try_update_sw(vol, 1); */ if (g_use_autoboot && !g_update_location) { /* * Create menu items for debug boot, this is a feature for developers * only. * * Developers (kernel developers) put kernel, cmdline, * rmadisk.img(optional) to platform boot directory in kexec enabled * preos. * * Generally, there are two ways to do that. * * 1. you can put these files into /boot after the system boot * into rootfs. * 2. you can put these files into platform.img.gz and create a new * platform.img.gz and then flash it to target device. * * Previous, if the system can't boot into rootfs, the only way left * is flash a new platform image. Apparently, it's a huge effort. * * To make more choice, two kernels are supported now, so make sure * there is a works kernel in /boot , you can always boot into * normal system and put a new kernel by any other way, such as scp, * ftp and etc. */ /* * make our menu acts more like grub which more users familiar with. */ tboot_ui_menu_item("Boot: kernel", start_default_kernel); tboot_ui_menu_item("Boot: kernel.bak", start_backup_kernel); tboot_ui_menu_item("Boot: kernel/rootfs on TF/micro-SD card", start_mmc_kernel); /* * boot from NFS is quite useless now because the usb network bandwidth * is too narrow to satisfy the boot up sequence. It may (80%) hang at * system boot up, especially at X server start up * * So, by default, disable it. */ if (strcasecmp(tboot_config_get(ENABLE_NFS_KEY), "yes") == 0) tboot_ui_menu_item("Boot: kernel/rootfs on NFS", start_nfs_kernel); tboot_ui_menu_selected(3); // set debug boot: kernel selected if (pthread_create(&t_auto, NULL, autoboot_thread, NULL)) { pr_perror("pthread_create"); die(); } } /* * dealy to start tboot server */ do { sleep(1); } while (autoboot_enabled || power_pressed); pr_info("Listening for the fastboot protocol over USB.\n"); fastboot_init(g_scratch_size * MEGABYTE); /* Shouldn't get here */ tboot_ui_exit(); if (tboot_config) hashmapFree(tboot_config); // tboot_cmds_free(); exit(1); }
static void __init msm7x2x_init(void) { msm7x2x_misc_init(); /* Initialize regulators first so that other devices can use them */ msm7x27a_init_regulators(); msm_adsp_add_pdev(); if (cpu_is_msm8625()) msm8625_device_i2c_init(); else msm7x27a_device_i2c_init(); msm7x27a_init_ebi2(); msm7x27a_uartdm_config(); #ifdef CONFIG_HUAWEI_KERNEL import_kernel_cmdline(); #endif msm7x27a_otg_gadget(); #ifndef CONFIG_HUAWEI_CAMERA msm7x27a_cfg_smsc911x(); #endif #if (defined(CONFIG_HUAWEI_BT_BCM43XX) && defined(CONFIG_HUAWEI_KERNEL)) /*before bt probe, config the bt_wake_msm gpio*/ bt_wake_msm_config(); #endif msm7x27a_add_footswitch_devices(); msm7x27a_add_platform_devices(); /* Ensure ar6000pm device is registered before MMC/SDC */ msm7x27a_init_ar6000pm(); msm7627a_init_mmc(); msm_fb_add_devices(); msm7x2x_init_host(); msm7x27a_pm_init(); register_i2c_devices(); //#if (defined(HUAWEI_BT_BLUEZ_VER30) || (!defined(CONFIG_HUAWEI_KERNEL))) //msm7627a_bt_power_init() will check QC or BCM bt chip powers inner. msm7627a_bt_power_init(); //#endif msm7627a_camera_init(); msm7627a_add_io_devices(); /*7x25a kgsl initializations*/ msm7x25a_kgsl_3d0_init(); #ifdef CONFIG_HUAWEI_FEATURE_OEMINFO rmt_oeminfo_add_device(); #endif #ifdef CONFIG_HUAWEI_KERNEL virtualkeys_init(); #endif #ifdef CONFIG_HUAWEI_KERNEL hw_extern_sdcard_add_device(); #endif /*8x25 kgsl initializations*/ msm8x25_kgsl_3d0_init(); #ifdef CONFIG_HUAWEI_MTK6252_MODEM { unsigned smem_size; boot_reason = *(unsigned int *) (smem_get_entry(SMEM_POWER_ON_STATUS_INFO, &smem_size)); printk(KERN_NOTICE "Boot Reason = 0x%02x\n", boot_reason); mtk6252_dev_init(); } #endif }