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/config-file.h"
19 #include "qemu/error-report.h"
20 #include "sysemu/sysemu.h"
21 #include "sysemu/cpus.h"
22 #include "hw/i386/pc.h"
23 #include "hw/i386/smbios.h"
24 #include "hw/loader.h"
27 /* legacy structures and constants for <= 2.0 machines */
28 struct smbios_header
{
34 struct smbios_header header
;
41 struct smbios_header header
;
45 #define SMBIOS_FIELD_ENTRY 0
46 #define SMBIOS_TABLE_ENTRY 1
48 static uint8_t *smbios_entries
;
49 static size_t smbios_entries_len
;
50 static bool smbios_legacy
= true;
51 /* end: legacy structures & constants for <= 2.0 machines */
54 static uint8_t *smbios_tables
;
55 static size_t smbios_tables_len
;
56 static unsigned smbios_table_max
;
57 static unsigned smbios_table_cnt
;
58 static struct smbios_entry_point ep
;
60 static int smbios_type4_count
= 0;
61 static bool smbios_immutable
;
62 static bool smbios_have_defaults
;
63 static uint32_t smbios_cpuid_version
, smbios_cpuid_features
, smbios_smp_sockets
;
65 static DECLARE_BITMAP(have_binfile_bitmap
, SMBIOS_MAX_TYPE
+1);
66 static DECLARE_BITMAP(have_fields_bitmap
, SMBIOS_MAX_TYPE
+1);
69 const char *vendor
, *version
, *date
;
70 bool have_major_minor
;
75 const char *manufacturer
, *product
, *version
, *serial
, *sku
, *family
;
76 /* uuid is in qemu_uuid[] */
80 const char *manufacturer
, *product
, *version
, *serial
, *asset
, *location
;
84 const char *manufacturer
, *version
, *serial
, *asset
, *sku
;
88 const char *sock_pfx
, *manufacturer
, *version
, *serial
, *asset
, *part
;
92 const char *loc_pfx
, *bank
, *manufacturer
, *serial
, *asset
, *part
;
95 static QemuOptsList qemu_smbios_opts
= {
97 .head
= QTAILQ_HEAD_INITIALIZER(qemu_smbios_opts
.head
),
100 * no elements => accept any params
101 * validation will happen later
103 { /* end of list */ }
107 static const QemuOptDesc qemu_smbios_file_opts
[] = {
110 .type
= QEMU_OPT_STRING
,
111 .help
= "binary file containing an SMBIOS element",
113 { /* end of list */ }
116 static const QemuOptDesc qemu_smbios_type0_opts
[] = {
119 .type
= QEMU_OPT_NUMBER
,
120 .help
= "SMBIOS element type",
123 .type
= QEMU_OPT_STRING
,
124 .help
= "vendor name",
127 .type
= QEMU_OPT_STRING
,
128 .help
= "version number",
131 .type
= QEMU_OPT_STRING
,
132 .help
= "release date",
135 .type
= QEMU_OPT_STRING
,
136 .help
= "revision number",
138 { /* end of list */ }
141 static const QemuOptDesc qemu_smbios_type1_opts
[] = {
144 .type
= QEMU_OPT_NUMBER
,
145 .help
= "SMBIOS element type",
147 .name
= "manufacturer",
148 .type
= QEMU_OPT_STRING
,
149 .help
= "manufacturer name",
152 .type
= QEMU_OPT_STRING
,
153 .help
= "product name",
156 .type
= QEMU_OPT_STRING
,
157 .help
= "version number",
160 .type
= QEMU_OPT_STRING
,
161 .help
= "serial number",
164 .type
= QEMU_OPT_STRING
,
168 .type
= QEMU_OPT_STRING
,
169 .help
= "SKU number",
172 .type
= QEMU_OPT_STRING
,
173 .help
= "family name",
175 { /* end of list */ }
178 static const QemuOptDesc qemu_smbios_type2_opts
[] = {
181 .type
= QEMU_OPT_NUMBER
,
182 .help
= "SMBIOS element type",
184 .name
= "manufacturer",
185 .type
= QEMU_OPT_STRING
,
186 .help
= "manufacturer name",
189 .type
= QEMU_OPT_STRING
,
190 .help
= "product name",
193 .type
= QEMU_OPT_STRING
,
194 .help
= "version number",
197 .type
= QEMU_OPT_STRING
,
198 .help
= "serial number",
201 .type
= QEMU_OPT_STRING
,
202 .help
= "asset tag number",
205 .type
= QEMU_OPT_STRING
,
206 .help
= "location in chassis",
208 { /* end of list */ }
211 static const QemuOptDesc qemu_smbios_type3_opts
[] = {
214 .type
= QEMU_OPT_NUMBER
,
215 .help
= "SMBIOS element type",
217 .name
= "manufacturer",
218 .type
= QEMU_OPT_STRING
,
219 .help
= "manufacturer name",
222 .type
= QEMU_OPT_STRING
,
223 .help
= "version number",
226 .type
= QEMU_OPT_STRING
,
227 .help
= "serial number",
230 .type
= QEMU_OPT_STRING
,
231 .help
= "asset tag number",
234 .type
= QEMU_OPT_STRING
,
235 .help
= "SKU number",
237 { /* end of list */ }
240 static const QemuOptDesc qemu_smbios_type4_opts
[] = {
243 .type
= QEMU_OPT_NUMBER
,
244 .help
= "SMBIOS element type",
247 .type
= QEMU_OPT_STRING
,
248 .help
= "socket designation string prefix",
250 .name
= "manufacturer",
251 .type
= QEMU_OPT_STRING
,
252 .help
= "manufacturer name",
255 .type
= QEMU_OPT_STRING
,
256 .help
= "version number",
259 .type
= QEMU_OPT_STRING
,
260 .help
= "serial number",
263 .type
= QEMU_OPT_STRING
,
264 .help
= "asset tag number",
267 .type
= QEMU_OPT_STRING
,
268 .help
= "part number",
270 { /* end of list */ }
273 static const QemuOptDesc qemu_smbios_type17_opts
[] = {
276 .type
= QEMU_OPT_NUMBER
,
277 .help
= "SMBIOS element type",
280 .type
= QEMU_OPT_STRING
,
281 .help
= "device locator string prefix",
284 .type
= QEMU_OPT_STRING
,
285 .help
= "bank locator string",
287 .name
= "manufacturer",
288 .type
= QEMU_OPT_STRING
,
289 .help
= "manufacturer name",
292 .type
= QEMU_OPT_STRING
,
293 .help
= "serial number",
296 .type
= QEMU_OPT_STRING
,
297 .help
= "asset tag number",
300 .type
= QEMU_OPT_STRING
,
301 .help
= "part number",
303 { /* end of list */ }
306 static void smbios_register_config(void)
308 qemu_add_opts(&qemu_smbios_opts
);
311 machine_init(smbios_register_config
);
313 static void smbios_validate_table(void)
315 uint32_t expect_t4_count
= smbios_legacy
? smp_cpus
: smbios_smp_sockets
;
317 if (smbios_type4_count
&& smbios_type4_count
!= expect_t4_count
) {
318 error_report("Expected %d SMBIOS Type 4 tables, got %d instead",
319 expect_t4_count
, smbios_type4_count
);
325 /* legacy setup functions for <= 2.0 machines */
326 static void smbios_add_field(int type
, int offset
, const void *data
, size_t len
)
328 struct smbios_field
*field
;
330 if (!smbios_entries
) {
331 smbios_entries_len
= sizeof(uint16_t);
332 smbios_entries
= g_malloc0(smbios_entries_len
);
334 smbios_entries
= g_realloc(smbios_entries
, smbios_entries_len
+
335 sizeof(*field
) + len
);
336 field
= (struct smbios_field
*)(smbios_entries
+ smbios_entries_len
);
337 field
->header
.type
= SMBIOS_FIELD_ENTRY
;
338 field
->header
.length
= cpu_to_le16(sizeof(*field
) + len
);
341 field
->offset
= cpu_to_le16(offset
);
342 memcpy(field
->data
, data
, len
);
344 smbios_entries_len
+= sizeof(*field
) + len
;
345 (*(uint16_t *)smbios_entries
) =
346 cpu_to_le16(le16_to_cpu(*(uint16_t *)smbios_entries
) + 1);
349 static void smbios_maybe_add_str(int type
, int offset
, const char *data
)
352 smbios_add_field(type
, offset
, data
, strlen(data
) + 1);
356 static void smbios_build_type_0_fields(void)
358 smbios_maybe_add_str(0, offsetof(struct smbios_type_0
, vendor_str
),
360 smbios_maybe_add_str(0, offsetof(struct smbios_type_0
, bios_version_str
),
362 smbios_maybe_add_str(0, offsetof(struct smbios_type_0
,
363 bios_release_date_str
),
365 if (type0
.have_major_minor
) {
366 smbios_add_field(0, offsetof(struct smbios_type_0
,
367 system_bios_major_release
),
369 smbios_add_field(0, offsetof(struct smbios_type_0
,
370 system_bios_minor_release
),
375 static void smbios_build_type_1_fields(void)
377 smbios_maybe_add_str(1, offsetof(struct smbios_type_1
, manufacturer_str
),
379 smbios_maybe_add_str(1, offsetof(struct smbios_type_1
, product_name_str
),
381 smbios_maybe_add_str(1, offsetof(struct smbios_type_1
, version_str
),
383 smbios_maybe_add_str(1, offsetof(struct smbios_type_1
, serial_number_str
),
385 smbios_maybe_add_str(1, offsetof(struct smbios_type_1
, sku_number_str
),
387 smbios_maybe_add_str(1, offsetof(struct smbios_type_1
, family_str
),
390 smbios_add_field(1, offsetof(struct smbios_type_1
, uuid
),
395 uint8_t *smbios_get_table_legacy(size_t *length
)
397 if (!smbios_legacy
) {
402 if (!smbios_immutable
) {
403 smbios_build_type_0_fields();
404 smbios_build_type_1_fields();
405 smbios_validate_table();
406 smbios_immutable
= true;
408 *length
= smbios_entries_len
;
409 return smbios_entries
;
411 /* end: legacy setup functions for <= 2.0 machines */
414 static bool smbios_skip_table(uint8_t type
, bool required_table
)
416 if (test_bit(type
, have_binfile_bitmap
)) {
417 return true; /* user provided their own binary blob(s) */
419 if (test_bit(type
, have_fields_bitmap
)) {
420 return false; /* user provided fields via command line */
422 if (smbios_have_defaults
&& required_table
) {
423 return false; /* we're building tables, and this one's required */
428 #define SMBIOS_BUILD_TABLE_PRE(tbl_type, tbl_handle, tbl_required) \
429 struct smbios_type_##tbl_type *t; \
430 size_t t_off; /* table offset into smbios_tables */ \
433 /* should we skip building this table ? */ \
434 if (smbios_skip_table(tbl_type, tbl_required)) { \
438 /* use offset of table t within smbios_tables */ \
439 /* (pointer must be updated after each realloc) */ \
440 t_off = smbios_tables_len; \
441 smbios_tables_len += sizeof(*t); \
442 smbios_tables = g_realloc(smbios_tables, smbios_tables_len); \
443 t = (struct smbios_type_##tbl_type *)(smbios_tables + t_off); \
445 t->header.type = tbl_type; \
446 t->header.length = sizeof(*t); \
447 t->header.handle = tbl_handle; \
450 #define SMBIOS_TABLE_SET_STR(tbl_type, field, value) \
452 int len = (value != NULL) ? strlen(value) + 1 : 0; \
454 smbios_tables = g_realloc(smbios_tables, \
455 smbios_tables_len + len); \
456 memcpy(smbios_tables + smbios_tables_len, value, len); \
457 smbios_tables_len += len; \
458 /* update pointer post-realloc */ \
459 t = (struct smbios_type_##tbl_type *)(smbios_tables + t_off); \
460 t->field = ++str_index; \
466 #define SMBIOS_BUILD_TABLE_POST \
468 size_t term_cnt, t_size; \
470 /* add '\0' terminator (add two if no strings defined) */ \
471 term_cnt = (str_index == 0) ? 2 : 1; \
472 smbios_tables = g_realloc(smbios_tables, \
473 smbios_tables_len + term_cnt); \
474 memset(smbios_tables + smbios_tables_len, 0, term_cnt); \
475 smbios_tables_len += term_cnt; \
477 /* update smbios max. element size */ \
478 t_size = smbios_tables_len - t_off; \
479 if (t_size > smbios_table_max) { \
480 smbios_table_max = t_size; \
483 /* update smbios element count */ \
484 smbios_table_cnt++; \
487 static void smbios_build_type_0_table(void)
489 SMBIOS_BUILD_TABLE_PRE(0, 0x000, false); /* optional, leave up to BIOS */
491 SMBIOS_TABLE_SET_STR(0, vendor_str
, type0
.vendor
);
492 SMBIOS_TABLE_SET_STR(0, bios_version_str
, type0
.version
);
494 t
->bios_starting_address_segment
= 0xE800; /* hardcoded in SeaBIOS */
496 SMBIOS_TABLE_SET_STR(0, bios_release_date_str
, type0
.date
);
498 t
->bios_rom_size
= 0; /* hardcoded in SeaBIOS with FIXME comment */
500 /* BIOS characteristics not supported */
501 memset(t
->bios_characteristics
, 0, 8);
502 t
->bios_characteristics
[0] = 0x08;
504 /* Enable targeted content distribution (needed for SVVP, per SeaBIOS) */
505 t
->bios_characteristics_extension_bytes
[0] = 0;
506 t
->bios_characteristics_extension_bytes
[1] = 4;
508 if (type0
.have_major_minor
) {
509 t
->system_bios_major_release
= type0
.major
;
510 t
->system_bios_minor_release
= type0
.minor
;
512 t
->system_bios_major_release
= 0;
513 t
->system_bios_minor_release
= 0;
516 /* hardcoded in SeaBIOS */
517 t
->embedded_controller_major_release
= 0xFF;
518 t
->embedded_controller_minor_release
= 0xFF;
520 SMBIOS_BUILD_TABLE_POST
;
523 static void smbios_build_type_1_table(void)
525 SMBIOS_BUILD_TABLE_PRE(1, 0x100, true); /* required */
527 SMBIOS_TABLE_SET_STR(1, manufacturer_str
, type1
.manufacturer
);
528 SMBIOS_TABLE_SET_STR(1, product_name_str
, type1
.product
);
529 SMBIOS_TABLE_SET_STR(1, version_str
, type1
.version
);
530 SMBIOS_TABLE_SET_STR(1, serial_number_str
, type1
.serial
);
532 memcpy(t
->uuid
, qemu_uuid
, 16);
534 memset(t
->uuid
, 0, 16);
536 t
->wake_up_type
= 0x06; /* power switch */
537 SMBIOS_TABLE_SET_STR(1, sku_number_str
, type1
.sku
);
538 SMBIOS_TABLE_SET_STR(1, family_str
, type1
.family
);
540 SMBIOS_BUILD_TABLE_POST
;
543 static void smbios_build_type_2_table(void)
545 SMBIOS_BUILD_TABLE_PRE(2, 0x200, false); /* optional */
547 SMBIOS_TABLE_SET_STR(2, manufacturer_str
, type2
.manufacturer
);
548 SMBIOS_TABLE_SET_STR(2, product_str
, type2
.product
);
549 SMBIOS_TABLE_SET_STR(2, version_str
, type2
.version
);
550 SMBIOS_TABLE_SET_STR(2, serial_number_str
, type2
.serial
);
551 SMBIOS_TABLE_SET_STR(2, asset_tag_number_str
, type2
.asset
);
552 t
->feature_flags
= 0x01; /* Motherboard */
553 SMBIOS_TABLE_SET_STR(2, location_str
, type2
.location
);
554 t
->chassis_handle
= 0x300; /* Type 3 (System enclosure) */
555 t
->board_type
= 0x0A; /* Motherboard */
556 t
->contained_element_count
= 0;
558 SMBIOS_BUILD_TABLE_POST
;
561 static void smbios_build_type_3_table(void)
563 SMBIOS_BUILD_TABLE_PRE(3, 0x300, true); /* required */
565 SMBIOS_TABLE_SET_STR(3, manufacturer_str
, type3
.manufacturer
);
566 t
->type
= 0x01; /* Other */
567 SMBIOS_TABLE_SET_STR(3, version_str
, type3
.version
);
568 SMBIOS_TABLE_SET_STR(3, serial_number_str
, type3
.serial
);
569 SMBIOS_TABLE_SET_STR(3, asset_tag_number_str
, type3
.asset
);
570 t
->boot_up_state
= 0x03; /* Safe */
571 t
->power_supply_state
= 0x03; /* Safe */
572 t
->thermal_state
= 0x03; /* Safe */
573 t
->security_status
= 0x02; /* Unknown */
576 t
->number_of_power_cords
= 0;
577 t
->contained_element_count
= 0;
578 SMBIOS_TABLE_SET_STR(3, sku_number_str
, type3
.sku
);
580 SMBIOS_BUILD_TABLE_POST
;
583 static void smbios_build_type_4_table(unsigned instance
)
587 SMBIOS_BUILD_TABLE_PRE(4, 0x400 + instance
, true); /* required */
589 snprintf(sock_str
, sizeof(sock_str
), "%s%2x", type4
.sock_pfx
, instance
);
590 SMBIOS_TABLE_SET_STR(4, socket_designation_str
, sock_str
);
591 t
->processor_type
= 0x03; /* CPU */
592 SMBIOS_TABLE_SET_STR(4, processor_manufacturer_str
, type4
.manufacturer
);
593 t
->processor_id
[0] = smbios_cpuid_version
;
594 t
->processor_id
[1] = smbios_cpuid_features
;
595 SMBIOS_TABLE_SET_STR(4, processor_version_str
, type4
.version
);
597 t
->external_clock
= 0; /* Unknown */
598 t
->max_speed
= 0; /* Unknown */
599 t
->current_speed
= 0; /* Unknown */
600 t
->status
= 0x41; /* Socket populated, CPU enabled */
601 t
->processor_upgrade
= 0x01; /* Other */
602 t
->l1_cache_handle
= 0xFFFF; /* N/A */
603 t
->l2_cache_handle
= 0xFFFF; /* N/A */
604 t
->l3_cache_handle
= 0xFFFF; /* N/A */
605 SMBIOS_TABLE_SET_STR(4, serial_number_str
, type4
.serial
);
606 SMBIOS_TABLE_SET_STR(4, asset_tag_number_str
, type4
.asset
);
607 SMBIOS_TABLE_SET_STR(4, part_number_str
, type4
.part
);
608 t
->core_count
= t
->core_enabled
= smp_cores
;
609 t
->thread_count
= smp_threads
;
610 t
->processor_characteristics
= 0x02; /* Unknown */
611 t
->processor_family
= t
->processor_family2
= 0x01; /* Other */
613 SMBIOS_BUILD_TABLE_POST
;
614 smbios_type4_count
++;
617 #define ONE_KB ((ram_addr_t)1 << 10)
618 #define ONE_MB ((ram_addr_t)1 << 20)
619 #define ONE_GB ((ram_addr_t)1 << 30)
621 #define MAX_T16_STD_SZ 0x80000000 /* 2T in Kilobytes */
623 static void smbios_build_type_16_table(unsigned dimm_cnt
)
627 SMBIOS_BUILD_TABLE_PRE(16, 0x1000, true); /* required */
629 t
->location
= 0x01; /* Other */
630 t
->use
= 0x03; /* System memory */
631 t
->error_correction
= 0x06; /* Multi-bit ECC (for Microsoft, per SeaBIOS) */
632 size_kb
= QEMU_ALIGN_UP(ram_size
, ONE_KB
) / ONE_KB
;
633 if (size_kb
< MAX_T16_STD_SZ
) {
634 t
->maximum_capacity
= size_kb
;
635 t
->extended_maximum_capacity
= 0;
637 t
->maximum_capacity
= MAX_T16_STD_SZ
;
638 t
->extended_maximum_capacity
= ram_size
;
640 t
->memory_error_information_handle
= 0xFFFE; /* Not provided */
641 t
->number_of_memory_devices
= dimm_cnt
;
643 SMBIOS_BUILD_TABLE_POST
;
646 #define MAX_T17_STD_SZ 0x7FFF /* (32G - 1M), in Megabytes */
647 #define MAX_T17_EXT_SZ 0x80000000 /* 2P, in Megabytes */
649 static void smbios_build_type_17_table(unsigned instance
, ram_addr_t size
)
654 SMBIOS_BUILD_TABLE_PRE(17, 0x1100 + instance
, true); /* required */
656 t
->physical_memory_array_handle
= 0x1000; /* Type 16 (Phys. Mem. Array) */
657 t
->memory_error_information_handle
= 0xFFFE; /* Not provided */
658 t
->total_width
= 0xFFFF; /* Unknown */
659 t
->data_width
= 0xFFFF; /* Unknown */
660 size_mb
= QEMU_ALIGN_UP(size
, ONE_MB
) / ONE_MB
;
661 if (size_mb
< MAX_T17_STD_SZ
) {
663 t
->extended_size
= 0;
665 assert(size_mb
< MAX_T17_EXT_SZ
);
666 t
->size
= MAX_T17_STD_SZ
;
667 t
->extended_size
= size_mb
;
669 t
->form_factor
= 0x09; /* DIMM */
670 t
->device_set
= 0; /* Not in a set */
671 snprintf(loc_str
, sizeof(loc_str
), "%s %d", type17
.loc_pfx
, instance
);
672 SMBIOS_TABLE_SET_STR(17, device_locator_str
, loc_str
);
673 SMBIOS_TABLE_SET_STR(17, bank_locator_str
, type17
.bank
);
674 t
->memory_type
= 0x07; /* RAM */
675 t
->type_detail
= 0x02; /* Other */
676 t
->speed
= 0; /* Unknown */
677 SMBIOS_TABLE_SET_STR(17, manufacturer_str
, type17
.manufacturer
);
678 SMBIOS_TABLE_SET_STR(17, serial_number_str
, type17
.serial
);
679 SMBIOS_TABLE_SET_STR(17, asset_tag_number_str
, type17
.asset
);
680 SMBIOS_TABLE_SET_STR(17, part_number_str
, type17
.part
);
681 t
->attributes
= 0; /* Unknown */
682 t
->configured_clock_speed
= 0; /* Unknown */
683 t
->minimum_voltage
= 0; /* Unknown */
684 t
->maximum_voltage
= 0; /* Unknown */
685 t
->configured_voltage
= 0; /* Unknown */
687 SMBIOS_BUILD_TABLE_POST
;
690 static void smbios_build_type_19_table(unsigned instance
,
691 ram_addr_t start
, ram_addr_t size
)
693 ram_addr_t end
, start_kb
, end_kb
;
695 SMBIOS_BUILD_TABLE_PRE(19, 0x1300 + instance
, true); /* required */
697 end
= start
+ size
- 1;
699 start_kb
= start
/ ONE_KB
;
700 end_kb
= end
/ ONE_KB
;
701 if (start_kb
< UINT32_MAX
&& end_kb
< UINT32_MAX
) {
702 t
->starting_address
= start_kb
;
703 t
->ending_address
= end_kb
;
704 t
->extended_starting_address
= t
->extended_ending_address
= 0;
706 t
->starting_address
= t
->ending_address
= UINT32_MAX
;
707 t
->extended_starting_address
= start
;
708 t
->extended_ending_address
= end
;
710 t
->memory_array_handle
= 0x1000; /* Type 16 (Phys. Mem. Array) */
711 t
->partition_width
= 1; /* One device per row */
713 SMBIOS_BUILD_TABLE_POST
;
716 static void smbios_build_type_32_table(void)
718 SMBIOS_BUILD_TABLE_PRE(32, 0x2000, true); /* required */
720 memset(t
->reserved
, 0, 6);
721 t
->boot_status
= 0; /* No errors detected */
723 SMBIOS_BUILD_TABLE_POST
;
726 static void smbios_build_type_127_table(void)
728 SMBIOS_BUILD_TABLE_PRE(127, 0x7F00, true); /* required */
729 SMBIOS_BUILD_TABLE_POST
;
732 void smbios_set_cpuid(uint32_t version
, uint32_t features
)
734 smbios_cpuid_version
= version
;
735 smbios_cpuid_features
= features
;
738 #define SMBIOS_SET_DEFAULT(field, value) \
743 #define G_FREE_UNLESS_NULL(ptr) \
748 void smbios_set_defaults(const char *manufacturer
, const char *product
,
749 const char *version
, bool legacy_mode
)
751 smbios_have_defaults
= true;
752 smbios_legacy
= legacy_mode
;
754 /* drop unwanted version of command-line file blob(s) */
756 G_FREE_UNLESS_NULL(smbios_tables
);
757 /* in legacy mode, also complain if fields were given for types > 1 */
758 if (find_next_bit(have_fields_bitmap
,
759 SMBIOS_MAX_TYPE
+1, 2) < SMBIOS_MAX_TYPE
+1) {
760 error_report("can't process fields for smbios "
761 "types > 1 on machine versions < 2.1!");
765 G_FREE_UNLESS_NULL(smbios_entries
);
768 SMBIOS_SET_DEFAULT(type1
.manufacturer
, manufacturer
);
769 SMBIOS_SET_DEFAULT(type1
.product
, product
);
770 SMBIOS_SET_DEFAULT(type1
.version
, version
);
771 SMBIOS_SET_DEFAULT(type2
.manufacturer
, manufacturer
);
772 SMBIOS_SET_DEFAULT(type2
.product
, product
);
773 SMBIOS_SET_DEFAULT(type2
.version
, version
);
774 SMBIOS_SET_DEFAULT(type3
.manufacturer
, manufacturer
);
775 SMBIOS_SET_DEFAULT(type3
.version
, version
);
776 SMBIOS_SET_DEFAULT(type4
.sock_pfx
, "CPU");
777 SMBIOS_SET_DEFAULT(type4
.manufacturer
, manufacturer
);
778 SMBIOS_SET_DEFAULT(type4
.version
, version
);
779 SMBIOS_SET_DEFAULT(type17
.loc_pfx
, "DIMM");
780 SMBIOS_SET_DEFAULT(type17
.manufacturer
, manufacturer
);
783 static void smbios_entry_point_setup(void)
785 memcpy(ep
.anchor_string
, "_SM_", 4);
786 memcpy(ep
.intermediate_anchor_string
, "_DMI_", 5);
787 ep
.length
= sizeof(struct smbios_entry_point
);
788 ep
.entry_point_revision
= 0; /* formatted_area reserved, per spec v2.1+ */
789 memset(ep
.formatted_area
, 0, 5);
791 /* compliant with smbios spec v2.8 */
792 ep
.smbios_major_version
= 2;
793 ep
.smbios_minor_version
= 8;
794 ep
.smbios_bcd_revision
= 0x28;
796 /* set during table construction, but BIOS may override: */
797 ep
.structure_table_length
= smbios_tables_len
;
798 ep
.max_structure_size
= smbios_table_max
;
799 ep
.number_of_structures
= smbios_table_cnt
;
801 /* BIOS must recalculate: */
803 ep
.intermediate_checksum
= 0;
804 ep
.structure_table_address
= 0; /* where BIOS has copied smbios_tables */
807 void smbios_get_tables(uint8_t **tables
, size_t *tables_len
,
808 uint8_t **anchor
, size_t *anchor_len
)
810 unsigned i
, dimm_cnt
, instance
;
813 *tables
= *anchor
= NULL
;
814 *tables_len
= *anchor_len
= 0;
818 if (!smbios_immutable
) {
819 smbios_build_type_0_table();
820 smbios_build_type_1_table();
821 smbios_build_type_2_table();
822 smbios_build_type_3_table();
824 smbios_smp_sockets
= smp_cpus
/ (smp_cores
* smp_threads
);
825 assert(smbios_smp_sockets
>= 1);
827 for (i
= 0; i
< smbios_smp_sockets
; i
++) {
828 smbios_build_type_4_table(i
);
831 #define MAX_DIMM_SZ (16ll * ONE_GB)
832 #define GET_DIMM_SZ ((i < dimm_cnt - 1) ? MAX_DIMM_SZ : ram_size % MAX_DIMM_SZ)
834 dimm_cnt
= QEMU_ALIGN_UP(ram_size
, MAX_DIMM_SZ
) / MAX_DIMM_SZ
;
836 smbios_build_type_16_table(dimm_cnt
);
838 for (i
= 0; i
< dimm_cnt
; i
++) {
839 smbios_build_type_17_table(i
, GET_DIMM_SZ
);
842 for (i
= 0, instance
= 0; i
< e820_get_num_entries(); i
++) {
843 uint64_t address
, length
;
844 if (e820_get_entry(i
, E820_RAM
, &address
, &length
)) {
845 smbios_build_type_19_table(instance
++, address
, length
);
849 smbios_build_type_32_table();
850 smbios_build_type_127_table();
852 smbios_validate_table();
853 smbios_entry_point_setup();
854 smbios_immutable
= true;
857 /* return tables blob and entry point (anchor), and their sizes */
858 *tables
= smbios_tables
;
859 *tables_len
= smbios_tables_len
;
860 *anchor
= (uint8_t *)&ep
;
861 *anchor_len
= sizeof(struct smbios_entry_point
);
864 static void save_opt(const char **dest
, QemuOpts
*opts
, const char *name
)
866 const char *val
= qemu_opt_get(opts
, name
);
873 void smbios_entry_add(QemuOpts
*opts
)
875 Error
*local_err
= NULL
;
878 assert(!smbios_immutable
);
880 val
= qemu_opt_get(opts
, "file");
882 struct smbios_structure_header
*header
;
884 struct smbios_table
*table
; /* legacy mode only */
886 qemu_opts_validate(opts
, qemu_smbios_file_opts
, &local_err
);
888 error_report("%s", error_get_pretty(local_err
));
892 size
= get_image_size(val
);
893 if (size
== -1 || size
< sizeof(struct smbios_structure_header
)) {
894 error_report("Cannot read SMBIOS file %s", val
);
899 * NOTE: standard double '\0' terminator expected, per smbios spec.
900 * (except in legacy mode, where the second '\0' is implicit and
901 * will be inserted by the BIOS).
903 smbios_tables
= g_realloc(smbios_tables
, smbios_tables_len
+ size
);
904 header
= (struct smbios_structure_header
*)(smbios_tables
+
907 if (load_image(val
, (uint8_t *)header
) != size
) {
908 error_report("Failed to load SMBIOS file %s", val
);
912 if (test_bit(header
->type
, have_fields_bitmap
)) {
913 error_report("can't load type %d struct, fields already specified!",
917 set_bit(header
->type
, have_binfile_bitmap
);
919 if (header
->type
== 4) {
920 smbios_type4_count
++;
923 smbios_tables_len
+= size
;
924 if (size
> smbios_table_max
) {
925 smbios_table_max
= size
;
929 /* add a copy of the newly loaded blob to legacy smbios_entries */
930 /* NOTE: This code runs before smbios_set_defaults(), so we don't
931 * yet know which mode (legacy vs. aggregate-table) will be
932 * required. We therefore add the binary blob to both legacy
933 * (smbios_entries) and aggregate (smbios_tables) tables, and
934 * delete the one we don't need from smbios_set_defaults(),
935 * once we know which machine version has been requested.
937 if (!smbios_entries
) {
938 smbios_entries_len
= sizeof(uint16_t);
939 smbios_entries
= g_malloc0(smbios_entries_len
);
941 smbios_entries
= g_realloc(smbios_entries
, smbios_entries_len
+
942 size
+ sizeof(*table
));
943 table
= (struct smbios_table
*)(smbios_entries
+ smbios_entries_len
);
944 table
->header
.type
= SMBIOS_TABLE_ENTRY
;
945 table
->header
.length
= cpu_to_le16(sizeof(*table
) + size
);
946 memcpy(table
->data
, header
, size
);
947 smbios_entries_len
+= sizeof(*table
) + size
;
948 (*(uint16_t *)smbios_entries
) =
949 cpu_to_le16(le16_to_cpu(*(uint16_t *)smbios_entries
) + 1);
950 /* end: add a copy of the newly loaded blob to legacy smbios_entries */
955 val
= qemu_opt_get(opts
, "type");
957 unsigned long type
= strtoul(val
, NULL
, 0);
959 if (type
> SMBIOS_MAX_TYPE
) {
960 error_report("out of range!");
964 if (test_bit(type
, have_binfile_bitmap
)) {
965 error_report("can't add fields, binary file already loaded!");
968 set_bit(type
, have_fields_bitmap
);
972 qemu_opts_validate(opts
, qemu_smbios_type0_opts
, &local_err
);
974 error_report("%s", error_get_pretty(local_err
));
977 save_opt(&type0
.vendor
, opts
, "vendor");
978 save_opt(&type0
.version
, opts
, "version");
979 save_opt(&type0
.date
, opts
, "date");
981 val
= qemu_opt_get(opts
, "release");
983 if (sscanf(val
, "%hhu.%hhu", &type0
.major
, &type0
.minor
) != 2) {
984 error_report("Invalid release");
987 type0
.have_major_minor
= true;
991 qemu_opts_validate(opts
, qemu_smbios_type1_opts
, &local_err
);
993 error_report("%s", error_get_pretty(local_err
));
996 save_opt(&type1
.manufacturer
, opts
, "manufacturer");
997 save_opt(&type1
.product
, opts
, "product");
998 save_opt(&type1
.version
, opts
, "version");
999 save_opt(&type1
.serial
, opts
, "serial");
1000 save_opt(&type1
.sku
, opts
, "sku");
1001 save_opt(&type1
.family
, opts
, "family");
1003 val
= qemu_opt_get(opts
, "uuid");
1005 if (qemu_uuid_parse(val
, qemu_uuid
) != 0) {
1006 error_report("Invalid UUID");
1009 qemu_uuid_set
= true;
1013 qemu_opts_validate(opts
, qemu_smbios_type2_opts
, &local_err
);
1015 error_report("%s", error_get_pretty(local_err
));
1018 save_opt(&type2
.manufacturer
, opts
, "manufacturer");
1019 save_opt(&type2
.product
, opts
, "product");
1020 save_opt(&type2
.version
, opts
, "version");
1021 save_opt(&type2
.serial
, opts
, "serial");
1022 save_opt(&type2
.asset
, opts
, "asset");
1023 save_opt(&type2
.location
, opts
, "location");
1026 qemu_opts_validate(opts
, qemu_smbios_type3_opts
, &local_err
);
1028 error_report("%s", error_get_pretty(local_err
));
1031 save_opt(&type3
.manufacturer
, opts
, "manufacturer");
1032 save_opt(&type3
.version
, opts
, "version");
1033 save_opt(&type3
.serial
, opts
, "serial");
1034 save_opt(&type3
.asset
, opts
, "asset");
1035 save_opt(&type3
.sku
, opts
, "sku");
1038 qemu_opts_validate(opts
, qemu_smbios_type4_opts
, &local_err
);
1040 error_report("%s", error_get_pretty(local_err
));
1043 save_opt(&type4
.sock_pfx
, opts
, "sock_pfx");
1044 save_opt(&type4
.manufacturer
, opts
, "manufacturer");
1045 save_opt(&type4
.version
, opts
, "version");
1046 save_opt(&type4
.serial
, opts
, "serial");
1047 save_opt(&type4
.asset
, opts
, "asset");
1048 save_opt(&type4
.part
, opts
, "part");
1051 qemu_opts_validate(opts
, qemu_smbios_type17_opts
, &local_err
);
1053 error_report("%s", error_get_pretty(local_err
));
1056 save_opt(&type17
.loc_pfx
, opts
, "loc_pfx");
1057 save_opt(&type17
.bank
, opts
, "bank");
1058 save_opt(&type17
.manufacturer
, opts
, "manufacturer");
1059 save_opt(&type17
.serial
, opts
, "serial");
1060 save_opt(&type17
.asset
, opts
, "asset");
1061 save_opt(&type17
.part
, opts
, "part");
1064 error_report("Don't know how to build fields for SMBIOS type %ld",
1070 error_report("Must specify type= or file=");