update_engine-整体结构(二)

在update_engine-整体结构(一)中分析UpdateEngineDaemon::OnInit()的整体情况。下面先分析在该方法中涉及的DaemonStateAndroid和BinderUpdateEngineAndroidService。

DaemonStateAndroid

它的继承关系为

aemonStateInterface中的成员函数都是纯虚函数，在这种情况中可以认为和java中的接口一样，所以在这里使用的是实现的关系，同时也只列出了较为重要的方法。UpdateEngineDaemon的OnInit()方法中调用了DaemonStateAndroid的Initialize()方法，那么这个方法都干了些什么呢？

src/system/update_engine/daemon_state_android.cc

 bool DaemonStateAndroid::Initialize() {
   boot_control_ = boot_control::CreateBootControl();                     //创建BootControl
   if (!boot_control_) {
     LOG(WARNING) << "Unable to create BootControl instance, using stub "
                  << "instead. All update attempts will fail.";
     boot_control_.reset(new BootControlStub());
   }

   hardware_ = hardware::CreateHardware();                               //创建hardware
   if (!hardware_) {
     LOG(ERROR) << "Error intializing the HardwareInterface.";
     return false;
   }

   LOG_IF(INFO, !hardware_->IsNormalBootMode()) << "Booted in dev mode.";
   LOG_IF(INFO, !hardware_->IsOfficialBuild()) << "Booted non-official build.";

   // Initialize prefs.
   base::FilePath non_volatile_path;
   // TODO(deymo): Fall back to in-memory prefs if there's no physical directory
   // available.
   if (!hardware_->GetNonVolatileDirectory(&non_volatile_path)) {
     LOG(ERROR) << "Failed to get a non-volatile directory.";
     return false;
   }
   Prefs* prefs = new Prefs();                                       //创建Prefs
   prefs_.reset(prefs);
   if (!prefs->Init(non_volatile_path.Append(kPrefsSubDirectory))) {
     LOG(ERROR) << "Failed to initialize preferences.";
     return false;
   }

   // The CertificateChecker singleton is used by the update attempter.
   certificate_checker_.reset(
       new CertificateChecker(prefs_.get(), &openssl_wrapper_));     //设置certificateChecker
   certificate_checker_->Init();

   // Initialize the UpdateAttempter before the UpdateManager.
   update_attempter_.reset(new UpdateAttempterAndroid(              //设置UpdateAttempterAndroid
       this, prefs_.get(), boot_control_.get(), hardware_.get()));

   return true;
 }

可以看到初始化了boot_control_,hardware_,ceritficate_checker_,update_attempter_。boot_control_,hardware_,主要实现对slot等底层的操作（在A/B升级中，会存在双系统A和B,可以将A和B称为slot）而update_attempter_其实是A/B升级的核心操作。在UpdateEngineDaemon的OnInit()中的daemon_state->StartUpdater(),最终调用的其实是update_attempter_->Init()

 bool DaemonStateAndroid::StartUpdater() {
   // The DaemonState in Android is a passive daemon. It will only start applying
   // an update when instructed to do so from the exposed binder API.
   update_attempter_->Init();
   return true;
 }

其实DaemonStateAndroid只进行了一个初始化的工作后，就把其他的工作交给了UpdateAttempterAndroid。DaemonStateAndroid到此就算分析完成了。下面认识UpdateAttempterAndroid。

UpdateAttempterAndroid

它的继承关系为

从它的结构就可以看出这个类的重要性了，在画类图的时候省略了函数的参数，已经成员函数只是部分出现。这个类图只是为了帮助理清类的结构。其实这几个接口都是回调接口，他们的函数都是在程序的运行过程中充当回调的角色。UpdateAttempterAndroid通过Init()来开始接管升级的主要流程,内容为:

 src/system/update_engine/update_attempter_android.cc

 void UpdateAttempterAndroid::Init() {
   // In case of update_engine restart without a reboot we need to restore the
   // reboot needed state.
   if (UpdateCompletedOnThisBoot())
     SetStatusAndNotify(UpdateStatus::UPDATED_NEED_REBOOT);
   else
     SetStatusAndNotify(UpdateStatus::IDLE);
 }

在这个方法中首先判断是否已经升级完成了但是没有重启，如果是那么就会发出重启的消息，否则就会发出空闲的请求。在来看SetStatusAndNotify这个方法

