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); 
}