Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2f272c05 authored by Yabin Cui's avatar Yabin Cui
Browse files

Create bootloader_message static library. 

bootloader_messages merges bootloader_message_writer
and bootloader.cpp, so we can use the same library to
manage bootloader_message in normal boot and recovery mode.

Bug: 29582118

Change-Id: I9efdf776ef8f02b53911ff43a518e035e0c29618
parent 6074099c

Android.mk

+7 −5
Original line number Diff line number Diff line
@@ -31,7 +31,6 @@ include $(CLEAR_VARS) 
LOCAL_SRC_FILES := \

    adb_install.cpp \

    asn1_decoder.cpp \

    bootloader.cpp \

    device.cpp \

    fuse_sdcard_provider.cpp \

    install.cpp \
@@ -66,6 +65,7 @@ LOCAL_C_INCLUDES += \ 


LOCAL_STATIC_LIBRARIES := \

    libbatterymonitor \

    libbootloader_message \

    libext4_utils_static \

    libsparse_static \

    libminzip \
@@ -143,15 +143,17 @@ LOCAL_SRC_FILES := \ 
LOCAL_STATIC_LIBRARIES := libcrypto_static

include $(BUILD_STATIC_LIBRARY)



include $(LOCAL_PATH)/minui/Android.mk \

include \

    $(LOCAL_PATH)/applypatch/Android.mk \

    $(LOCAL_PATH)/bootloader_message/Android.mk \

    $(LOCAL_PATH)/edify/Android.mk \

    $(LOCAL_PATH)/minui/Android.mk \

    $(LOCAL_PATH)/minzip/Android.mk \

    $(LOCAL_PATH)/minadbd/Android.mk \

    $(LOCAL_PATH)/mtdutils/Android.mk \

    $(LOCAL_PATH)/otafault/Android.mk \

    $(LOCAL_PATH)/tests/Android.mk \

    $(LOCAL_PATH)/tools/Android.mk \

    $(LOCAL_PATH)/edify/Android.mk \

    $(LOCAL_PATH)/uncrypt/Android.mk \

    $(LOCAL_PATH)/otafault/Android.mk \

    $(LOCAL_PATH)/updater/Android.mk \

    $(LOCAL_PATH)/update_verifier/Android.mk \
 
    $(LOCAL_PATH)/applypatch/Android.mk

bootloader.cpp

deleted100644 → 0
+0 −235
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2008 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <errno.h>

#include <fcntl.h>

#include <inttypes.h>

#include <stdio.h>

#include <string.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <unistd.h>



#include <fs_mgr.h>



#include <android-base/file.h>



#include "bootloader.h"

#include "common.h"

#include "mtdutils/mtdutils.h"

#include "roots.h"

#include "unique_fd.h"



static int get_bootloader_message_mtd(bootloader_message* out, const Volume* v);

static int set_bootloader_message_mtd(const bootloader_message* in, const Volume* v);

static bool read_misc_partition(const Volume* v, size_t offset, size_t size, std::string* out);

static bool write_misc_partition(const Volume* v, size_t offset, const std::string& in);



int get_bootloader_message(bootloader_message* out) {

    Volume* v = volume_for_path("/misc");

    if (v == nullptr) {

        LOGE("Cannot load volume /misc!\n");

        return -1;

    }

    if (strcmp(v->fs_type, "mtd") == 0) {

        return get_bootloader_message_mtd(out, v);

    } else if (strcmp(v->fs_type, "emmc") == 0) {

        std::string s;

        if (!read_misc_partition(v, BOOTLOADER_MESSAGE_OFFSET_IN_MISC, sizeof(bootloader_message),

                                 &s)) {

            return -1;

        }

        memcpy(out, s.data(), s.size());

        return 0;

    }

    LOGE("Unknown misc partition fs_type \"%s\"\n", v->fs_type);

    return -1;

}



bool read_wipe_package(size_t size, std::string* out) {

    Volume* v = volume_for_path("/misc");

    if (v == nullptr) {

        LOGE("Cannot load volume /misc!\n");

        return false;

    }

    if (strcmp(v->fs_type, "mtd") == 0) {

        LOGE("Read wipe package on mtd is not supported.\n");

        return false;

    } else if (strcmp(v->fs_type, "emmc") == 0) {

        return read_misc_partition(v, WIPE_PACKAGE_OFFSET_IN_MISC, size, out);

    }

    LOGE("Unknown misc partition fs_type \"%s\"\n", v->fs_type);

    return false;

}



