1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef _BOOTLOADER_MESSAGE_H 18 #define _BOOTLOADER_MESSAGE_H 19 20 #include <assert.h> 21 #include <stddef.h> 22 #include <stdint.h> 23 24 // Spaces used by misc partition are as below: 25 // 0 - 2K For bootloader_message 26 // 2K - 16K Used by Vendor's bootloader (the 2K - 4K range may be optionally used 27 // as bootloader_message_ab struct) 28 // 16K - 32K Used by uncrypt and recovery to store wipe_package for A/B devices 29 // 32K - 64K System space, used for miscellanious AOSP features. See below. 30 // Note that these offsets are admitted by bootloader,recovery and uncrypt, so they 31 // are not configurable without changing all of them. 32 constexpr size_t BOOTLOADER_MESSAGE_OFFSET_IN_MISC = 0; 33 constexpr size_t VENDOR_SPACE_OFFSET_IN_MISC = 2 * 1024; 34 constexpr size_t WIPE_PACKAGE_OFFSET_IN_MISC = 16 * 1024; 35 constexpr size_t SYSTEM_SPACE_OFFSET_IN_MISC = 32 * 1024; 36 constexpr size_t SYSTEM_SPACE_SIZE_IN_MISC = 32 * 1024; 37 38 /* Bootloader Message (2-KiB) 39 * 40 * This structure describes the content of a block in flash 41 * that is used for recovery and the bootloader to talk to 42 * each other. 43 * 44 * The command field is updated by linux when it wants to 45 * reboot into recovery or to update radio or bootloader firmware. 46 * It is also updated by the bootloader when firmware update 47 * is complete (to boot into recovery for any final cleanup) 48 * 49 * The status field was used by the bootloader after the completion 50 * of an "update-radio" or "update-hboot" command, which has been 51 * deprecated since Froyo. 52 * 53 * The recovery field is only written by linux and used 54 * for the system to send a message to recovery or the 55 * other way around. 56 * 57 * The stage field is written by packages which restart themselves 58 * multiple times, so that the UI can reflect which invocation of the 59 * package it is. If the value is of the format "#/#" (eg, "1/3"), 60 * the UI will add a simple indicator of that status. 61 * 62 * We used to have slot_suffix field for A/B boot control metadata in 63 * this struct, which gets unintentionally cleared by recovery or 64 * uncrypt. Move it into struct bootloader_message_ab to avoid the 65 * issue. 66 */ 67 struct bootloader_message { 68 char command[32]; 69 char status[32]; 70 char recovery[768]; 71 72 // The 'recovery' field used to be 1024 bytes. It has only ever 73 // been used to store the recovery command line, so 768 bytes 74 // should be plenty. We carve off the last 256 bytes to store the 75 // stage string (for multistage packages) and possible future 76 // expansion. 77 char stage[32]; 78 79 // The 'reserved' field used to be 224 bytes when it was initially 80 // carved off from the 1024-byte recovery field. Bump it up to 81 // 1184-byte so that the entire bootloader_message struct rounds up 82 // to 2048-byte. 83 char reserved[1184]; 84 }; 85 86 // Holds Virtual A/B merge status information. Current version is 1. New fields 87 // must be added to the end. 88 struct misc_virtual_ab_message { 89 uint8_t version; 90 uint32_t magic; 91 uint8_t merge_status; // IBootControl 1.1, MergeStatus enum. 92 uint8_t source_slot; // Slot number when merge_status was written. 93 uint8_t reserved[57]; 94 } __attribute__((packed)); 95 96 struct misc_memtag_message { 97 uint8_t version; 98 uint32_t magic; // magic string for treble compat 99 uint32_t memtag_mode; 100 uint8_t reserved[55]; 101 } __attribute__((packed)); 102 103 #define MISC_VIRTUAL_AB_MESSAGE_VERSION 2 104 #define MISC_VIRTUAL_AB_MAGIC_HEADER 0x56740AB0 105 106 #define MISC_MEMTAG_MESSAGE_VERSION 1 107 #define MISC_MEMTAG_MAGIC_HEADER 0x5afefe5a 108 #define MISC_MEMTAG_MODE_MEMTAG 0x1 109 #define MISC_MEMTAG_MODE_MEMTAG_ONCE 0x2 110 #define MISC_MEMTAG_MODE_MEMTAG_KERNEL 0x4 111 #define MISC_MEMTAG_MODE_MEMTAG_KERNEL_ONCE 0x8 112 #define MISC_MEMTAG_MODE_MEMTAG_OFF 0x10 113 // This is set when the state was overridden forcibly. This does not need to be 114 // interpreted by the bootloader but is only for bookkeeping purposes so 115 // userspace knows what to do when the override is undone. 116 // See system/extras/mtectrl in AOSP for more information. 117 #define MISC_MEMTAG_MODE_FORCED 0x20 118 119 #if (__STDC_VERSION__ >= 201112L) || defined(__cplusplus) 120 static_assert(sizeof(struct misc_virtual_ab_message) == 64, 121 "struct misc_virtual_ab_message has wrong size"); 122 static_assert(sizeof(struct misc_memtag_message) == 64, 123 "struct misc_memtag_message has wrong size"); 124 #endif 125 126 // This struct is not meant to be used directly, rather, it is to make 127 // computation of offsets easier. New fields must be added to the end. 128 struct misc_system_space_layout { 129 misc_virtual_ab_message virtual_ab_message; 130 misc_memtag_message memtag_message; 131 } __attribute__((packed)); 132 133 #ifdef __cplusplus 134 135 #include <string> 136 #include <vector> 137 138 // Gets the block device name of /misc partition. 139 std::string get_misc_blk_device(std::string* err); 140 // Return the block device name for the bootloader message partition and waits 141 // for the device for up to 10 seconds. In case of error returns the empty 142 // string. 143 std::string get_bootloader_message_blk_device(std::string* err); 144 145 // Writes |size| bytes of data from buffer |p| to |misc_blk_device| at |offset|. If the write fails, 146 // sets the error message in |err|. 147 bool write_misc_partition(const void* p, size_t size, const std::string& misc_blk_device, 148 size_t offset, std::string* err); 149 150 // Read bootloader message into boot. Error message will be set in err. 151 bool read_bootloader_message(bootloader_message* boot, std::string* err); 152 153 // Read bootloader message from the specified misc device into boot. 154 bool read_bootloader_message_from(bootloader_message* boot, const std::string& misc_blk_device, 155 std::string* err); 156 157 // Write bootloader message to BCB. 158 bool write_bootloader_message(const bootloader_message& boot, std::string* err); 159 160 // Write bootloader message to the specified BCB device. 161 bool write_bootloader_message_to(const bootloader_message& boot, 162 const std::string& misc_blk_device, std::string* err); 163 164 // Write bootloader message (boots into recovery with the options) to BCB. Will 165 // set the command and recovery fields, and reset the rest. 166 bool write_bootloader_message(const std::vector<std::string>& options, std::string* err); 167 168 // Write bootloader message (boots into recovery with the options) to the specific BCB device. Will 169 // set the command and recovery fields, and reset the rest. 170 bool write_bootloader_message_to(const std::vector<std::string>& options, 171 const std::string& misc_blk_device, std::string* err); 172 173 // Update bootloader message (boots into recovery with the options) to BCB. Will 174 // only update the command and recovery fields. 175 bool update_bootloader_message(const std::vector<std::string>& options, std::string* err); 176 177 // Update bootloader message (boots into recovery with the |options|) in |boot|. Will only update 178 // the command and recovery fields. 179 bool update_bootloader_message_in_struct(bootloader_message* boot, 180 const std::vector<std::string>& options); 181 182 // Clear BCB. 183 bool clear_bootloader_message(std::string* err); 184 185 // Writes the reboot-bootloader reboot reason to the bootloader_message. 186 bool write_reboot_bootloader(std::string* err); 187 188 // Read the wipe package from BCB (from offset WIPE_PACKAGE_OFFSET_IN_MISC). 189 bool read_wipe_package(std::string* package_data, size_t size, std::string* err); 190 191 // Write the wipe package into BCB (to offset WIPE_PACKAGE_OFFSET_IN_MISC). 192 bool write_wipe_package(const std::string& package_data, std::string* err); 193 194 // Read or write the Virtual A/B message from system space in /misc. 195 bool ReadMiscVirtualAbMessage(misc_virtual_ab_message* message, std::string* err); 196 bool WriteMiscVirtualAbMessage(const misc_virtual_ab_message& message, std::string* err); 197 198 // Read or write the memtag message from system space in /misc. 199 bool ReadMiscMemtagMessage(misc_memtag_message* message, std::string* err); 200 bool WriteMiscMemtagMessage(const misc_memtag_message& message, std::string* err); 201 #else 202 203 #include <stdbool.h> 204 205 // C Interface. 206 bool write_bootloader_message(const char* options); 207 bool write_reboot_bootloader(void); 208 209 #endif // ifdef __cplusplus 210 211 #endif // _BOOTLOADER_MESSAGE_H 212