正文

android L 关机流程图

IP云
IP云V管理员/10 阅读
08/04
提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

下面是简单的流程图，从Java到kernel层。

ShutdownThread.java文件

stop playing music，因为后面可能要playing shutdown music.

代码如下：（我在Android6.0上沒有看到調用requestAudioFocus的代碼）

private static void beginShutdownSequence(Context context) {
....
//acquire audio focus to make the other apps to stop playing muisc
mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
mAudioManager.requestAudioFocus(null,
AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN);

show system dialog to indicate phone is shutting down，如果没有关机动画的话，要show一个关机提示出来。

代码如下：

1 if (!checkAnimationFileExist()) {
2 // throw up an indeterminate system dialog to indicate radio is
3 // shutting down.
4 ProgressDialog pd = new ProgressDialog(context);
5 pd.setTitle(context.getText(com.android.internal.R.string.power_off));
6 pd.setMessage(context.getText(com.android.internal.R.string.shutdown_progress));
7 pd.setIndeterminate(true);
8 pd.setCancelable(false);
9 pd.getWindow().setType(WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG);
10
11 pd.show();
12 }

Hold the wakelock,make sure we never fall asleep again，抓锁防止机器关机过程中休眠

代码如下：

1 sInstance.mCpuWakeLock = sInstance.mPowerManager.newWakeLock(
2 PowerManager.PARTIAL_WAKE_LOCK, TAG + "-cpu");//这个只是锁住cpu不进入休眠，但screen是off的，需full锁来保证screen常亮
3 sInstance.mCpuWakeLock.setReferenceCounted(false);
4 sInstance.mCpuWakeLock.acquire();

make sure the screen stays on,再抓一个full锁，防止屏幕半暗

代码如下：

1 sInstance.mScreenWakeLock = sInstance.mPowerManager.newWakeLock(
2 PowerManager.FULL_WAKE_LOCK, TAG + "-screen");//保持srceen常亮
3 sInstance.mScreenWakeLock.setReferenceCounted(false);
4 sInstance.mScreenWakeLock.acquire();

sending shutdown broadcast，发出广播，通知各app该保存数据赶紧的，我要关机了

代码如下：

1 Intent intent = new Intent(Intent.ACTION_SHUTDOWN);
2 intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
3 mContext.sendOrderedBroadcastAsUser(intent,//发广播
4 UserHandle.ALL, null, br, mHandler, 0, null, null);

shutdown activity manager，关闭activity manager，即关闭AppOpsService，UsageStatsService，BatteryStatsService

注意：Android L 与KK在关闭UsageStatsService上有所区别

代码如下：

[ActivityManagerService.java]

1 final IActivityManager am =
2 ActivityManagerNative.asInterface(ServiceManager.checkService("activity"));
3 if (am != null) {
4 try {
5 am.shutdown(MAX_BROADCAST_TIME);
6 } catch (RemoteException e) {
7 }
8 }

shutdown package manager，保存app使用时间到 disk里，这是android L新增的功能。

代码如下：

[PackageManagerService.java]

1 final PackageManagerService pm = (PackageManagerService)
2 ServiceManager.getService("package");
3 if (pm != null) {
4 pm.shutdown();
5 }

show shutdown animation，播放关机动画了

代码如下：

1 private static void showShutdownAnimation() {
2 /*
3 * When boot completed, "service.bootanim.exit" property is set to 1.
4 * Bootanimation checks this property to stop showing the boot animation.
5 * Since we use the same code for shutdown animation, we
6 * need to reset this property to 0. If this is not set to 0 then shutdown
7 * will stop and exit after displaying the first frame of the animation
8 */
9 SystemProperties.set("service.bootanim.exit", "0");
10
11 SystemProperties.set("ctl.start", "bootanim");//也是用bootanim进程，跟开关动画一样的方式。
12 }

shutdown radio[NFC,BT,MODEM],注意这里关闭modem这块与andorid KK的不一样。

代码如下：

shutdownRadios(MAX_RADIO_WAIT_TIME);

shutdown MountService,特别这里会导致关机失败。

代码如下：

1 // Set initial variables and time out time.
2 mActionDone = false;
3 final long endShutTime = SystemClock.elapsedRealtime() + MAX_SHUTDOWN_WAIT_TIME;
4 synchronized (mActionDoneSync) {
5 try {
6 final IMountService mount = IMountService.Stub.asInterface(
7 ServiceManager.checkService("mount"));
8 if (mount != null) {
9 mount.shutdown(observer);
10 } else {
11 Log.w(TAG, "MountService unavailable for shutdown");
12 }
13 } catch (Exception e) {
14 Log.e(TAG, "Exception during MountService shutdown", e);
15 }
16 while (!mActionDone) {
17 long delay = endShutTime - SystemClock.elapsedRealtime();
18 if (delay <= 0) {
19 Log.w(TAG, "Shutdown wait timed out");
20 break;
21 }
22 try {
23 mActionDoneSync.wait(delay);
24 } catch (InterruptedException e) {
25 }
26 }
27 }

走完上层关机流程，下面就要执行关机动作了。

代码如下：

1 public static void rebootOrShutdown(boolean reboot, String reason) {
2 deviceRebootOrShutdown(reboot, reason);
3 if (reboot) {
4 Log.i(TAG, "Rebooting, reason: " + reason);
5 PowerManagerService.lowLevelReboot(reason);//重启, 其中reason字符串可以爲空、“bootloader”、“recovery”, 在手機下次啓動中LK會根據這些值使手機進入不同的模式
6 Log.e(TAG, "Reboot failed, will attempt shutdown instead");
7 } else if (SHUTDOWN_VIBRATE_MS > 0) {
8 // vibrate before shutting down
9 Vibrator vibrator = new SystemVibrator();
10 try {
11 vibrator.vibrate(SHUTDOWN_VIBRATE_MS, VIBRATION_ATTRIBUTES);
12 } catch (Exception e) {
13 // Failure to vibrate shouldn't interrupt shutdown. Just log it.
14 Log.w(TAG, "Failed to vibrate during shutdown.", e);
15 }
16
17 // vibrator is asynchronous so we need to wait to avoid shutting down too soon.
18 try {
19 Thread.sleep(SHUTDOWN_VIBRATE_MS);
20 } catch (InterruptedException unused) {
21 }
22 }
23
24 // Shutdown power
25 Log.i(TAG, "Performing low-level shutdown...");
26 PowerManagerService.lowLevelShutdown();//关机
27 }

从代码上看始终会走到lowLevelShutdown()，但如果是重启就不会，lowLevelReboot()就停止了。

lowLevelShutdown()与lowLevelReboot()都在PowerManagerService.java实现，其实都只是设置一个属性：SystemProperties.set("sys.powerctl", "xxx");

正是这个动作触发关机流程往下走，这涉及到init进程的4大功能，请参考我的另一篇文章Android的init进程

sys.powerctl属性触发开关在init.rc定义

on property:sys.powerctl=*
powerctl ${sys.powerctl}

我们来解读这句话，on property:sys.powerctl=*表示当属性sys.powerctl设置为任何值是都会跑到这里，触发动作是powerctl ${sys.powerctl},这个动作的意思是调用powerctl指令，并把sys.powerctl的值传给它。powerctl指令在init 进程会执行。

从下面的表可知，powerctl对应的操作是do_powerctl

[system/core/init/keywords.h]

KEYWORD(powerctl, COMMAND, 1, do_powerctl)

do_powerctl的实现

代码如下：

[system/core/init/builtins.c]

1 int do_powerctl(int nargs, char **args)
2 {
3 char command[PROP_VALUE_MAX];
4 int res;
5 int len = 0;
6 int cmd = 0;
7 const char *reboot_target;
8
9 res = expand_props(command, args[1], sizeof(command)); //args中存放的是: shutdown 或者 reboot 或者 reboot,bootloader 或者 reboot,recovery
10 if (res) {
11 ERROR("powerctl: cannot expand '%s'\n", args[1]);
12 return -EINVAL;
13 }
14
15 if (strncmp(command, "shutdown", 8) == 0) {
16 cmd = ANDROID_RB_POWEROFF;
17 len = 8;
18 } else if (strncmp(command, "reboot", 6) == 0) {
19 cmd = ANDROID_RB_RESTART2;
20 len = 6;
21 } else {
22 ERROR("powerctl: unrecognized command '%s'\n", command);
23 return -EINVAL;
24 }
25
26 if (command[len] == ',') {
27 char prop_value[PROP_VALUE_MAX] = {0};
28 reboot_target = &command[len + 1]; // 存放reboot的reason，也就是下次手機重啓將要進入的模式
29
30 if ((property_get("init.svc.recovery", prop_value) == 0) &&
31 (strncmp(reboot_target, "keys", 4) == 0)) {
32 ERROR("powerctl: permission denied\n");
33 return -EINVAL;
34 }
35 } else if (command[len] == '\0') { // 如果reason爲空，對於reboot來說，下次手機會正常啓機
36 reboot_target = "";
37 } else {
38 ERROR("powerctl: unrecognized reboot target '%s'\n", &command[len]);
39 return -EINVAL;
40 }
41
42 return android_reboot(cmd, 0, reboot_target);
43 }

它调用android_reboot()函数，实现如下：

[system/core/libcutils/android_reboot.c]

1 int android_reboot(int cmd, int flags UNUSED, const char *arg)
2 {
3 int ret;
4
5 sync();
6 remount_ro();
7
8 switch (cmd) {
9 case ANDROID_RB_RESTART:
10 ret = reboot(RB_AUTOBOOT);
11 break;
12
13 case ANDROID_RB_POWEROFF:
14 ret = reboot(RB_POWER_OFF);
15 break;
16
17 case ANDROID_RB_RESTART2: // arg中存放的是reboot的reason，如bootloader、recovery
18 ret = syscall(__NR_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
19 LINUX_REBOOT_CMD_RESTART2, arg);
20 break;
21
22 default:
23 ret = -1;
24 }
25
26 return ret;
27 }

从这里看出它的主要工作：

sync() 回写block设备的内容，这是阻塞型操作。

remount_ro() 把block设备remount成ro，这里有个关键LOG：SysRq : Emergency Remount R/O，这是在logkit所能看到的最后一句LOG，因为remount成ro了，后面的LOG要通过last kmsg技术导出来。

reboot()或者syscall(__NR_reboot....，这点与android KK不同，这边直接用syscall功能，KK则通过汇编。

后面syscall(__NR_reboot...知道，直接调用了linux的__NR_reboot系统调用，这个系统调用会跑哪里？后面会讲。

reboot()这个函数实现如下：

[bionic/libc/bionic/reboot.cpp]

1 int reboot(int mode) {
2 return __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, mode, NULL);
3 }

调用了__reboot,它在汇编实现如下：

[bionic/libc/arch-arm/syscalls/__reboot.S]

1 ENTRY(__reboot)
2 mov ip, r7
3 ldr r7, =__NR_reboot //也跑到__NR_reboot系统调用
 4 swi #0
5 mov r7, ip
6 cmn r0, #(MAX_ERRNO + 1)
7 bxls lr
8 neg r0, r0
9 b __set_errno_internal
10 END(__reboot)

__NR_reboot对应的内核入口在哪里？

如下：

[bionic/libc/kernel/uapi/asm-generic/unistd.h]

#define __NR_reboot 142

它在内核入口如下：

注：bionic/libc/kernel/uapi/asm-generic/unistd.h与kernel/include/uapi/asm-generic/unistd.h是对应的，方便以后代码追踪

[kernel/include/uapi/asm-generic/unistd.h]

1 #define __NR_reboot 142
2 __SYSCALL(__NR_reboot, sys_reboot)

__NR_reboot 映射到 sys_reboot

grep 下sys_reboot找不到，其实在这里

用SYSCALL_DEFINE定义

[kernel/kernel/reboot.c]

1 /*
2 * Reboot system call: for obvious reasons only root may call it,
3 * and even root needs to set up some magic numbers in the registers
4 * so that some mistake won't make this reboot the whole machine.
5 * You can also set the meaning of the ctrl-alt-del-key here.
6 *
7 * reboot doesn't sync: do that yourself before calling this.
8 */
9 SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
10 void __user *, arg)
11 {
12 struct pid_namespace *pid_ns = task_active_pid_ns(current);
13 char buffer[256];
14 int ret = 0;
15
16 /* We only trust the superuser with rebooting the system. */
17 if (!ns_capable(pid_ns->user_ns, CAP_SYS_BOOT))
18 return -EPERM;
19
20 /* For safety, we require "magic" arguments. */
21 if (magic1 != LINUX_REBOOT_MAGIC1 ||
22 (magic2 != LINUX_REBOOT_MAGIC2 &&
23 magic2 != LINUX_REBOOT_MAGIC2A &&
24 magic2 != LINUX_REBOOT_MAGIC2B &&
25 magic2 != LINUX_REBOOT_MAGIC2C))
26 return -EINVAL;
27
28 /*
29 * If pid namespaces are enabled and the current task is in a child
30 * pid_namespace, the command is handled by reboot_pid_ns() which will
31 * call do_exit().
32 */
33 ret = reboot_pid_ns(pid_ns, cmd);
34 if (ret)
35 return ret;
36
37 /* Instead of trying to make the power_off code look like
38 * halt when pm_power_off is not set do it the easy way.
39 */
40 if ((cmd == LINUX_REBOOT_CMD_POWER_OFF) && !pm_power_off)
41 cmd = LINUX_REBOOT_CMD_HALT;
42
43 mutex_lock(&reboot_mutex);
44 switch (cmd) {
45 case LINUX_REBOOT_CMD_RESTART:
46 kernel_restart(NULL);
47 break;
48
49 case LINUX_REBOOT_CMD_CAD_ON:
50 C_A_D = 1;
51 break;
52
53 case LINUX_REBOOT_CMD_CAD_OFF:
54 C_A_D = 0;
55 break;
56
57 case LINUX_REBOOT_CMD_HALT:
58 kernel_halt();
59 do_exit(0);
60 panic("cannot halt");
61
62 case LINUX_REBOOT_CMD_POWER_OFF:
63 kernel_power_off();
64 do_exit(0);
65 break;
66
67 case LINUX_REBOOT_CMD_RESTART2:
68 ret = strncpy_from_user(&buffer[0], arg, sizeof(buffer) - 1);
69 if (ret < 0) {
70 ret = -EFAULT;
71 break;
72 }
73 buffer[sizeof(buffer) - 1] = '\0';
74
75 kernel_restart(buffer);
76 break;
77
78 #ifdef CONFIG_KEXEC
79 case LINUX_REBOOT_CMD_KEXEC:
80 ret = kernel_kexec();
81 break;
82 #endif
83
84 #ifdef CONFIG_HIBERNATION
85 case LINUX_REBOOT_CMD_SW_SUSPEND:
86 ret = hibernate();
87 break;
88 #endif
89
90 default:
91 ret = -EINVAL;
92 break;
93 }
94 mutex_unlock(&reboot_mutex);
95 return ret;
96 }

有很多分支，我们只关心kernel_power_off()和kernel_restart()两函数就行

如下：

kernel_power_off：

1 void kernel_power_off(void)
2 {
3 kernel_shutdown_prepare(SYSTEM_POWER_OFF);//关闭外设
4 if (pm_power_off_prepare)
5 pm_power_off_prepare();
6 migrate_to_reboot_cpu(); // 比如執行reboot命令的進程運行在CPU1上，而將來CPU1會先於CPU0被停止，故需要將當前進程轉移至CPU0上
7 syscore_shutdown();//关闭syscore
8 printk(KERN_EMERG "Power down.\n");//关键打印
9 kmsg_dump(KMSG_DUMP_POWEROFF);
10 machine_power_off();
11 }

kernel_restart:

1 void kernel_restart(char *cmd)
2 {
3 kernel_restart_prepare(cmd);//关闭外设
4 migrate_to_reboot_cpu();
5 syscore_shutdown();//关闭syscore
6 if (!cmd)
7 printk(KERN_EMERG "Restarting system.\n");//关键打印
8 else
9 printk(KERN_EMERG "Restarting system with command '%s'.\n", cmd);
10 kmsg_dump(KMSG_DUMP_RESTART);
11 machine_restart(cmd);
12 }

都执行XX_prepare()函数

1 static void kernel_shutdown_prepare(enum system_states state)
2 {
3 blocking_notifier_call_chain(&reboot_notifier_list,
4 (state == SYSTEM_HALT)?SYS_HALT:SYS_POWER_OFF, NULL);
5 system_state = state;
6 usermodehelper_disable();
7 device_shutdown();
8 }

上面的第3行會遍歷reboot_notifier_list鏈表，向其中註冊的每一個notifier_block發送SYS_POWER_OFF事件。

在我們的驅動程序中可以調用如下函數將notifier_block註冊到系統中：

1 /**
2 * register_reboot_notifier - Register function to be called at reboot time
3 * @nb: Info about notifier function to be called
4 *
5 * Registers a function with the list of functions
6 * to be called at reboot time.
7 *
8 * Currently always returns zero, as blocking_notifier_chain_register()
9 * always returns zero.
10 */
11 int register_reboot_notifier(struct notifier_block *nb)
12 {
13 return blocking_notifier_chain_register(&reboot_notifier_list, nb);
14 }
15 EXPORT_SYMBOL(register_reboot_notifier);

在第7行中調用了device_shutdown()函數，如下：

1 /**
2 * device_shutdown - call ->shutdown() on each device to shutdown.
3 */
4 void device_shutdown(void)
5 {
6 struct device *dev, *parent;
7
8 spin_lock(&devices_kset->list_lock);
9 /*
10 * Walk the devices list backward, shutting down each in turn.
11 * Beware that device unplug events may also start pulling
12 * devices offline, even as the system is shutting down.
13 */
14 while (!list_empty(&devices_kset->list)) {
15 dev = list_entry(devices_kset->list.prev, struct device,
16 kobj.entry);
17 ......
18
19 if (dev->bus && dev->bus->shutdown) { // 如 i2c_bus_type
20 if (initcall_debug)
21 dev_info(dev, "shutdown\n");
22 dev->bus->shutdown(dev);
23 } else if (dev->driver && dev->driver->shutdown) { // 如spi_bus_type、usb_bus_type
24 if (initcall_debug)
25 dev_info(dev, "shutdown\n");
26 dev->driver->shutdown(dev);
27 }
28 ......
29 }
30 spin_unlock(&devices_kset->list_lock);
31 }
32

kernel_restart_prepare:

1 void kernel_restart_prepare(char *cmd)
2 {
3 blocking_notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd);
4 system_state = SYSTEM_RESTART;
5 usermodehelper_disable();
6 device_shutdown();
7 }

