Android系统关机的全流程解析

/** 
 * Reboot the device. Will not return if the reboot is 
 * successful. Requires the {@link android.Manifest.permission#REBOOT} 
 * permission. 
 * 
 * @param reason code to pass to the kernel (e.g., "recovery") to 
 *        request special boot modes, or null. 
 */ 
public void reboot(String reason) 
{   
  try { 
    mService.reboot(reason); 
  } catch (RemoteException e) { 
  }   
}  

/** 
 * {@hide} 
 */ 
public PowerManager(IPowerManager service, Handler handler) 
{ 
  mService = service; 
  mHandler = handler; 
} 

interface IPowerManager 
{ 
... 
void reboot(String reason); 
... 
} 

/**  
 * Reboot the device immediately, passing 'reason' (may be null) 
 * to the underlying __reboot system call. Should not return. 
 */ 
public void reboot(String reason) 
{   
  mContext.enforceCallingOrSelfPermission(android.Manifest.permission.REBOOT, null); 
 
  if (mHandler == null || !ActivityManagerNative.isSystemReady()) { 
    throw new IllegalStateException("Too early to call reboot()"); 
  }   
 
  final String finalReason = reason; 
  Runnable runnable = new Runnable() { 
    public void run() { 
      synchronized (this) { 
        ShutdownThread.reboot(getUiContext(), finalReason, false); 
      }   
 
    }   
  };   
  // ShutdownThread must run on a looper capable of displaying the UI. 
  mHandler.post(runnable); 
 
  // PowerManager.reboot() is documented not to return so just wait for the inevitable. 
  synchronized (runnable) { 
    while (true) { 
      try { 
        runnable.wait(); 
      } catch (InterruptedException e) {  
      }   
    }   
  }   
} 

/** 
 * Request a clean shutdown, waiting for subsystems to clean up their 
 * state etc. Must be called from a Looper thread in which its UI 
 * is shown. 
 * 
 * @param context Context used to display the shutdown progress dialog. 
 * @param reason code to pass to the kernel (e.g. "recovery"), or null. 
 * @param confirm true if user confirmation is needed before shutting down. 
 */ 
public static void reboot(final Context context, String reason, boolean confirm) { 
  mReboot = true; 
  mRebootSafeMode = false; 
  mRebootReason = reason; 
  shutdownInner(context, confirm); 
} 

/** 
 * Makes sure we handle the shutdown gracefully. 
 * Shuts off power regardless of radio and bluetooth state if the alloted time has passed. 
 */  
public void run() { 
  BroadcastReceiver br = new BroadcastReceiver() { 
    @Override public void onReceive(Context context, Intent intent) { 
      // We don't allow apps to cancel this, so ignore the result. 
      actionDone(); 
    } 
  }; 
 
  /* 
   * Write a system property in case the system_server reboots before we 
   * get to the actual hardware restart. If that happens, we'll retry at 
   * the beginning of the SystemServer startup. 
   */  
  {   
    String reason = (mReboot ? "1" : "0") + (mRebootReason != null ? mRebootReason : ""); 
    SystemProperties.set(SHUTDOWN_ACTION_PROPERTY, reason); 
  } 
 
  /* 
   * If we are rebooting into safe mode, write a system property 
   * indicating so. 
   */  
  if (mRebootSafeMode) { 
    SystemProperties.set(REBOOT_SAFEMODE_PROPERTY, "1"); 
  } 
  ... 
  rebootOrShutdown(mReboot, mRebootReason); 
}  

  /** 
   * Do not call this directly. Use {@link #reboot(Context, String, boolean)} 
   * or {@link #shutdown(Context, boolean)} instead. 
   * 
   * @param reboot true to reboot or false to shutdown 
   * @param reason reason for reboot 
   */ 
  public static void rebootOrShutdown(boolean reboot, String reason) { 
    if (reboot) { 
      Log.i(TAG, "Rebooting, reason: " + reason);  
      try { 
        PowerManagerService.lowLevelReboot(reason); 
      } catch (Exception e) { 
        Log.e(TAG, "Reboot failed, will attempt shutdown instead", e); 
      }  
    } else if (SHUTDOWN_VIBRATE_MS > 0) { 
      // vibrate before shutting down 
      Vibrator vibrator = new SystemVibrator(); 
      try { 
        vibrator.vibrate(SHUTDOWN_VIBRATE_MS); 
      } catch (Exception e) { 
        // Failure to vibrate shouldn't interrupt shutdown. Just log it. 
        Log.w(TAG, "Failed to vibrate during shutdown.", e); 
      }   
         
      // vibrator is asynchronous so we need to wait to avoid shutting down too soon. 
      try { 
        Thread.sleep(SHUTDOWN_VIBRATE_MS); 
      } catch (InterruptedException unused) { 
      }   
    }   
       
    // Shutdown power 
    Log.i(TAG, "Performing low-level shutdown..."); 
    PowerManagerService.lowLevelShutdown(); 
  } 
} 