SetStatusAndNotify

  void UpdateAttempterAndroid::SetStatusAndNotify(UpdateStatus status) {
    status_ = status;
    size_t payload_size =
        install_plan_.payloads.empty() ?  : install_plan_.payloads[].size;
    for (auto observer : daemon_state_->service_observers()) {
      observer->SendStatusUpdate(
          , download_progress_, status_, "", payload_size);
    }
    last_notify_time_ = TimeTicks::Now();
 }

在这个方法中首先会获取payload(升级包中的payload.bin文件)的大小，之后遍历binder观察者的集合，将更新的情况发送出去，从而通知客户端（使用update_engine服务的）。最后更新通知时间。关于install_plan是一个比较重要的结构体，在后面的叙述中会对其进行描述，现在只需知道它是代表升级包的一个数据结构便可。再看来BinderUpdateEngineAndroidService。

BinderUpdateEngineAndroidService

它的继承结构为

BinderUpdateEngineAndroidService代表了服务端的binder(BnBinder)可以和客户端的(BpBinder)进行通信。关于Binder的通信原理就不多做说明了。下面是BinderUpdateEngineAndroidService中部分方法的说明。

src/system/update_engine/binder_service_brillo.cc

  Status BinderUpdateEngineAndroidService::bind(
      const android::sp<IUpdateEngineCallback>& callback, bool* return_value) {
    callbacks_.emplace_back(callback);

    const android::sp<IBinder>& callback_binder =
        IUpdateEngineCallback::asBinder(callback);
    auto binder_wrapper = android::BinderWrapper::Get();
    binder_wrapper->RegisterForDeathNotifications(
        callback_binder,
       base::Bind(
           base::IgnoreResult(&BinderUpdateEngineAndroidService::UnbindCallback),
           base::Unretained(this),
           base::Unretained(callback_binder.get())));

   // Send an status update on connection (except when no update sent so far),
   // since the status update is oneway and we don't need to wait for the
   // response.
   if (last_status_ != -)
     callback->onStatusUpdate(last_status_, last_progress_);

   *return_value = true;
   return Status::ok();
 }

 void BinderUpdateEngineAndroidService::SendStatusUpdate(
     int64_t /* last_checked_time */,
     double progress,
     update_engine::UpdateStatus status,
     const std::string& /* new_version  */,
     int64_t /* new_size */) {
   last_status_ = static_cast<int>(status);
   last_progress_ = progress;
   for (auto& callback : callbacks_) {
     callback->onStatusUpdate(last_status_, last_progress_);
   }
 }

 Status BinderUpdateEngineAndroidService::unbind(
     const android::sp<IUpdateEngineCallback>& callback, bool* return_value) {
   const android::sp<IBinder>& callback_binder =
       IUpdateEngineCallback::asBinder(callback);
   auto binder_wrapper = android::BinderWrapper::Get();
   binder_wrapper->UnregisterForDeathNotifications(callback_binder);

   *return_value = UnbindCallback(callback_binder.get());
   return Status::ok();
 }

 Status BinderUpdateEngineAndroidService::applyPayload(
     const android::String16& url,
     int64_t payload_offset,
     int64_t payload_size,
     const std::vector<android::String16>& header_kv_pairs) {
   const std::string payload_url{android::String8{url}.string()};
   std::vector<std::string> str_headers;
   str_headers.reserve(header_kv_pairs.size());
   for (const auto& header : header_kv_pairs) {
     str_headers.emplace_back(android::String8{header}.string());
   }

   brillo::ErrorPtr error;
   if (!service_delegate_->ApplyPayload(
           payload_url, payload_offset, payload_size, str_headers, &error)) {
     return ErrorPtrToStatus(error);
   }
   return Status::ok();
 }

当某一个客户端要使用update_engine提供的服务时，首先会通过bind(...)来获取到客户端传过来的IUpdateEngineCallback回调接口，之后获取代表客户端的callback_binder_。之后就可以根据IUpdateEngineCallback，来通知客户端更新的状态和更新是否完成。applyPayload(..)是A/B更新的入口,在这个方法中最终会调用service_delegate_->ApplyPayload(...),service_delegate_其实就是DaemonAttempterAndroid，在这个时候就把更新的工作移交给了DaemonStateAndroid。在上面的分析中涉及到了IUpdateEngine和IUpdateEngineCallback,下面是他们的源码