除了前面不同，都调用了device_shutdown()函数，关闭外设。

machine_power_off() machine_resestart()函数实现

machine_power_off:

1 void machine_power_off(void)
2 {
3 preempt_disable();
4 smp_send_stop();
5
6 if (pm_power_off)
7 pm_power_off();//关机
8 }

其中，第4行的smp_send_stop會將除CPU0之外的CPU全部stop。

machine_restart:

1 void machine_restart(char *cmd)
2 {
3 preempt_disable();
4 smp_send_stop();
5
6 /* Flush the console to make sure all the relevant messages make it
7 * out to the console drivers */
8 arm_machine_flush_console();
9
10 arm_pm_restart(reboot_mode, cmd);//重启
11
12 /* Give a grace period for failure to restart of 1s */
13 mdelay(1000);
14
15 /* Whoops - the platform was unable to reboot. Tell the user! */
16 printk("Reboot failed -- System halted\n");
17 local_irq_disable();
18 while (1);
19 }

pm_power_offf()arm_pm_restart()都是一个函数指针

赋值如下：

[kernel/drivers/power/reset/msm-poweroff.c]

1 pm_power_off = do_msm_poweroff;
2 arm_pm_restart = do_msm_restart;

高通平台的关机代码与之前有所不同，现在文件msm-poweroff.c以前是restart.c。

