Android上层进入recovery流程

recovery介绍

recovery是android的一种特殊模式，我称之为还原升级模式。这里从recovery的功能说起：
1.擦除用户数据
设置菜单中的恢复到出厂模式，即擦除用户数据
2.系统升级
设置菜单中的系统升级功能；OTA INSTALL，即使用update.zip包升级
recovery的详细功能在源码 bootable/recovery/recovery.c 文件的注释中有详细介绍

uboot、main system、recovery

将android系统分成三个部分：
1、Main system：用boot.img启动的Linux系统，Android的正常工作模式；
2、Recovery：用recovery.img启动的Linux系统，recovery模式；
3、uboot：引导程序，通常情况下是引导kernel uImage，挂载根文件系统，启动android镜像；也可以引导recovery.img，进入recovery模 式

这三个部分通信的两中方式：cache分区、BCB(bootloader control block)数据块
1.cache分区： main system –> recovery
cache分区主要是main system 与recovery通信，main system通过cache向recovery发送消息，控制recovery功能，如：升级或擦除数据。
通信主要通过cache下的三个文件
1）/cache/recovery/command
Main system传给Recovery的命令行，控制recovery的功能 ，如：升级或擦除数据。具体有以下几种：
–send_intent=anystring write the text out to recovery/intent
–update_package=root:path 系统升级，path表示升级包的路径
–wipe_data erase user data (and cache), then reboot
–wipe_cache wipe cache (but not user data), then reboot

2）/cache/recovery/log
存放 recvoery 过程的log。在recovery运行过程中，stdout及stderr会重定位到/tmp/recovery.log文件，Recovery退出之前会将其转储 到/cache/recovery/log中。

3）/cache/recovery/intent
Recovery传给Main system的信息

2.BCB(bootloader control block)数据块

struct bootloader_message { 
    char command[32]; 
    char status[32]; 
    char recovery[1024]; 
}; 

BCB是Bootloader与Recovery的通信接口，也是Bootloader与Main system的通信接口，存储在flash中的MISC分区，占用三个page，各成员意义如下：
command：
当Main system想要重启进入recovery模式，或升级radio/bootloader firmware时，会更新这个域。
当firmware更新完毕，为了启动后进入recovery做最终的清除，bootloader还会修改它。
下面是command域的三种情况：
（1）. command = “boot-recovery” 时，系统会进入Recovery模式。Recovery服务会具体根据/cache/recovery/command中的命令执行相应的操作
（例如，升级update.zip或擦除cache，data等）。
（2）. command = “update-radia” 或 “update-hboot” 时，系统会进入更新firmware（更新bootloader），具体由bootloader完成。
（3）. command为空时，即没有任何命令，系统会进入正常的启动，最后进入主系统（main system）。这种是最通常的启动流程。

status：
update-radio或update-hboot完成后，bootloader会写入相应的信息，一般是一些状态或执行结果。

recovery：
当Main system想要重启进入recovery模式，可能会更新这个域，注意：不是一定更新。必须以“recovery\n”开头，否则这个域的所有内容会被忽略。这一项的内容中“recovery/\n”以后的部分，是/cache/recovery/command支持的命令，可以认为这是在Recovery操作过程中，对命令操作的备份。
Recovery也会更新这个域的信息，执行某操作前把该操作命令写到recovery域，并更新command域，防止recovery过程被中断后系统不能正常启动。操作完成后再清空recovery域及command域，这样在进入Main system之前，就能确保操作被执行。

从android上层进入recvoery具体流程：

android部分：

当我们在设置中点击系统升级时，系统会起一个reboot线程，在线程中根据不同的功能调用RecoverySystem类的方法，目标文件：frameworks/base/services/java/com/android/server/MasterClearReceiver.java；
注意：这里可能不同平台有所不同，但大体思想一致

    public void onReceive(final Context context, final Intent intent) {
        ............
        Slog.w(TAG, "!!! FACTORY RESET !!!");
        // The reboot call is blocking, so we need to do it on another thread.
        Thread thr = new Thread("Reboot") {
            @Override
            public void run() {
                try {
                    if("from-sd".equals(intent.getStringExtra("update-type")))
                        {
                        RecoverySystem.rebootUpdateFromSD(context);  /*从sd卡升级*/
                    }
                    else if("from-udisk".equals(intent.getStringExtra("update-type")))
                        {                       
                        RecoverySystem.rebootUpdateFromUDisk(context);  /*从u盘升级*/
                    }
                    else
                        RecoverySystem.rebootWipeUserData(context);  /*擦除数据*/
                } catch (IOException e) {
                    Slog.e(TAG, "Can't perform master clear/factory reset", e);
                }
            }
        };
        thr.start();
    }