out/target/product/xxx/obj/STATIC_LIBRARIES/libupdate_engine_android_intermediates/aidl-generated/include/android/os/IUpdateEngine.h

  namespace android {

  namespace os {

  class IUpdateEngine : public ::android::IInterface {
  public:
  DECLARE_META_INTERFACE(UpdateEngine)
  virtual ::android::binder::Status applyPayload(const ::android::String16& url, int64_t payload_offset, int64_t payload_size, const ::std::vector<::android::String16>& headerKeyValuePairs) = ;
  virtual ::android::binder::Status bind(const ::android::sp<::android::os::IUpdateEngineCallback>& callback, bool* _aidl_return) = ;
 virtual ::android::binder::Status unbind(const ::android::sp<::android::os::IUpdateEngineCallback>& callback, bool* _aidl_return) = ;
 virtual ::android::binder::Status suspend() = ;
 virtual ::android::binder::Status resume() = ;
 virtual ::android::binder::Status cancel() = ;
 virtual ::android::binder::Status resetStatus() = ;
 enum Call {
   APPLYPAYLOAD = ::android::IBinder::FIRST_CALL_TRANSACTION + ,
   BIND = ::android::IBinder::FIRST_CALL_TRANSACTION + ,
   UNBIND = ::android::IBinder::FIRST_CALL_TRANSACTION + ,
   SUSPEND = ::android::IBinder::FIRST_CALL_TRANSACTION + ,
   RESUME = ::android::IBinder::FIRST_CALL_TRANSACTION + ,
   CANCEL = ::android::IBinder::FIRST_CALL_TRANSACTION + ,
   RESETSTATUS = ::android::IBinder::FIRST_CALL_TRANSACTION + ,
 };
 };  // class IUpdateEngine

 }  // namespace os

 }  // namespace android

 #endif  // AIDL_GENERATED_ANDROID_OS_I_UPDATE_ENGINE_H_

out/target/product/qcs605/obj/STATIC_LIBRARIES/libupdate_engine_android_intermediates/aidl-generated/include/android/os/IUpdateEngineCallback.h

  namespace android {

  namespace os {

  class IUpdateEngineCallback : public ::android::IInterface {
  public:
  DECLARE_META_INTERFACE(UpdateEngineCallback)
  virtual ::android::binder::Status onStatusUpdate(int32_t status_code, float percentage) = ;
  virtual ::android::binder::Status onPayloadApplicationComplete(int32_t error_code) = ;
 enum Call {
   ONSTATUSUPDATE = ::android::IBinder::FIRST_CALL_TRANSACTION + ,
   ONPAYLOADAPPLICATIONCOMPLETE = ::android::IBinder::FIRST_CALL_TRANSACTION + ,
 };
 };  // class IUpdateEngineCallback

 }  // namespace os

 }  

