Merge tag 'android-7.1.0_r4' of https://android.googlesource.com/platform/bootable/recovery into 71 (717b26f1) · Commits · e / os / android_bootable_recovery

Android.mk

+11 −5

Original line number	Diff line number	Diff line
		@@ -34,7 +34,6 @@ include $(CLEAR_VARS)
		LOCAL_SRC_FILES := \
		adb_install.cpp \
		asn1_decoder.cpp \
		bootloader.cpp \
		device.cpp \
		fuse_sdcard_provider.cpp \
		install.cpp \
		@@ -72,6 +71,7 @@ LOCAL_C_INCLUDES += \
		LOCAL_STATIC_LIBRARIES := \
		libbatterymonitor \
		libminivold_static \
		libbootloader_message \
		libext4_utils_static \
		libmake_ext4fs_static \
		libminizip_static \
		@@ -123,6 +123,10 @@ ifeq ($(TARGET_HAVE_OEMLOCK), true)
		LOCAL_STATIC_LIBRARIES += liboemlock
		endif

		ifeq ($(AB_OTA_UPDATER),true)
		LOCAL_CFLAGS += -DAB_OTA_UPDATER=1
		endif

		LOCAL_MODULE_PATH := $(TARGET_RECOVERY_ROOT_OUT)/sbin

		# Handling for EV_REL is disabled by default because some accelerometers
		@@ -338,18 +342,20 @@ LOCAL_C_INCLUDES := system/core/fs_mgr/include
		LOCAL_STATIC_LIBRARIES := libcrypto_utils_static 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 \
		$(LOCAL_PATH)/fstools/Android.mk

		endif

bootloader.cpp

deleted100644 → 0

+0 −225

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 "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 int get_bootloader_message_block(bootloader_message* out, const Volume* v);
		static int set_bootloader_message_block(const bootloader_message* in, const Volume* v);

		int get_bootloader_message(bootloader_message* out) {
		Volume* v = volume_for_path("/misc");
		if (v == nullptr) {
		LOGI("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) {
		return get_bootloader_message_block(out, v);
		}
		LOGE("unknown misc partition fs_type \"%s\"\n", v->fs_type);
		return -1;
		}

		int set_bootloader_message(const bootloader_message* in) {
		Volume* v = volume_for_path("/misc");
		if (v == nullptr) {
		LOGI("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) {
		return set_bootloader_message_block(in, v);
		}
		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 int get_bootloader_message_block(bootloader_message* out,
		const Volume* v) {
		wait_for_device(v->blk_device);
		FILE* f = fopen(v->blk_device, "rb");
		if (f == nullptr) {
		LOGE("failed to open \"%s\": %s\n", v->blk_device, strerror(errno));
		return -1;
		}
		#ifdef BOARD_RECOVERY_BLDRMSG_OFFSET
		fseek(f, BOARD_RECOVERY_BLDRMSG_OFFSET, SEEK_SET);
		#endif
		bootloader_message temp;
		int count = fread(&temp, sizeof(temp), 1, f);
		if (count != 1) {
		LOGE("failed to read \"%s\": %s\n", v->blk_device, strerror(errno));
		return -1;
		}
		if (fclose(f) != 0) {
		LOGE("failed to close \"%s\": %s\n", v->blk_device, strerror(errno));
		return -1;
		}
		memcpy(out, &temp, sizeof(temp));
		return 0;
		}

		static int set_bootloader_message_block(const bootloader_message* in,
		const Volume* v) {
		wait_for_device(v->blk_device);
		unique_fd fd(open(v->blk_device, O_RDWR \| O_APPEND \| O_SYNC));
		if (fd.get() == -1) {
		LOGE("failed to open \"%s\": %s\n", v->blk_device, strerror(errno));
		return -1;
		}

		#ifdef BOARD_RECOVERY_BLDRMSG_OFFSET
		lseek(fd.get(), BOARD_RECOVERY_BLDRMSG_OFFSET, SEEK_SET);
		#endif

		size_t written = 0;
		const uint8_t* start = reinterpret_cast<const uint8_t*>(in);
		size_t total = sizeof(*in);
		while (written < total) {
		ssize_t wrote = TEMP_FAILURE_RETRY(write(fd.get(), start + written, total - written));
		if (wrote == -1) {
		LOGE("failed to write %" PRId64 " bytes: %s\n",
		static_cast<off64_t>(written), strerror(errno));
		return -1;
		}
		written += wrote;
		}

		if (fsync(fd.get()) == -1) {
		LOGE("failed to fsync \"%s\": %s\n", v->blk_device, strerror(errno));
		return -1;
		}
		return 0;
		}

bootloader.h

+2 −55

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

		#ifndef _RECOVERY_BOOTLOADER_H
		#define _RECOVERY_BOOTLOADER_H

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

		#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

+78 −4

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_bootloader_message(const bootloader_message& boot, 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_RDONLY));
		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,11 +119,17 @@ static bool write_bootloader_message(const bootloader_message& boot, std::string
		strerror(errno));
		return false;
		}
		if (!android::base::WriteFully(fd.get(), &boot, sizeof(boot))) {
		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::WriteFully(fd.get(), p, size)) {
		*err = android::base::StringPrintf("failed to write %s: %s", misc_blk_device.c_str(),
		strerror(errno));
		return false;
		}

		// TODO: O_SYNC and fsync duplicates each other?
		if (fsync(fd.get()) == -1) {
		*err = android::base::StringPrintf("failed to fsync %s: %s", misc_blk_device.c_str(),
		@@ -83,6 +139,14 @@ static bool write_bootloader_message(const bootloader_message& boot, std::string
		return true;
		}

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

		bool clear_bootloader_message(std::string* err) {
		bootloader_message boot = {};
		return write_bootloader_message(boot, err);
		@@ -101,6 +165,16 @@ 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);
		}

		extern "C" bool write_bootloader_message(const char* options) {
		std::string err;
		return write_bootloader_message({options}, &err);