4 * Copyright (C) 2009 Hewlett-Packard Development Company, L.P.
5 * Copyright (C) 2013 Red Hat, Inc.
8 * Alex Williamson <alex.williamson@hp.com>
9 * Markus Armbruster <armbru@redhat.com>
11 * This work is licensed under the terms of the GNU GPL, version 2. See
12 * the COPYING file in the top-level directory.
14 * Contributions after 2012-01-13 are licensed under the terms of the
15 * GNU GPL, version 2 or (at your option) any later version.
18 #include "qemu/osdep.h"
19 #include "qapi/error.h"
20 #include "qemu/config-file.h"
21 #include "qemu/error-report.h"
22 #include "sysemu/sysemu.h"
23 #include "sysemu/cpus.h"
24 #include "hw/smbios/smbios.h"
25 #include "hw/loader.h"
26 #include "exec/cpu-common.h"
27 #include "smbios_build.h"
28 #include "hw/smbios/ipmi.h"
30 /* legacy structures and constants for <= 2.0 machines */
31 struct smbios_header
{
37 struct smbios_header header
;
44 struct smbios_header header
;
48 #define SMBIOS_FIELD_ENTRY 0
49 #define SMBIOS_TABLE_ENTRY 1
51 static uint8_t *smbios_entries
;
52 static size_t smbios_entries_len
;
53 static bool smbios_legacy
= true;
54 static bool smbios_uuid_encoded
= true;
55 /* end: legacy structures & constants for <= 2.0 machines */
58 uint8_t *smbios_tables
;
59 size_t smbios_tables_len
;
60 unsigned smbios_table_max
;
61 unsigned smbios_table_cnt
;
62 static SmbiosEntryPointType smbios_ep_type
= SMBIOS_ENTRY_POINT_21
;
64 static SmbiosEntryPoint ep
;
66 static int smbios_type4_count
= 0;
67 static bool smbios_immutable
;
68 static bool smbios_have_defaults
;
69 static uint32_t smbios_cpuid_version
, smbios_cpuid_features
, smbios_smp_sockets
;
71 static DECLARE_BITMAP(have_binfile_bitmap
, SMBIOS_MAX_TYPE
+1);
72 static DECLARE_BITMAP(have_fields_bitmap
, SMBIOS_MAX_TYPE
+1);
75 const char *vendor
, *version
, *date
;
76 bool have_major_minor
, uefi
;
81 const char *manufacturer
, *product
, *version
, *serial
, *sku
, *family
;
82 /* uuid is in qemu_uuid[] */
86 const char *manufacturer
, *product
, *version
, *serial
, *asset
, *location
;
90 const char *manufacturer
, *version
, *serial
, *asset
, *sku
;
94 const char *sock_pfx
, *manufacturer
, *version
, *serial
, *asset
, *part
;
98 const char *loc_pfx
, *bank
, *manufacturer
, *serial
, *asset
, *part
;
102 static QemuOptsList qemu_smbios_opts
= {
104 .head
= QTAILQ_HEAD_INITIALIZER(qemu_smbios_opts
.head
),
107 * no elements => accept any params
108 * validation will happen later
110 { /* end of list */ }
114 static const QemuOptDesc qemu_smbios_file_opts
[] = {
117 .type
= QEMU_OPT_STRING
,
118 .help
= "binary file containing an SMBIOS element",
120 { /* end of list */ }
123 static const QemuOptDesc qemu_smbios_type0_opts
[] = {
126 .type
= QEMU_OPT_NUMBER
,
127 .help
= "SMBIOS element type",
130 .type
= QEMU_OPT_STRING
,
131 .help
= "vendor name",
134 .type
= QEMU_OPT_STRING
,
135 .help
= "version number",
138 .type
= QEMU_OPT_STRING
,
139 .help
= "release date",
142 .type
= QEMU_OPT_STRING
,
143 .help
= "revision number",
146 .type
= QEMU_OPT_BOOL
,
147 .help
= "uefi support",
149 { /* end of list */ }
152 static const QemuOptDesc qemu_smbios_type1_opts
[] = {
155 .type
= QEMU_OPT_NUMBER
,
156 .help
= "SMBIOS element type",
158 .name
= "manufacturer",
159 .type
= QEMU_OPT_STRING
,
160 .help
= "manufacturer name",
163 .type
= QEMU_OPT_STRING
,
164 .help
= "product name",
167 .type
= QEMU_OPT_STRING
,
168 .help
= "version number",
171 .type
= QEMU_OPT_STRING
,
172 .help
= "serial number",
175 .type
= QEMU_OPT_STRING
,
179 .type
= QEMU_OPT_STRING
,
180 .help
= "SKU number",
183 .type
= QEMU_OPT_STRING
,
184 .help
= "family name",
186 { /* end of list */ }
189 static const QemuOptDesc qemu_smbios_type2_opts
[] = {
192 .type
= QEMU_OPT_NUMBER
,
193 .help
= "SMBIOS element type",
195 .name
= "manufacturer",
196 .type
= QEMU_OPT_STRING
,
197 .help
= "manufacturer name",
200 .type
= QEMU_OPT_STRING
,
201 .help
= "product name",
204 .type
= QEMU_OPT_STRING
,
205 .help
= "version number",
208 .type
= QEMU_OPT_STRING
,
209 .help
= "serial number",
212 .type
= QEMU_OPT_STRING
,
213 .help
= "asset tag number",
216 .type
= QEMU_OPT_STRING
,
217 .help
= "location in chassis",
219 { /* end of list */ }
222 static const QemuOptDesc qemu_smbios_type3_opts
[] = {
225 .type
= QEMU_OPT_NUMBER
,
226 .help
= "SMBIOS element type",
228 .name
= "manufacturer",
229 .type
= QEMU_OPT_STRING
,
230 .help
= "manufacturer name",
233 .type
= QEMU_OPT_STRING
,
234 .help
= "version number",
237 .type
= QEMU_OPT_STRING
,
238 .help
= "serial number",
241 .type
= QEMU_OPT_STRING
,
242 .help
= "asset tag number",
245 .type
= QEMU_OPT_STRING
,
246 .help
= "SKU number",
248 { /* end of list */ }
251 static const QemuOptDesc qemu_smbios_type4_opts
[] = {
254 .type
= QEMU_OPT_NUMBER
,
255 .help
= "SMBIOS element type",
258 .type
= QEMU_OPT_STRING
,
259 .help
= "socket designation string prefix",
261 .name
= "manufacturer",
262 .type
= QEMU_OPT_STRING
,
263 .help
= "manufacturer name",
266 .type
= QEMU_OPT_STRING
,
267 .help
= "version number",
270 .type
= QEMU_OPT_STRING
,
271 .help
= "serial number",
274 .type
= QEMU_OPT_STRING
,
275 .help
= "asset tag number",
278 .type
= QEMU_OPT_STRING
,
279 .help
= "part number",
281 { /* end of list */ }
284 static const QemuOptDesc qemu_smbios_type17_opts
[] = {
287 .type
= QEMU_OPT_NUMBER
,
288 .help
= "SMBIOS element type",
291 .type
= QEMU_OPT_STRING
,
292 .help
= "device locator string prefix",
295 .type
= QEMU_OPT_STRING
,
296 .help
= "bank locator string",
298 .name
= "manufacturer",
299 .type
= QEMU_OPT_STRING
,
300 .help
= "manufacturer name",
303 .type
= QEMU_OPT_STRING
,
304 .help
= "serial number",
307 .type
= QEMU_OPT_STRING
,
308 .help
= "asset tag number",
311 .type
= QEMU_OPT_STRING
,
312 .help
= "part number",
315 .type
= QEMU_OPT_NUMBER
,
316 .help
= "maximum capable speed",
318 { /* end of list */ }
321 static void smbios_register_config(void)
323 qemu_add_opts(&qemu_smbios_opts
);
326 opts_init(smbios_register_config
);
328 static void smbios_validate_table(void)
330 uint32_t expect_t4_count
= smbios_legacy
? smp_cpus
: smbios_smp_sockets
;
332 if (smbios_type4_count
&& smbios_type4_count
!= expect_t4_count
) {
333 error_report("Expected %d SMBIOS Type 4 tables, got %d instead",
334 expect_t4_count
, smbios_type4_count
);
340 /* legacy setup functions for <= 2.0 machines */
341 static void smbios_add_field(int type
, int offset
, const void *data
, size_t len
)
343 struct smbios_field
*field
;
345 if (!smbios_entries
) {
346 smbios_entries_len
= sizeof(uint16_t);
347 smbios_entries
= g_malloc0(smbios_entries_len
);
349 smbios_entries
= g_realloc(smbios_entries
, smbios_entries_len
+
350 sizeof(*field
) + len
);
351 field
= (struct smbios_field
*)(smbios_entries
+ smbios_entries_len
);
352 field
->header
.type
= SMBIOS_FIELD_ENTRY
;
353 field
->header
.length
= cpu_to_le16(sizeof(*field
) + len
);
356 field
->offset
= cpu_to_le16(offset
);
357 memcpy(field
->data
, data
, len
);
359 smbios_entries_len
+= sizeof(*field
) + len
;
360 (*(uint16_t *)smbios_entries
) =
361 cpu_to_le16(le16_to_cpu(*(uint16_t *)smbios_entries
) + 1);
364 static void smbios_maybe_add_str(int type
, int offset
, const char *data
)
367 smbios_add_field(type
, offset
, data
, strlen(data
) + 1);
371 static void smbios_build_type_0_fields(void)
373 smbios_maybe_add_str(0, offsetof(struct smbios_type_0
, vendor_str
),
375 smbios_maybe_add_str(0, offsetof(struct smbios_type_0
, bios_version_str
),
377 smbios_maybe_add_str(0, offsetof(struct smbios_type_0
,
378 bios_release_date_str
),
380 if (type0
.have_major_minor
) {
381 smbios_add_field(0, offsetof(struct smbios_type_0
,
382 system_bios_major_release
),
384 smbios_add_field(0, offsetof(struct smbios_type_0
,
385 system_bios_minor_release
),
390 static void smbios_build_type_1_fields(void)
392 smbios_maybe_add_str(1, offsetof(struct smbios_type_1
, manufacturer_str
),
394 smbios_maybe_add_str(1, offsetof(struct smbios_type_1
, product_name_str
),
396 smbios_maybe_add_str(1, offsetof(struct smbios_type_1
, version_str
),
398 smbios_maybe_add_str(1, offsetof(struct smbios_type_1
, serial_number_str
),
400 smbios_maybe_add_str(1, offsetof(struct smbios_type_1
, sku_number_str
),
402 smbios_maybe_add_str(1, offsetof(struct smbios_type_1
, family_str
),
405 /* We don't encode the UUID in the "wire format" here because this
406 * function is for legacy mode and needs to keep the guest ABI, and
407 * because we don't know what's the SMBIOS version advertised by the
410 smbios_add_field(1, offsetof(struct smbios_type_1
, uuid
),
415 uint8_t *smbios_get_table_legacy(size_t *length
)
417 if (!smbios_legacy
) {
422 if (!smbios_immutable
) {
423 smbios_build_type_0_fields();
424 smbios_build_type_1_fields();
425 smbios_validate_table();
426 smbios_immutable
= true;
428 *length
= smbios_entries_len
;
429 return smbios_entries
;
431 /* end: legacy setup functions for <= 2.0 machines */
434 bool smbios_skip_table(uint8_t type
, bool required_table
)
436 if (test_bit(type
, have_binfile_bitmap
)) {
437 return true; /* user provided their own binary blob(s) */
439 if (test_bit(type
, have_fields_bitmap
)) {
440 return false; /* user provided fields via command line */
442 if (smbios_have_defaults
&& required_table
) {
443 return false; /* we're building tables, and this one's required */
448 static void smbios_build_type_0_table(void)
450 SMBIOS_BUILD_TABLE_PRE(0, 0x000, false); /* optional, leave up to BIOS */
452 SMBIOS_TABLE_SET_STR(0, vendor_str
, type0
.vendor
);
453 SMBIOS_TABLE_SET_STR(0, bios_version_str
, type0
.version
);
455 t
->bios_starting_address_segment
= cpu_to_le16(0xE800); /* from SeaBIOS */
457 SMBIOS_TABLE_SET_STR(0, bios_release_date_str
, type0
.date
);
459 t
->bios_rom_size
= 0; /* hardcoded in SeaBIOS with FIXME comment */
461 t
->bios_characteristics
= cpu_to_le64(0x08); /* Not supported */
462 t
->bios_characteristics_extension_bytes
[0] = 0;
463 t
->bios_characteristics_extension_bytes
[1] = 0x14; /* TCD/SVVP | VM */
465 t
->bios_characteristics_extension_bytes
[1] |= 0x08; /* |= UEFI */
468 if (type0
.have_major_minor
) {
469 t
->system_bios_major_release
= type0
.major
;
470 t
->system_bios_minor_release
= type0
.minor
;
472 t
->system_bios_major_release
= 0;
473 t
->system_bios_minor_release
= 0;
476 /* hardcoded in SeaBIOS */
477 t
->embedded_controller_major_release
= 0xFF;
478 t
->embedded_controller_minor_release
= 0xFF;
480 SMBIOS_BUILD_TABLE_POST
;
483 /* Encode UUID from the big endian encoding described on RFC4122 to the wire
484 * format specified by SMBIOS version 2.6.
486 static void smbios_encode_uuid(struct smbios_uuid
*uuid
, const uint8_t *buf
)
488 memcpy(uuid
, buf
, 16);
489 if (smbios_uuid_encoded
) {
490 uuid
->time_low
= bswap32(uuid
->time_low
);
491 uuid
->time_mid
= bswap16(uuid
->time_mid
);
492 uuid
->time_hi_and_version
= bswap16(uuid
->time_hi_and_version
);
496 static void smbios_build_type_1_table(void)
498 SMBIOS_BUILD_TABLE_PRE(1, 0x100, true); /* required */
500 SMBIOS_TABLE_SET_STR(1, manufacturer_str
, type1
.manufacturer
);
501 SMBIOS_TABLE_SET_STR(1, product_name_str
, type1
.product
);
502 SMBIOS_TABLE_SET_STR(1, version_str
, type1
.version
);
503 SMBIOS_TABLE_SET_STR(1, serial_number_str
, type1
.serial
);
505 smbios_encode_uuid(&t
->uuid
, qemu_uuid
);
507 memset(&t
->uuid
, 0, 16);
509 t
->wake_up_type
= 0x06; /* power switch */
510 SMBIOS_TABLE_SET_STR(1, sku_number_str
, type1
.sku
);
511 SMBIOS_TABLE_SET_STR(1, family_str
, type1
.family
);
513 SMBIOS_BUILD_TABLE_POST
;
516 static void smbios_build_type_2_table(void)
518 SMBIOS_BUILD_TABLE_PRE(2, 0x200, false); /* optional */
520 SMBIOS_TABLE_SET_STR(2, manufacturer_str
, type2
.manufacturer
);
521 SMBIOS_TABLE_SET_STR(2, product_str
, type2
.product
);
522 SMBIOS_TABLE_SET_STR(2, version_str
, type2
.version
);
523 SMBIOS_TABLE_SET_STR(2, serial_number_str
, type2
.serial
);
524 SMBIOS_TABLE_SET_STR(2, asset_tag_number_str
, type2
.asset
);
525 t
->feature_flags
= 0x01; /* Motherboard */
526 SMBIOS_TABLE_SET_STR(2, location_str
, type2
.location
);
527 t
->chassis_handle
= cpu_to_le16(0x300); /* Type 3 (System enclosure) */
528 t
->board_type
= 0x0A; /* Motherboard */
529 t
->contained_element_count
= 0;
531 SMBIOS_BUILD_TABLE_POST
;
534 static void smbios_build_type_3_table(void)
536 SMBIOS_BUILD_TABLE_PRE(3, 0x300, true); /* required */
538 SMBIOS_TABLE_SET_STR(3, manufacturer_str
, type3
.manufacturer
);
539 t
->type
= 0x01; /* Other */
540 SMBIOS_TABLE_SET_STR(3, version_str
, type3
.version
);
541 SMBIOS_TABLE_SET_STR(3, serial_number_str
, type3
.serial
);
542 SMBIOS_TABLE_SET_STR(3, asset_tag_number_str
, type3
.asset
);
543 t
->boot_up_state
= 0x03; /* Safe */
544 t
->power_supply_state
= 0x03; /* Safe */
545 t
->thermal_state
= 0x03; /* Safe */
546 t
->security_status
= 0x02; /* Unknown */
547 t
->oem_defined
= cpu_to_le32(0);
549 t
->number_of_power_cords
= 0;
550 t
->contained_element_count
= 0;
551 SMBIOS_TABLE_SET_STR(3, sku_number_str
, type3
.sku
);
553 SMBIOS_BUILD_TABLE_POST
;
556 static void smbios_build_type_4_table(unsigned instance
)
560 SMBIOS_BUILD_TABLE_PRE(4, 0x400 + instance
, true); /* required */
562 snprintf(sock_str
, sizeof(sock_str
), "%s%2x", type4
.sock_pfx
, instance
);
563 SMBIOS_TABLE_SET_STR(4, socket_designation_str
, sock_str
);
564 t
->processor_type
= 0x03; /* CPU */
565 t
->processor_family
= 0x01; /* Other */
566 SMBIOS_TABLE_SET_STR(4, processor_manufacturer_str
, type4
.manufacturer
);
567 t
->processor_id
[0] = cpu_to_le32(smbios_cpuid_version
);
568 t
->processor_id
[1] = cpu_to_le32(smbios_cpuid_features
);
569 SMBIOS_TABLE_SET_STR(4, processor_version_str
, type4
.version
);
571 t
->external_clock
= cpu_to_le16(0); /* Unknown */
572 /* SVVP requires max_speed and current_speed to not be unknown. */
573 t
->max_speed
= cpu_to_le16(2000); /* 2000 MHz */
574 t
->current_speed
= cpu_to_le16(2000); /* 2000 MHz */
575 t
->status
= 0x41; /* Socket populated, CPU enabled */
576 t
->processor_upgrade
= 0x01; /* Other */
577 t
->l1_cache_handle
= cpu_to_le16(0xFFFF); /* N/A */
578 t
->l2_cache_handle
= cpu_to_le16(0xFFFF); /* N/A */
579 t
->l3_cache_handle
= cpu_to_le16(0xFFFF); /* N/A */
580 SMBIOS_TABLE_SET_STR(4, serial_number_str
, type4
.serial
);
581 SMBIOS_TABLE_SET_STR(4, asset_tag_number_str
, type4
.asset
);
582 SMBIOS_TABLE_SET_STR(4, part_number_str
, type4
.part
);
583 t
->core_count
= t
->core_enabled
= smp_cores
;
584 t
->thread_count
= smp_threads
;
585 t
->processor_characteristics
= cpu_to_le16(0x02); /* Unknown */
586 t
->processor_family2
= cpu_to_le16(0x01); /* Other */
588 SMBIOS_BUILD_TABLE_POST
;
589 smbios_type4_count
++;
592 #define ONE_KB ((ram_addr_t)1 << 10)
593 #define ONE_MB ((ram_addr_t)1 << 20)
594 #define ONE_GB ((ram_addr_t)1 << 30)
596 #define MAX_T16_STD_SZ 0x80000000 /* 2T in Kilobytes */
598 static void smbios_build_type_16_table(unsigned dimm_cnt
)
602 SMBIOS_BUILD_TABLE_PRE(16, 0x1000, true); /* required */
604 t
->location
= 0x01; /* Other */
605 t
->use
= 0x03; /* System memory */
606 t
->error_correction
= 0x06; /* Multi-bit ECC (for Microsoft, per SeaBIOS) */
607 size_kb
= QEMU_ALIGN_UP(ram_size
, ONE_KB
) / ONE_KB
;
608 if (size_kb
< MAX_T16_STD_SZ
) {
609 t
->maximum_capacity
= cpu_to_le32(size_kb
);
610 t
->extended_maximum_capacity
= cpu_to_le64(0);
612 t
->maximum_capacity
= cpu_to_le32(MAX_T16_STD_SZ
);
613 t
->extended_maximum_capacity
= cpu_to_le64(ram_size
);
615 t
->memory_error_information_handle
= cpu_to_le16(0xFFFE); /* Not provided */
616 t
->number_of_memory_devices
= cpu_to_le16(dimm_cnt
);
618 SMBIOS_BUILD_TABLE_POST
;
621 #define MAX_T17_STD_SZ 0x7FFF /* (32G - 1M), in Megabytes */
622 #define MAX_T17_EXT_SZ 0x80000000 /* 2P, in Megabytes */
624 static void smbios_build_type_17_table(unsigned instance
, uint64_t size
)
629 SMBIOS_BUILD_TABLE_PRE(17, 0x1100 + instance
, true); /* required */
631 t
->physical_memory_array_handle
= cpu_to_le16(0x1000); /* Type 16 above */
632 t
->memory_error_information_handle
= cpu_to_le16(0xFFFE); /* Not provided */
633 t
->total_width
= cpu_to_le16(0xFFFF); /* Unknown */
634 t
->data_width
= cpu_to_le16(0xFFFF); /* Unknown */
635 size_mb
= QEMU_ALIGN_UP(size
, ONE_MB
) / ONE_MB
;
636 if (size_mb
< MAX_T17_STD_SZ
) {
637 t
->size
= cpu_to_le16(size_mb
);
638 t
->extended_size
= cpu_to_le32(0);
640 assert(size_mb
< MAX_T17_EXT_SZ
);
641 t
->size
= cpu_to_le16(MAX_T17_STD_SZ
);
642 t
->extended_size
= cpu_to_le32(size_mb
);
644 t
->form_factor
= 0x09; /* DIMM */
645 t
->device_set
= 0; /* Not in a set */
646 snprintf(loc_str
, sizeof(loc_str
), "%s %d", type17
.loc_pfx
, instance
);
647 SMBIOS_TABLE_SET_STR(17, device_locator_str
, loc_str
);
648 SMBIOS_TABLE_SET_STR(17, bank_locator_str
, type17
.bank
);
649 t
->memory_type
= 0x07; /* RAM */
650 t
->type_detail
= cpu_to_le16(0x02); /* Other */
651 t
->speed
= cpu_to_le16(type17
.speed
);
652 SMBIOS_TABLE_SET_STR(17, manufacturer_str
, type17
.manufacturer
);
653 SMBIOS_TABLE_SET_STR(17, serial_number_str
, type17
.serial
);
654 SMBIOS_TABLE_SET_STR(17, asset_tag_number_str
, type17
.asset
);
655 SMBIOS_TABLE_SET_STR(17, part_number_str
, type17
.part
);
656 t
->attributes
= 0; /* Unknown */
657 t
->configured_clock_speed
= t
->speed
; /* reuse value for max speed */
658 t
->minimum_voltage
= cpu_to_le16(0); /* Unknown */
659 t
->maximum_voltage
= cpu_to_le16(0); /* Unknown */
660 t
->configured_voltage
= cpu_to_le16(0); /* Unknown */
662 SMBIOS_BUILD_TABLE_POST
;
665 static void smbios_build_type_19_table(unsigned instance
,
666 uint64_t start
, uint64_t size
)
668 uint64_t end
, start_kb
, end_kb
;
670 SMBIOS_BUILD_TABLE_PRE(19, 0x1300 + instance
, true); /* required */
672 end
= start
+ size
- 1;
674 start_kb
= start
/ ONE_KB
;
675 end_kb
= end
/ ONE_KB
;
676 if (start_kb
< UINT32_MAX
&& end_kb
< UINT32_MAX
) {
677 t
->starting_address
= cpu_to_le32(start_kb
);
678 t
->ending_address
= cpu_to_le32(end_kb
);
679 t
->extended_starting_address
=
680 t
->extended_ending_address
= cpu_to_le64(0);
682 t
->starting_address
= t
->ending_address
= cpu_to_le32(UINT32_MAX
);
683 t
->extended_starting_address
= cpu_to_le64(start
);
684 t
->extended_ending_address
= cpu_to_le64(end
);
686 t
->memory_array_handle
= cpu_to_le16(0x1000); /* Type 16 above */
687 t
->partition_width
= 1; /* One device per row */
689 SMBIOS_BUILD_TABLE_POST
;
692 static void smbios_build_type_32_table(void)
694 SMBIOS_BUILD_TABLE_PRE(32, 0x2000, true); /* required */
696 memset(t
->reserved
, 0, 6);
697 t
->boot_status
= 0; /* No errors detected */
699 SMBIOS_BUILD_TABLE_POST
;
702 static void smbios_build_type_127_table(void)
704 SMBIOS_BUILD_TABLE_PRE(127, 0x7F00, true); /* required */
705 SMBIOS_BUILD_TABLE_POST
;
708 void smbios_set_cpuid(uint32_t version
, uint32_t features
)
710 smbios_cpuid_version
= version
;
711 smbios_cpuid_features
= features
;
714 #define SMBIOS_SET_DEFAULT(field, value) \
719 void smbios_set_defaults(const char *manufacturer
, const char *product
,
720 const char *version
, bool legacy_mode
,
721 bool uuid_encoded
, SmbiosEntryPointType ep_type
)
723 smbios_have_defaults
= true;
724 smbios_legacy
= legacy_mode
;
725 smbios_uuid_encoded
= uuid_encoded
;
726 smbios_ep_type
= ep_type
;
728 /* drop unwanted version of command-line file blob(s) */
730 g_free(smbios_tables
);
731 /* in legacy mode, also complain if fields were given for types > 1 */
732 if (find_next_bit(have_fields_bitmap
,
733 SMBIOS_MAX_TYPE
+1, 2) < SMBIOS_MAX_TYPE
+1) {
734 error_report("can't process fields for smbios "
735 "types > 1 on machine versions < 2.1!");
739 g_free(smbios_entries
);
742 SMBIOS_SET_DEFAULT(type1
.manufacturer
, manufacturer
);
743 SMBIOS_SET_DEFAULT(type1
.product
, product
);
744 SMBIOS_SET_DEFAULT(type1
.version
, version
);
745 SMBIOS_SET_DEFAULT(type2
.manufacturer
, manufacturer
);
746 SMBIOS_SET_DEFAULT(type2
.product
, product
);
747 SMBIOS_SET_DEFAULT(type2
.version
, version
);
748 SMBIOS_SET_DEFAULT(type3
.manufacturer
, manufacturer
);
749 SMBIOS_SET_DEFAULT(type3
.version
, version
);
750 SMBIOS_SET_DEFAULT(type4
.sock_pfx
, "CPU");
751 SMBIOS_SET_DEFAULT(type4
.manufacturer
, manufacturer
);
752 SMBIOS_SET_DEFAULT(type4
.version
, version
);
753 SMBIOS_SET_DEFAULT(type17
.loc_pfx
, "DIMM");
754 SMBIOS_SET_DEFAULT(type17
.manufacturer
, manufacturer
);
757 static void smbios_entry_point_setup(void)
759 switch (smbios_ep_type
) {
760 case SMBIOS_ENTRY_POINT_21
:
761 memcpy(ep
.ep21
.anchor_string
, "_SM_", 4);
762 memcpy(ep
.ep21
.intermediate_anchor_string
, "_DMI_", 5);
763 ep
.ep21
.length
= sizeof(struct smbios_21_entry_point
);
764 ep
.ep21
.entry_point_revision
= 0; /* formatted_area reserved */
765 memset(ep
.ep21
.formatted_area
, 0, 5);
767 /* compliant with smbios spec v2.8 */
768 ep
.ep21
.smbios_major_version
= 2;
769 ep
.ep21
.smbios_minor_version
= 8;
770 ep
.ep21
.smbios_bcd_revision
= 0x28;
772 /* set during table construction, but BIOS may override: */
773 ep
.ep21
.structure_table_length
= cpu_to_le16(smbios_tables_len
);
774 ep
.ep21
.max_structure_size
= cpu_to_le16(smbios_table_max
);
775 ep
.ep21
.number_of_structures
= cpu_to_le16(smbios_table_cnt
);
777 /* BIOS must recalculate */
778 ep
.ep21
.checksum
= 0;
779 ep
.ep21
.intermediate_checksum
= 0;
780 ep
.ep21
.structure_table_address
= cpu_to_le32(0);
783 case SMBIOS_ENTRY_POINT_30
:
784 memcpy(ep
.ep30
.anchor_string
, "_SM3_", 5);
785 ep
.ep30
.length
= sizeof(struct smbios_30_entry_point
);
786 ep
.ep30
.entry_point_revision
= 1;
787 ep
.ep30
.reserved
= 0;
789 /* compliant with smbios spec 3.0 */
790 ep
.ep30
.smbios_major_version
= 3;
791 ep
.ep30
.smbios_minor_version
= 0;
792 ep
.ep30
.smbios_doc_rev
= 0;
794 /* set during table construct, but BIOS might override */
795 ep
.ep30
.structure_table_max_size
= cpu_to_le32(smbios_tables_len
);
797 /* BIOS must recalculate */
798 ep
.ep30
.checksum
= 0;
799 ep
.ep30
.structure_table_address
= cpu_to_le64(0);
808 void smbios_get_tables(const struct smbios_phys_mem_area
*mem_array
,
809 const unsigned int mem_array_size
,
810 uint8_t **tables
, size_t *tables_len
,
811 uint8_t **anchor
, size_t *anchor_len
)
813 unsigned i
, dimm_cnt
;
816 *tables
= *anchor
= NULL
;
817 *tables_len
= *anchor_len
= 0;
821 if (!smbios_immutable
) {
822 smbios_build_type_0_table();
823 smbios_build_type_1_table();
824 smbios_build_type_2_table();
825 smbios_build_type_3_table();
827 smbios_smp_sockets
= DIV_ROUND_UP(smp_cpus
, smp_cores
* smp_threads
);
828 assert(smbios_smp_sockets
>= 1);
830 for (i
= 0; i
< smbios_smp_sockets
; i
++) {
831 smbios_build_type_4_table(i
);
834 #define MAX_DIMM_SZ (16ll * ONE_GB)
835 #define GET_DIMM_SZ ((i < dimm_cnt - 1) ? MAX_DIMM_SZ \
836 : ((ram_size - 1) % MAX_DIMM_SZ) + 1)
838 dimm_cnt
= QEMU_ALIGN_UP(ram_size
, MAX_DIMM_SZ
) / MAX_DIMM_SZ
;
840 smbios_build_type_16_table(dimm_cnt
);
842 for (i
= 0; i
< dimm_cnt
; i
++) {
843 smbios_build_type_17_table(i
, GET_DIMM_SZ
);
846 for (i
= 0; i
< mem_array_size
; i
++) {
847 smbios_build_type_19_table(i
, mem_array
[i
].address
,
848 mem_array
[i
].length
);
851 smbios_build_type_32_table();
852 smbios_build_type_38_table();
853 smbios_build_type_127_table();
855 smbios_validate_table();
856 smbios_entry_point_setup();
857 smbios_immutable
= true;
860 /* return tables blob and entry point (anchor), and their sizes */
861 *tables
= smbios_tables
;
862 *tables_len
= smbios_tables_len
;
863 *anchor
= (uint8_t *)&ep
;
865 /* calculate length based on anchor string */
866 if (!strncmp((char *)&ep
, "_SM_", 4)) {
867 *anchor_len
= sizeof(struct smbios_21_entry_point
);
868 } else if (!strncmp((char *)&ep
, "_SM3_", 5)) {
869 *anchor_len
= sizeof(struct smbios_30_entry_point
);
875 static void save_opt(const char **dest
, QemuOpts
*opts
, const char *name
)
877 const char *val
= qemu_opt_get(opts
, name
);
884 void smbios_entry_add(QemuOpts
*opts
)
888 assert(!smbios_immutable
);
890 val
= qemu_opt_get(opts
, "file");
892 struct smbios_structure_header
*header
;
894 struct smbios_table
*table
; /* legacy mode only */
896 qemu_opts_validate(opts
, qemu_smbios_file_opts
, &error_fatal
);
898 size
= get_image_size(val
);
899 if (size
== -1 || size
< sizeof(struct smbios_structure_header
)) {
900 error_report("Cannot read SMBIOS file %s", val
);
905 * NOTE: standard double '\0' terminator expected, per smbios spec.
906 * (except in legacy mode, where the second '\0' is implicit and
907 * will be inserted by the BIOS).
909 smbios_tables
= g_realloc(smbios_tables
, smbios_tables_len
+ size
);
910 header
= (struct smbios_structure_header
*)(smbios_tables
+
913 if (load_image(val
, (uint8_t *)header
) != size
) {
914 error_report("Failed to load SMBIOS file %s", val
);
918 if (test_bit(header
->type
, have_fields_bitmap
)) {
919 error_report("can't load type %d struct, fields already specified!",
923 set_bit(header
->type
, have_binfile_bitmap
);
925 if (header
->type
== 4) {
926 smbios_type4_count
++;
929 smbios_tables_len
+= size
;
930 if (size
> smbios_table_max
) {
931 smbios_table_max
= size
;
935 /* add a copy of the newly loaded blob to legacy smbios_entries */
936 /* NOTE: This code runs before smbios_set_defaults(), so we don't
937 * yet know which mode (legacy vs. aggregate-table) will be
938 * required. We therefore add the binary blob to both legacy
939 * (smbios_entries) and aggregate (smbios_tables) tables, and
940 * delete the one we don't need from smbios_set_defaults(),
941 * once we know which machine version has been requested.
943 if (!smbios_entries
) {
944 smbios_entries_len
= sizeof(uint16_t);
945 smbios_entries
= g_malloc0(smbios_entries_len
);
947 smbios_entries
= g_realloc(smbios_entries
, smbios_entries_len
+
948 size
+ sizeof(*table
));
949 table
= (struct smbios_table
*)(smbios_entries
+ smbios_entries_len
);
950 table
->header
.type
= SMBIOS_TABLE_ENTRY
;
951 table
->header
.length
= cpu_to_le16(sizeof(*table
) + size
);
952 memcpy(table
->data
, header
, size
);
953 smbios_entries_len
+= sizeof(*table
) + size
;
954 (*(uint16_t *)smbios_entries
) =
955 cpu_to_le16(le16_to_cpu(*(uint16_t *)smbios_entries
) + 1);
956 /* end: add a copy of the newly loaded blob to legacy smbios_entries */
961 val
= qemu_opt_get(opts
, "type");
963 unsigned long type
= strtoul(val
, NULL
, 0);
965 if (type
> SMBIOS_MAX_TYPE
) {
966 error_report("out of range!");
970 if (test_bit(type
, have_binfile_bitmap
)) {
971 error_report("can't add fields, binary file already loaded!");
974 set_bit(type
, have_fields_bitmap
);
978 qemu_opts_validate(opts
, qemu_smbios_type0_opts
, &error_fatal
);
979 save_opt(&type0
.vendor
, opts
, "vendor");
980 save_opt(&type0
.version
, opts
, "version");
981 save_opt(&type0
.date
, opts
, "date");
982 type0
.uefi
= qemu_opt_get_bool(opts
, "uefi", false);
984 val
= qemu_opt_get(opts
, "release");
986 if (sscanf(val
, "%hhu.%hhu", &type0
.major
, &type0
.minor
) != 2) {
987 error_report("Invalid release");
990 type0
.have_major_minor
= true;
994 qemu_opts_validate(opts
, qemu_smbios_type1_opts
, &error_fatal
);
995 save_opt(&type1
.manufacturer
, opts
, "manufacturer");
996 save_opt(&type1
.product
, opts
, "product");
997 save_opt(&type1
.version
, opts
, "version");
998 save_opt(&type1
.serial
, opts
, "serial");
999 save_opt(&type1
.sku
, opts
, "sku");
1000 save_opt(&type1
.family
, opts
, "family");
1002 val
= qemu_opt_get(opts
, "uuid");
1004 if (qemu_uuid_parse(val
, qemu_uuid
) != 0) {
1005 error_report("Invalid UUID");
1008 qemu_uuid_set
= true;
1012 qemu_opts_validate(opts
, qemu_smbios_type2_opts
, &error_fatal
);
1013 save_opt(&type2
.manufacturer
, opts
, "manufacturer");
1014 save_opt(&type2
.product
, opts
, "product");
1015 save_opt(&type2
.version
, opts
, "version");
1016 save_opt(&type2
.serial
, opts
, "serial");
1017 save_opt(&type2
.asset
, opts
, "asset");
1018 save_opt(&type2
.location
, opts
, "location");
1021 qemu_opts_validate(opts
, qemu_smbios_type3_opts
, &error_fatal
);
1022 save_opt(&type3
.manufacturer
, opts
, "manufacturer");
1023 save_opt(&type3
.version
, opts
, "version");
1024 save_opt(&type3
.serial
, opts
, "serial");
1025 save_opt(&type3
.asset
, opts
, "asset");
1026 save_opt(&type3
.sku
, opts
, "sku");
1029 qemu_opts_validate(opts
, qemu_smbios_type4_opts
, &error_fatal
);
1030 save_opt(&type4
.sock_pfx
, opts
, "sock_pfx");
1031 save_opt(&type4
.manufacturer
, opts
, "manufacturer");
1032 save_opt(&type4
.version
, opts
, "version");
1033 save_opt(&type4
.serial
, opts
, "serial");
1034 save_opt(&type4
.asset
, opts
, "asset");
1035 save_opt(&type4
.part
, opts
, "part");
1038 qemu_opts_validate(opts
, qemu_smbios_type17_opts
, &error_fatal
);
1039 save_opt(&type17
.loc_pfx
, opts
, "loc_pfx");
1040 save_opt(&type17
.bank
, opts
, "bank");
1041 save_opt(&type17
.manufacturer
, opts
, "manufacturer");
1042 save_opt(&type17
.serial
, opts
, "serial");
1043 save_opt(&type17
.asset
, opts
, "asset");
1044 save_opt(&type17
.part
, opts
, "part");
1045 type17
.speed
= qemu_opt_get_number(opts
, "speed", 0);
1048 error_report("Don't know how to build fields for SMBIOS type %ld",
1054 error_report("Must specify type= or file=");