接下来接着看service_delegate_->ApplyPayload(...)

 src/update_engine/update_attempter_android.cc

   bool UpdateAttempterAndroid::ApplyPayload(
       const string& payload_url,
       int64_t payload_offset,
       int64_t payload_size,
       const vector<string>& key_value_pair_headers,
       brillo::ErrorPtr* error) {
     if (status_ == UpdateStatus::UPDATED_NEED_REBOOT) {          //检查是否已经更新完成，需要重新启动
       return LogAndSetError(
           error, FROM_HERE, "An update already applied, waiting for reboot");
    }
    if (ongoing_update_) {                                       //检查是否正在更新
      return LogAndSetError(
          error, FROM_HERE, "Already processing an update, cancel it first.");
    }
    DCHECK(status_ == UpdateStatus::IDLE);                       //检查当前是否为空闲状态

    std::map<string, string> headers;
    for (const string& key_value_pair : key_value_pair_headers) {
      string key;
      string value;
      if (!brillo::string_utils::SplitAtFirst(
              key_value_pair, "=", &key, &value, false)) {
        return LogAndSetError(
            error, FROM_HERE, "Passed invalid header: " + key_value_pair);
      }
      if (!headers.emplace(key, value).second)
        return LogAndSetError(error, FROM_HERE, "Passed repeated key: " + key);      //将传递进来的key-value保存到headers中
    }

    // Unique identifier for the payload. An empty string means that the payload
    // can't be resumed.
    string payload_id = (headers[kPayloadPropertyFileHash] +
                         headers[kPayloadPropertyMetadataHash]);                     //根据Payload的hash和元数据的hash计算一个payload_id

    // Setup the InstallPlan based on the request.
    install_plan_ = InstallPlan();                                                   //创建一个InstallPlan

    install_plan_.download_url = payload_url;
    install_plan_.version = "";
    base_offset_ = payload_offset;
    InstallPlan::Payload payload;
    payload.size = payload_size;
    if (!payload.size) {
      if (!base::StringToUint64(headers[kPayloadPropertyFileSize],
                                &payload.size)) {
        payload.size = ;
      }
    }
    if (!brillo::data_encoding::Base64Decode(headers[kPayloadPropertyFileHash],
                                             &payload.hash)) {
      LOG(WARNING) << "Unable to decode base64 file hash: "
                   << headers[kPayloadPropertyFileHash];
    }
    if (!base::StringToUint64(headers[kPayloadPropertyMetadataSize],
                              &payload.metadata_size)) {
      payload.metadata_size = ;
    }
    // The |payload.type| is not used anymore since minor_version 3.
    payload.type = InstallPayloadType::kUnknown;
    install_plan_.payloads.push_back(payload);                          //为payload赋值完成后，将其放入到集合中，因为ApplyPayload可能被多次调用，会有多个payload

    // The |public_key_rsa| key would override the public key stored on disk.
    install_plan_.public_key_rsa = "";

    install_plan_.hash_checks_mandatory = hardware_->IsOfficialBuild();  //是否进行强制性的hash验证，如果为user版则为true,如果为userdebug则为false
    install_plan_.is_resume = !payload_id.empty() &&
                              DeltaPerformer::CanResumeUpdate(prefs_, payload_id);  //是否接着上次未更新完的继续更新
    if (!install_plan_.is_resume) {                                                 //如果从头开始更新
      if (!DeltaPerformer::ResetUpdateProgress(prefs_, false)) {                    //重置更新进度
        LOG(WARNING) << "Unable to reset the update progress.";
      }
      if (!prefs_->SetString(kPrefsUpdateCheckResponseHash, payload_id)) {           //保存payload_id
        LOG(WARNING) << "Unable to save the update check response hash.";
      }
    }
    install_plan_.source_slot = boot_control_->GetCurrentSlot();                //当前正在运行的slot
    install_plan_.target_slot = install_plan_.source_slot ==  ?  : ;         //备用的也就是将要升级的slot

    int data_wipe = ;                                                          //是否进行数据擦除，也就是恢复出厂设置，在做升级包时可以指定该值 -w
    install_plan_.powerwash_required =
        base::StringToInt(headers[kPayloadPropertyPowerwash], &data_wipe) &&
        data_wipe != ;

    NetworkId network_id = kDefaultNetworkId;                                     //NetworkId没有使用过，估计和流式更新相关。
    if (!headers[kPayloadPropertyNetworkId].empty()) {
      if (!base::StringToUint64(headers[kPayloadPropertyNetworkId],
                                &network_id)) {
        return LogAndSetError(
            error,
            FROM_HERE,
            "Invalid network_id: " + headers[kPayloadPropertyNetworkId]);
      }
      if (!network_selector_->SetProcessNetwork(network_id)) {
        return LogAndSetError(
            error,
            FROM_HERE,
            "Unable to set network_id: " + headers[kPayloadPropertyNetworkId]);
      }
    }

   LOG(INFO) << "Using this install plan:";
   install_plan_.Dump();

   BuildUpdateActions(payload_url);        //创建Action,这一架构可以说是更新的主要架构
   // Setup extra headers.
   HttpFetcher* fetcher = download_action_->http_fetcher();
   if (!headers[kPayloadPropertyAuthorization].empty())
     fetcher->SetHeader("Authorization", headers[kPayloadPropertyAuthorization]);
   if (!headers[kPayloadPropertyUserAgent].empty())
     fetcher->SetHeader("User-Agent", headers[kPayloadPropertyUserAgent]);

   SetStatusAndNotify(UpdateStatus::UPDATE_AVAILABLE);
   ongoing_update_ = true;                 //表式正在更新

   // Just in case we didn't update boot flags yet, make sure they're updated
   // before any update processing starts. This will start the update process.
   UpdateBootFlags();                      //修改bootFlags并且开始执行Action
   return true;
 }

从整体上看ApplyPayload主要进行了两个工作首先是初始化payload,之后将具体的升级流程交给了一系列的Action。先看第一部分，要想了解初始化的一些细节，首先应该知道，一个升级包中都包含了些什么。下面以差分包为例，将一个差分包解压后会得到下面的几个文件。

升级包的基本结构

├── care_map.txt                    #基本上用不到
├── compatibility.zip                #基本上用不到
├── META-INF
│   └── com
│           └── android
│              ├── metadata           #基本上用不到
│              └── otacert               #基本上用不到
├── payload.bin                        #主要的升级文件
└── payload_properties.txt       #升级文件附带的属性

