Snap for 11486370 from f19ae44727b1641337a7583bd8f39064a99651f2 to 24Q2-release (1393e32d) · Commits · e / os / android_bootable_recovery

bootloader_message/Android.bp

+11 −0

Original line number	Diff line number	Diff line
		@@ -39,6 +39,17 @@ cc_defaults {
		export_include_dirs: ["include"],
		}

		cc_binary {
		name: "misctrl",
		shared_libs: [
		"libbase",
		"libbootloader_message",
		"liblog",
		],
		init_rc: ["misctrl.rc"],
		srcs: ["misctrl_main.cpp"],
		}

		cc_library {
		name: "libbootloader_message",
		defaults: [

bootloader_message/bootloader_message.cpp

+28 −0

Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@
		#include <vector>

		#include <android-base/file.h>
		#include <android-base/hex.h>
		#include <android-base/properties.h>
		#include <android-base/stringprintf.h>
		#include <android-base/unique_fd.h>
		@@ -324,6 +325,33 @@ bool WriteMiscKcmdlineMessage(const misc_kcmdline_message& message, std::string*
		offsetof(misc_system_space_layout, kcmdline_message), err);
		}

		bool ReadMiscControlMessage(misc_control_message* message, std::string* err) {
		return ReadMiscPartitionSystemSpace(message, sizeof(*message),
		offsetof(misc_system_space_layout, control_message), err);
		}

		bool WriteMiscControlMessage(const misc_control_message& message, std::string* err) {
		return WriteMiscPartitionSystemSpace(&message, sizeof(message),
		offsetof(misc_system_space_layout, control_message), err);
		}

		bool CheckReservedSystemSpaceEmpty(bool* empty, std::string* err) {
		constexpr size_t kReservedSize = SYSTEM_SPACE_SIZE_IN_MISC - sizeof(misc_system_space_layout);

		uint8_t space[kReservedSize];
		if (!ReadMiscPartitionSystemSpace(&space, kReservedSize, sizeof(misc_system_space_layout), err)) {
		return false;
		}

		*empty = space[0] == 0 && 0 == memcmp(space, space + 1, kReservedSize - 1);

		if (!*empty) {
		*err = android::base::HexString(space, kReservedSize);
		}

		return true;
		}

		extern "C" bool write_reboot_bootloader(void) {
		std::string err;
		return write_reboot_bootloader(&err);

bootloader_message/include/bootloader_message/bootloader_message.h

+28 −0

Original line number	Diff line number	Diff line
		@@ -107,6 +107,14 @@ struct misc_kcmdline_message {
		uint8_t reserved[51];
		} __attribute__((packed));

		// holds generic platform info, managed by misctrl
		struct misc_control_message {
		uint8_t version;
		uint32_t magic;
		uint64_t misctrl_flags;
		uint8_t reserved[51];
		} __attribute__((packed));

		#define MISC_VIRTUAL_AB_MESSAGE_VERSION 2
		#define MISC_VIRTUAL_AB_MAGIC_HEADER 0x56740AB0

		@@ -127,6 +135,10 @@ struct misc_kcmdline_message {
		#define MISC_KCMDLINE_MAGIC_HEADER 0x6ab5110c
		#define MISC_KCMDLINE_BINDER_RUST 0x1

		#define MISC_CONTROL_MESSAGE_VERSION 1
		#define MISC_CONTROL_MAGIC_HEADER 0x736d6f72
		#define MISC_CONTROL_16KB_BEFORE 0x1

		#if (__STDC_VERSION__ >= 201112L) \|\| defined(__cplusplus)
		static_assert(sizeof(struct misc_virtual_ab_message) == 64,
		"struct misc_virtual_ab_message has wrong size");
		@@ -134,6 +146,8 @@ static_assert(sizeof(struct misc_memtag_message) == 64,
		"struct misc_memtag_message has wrong size");
		static_assert(sizeof(struct misc_kcmdline_message) == 64,
		"struct misc_kcmdline_message has wrong size");
		static_assert(sizeof(struct misc_control_message) == 64,
		"struct misc_control_message has wrong size");
		#endif

		// This struct is not meant to be used directly, rather, it is to make
		@@ -142,8 +156,14 @@ struct misc_system_space_layout {
		misc_virtual_ab_message virtual_ab_message;
		misc_memtag_message memtag_message;
		misc_kcmdline_message kcmdline_message;
		misc_control_message control_message;
		} __attribute__((packed));

		#if (__STDC_VERSION__ >= 201112L) \|\| defined(__cplusplus)
		static_assert(sizeof(struct misc_system_space_layout) % 64 == 0,
		"prefer to extend by 64 byte chunks, for consistency");
		#endif

		#ifdef __cplusplus

		#include <string>
		@@ -216,6 +236,14 @@ bool WriteMiscMemtagMessage(const misc_memtag_message& message, std::string* err
		// Read or write the kcmdline message from system space in /misc.
		bool ReadMiscKcmdlineMessage(misc_kcmdline_message* message, std::string* err);
		bool WriteMiscKcmdlineMessage(const misc_kcmdline_message& message, std::string* err);

		// Read or write the kcmdline message from system space in /misc.
		bool ReadMiscControlMessage(misc_control_message* message, std::string* err);
		bool WriteMiscControlMessage(const misc_control_message& message, std::string* err);

		// Check reserved system space.
		bool CheckReservedSystemSpaceEmpty(bool* empty, std::string* err);

		#else

		#include <stdbool.h>

bootloader_message/misctrl.rc

0 → 100644

+4 −0

Original line number	Diff line number	Diff line
		service misctrl /system/bin/misctrl
		user root # for misc partition access
		class core
		oneshot

bootloader_message/misctrl_main.cpp

0 → 100644

+104 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2024 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 <android-base/properties.h>
		#include <bootloader_message/bootloader_message.h>
		#include <log/log.h>

		#include <string>

		#include <cstdio>

		static void log(const char* fmt, ...) __attribute__((format(printf, 1, 2)));
		static void log(const char* fmt, ...) {
		va_list va;
		va_start(va, fmt);

		va_list vb;
		va_copy(vb, va);

		__android_log_vprint(ANDROID_LOG_ERROR, "misctrl", fmt, va);
		va_end(va);

		vfprintf(stderr, fmt, vb);
		fprintf(stderr, "\n");
		va_end(vb);
		}

		static int check_control_message() {
		misc_control_message m;
		std::string err;
		if (!ReadMiscControlMessage(&m, &err)) {
		log("Could not read misctrl message: %s", err.c_str());
		return 1;
		}

		if (m.magic != MISC_CONTROL_MAGIC_HEADER \|\| m.version != MISC_CONTROL_MESSAGE_VERSION) {
		log("misctrl message invalid, resetting it");
		m = { .version = MISC_CONTROL_MESSAGE_VERSION,
		.magic = MISC_CONTROL_MAGIC_HEADER,
		.misctrl_flags = 0 };
		}

		int res = 0;

		const size_t ps = getpagesize();

		if (ps != 4096 && ps != 16384) {
		log("Unrecognized page size: %zu", ps);
		res = 1;
		}

		if (ps == 16384) {
		m.misctrl_flags \|= MISC_CONTROL_16KB_BEFORE;
		}

		bool before_16kb = m.misctrl_flags & MISC_CONTROL_16KB_BEFORE;
		res \|= android::base::SetProperty("ro.misctrl.16kb_before", before_16kb ? "1" : "0");

		if (!WriteMiscControlMessage(m, &err)) {
		log("Could not write misctrl message: %s", err.c_str());
		res \|= 1;
		}

		return res;
		}

		static int check_reserved_space() {
		bool empty;
		std::string err;
		bool success = CheckReservedSystemSpaceEmpty(&empty, &err);
		if (!success) {
		log("Could not read reserved space: %s", err.c_str());
		return 1;
		}
		log("System reserved space empty? %d.", empty);

		if (!err.empty()) {
		constexpr size_t kPrintChunkSize = 256;
		for (size_t i = 0; i < err.size(); i += kPrintChunkSize) {
		log("DATA: %s", err.substr(i, kPrintChunkSize).c_str());
		}
		}

		return empty ? 0 : 1;
		}

		int main() {
		int err = 0;
		err \|= check_control_message();
		err \|= check_reserved_space();
		return err;
		}