int set_bootloader_message(const bootloader_message* in) {

    Volume* v = volume_for_path("/misc");

    if (v == nullptr) {

        LOGE("Cannot load volume /misc!\n");

        return -1;

    }

    if (strcmp(v->fs_type, "mtd") == 0) {

        return set_bootloader_message_mtd(in, v);

    } else if (strcmp(v->fs_type, "emmc") == 0) {

        std::string s(reinterpret_cast<const char*>(in), sizeof(*in));

        bool success = write_misc_partition(v, BOOTLOADER_MESSAGE_OFFSET_IN_MISC, s);

        return success ? 0 : -1;

    }

    LOGE("Unknown misc partition fs_type \"%s\"\n", v->fs_type);

    return -1;

}



// ------------------------------

// for misc partitions on MTD

// ------------------------------



static const int MISC_PAGES = 3;         // number of pages to save

static const int MISC_COMMAND_PAGE = 1;  // bootloader command is this page



static int get_bootloader_message_mtd(bootloader_message* out,

                                      const Volume* v) {

    size_t write_size;

    mtd_scan_partitions();

    const MtdPartition* part = mtd_find_partition_by_name(v->blk_device);

    if (part == nullptr || mtd_partition_info(part, nullptr, nullptr, &write_size)) {

        LOGE("failed to find \"%s\"\n", v->blk_device);

        return -1;

    }



    MtdReadContext* read = mtd_read_partition(part);

    if (read == nullptr) {

        LOGE("failed to open \"%s\": %s\n", v->blk_device, strerror(errno));

        return -1;

    }



    const ssize_t size = write_size * MISC_PAGES;

    char data[size];

    ssize_t r = mtd_read_data(read, data, size);

    if (r != size) LOGE("failed to read \"%s\": %s\n", v->blk_device, strerror(errno));

    mtd_read_close(read);

    if (r != size) return -1;



    memcpy(out, &data[write_size * MISC_COMMAND_PAGE], sizeof(*out));

    return 0;

}

static int set_bootloader_message_mtd(const bootloader_message* in,

                                      const Volume* v) {

    size_t write_size;

    mtd_scan_partitions();

    const MtdPartition* part = mtd_find_partition_by_name(v->blk_device);

    if (part == nullptr || mtd_partition_info(part, nullptr, nullptr, &write_size)) {

        LOGE("failed to find \"%s\"\n", v->blk_device);

        return -1;

    }



    MtdReadContext* read = mtd_read_partition(part);

    if (read == nullptr) {

        LOGE("failed to open \"%s\": %s\n", v->blk_device, strerror(errno));

        return -1;

    }



    ssize_t size = write_size * MISC_PAGES;

    char data[size];

    ssize_t r = mtd_read_data(read, data, size);

    if (r != size) LOGE("failed to read \"%s\": %s\n", v->blk_device, strerror(errno));

    mtd_read_close(read);

    if (r != size) return -1;



    memcpy(&data[write_size * MISC_COMMAND_PAGE], in, sizeof(*in));



    MtdWriteContext* write = mtd_write_partition(part);

    if (write == nullptr) {

        LOGE("failed to open \"%s\": %s\n", v->blk_device, strerror(errno));

        return -1;

    }

    if (mtd_write_data(write, data, size) != size) {

        LOGE("failed to write \"%s\": %s\n", v->blk_device, strerror(errno));

        mtd_write_close(write);

        return -1;

    }

    if (mtd_write_close(write)) {

        LOGE("failed to finish \"%s\": %s\n", v->blk_device, strerror(errno));

        return -1;

    }



    LOGI("Set boot command \"%s\"\n", in->command[0] != 255 ? in->command : "");

    return 0;

}





// ------------------------------------

// for misc partitions on block devices

// ------------------------------------



static void wait_for_device(const char* fn) {

    int tries = 0;

    int ret;

    do {

        ++tries;

        struct stat buf;

        ret = stat(fn, &buf);

        if (ret == -1) {

            printf("failed to stat \"%s\" try %d: %s\n", fn, tries, strerror(errno));

            sleep(1);

        }

    } while (ret && tries < 10);



    if (ret) {

        printf("failed to stat \"%s\"\n", fn);

    }

}



static bool read_misc_partition(const Volume* v, size_t offset, size_t size, std::string* out) {

    wait_for_device(v->blk_device);

    unique_fd fd(open(v->blk_device, O_RDONLY));

    if (fd.get() == -1) {

        LOGE("Failed to open \"%s\": %s\n", v->blk_device, strerror(errno));

        return false;

    }

    if (lseek(fd.get(), static_cast<off_t>(offset), SEEK_SET) != static_cast<off_t>(offset)) {

        LOGE("Failed to lseek \"%s\": %s\n", v->blk_device, strerror(errno));

        return false;

    }

    out->resize(size);

    if (!android::base::ReadFully(fd.get(), &(*out)[0], size)) {

        LOGE("Failed to read \"%s\": %s\n", v->blk_device, strerror(errno));

        return false;

    }

    return true;

}