RecoverySystem类定义于文件：frameworks/base/core/java/android/os/RecoverySystem.java

public class RecoverySystem {
    /*这里创建了cache/recovery 下的文件，用于向recovery传递消息*/
    private static File RECOVERY_DIR = new File("/cache/recovery");
    private static File COMMAND_FILE = new File(RECOVERY_DIR, "command");
    private static File LOG_FILE = new File(RECOVERY_DIR, "log");
    private static String LAST_PREFIX = "last_";  /*最新的log 以last_开头*/

    public static void rebootWipeUserData(Context context) throws IOException {
        final ConditionVariable condition = new ConditionVariable();
        Intent intent = new Intent("android.intent.action.MASTER_CLEAR_NOTIFICATION");
        context.sendOrderedBroadcastAsUser(intent, UserHandle.OWNER,
                android.Manifest.permission.MASTER_CLEAR,
                new BroadcastReceiver() {
                    @Override
                    public void onReceive(Context context, Intent intent) {
                        condition.open();
                    }
                }, null, 0, null, null);
        condition.block();
        /*擦除用户分区  走这里*/
        bootCommand(context, "--wipe_data\n--locale=" + Locale.getDefault().toString());
    }

    public static void rebootUpdateFromSD(Context context) throws IOException {   
            ...............
        /*从sd卡升级  走这里*
        bootCommand(context, "--update_package=/ext_sdcard1/update.zip\n--locale=" + Locale.getDefault().toString());
    }

    public static void rebootUpdateFromUDisk(Context context) throws IOException {
        ..........
        /*从u盘升级  走这里*/
        bootCommand(context, "--update_package=/udisk1/update.zip\n--locale=" + Locale.getDefault().toString());
    }

        private static void bootCommand(Context context, String arg) throws IOException {
        RECOVERY_DIR.mkdirs();  // In case we need it
        COMMAND_FILE.delete();  // In case it's not writable
        LOG_FILE.delete();

        FileWriter command = new FileWriter(COMMAND_FILE);
        try {
            command.write(arg);  /*到这里可以发现 无论要实现是什么功能，都是往cache/recvoery/command文件中写命令 */
            command.write("\n");
        } finally {
            command.close();
        }

        // Having written the command file, go ahead and reboot
        PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
        pm.reboot("recovery");  /*最后调用pm.reboot重启并进入recovery*/

        throw new IOException("Reboot failed (no permissions?)");
    }

注意：这里容易混淆，一个是进入以后干什么，一个是如何进入
1.调用bootCommand往往cache/recvoery/command文件中写命令是为了进入recovery后，由recovery解析命令，然后执行命令；
2.pm.reboot(“recovery”); 以及下面的所有操作都是为了重启系统，并进入recvoery模式；

PowerManager类定义于文件：frameworks/base/core/java/android/os/PowerManager.java

 public class PowerManager
 {
  ...
  IPowerManager mService;
  Handler mHandler;
  public PowerManager(IPowerManager service, Handler handler)
     {
         mService = service;
         mHandler = handler;
     }
   ...
  public void reboot(String reason)
     {
         try {
             mService.reboot(reason);  /*reason 是recvoery*/
         } catch (RemoteException e) {
         }
     }
 }

mService指向的是PowerManagerService类，这个类定义于文件：frameworks/base/services/java/com/android/server/power/PowerManagerService.java

public void reboot(boolean confirm, String reason, boolean wait) {
        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.REBOOT, null);

        final long ident = Binder.clearCallingIdentity();
        try {
            shutdownOrRebootInternal(false, confirm, reason, wait);  /*走这里*/
        } finally {
            Binder.restoreCallingIdentity(ident);
        }
    }
shutdownOrRebootInternal(false, confirm, reason, wait);  参数为(false,false,"recovery",true)
private void shutdownOrRebootInternal(final boolean shutdown, final boolean confirm,
        ...
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                synchronized (this) {
                    if (shutdown) {   
                        ShutdownThread.shutdown(mContext, confirm);
                    } else {   /*shutdown应该为false 所以走这里， reason为recovery*/
                        ShutdownThread.reboot(mContext, reason, confirm);
                    }
                }
            }
        };

ShutdownThread类在文件：frameworks/base/services/java/com/android/server/power/ShutdownThread.java