do_msm_poweroff()与do_msm_restart()实现如下：

do_msm_poweroff:

1 static void do_msm_poweroff(void)
2 {
3 ....
4 pr_notice("Powering off the SoC\n");//关键打印
5 #ifdef CONFIG_MSM_DLOAD_MODE
6 set_dload_mode(0);//关机，所以dloadmode是0
7 #endif
8 qpnp_pon_system_pwr_off(PON_POWER_OFF_SHUTDOWN);//配置PMIC,是关机
9 .....
10 /* MSM initiated power off, lower ps_hold */
11 __raw_writel(0, msm_ps_hold);//拉PS＿HOLD,执行关机动作。
12
13 mdelay(10000);
14 pr_err("Powering off has failed\n");
15 return;
16 }

do_msm_restart:

 

1 static void msm_restart_prepare(const char *cmd)
2 {
3 #ifdef CONFIG_MSM_DLOAD_MODE
4
5 /* Write download mode flags if we're panic'ing
6 * Write download mode flags if restart_mode says so
7 * Kill download mode if master-kill switch is set
8 */
9
10 set_dload_mode(download_mode &&
11 (in_panic || restart_mode == RESTART_DLOAD));//设置dload
12 #endif
13
14 /* Hard reset the PMIC unless memory contents must be maintained. */
15 if (get_dload_mode() || (cmd != NULL && cmd[0] != '\0'))
16 qpnp_pon_system_pwr_off(PON_POWER_OFF_WARM_RESET);//设置PIMC为热重启
17 else
18 qpnp_pon_system_pwr_off(PON_POWER_OFF_HARD_RESET);//设置PIMC为硬重启
19
20 if (cmd != NULL) {
21 if (!strncmp(cmd, "bootloader", 10)) {
22 __raw_writel(0x77665500, restart_reason);//写一些东东到IMEM，用于bootloader,recovery等
23 } else if (!strncmp(cmd, "recovery", 8)) {
24 __raw_writel(0x77665502, restart_reason);
25 } else if (!strcmp(cmd, "rtc")) {
26 __raw_writel(0x77665503, restart_reason);
27 } else if (!strncmp(cmd, "oem-", 4)) {
28 unsigned long code;
29 int ret;
30 ret = kstrtoul(cmd + 4, 16, &code);
31 if (!ret)
32 __raw_writel(0x6f656d00 | (code & 0xff),
33 restart_reason);
34 } else if (!strncmp(cmd, "edl", 3)) {
35 enable_emergency_dload_mode();
36 } else {
37 __raw_writel(0x77665501, restart_reason);
38 }
39 }
40
41 .....
42
43 }

do_msm_poweroff()与do_msm_restart()都设置了dload,PMIC，唯一不同的是do_msm_restart()里 多了一个__raw_writel的动作，即reason写入IMEM,目的在于重启进入sbl1时判断应该进入那种模式，如我们开发用的 bootloader模式，恢复出厂设置的recovery模式等。

完了