static bool write_misc_partition(const Volume* v, size_t offset, const std::string& in) {

    wait_for_device(v->blk_device);

    unique_fd fd(open(v->blk_device, O_WRONLY | O_SYNC));

    if (fd.get() == -1) {

        LOGE("Failed to open \"%s\": %s\n", v->blk_device, strerror(errno));

        return false;

    }

    if (lseek(fd.get(), static_cast<off_t>(offset), SEEK_SET) != static_cast<off_t>(offset)) {

        LOGE("Failed to lseek \"%s\": %s\n", v->blk_device, strerror(errno));

        return false;

    }

    if (!android::base::WriteFully(fd.get(), in.data(), in.size())) {

        LOGE("Failed to write \"%s\": %s\n", v->blk_device, strerror(errno));

        return false;

    }



    if (fsync(fd.get()) == -1) {

        LOGE("Failed to fsync \"%s\": %s\n", v->blk_device, strerror(errno));

        return false;

    }

    return true;

}

bootloader.h

+2 −73
Original line number Diff line number Diff line
@@ -14,76 +14,5 @@ 
 * limitations under the License.

 */



#ifndef _RECOVERY_BOOTLOADER_H

#define _RECOVERY_BOOTLOADER_H



#include <stddef.h>



// Spaces used by misc partition are as below:

// 0   - 2K     Bootloader Message

// 2K  - 16K    Used by Vendor's bootloader

// 16K - 64K    Used by uncrypt and recovery to store wipe_package for A/B devices

// Note that these offsets are admitted by bootloader,recovery and uncrypt, so they

// are not configurable without changing all of them.

static const size_t BOOTLOADER_MESSAGE_OFFSET_IN_MISC = 0;

static const size_t WIPE_PACKAGE_OFFSET_IN_MISC = 16 * 1024;



/* Bootloader Message

 *

 * This structure describes the content of a block in flash

 * that is used for recovery and the bootloader to talk to

 * each other.

 *

 * The command field is updated by linux when it wants to

 * reboot into recovery or to update radio or bootloader firmware.

 * It is also updated by the bootloader when firmware update

 * is complete (to boot into recovery for any final cleanup)

 *

 * The status field is written by the bootloader after the

 * completion of an "update-radio" or "update-hboot" command.

 *

 * The recovery field is only written by linux and used

 * for the system to send a message to recovery or the

 * other way around.

 *

 * The stage field is written by packages which restart themselves

 * multiple times, so that the UI can reflect which invocation of the

 * package it is.  If the value is of the format "#/#" (eg, "1/3"),

 * the UI will add a simple indicator of that status.

 *

 * The slot_suffix field is used for A/B implementations where the

 * bootloader does not set the androidboot.ro.boot.slot_suffix kernel

 * commandline parameter. This is used by fs_mgr to mount /system and

 * other partitions with the slotselect flag set in fstab. A/B

 * implementations are free to use all 32 bytes and may store private

 * data past the first NUL-byte in this field.

 */

struct bootloader_message {

    char command[32];

    char status[32];

    char recovery[768];



    // The 'recovery' field used to be 1024 bytes.  It has only ever

    // been used to store the recovery command line, so 768 bytes

    // should be plenty.  We carve off the last 256 bytes to store the

    // stage string (for multistage packages) and possible future

    // expansion.

    char stage[32];

    char slot_suffix[32];

    char reserved[192];

};



/* Read and write the bootloader command from the "misc" partition.

 * These return zero on success.

 */

int get_bootloader_message(struct bootloader_message *out);

int set_bootloader_message(const struct bootloader_message *in);



#ifdef __cplusplus



#include <string>



bool read_wipe_package(size_t size, std::string* out);

#endif



#endif
 
// TODO: Remove this file once we remove all places that include this file.

#include "bootloader_message/include/bootloader_message/bootloader_message.h"

bootloader_message/Android.mk

0 → 100644
+24 −0
Original line number Diff line number Diff line 
# Copyright (C) 2016 The Android Open Source Project

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#      http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.



LOCAL_PATH := $(call my-dir)



include $(CLEAR_VARS)

LOCAL_CLANG := true

LOCAL_SRC_FILES := bootloader_message.cpp

LOCAL_MODULE := libbootloader_message

LOCAL_STATIC_LIBRARIES := libbase libfs_mgr

LOCAL_C_INCLUDES := $(LOCAL_PATH)/include

LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include

include $(BUILD_STATIC_LIBRARY)