/** 
 * Request a clean shutdown, waiting for subsystems to clean up their 
 * state etc. Must be called from a Looper thread in which its UI 
 * is shown. 
 * 
 * @param context Context used to display the shutdown progress dialog. 
 * @param confirm true if user confirmation is needed before shutting down. 
 */ 
public static void shutdown(final Context context, boolean confirm) { 
  mReboot = false; 
  mRebootSafeMode = false; 
  shutdownInner(context, confirm); 
} 

/**  
 * Low-level function to reboot the device. 
 * 
 * @param reason code to pass to the kernel (e.g. "recovery"), or null. 
 * @throws IOException if reboot fails for some reason (eg, lack of 
 *     permission) 
 */ 
public static void lowLevelReboot(String reason) throws IOException { 
  nativeReboot(reason); 
}  
 
/**  
 * Low-level function turn the device off immediately, without trying 
 * to be clean. Most people should use 
 * {@link com.android.server.pm.internal.app.ShutdownThread} for a clean shutdown. 
 */ 
public static void lowLevelShutdown() { 
  nativeShutdown(); 
} 

private static native void nativeShutdown(); 
private static native void nativeReboot(String reason) throws IOException; 

static JNINativeMethod gPowerManagerServiceMethods[] = {  
  /* name, signature, funcPtr */ 
  ... 
  { "nativeShutdown", "()V", 
      (void*) nativeShutdown }, 
  { "nativeReboot", "(Ljava/lang/String;)V", 
      (void*) nativeReboot }, 
  ... 
}; 

static void nativeShutdown(JNIEnv *env, jobject clazz) { 
  android_reboot(ANDROID_RB_POWEROFF, 0, 0); 
} 
 
static void nativeReboot(JNIEnv *env, jobject clazz, jstring reason) { 
  if (reason == NULL) { 
    android_reboot(ANDROID_RB_RESTART, 0, 0); 
  } else { 
    const char *chars = env->GetStringUTFChars(reason, NULL); 
    android_reboot(ANDROID_RB_RESTART2, 0, (char *) chars); 
    env->ReleaseStringUTFChars(reason, chars); // In case it fails. 
  } 
  jniThrowIOException(env, errno); 
} 

