1 /* Dynamic linker/loader of ACPI tables 2 * 3 * Copyright (C) 2013 Red Hat Inc 4 * 5 * Author: Michael S. Tsirkin <mst@redhat.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 17 * You should have received a copy of the GNU General Public License along 18 * with this program; if not, see <http://www.gnu.org/licenses/>. 19 */ 20 21 #include "qemu/osdep.h" 22 #include "qemu-common.h" 23 #include "hw/acpi/bios-linker-loader.h" 24 #include "hw/nvram/fw_cfg.h" 25 26 #include "qemu/bswap.h" 27 28 /* 29 * Linker/loader is a paravirtualized interface that passes commands to guest. 30 * The commands can be used to request guest to 31 * - allocate memory chunks and initialize them from QEMU FW CFG files 32 * - link allocated chunks by storing pointer to one chunk into another 33 * - calculate ACPI checksum of part of the chunk and store into same chunk 34 */ 35 #define BIOS_LINKER_LOADER_FILESZ FW_CFG_MAX_FILE_PATH 36 37 struct BiosLinkerLoaderEntry { 38 uint32_t command; 39 union { 40 /* 41 * COMMAND_ALLOCATE - allocate a table from @alloc.file 42 * subject to @alloc.align alignment (must be power of 2) 43 * and @alloc.zone (can be HIGH or FSEG) requirements. 44 * 45 * Must appear exactly once for each file, and before 46 * this file is referenced by any other command. 47 */ 48 struct { 49 char file[BIOS_LINKER_LOADER_FILESZ]; 50 uint32_t align; 51 uint8_t zone; 52 } alloc; 53 54 /* 55 * COMMAND_ADD_POINTER - patch the table (originating from 56 * @dest_file) at @pointer.offset, by adding a pointer to the table 57 * originating from @src_file. 1,2,4 or 8 byte unsigned 58 * addition is used depending on @pointer.size. 59 */ 60 struct { 61 char dest_file[BIOS_LINKER_LOADER_FILESZ]; 62 char src_file[BIOS_LINKER_LOADER_FILESZ]; 63 uint32_t offset; 64 uint8_t size; 65 } pointer; 66 67 /* 68 * COMMAND_ADD_CHECKSUM - calculate checksum of the range specified by 69 * @cksum_start and @cksum_length fields, 70 * and then add the value at @cksum.offset. 71 * Checksum simply sums -X for each byte X in the range 72 * using 8-bit math. 73 */ 74 struct { 75 char file[BIOS_LINKER_LOADER_FILESZ]; 76 uint32_t offset; 77 uint32_t start; 78 uint32_t length; 79 } cksum; 80 81 /* 82 * COMMAND_WRITE_POINTER - write the fw_cfg file (originating from 83 * @dest_file) at @wr_pointer.offset, by adding a pointer to 84 * @src_offset within the table originating from @src_file. 85 * 1,2,4 or 8 byte unsigned addition is used depending on 86 * @wr_pointer.size. 87 */ 88 struct { 89 char dest_file[BIOS_LINKER_LOADER_FILESZ]; 90 char src_file[BIOS_LINKER_LOADER_FILESZ]; 91 uint32_t dst_offset; 92 uint32_t src_offset; 93 uint8_t size; 94 } wr_pointer; 95 96 /* padding */ 97 char pad[124]; 98 }; 99 } QEMU_PACKED; 100 typedef struct BiosLinkerLoaderEntry BiosLinkerLoaderEntry; 101 102 enum { 103 BIOS_LINKER_LOADER_COMMAND_ALLOCATE = 0x1, 104 BIOS_LINKER_LOADER_COMMAND_ADD_POINTER = 0x2, 105 BIOS_LINKER_LOADER_COMMAND_ADD_CHECKSUM = 0x3, 106 BIOS_LINKER_LOADER_COMMAND_WRITE_POINTER = 0x4, 107 }; 108 109 enum { 110 BIOS_LINKER_LOADER_ALLOC_ZONE_HIGH = 0x1, 111 BIOS_LINKER_LOADER_ALLOC_ZONE_FSEG = 0x2, 112 }; 113 114 /* 115 * BiosLinkerFileEntry: 116 * 117 * An internal type used for book-keeping file entries 118 */ 119 typedef struct BiosLinkerFileEntry { 120 char *name; /* file name */ 121 GArray *blob; /* data accosiated with @name */ 122 } BiosLinkerFileEntry; 123 124 /* 125 * bios_linker_loader_init: allocate a new linker object instance. 126 * 127 * After initialization, linker commands can be added, and will 128 * be stored in the linker.cmd_blob array. 129 */ 130 BIOSLinker *bios_linker_loader_init(void) 131 { 132 BIOSLinker *linker = g_new(BIOSLinker, 1); 133 134 linker->cmd_blob = g_array_new(false, true /* clear */, 1); 135 linker->file_list = g_array_new(false, true /* clear */, 136 sizeof(BiosLinkerFileEntry)); 137 return linker; 138 } 139 140 /* Free linker wrapper */ 141 void bios_linker_loader_cleanup(BIOSLinker *linker) 142 { 143 int i; 144 BiosLinkerFileEntry *entry; 145 146 g_array_free(linker->cmd_blob, true); 147 148 for (i = 0; i < linker->file_list->len; i++) { 149 entry = &g_array_index(linker->file_list, BiosLinkerFileEntry, i); 150 g_free(entry->name); 151 } 152 g_array_free(linker->file_list, true); 153 g_free(linker); 154 } 155 156 static const BiosLinkerFileEntry * 157 bios_linker_find_file(const BIOSLinker *linker, const char *name) 158 { 159 int i; 160 BiosLinkerFileEntry *entry; 161 162 for (i = 0; i < linker->file_list->len; i++) { 163 entry = &g_array_index(linker->file_list, BiosLinkerFileEntry, i); 164 if (!strcmp(entry->name, name)) { 165 return entry; 166 } 167 } 168 return NULL; 169 } 170 171 /* 172 * bios_linker_loader_alloc: ask guest to load file into guest memory. 173 * 174 * @linker: linker object instance 175 * @file_name: name of the file blob to be loaded 176 * @file_blob: pointer to blob corresponding to @file_name 177 * @alloc_align: required minimal alignment in bytes. Must be a power of 2. 178 * @alloc_fseg: request allocation in FSEG zone (useful for the RSDP ACPI table) 179 * 180 * Note: this command must precede any other linker command using this file. 181 */ 182 void bios_linker_loader_alloc(BIOSLinker *linker, 183 const char *file_name, 184 GArray *file_blob, 185 uint32_t alloc_align, 186 bool alloc_fseg) 187 { 188 BiosLinkerLoaderEntry entry; 189 BiosLinkerFileEntry file = { g_strdup(file_name), file_blob}; 190 191 assert(!(alloc_align & (alloc_align - 1))); 192 193 assert(!bios_linker_find_file(linker, file_name)); 194 g_array_append_val(linker->file_list, file); 195 196 memset(&entry, 0, sizeof entry); 197 strncpy(entry.alloc.file, file_name, sizeof entry.alloc.file - 1); 198 entry.command = cpu_to_le32(BIOS_LINKER_LOADER_COMMAND_ALLOCATE); 199 entry.alloc.align = cpu_to_le32(alloc_align); 200 entry.alloc.zone = alloc_fseg ? BIOS_LINKER_LOADER_ALLOC_ZONE_FSEG : 201 BIOS_LINKER_LOADER_ALLOC_ZONE_HIGH; 202 203 /* Alloc entries must come first, so prepend them */ 204 g_array_prepend_vals(linker->cmd_blob, &entry, sizeof entry); 205 } 206 207 /* 208 * bios_linker_loader_add_checksum: ask guest to add checksum of ACPI 209 * table in the specified file at the specified offset. 210 * 211 * Checksum calculation simply sums -X for each byte X in the range 212 * using 8-bit math (i.e. ACPI checksum). 213 * 214 * @linker: linker object instance 215 * @file: file that includes the checksum to be calculated 216 * and the data to be checksummed 217 * @start_offset, @size: range of data in the file to checksum, 218 * relative to the start of file blob 219 * @checksum_offset: location of the checksum to be patched within file blob, 220 * relative to the start of file blob 221 */ 222 void bios_linker_loader_add_checksum(BIOSLinker *linker, const char *file_name, 223 unsigned start_offset, unsigned size, 224 unsigned checksum_offset) 225 { 226 BiosLinkerLoaderEntry entry; 227 const BiosLinkerFileEntry *file = bios_linker_find_file(linker, file_name); 228 229 assert(file); 230 assert(start_offset < file->blob->len); 231 assert(start_offset + size <= file->blob->len); 232 assert(checksum_offset >= start_offset); 233 assert(checksum_offset + 1 <= start_offset + size); 234 235 *(file->blob->data + checksum_offset) = 0; 236 memset(&entry, 0, sizeof entry); 237 strncpy(entry.cksum.file, file_name, sizeof entry.cksum.file - 1); 238 entry.command = cpu_to_le32(BIOS_LINKER_LOADER_COMMAND_ADD_CHECKSUM); 239 entry.cksum.offset = cpu_to_le32(checksum_offset); 240 entry.cksum.start = cpu_to_le32(start_offset); 241 entry.cksum.length = cpu_to_le32(size); 242 243 g_array_append_vals(linker->cmd_blob, &entry, sizeof entry); 244 } 245 246 /* 247 * bios_linker_loader_add_pointer: ask guest to patch address in 248 * destination file with a pointer to source file 249 * 250 * @linker: linker object instance 251 * @dest_file: destination file that must be changed 252 * @dst_patched_offset: location within destination file blob to be patched 253 * with the pointer to @src_file+@src_offset (i.e. source 254 * blob allocated in guest memory + @src_offset), in bytes 255 * @dst_patched_offset_size: size of the pointer to be patched 256 * at @dst_patched_offset in @dest_file blob, in bytes 257 * @src_file: source file who's address must be taken 258 * @src_offset: location within source file blob to which 259 * @dest_file+@dst_patched_offset will point to after 260 * firmware's executed ADD_POINTER command 261 */ 262 void bios_linker_loader_add_pointer(BIOSLinker *linker, 263 const char *dest_file, 264 uint32_t dst_patched_offset, 265 uint8_t dst_patched_size, 266 const char *src_file, 267 uint32_t src_offset) 268 { 269 uint64_t le_src_offset; 270 BiosLinkerLoaderEntry entry; 271 const BiosLinkerFileEntry *dst_file = 272 bios_linker_find_file(linker, dest_file); 273 const BiosLinkerFileEntry *source_file = 274 bios_linker_find_file(linker, src_file); 275 276 assert(dst_patched_offset < dst_file->blob->len); 277 assert(dst_patched_offset + dst_patched_size <= dst_file->blob->len); 278 assert(src_offset < source_file->blob->len); 279 280 memset(&entry, 0, sizeof entry); 281 strncpy(entry.pointer.dest_file, dest_file, 282 sizeof entry.pointer.dest_file - 1); 283 strncpy(entry.pointer.src_file, src_file, 284 sizeof entry.pointer.src_file - 1); 285 entry.command = cpu_to_le32(BIOS_LINKER_LOADER_COMMAND_ADD_POINTER); 286 entry.pointer.offset = cpu_to_le32(dst_patched_offset); 287 entry.pointer.size = dst_patched_size; 288 assert(dst_patched_size == 1 || dst_patched_size == 2 || 289 dst_patched_size == 4 || dst_patched_size == 8); 290 291 le_src_offset = cpu_to_le64(src_offset); 292 memcpy(dst_file->blob->data + dst_patched_offset, 293 &le_src_offset, dst_patched_size); 294 295 g_array_append_vals(linker->cmd_blob, &entry, sizeof entry); 296 } 297 298 /* 299 * bios_linker_loader_write_pointer: ask guest to write a pointer to the 300 * source file into the destination file, and write it back to QEMU via 301 * fw_cfg DMA. 302 * 303 * @linker: linker object instance 304 * @dest_file: destination file that must be written 305 * @dst_patched_offset: location within destination file blob to be patched 306 * with the pointer to @src_file, in bytes 307 * @dst_patched_offset_size: size of the pointer to be patched 308 * at @dst_patched_offset in @dest_file blob, in bytes 309 * @src_file: source file who's address must be taken 310 * @src_offset: location within source file blob to which 311 * @dest_file+@dst_patched_offset will point to after 312 * firmware's executed WRITE_POINTER command 313 */ 314 void bios_linker_loader_write_pointer(BIOSLinker *linker, 315 const char *dest_file, 316 uint32_t dst_patched_offset, 317 uint8_t dst_patched_size, 318 const char *src_file, 319 uint32_t src_offset) 320 { 321 BiosLinkerLoaderEntry entry; 322 const BiosLinkerFileEntry *source_file = 323 bios_linker_find_file(linker, src_file); 324 325 assert(source_file); 326 assert(src_offset < source_file->blob->len); 327 memset(&entry, 0, sizeof entry); 328 strncpy(entry.wr_pointer.dest_file, dest_file, 329 sizeof entry.wr_pointer.dest_file - 1); 330 strncpy(entry.wr_pointer.src_file, src_file, 331 sizeof entry.wr_pointer.src_file - 1); 332 entry.command = cpu_to_le32(BIOS_LINKER_LOADER_COMMAND_WRITE_POINTER); 333 entry.wr_pointer.dst_offset = cpu_to_le32(dst_patched_offset); 334 entry.wr_pointer.src_offset = cpu_to_le32(src_offset); 335 entry.wr_pointer.size = dst_patched_size; 336 assert(dst_patched_size == 1 || dst_patched_size == 2 || 337 dst_patched_size == 4 || dst_patched_size == 8); 338 339 g_array_append_vals(linker->cmd_blob, &entry, sizeof entry); 340 } 341