uncrypt/bootloader_message_writer.cpp→bootloader_message/bootloader_message.cpp

+64 −6
Original line number Diff line number Diff line
@@ -14,6 +14,8 @@ 
 * limitations under the License.

 */



#include <bootloader_message/bootloader_message.h>



#include <errno.h>

#include <fcntl.h>

#include <string.h>
@@ -27,8 +29,6 @@ 
#include <android-base/unique_fd.h>

#include <fs_mgr.h>



#include "bootloader.h"



static struct fstab* read_fstab(std::string* err) {

  // The fstab path is always "/fstab.${ro.hardware}".

  std::string fstab_path = "/fstab.";
@@ -58,7 +58,57 @@ static std::string get_misc_blk_device(std::string* err) { 
  return record->blk_device;

}



static bool write_misc_partition(const void* p, size_t size, size_t misc_offset, std::string* err) {

// In recovery mode, recovery can get started and try to access the misc

// device before the kernel has actually created it.

static bool wait_for_device(const std::string& blk_device, std::string* err) {

  int tries = 0;

  int ret;

  err->clear();

  do {

    ++tries;

    struct stat buf;

    ret = stat(blk_device.c_str(), &buf);

    if (ret == -1) {

      *err += android::base::StringPrintf("failed to stat %s try %d: %s\n",

                                          blk_device.c_str(), tries, strerror(errno));

      sleep(1);

    }

  } while (ret && tries < 10);



  if (ret) {

    *err += android::base::StringPrintf("failed to stat %s\n", blk_device.c_str());

  }

  return ret == 0;

}



static bool read_misc_partition(void* p, size_t size, size_t offset, std::string* err) {

  std::string misc_blk_device = get_misc_blk_device(err);

  if (misc_blk_device.empty()) {

    return false;

  }

  if (!wait_for_device(misc_blk_device, err)) {

    return false;

  }

  android::base::unique_fd fd(open(misc_blk_device.c_str(), O_WRONLY | O_SYNC));

  if (fd.get() == -1) {

    *err = android::base::StringPrintf("failed to open %s: %s", misc_blk_device.c_str(),

                                       strerror(errno));

    return false;

  }

  if (lseek(fd.get(), static_cast<off_t>(offset), SEEK_SET) != static_cast<off_t>(offset)) {

    *err = android::base::StringPrintf("failed to lseek %s: %s", misc_blk_device.c_str(),

                                       strerror(errno));

    return false;

  }

  if (!android::base::ReadFully(fd.get(), p, size)) {

    *err = android::base::StringPrintf("failed to read %s: %s", misc_blk_device.c_str(),

                                       strerror(errno));

    return false;

  }

  return true;

}



static bool write_misc_partition(const void* p, size_t size, size_t offset, std::string* err) {

  std::string misc_blk_device = get_misc_blk_device(err);

  if (misc_blk_device.empty()) {

    return false;
@@ -69,8 +119,7 @@ static bool write_misc_partition(const void* p, size_t size, size_t misc_offset, 
                                       strerror(errno));

    return false;

  }

  if (lseek(fd.get(), static_cast<off_t>(misc_offset), SEEK_SET) !=

      static_cast<off_t>(misc_offset)) {

  if (lseek(fd.get(), static_cast<off_t>(offset), SEEK_SET) != static_cast<off_t>(offset)) {

    *err = android::base::StringPrintf("failed to lseek %s: %s", misc_blk_device.c_str(),

                                       strerror(errno));

    return false;
@@ -90,7 +139,11 @@ static bool write_misc_partition(const void* p, size_t size, size_t misc_offset, 
  return true;

}



static bool write_bootloader_message(const bootloader_message& boot, std::string* err) {

bool read_bootloader_message(bootloader_message* boot, std::string* err) {

  return read_misc_partition(boot, sizeof(*boot), BOOTLOADER_MESSAGE_OFFSET_IN_MISC, err);

}



bool write_bootloader_message(const bootloader_message& boot, std::string* err) {

  return write_misc_partition(&boot, sizeof(boot), BOOTLOADER_MESSAGE_OFFSET_IN_MISC, err);

}
@@ -112,6 +165,11 @@ bool write_bootloader_message(const std::vector<std::string>& options, std::stri 
  return write_bootloader_message(boot, err);

}



bool read_wipe_package(std::string* package_data, size_t size, std::string* err) {

  package_data->resize(size);

  return read_misc_partition(&(*package_data)[0], size, WIPE_PACKAGE_OFFSET_IN_MISC, err);

}



bool write_wipe_package(const std::string& package_data, std::string* err) {

  return write_misc_partition(package_data.data(), package_data.size(),

                              WIPE_PACKAGE_OFFSET_IN_MISC, err);