int android_reboot(int cmd, int flags, char *arg) 
{ 
  int ret = 0; 
  int reason = -1; 
 
#ifdef RECOVERY_PRE_COMMAND 
  if (cmd == (int) ANDROID_RB_RESTART2) { 
    if (arg && strlen(arg) > 0) { 
      char cmd[PATH_MAX]; 
      sprintf(cmd, RECOVERY_PRE_COMMAND " %s", arg); 
      system(cmd); 
    } 
  } 
#endif 
 
  if (!(flags & ANDROID_RB_FLAG_NO_SYNC)) 
    sync(); 
 
  if (!(flags & ANDROID_RB_FLAG_NO_REMOUNT_RO)) 
    remount_ro(); 
 
  switch (cmd) { 
    case ANDROID_RB_RESTART: 
      reason = RB_AUTOBOOT; 
      break; 
 
    case ANDROID_RB_POWEROFF: 
      ret = reboot(RB_POWER_OFF); 
      return ret; 
 
    case ANDROID_RB_RESTART2: 
      // REBOOT_MAGIC 
      break; 
 
    default: 
      return -1; 
  } 
 
#ifdef RECOVERY_PRE_COMMAND_CLEAR_REASON 
  reason = RB_AUTOBOOT; 
#endif 
 
  if (reason != -1) 
    ret = reboot(reason); 
  else 
    ret = __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, 
              LINUX_REBOOT_CMD_RESTART2, arg); 
 
  return ret; 
} 

#define RB_AUTOBOOT   LINUX_REBOOT_CMD_RESTART 
#define RB_HALT_SYSTEM LINUX_REBOOT_CMD_HALT 
#define RB_ENABLE_CAD  LINUX_REBOOT_CMD_CAD_ON 
#define RB_DISABLE_CAD LINUX_REBOOT_CMD_CAD_OFF 
#define RB_POWER_OFF  LINUX_REBOOT_CMD_POWER_OFF 

#define LINUX_REBOOT_MAGIC1 0xfee1dead 
#define LINUX_REBOOT_MAGIC2 672274793 
/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ 
#define LINUX_REBOOT_MAGIC2A 85072278 
#define LINUX_REBOOT_MAGIC2B 369367448 
#define LINUX_REBOOT_MAGIC2C 537993216 
#define LINUX_REBOOT_CMD_RESTART 0x01234567 
/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ 
#define LINUX_REBOOT_CMD_HALT 0xCDEF0123 
#define LINUX_REBOOT_CMD_CAD_ON 0x89ABCDEF 
#define LINUX_REBOOT_CMD_CAD_OFF 0x00000000 
#define LINUX_REBOOT_CMD_POWER_OFF 0x4321FEDC 
/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ 
#define LINUX_REBOOT_CMD_RESTART2 0xA1B2C3D4 
#define LINUX_REBOOT_CMD_SW_SUSPEND 0xD000FCE2 
#define LINUX_REBOOT_CMD_KEXEC 0x45584543 

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

