android recovery 和reboot

android  recovery 和reboot

recovery工作的是要bootloader支持的，因为bootloader要选择启动哪个kernel和ramdisk。

设置模块中进行恢复出厂设置操作，recovery
Power.reboot("recovery");

 

reboot system  

  

case1: factory reset  

Settings/src/com/android/settings/MasterClear.java  

 sendBroadcast(new Intent("android.intent.action.MASTER_CLEAR"));  

->  

frameworks/base/services/java/com/android/server/MasterClearReceiver.java  

    RecoverySystem.rebootWipeUserData(context);  

->  

frameworks/base/core/java/android/os/RecoverySystem.java  

    bootCommand(context, "--wipe_data");  

    ->  

    PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);  

    pm.reboot("recovery");  

->  

frameworks/base/services/java/com/android/server/PowerManagerService.java  

    public void reboot(String reason){  

        ShutdownThread.reboot(mContext, finalReason, false);  

    }  

->  

frameworks/base/core/java/com/android/internal/app/ShutdownThread.java  

    rebootOrShutdown(){  

        Power.reboot(reason);  

    }  

->  

frameworks/base/core/java/android/os/Power.java  

    rebootNative(reason);  

->  

frameworks/base/core/jni/anroid_os_Power.cpp  

    __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, (char*) chars);  

->  

kernel/kernel/sys.c  

    case LINUX_REBOOT_CMD_RESTART2:  

        kernel_restart(buffer);  

    ->  

    machine_restart(cmd);  

->  

kernel/arch/arm/kernel/process.c  

    void arm_machine_restart(char mode, const char *cmd){  

        //set flag and reboot   

    } 

参数表示reboot的原因

然后会到JNI
static void android_os_Power_reboot(JNIEnv *env, jobject clazz, jstring reason)
{
    sync();
#ifdef HAVE_ANDROID_OS
    if (reason == NULL) {
        reboot(RB_AUTOBOOT);
    } else {
        const char *chars = env->GetStringUTFChars(reason, NULL);
        __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
                 LINUX_REBOOT_CMD_RESTART2, (char*) chars);
        env->ReleaseStringUTFChars(reason, chars);  // In case it fails.
    }
    jniThrowIOException(env, errno);
#endif
}


这里会调用到c库里面的函数

__reboot:
    .save   {r4, r7}
    stmfd   sp!, {r4, r7}
    ldr     r7, =__NR_reboot
    swi     #0
    ldmfd   sp!, {r4, r7}
    movs    r0, r0
    bxpl    lr
    b       __set_syscall_errno
    .fnend


c库实际上到最底下就是系统调用的封装了，
一般都是sys_reboot的实现了，
不过Qualcomm这里用了宏来定义的。

调用了系统调用，kernel里面实现，我们就到了kernel里面

SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
        void __user *, arg)



    switch (cmd) {
    case LINUX_REBOOT_CMD_RESTART:
        kernel_restart(NULL);
        break;

    case LINUX_REBOOT_CMD_CAD_ON:
        C_A_D = 1;
        break;

    case LINUX_REBOOT_CMD_CAD_OFF:
        C_A_D = 0;
        break;

    case LINUX_REBOOT_CMD_HALT:
        kernel_halt();
        unlock_kernel();
        do_exit(0);
        break;

    case LINUX_REBOOT_CMD_POWER_OFF:
        kernel_power_off();
        unlock_kernel();
        do_exit(0);
        break;

    case LINUX_REBOOT_CMD_RESTART2:
        if (strncpy_from_user(&buffer[0], arg, sizeof(buffer) - 1) < 0) {
            unlock_kernel();
            return -EFAULT;
        }
        buffer[sizeof(buffer) - 1] = '/0';

        kernel_restart(buffer);


走到kernel_restart
void kernel_restart(char *cmd)
{
    kernel_restart_prepare(cmd);
    if (!cmd)
        printk(KERN_EMERG "Restarting system./n");
    else
        printk(KERN_EMERG "Restarting system with command '%s'./n", cmd);
    machine_restart(cmd);
}



void machine_restart(char * __unused)
{
    arm_pm_restart(reboot_mode);
}

    arm_pm_restart(reboot_mode);
这个函数是要每个target自己定义的，
以Qualcomm来说
static void msm_pm_restart(char str)
{
    msm_rpcrouter_close();
    msm_proc_comm(PCOM_RESET_CHIP, &restart_reason, 0);

    for (;;)
        ;
}

这里的restart reason是recovery

static int msm_reboot_call
    (struct notifier_block *this, unsigned long code, void *_cmd)
{
    if ((code == SYS_RESTART) && _cmd) {
        char *cmd = _cmd;
        if (!strcmp(cmd, "bootloader")) {
            restart_reason = 0x77665500;
        } else if (!strcmp(cmd, "recovery")) {
            restart_reason = 0x77665502;
        } else if (!strcmp(cmd, "eraseflash")) {
            restart_reason = 0x776655EF;
        } else if (!strncmp(cmd, "oem-", 4)) {
            unsigned code = simple_strtoul(cmd + 4, 0, 16) & 0xff;
            restart_reason = 0x6f656d00 | code;
        } else {
            restart_reason = 0x77665501;
        }
    }
    return NOTIFY_DONE;
}

会把这个原因写到smem里面去

下次启动的时候怎么管用呢？

bootloader下次起来的时候会去读这个值

Qualcomm的bootloader是appsboot.mbn
void aboot_init(const struct app_descriptor *app)
{
    unsigned reboot_mode = 0;
    unsigned disp_init = 0;
    #if DISPLAY_SPLASH_SCREEN
    display_init();
    dprintf(INFO, "Diplay initialized/n");
    disp_init = 1;
    #endif
    page_size = flash_page_size();
    page_mask = page_size - 1;
    if (keys_get_state(KEY_HOME) != 0)
            boot_into_recovery = 1;
    if (keys_get_state(KEY_BACK) != 0)
        goto fastboot;
    if (keys_get_state(KEY_CLEAR) != 0)
        goto fastboot;
    if (keys_get_state(KEY_VOLUMEUP) != 0)
        goto fastboot;
    if (keys_get_state(KEY_CAMERA) != 0)
        goto fastboot;
    if (keys_get_state(KEY_VOLUMEDOWN) != 0)
            boot_into_recovery = 1;
        //goto fastboot;

    reboot_mode = check_reboot_mode();
        if (reboot_mode == RECOVERY_MODE){
            boot_into_recovery = 1;
        }else if(reboot_mode == FASTBOOT_MODE){
            goto fastboot;
        }
    recovery_init();
    boot_linux_from_flash();
    dprintf(CRITICAL, "ERROR: Could not do normal boot. Reverting "
        "to fastboot mode./n");

fastboot:
    if(!disp_init) {
        display_init();
    } else {
        fbcon_clear();
    }
    dprintf(INFO, "Diplay initialized/n");
    udc_init(&surf_udc_device);

    fastboot_register("boot", cmd_boot);
    fastboot_register("erase:", cmd_erase);
    fastboot_register("flash:", cmd_flash);
    fastboot_register("continue", cmd_continue);
    fastboot_register("reboot", cmd_reboot);
    fastboot_register("reboot-bootloader", cmd_reboot_bootloader);
    fastboot_publish("product", "swordfish");
    fastboot_publish("kernel", "lk");

    fastboot_init(target_get_scratch_address(), 150 * 1024 * 1024);
    udc_start();
        target_battery_charging_enable(1, 0);
}

APP_START(aboot)
    .init = aboot_init,
APP_END

aboot函数进入recovery有三种情况
1：如果按键就会进入recovery
2：如果check_boot_mode是recovery的时候就会做
3 : 如果recovery_init返回的是真的话就会进入recovery mode


第一种很好理解，按组合按键进入

第二种会去读smem
unsigned check_reboot_mode(void)
{
    unsigned mode[2] = {0, 0};
    unsigned int mode_len = sizeof(mode);
    unsigned smem_status;

    smem_status = smem_read_alloc_entry(SMEM_APPS_BOOT_MODE,
                    &mode, mode_len );
    if(smem_status)
    {
      dprintf(CRITICAL, "ERROR: unable to read shared memory for reboot mode/n");
      return 0;
    }
    return mode[0];
}


unsigned smem_read_alloc_entry(smem_mem_type_t type, void *buf, int len)
{
    struct smem_alloc_info *ainfo;
    unsigned *dest = buf;
    unsigned src;
    unsigned size;

    if (((len & 0x3) != 0) || (((unsigned)buf & 0x3) != 0))
        return 1;

    if (type < SMEM_FIRST_VALID_TYPE || type > SMEM_LAST_VALID_TYPE)
        return 1;

    /* TODO: Use smem spinlocks */
    ainfo = &smem->alloc_info[type];
    if (readl(&ainfo->allocated) == 0)
        return 1;

    if ((size = readl(&ainfo->size)) != (unsigned)len)
        return 1;

    src = MSM_SHARED_BASE + readl(&ainfo->offset);
    for (; size > 0; src += 4, size -= 4)
        *(dest++) = readl(src);

    return 0;
}


这个文章只解释如何进入recovery。