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 113 #if (__STDC_VERSION__ >= 201112L) || defined(__cplusplus) 114 static_assert(sizeof(struct misc_virtual_ab_message) == 64, 115 "struct misc_virtual_ab_message has wrong size"); 116 static_assert(sizeof(struct misc_memtag_message) == 64, 117 "struct misc_memtag_message has wrong size"); 118 #endif 119 120 // This struct is not meant to be used directly, rather, it is to make 121 // computation of offsets easier. New fields must be added to the end. 122 struct misc_system_space_layout { 123 misc_virtual_ab_message virtual_ab_message; 124 misc_memtag_message memtag_message; 125 } __attribute__((packed)); 126 127 #ifdef __cplusplus 128 129 #include <string> 130 #include <vector> 131 132 // Gets the block device name of /misc partition. 133 std::string get_misc_blk_device(std::string* err); 134 // Return the block device name for the bootloader message partition and waits 135 // for the device for up to 10 seconds. In case of error returns the empty 136 // string. 137 std::string get_bootloader_message_blk_device(std::string* err); 138 139 // Writes |size| bytes of data from buffer |p| to |misc_blk_device| at |offset|. If the write fails, 140 // sets the error message in |err|. 141 bool write_misc_partition(const void* p, size_t size, const std::string& misc_blk_device, 142 size_t offset, std::string* err); 143 144 // Read bootloader message into boot. Error message will be set in err. 145 bool read_bootloader_message(bootloader_message* boot, std::string* err); 146 147 // Read bootloader message from the specified misc device into boot. 148 bool read_bootloader_message_from(bootloader_message* boot, const std::string& misc_blk_device, 149 std::string* err); 150 151 // Write bootloader message to BCB. 152 bool write_bootloader_message(const bootloader_message& boot, std::string* err); 153 154 // Write bootloader message to the specified BCB device. 155 bool write_bootloader_message_to(const bootloader_message& boot, 156 const std::string& misc_blk_device, std::string* err); 157 158 // Write bootloader message (boots into recovery with the options) to BCB. Will 159 // set the command and recovery fields, and reset the rest. 160 bool write_bootloader_message(const std::vector<std::string>& options, std::string* err); 161 162 // Write bootloader message (boots into recovery with the options) to the specific BCB device. Will 163 // set the command and recovery fields, and reset the rest. 164 bool write_bootloader_message_to(const std::vector<std::string>& options, 165 const std::string& misc_blk_device, std::string* err); 166 167 // Update bootloader message (boots into recovery with the options) to BCB. Will 168 // only update the command and recovery fields. 169 bool update_bootloader_message(const std::vector<std::string>& options, std::string* err); 170 171 // Update bootloader message (boots into recovery with the |options|) in |boot|. Will only update 172 // the command and recovery fields. 173 bool update_bootloader_message_in_struct(bootloader_message* boot, 174 const std::vector<std::string>& options); 175 176 // Clear BCB. 177 bool clear_bootloader_message(std::string* err); 178 179 // Writes the reboot-bootloader reboot reason to the bootloader_message. 180 bool write_reboot_bootloader(std::string* err); 181 182 // Read the wipe package from BCB (from offset WIPE_PACKAGE_OFFSET_IN_MISC). 183 bool read_wipe_package(std::string* package_data, size_t size, std::string* err); 184 185 // Write the wipe package into BCB (to offset WIPE_PACKAGE_OFFSET_IN_MISC). 186 bool write_wipe_package(const std::string& package_data, std::string* err); 187 188 // Read or write the Virtual A/B message from system space in /misc. 189 bool ReadMiscVirtualAbMessage(misc_virtual_ab_message* message, std::string* err); 190 bool WriteMiscVirtualAbMessage(const misc_virtual_ab_message& message, std::string* err); 191 192 // Read or write the memtag message from system space in /misc. 193 bool ReadMiscMemtagMessage(misc_memtag_message* message, std::string* err); 194 bool WriteMiscMemtagMessage(const misc_memtag_message& message, std::string* err); 195 #else 196 197 #include <stdbool.h> 198 199 // C Interface. 200 bool write_bootloader_message(const char* options); 201 bool write_reboot_bootloader(void); 202 203 #endif // ifdef __cplusplus 204 205 #endif // _BOOTLOADER_MESSAGE_H 206