当前位置：首页 > news >正文

安卓关机和重启源码流程

news 来源：原创 2025/9/10 1:02:16

// systemui关机

frameworks/base/packages/SystemUI/src/com/android/systemui/globalactions/GlobalActionsComponent.java

@Overridepublic void shutdown() {try {mBarService.shutdown();} catch (RemoteException e) {}}

frameworks/base/services/core/java/com/android/server/statusbar/StatusBarManagerService.java

@Overridepublic void shutdown() {enforceStatusBarService();
// 原因为：userrequestedString reason = PowerManager.SHUTDOWN_USER_REQUESTED;ShutdownCheckPoints.recordCheckPoint(Binder.getCallingPid(), reason);final long identity = Binder.clearCallingIdentity();try {mNotificationDelegate.prepareForPossibleShutdown();// ShutdownThread displays UI, so give it a UI context.
// 调用ShutdownThread.shutdown，传入参数为 falsemHandler.post(() ->ShutdownThread.shutdown(getUiContext(), reason, false));} finally {Binder.restoreCallingIdentity(identity);}}

// 调用ShutdownThread.shutdown，传入参数为 false

frameworks/base/services/core/java/com/android/server/power/ShutdownThread.java

public static void shutdown(final Context context, String reason, boolean confirm) {mReboot = false;mRebootSafeMode = false;mReason = reason;
// confirm 为falseshutdownInner(context, confirm);}

// shutdownInner 方法

private static void shutdownInner(final Context context, boolean confirm) {// ShutdownThread is called from many places, so best to verify here that the context passed// in is themed.context.assertRuntimeOverlayThemable();// ensure that only one thread is trying to power down.// any additional calls are just returnedsynchronized (sIsStartedGuard) {if (sIsStarted) {if (DEBUG) {Log.d(TAG, "Request to shutdown already running, returning.");}return;}}// Add checkpoint for this shutdown attempt. The user might still cancel the dialog, but// this point preserves the system trace of the trigger point of the ShutdownThread.
// 会记录是哪个进程调用shutdown 关机的ShutdownCheckPoints.recordCheckPoint(/* reason= */ null);// 关于关机重启的dialogfinal int longPressBehavior = context.getResources().getInteger(com.android.internal.R.integer.config_longPressOnPowerBehavior);final int resourceId = mRebootSafeMode? com.android.internal.R.string.reboot_safemode_confirm: (longPressBehavior == 2? com.android.internal.R.string.shutdown_confirm_question: com.android.internal.R.string.shutdown_confirm);if (DEBUG) {Log.d(TAG, "Notifying thread to start shutdown longPressBehavior=" + longPressBehavior);}
// confirm 为false，不启动dialogif (confirm) {final CloseDialogReceiver closer = new CloseDialogReceiver(context);if (sConfirmDialog != null) {sConfirmDialog.dismiss();}sConfirmDialog = new AlertDialog.Builder(context).setTitle(mRebootSafeMode? com.android.internal.R.string.reboot_safemode_title: com.android.internal.R.string.power_off).setMessage(resourceId).setPositiveButton(com.android.internal.R.string.yes, new DialogInterface.OnClickListener() {public void onClick(DialogInterface dialog, int which) {beginShutdownSequence(context);}}).setNegativeButton(com.android.internal.R.string.no, null).create();closer.dialog = sConfirmDialog;sConfirmDialog.setOnDismissListener(closer);sConfirmDialog.getWindow().setType(WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG);sConfirmDialog.show();} else {
// 调用 beginShutdownSequencebeginShutdownSequence(context);}}

// 调用 beginShutdownSequence

private static final ShutdownThread sInstance = new ShutdownThread();private static void beginShutdownSequence(Context context) {synchronized (sIsStartedGuard) {if (sIsStarted) {if (DEBUG) {Log.d(TAG, "Shutdown sequence already running, returning.");}return;}sIsStarted = true;}
// sInstance 是 ShutdownThreadsInstance.mProgressDialog = showShutdownDialog(context);sInstance.mContext = context;sInstance.mPowerManager = (PowerManager)context.getSystemService(Context.POWER_SERVICE);// make sure we never fall asleep againsInstance.mCpuWakeLock = null;try {
// 让cpu 不睡眠，亮屏sInstance.mCpuWakeLock = sInstance.mPowerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG + "-cpu");sInstance.mCpuWakeLock.setReferenceCounted(false);sInstance.mCpuWakeLock.acquire();} catch (SecurityException e) {Log.w(TAG, "No permission to acquire wake lock", e);sInstance.mCpuWakeLock = null;}// also make sure the screen stays on for better user experiencesInstance.mScreenWakeLock = null;if (sInstance.mPowerManager.isScreenOn()) {try {sInstance.mScreenWakeLock = sInstance.mPowerManager.newWakeLock(PowerManager.FULL_WAKE_LOCK, TAG + "-screen");sInstance.mScreenWakeLock.setReferenceCounted(false);sInstance.mScreenWakeLock.acquire();} catch (SecurityException e) {Log.w(TAG, "No permission to acquire wake lock", e);sInstance.mScreenWakeLock = null;}}if (SecurityLog.isLoggingEnabled()) {SecurityLog.writeEvent(SecurityLog.TAG_OS_SHUTDOWN);}// start the thread that initiates shutdownsInstance.mHandler = new Handler() {};
// 启动 ShutdownThread 线程sInstance.start();}

// 启动 ShutdownThread 线程

public void run() {TimingsTraceLog shutdownTimingLog = newTimingsLog();shutdownTimingLog.traceBegin("SystemServerShutdown");metricShutdownStart();metricStarted(METRIC_SYSTEM_SERVER);// 保存关机的信息，前面调用了 recordCheckPoint，保存关机的调用栈// Start dumping check points for this shutdown in a separate thread.Thread dumpCheckPointsThread = ShutdownCheckPoints.newDumpThread(new File(CHECK_POINTS_FILE_BASENAME));dumpCheckPointsThread.start();/** 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") + (mReason != null ? mReason : "");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");}shutdownTimingLog.traceBegin("DumpPreRebootInfo");try {Slog.i(TAG, "Logging pre-reboot information...");PreRebootLogger.log(mContext);} catch (Exception e) {Slog.e(TAG, "Failed to log pre-reboot information", e);}shutdownTimingLog.traceEnd(); // DumpPreRebootInfometricStarted(METRIC_SEND_BROADCAST);shutdownTimingLog.traceBegin("SendShutdownBroadcast");Log.i(TAG, "Sending shutdown broadcast...");// First send the high-level shut down broadcast.mActionDone = false;
// 发送关机广播，只能是前台receiver和注册广播类型Intent intent = new Intent(Intent.ACTION_SHUTDOWN);intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND | Intent.FLAG_RECEIVER_REGISTERED_ONLY);final Bundle opts = BroadcastOptions.makeBasic().setDeferralPolicy(BroadcastOptions.DEFERRAL_POLICY_UNTIL_ACTIVE).toBundle();final ActivityManagerInternal activityManagerInternal = LocalServices.getService(ActivityManagerInternal.class);
// 设置广播 回调 this::actionDoneactivityManagerInternal.broadcastIntentWithCallback(intent,new IIntentReceiver.Stub() {@Overridepublic void performReceive(Intent intent, int resultCode, String data,Bundle extras, boolean ordered, boolean sticky, int sendingUser) {mHandler.post(ShutdownThread.this::actionDone);}}, null, UserHandle.USER_ALL, null, null, opts);final long endTime = SystemClock.elapsedRealtime() + MAX_BROADCAST_TIME;synchronized (mActionDoneSync) {while (!mActionDone) {long delay = endTime - SystemClock.elapsedRealtime();if (delay <= 0) {Log.w(TAG, "Shutdown broadcast timed out");break;} else if (mRebootHasProgressBar) {int status = (int)((MAX_BROADCAST_TIME - delay) * 1.0 *BROADCAST_STOP_PERCENT / MAX_BROADCAST_TIME);sInstance.setRebootProgress(status, null);}try {
// 等待处理完关机广播，等待 500msmActionDoneSync.wait(Math.min(delay, ACTION_DONE_POLL_WAIT_MS));} catch (InterruptedException e) {}}}if (mRebootHasProgressBar) {sInstance.setRebootProgress(BROADCAST_STOP_PERCENT, null);}shutdownTimingLog.traceEnd(); // SendShutdownBroadcastmetricEnded(METRIC_SEND_BROADCAST);Log.i(TAG, "Shutting down activity manager...");shutdownTimingLog.traceBegin("ShutdownActivityManager");metricStarted(METRIC_AM);final IActivityManager am =IActivityManager.Stub.asInterface(ServiceManager.checkService("activity"));if (am != null) {try {
// 1）调用AMS 的 shutdown 方法am.shutdown(MAX_BROADCAST_TIME);} catch (RemoteException e) {}}if (mRebootHasProgressBar) {sInstance.setRebootProgress(ACTIVITY_MANAGER_STOP_PERCENT, null);}shutdownTimingLog.traceEnd();// ShutdownActivityManagermetricEnded(METRIC_AM);Log.i(TAG, "Shutting down package manager...");shutdownTimingLog.traceBegin("ShutdownPackageManager");metricStarted(METRIC_PM);final PackageManagerInternal pm = LocalServices.getService(PackageManagerInternal.class);if (pm != null) {
// 关闭 packagemanagerservicepm.shutdown();}if (mRebootHasProgressBar) {sInstance.setRebootProgress(PACKAGE_MANAGER_STOP_PERCENT, null);}shutdownTimingLog.traceEnd(); // ShutdownPackageManagermetricEnded(METRIC_PM);// Shutdown radios.shutdownTimingLog.traceBegin("ShutdownRadios");metricStarted(METRIC_RADIOS);
// 2）关闭radio：shutdownRadiosshutdownRadios(MAX_RADIO_WAIT_TIME);if (mRebootHasProgressBar) {sInstance.setRebootProgress(RADIO_STOP_PERCENT, null);}shutdownTimingLog.traceEnd(); // ShutdownRadiosmetricEnded(METRIC_RADIOS);if (mRebootHasProgressBar) {sInstance.setRebootProgress(MOUNT_SERVICE_STOP_PERCENT, null);// If it's to reboot to install an update and uncrypt hasn't been// done yet, trigger it now.uncrypt();}// Wait for the check points dump thread to finish, or kill it if not finished in time.shutdownTimingLog.traceBegin("ShutdownCheckPointsDumpWait");try {dumpCheckPointsThread.join(MAX_CHECK_POINTS_DUMP_WAIT_TIME);} catch (InterruptedException ex) {}shutdownTimingLog.traceEnd(); // ShutdownCheckPointsDumpWaitshutdownTimingLog.traceEnd(); // SystemServerShutdownmetricEnded(METRIC_SYSTEM_SERVER);saveMetrics(mReboot, mReason);// Remaining work will be done by init, including vold shutdown
// 3）调用 rebootOrShutdown 方法rebootOrShutdown(mContext, mReboot, mReason);}

// 1）调用AMS 的 shutdown 方法

/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

7150      @Override
7151      public boolean shutdown(int timeout) {
7152          if (checkCallingPermission(android.Manifest.permission.SHUTDOWN)
7153                  != PackageManager.PERMISSION_GRANTED) {
7154              throw new SecurityException("Requires permission "
7155                      + android.Manifest.permission.SHUTDOWN);
7156          }
7157  
/// 主要调用了 ActivityTaskManagerService 的 shuttingDown，去保存最近的任务状态
7158          final boolean timedout = mAtmInternal.shuttingDown(mBooted, timeout);
7159  
7160          mAppOpsService.shutdown();
7161          if (mUsageStatsService != null) {
7162              mUsageStatsService.prepareShutdown();
7163          }
7164          mBatteryStatsService.shutdown();
7165          mProcessStats.shutdown();
7166  
7167          return timedout;
7168      }

/frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java

6045          @Override
6046          public boolean shuttingDown(boolean booted, int timeout) {
6047              mShuttingDown = true;
6048              synchronized (mGlobalLock) {
6049                  mRootWindowContainer.prepareForShutdown();
// 设置不接受input
6050                  updateEventDispatchingLocked(booted);
// 关于最近任务持久化
6051                  notifyTaskPersisterLocked(null, true);
// 设置activity走pause流程
6052                  return mTaskSupervisor.shutdownLocked(timeout);
6053              }
6054          }

// 2）关闭radio：shutdownRadios

625      private void shutdownRadios(final int timeout) {
626          // If a radio is wedged, disabling it may hang so we do this work in another thread,
627          // just in case.
628          final long endTime = SystemClock.elapsedRealtime() + timeout;
629          final boolean[] done = new boolean[1];
630          Thread t = new Thread() {
631              public void run() {
632                  TimingsTraceLog shutdownTimingsTraceLog = newTimingsLog();
633                  boolean radioOff;
634  
635                  TelephonyManager telephonyManager = mContext.getSystemService(
636                          TelephonyManager.class);
637  
638                  radioOff = telephonyManager == null
639                          || !telephonyManager.isAnyRadioPoweredOn();
640                  if (!radioOff) {
641                      Log.w(TAG, "Turning off cellular radios...");
642                      metricStarted(METRIC_RADIO);
// 调用 TelephonyManager 的 shutdownAllRadios 方法
643                      telephonyManager.shutdownAllRadios();
644                  }
645  
646                  Log.i(TAG, "Waiting for Radio...");
647  
648                  long delay = endTime - SystemClock.elapsedRealtime();
649                  while (delay > 0) {
650                      if (mRebootHasProgressBar) {
651                          int status = (int)((timeout - delay) * 1.0 *
652                                  (RADIO_STOP_PERCENT - PACKAGE_MANAGER_STOP_PERCENT) / timeout);
653                          status += PACKAGE_MANAGER_STOP_PERCENT;
654                          sInstance.setRebootProgress(status, null);
655                      }
656  
657                      if (!radioOff) {
// 需要满足 isAnyRadioPoweredOn
658                          radioOff = !telephonyManager.isAnyRadioPoweredOn();
659                          if (radioOff) {
660                              Log.i(TAG, "Radio turned off.");
661                              metricEnded(METRIC_RADIO);
662                              shutdownTimingsTraceLog
663                                      .logDuration("ShutdownRadio", TRON_METRICS.get(METRIC_RADIO));
664                          }
665                      }
666  
667                      if (radioOff) {
668                          Log.i(TAG, "Radio shutdown complete.");
669                          done[0] = true;
670                          break;
671                      }
672                      SystemClock.sleep(RADIOS_STATE_POLL_SLEEP_MS);
673                      delay = endTime - SystemClock.elapsedRealtime();
674                  }
675              }
676          };
677  
678          t.start();
679          try {
680              t.join(timeout);
681          } catch (InterruptedException ex) {
682          }
683          if (!done[0]) {
684              Log.w(TAG, "Timed out waiting for Radio shutdown.");
685          }
686      }

// 3）调用 rebootOrShutdown 方法

696      public static void rebootOrShutdown(final Context context, boolean reboot, String reason) {
// 如果是重启，则会打印下列的log Rebooting, reason
697          if (reboot) {
698              Log.i(TAG, "Rebooting, reason: " + reason);
699              PowerManagerService.lowLevelReboot(reason);
700              Log.e(TAG, "Reboot failed, will attempt shutdown instead");
701              reason = null;
// 振动为 500毫秒，这里先振动
702          } else if (SHUTDOWN_VIBRATE_MS > 0 && context != null) {
703              // vibrate before shutting down
704              Vibrator vibrator = new SystemVibrator(context);
705              try {
706                  if (vibrator.hasVibrator()) {
707                      vibrator.vibrate(SHUTDOWN_VIBRATE_MS, VIBRATION_ATTRIBUTES);
708                      // vibrator is asynchronous so we need to wait to avoid shutting down too soon.
709                      try {
710                          Thread.sleep(SHUTDOWN_VIBRATE_MS);
711                      } catch (InterruptedException unused) {
712                          // this is not critical and does not require logging
713                      }
714                  }
715              } catch (Exception e) {
716                  // Failure to vibrate shouldn't interrupt shutdown.  Just log it.
717                  Log.w(TAG, "Failed to vibrate during shutdown.", e);
718              }
719  
720          }
721          // Shutdown power
// 关机会打印下列delog
722          Log.i(TAG, "Performing low-level shutdown...");
// 关机调用下列的方法
723          PowerManagerService.lowLevelShutdown(reason);
724      }

/frameworks/base/services/core/java/com/android/server/power/PowerManagerService.java

4468      public static void lowLevelShutdown(String reason) {
4469          if (reason == null) {
4470              reason = "";
4471          }
/// sprd这里增加了判断是否在充电，charging
// 这里直接去设置个属性，设置关机，reason为 userrequest，会设置到init 进程
4472          SystemProperties.set("sys.powerctl", "shutdown," + reason);
4473      }

//reboot重启的流程为：

4482      public static void lowLevelReboot(String reason) {
4483          if (reason == null) {
4484              reason = "";
4485          }
4486  
4487          // If the reason is "quiescent", it means that the boot process should proceed
4488          // without turning on the screen/lights.
4489          // The "quiescent" property is sticky, meaning that any number
4490          // of subsequent reboots should honor the property until it is reset.
4491          if (reason.equals(PowerManager.REBOOT_QUIESCENT)) {
4492              sQuiescent = true;
4493              reason = "";
4494          } else if (reason.endsWith("," + PowerManager.REBOOT_QUIESCENT)) {
4495              sQuiescent = true;
4496              reason = reason.substring(0,
4497                      reason.length() - PowerManager.REBOOT_QUIESCENT.length() - 1);
4498          }
4499  
4500          if (reason.equals(PowerManager.REBOOT_RECOVERY)
4501                  || reason.equals(PowerManager.REBOOT_RECOVERY_UPDATE)) {
4502              reason = "recovery";
4503          }
4504  
4505          if (sQuiescent) {
4506              // Pass the optional "quiescent" argument to the bootloader to let it know
4507              // that it should not turn the screen/lights on.
4508              if (!"".equals(reason)) {
4509                  reason += ",";
4510              }
4511              reason = reason + "quiescent";
4512          }
4513  
// 重启发送的是："sys.powerctl", "reboot,"
4514          SystemProperties.set("sys.powerctl", "reboot," + reason);
4515          try {
4516              Thread.sleep(20 * 1000L);
4517          } catch (InterruptedException e) {
4518              Thread.currentThread().interrupt();
4519          }
4520          Slog.wtf(TAG, "Unexpected return from lowLevelReboot!");
4521      }

// 系统进程是通过 system_property_set 提供的接口，与 property_service socket 通信

/xref/bionic/libc/bionic/system_property_set.cpp

247  __BIONIC_WEAK_FOR_NATIVE_BRIDGE
248  int __system_property_set(const char* key, const char* value) {
249    if (key == nullptr) return -1;
250    if (value == nullptr) value = "";
251  
252    if (g_propservice_protocol_version == 0) {
253      detect_protocol_version();
254    }
。。。
256    if (g_propservice_protocol_version == kProtocolVersion1) {
。。。。
266  
267      return send_prop_msg(&msg);
268    } else {
// 使用的是新的版本
// 版本是通过 getprop获取到const char* kServiceVersionPropertyName = "ro.property_service.version";
269      // New protocol only allows long values for ro. properties only.
270      if (strlen(value) >= PROP_VALUE_MAX && strncmp(key, "ro.", 3) != 0) return -1;
271      // Use proper protocol
// 创建 PropertyServiceConnection  对象，进行socket 通信
272      PropertyServiceConnection connection;
273      if (!connection.IsValid()) {
274        errno = connection.GetLastError();
275        async_safe_format_log(
276            ANDROID_LOG_WARN, "libc",
277            "Unable to set property \"%s\" to \"%s\": connection failed; errno=%d (%s)", key, value,
278            errno, strerror(errno));
279        return -1;
280      }
281  
282      SocketWriter writer(&connection);
// 通过socket 去发送消息
283      if (!writer.WriteUint32(PROP_MSG_SETPROP2).WriteString(key).WriteString(value).Send()) {
284        errno = connection.GetLastError();
285        async_safe_format_log(ANDROID_LOG_WARN, "libc",
286                              "Unable to set property \"%s\" to \"%s\": write failed; errno=%d (%s)",
287                              key, value, errno, strerror(errno));
288        return -1;
289      }
290  
291      int result = -1;
292      if (!connection.RecvInt32(&result)) {
293        errno = connection.GetLastError();
294        async_safe_format_log(ANDROID_LOG_WARN, "libc",
295                              "Unable to set property \"%s\" to \"%s\": recv failed; errno=%d (%s)",
296                              key, value, errno, strerror(errno));
297        return -1;
298      }
299  
300      if (result != PROP_SUCCESS) {
301        async_safe_format_log(ANDROID_LOG_WARN, "libc",
302                              "Unable to set property \"%s\" to \"%s\": error code: 0x%x", key, value,
303                              result);
304        return -1;
305      }

// 创建 PropertyServiceConnection 对象，进行socket 通信

51  static const char property_service_socket[] = "/dev/socket/" PROP_SERVICE_NAME;
52  static const char* kServiceVersionPropertyName = "ro.property_service.version";
53  
54  class PropertyServiceConnection {
55   public:
56    PropertyServiceConnection() : last_error_(0) {
57      socket_.reset(::socket(AF_LOCAL, SOCK_STREAM | SOCK_CLOEXEC, 0));
58      if (socket_.get() == -1) {
59        last_error_ = errno;
60        return;
61      }
62  
63      const size_t namelen = strlen(property_service_socket);
64      sockaddr_un addr;
65      memset(&addr, 0, sizeof(addr));
// 构造方法中会去socket 通信：property_service_socket为  "/dev/socket/" PROP_SERVICE_NAME
66      strlcpy(addr.sun_path, property_service_socket, sizeof(addr.sun_path));
67      addr.sun_family = AF_LOCAL;
68      socklen_t alen = namelen + offsetof(sockaddr_un, sun_path) + 1;
69  
70      if (TEMP_FAILURE_RETRY(connect(socket_.get(),
71                                     reinterpret_cast<sockaddr*>(&addr), alen)) == -1) {
72        last_error_ = errno;
73        socket_.reset();
74      }
75    }

// property_service 的启动

/android-14.0.0_r21/xref/system/core/init/property_service.cpp

// 在init 初始化的时候，在第二个阶段会StartPropertyService

1485  void StartPropertyService(int* epoll_socket) {
// 初始化 "ro.property_service.version" 的值为 2，前面 system_property_set 会去获取
1486      InitPropertySet("ro.property_service.version", "2");
1487  
1488      int sockets[2];
// 创建socket，这里是和init 通信
1489      if (socketpair(AF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC, 0, sockets) != 0) {
1490          PLOG(FATAL) << "Failed to socketpair() between property_service and init";
1491      }
1492      *epoll_socket = from_init_socket = sockets[0];
1493      init_socket = sockets[1];
1494      StartSendingMessages();
1495  
// 创建与 PROP_SERVICE 的socket通信
1496      if (auto result = CreateSocket(PROP_SERVICE_NAME, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
1497                                     /*passcred=*/false, /*should_listen=*/false, 0666, /*uid=*/0,
1498                                     /*gid=*/0, /*socketcon=*/{});
1499          result.ok()) {
// 保存fd 值
1500          property_set_fd = *result;
1501      } else {
1502          LOG(FATAL) << "start_property_service socket creation failed: " << result.error();
1503      }
1504  
1505      listen(property_set_fd, 8);
1506  
// 创建 PropertyServiceThread 线程
1507      auto new_thread = std::thread{PropertyServiceThread};
1508      property_service_thread.swap(new_thread);
1509  
1510      auto async_persist_writes =
1511              android::base::GetBoolProperty("ro.property_service.async_persist_writes", false);
1512  
1513      if (async_persist_writes) {
1514          persist_write_thread = std::make_unique<PersistWriteThread>();
1515      }
1516  }

// PropertyServiceThread 线程

1422  static void PropertyServiceThread() {
1423      Epoll epoll;
1424      if (auto result = epoll.Open(); !result.ok()) {
1425          LOG(FATAL) << result.error();
1426      }
1427  
// 监听 与 PROP_SERVICE的socket 通信，会回调 handle_property_set_fd
1428      if (auto result = epoll.RegisterHandler(property_set_fd, handle_property_set_fd);
1429          !result.ok()) {
1430          LOG(FATAL) << result.error();
1431      }
1432  
// 监听与init 的socket 通信
1433      if (auto result = epoll.RegisterHandler(init_socket, HandleInitSocket); !result.ok()) {
1434          LOG(FATAL) << result.error();
1435      }
1436  
1437      while (true) {
1438          auto epoll_result = epoll.Wait(std::nullopt);
1439          if (!epoll_result.ok()) {
1440              LOG(ERROR) << epoll_result.error();
1441          }
1442      }
1443  }

// property的设置有变化，则回调 handle_property_set_fd
SystemProperties.set(“sys.powerctl”, “shutdown,” + reason);
SystemProperties.set(“sys.powerctl”, “reboot,” + reason);

582  static void handle_property_set_fd() {
583      static constexpr uint32_t kDefaultSocketTimeout = 2000; /* ms */
584  
585      int s = accept4(property_set_fd, nullptr, nullptr, SOCK_CLOEXEC);
586      if (s == -1) {
587          return;
588      }
589  
590      ucred cr;
591      socklen_t cr_size = sizeof(cr);
592      if (getsockopt(s, SOL_SOCKET, SO_PEERCRED, &cr, &cr_size) < 0) {
593          close(s);
594          PLOG(ERROR) << "sys_prop: unable to get SO_PEERCRED";
595          return;
596      }
597  
598      SocketConnection socket(s, cr);
// 超时时间为 2 秒
599      uint32_t timeout_ms = kDefaultSocketTimeout;
600  
601      uint32_t cmd = 0;
602      if (!socket.RecvUint32(&cmd, &timeout_ms)) {
603          PLOG(ERROR) << "sys_prop: error while reading command from the socket";
604          socket.SendUint32(PROP_ERROR_READ_CMD);
605          return;
606      }
608      switch (cmd) {
。。。639      case PROP_MSG_SETPROP2: {
640          std::string name;
641          std::string value;
// 获取到name 和value
642          if (!socket.RecvString(&name, &timeout_ms) ||
643              !socket.RecvString(&value, &timeout_ms)) {
644            PLOG(ERROR) << "sys_prop(PROP_MSG_SETPROP2): error while reading name/value from the socket";
645            socket.SendUint32(PROP_ERROR_READ_DATA);
646            return;
647          }
648  
649          std::string source_context;
650          if (!socket.GetSourceContext(&source_context)) {
651              PLOG(ERROR) << "Unable to set property '" << name << "': getpeercon() failed";
652              socket.SendUint32(PROP_ERROR_PERMISSION_DENIED);
653              return;
654          }
655  
656          // HandlePropertySet takes ownership of the socket if the set is handled asynchronously.
657          const auto& cr = socket.cred();
658          std::string error;
// 处理 name 和value：HandlePropertySet
659          auto result = HandlePropertySet(name, value, source_context, cr, &socket, &error);
660          if (!result) {
661              // Result will be sent after completion.
662              return;
663          }
664          if (*result != PROP_SUCCESS) {
665              LOG(ERROR) << "Unable to set property '" << name << "' from uid:" << cr.uid
666                         << " gid:" << cr.gid << " pid:" << cr.pid << ": " << error;
667          }
668          socket.SendUint32(*result);
669          break;
670        }

// 处理 name 和value：HandlePropertySet

529  std::optional<uint32_t> HandlePropertySet(const std::string& name, const std::string& value,
530                                            const std::string& source_context, const ucred& cr,
531                                            SocketConnection* socket, std::string* error) {
532      if (auto ret = CheckPermissions(name, value, source_context, cr, error); ret != PROP_SUCCESS) {
533          return {ret};
534      }
535  
// 如果是 ctl. 开头，则执行 SendControlMessage
536      if (StartsWith(name, "ctl.")) {
537          return {SendControlMessage(name.c_str() + 4, value, cr.pid, socket, error)};
538      }
539  
540      // sys.powerctl is a special property that is used to make the device reboot.  We want to log
541      // any process that sets this property to be able to accurately blame the cause of a shutdown.
// 满足下列条件："sys.powerctl"
542      if (name == "sys.powerctl") {
// cr.pid 获取的是调用端的pid，cmdline_path 获取到对应pid进程的进程名
// todo: 待追踪  cr.pid的赋值
543          std::string cmdline_path = StringPrintf("proc/%d/cmdline", cr.pid);
544          std::string process_cmdline;
545          std::string process_log_string;
546          if (ReadFileToString(cmdline_path, &process_cmdline)) {
547              // Since cmdline is null deliminated, .c_str() conveniently gives us just the process
548              // path.
549              process_log_string = StringPrintf(" (%s)", process_cmdline.c_str());
550          }
// 会打印下列的log：
551          LOG(INFO) << "Received sys.powerctl='" << value << "' from pid: " << cr.pid
552                    << process_log_string;
553          if (value == "reboot,userspace" && !is_userspace_reboot_supported().value_or(false)) {
554              *error = "Userspace reboot is not supported by this device";
555              return {PROP_ERROR_INVALID_VALUE};
556          }
557      }
558  
// 不满足name 为 kRestoreconProperty 
563      if (name == kRestoreconProperty && cr.pid != 1 && !value.empty()) {
564          static AsyncRestorecon async_restorecon;
565          async_restorecon.TriggerRestorecon(value);
566          return {PROP_SUCCESS};
567      }
568  
// 调用 PropertySet 方法
569      return PropertySet(name, value, socket, error);
570  }

// 调用 PropertySet 方法

383  static std::optional<uint32_t> PropertySet(const std::string& name, const std::string& value,
384                                             SocketConnection* socket, std::string* error) {
385      size_t valuelen = value.size();
386  
// 判断name 和value 是否合法
387      if (!IsLegalPropertyName(name)) {
388          *error = "Illegal property name";
389          return {PROP_ERROR_INVALID_NAME};
390      }
391  
392      if (auto result = IsLegalPropertyValue(name, value); !result.ok()) {
393          *error = result.error().message();
394          return {PROP_ERROR_INVALID_VALUE};
395      }
396  
// 保存到  __system_property
397      prop_info* pi = (prop_info*)__system_property_find(name.c_str());
398      if (pi != nullptr) {
399          // ro.* properties are actually "write-once".
400          if (StartsWith(name, "ro.")) {
401              *error = "Read-only property was already set";
402              return {PROP_ERROR_READ_ONLY_PROPERTY};
403          }
404  
405          __system_property_update(pi, value.c_str(), valuelen);
406      } else {
407          int rc = __system_property_add(name.c_str(), name.size(), value.c_str(), valuelen);
408          if (rc < 0) {
409              *error = "__system_property_add failed";
410              return {PROP_ERROR_SET_FAILED};
411          }
412      }
413  
414      // Don't write properties to disk until after we have read all default
415      // properties to prevent them from being overwritten by default values.
// 如果是persist 属性，则缓存到 "/data/property/persistent_properties"
416      if (socket && persistent_properties_loaded && StartsWith(name, "persist.")) {
417          if (persist_write_thread) {
418              persist_write_thread->Write(name, value, std::move(*socket));
419              return {};
420          }
421          WritePersistentProperty(name, value);
422      }
423  
// 通知到属性变化 
424      NotifyPropertyChange(name, value);
425      return {PROP_SUCCESS};
426  }

185  void NotifyPropertyChange(const std::string& name, const std::string& value) {
186      // If init hasn't started its main loop, then it won't be handling property changed messages
187      // anyway, so there's no need to try to send them.
188      auto lock = std::lock_guard{accept_messages_lock};
// 在执行reboot 重启或者关机，StopSendingMessages 会设置 accept_messages为false
189      if (accept_messages) {
190          PropertyChanged(name, value);
191      }
192  }

/system/core/init/init.cpp

363  void PropertyChanged(const std::string& name, const std::string& value) {
364      // If the property is sys.powerctl, we bypass the event queue and immediately handle it.
365      // This is to ensure that init will always and immediately shutdown/reboot, regardless of
366      // if there are other pending events to process or if init is waiting on an exec service or
367      // waiting on a property.
368      // In non-thermal-shutdown case, 'shutdown' trigger will be fired to let device specific
369      // commands to be executed.
// 满足下列条件，"sys.powerctl"，回调 trigger_shutdown 方法
370      if (name == "sys.powerctl") {
371          trigger_shutdown(value);
372      }
373  
374      if (property_triggers_enabled) {
// 去增加属性变化
375          ActionManager::GetInstance().QueuePropertyChange(name, value);
376          WakeMainInitThread();
377      }
378  
379      prop_waiter_state.CheckAndResetWait(name, value);
380  }

// 回调 trigger_shutdown 方法，传入参数是value，为shutdown或者reboot
trigger_shutdown = [](const std::string& command) { shutdown_state.TriggerShutdown(command); };

236  static class ShutdownState {
237    public:
238      void TriggerShutdown(const std::string& command) {
239          // We can't call HandlePowerctlMessage() directly in this function,
240          // because it modifies the contents of the action queue, which can cause the action queue
241          // to get into a bad state if this function is called from a command being executed by the
242          // action queue.  Instead we set this flag and ensure that shutdown happens before the next
243          // command is run in the main init loop.
244          auto lock = std::lock_guard{shutdown_command_lock_};
// 缓存value 的值
245          shutdown_command_ = command;
// 设置  do_shutdown_ = true
246          do_shutdown_ = true;
// 唤醒init 主线程
247          WakeMainInitThread();
248      }// 通过 CheckShutdown 可以获取到 shutdown_command_ 值
250      std::optional<std::string> CheckShutdown() __attribute__((warn_unused_result)) {
251          auto lock = std::lock_guard{shutdown_command_lock_};
252          if (do_shutdown_ && !IsShuttingDown()) {
253              do_shutdown_ = false;
254              return shutdown_command_;
255          }
256          return {};
257      }

153  static void WakeMainInitThread() {
154      uint64_t counter = 1;
155      TEMP_FAILURE_RETRY(write(wake_main_thread_fd, &counter, sizeof(counter)));
156  }

// 唤醒init 主线程

912  int SecondStageMain(int argc, char** argv) {
913      if (REBOOT_BOOTLOADER_ON_PANIC) {
914          InstallRebootSignalHandlers();
915      }
916  
917      // No threads should be spin up until signalfd
918      // is registered. If the threads are indeed required,
919      // each of these threads _should_ make sure SIGCHLD signal
920      // is blocked. See b/223076262
921      boot_clock::time_point start_time = boot_clock::now();
922  
923      trigger_shutdown = [](const std::string& command) { shutdown_state.TriggerShutdown(command); };
。。
// 下列方法监听了 wake_main_thread_fd
1005      InstallInitNotifier(&epoll);
。。。
1090      while (true) {
1091          // By default, sleep until something happens. Do not convert far_future into
1092          // std::chrono::milliseconds because that would trigger an overflow. The unit of boot_clock
1093          // is 1ns.
1094          const boot_clock::time_point far_future = boot_clock::time_point::max();
1095          boot_clock::time_point next_action_time = far_future;
1096  
// 获取到 shutdown_command 
1097          auto shutdown_command = shutdown_state.CheckShutdown();
// 会打印下列log
1098          if (shutdown_command) {
1099              LOG(INFO) << "Got shutdown_command '" << *shutdown_command
1100                        << "' Calling HandlePowerctlMessage()";
// 3-1）执行 HandlePowerctlMessage 方法
1101              HandlePowerctlMessage(*shutdown_command);
1102          }
1103  
// 前面分析调用了 ResetWaitForPropLocked设置 MightBeWaiting为false；UnSetExec也设置了 is_exec_service_running为false
// 3-2）执行 action命令：ExecuteOneCommand
1104          if (!(prop_waiter_state.MightBeWaiting() || Service::is_exec_service_running())) {
1105              am.ExecuteOneCommand();
1106              // If there's more work to do, wake up again immediately.
1107              if (am.HasMoreCommands()) {
1108                  next_action_time = boot_clock::now();
1109              }
1110          }
1111          // Since the above code examined pending actions, no new actions must be
1112          // queued by the code between this line and the Epoll::Wait() call below
1113          // without calling WakeMainInitThread().
1114          if (!IsShuttingDown()) {
1115              auto next_process_action_time = HandleProcessActions();
1116  
1117              // If there's a process that needs restarting, wake up in time for that.
1118              if (next_process_action_time) {
1119                  next_action_time = std::min(next_action_time, *next_process_action_time);
1120              }
1121          }
1122  
1123          std::optional<std::chrono::milliseconds> epoll_timeout;
1124          if (next_action_time != far_future) {
1125              epoll_timeout = std::chrono::ceil<std::chrono::milliseconds>(
1126                      std::max(next_action_time - boot_clock::now(), 0ns));
1127          }
// epoll 机制在这里wait，前面会唤醒int 主线程；执行while 循环
1128          auto epoll_result = epoll.Wait(epoll_timeout);
1129          if (!epoll_result.ok()) {
1130              LOG(ERROR) << epoll_result.error();
1131          }
1132          if (!IsShuttingDown()) {
1133              HandleControlMessages();
1134              SetUsbController();
1135          }
1136      }
1137  
1138      return 0;
1139  }

// 3-1）执行 HandlePowerctlMessage 方法

/android-14.0.0_r21/xref/system/core/init/reboot.cpp

1027  void HandlePowerctlMessage(const std::string& command) {
1028      unsigned int cmd = 0;
1029      std::vector<std::string> cmd_params = Split(command, ",");
1030      std::string reboot_target = "";
1031      bool run_fsck = false;
1032      bool command_invalid = false;
1033      bool userspace_reboot = false;
1034  
// 处理关机流程，设置  cmd = ANDROID_RB_POWEROFF
1035      if (cmd_params[0] == "shutdown") {
1036          cmd = ANDROID_RB_POWEROFF;
1037          if (cmd_params.size() >= 2) {
1038              if (cmd_params[1] == "userrequested") {
1039                  // The shutdown reason is PowerManager.SHUTDOWN_USER_REQUESTED.
1040                  // Run fsck once the file system is remounted in read-only mode.
// 也满足下列条件
1041                  run_fsck = true;
1042              } else if (cmd_params[1] == "thermal") {
1043                  // Turn off sources of heat immediately.
1044                  TurnOffBacklight();
1045                  // run_fsck is false to avoid delay
1046                  cmd = ANDROID_RB_THERMOFF;
1047              }
1048          }
// 处理重启逻辑
1049      } else if (cmd_params[0] == "reboot") {
1050          cmd = ANDROID_RB_RESTART2;
1051          if (cmd_params.size() >= 2) {
1052              reboot_target = cmd_params[1];
1053              if (reboot_target == "userspace") {
1054                  LOG(INFO) << "Userspace reboot requested";
1055                  userspace_reboot = true;
1056              }
1057              // adb reboot fastboot should boot into bootloader for devices not
1058              // supporting logical partitions.
1059              if (reboot_target == "fastboot" &&
1060                  !android::base::GetBoolProperty("ro.boot.dynamic_partitions", false)) {
1061                  reboot_target = "bootloader";
1062              }
1063              // When rebooting to the bootloader notify the bootloader writing
1064              // also the BCB.
1065              if (reboot_target == "bootloader") {
1066                  std::string err;
1067                  if (!write_reboot_bootloader(&err)) {
1068                      LOG(ERROR) << "reboot-bootloader: Error writing "
1069                                    "bootloader_message: "
1070                                 << err;
1071                  }
1072              } else if (reboot_target == "recovery") {
1073                  bootloader_message boot = {};
1074                  if (std::string err; !read_bootloader_message(&boot, &err)) {
1075                      LOG(ERROR) << "Failed to read bootloader message: " << err;
1076                  }
1077                  // Update the boot command field if it's empty, and preserve
1078                  // the other arguments in the bootloader message.
1079                  if (!CommandIsPresent(&boot)) {
1080                      strlcpy(boot.command, "boot-recovery", sizeof(boot.command));
1081                      if (std::string err; !write_bootloader_message(boot, &err)) {
1082                          LOG(ERROR) << "Failed to set bootloader message: " << err;
1083                          return;
1084                      }
1085                  }
1086              } else if (reboot_target == "quiescent") {
1087                  bootloader_message boot = {};
1088                  if (std::string err; !read_bootloader_message(&boot, &err)) {
1089                      LOG(ERROR) << "Failed to read bootloader message: " << err;
1090                  }
1091                  // Update the boot command field if it's empty, and preserve
1092                  // the other arguments in the bootloader message.
1093                  if (!CommandIsPresent(&boot)) {
1094                      strlcpy(boot.command, "boot-quiescent", sizeof(boot.command));
1095                      if (std::string err; !write_bootloader_message(boot, &err)) {
1096                          LOG(ERROR) << "Failed to set bootloader message: " << err;
1097                          return;
1098                      }
1099                  }
1100              } else if (reboot_target == "sideload" || reboot_target == "sideload-auto-reboot" ||
1101                         reboot_target == "fastboot") {
1102                  std::string arg = reboot_target == "sideload-auto-reboot" ? "sideload_auto_reboot"
1103                                                                            : reboot_target;
1104                  const std::vector<std::string> options = {
1105                          "--" + arg,
1106                  };
1107                  std::string err;
1108                  if (!write_bootloader_message(options, &err)) {
1109                      LOG(ERROR) << "Failed to set bootloader message: " << err;
1110                      return;
1111                  }
1112                  reboot_target = "recovery";
1113              }
1114  
1115              // If there are additional parameter, pass them along
1116              for (size_t i = 2; (cmd_params.size() > i) && cmd_params[i].size(); ++i) {
1117                  reboot_target += "," + cmd_params[i];
1118              }
1119          }
1120      } else {
1121          command_invalid = true;
1122      }
1123      if (command_invalid) {
1124          LOG(ERROR) << "powerctl: unrecognized command '" << command << "'";
1125          return;
1126      }
1127  
1128      // We do not want to process any messages (queue'ing triggers, shutdown messages, control
1129      // messages, etc) from properties during reboot.
// 设置accept_messages = false，init不会处理设置属性了
1130      StopSendingMessages();
1131  
1132      if (userspace_reboot) {
1133          HandleUserspaceReboot();
1134          return;
1135      }
1136  
// 会打印下列的log
1137      LOG(INFO) << "Clear action queue and start shutdown trigger";
// 先清除所有的event
1138      ActionManager::GetInstance().ClearQueue();
1139      // Queue shutdown trigger first
// 增加shutdown 事件
1140      ActionManager::GetInstance().QueueEventTrigger("shutdown");
1141      // Queue built-in shutdown_done
// 设置 关机方法作为回调方法 DoReboot
1142      auto shutdown_handler = [cmd, command, reboot_target, run_fsck](const BuiltinArguments&) {
// cmd= ANDROID_RB_POWEROFF；command为shutdown,userrequest;  reboot_target为空，run_fsck为true
1143          DoReboot(cmd, command, reboot_target, run_fsck);
1144          return Result<void>{};
1145      };
// 给 ActionManager 增加action 事件
1146      ActionManager::GetInstance().QueueBuiltinAction(shutdown_handler, "shutdown_done");
1147  
// 进入到关机模式
1148      EnterShutdown();
1149  }

// 进入到关机模式EnterShutdown

802  static void EnterShutdown() {
// 会打印下列的log
803      LOG(INFO) << "Entering shutdown mode";
// 设置 shutting_down = true，可以通过 IsShuttingDown() 获取到
804      shutting_down = true;
805      // Skip wait for prop if it is in progress
806      ResetWaitForProp();
807      // Clear EXEC flag if there is one pending
// 遍历所有的service
808      for (const auto& s : ServiceList::GetInstance()) {
809          s->UnSetExec();
810      }
811  }

/system/core/init/service.h

// 遍历所有的service，设置  is_exec_service_running_ = false
99      void UnSetExec() {
100          is_exec_service_running_ = false;
101          flags_ &= ~SVC_EXEC;
102      }110      static bool is_exec_service_running() { return is_exec_service_running_; }

// 给 ActionManager 增加action 事件

/system/core/init/action_manager.cpp

57  void ActionManager::QueueBuiltinAction(BuiltinFunction func, const std::string& name) {
58      auto lock = std::lock_guard{event_queue_lock_};
// 创建 Action 对象，设置 oneshot 为true
59      auto action = std::make_unique<Action>(true, nullptr, "<Builtin Action>", 0, name,
60                                             std::map<std::string, std::string>{});
// 增加命令AddCommand
61      action->AddCommand(std::move(func), {name}, 0);
62  
// 将 action 保存到 event_queue_ 和 actions_
63      event_queue_.emplace(action.get());
64      actions_.emplace_back(std::move(action));
65  }

// 创建 Action 对象

99  Action::Action(bool oneshot, Subcontext* subcontext, const std::string& filename, int line,
100                 const std::string& event_trigger,
101                 const std::map<std::string, std::string>& property_triggers)
102      : property_triggers_(property_triggers),
103        event_trigger_(event_trigger),
104        oneshot_(oneshot),
105        subcontext_(subcontext),
106        filename_(filename),
107        line_(line) {}

// 增加命令AddCommand

126  void Action::AddCommand(BuiltinFunction f, std::vector<std::string>&& args, int line) {
// 将回调函数保存到 commands_
127      commands_.emplace_back(std::move(f), false, std::move(args), line);
128  }

// 前面分析调用了 ResetWaitForPropLocked设置 MightBeWaiting为false；UnSetExec也设置了 is_exec_service_running为false
// 3-2）执行 action命令：ExecuteOneCommand

/system/core/init/action_manager.cpp

67  void ActionManager::ExecuteOneCommand() {
68      {
69          auto lock = std::lock_guard{event_queue_lock_};
70          // Loop through the event queue until we have an action to execute
71          while (current_executing_actions_.empty() && !event_queue_.empty()) {
// 遍历所有的 actions_，这里只有一个
// event_queue_.front() 为 event 参数：CheckEvent调用的是：Action::CheckEvent(const BuiltinAction& builtin_action)
72              for (const auto& action : actions_) {
73                  if (std::visit([&action](const auto& event) { return action->CheckEvent(event); },
74                                 event_queue_.front())) {
// 将 action 保存到 current_executing_actions_
75                      current_executing_actions_.emplace(action.get());
76                  }
77              }
78              event_queue_.pop();
79          }
80      }
81  
82      if (current_executing_actions_.empty()) {
83          return;
84      }
85  
86      auto action = current_executing_actions_.front();
87  
88      if (current_command_ == 0) {
// 会打印下列log
89          std::string trigger_name = action->BuildTriggersString();
90          LOG(INFO) << "processing action (" << trigger_name << ") from (" << action->filename()
91                    << ":" << action->line() << ")";
92      }
93  
// 执行 ExecuteOneCommand 方法
94      action->ExecuteOneCommand(current_command_);
95  
96      // If this was the last command in the current action, then remove
97      // the action from the executing list.
98      // If this action was oneshot, then also remove it from actions_.
99      ++current_command_;
100      if (current_command_ == action->NumCommands()) {
101          current_executing_actions_.pop();
102          current_command_ = 0;
// action 是 oneshot，执行完去移除它；重新设置 current_command_ = 0
103          if (action->oneshot()) {
104              auto eraser = [&action](std::unique_ptr<Action>& a) { return a.get() == action; };
105              actions_.erase(std::remove_if(actions_.begin(), actions_.end(), eraser),
106                             actions_.end());
107          }
108      }
109  }

// 执行 ExecuteOneCommand 方法

/system/core/init/action.cpp

146  void Action::ExecuteOneCommand(std::size_t command) const {
147      // We need a copy here since some Command execution may result in
148      // changing commands_ vector by importing .rc files through parser
149      Command cmd = commands_[command];
// 获取到第一个 command
150      ExecuteCommand(cmd);
151  }

159  void Action::ExecuteCommand(const Command& command) const {
160      android::base::Timer t;
// 回调 do_reboot 方法
161      auto result = command.InvokeFunc(subcontext_);
162      auto duration = t.duration();
163  
164      // Any action longer than 50ms will be warned to user as slow operation
165      if (!result.has_value() || duration > 50ms ||
166          android::base::GetMinimumLogSeverity() <= android::base::DEBUG) {
167          std::string trigger_name = BuildTriggersString();
168          std::string cmd_str = command.BuildCommandString();
169  
170          LOG(INFO) << "Command '" << cmd_str << "' action=" << trigger_name << " (" << filename_
171                    << ":" << command.line() << ") took " << duration.count() << "ms and "
172                    << (result.ok() ? "succeeded" : "failed: " + result.error().message());
173      }
174  }

// InvokeFunc 具体实现

31  Result<void> RunBuiltinFunction(const BuiltinFunction& function,
32                                  const std::vector<std::string>& args, const std::string& context) {
33      BuiltinArguments builtin_arguments{.context = context};
34  
35      builtin_arguments.args.resize(args.size());
36      builtin_arguments.args[0] = args[0];
37      for (std::size_t i = 1; i < args.size(); ++i) {
38          auto expanded_arg = ExpandProps(args[i]);
39          if (!expanded_arg.ok()) {
40              return expanded_arg.error();
41          }
42          builtin_arguments.args[i] = std::move(*expanded_arg);
43      }
44  
45      return function(builtin_arguments);
46  }
47  
48  Command::Command(BuiltinFunction f, bool execute_in_subcontext, std::vector<std::string>&& args,
49                   int line)
50      : func_(std::move(f)),
51        execute_in_subcontext_(execute_in_subcontext),
52        args_(std::move(args)),
53        line_(line) {}
54  
55  Result<void> Command::InvokeFunc(Subcontext* subcontext) const {
// subcontext 为空
56      if (subcontext) {
57          if (execute_in_subcontext_) {
58              return subcontext->Execute(args_);
59          }
60  
61          auto expanded_args = subcontext->ExpandArgs(args_);
62          if (!expanded_args.ok()) {
63              return expanded_args.error();
64          }
65          return RunBuiltinFunction(func_, *expanded_args, subcontext->context());
66      }
67  
68      return RunBuiltinFunction(func_, args_, kInitContext);
69  }

// 执行 DoReboot 方法

// cmd= ANDROID_RB_POWEROFF；command为shutdown,userrequest; reboot_target为空，run_fsck为true
1143 DoReboot(cmd, command, reboot_target, run_fsck);

/system/core/init/reboot.cpp

613  static void DoReboot(unsigned int cmd, const std::string& reason, const std::string& reboot_target,
614                       bool run_fsck) {
615      Timer t;
// 会打印下列的log
616      LOG(INFO) << "Reboot start, reason: " << reason << ", reboot_target: " << reboot_target;
617  
//cmd 是ANDROID_RB_POWEROFF
618      bool is_thermal_shutdown = cmd == ANDROID_RB_THERMOFF;
619  
620      auto shutdown_timeout = 0ms;
621      if (!SHUTDOWN_ZERO_TIMEOUT) {
// 默认的超时时间为 6 秒
622          constexpr unsigned int shutdown_timeout_default = 6;
623          constexpr unsigned int max_thermal_shutdown_timeout = 3;
// 没有
624          auto shutdown_timeout_final = android::base::GetUintProperty("ro.build.shutdown_timeout",
625                                                                       shutdown_timeout_default);
626          if (is_thermal_shutdown && shutdown_timeout_final > max_thermal_shutdown_timeout) {
627              shutdown_timeout_final = max_thermal_shutdown_timeout;
628          }
629          shutdown_timeout = std::chrono::seconds(shutdown_timeout_final);
630      }
// 会打印下列的log
631      LOG(INFO) << "Shutdown timeout: " << shutdown_timeout.count() << " ms";
632  
633      sem_t reboot_semaphore;
634      if (sem_init(&reboot_semaphore, false, 0) == -1) {
635          // These should never fail, but if they do, skip the graceful reboot and reboot immediately.
636          LOG(ERROR) << "sem_init() fail and RebootSystem() return!";
637          RebootSystem(cmd, reboot_target, reason);
638      }
639  
640      // Start a thread to monitor init shutdown process
641      LOG(INFO) << "Create reboot monitor thread.";
642      bool reboot_monitor_run = true;
// 3-2-1）创建reboot 的监控的线程 RebootMonitorThread
643      std::thread reboot_monitor_thread(&RebootMonitorThread, cmd, reboot_target, &reboot_semaphore,
644                                        shutdown_timeout, &reboot_monitor_run);
645      reboot_monitor_thread.detach();
646  
647      // Start reboot monitor thread
648      sem_post(&reboot_semaphore);
649  
650      // Ensure last reboot reason is reduced to canonical
651      // alias reported in bootloader or system boot reason.
652      size_t skip = 0;
653      std::vector<std::string> reasons = Split(reason, ",");
654      if (reasons.size() >= 2 && reasons[0] == "reboot" &&
655          (reasons[1] == "recovery" || reasons[1] == "bootloader" || reasons[1] == "cold" ||
656           reasons[1] == "hard" || reasons[1] == "warm")) {
657          skip = strlen("reboot,");
658      }
// 3-2-2）序列化关机或者重启的原因：PersistRebootReason
659      PersistRebootReason(reason.c_str() + skip, true);
660  
661      // If /data isn't mounted then we can skip the extra reboot steps below, since we don't need to
662      // worry about unmounting it.
663      if (!IsDataMounted("*")) {
664          sync();
665          RebootSystem(cmd, reboot_target, reason);
666          abort();
667      }
668  
// 是否显示关机动画，这里不去显示
669      bool do_shutdown_animation = GetBoolProperty("ro.init.shutdown_animation", false);
670      // watchdogd is a vendor specific component but should be alive to complete shutdown safely.
671      const std::set<std::string> to_starts{"watchdogd"};
672      std::set<std::string> stop_first;
// 遍历所有的service
673      for (const auto& s : ServiceList::GetInstance()) {
// kDebuggingServices为 {"tombstoned", "logd", "adbd", "console"}
674          if (kDebuggingServices.count(s->name())) {
675              // keep debugging tools until non critical ones are all gone.
676              s->SetShutdownCritical();
// to_starts为 watchdogd，走启动 watchdogd进程的
677          } else if (to_starts.count(s->name())) {
678              if (auto result = s->Start(); !result.ok()) {
679                  LOG(ERROR) << "Could not start shutdown 'to_start' service '" << s->name()
680                             << "': " << result.error();
681              }
682              s->SetShutdownCritical();
683          } else if (do_shutdown_animation) {
684              continue;
685          } else if (s->IsShutdownCritical()) {
686              // Start shutdown critical service if not started.
687              if (auto result = s->Start(); !result.ok()) {
688                  LOG(ERROR) << "Could not start shutdown critical service '" << s->name()
689                             << "': " << result.error();
690              }
691          } else {
//  将不是上述的service，增加到 stop_first
692              stop_first.insert(s->name());
693          }
694      }
695  
// 如果没有关机动画，则取关闭背光
697      if (!do_shutdown_animation && (cmd == ANDROID_RB_POWEROFF || is_thermal_shutdown)) {
// 3-2-3）关闭背光：TurnOffBacklight
698          TurnOffBacklight();
699      }
700  
701      Service* boot_anim = ServiceList::GetInstance().FindService("bootanim");
702      Service* surface_flinger = ServiceList::GetInstance().FindService("surfaceflinger");
703      if (boot_anim != nullptr && surface_flinger != nullptr && surface_flinger->IsRunning()) {
704  
// 不启动bootanim 
705          if (do_shutdown_animation) {
。。。
730      }
731  
732      // optional shutdown step
733      // 1. terminate all services except shutdown critical ones. wait for delay to finish
734      if (shutdown_timeout > 0ms) {
// 3-2-4）发送signal15去中止进程StopServicesAndLogViolations
735          StopServicesAndLogViolations(stop_first, shutdown_timeout / 2, true /* SIGTERM */);
736      }
737      // Send SIGKILL to ones that didn't terminate cleanly.
// 发送sigkill ，kill没有被terminate 的进程
738      StopServicesAndLogViolations(stop_first, 0ms, false /* SIGKILL */);
739      SubcontextTerminate();
740      // Reap subcontext pids.
741      ReapAnyOutstandingChildren();
742  
743      // 3. send volume abort_fuse and volume shutdown to vold
// 对vold 进程的处理
744      Service* vold_service = ServiceList::GetInstance().FindService("vold");
745      if (vold_service != nullptr && vold_service->IsRunning()) {
746          // Manually abort FUSE connections, since the FUSE daemon is already dead
747          // at this point, and unmounting it might hang.
748          CallVdc("volume", "abort_fuse");
749          CallVdc("volume", "shutdown");
750          vold_service->Stop();
751      } else {
752          LOG(INFO) << "vold not running, skipping vold shutdown";
753      }
754      // logcat stopped here
// 杀掉 {"tombstoned", "logd", "adbd", "console"} 进程
755      StopServices(kDebuggingServices, 0ms, false /* SIGKILL */);
756      // 4. sync, try umount, and optionally run fsck for user shutdown
757      {
758          Timer sync_timer;
759          LOG(INFO) << "sync() before umount...";
//sync 用于强制被改变的内容立刻写入磁盘，更新超块信息。
760          sync();
761          LOG(INFO) << "sync() before umount took" << sync_timer;
762      }
763      // 5. drop caches and disable zram backing device, if exist
// 处理zram
764      KillZramBackingDevice();
765  
// 会打印处理了多久
766      LOG(INFO) << "Ready to unmount apexes. So far shutdown sequence took " << t;
767      // 6. unmount active apexes, otherwise they might prevent clean unmount of /data.
768      if (auto ret = UnmountAllApexes(); !ret.ok()) {
769          LOG(ERROR) << ret.error();
770      }
771      UmountStat stat =
772              TryUmountAndFsck(cmd, run_fsck, shutdown_timeout - t.duration(), &reboot_semaphore);
773      // Follow what linux shutdown is doing: one more sync with little bit delay
774      {
775          Timer sync_timer;
776          LOG(INFO) << "sync() after umount...";
777          sync();
778          LOG(INFO) << "sync() after umount took" << sync_timer;
779      }
780      if (!is_thermal_shutdown) std::this_thread::sleep_for(100ms);
//  会打印init从收到关机命令到现在的时间powerctl_shutdown_time_ms:11559:0
781      LogShutdownTime(stat, &t);
782  
783      // Send signal to terminate reboot monitor thread.
784      reboot_monitor_run = false;
785      sem_post(&reboot_semaphore);
786  
787      // Reboot regardless of umount status. If umount fails, fsck after reboot will fix it.
788      if (IsDataMounted("f2fs")) {
789          uint32_t flag = F2FS_GOING_DOWN_FULLSYNC;
790          unique_fd fd(TEMP_FAILURE_RETRY(open("/data", O_RDONLY)));
791          int ret = ioctl(fd.get(), F2FS_IOC_SHUTDOWN, &flag);
792          if (ret) {
793              PLOG(ERROR) << "Shutdown /data: ";
794          } else {
795              LOG(INFO) << "Shutdown /data";
796          }
797      }
// 3-2-5）重启系统：RebootSystem
798      RebootSystem(cmd, reboot_target, reason);
// 主动退出init进程
799      abort();
800  }

// 3-2-1）创建reboot 的监控的线程 RebootMonitorThread

322  // Create reboot/shutdwon monitor thread
323  void RebootMonitorThread(unsigned int cmd, const std::string& reboot_target,
324                           sem_t* reboot_semaphore, std::chrono::milliseconds shutdown_timeout,
325                           bool* reboot_monitor_run) {
326      unsigned int remaining_shutdown_time = 0;
327  
328      // 300 seconds more than the timeout passed to the thread as there is a final Umount pass
329      // after the timeout is reached.
330      constexpr unsigned int shutdown_watchdog_timeout_default = 300;
331      auto shutdown_watchdog_timeout = android::base::GetUintProperty(
332              "ro.build.shutdown.watchdog.timeout", shutdown_watchdog_timeout_default);
// 为 306 秒，给关机的超时时间为 306秒
333      remaining_shutdown_time = shutdown_watchdog_timeout + shutdown_timeout.count() / 1000;
334  
335      while (*reboot_monitor_run == true) {
336          if (TEMP_FAILURE_RETRY(sem_wait(reboot_semaphore)) == -1) {
337              LOG(ERROR) << "sem_wait failed and exit RebootMonitorThread()";
338              return;
339          }
340  
341          timespec shutdown_timeout_timespec;
342          if (clock_gettime(CLOCK_MONOTONIC, &shutdown_timeout_timespec) == -1) {
343              LOG(ERROR) << "clock_gettime() fail! exit RebootMonitorThread()";
344              return;
345          }
346  
347          // If there are some remaining shutdown time left from previous round, we use
348          // remaining time here.
349          shutdown_timeout_timespec.tv_sec += remaining_shutdown_time;
350  
// 会 打印 超时的kernel 时间
351          LOG(INFO) << "shutdown_timeout_timespec.tv_sec: " << shutdown_timeout_timespec.tv_sec;
352  
353          int sem_return = 0;
354          while ((sem_return = sem_timedwait_monotonic_np(reboot_semaphore,
355                                                          &shutdown_timeout_timespec)) == -1 &&
356                 errno == EINTR) {
357          }
358  
// 为-1 则是超时了
359          if (sem_return == -1) {
360              LOG(ERROR) << "Reboot thread timed out";
361  
362              if (android::base::GetBoolProperty("ro.debuggable", false) == true) {
363                  if (false) {
364                      // SEPolicy will block debuggerd from running and this is intentional.
365                      // But these lines are left to be enabled during debugging.
366                      LOG(INFO) << "Try to dump init process call trace:";
367                      const char* vdc_argv[] = {"/system/bin/debuggerd", "-b", "1"};
368                      int status;
369                      logwrap_fork_execvp(arraysize(vdc_argv), vdc_argv, &status, false, LOG_KLOG,
370                                          true, nullptr);
371                  }
// 收集 CPU 等信息
372                  LOG(INFO) << "Show stack for all active CPU:";
373                  WriteStringToFile("l", PROC_SYSRQ);
374  
375                  LOG(INFO) << "Show tasks that are in disk sleep(uninterruptable sleep), which are "
376                               "like "
377                               "blocked in mutex or hardware register access:";
378                  WriteStringToFile("w", PROC_SYSRQ);
379              }
380  
381              // In shutdown case,notify kernel to sync and umount fs to read-only before shutdown.
382              if (cmd == ANDROID_RB_POWEROFF || cmd == ANDROID_RB_THERMOFF) {
383                  WriteStringToFile("s", PROC_SYSRQ);
384  
385                  WriteStringToFile("u", PROC_SYSRQ);
386  
387                  RebootSystem(cmd, reboot_target);
388              }
389  
390              LOG(ERROR) << "Trigger crash at last!";
391              WriteStringToFile("c", PROC_SYSRQ);
392          } else {
393              timespec current_time_timespec;
394  
395              if (clock_gettime(CLOCK_MONOTONIC, &current_time_timespec) == -1) {
396                  LOG(ERROR) << "clock_gettime() fail! exit RebootMonitorThread()";
397                  return;
398              }
399  
// 还有多少时间剩余
400              remaining_shutdown_time =
401                      shutdown_timeout_timespec.tv_sec - current_time_timespec.tv_sec;
402  
403              LOG(INFO) << "remaining_shutdown_time: " << remaining_shutdown_time;
404          }
405      }
406  }

// 3-2-2）序列化关机或者重启的原因：PersistRebootReason

100  static void PersistRebootReason(const char* reason, bool write_to_property) {
101      if (write_to_property) {
102          SetProperty(LAST_REBOOT_REASON_PROPERTY, reason);
103      }
// "/metadata/bootstat/"
104      auto fd = unique_fd(TEMP_FAILURE_RETRY(open(
105              LAST_REBOOT_REASON_FILE, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_BINARY, 0666)));
106      if (!fd.ok()) {
107          PLOG(ERROR) << "Could not open '" << LAST_REBOOT_REASON_FILE
108                      << "' to persist reboot reason";
109          return;
110      }
111      WriteStringToFd(reason, fd);
112      fsync(fd.get());
113  }

// 3-2-3）关闭背光：TurnOffBacklight

192  // Turn off backlight while we are performing power down cleanup activities.
193  static void TurnOffBacklight() {
194      Service* service = ServiceList::GetInstance().FindService("blank_screen");
195      if (service == nullptr) {
196          LOG(WARNING) << "cannot find blank_screen in TurnOffBacklight";
197          return;
198      }
199      if (auto result = service->Start(); !result.ok()) {
200          LOG(WARNING) << "Could not start blank_screen service: " << result.error();
201      }
202  }

// 3-2-4）发送signal15去中止进程StopServicesAndLogViolations

575  int StopServicesAndLogViolations(const std::set<std::string>& services,
576                                   std::chrono::milliseconds timeout, bool terminate) {
577      StopServices(services, timeout, terminate);
578      int still_running = 0;
579      for (const auto& s : ServiceList::GetInstance()) {
580          if (s->IsRunning() && services.count(s->name())) {
581              LOG(ERROR) << "[service-misbehaving] : service '" << s->name() << "' is still running "
582                         << timeout.count() << "ms after receiving "
583                         << (terminate ? "SIGTERM" : "SIGKILL");
584              still_running++;
585          }
586      }
587      return still_running;
588  }

546  static void StopServices(const std::set<std::string>& services, std::chrono::milliseconds timeout,
547                           bool terminate) {
//  会打印下列log
548      LOG(INFO) << "Stopping " << services.size() << " services by sending "
549                << (terminate ? "SIGTERM" : "SIGKILL");
550      std::vector<pid_t> pids;
551      pids.reserve(services.size());
552      for (const auto& s : ServiceList::GetInstance().services_in_shutdown_order()) {
553          if (services.count(s->name()) == 0) {
554              continue;
555          }
556          if (s->pid() > 0) {
557              pids.push_back(s->pid());
558          }
559          if (terminate) {
// 调用 Terminate 方法
560              s->Terminate();
561          } else {
562              s->Stop();
563          }
564      }
565      if (timeout > 0ms) {
566          WaitToBeReaped(pids, timeout);
567      } else {
568          // Even if we don't to wait for services to stop, we still optimistically reap zombies.
569          ReapAnyOutstandingChildren();
570      }
571  }
572

// 3-2-5）重启系统：RebootSystem

/system/core/init/reboot_utils.cpp

109  void __attribute__((noreturn))
110  RebootSystem(unsigned int cmd, const std::string& rebootTarget, const std::string& reboot_reason) {
// 会打印下列的log
111      LOG(INFO) << "Reboot ending, jumping to kernel";
112  
113      if (!IsRebootCapable()) {
114          // On systems where init does not have the capability of rebooting the
115          // device, just exit cleanly.
116          exit(0);
117      }
118  
119      switch (cmd) {
// 关机会走reboot(RB_POWER_OFF)
120          case ANDROID_RB_POWEROFF:
121              reboot(RB_POWER_OFF);
122              break;
123  
// 重启
124          case ANDROID_RB_RESTART2:
125              syscall(__NR_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
126                      LINUX_REBOOT_CMD_RESTART2, rebootTarget.c_str());
127              break;
128  
129          case ANDROID_RB_THERMOFF:
130              if (android::base::GetBoolProperty("ro.thermal_warmreset", false)) {
131                  std::string reason = "shutdown,thermal";
132                  if (!reboot_reason.empty()) reason = reboot_reason;
133  
134                  LOG(INFO) << "Try to trigger a warm reset for thermal shutdown";
135                  syscall(__NR_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
136                          LINUX_REBOOT_CMD_RESTART2, reason.c_str());
137              } else {
138                  reboot(RB_POWER_OFF);
139              }
140              break;
141      }
142      // In normal case, reboot should not return.
143      PLOG(ERROR) << "reboot call returned";
144      abort();
145  }

安卓关机和重启源码流程

// systemui关机 frameworks/base/packages/SystemUI/src/com/android/systemui/globalactions/GlobalActionsComponent.java Overridepublic void shutdown() {try {mBarService.shutdown();} catch (RemoteException e) {}}frameworks/base/services/core/java/com/android…...

编程日记 2025/9/10 1:02:16

相关文章：