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 最终实现在内核中的__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的相关流程，下文分析。