payload_properties.txt文件的内容大致为：

 FILE_HASH=4kYpprUJyMwW8NNV25v0ovMWV11PPijNANQwHy0oZwc=
 FILE_SIZE=
 METADATA_HASH=l2ih2Xam7jqAQYhr9SRdVddG9NPeenaWzTEd+DHct+o=
 METADATA_SIZE=

接下来再看一下InstallPlan这个数据结构

InstallPlan数据结构

   namespace chromeos_update_engine {

   enum class InstallPayloadType {    //升级包的类型
     kUnknown,                         //未知
     kFull,                             //全包
     kDelta,                            //差分包
   };

   std::string InstallPayloadTypeToString(InstallPayloadType type);

  struct InstallPlan {
    InstallPlan() = default;

    bool operator==(const InstallPlan& that) const;
    bool operator!=(const InstallPlan& that) const;

    void Dump() const;

    // Load the |source_path| and |target_path| of all |partitions| based on the
    // |source_slot| and |target_slot| if available. Returns whether it succeeded
    // to load all the partitions for the valid slots.
    bool LoadPartitionsFromSlots(BootControlInterface* boot_control);      //获取source_slot和target_slot中的分区path

    bool is_resume{false};                                                 // 是否未更新完成需要恢复更新
    std::string download_url;  // url to download from                      升级文件的url
    std::string version;       // version we are installing.                版本号

    struct Payload {
      uint64_t size = ;               // size of the payload              payload.bin的大小
      uint64_t metadata_size = ;      // size of the metadata             元数据的大小
      std::string metadata_signature;  // signature of the metadata in base64   元数据的签名
      brillo::Blob hash;               // SHA256 hash of the payload        payload.bin的hash
      InstallPayloadType type{InstallPayloadType::kUnknown};                //升级包的类型
      // Only download manifest and fill in partitions in install plan without
      // apply the payload if true. Will be set by DownloadAction when resuming
      // multi-payload.
      bool already_applied = false;                                        //升级包是否已经被应用

      bool operator==(const Payload& that) const {
        return size == that.size && metadata_size == that.metadata_size &&
               metadata_signature == that.metadata_signature &&
               hash == that.hash && type == that.type &&
               already_applied == that.already_applied;
      }
    };
    std::vector<Payload> payloads;

    // The partition slots used for the update.
    BootControlInterface::Slot source_slot{BootControlInterface::kInvalidSlot};  //定义source_slot
    BootControlInterface::Slot target_slot{BootControlInterface::kInvalidSlot};  //定义target_slot

    // The vector below is used for partition verification. The flow is:
    //
    // 1. DownloadAction fills in the expected source and target partition sizes
    // and hashes based on the manifest.
    //
    // 2. FilesystemVerifierAction computes and verifies the partition sizes and
    // hashes against the expected values.
    struct Partition {                                              //一个分区在source_slot和target_slot都存在
      bool operator==(const Partition& that) const;

      // The name of the partition.
      std::string name;

      std::string source_path;                                 //在source_slot中的位置
      uint64_t source_size{};                                 //大小
      brillo::Blob source_hash;                                //hash

      std::string target_path;                                  //在target_slot中的位置
      uint64_t target_size{};
      brillo::Blob target_hash;                                

      // Whether we should run the postinstall script from this partition and the
      // postinstall parameters.
      bool run_postinstall{false};
      std::string postinstall_path;
      std::string filesystem_type;                               //文件系统的类型
      bool postinstall_optional{false};
    };
    std::vector<Partition> partitions;

    // True if payload hash checks are mandatory based on the system state and
    // the Omaha response.
    bool hash_checks_mandatory{false};                        //是否强制进行hash检查

    // True if Powerwash is required on reboot after applying the payload.
    // False otherwise.
    bool powerwash_required{false};                           //是否在升级时进行数据的擦除

    // If not blank, a base-64 encoded representation of the PEM-encoded
    // public key in the response.
    std::string public_key_rsa;                             //public_key 一般为null,这个秘钥常常是已经被内置到了系统中了
  };
  }

把这个数据结构弄明白后，也就对ApplyPayload(..)中对InstallPlan的赋值有一个大体的意思了。在这里出现了source和target的概念，source代表的是现在正在运行的系统，target代表此时此刻备用的系统。也可以把source系统做为一个旧的系统，因为在升级检测新版本的时候，会根据source系统检测新的版本，而在升级的时候，先会把source系统拷贝到target中，之后再利用升级包对target进行差分升级。回到ApplyPayload()，对InstallPlan初始化完成后，就会建立Action。这个时候我们就需要明白Action是什么，又是如何运行的。