public static void reboot(final Context context, String reason, boolean confirm) { //方法中的变量为全局变量

        mReboot = true;
        mRebootSafeMode = false;
        mRebootUpdate = false;
        mRebootReason = reason;
        shutdownInner(context, confirm);       //此方法是在手机界面上弹出一个确认框，是否重启
    }

这里不再详细跟踪代码了，shutdownInner(context, confirm); -->rebootOrShutdown(mContext, mReboot, mRebootReason); --> PowerManagerService.lowLevelReboot(reason); reason为“recoery”

PowerManagerService.lowLevelReboot方法定义在文件：./frameworks/base/services/java/com/android/server/power/PowerManagerService.java

public static void lowLevelReboot(String reason) throws IOException {
    nativeReboot(reason);  /*这里说明调用了本地jni库  reason为recovery*/
}

注意：这里不同的平台可能有所不同，本地库的编写不可能都相同，仅做参考
nativeReboot定义在文件frameworks/base/services/jni/com_android_server_power_PowerManagerService.cpp

static void nativeReboot(JNIEnv *env, jclass clazz, jstring reason) {
    if (reason == NULL) { /*reason参数为空 正常启动*/
        android_reboot(ANDROID_RB_RESTART, 0, 0);
    } else {
        ...
        android_reboot(ANDROID_RB_RESTART2, 0, (char *) chars);  /*chars 为 recovery*/
    }
    ...
}

android_reboot定义在文件：system/core/libcutils/android_reboot.c

int android_reboot(int cmd, int flags, char *arg)
{
    int ret;
    if (!(flags & ANDROID_RB_FLAG_NO_SYNC))
        sync();
    if (!(flags & ANDROID_RB_FLAG_NO_REMOUNT_RO))
        remount_ro();
   swich (cmd) {
        case ANDROID_RB_RESTART:  /*正常启动*/
            ret = reboot(RB_AUTOBOOT);
           break;
        case ANDROID_RB_POWEROFF: /*关机*/  
            ret = reboot(RB_POWER_OFF);
            break;
        case ANDROID_RB_RESTART2:  /*特殊启动 recvoery*/
        if(0 == strcmp(arg,"recovery")){
                 writemisc();   /*这里是往misc分区写recovery命令行，在uboot中会检测misc分区中的BCB数据块*/ 
        }
            /*这里是系统调用，参数LINUX_REBOOT_MAGIC1和LINUX_REBOOT_MAGIC2是个固定的整数，在内核中用来检验；arg为recovery*/    
            ret = __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,LINUX_REBOOT_CMD_RESTART2, arg);  
            break；
        default:
            ret = -1;
    }
    return ret;
}
/*在uboot中会检测BCB数据块，进入recovery模式*/
static int build_recovery_cmd()
{
    memcpy(bm.command, "boot-recovery", 14);   /*将"boot-recovery" 写入command域*/
    memcpy(bm.recovery, "recovery", 9);
    return 0;

}

static int writemisc(){
    int phy_block_size = 0;
    int index, fd=0;

    fd = open(MISC_PARTITION, O_RDWR);
    if (fd < 0) return -1;
        build_recovery_cmd();
    lseek(fd, 0x0, SEEK_SET);
    int cnt = write(fd, &bm, sizeof(bm));
    printf("Write %d bytes to misc partition\r\n", cnt);
    close(fd);
    return 0;
}

__reboot系统调用定义在：./bionic/libc/arch-arm/syscalls/__reboot.S

#include <sys/linux-syscalls.h>

ENTRY(__reboot)
    .save   {r4, r7}
    stmfd   sp!, {r4, r7}
    ldr     r7, =__NR_reboot  // 系统调用号 88， binoic/libc/include/sys/linux-syscalls.h
    swi     #0
    ldmfd   sp!, {r4, r7}
    movs    r0, r0
    bxpl    lr
    b       __set_syscall_errno
END(__reboot)

最终实现在内核中的__NR_reboot

内核部分

__NR_reboot定义在文件：kernel/include/asm-generic/unistd.h

#define __NR_reboot 142
__SYSCALL(__NR_reboot, sys_reboot)

__NR_reboot被映射到sys_reboot，最终的代码实现在文件：kernel/kernel/sys.c

SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
        void __user *, arg)
{
    char buffer[256];
    int ret = 0;
    .....
    /* 这里说明了两个魔数的功能，注意两个地方的魔数定义必须相同*/
    if (magic1 != LINUX_REBOOT_MAGIC1 ||
        (magic2 != LINUX_REBOOT_MAGIC2 &&
                    magic2 != LINUX_REBOOT_MAGIC2A &&
            magic2 != LINUX_REBOOT_MAGIC2B &&
                    magic2 != LINUX_REBOOT_MAGIC2C))
        return -EINVAL;

    ....
    mutex_lock(&reboot_mutex);
    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();
        do_exit(0);
        panic("cannot halt");

    case LINUX_REBOOT_CMD_POWER_OFF:  /*关机*/
        kernel_power_off();
        do_exit(0);
        break;

    case LINUX_REBOOT_CMD_RESTART2:   /*recovery重启走这里*/
        if (strncpy_from_user(&buffer[0], arg, sizeof(buffer) - 1) < 0) {
            ret = -EFAULT;
            break;
        }
        buffer[sizeof(buffer) - 1] = '\0';

        kernel_restart(buffer);  /*buffer 为 reovery*/
        break;
    ....
    default:
        ret = -EINVAL;
        break;
    }
    mutex_unlock(&reboot_mutex);
    return ret;
}

void kernel_restart(char *cmd) /*这里cmd 为 recovery*/
{
    kernel_restart_prepare(cmd);
    disable_nonboot_cpus();
    if (!cmd)
        printk(KERN_EMERG "Restarting system.\n");
    else
        printk(KERN_EMERG "Restarting system with command '%s'.\n", cmd);
    kmsg_dump(KMSG_DUMP_RESTART);
    machine_restart(cmd);
}
EXPORT_SYMBOL_GPL(kernel_restart);

machine_restart定义文件为：kernel/arch/arm/kernel/process.c

void machine_restart(char *cmd)
{
    ...
    arm_pm_restart(reboot_mode, cmd);  /*走这里，cmd 为 recovery*/
    ....
}

最终是调用arch_reset(mode,cmd),重启系统；cmd为传入的启动参数
目标文件在平台配置文件中，例如：arch/arm/mach-prima2/include/mach/system.h

/********************
这里只是让系统重启，没有其他操作；
*********************/
void arch_reset(char mode, const char *cmd)
{
    /*
     * use powerdown watch dog to reset system
     */
    uint32_t u4Test;
    PDWNC_WRITE32(REG_RW_RESRV1, 0x33633363);
    PDWNC_WRITE32(REG_RW_WDT, 0xffd00000);
    for(u4Test = 0; u4Test < 10000; u4Test++)
    {

    }
    PDWNC_WRITE32(REG_RW_WDTSET, 1);
    while(1);

}

各个平台有不同的实现方式，有的是直接设置寄存器，进入recovery；
这里是通过设置BCB进入reovery，在前面已经分析了
接下来可以想象在uboot中肯定会去检测BCB数据块，然后加载recoery镜像，进入recovery模式

uboot部分

uboot中会先后检查三种方式进入recovery是否成立：第一种是kernel直接写一个寄存器来标记下次启动将进入recovery模式；第二种是快捷键：powerkey+downVOL；第三中就是上层应用发送下来的command命令，这个命令在系统重启之前会往MISC分区中
command(“boot-recovery”)。这里采用的是第三中方式；
uboot检查代码在文件：uboot-83xx/lib_arm/board.c；如果没有，就在该文件中搜索“recovery”，应该会有相关函数

BOOL recovery_check_command_trigger(void)
{
     struct misc_message misc_msg;
     struct misc_message *pmisc_msg = &misc_msg;
     const unsigned int size = NAND_WRITE_SIZE * MISC_PAGES;
     unsigned char *pdata;
         int ret;

     pdata = (uchar*)malloc(sizeof(uchar)*size);
     ret = mboot_recovery_load_misc(pdata, size);

        if (ret < 0)
        {
             return FALSE; 
        } 

     memcpy(pmisc_msg, &pdata[NAND_WRITE_SIZE * MISC_COMMAND_PAGE], sizeof(misc_msg)); 
     MSG("Boot command: %.*s\n", sizeof(misc_msg.command), misc_msg.command);
     MSG("Boot status: %.*s\n", sizeof(misc_msg.status), misc_msg.status);
     MSG("Boot message\n\"%.20s\"\n", misc_msg.recovery);

     if(strcmp(misc_msg.command, "boot-recovery")==0)  /*判断command域中的值，如果是"boot-recovery"，就进入  recvoery*/
     { g_boot_mode = RECOVERY_BOOT;
     }

     return TRUE;
}

该到此结束！
进入recvoery的相关流程，下文分析。