resolve merge conflicts of 2f272c0 to nyc-mr1-dev-plus-aosp (9b15ba82) · Commits · e / tools / etwrp

Android.mk

+8 −6

Original line number	Diff line number	Diff line
		@@ -41,7 +41,6 @@ include $(CLEAR_VARS)
		LOCAL_SRC_FILES := \
		adb_install.cpp \
		asn1_decoder.cpp \
		bootloader.cpp \
		device.cpp \
		fuse_sdcard_provider.cpp \
		install.cpp \
		@@ -76,6 +75,7 @@ LOCAL_C_INCLUDES += \

		LOCAL_STATIC_LIBRARIES := \
		libbatterymonitor \
		libbootloader_message \
		libext4_utils_static \
		libsparse_static \
		libminzip \
		@@ -152,14 +152,16 @@ LOCAL_SRC_FILES := \
		LOCAL_STATIC_LIBRARIES := libcrypto_utils_static libcrypto_static
		include $(BUILD_STATIC_LIBRARY)

		include $(LOCAL_PATH)/minui/Android.mk \
		$(LOCAL_PATH)/minzip/Android.mk \
		include \
		$(LOCAL_PATH)/applypatch/Android.mk \
		$(LOCAL_PATH)/bootloader_message/Android.mk \
		$(LOCAL_PATH)/edify/Android.mk \
		$(LOCAL_PATH)/minadbd/Android.mk \
		$(LOCAL_PATH)/minui/Android.mk \
		$(LOCAL_PATH)/minzip/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 −150

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 <android-base/unique_fd.h>

		#include "bootloader.h"
		#include "common.h"
		#include "roots.h"

		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, "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, "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 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);
		android::base::unique_fd fd(open(v->blk_device, O_RDONLY));
		if (fd == -1) {
		LOGE("Failed to open \"%s\": %s\n", v->blk_device, strerror(errno));
		return false;
		}
		if (lseek(fd, 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, &(*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);
		android::base::unique_fd fd(open(v->blk_device, O_WRONLY \| O_SYNC));
		if (fd == -1) {
		LOGE("Failed to open \"%s\": %s\n", v->blk_device, strerror(errno));
		return false;
		}
		if (lseek(fd, 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, in.data(), in.size())) {
		LOGE("Failed to write \"%s\": %s\n", v->blk_device, strerror(errno));
		return false;
		}

		if (fsync(fd) == -1) {
		LOGE("Failed to fsync \"%s\": %s\n", v->blk_device, strerror(errno));
		return false;
		}
		return true;
		}

bootloader.h

+2 −173

Original line number	Diff line number	Diff line
		@@ -14,176 +14,5 @@
		* limitations under the License.
		*/

		#ifndef _RECOVERY_BOOTLOADER_H
		#define _RECOVERY_BOOTLOADER_H

		#include <assert.h>
		#include <stddef.h>

		// Spaces used by misc partition are as below:
		// 0 - 2K For bootloader_message
		// 2K - 16K Used by Vendor's bootloader (the 2K - 4K range may be optionally used
		// as bootloader_message_ab struct)
		// 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 (2-KiB)
		*
		* 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.
		*
		* We used to have slot_suffix field for A/B boot control metadata in
		* this struct, which gets unintentionally cleared by recovery or
		* uncrypt. Move it into struct bootloader_message_ab to avoid the
		* issue.
		*/
		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];

		// The 'reserved' field used to be 224 bytes when it was initially
		// carved off from the 1024-byte recovery field. Bump it up to
		// 1184-byte so that the entire bootloader_message struct rounds up
		// to 2048-byte.
		char reserved[1184];
		};

		/**
		* We must be cautious when changing the bootloader_message struct size,
		* because A/B-specific fields may end up with different offsets.
		*/
		#if (__STDC_VERSION__ >= 201112L) \|\| defined(__cplusplus)
		static_assert(sizeof(struct bootloader_message) == 2048,
		"struct bootloader_message size changes, which may break A/B devices");
		#endif

		/**
		* The A/B-specific bootloader message structure (4-KiB).
		*
		* We separate A/B boot control metadata from the regular bootloader
		* message struct and keep it here. Everything that's A/B-specific
		* stays after struct bootloader_message, which should be managed by
		* the A/B-bootloader or boot control HAL.
		*
		* 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. It is encouraged, but
		* not mandatory, to use 'struct bootloader_control' described below.
		*/
		struct bootloader_message_ab {
		struct bootloader_message message;
		char slot_suffix[32];

		// Round up the entire struct to 4096-byte.
		char reserved[2016];
		};

		/**
		* Be cautious about the struct size change, in case we put anything post
		* bootloader_message_ab struct (b/29159185).
		*/
		#if (__STDC_VERSION__ >= 201112L) \|\| defined(__cplusplus)
		static_assert(sizeof(struct bootloader_message_ab) == 4096,
		"struct bootloader_message_ab size changes");
		#endif

		#define BOOT_CTRL_MAGIC 0x42414342 /* Bootloader Control AB */
		#define BOOT_CTRL_VERSION 1

		struct slot_metadata {
		// Slot priority with 15 meaning highest priority, 1 lowest
		// priority and 0 the slot is unbootable.
		uint8_t priority : 4;
		// Number of times left attempting to boot this slot.
		uint8_t tries_remaining : 3;
		// 1 if this slot has booted successfully, 0 otherwise.
		uint8_t successful_boot : 1;
		// 1 if this slot is corrupted from a dm-verity corruption, 0
		// otherwise.
		uint8_t verity_corrupted : 1;
		// Reserved for further use.
		uint8_t reserved : 7;
		} __attribute__((packed));

		/* Bootloader Control AB
		*
		* This struct can be used to manage A/B metadata. It is designed to
		* be put in the 'slot_suffix' field of the 'bootloader_message'
		* structure described above. It is encouraged to use the
		* 'bootloader_control' structure to store the A/B metadata, but not
		* mandatory.
		*/
		struct bootloader_control {
		// NUL terminated active slot suffix.
		char slot_suffix[4];
		// Bootloader Control AB magic number (see BOOT_CTRL_MAGIC).
		uint32_t magic;
		// Version of struct being used (see BOOT_CTRL_VERSION).
		uint8_t version;
		// Number of slots being managed.
		uint8_t nb_slot : 3;
		// Number of times left attempting to boot recovery.
		uint8_t recovery_tries_remaining : 3;
		// Ensure 4-bytes alignment for slot_info field.
		uint8_t reserved0[2];
		// Per-slot information. Up to 4 slots.
		struct slot_metadata slot_info[4];
		// Reserved for further use.
		uint8_t reserved1[8];
		// CRC32 of all 28 bytes preceding this field (little endian
		// format).
		uint32_t crc32_le;
		} __attribute__((packed));

		#if (__STDC_VERSION__ >= 201112L) \|\| defined(__cplusplus)
		static_assert(sizeof(struct bootloader_control) ==
		sizeof(((struct bootloader_message_ab *)0)->slot_suffix),
		"struct bootloader_control has wrong size");
		#endif

		/* 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);