ENTRY(__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 
END(__reboot) 

#define __NR_reboot            (__NR_SYSCALL_BASE + 88) 

/* kernel/sys.c */ 
#define __NR_setpriority 140 
__SYSCALL(__NR_setpriority, sys_setpriority) 
#define __NR_getpriority 141 
__SYSCALL(__NR_getpriority, sys_getpriority) 
#define __NR_reboot 142 
__SYSCALL(__NR_reboot, sys_reboot) 

asmlinkage long sys_reboot(int magic1, int magic2, unsigned int cmd, 
        void __user *arg); 

#define SYSCALL_DEFINE1(name, ...) SYSCALL_DEFINEx(1, _##name, __VA_ARGS__) 
#define SYSCALL_DEFINE2(name, ...) SYSCALL_DEFINEx(2, _##name, __VA_ARGS__) 
#define SYSCALL_DEFINE3(name, ...) SYSCALL_DEFINEx(3, _##name, __VA_ARGS__) 
#define SYSCALL_DEFINE4(name, ...) SYSCALL_DEFINEx(4, _##name, __VA_ARGS__) 
#define SYSCALL_DEFINE5(name, ...) SYSCALL_DEFINEx(5, _##name, __VA_ARGS__) 
#define SYSCALL_DEFINE6(name, ...) SYSCALL_DEFINEx(6, _##name, __VA_ARGS__) 
... 
 
#define SYSCALL_DEFINEx(x, sname, ...)       \ 
  __SYSCALL_DEFINEx(x, sname, __VA_ARGS__) 
... 
 
#define __SYSCALL_DEFINEx(x, name, ...)         \ 
  asmlinkage long sys##name(__SC_DECL##x(__VA_ARGS__)) 

#define SYSCALL_DEFINE4(name, ...) \ 
  asmlinkage long sys##_name(__SC_DECL##4(__VA_ARGS__)) 

/* 
 * Reboot system call: for obvious reasons only root may call it, 
 * and even root needs to set up some magic numbers in the registers 
 * so that some mistake won't make this reboot the whole machine. 
 * You can also set the meaning of the ctrl-alt-del-key here. 
 * 
 * reboot doesn't sync: do that yourself before calling this. 
 */ 
SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd, 
    void __user *, arg) 
{ 
  char buffer[256]; 
  int ret = 0; 
 
  /* We only trust the superuser with rebooting the system. */ 
  if (!capable(CAP_SYS_BOOT)) 
    return -EPERM; 
 
  /* For safety, we require "magic" arguments. */ 
  if (magic1 != LINUX_REBOOT_MAGIC1 || 
    (magic2 != LINUX_REBOOT_MAGIC2 && 
          magic2 != LINUX_REBOOT_MAGIC2A && 
      magic2 != LINUX_REBOOT_MAGIC2B && 
          magic2 != LINUX_REBOOT_MAGIC2C)) 
    return -EINVAL; 
 
  /* Instead of trying to make the power_off code look like 
   * halt when pm_power_off is not set do it the easy way. 
   */ 
  if ((cmd == LINUX_REBOOT_CMD_POWER_OFF) && !pm_power_off) 
    cmd = LINUX_REBOOT_CMD_HALT; 
 
  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: 
    if (strncpy_from_user(&buffer[0], arg, sizeof(buffer) - 1) < 0) { 
      ret = -EFAULT; 
      break; 
    } 
    buffer[sizeof(buffer) - 1] = '\0'; 
 
    kernel_restart(buffer); 
    break; 
 
#ifdef CONFIG_KEXEC 
  case LINUX_REBOOT_CMD_KEXEC: 
    ret = kernel_kexec(); 
    break; 
#endif 
 
#ifdef CONFIG_HIBERNATION 
  case LINUX_REBOOT_CMD_SW_SUSPEND: 
    ret = hibernate(); 
    break; 
#endif 
 
  default: 
    ret = -EINVAL; 
    break; 
  } 
  mutex_unlock(&reboot_mutex); 
  return ret; 
} 

/* We only trust the superuser with rebooting the system. */ 
if (!capable(CAP_SYS_BOOT)) 
  return -EPERM; 

/* For safety, we require "magic" arguments. */ 
if (magic1 != LINUX_REBOOT_MAGIC1 || 
  (magic2 != LINUX_REBOOT_MAGIC2 && 
        magic2 != LINUX_REBOOT_MAGIC2A && 
    magic2 != LINUX_REBOOT_MAGIC2B && 
        magic2 != LINUX_REBOOT_MAGIC2C)) 
  return -EINVAL; 

/* Instead of trying to make the power_off code look like 
 * halt when pm_power_off is not set do it the easy way. 
 */ 
if ((cmd == LINUX_REBOOT_CMD_POWER_OFF) && !pm_power_off) 
  cmd = LINUX_REBOOT_CMD_HALT; 

/* 
 * Function pointers to optional machine specific functions 
 */ 
void (*pm_power_off)(void); 
EXPORT_SYMBOL(pm_power_off); 

pm_power_off = msm_pm_power_off; 

/* 
 * Commands accepted by the _reboot() system call. 
 *    
 * RESTART   Restart system using default command and mode. 
 * HALT    Stop OS and give system control to ROM monitor, if any. 
 * CAD_ON   Ctrl-Alt-Del sequence causes RESTART command. 
 * CAD_OFF   Ctrl-Alt-Del sequence sends SIGINT to init task. 
 * POWER_OFF  Stop OS and remove all power from system, if possible. 
 * RESTART2  Restart system using given command string. 
 * SW_SUSPEND Suspend system using software suspend if compiled in. 
 * KEXEC    Restart system using a previously loaded Linux kernel 
 */    
     
