hw/i386/smbios.c

   1 /*
   2  * SMBIOS Support
   3  *
   4  * Copyright (C) 2009 Hewlett-Packard Development Company, L.P.
   5  *
   6  * Authors:
   7  *  Alex Williamson <alex.williamson@hp.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2.  See
  10  * the COPYING file in the top-level directory.
  11  *
  12  * Contributions after 2012-01-13 are licensed under the terms of the
  13  * GNU GPL, version 2 or (at your option) any later version.
  14  */
  15
  16 #include "qemu/error-report.h"
  17 #include "sysemu/sysemu.h"
  18 #include "hw/i386/smbios.h"
  19 #include "hw/loader.h"
  20
  21 /*
  22  * Structures shared with the BIOS
  23  */
  24 struct smbios_header {
  25     uint16_t length;
  26     uint8_t type;
  27 } QEMU_PACKED;
  28
  29 struct smbios_field {
  30     struct smbios_header header;
  31     uint8_t type;
  32     uint16_t offset;
  33     uint8_t data[];
  34 } QEMU_PACKED;
  35
  36 struct smbios_table {
  37     struct smbios_header header;
  38     uint8_t data[];
  39 } QEMU_PACKED;
  40
  41 #define SMBIOS_FIELD_ENTRY 0
  42 #define SMBIOS_TABLE_ENTRY 1
  43
  44
  45 static uint8_t *smbios_entries;
  46 static size_t smbios_entries_len;
  47 static int smbios_type4_count = 0;
  48
  49 static void smbios_validate_table(void)
  50 {
  51     if (smbios_type4_count && smbios_type4_count != smp_cpus) {
  52         error_report("Number of SMBIOS Type 4 tables must match cpu count");
  53         exit(1);
  54     }
  55 }
  56
  57 uint8_t *smbios_get_table(size_t *length)
  58 {
  59     smbios_validate_table();
  60     *length = smbios_entries_len;
  61     return smbios_entries;
  62 }
  63
  64 /*
  65  * To avoid unresolvable overlaps in data, don't allow both
  66  * tables and fields for the same smbios type.
  67  */
  68 static void smbios_check_collision(int type, int entry)
  69 {
  70     uint16_t *num_entries = (uint16_t *)smbios_entries;
  71     struct smbios_header *header;
  72     char *p;
  73     int i;
  74
  75     if (!num_entries)
  76         return;
  77
  78     p = (char *)(num_entries + 1);
  79
  80     for (i = 0; i < *num_entries; i++) {
  81         header = (struct smbios_header *)p;
  82         if (entry == SMBIOS_TABLE_ENTRY && header->type == SMBIOS_FIELD_ENTRY) {
  83             struct smbios_field *field = (void *)header;
  84             if (type == field->type) {
  85                 error_report("SMBIOS type %d field already defined, "
  86                              "cannot add table", type);
  87                 exit(1);
  88             }
  89         } else if (entry == SMBIOS_FIELD_ENTRY &&
  90                    header->type == SMBIOS_TABLE_ENTRY) {
  91             struct smbios_structure_header *table = (void *)(header + 1);
  92             if (type == table->type) {
  93                 error_report("SMBIOS type %d table already defined, "
  94                              "cannot add field", type);
  95                 exit(1);
  96             }
  97         }
  98         p += le16_to_cpu(header->length);
  99     }
 100 }
 101
 102 void smbios_add_field(int type, int offset, const void *data, size_t len)
 103 {
 104     struct smbios_field *field;
 105
 106     smbios_check_collision(type, SMBIOS_FIELD_ENTRY);
 107
 108     if (!smbios_entries) {
 109         smbios_entries_len = sizeof(uint16_t);
 110         smbios_entries = g_malloc0(smbios_entries_len);
 111     }
 112     smbios_entries = g_realloc(smbios_entries, smbios_entries_len +
 113                                                   sizeof(*field) + len);
 114     field = (struct smbios_field *)(smbios_entries + smbios_entries_len);
 115     field->header.type = SMBIOS_FIELD_ENTRY;
 116     field->header.length = cpu_to_le16(sizeof(*field) + len);
 117
 118     field->type = type;
 119     field->offset = cpu_to_le16(offset);
 120     memcpy(field->data, data, len);
 121
 122     smbios_entries_len += sizeof(*field) + len;
 123     (*(uint16_t *)smbios_entries) =
 124             cpu_to_le16(le16_to_cpu(*(uint16_t *)smbios_entries) + 1);
 125 }
 126
 127 static void smbios_build_type_0_fields(const char *t)
 128 {
 129     char buf[1024];
 130     unsigned char major, minor;
 131
 132     if (get_param_value(buf, sizeof(buf), "vendor", t))
 133         smbios_add_field(0, offsetof(struct smbios_type_0, vendor_str),
 134                          buf, strlen(buf) + 1);
 135     if (get_param_value(buf, sizeof(buf), "version", t))
 136         smbios_add_field(0, offsetof(struct smbios_type_0, bios_version_str),
 137                          buf, strlen(buf) + 1);
 138     if (get_param_value(buf, sizeof(buf), "date", t))
 139         smbios_add_field(0, offsetof(struct smbios_type_0,
 140                                      bios_release_date_str),
 141                          buf, strlen(buf) + 1);
 142     if (get_param_value(buf, sizeof(buf), "release", t)) {
 143         if (sscanf(buf, "%hhu.%hhu", &major, &minor) != 2) {
 144             error_report("Invalid release");
 145             exit(1);
 146         }
 147         smbios_add_field(0, offsetof(struct smbios_type_0,
 148                                      system_bios_major_release),
 149                          &major, 1);
 150         smbios_add_field(0, offsetof(struct smbios_type_0,
 151                                      system_bios_minor_release),
 152                          &minor, 1);
 153     }
 154 }
 155
 156 static void smbios_build_type_1_fields(const char *t)
 157 {
 158     char buf[1024];
 159
 160     if (get_param_value(buf, sizeof(buf), "manufacturer", t))
 161         smbios_add_field(1, offsetof(struct smbios_type_1, manufacturer_str),
 162                          buf, strlen(buf) + 1);
 163     if (get_param_value(buf, sizeof(buf), "product", t))
 164         smbios_add_field(1, offsetof(struct smbios_type_1, product_name_str),
 165                          buf, strlen(buf) + 1);
 166     if (get_param_value(buf, sizeof(buf), "version", t))
 167         smbios_add_field(1, offsetof(struct smbios_type_1, version_str),
 168                          buf, strlen(buf) + 1);
 169     if (get_param_value(buf, sizeof(buf), "serial", t))
 170         smbios_add_field(1, offsetof(struct smbios_type_1, serial_number_str),
 171                          buf, strlen(buf) + 1);
 172     if (get_param_value(buf, sizeof(buf), "uuid", t)) {
 173         if (qemu_uuid_parse(buf, qemu_uuid) != 0) {
 174             error_report("Invalid UUID");
 175             exit(1);
 176         }
 177     }
 178     if (get_param_value(buf, sizeof(buf), "sku", t))
 179         smbios_add_field(1, offsetof(struct smbios_type_1, sku_number_str),
 180                          buf, strlen(buf) + 1);
 181     if (get_param_value(buf, sizeof(buf), "family", t))
 182         smbios_add_field(1, offsetof(struct smbios_type_1, family_str),
 183                          buf, strlen(buf) + 1);
 184 }
 185
 186 int smbios_entry_add(const char *t)
 187 {
 188     char buf[1024];
 189
 190     if (get_param_value(buf, sizeof(buf), "file", t)) {
 191         struct smbios_structure_header *header;
 192         struct smbios_table *table;
 193         int size = get_image_size(buf);
 194
 195         if (size == -1 || size < sizeof(struct smbios_structure_header)) {
 196             error_report("Cannot read SMBIOS file %s", buf);
 197             exit(1);
 198         }
 199
 200         if (!smbios_entries) {
 201             smbios_entries_len = sizeof(uint16_t);
 202             smbios_entries = g_malloc0(smbios_entries_len);
 203         }
 204
 205         smbios_entries = g_realloc(smbios_entries, smbios_entries_len +
 206                                                       sizeof(*table) + size);
 207         table = (struct smbios_table *)(smbios_entries + smbios_entries_len);
 208         table->header.type = SMBIOS_TABLE_ENTRY;
 209         table->header.length = cpu_to_le16(sizeof(*table) + size);
 210
 211         if (load_image(buf, table->data) != size) {
 212             error_report("Failed to load SMBIOS file %s", buf);
 213             exit(1);
 214         }
 215
 216         header = (struct smbios_structure_header *)(table->data);
 217         smbios_check_collision(header->type, SMBIOS_TABLE_ENTRY);
 218         if (header->type == 4) {
 219             smbios_type4_count++;
 220         }
 221
 222         smbios_entries_len += sizeof(*table) + size;
 223         (*(uint16_t *)smbios_entries) =
 224                 cpu_to_le16(le16_to_cpu(*(uint16_t *)smbios_entries) + 1);
 225         return 0;
 226     }
 227
 228     if (get_param_value(buf, sizeof(buf), "type", t)) {
 229         unsigned long type = strtoul(buf, NULL, 0);
 230         switch (type) {
 231         case 0:
 232             smbios_build_type_0_fields(t);
 233             return 0;
 234         case 1:
 235             smbios_build_type_1_fields(t);
 236             return 0;
 237         default:
 238             error_report("Don't know how to build fields for SMBIOS type %ld",
 239                          type);
 240             exit(1);
 241         }
 242     }
 243
 244     error_report("Must specify type= or file=");
 245     return -1;
 246 }