?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
smbus: allow returning an error from reads
[qemu/ar7.git] / hw / i386 / smbios.c
blob76607181c38390ba69edba9333b67c068d10a011
1 /*
2 * SMBIOS Support
3 *
4 * Copyright (C) 2009 Hewlett-Packard Development Company, L.P.
5 * Copyright (C) 2013 Red Hat, Inc.
6 *
7 * Authors:
8 * Alex Williamson <alex.williamson@hp.com>
9 * Markus Armbruster <armbru@redhat.com>
10 *
11 * This work is licensed under the terms of the GNU GPL, version 2. See
12 * the COPYING file in the top-level directory.
13 *
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.
16 */
17
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"
25
26
27 /* legacy structures and constants for <= 2.0 machines */
28 struct smbios_header {
29 uint16_t length;
30 uint8_t type;
31 } QEMU_PACKED;
32
33 struct smbios_field {
34 struct smbios_header header;
35 uint8_t type;
36 uint16_t offset;
37 uint8_t data[];
38 } QEMU_PACKED;
39
40 struct smbios_table {
41 struct smbios_header header;
42 uint8_t data[];
43 } QEMU_PACKED;
44
45 #define SMBIOS_FIELD_ENTRY 0
46 #define SMBIOS_TABLE_ENTRY 1
47
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 */
52
53
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;
59
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;
64
65 static DECLARE_BITMAP(have_binfile_bitmap, SMBIOS_MAX_TYPE+1);
66 static DECLARE_BITMAP(have_fields_bitmap, SMBIOS_MAX_TYPE+1);
67
68 static struct {
69 const char *vendor, *version, *date;
70 bool have_major_minor;
71 uint8_t major, minor;
72 } type0;
73
74 static struct {
75 const char *manufacturer, *product, *version, *serial, *sku, *family;
76 /* uuid is in qemu_uuid[] */
77 } type1;
78
79 static struct {
80 const char *manufacturer, *product, *version, *serial, *asset, *location;
81 } type2;
82
83 static struct {
84 const char *manufacturer, *version, *serial, *asset, *sku;
85 } type3;
86
87 static struct {
88 const char *sock_pfx, *manufacturer, *version, *serial, *asset, *part;
89 } type4;
90
91 static struct {
92 const char *loc_pfx, *bank, *manufacturer, *serial, *asset, *part;
93 } type17;
94
95 static QemuOptsList qemu_smbios_opts = {
96 .name = "smbios",
97 .head = QTAILQ_HEAD_INITIALIZER(qemu_smbios_opts.head),
98 .desc = {
99 /*
100 * no elements => accept any params
101 * validation will happen later
102 */
103 { /* end of list */ }
104 }
105 };
106
107 static const QemuOptDesc qemu_smbios_file_opts[] = {
108 {
109 .name = "file",
110 .type = QEMU_OPT_STRING,
111 .help = "binary file containing an SMBIOS element",
112 },
113 { /* end of list */ }
114 };
115
116 static const QemuOptDesc qemu_smbios_type0_opts[] = {
117 {
118 .name = "type",
119 .type = QEMU_OPT_NUMBER,
120 .help = "SMBIOS element type",
121 },{
122 .name = "vendor",
123 .type = QEMU_OPT_STRING,
124 .help = "vendor name",
125 },{
126 .name = "version",
127 .type = QEMU_OPT_STRING,
128 .help = "version number",
129 },{
130 .name = "date",
131 .type = QEMU_OPT_STRING,
132 .help = "release date",
133 },{
134 .name = "release",
135 .type = QEMU_OPT_STRING,
136 .help = "revision number",
137 },
138 { /* end of list */ }
139 };
140
141 static const QemuOptDesc qemu_smbios_type1_opts[] = {
142 {
143 .name = "type",
144 .type = QEMU_OPT_NUMBER,
145 .help = "SMBIOS element type",
146 },{
147 .name = "manufacturer",
148 .type = QEMU_OPT_STRING,
149 .help = "manufacturer name",
150 },{
151 .name = "product",
152 .type = QEMU_OPT_STRING,
153 .help = "product name",
154 },{
155 .name = "version",
156 .type = QEMU_OPT_STRING,
157 .help = "version number",
158 },{
159 .name = "serial",
160 .type = QEMU_OPT_STRING,
161 .help = "serial number",
162 },{
163 .name = "uuid",
164 .type = QEMU_OPT_STRING,
165 .help = "UUID",
166 },{
167 .name = "sku",
168 .type = QEMU_OPT_STRING,
169 .help = "SKU number",
170 },{
171 .name = "family",
172 .type = QEMU_OPT_STRING,
173 .help = "family name",
174 },
175 { /* end of list */ }
176 };
177
178 static const QemuOptDesc qemu_smbios_type2_opts[] = {
179 {
180 .name = "type",
181 .type = QEMU_OPT_NUMBER,
182 .help = "SMBIOS element type",
183 },{
184 .name = "manufacturer",
185 .type = QEMU_OPT_STRING,
186 .help = "manufacturer name",
187 },{
188 .name = "product",
189 .type = QEMU_OPT_STRING,
190 .help = "product name",
191 },{
192 .name = "version",
193 .type = QEMU_OPT_STRING,
194 .help = "version number",
195 },{
196 .name = "serial",
197 .type = QEMU_OPT_STRING,
198 .help = "serial number",
199 },{
200 .name = "asset",
201 .type = QEMU_OPT_STRING,
202 .help = "asset tag number",
203 },{
204 .name = "location",
205 .type = QEMU_OPT_STRING,
206 .help = "location in chassis",
207 },
208 { /* end of list */ }
209 };
210
211 static const QemuOptDesc qemu_smbios_type3_opts[] = {
212 {
213 .name = "type",
214 .type = QEMU_OPT_NUMBER,
215 .help = "SMBIOS element type",
216 },{
217 .name = "manufacturer",
218 .type = QEMU_OPT_STRING,
219 .help = "manufacturer name",
220 },{
221 .name = "version",
222 .type = QEMU_OPT_STRING,
223 .help = "version number",
224 },{
225 .name = "serial",
226 .type = QEMU_OPT_STRING,
227 .help = "serial number",
228 },{
229 .name = "asset",
230 .type = QEMU_OPT_STRING,
231 .help = "asset tag number",
232 },{
233 .name = "sku",
234 .type = QEMU_OPT_STRING,
235 .help = "SKU number",
236 },
237 { /* end of list */ }
238 };
239
240 static const QemuOptDesc qemu_smbios_type4_opts[] = {
241 {
242 .name = "type",
243 .type = QEMU_OPT_NUMBER,
244 .help = "SMBIOS element type",
245 },{
246 .name = "sock_pfx",
247 .type = QEMU_OPT_STRING,
248 .help = "socket designation string prefix",
249 },{
250 .name = "manufacturer",
251 .type = QEMU_OPT_STRING,
252 .help = "manufacturer name",
253 },{
254 .name = "version",
255 .type = QEMU_OPT_STRING,
256 .help = "version number",
257 },{
258 .name = "serial",
259 .type = QEMU_OPT_STRING,
260 .help = "serial number",
261 },{
262 .name = "asset",
263 .type = QEMU_OPT_STRING,
264 .help = "asset tag number",
265 },{
266 .name = "part",
267 .type = QEMU_OPT_STRING,
268 .help = "part number",
269 },
270 { /* end of list */ }
271 };
272
273 static const QemuOptDesc qemu_smbios_type17_opts[] = {
274 {
275 .name = "type",
276 .type = QEMU_OPT_NUMBER,
277 .help = "SMBIOS element type",
278 },{
279 .name = "loc_pfx",
280 .type = QEMU_OPT_STRING,
281 .help = "device locator string prefix",
282 },{
283 .name = "bank",
284 .type = QEMU_OPT_STRING,
285 .help = "bank locator string",
286 },{
287 .name = "manufacturer",
288 .type = QEMU_OPT_STRING,
289 .help = "manufacturer name",
290 },{
291 .name = "serial",
292 .type = QEMU_OPT_STRING,
293 .help = "serial number",
294 },{
295 .name = "asset",
296 .type = QEMU_OPT_STRING,
297 .help = "asset tag number",
298 },{
299 .name = "part",
300 .type = QEMU_OPT_STRING,
301 .help = "part number",
302 },
303 { /* end of list */ }
304 };
305
306 static void smbios_register_config(void)
307 {
308 qemu_add_opts(&qemu_smbios_opts);
309 }
310
311 machine_init(smbios_register_config);
312
313 static void smbios_validate_table(void)
314 {
315 uint32_t expect_t4_count = smbios_legacy ? smp_cpus : smbios_smp_sockets;
316
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);
320 exit(1);
321 }
322 }
323
324
325 /* legacy setup functions for <= 2.0 machines */
326 static void smbios_add_field(int type, int offset, const void *data, size_t len)
327 {
328 struct smbios_field *field;
329
330 if (!smbios_entries) {
331 smbios_entries_len = sizeof(uint16_t);
332 smbios_entries = g_malloc0(smbios_entries_len);
333 }
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);
339
340 field->type = type;
341 field->offset = cpu_to_le16(offset);
342 memcpy(field->data, data, len);
343
344 smbios_entries_len += sizeof(*field) + len;
345 (*(uint16_t *)smbios_entries) =
346 cpu_to_le16(le16_to_cpu(*(uint16_t *)smbios_entries) + 1);
347 }
348
349 static void smbios_maybe_add_str(int type, int offset, const char *data)
350 {
351 if (data) {
352 smbios_add_field(type, offset, data, strlen(data) + 1);
353 }
354 }
355
356 static void smbios_build_type_0_fields(void)
357 {
358 smbios_maybe_add_str(0, offsetof(struct smbios_type_0, vendor_str),
359 type0.vendor);
360 smbios_maybe_add_str(0, offsetof(struct smbios_type_0, bios_version_str),
361 type0.version);
362 smbios_maybe_add_str(0, offsetof(struct smbios_type_0,
363 bios_release_date_str),
364 type0.date);
365 if (type0.have_major_minor) {
366 smbios_add_field(0, offsetof(struct smbios_type_0,
367 system_bios_major_release),
368 &type0.major, 1);
369 smbios_add_field(0, offsetof(struct smbios_type_0,
370 system_bios_minor_release),
371 &type0.minor, 1);
372 }
373 }
374
375 static void smbios_build_type_1_fields(void)
376 {
377 smbios_maybe_add_str(1, offsetof(struct smbios_type_1, manufacturer_str),
378 type1.manufacturer);
379 smbios_maybe_add_str(1, offsetof(struct smbios_type_1, product_name_str),
380 type1.product);
381 smbios_maybe_add_str(1, offsetof(struct smbios_type_1, version_str),
382 type1.version);
383 smbios_maybe_add_str(1, offsetof(struct smbios_type_1, serial_number_str),
384 type1.serial);
385 smbios_maybe_add_str(1, offsetof(struct smbios_type_1, sku_number_str),
386 type1.sku);
387 smbios_maybe_add_str(1, offsetof(struct smbios_type_1, family_str),
388 type1.family);
389 if (qemu_uuid_set) {
390 smbios_add_field(1, offsetof(struct smbios_type_1, uuid),
391 qemu_uuid, 16);
392 }
393 }
394
395 uint8_t *smbios_get_table_legacy(size_t *length)
396 {
397 if (!smbios_legacy) {
398 *length = 0;
399 return NULL;
400 }
401
402 if (!smbios_immutable) {
403 smbios_build_type_0_fields();
404 smbios_build_type_1_fields();
405 smbios_validate_table();
406 smbios_immutable = true;
407 }
408 *length = smbios_entries_len;
409 return smbios_entries;
410 }
411 /* end: legacy setup functions for <= 2.0 machines */
412
413
414 static bool smbios_skip_table(uint8_t type, bool required_table)
415 {
416 if (test_bit(type, have_binfile_bitmap)) {
417 return true; /* user provided their own binary blob(s) */
418 }
419 if (test_bit(type, have_fields_bitmap)) {
420 return false; /* user provided fields via command line */
421 }
422 if (smbios_have_defaults && required_table) {
423 return false; /* we're building tables, and this one's required */
424 }
425 return true;
426 }
427
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 */ \
431 int str_index = 0; \
432 do { \
433 /* should we skip building this table ? */ \
434 if (smbios_skip_table(tbl_type, tbl_required)) { \
435 return; \
436 } \
437 \
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); \
444 \
445 t->header.type = tbl_type; \
446 t->header.length = sizeof(*t); \
447 t->header.handle = tbl_handle; \
448 } while (0)
449
450 #define SMBIOS_TABLE_SET_STR(tbl_type, field, value) \
451 do { \
452 int len = (value != NULL) ? strlen(value) + 1 : 0; \
453 if (len > 1) { \
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; \
461 } else { \
462 t->field = 0; \
463 } \
464 } while (0)
465
466 #define SMBIOS_BUILD_TABLE_POST \
467 do { \
468 size_t term_cnt, t_size; \
469 \
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; \
476 \
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; \
481 } \
482 \
483 /* update smbios element count */ \
484 smbios_table_cnt++; \
485 } while (0)
486
487 static void smbios_build_type_0_table(void)
488 {
489 SMBIOS_BUILD_TABLE_PRE(0, 0x000, false); /* optional, leave up to BIOS */
490
491 SMBIOS_TABLE_SET_STR(0, vendor_str, type0.vendor);
492 SMBIOS_TABLE_SET_STR(0, bios_version_str, type0.version);
493
494 t->bios_starting_address_segment = 0xE800; /* hardcoded in SeaBIOS */
495
496 SMBIOS_TABLE_SET_STR(0, bios_release_date_str, type0.date);
497
498 t->bios_rom_size = 0; /* hardcoded in SeaBIOS with FIXME comment */
499
500 /* BIOS characteristics not supported */
501 memset(t->bios_characteristics, 0, 8);
502 t->bios_characteristics[0] = 0x08;
503
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;
507
508 if (type0.have_major_minor) {
509 t->system_bios_major_release = type0.major;
510 t->system_bios_minor_release = type0.minor;
511 } else {
512 t->system_bios_major_release = 0;
513 t->system_bios_minor_release = 0;
514 }
515
516 /* hardcoded in SeaBIOS */
517 t->embedded_controller_major_release = 0xFF;
518 t->embedded_controller_minor_release = 0xFF;
519
520 SMBIOS_BUILD_TABLE_POST;
521 }
522
523 static void smbios_build_type_1_table(void)
524 {
525 SMBIOS_BUILD_TABLE_PRE(1, 0x100, true); /* required */
526
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);
531 if (qemu_uuid_set) {
532 memcpy(t->uuid, qemu_uuid, 16);
533 } else {
534 memset(t->uuid, 0, 16);
535 }
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);
539
540 SMBIOS_BUILD_TABLE_POST;
541 }
542
543 static void smbios_build_type_2_table(void)
544 {
545 SMBIOS_BUILD_TABLE_PRE(2, 0x200, false); /* optional */
546
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;
557
558 SMBIOS_BUILD_TABLE_POST;
559 }
560
561 static void smbios_build_type_3_table(void)
562 {
563 SMBIOS_BUILD_TABLE_PRE(3, 0x300, true); /* required */
564
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 */
574 t->oem_defined = 0;
575 t->height = 0;
576 t->number_of_power_cords = 0;
577 t->contained_element_count = 0;
578 SMBIOS_TABLE_SET_STR(3, sku_number_str, type3.sku);
579
580 SMBIOS_BUILD_TABLE_POST;
581 }
582
583 static void smbios_build_type_4_table(unsigned instance)
584 {
585 char sock_str[128];
586
587 SMBIOS_BUILD_TABLE_PRE(4, 0x400 + instance, true); /* required */
588
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);
596 t->voltage = 0;
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 */
612
613 SMBIOS_BUILD_TABLE_POST;
614 smbios_type4_count++;
615 }
616
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)
620
621 #define MAX_T16_STD_SZ 0x80000000 /* 2T in Kilobytes */
622
623 static void smbios_build_type_16_table(unsigned dimm_cnt)
624 {
625 ram_addr_t size_kb;
626
627 SMBIOS_BUILD_TABLE_PRE(16, 0x1000, true); /* required */
628
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;
636 } else {
637 t->maximum_capacity = MAX_T16_STD_SZ;
638 t->extended_maximum_capacity = ram_size;
639 }
640 t->memory_error_information_handle = 0xFFFE; /* Not provided */
641 t->number_of_memory_devices = dimm_cnt;
642
643 SMBIOS_BUILD_TABLE_POST;
644 }
645
646 #define MAX_T17_STD_SZ 0x7FFF /* (32G - 1M), in Megabytes */
647 #define MAX_T17_EXT_SZ 0x80000000 /* 2P, in Megabytes */
648
649 static void smbios_build_type_17_table(unsigned instance, ram_addr_t size)
650 {
651 char loc_str[128];
652 ram_addr_t size_mb;
653
654 SMBIOS_BUILD_TABLE_PRE(17, 0x1100 + instance, true); /* required */
655
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) {
662 t->size = size_mb;
663 t->extended_size = 0;
664 } else {
665 assert(size_mb < MAX_T17_EXT_SZ);
666 t->size = MAX_T17_STD_SZ;
667 t->extended_size = size_mb;
668 }
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 */
686
687 SMBIOS_BUILD_TABLE_POST;
688 }
689
690 static void smbios_build_type_19_table(unsigned instance,
691 ram_addr_t start, ram_addr_t size)
692 {
693 ram_addr_t end, start_kb, end_kb;
694
695 SMBIOS_BUILD_TABLE_PRE(19, 0x1300 + instance, true); /* required */
696
697 end = start + size - 1;
698 assert(end > start);
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;
705 } else {
706 t->starting_address = t->ending_address = UINT32_MAX;
707 t->extended_starting_address = start;
708 t->extended_ending_address = end;
709 }
710 t->memory_array_handle = 0x1000; /* Type 16 (Phys. Mem. Array) */
711 t->partition_width = 1; /* One device per row */
712
713 SMBIOS_BUILD_TABLE_POST;
714 }
715
716 static void smbios_build_type_32_table(void)
717 {
718 SMBIOS_BUILD_TABLE_PRE(32, 0x2000, true); /* required */
719
720 memset(t->reserved, 0, 6);
721 t->boot_status = 0; /* No errors detected */
722
723 SMBIOS_BUILD_TABLE_POST;
724 }
725
726 static void smbios_build_type_127_table(void)
727 {
728 SMBIOS_BUILD_TABLE_PRE(127, 0x7F00, true); /* required */
729 SMBIOS_BUILD_TABLE_POST;
730 }
731
732 void smbios_set_cpuid(uint32_t version, uint32_t features)
733 {
734 smbios_cpuid_version = version;
735 smbios_cpuid_features = features;
736 }
737
738 #define SMBIOS_SET_DEFAULT(field, value) \
739 if (!field) { \
740 field = value; \
741 }
742
743 #define G_FREE_UNLESS_NULL(ptr) \
744 if (ptr != NULL) { \
745 g_free(ptr); \
746 }
747
748 void smbios_set_defaults(const char *manufacturer, const char *product,
749 const char *version, bool legacy_mode)
750 {
751 smbios_have_defaults = true;
752 smbios_legacy = legacy_mode;
753
754 /* drop unwanted version of command-line file blob(s) */
755 if (smbios_legacy) {
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!");
762 exit(1);
763 }
764 } else {
765 G_FREE_UNLESS_NULL(smbios_entries);
766 }
767
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);
781 }
782
783 static void smbios_entry_point_setup(void)
784 {
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);
790
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;
795
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;
800
801 /* BIOS must recalculate: */
802 ep.checksum = 0;
803 ep.intermediate_checksum = 0;
804 ep.structure_table_address = 0; /* where BIOS has copied smbios_tables */
805 }
806
807 void smbios_get_tables(uint8_t **tables, size_t *tables_len,
808 uint8_t **anchor, size_t *anchor_len)
809 {
810 unsigned i, dimm_cnt, instance;
811
812 if (smbios_legacy) {
813 *tables = *anchor = NULL;
814 *tables_len = *anchor_len = 0;
815 return;
816 }
817
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();
823
824 smbios_smp_sockets = smp_cpus / (smp_cores * smp_threads);
825 assert(smbios_smp_sockets >= 1);
826
827 for (i = 0; i < smbios_smp_sockets; i++) {
828 smbios_build_type_4_table(i);
829 }
830
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)
833
834 dimm_cnt = QEMU_ALIGN_UP(ram_size, MAX_DIMM_SZ) / MAX_DIMM_SZ;
835
836 smbios_build_type_16_table(dimm_cnt);
837
838 for (i = 0; i < dimm_cnt; i++) {
839 smbios_build_type_17_table(i, GET_DIMM_SZ);
840 }
841
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);
846 }
847 }
848
849 smbios_build_type_32_table();
850 smbios_build_type_127_table();
851
852 smbios_validate_table();
853 smbios_entry_point_setup();
854 smbios_immutable = true;
855 }
856
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);
862 }
863
864 static void save_opt(const char **dest, QemuOpts *opts, const char *name)
865 {
866 const char *val = qemu_opt_get(opts, name);
867
868 if (val) {
869 *dest = val;
870 }
871 }
872
873 void smbios_entry_add(QemuOpts *opts)
874 {
875 Error *local_err = NULL;
876 const char *val;
877
878 assert(!smbios_immutable);
879
880 val = qemu_opt_get(opts, "file");
881 if (val) {
882 struct smbios_structure_header *header;
883 int size;
884 struct smbios_table *table; /* legacy mode only */
885
886 qemu_opts_validate(opts, qemu_smbios_file_opts, &local_err);
887 if (local_err) {
888 error_report("%s", error_get_pretty(local_err));
889 exit(1);
890 }
891
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);
895 exit(1);
896 }
897
898 /*
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).
902 */
903 smbios_tables = g_realloc(smbios_tables, smbios_tables_len + size);
904 header = (struct smbios_structure_header *)(smbios_tables +
905 smbios_tables_len);
906
907 if (load_image(val, (uint8_t *)header) != size) {
908 error_report("Failed to load SMBIOS file %s", val);
909 exit(1);
910 }
911
912 if (test_bit(header->type, have_fields_bitmap)) {
913 error_report("can't load type %d struct, fields already specified!",
914 header->type);
915 exit(1);
916 }
917 set_bit(header->type, have_binfile_bitmap);
918
919 if (header->type == 4) {
920 smbios_type4_count++;
921 }
922
923 smbios_tables_len += size;
924 if (size > smbios_table_max) {
925 smbios_table_max = size;
926 }
927 smbios_table_cnt++;
928
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.
936 */
937 if (!smbios_entries) {
938 smbios_entries_len = sizeof(uint16_t);
939 smbios_entries = g_malloc0(smbios_entries_len);
940 }
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 */
951
952 return;
953 }
954
955 val = qemu_opt_get(opts, "type");
956 if (val) {
957 unsigned long type = strtoul(val, NULL, 0);
958
959 if (type > SMBIOS_MAX_TYPE) {
960 error_report("out of range!");
961 exit(1);
962 }
963
964 if (test_bit(type, have_binfile_bitmap)) {
965 error_report("can't add fields, binary file already loaded!");
966 exit(1);
967 }
968 set_bit(type, have_fields_bitmap);
969
970 switch (type) {
971 case 0:
972 qemu_opts_validate(opts, qemu_smbios_type0_opts, &local_err);
973 if (local_err) {
974 error_report("%s", error_get_pretty(local_err));
975 exit(1);
976 }
977 save_opt(&type0.vendor, opts, "vendor");
978 save_opt(&type0.version, opts, "version");
979 save_opt(&type0.date, opts, "date");
980
981 val = qemu_opt_get(opts, "release");
982 if (val) {
983 if (sscanf(val, "%hhu.%hhu", &type0.major, &type0.minor) != 2) {
984 error_report("Invalid release");
985 exit(1);
986 }
987 type0.have_major_minor = true;
988 }
989 return;
990 case 1:
991 qemu_opts_validate(opts, qemu_smbios_type1_opts, &local_err);
992 if (local_err) {
993 error_report("%s", error_get_pretty(local_err));
994 exit(1);
995 }
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");
1002
1003 val = qemu_opt_get(opts, "uuid");
1004 if (val) {
1005 if (qemu_uuid_parse(val, qemu_uuid) != 0) {
1006 error_report("Invalid UUID");
1007 exit(1);
1008 }
1009 qemu_uuid_set = true;
1010 }
1011 return;
1012 case 2:
1013 qemu_opts_validate(opts, qemu_smbios_type2_opts, &local_err);
1014 if (local_err) {
1015 error_report("%s", error_get_pretty(local_err));
1016 exit(1);
1017 }
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");
1024 return;
1025 case 3:
1026 qemu_opts_validate(opts, qemu_smbios_type3_opts, &local_err);
1027 if (local_err) {
1028 error_report("%s", error_get_pretty(local_err));
1029 exit(1);
1030 }
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");
1036 return;
1037 case 4:
1038 qemu_opts_validate(opts, qemu_smbios_type4_opts, &local_err);
1039 if (local_err) {
1040 error_report("%s", error_get_pretty(local_err));
1041 exit(1);
1042 }
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");
1049 return;
1050 case 17:
1051 qemu_opts_validate(opts, qemu_smbios_type17_opts, &local_err);
1052 if (local_err) {
1053 error_report("%s", error_get_pretty(local_err));
1054 exit(1);
1055 }
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");
1062 return;
1063 default:
1064 error_report("Don't know how to build fields for SMBIOS type %ld",
1065 type);
1066 exit(1);
1067 }
1068 }
1069
1070 error_report("Must specify type= or file=");
1071 exit(1);
1072 }
AR7 emulation for QEMU