#define LINUX_REBOOT_CMD_RESTART  0x01234567 
#define LINUX_REBOOT_CMD_HALT    0xCDEF0123 
#define LINUX_REBOOT_CMD_CAD_ON   0x89ABCDEF 
#define LINUX_REBOOT_CMD_CAD_OFF  0x00000000  
#define LINUX_REBOOT_CMD_POWER_OFF 0x4321FEDC 
#define LINUX_REBOOT_CMD_RESTART2  0xA1B2C3D4 
#define LINUX_REBOOT_CMD_SW_SUSPEND 0xD000FCE2 
#define LINUX_REBOOT_CMD_KEXEC   0x45584543 

/** 
 * kernel_power_off - power_off the system 
 * 
 * Shutdown everything and perform a clean system power_off. 
 */ 
void kernel_power_off(void) 
{ 
  kernel_shutdown_prepare(SYSTEM_POWER_OFF); 
  if (pm_power_off_prepare) 
    pm_power_off_prepare(); 
  disable_nonboot_cpus(); 
  syscore_shutdown(); 
  printk(KERN_EMERG "Power down.\n"); 
  kmsg_dump(KMSG_DUMP_POWEROFF); 
  machine_power_off(); 
} 
EXPORT_SYMBOL_GPL(kernel_power_off); 

void machine_power_off(void) 
{   
  machine_shutdown(); 
  if (pm_power_off) 
    pm_power_off(); 
} 

/** 
 * kernel_restart - reboot the system 
 * @cmd: pointer to buffer containing command to execute for restart 
 *   or %NULL 
 * 
 * Shutdown everything and perform a clean reboot. 
 * This is not safe to call in interrupt context. 
 */ 
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); 
  kmsg_dump(KMSG_DUMP_RESTART); 
  machine_restart(cmd); 
} 
EXPORT_SYMBOL_GPL(kernel_restart); 

void machine_restart(char *cmd) 
{ 
  machine_shutdown(); 
  arm_pm_restart(reboot_mode, cmd); 
} 
... 
void (*arm_pm_restart)(char str, const char *cmd) = arm_machine_restart; 
EXPORT_SYMBOL_GPL(arm_pm_restart); 

arm_pm_restart = msm_pm_restart; 

late_initcall_sync(msm_pm_init); 

static void msm_pm_restart(char str, const char *cmd) 
{     
  msm_rpcrouter_close(); 
  msm_proc_comm(PCOM_RESET_CHIP, &restart_reason, 0); 
 
  for (;;) 
    ; 
}  

void kernel_restart_prepare(char *cmd) 
{   
  blocking_notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd); 
  system_state = SYSTEM_RESTART; 
  usermodehelper_disable(); 
  device_shutdown(); 
  syscore_shutdown(); 
} 

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; 
}       
     
static struct notifier_block msm_reboot_notifier = { 
  .notifier_call = msm_reboot_call, 
}; 
 
... 
 
static int __init msm_pm_init(void) 
{ 
... 
  register_reboot_notifier(&msm_reboot_notifier); 
... 
} 

private final void shutdownIfNoPower() { 
// shut down gracefully if our battery is critically low and we are not powered. 
// wait until the system has booted before attempting to display the shutdown dialog. 
if (mBatteryLevel == 0 && !isPowered() && ActivityManagerNative.isSystemReady()) { 
  Intent intent = new Intent(Intent.ACTION_REQUEST_SHUTDOWN); 
  intent.putExtra(Intent.EXTRA_KEY_CONFIRM, false); 
  intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 
  mContext.startActivity(intent); 
}