]>
Commit | Line | Data |
---|---|---|
b6f6e3d3 AL |
1 | /* |
2 | * SMBIOS Support | |
3 | * | |
4 | * Copyright (C) 2009 Hewlett-Packard Development Company, L.P. | |
4f953d2f | 5 | * Copyright (C) 2013 Red Hat, Inc. |
b6f6e3d3 AL |
6 | * |
7 | * Authors: | |
8 | * Alex Williamson <alex.williamson@hp.com> | |
4f953d2f | 9 | * Markus Armbruster <armbru@redhat.com> |
b6f6e3d3 AL |
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 | * | |
6b620ca3 PB |
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. | |
b6f6e3d3 AL |
16 | */ |
17 | ||
4f953d2f | 18 | #include "qemu/config-file.h" |
5bb95e41 | 19 | #include "qemu/error-report.h" |
9c17d615 | 20 | #include "sysemu/sysemu.h" |
c97294ec GS |
21 | #include "sysemu/cpus.h" |
22 | #include "hw/i386/pc.h" | |
0d09e41a | 23 | #include "hw/i386/smbios.h" |
83c9f4ca | 24 | #include "hw/loader.h" |
b6f6e3d3 | 25 | |
e6667f71 GS |
26 | |
27 | /* legacy structures and constants for <= 2.0 machines */ | |
b6f6e3d3 AL |
28 | struct smbios_header { |
29 | uint16_t length; | |
30 | uint8_t type; | |
541dc0d4 | 31 | } QEMU_PACKED; |
b6f6e3d3 AL |
32 | |
33 | struct smbios_field { | |
34 | struct smbios_header header; | |
35 | uint8_t type; | |
36 | uint16_t offset; | |
37 | uint8_t data[]; | |
541dc0d4 | 38 | } QEMU_PACKED; |
b6f6e3d3 AL |
39 | |
40 | struct smbios_table { | |
41 | struct smbios_header header; | |
42 | uint8_t data[]; | |
541dc0d4 | 43 | } QEMU_PACKED; |
b6f6e3d3 AL |
44 | |
45 | #define SMBIOS_FIELD_ENTRY 0 | |
46 | #define SMBIOS_TABLE_ENTRY 1 | |
47 | ||
b6f6e3d3 AL |
48 | static uint8_t *smbios_entries; |
49 | static size_t smbios_entries_len; | |
c97294ec | 50 | static bool smbios_legacy = true; |
e6667f71 GS |
51 | /* end: legacy structures & constants for <= 2.0 machines */ |
52 | ||
53 | ||
c97294ec GS |
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 | ||
09c0848e | 60 | static int smbios_type4_count = 0; |
fc3b3295 | 61 | static bool smbios_immutable; |
c97294ec GS |
62 | static bool smbios_have_defaults; |
63 | static uint32_t smbios_cpuid_version, smbios_cpuid_features, smbios_smp_sockets; | |
09c0848e | 64 | |
2e6e8d7a GS |
65 | static DECLARE_BITMAP(have_binfile_bitmap, SMBIOS_MAX_TYPE+1); |
66 | static DECLARE_BITMAP(have_fields_bitmap, SMBIOS_MAX_TYPE+1); | |
ec2df8c1 | 67 | |
fc3b3295 MA |
68 | static struct { |
69 | const char *vendor, *version, *date; | |
84351843 | 70 | bool have_major_minor, uefi; |
fc3b3295 MA |
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 | ||
c97294ec GS |
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 | ||
4f953d2f MA |
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", | |
84351843 GS |
137 | },{ |
138 | .name = "uefi", | |
139 | .type = QEMU_OPT_BOOL, | |
140 | .help = "uefi support", | |
4f953d2f MA |
141 | }, |
142 | { /* end of list */ } | |
143 | }; | |
144 | ||
145 | static const QemuOptDesc qemu_smbios_type1_opts[] = { | |
146 | { | |
147 | .name = "type", | |
148 | .type = QEMU_OPT_NUMBER, | |
149 | .help = "SMBIOS element type", | |
150 | },{ | |
151 | .name = "manufacturer", | |
152 | .type = QEMU_OPT_STRING, | |
153 | .help = "manufacturer name", | |
154 | },{ | |
155 | .name = "product", | |
156 | .type = QEMU_OPT_STRING, | |
157 | .help = "product name", | |
158 | },{ | |
159 | .name = "version", | |
160 | .type = QEMU_OPT_STRING, | |
161 | .help = "version number", | |
162 | },{ | |
163 | .name = "serial", | |
164 | .type = QEMU_OPT_STRING, | |
165 | .help = "serial number", | |
166 | },{ | |
167 | .name = "uuid", | |
168 | .type = QEMU_OPT_STRING, | |
169 | .help = "UUID", | |
170 | },{ | |
171 | .name = "sku", | |
172 | .type = QEMU_OPT_STRING, | |
173 | .help = "SKU number", | |
174 | },{ | |
175 | .name = "family", | |
176 | .type = QEMU_OPT_STRING, | |
177 | .help = "family name", | |
178 | }, | |
179 | { /* end of list */ } | |
180 | }; | |
181 | ||
c97294ec GS |
182 | static const QemuOptDesc qemu_smbios_type2_opts[] = { |
183 | { | |
184 | .name = "type", | |
185 | .type = QEMU_OPT_NUMBER, | |
186 | .help = "SMBIOS element type", | |
187 | },{ | |
188 | .name = "manufacturer", | |
189 | .type = QEMU_OPT_STRING, | |
190 | .help = "manufacturer name", | |
191 | },{ | |
192 | .name = "product", | |
193 | .type = QEMU_OPT_STRING, | |
194 | .help = "product name", | |
195 | },{ | |
196 | .name = "version", | |
197 | .type = QEMU_OPT_STRING, | |
198 | .help = "version number", | |
199 | },{ | |
200 | .name = "serial", | |
201 | .type = QEMU_OPT_STRING, | |
202 | .help = "serial number", | |
203 | },{ | |
204 | .name = "asset", | |
205 | .type = QEMU_OPT_STRING, | |
206 | .help = "asset tag number", | |
207 | },{ | |
208 | .name = "location", | |
209 | .type = QEMU_OPT_STRING, | |
210 | .help = "location in chassis", | |
211 | }, | |
212 | { /* end of list */ } | |
213 | }; | |
214 | ||
215 | static const QemuOptDesc qemu_smbios_type3_opts[] = { | |
216 | { | |
217 | .name = "type", | |
218 | .type = QEMU_OPT_NUMBER, | |
219 | .help = "SMBIOS element type", | |
220 | },{ | |
221 | .name = "manufacturer", | |
222 | .type = QEMU_OPT_STRING, | |
223 | .help = "manufacturer name", | |
224 | },{ | |
225 | .name = "version", | |
226 | .type = QEMU_OPT_STRING, | |
227 | .help = "version number", | |
228 | },{ | |
229 | .name = "serial", | |
230 | .type = QEMU_OPT_STRING, | |
231 | .help = "serial number", | |
232 | },{ | |
233 | .name = "asset", | |
234 | .type = QEMU_OPT_STRING, | |
235 | .help = "asset tag number", | |
236 | },{ | |
237 | .name = "sku", | |
238 | .type = QEMU_OPT_STRING, | |
239 | .help = "SKU number", | |
240 | }, | |
241 | { /* end of list */ } | |
242 | }; | |
243 | ||
244 | static const QemuOptDesc qemu_smbios_type4_opts[] = { | |
245 | { | |
246 | .name = "type", | |
247 | .type = QEMU_OPT_NUMBER, | |
248 | .help = "SMBIOS element type", | |
249 | },{ | |
250 | .name = "sock_pfx", | |
251 | .type = QEMU_OPT_STRING, | |
252 | .help = "socket designation string prefix", | |
253 | },{ | |
254 | .name = "manufacturer", | |
255 | .type = QEMU_OPT_STRING, | |
256 | .help = "manufacturer name", | |
257 | },{ | |
258 | .name = "version", | |
259 | .type = QEMU_OPT_STRING, | |
260 | .help = "version number", | |
261 | },{ | |
262 | .name = "serial", | |
263 | .type = QEMU_OPT_STRING, | |
264 | .help = "serial number", | |
265 | },{ | |
266 | .name = "asset", | |
267 | .type = QEMU_OPT_STRING, | |
268 | .help = "asset tag number", | |
269 | },{ | |
270 | .name = "part", | |
271 | .type = QEMU_OPT_STRING, | |
272 | .help = "part number", | |
273 | }, | |
274 | { /* end of list */ } | |
275 | }; | |
276 | ||
277 | static const QemuOptDesc qemu_smbios_type17_opts[] = { | |
278 | { | |
279 | .name = "type", | |
280 | .type = QEMU_OPT_NUMBER, | |
281 | .help = "SMBIOS element type", | |
282 | },{ | |
283 | .name = "loc_pfx", | |
284 | .type = QEMU_OPT_STRING, | |
285 | .help = "device locator string prefix", | |
286 | },{ | |
287 | .name = "bank", | |
288 | .type = QEMU_OPT_STRING, | |
289 | .help = "bank locator string", | |
290 | },{ | |
291 | .name = "manufacturer", | |
292 | .type = QEMU_OPT_STRING, | |
293 | .help = "manufacturer name", | |
294 | },{ | |
295 | .name = "serial", | |
296 | .type = QEMU_OPT_STRING, | |
297 | .help = "serial number", | |
298 | },{ | |
299 | .name = "asset", | |
300 | .type = QEMU_OPT_STRING, | |
301 | .help = "asset tag number", | |
302 | },{ | |
303 | .name = "part", | |
304 | .type = QEMU_OPT_STRING, | |
305 | .help = "part number", | |
306 | }, | |
307 | { /* end of list */ } | |
308 | }; | |
309 | ||
4f953d2f MA |
310 | static void smbios_register_config(void) |
311 | { | |
312 | qemu_add_opts(&qemu_smbios_opts); | |
313 | } | |
314 | ||
315 | machine_init(smbios_register_config); | |
316 | ||
09c0848e BK |
317 | static void smbios_validate_table(void) |
318 | { | |
c97294ec GS |
319 | uint32_t expect_t4_count = smbios_legacy ? smp_cpus : smbios_smp_sockets; |
320 | ||
321 | if (smbios_type4_count && smbios_type4_count != expect_t4_count) { | |
322 | error_report("Expected %d SMBIOS Type 4 tables, got %d instead", | |
323 | expect_t4_count, smbios_type4_count); | |
09c0848e BK |
324 | exit(1); |
325 | } | |
326 | } | |
b6f6e3d3 | 327 | |
e6667f71 GS |
328 | |
329 | /* legacy setup functions for <= 2.0 machines */ | |
fc3b3295 | 330 | static void smbios_add_field(int type, int offset, const void *data, size_t len) |
b6f6e3d3 AL |
331 | { |
332 | struct smbios_field *field; | |
333 | ||
b6f6e3d3 AL |
334 | if (!smbios_entries) { |
335 | smbios_entries_len = sizeof(uint16_t); | |
7267c094 | 336 | smbios_entries = g_malloc0(smbios_entries_len); |
b6f6e3d3 | 337 | } |
7267c094 | 338 | smbios_entries = g_realloc(smbios_entries, smbios_entries_len + |
b6f6e3d3 AL |
339 | sizeof(*field) + len); |
340 | field = (struct smbios_field *)(smbios_entries + smbios_entries_len); | |
341 | field->header.type = SMBIOS_FIELD_ENTRY; | |
342 | field->header.length = cpu_to_le16(sizeof(*field) + len); | |
343 | ||
344 | field->type = type; | |
345 | field->offset = cpu_to_le16(offset); | |
346 | memcpy(field->data, data, len); | |
347 | ||
348 | smbios_entries_len += sizeof(*field) + len; | |
349 | (*(uint16_t *)smbios_entries) = | |
350 | cpu_to_le16(le16_to_cpu(*(uint16_t *)smbios_entries) + 1); | |
351 | } | |
352 | ||
e26d3e73 | 353 | static void smbios_maybe_add_str(int type, int offset, const char *data) |
b6f6e3d3 | 354 | { |
e26d3e73 MA |
355 | if (data) { |
356 | smbios_add_field(type, offset, data, strlen(data) + 1); | |
4f953d2f | 357 | } |
e26d3e73 MA |
358 | } |
359 | ||
360 | static void smbios_build_type_0_fields(void) | |
361 | { | |
362 | smbios_maybe_add_str(0, offsetof(struct smbios_type_0, vendor_str), | |
363 | type0.vendor); | |
364 | smbios_maybe_add_str(0, offsetof(struct smbios_type_0, bios_version_str), | |
365 | type0.version); | |
366 | smbios_maybe_add_str(0, offsetof(struct smbios_type_0, | |
b6f6e3d3 | 367 | bios_release_date_str), |
e26d3e73 | 368 | type0.date); |
fc3b3295 | 369 | if (type0.have_major_minor) { |
b6f6e3d3 | 370 | smbios_add_field(0, offsetof(struct smbios_type_0, |
ebc85e3f | 371 | system_bios_major_release), |
fc3b3295 | 372 | &type0.major, 1); |
b6f6e3d3 | 373 | smbios_add_field(0, offsetof(struct smbios_type_0, |
ebc85e3f | 374 | system_bios_minor_release), |
fc3b3295 | 375 | &type0.minor, 1); |
b6f6e3d3 AL |
376 | } |
377 | } | |
378 | ||
fc3b3295 | 379 | static void smbios_build_type_1_fields(void) |
b6f6e3d3 | 380 | { |
e26d3e73 MA |
381 | smbios_maybe_add_str(1, offsetof(struct smbios_type_1, manufacturer_str), |
382 | type1.manufacturer); | |
383 | smbios_maybe_add_str(1, offsetof(struct smbios_type_1, product_name_str), | |
384 | type1.product); | |
385 | smbios_maybe_add_str(1, offsetof(struct smbios_type_1, version_str), | |
386 | type1.version); | |
387 | smbios_maybe_add_str(1, offsetof(struct smbios_type_1, serial_number_str), | |
388 | type1.serial); | |
389 | smbios_maybe_add_str(1, offsetof(struct smbios_type_1, sku_number_str), | |
390 | type1.sku); | |
391 | smbios_maybe_add_str(1, offsetof(struct smbios_type_1, family_str), | |
392 | type1.family); | |
fc3b3295 MA |
393 | if (qemu_uuid_set) { |
394 | smbios_add_field(1, offsetof(struct smbios_type_1, uuid), | |
395 | qemu_uuid, 16); | |
396 | } | |
397 | } | |
398 | ||
e6667f71 | 399 | uint8_t *smbios_get_table_legacy(size_t *length) |
fc3b3295 | 400 | { |
c97294ec GS |
401 | if (!smbios_legacy) { |
402 | *length = 0; | |
403 | return NULL; | |
404 | } | |
405 | ||
fc3b3295 MA |
406 | if (!smbios_immutable) { |
407 | smbios_build_type_0_fields(); | |
408 | smbios_build_type_1_fields(); | |
409 | smbios_validate_table(); | |
410 | smbios_immutable = true; | |
411 | } | |
412 | *length = smbios_entries_len; | |
413 | return smbios_entries; | |
414 | } | |
e6667f71 GS |
415 | /* end: legacy setup functions for <= 2.0 machines */ |
416 | ||
fc3b3295 | 417 | |
c97294ec GS |
418 | static bool smbios_skip_table(uint8_t type, bool required_table) |
419 | { | |
420 | if (test_bit(type, have_binfile_bitmap)) { | |
421 | return true; /* user provided their own binary blob(s) */ | |
422 | } | |
423 | if (test_bit(type, have_fields_bitmap)) { | |
424 | return false; /* user provided fields via command line */ | |
425 | } | |
426 | if (smbios_have_defaults && required_table) { | |
427 | return false; /* we're building tables, and this one's required */ | |
428 | } | |
429 | return true; | |
430 | } | |
431 | ||
432 | #define SMBIOS_BUILD_TABLE_PRE(tbl_type, tbl_handle, tbl_required) \ | |
433 | struct smbios_type_##tbl_type *t; \ | |
434 | size_t t_off; /* table offset into smbios_tables */ \ | |
435 | int str_index = 0; \ | |
436 | do { \ | |
437 | /* should we skip building this table ? */ \ | |
438 | if (smbios_skip_table(tbl_type, tbl_required)) { \ | |
439 | return; \ | |
440 | } \ | |
441 | \ | |
442 | /* use offset of table t within smbios_tables */ \ | |
443 | /* (pointer must be updated after each realloc) */ \ | |
444 | t_off = smbios_tables_len; \ | |
445 | smbios_tables_len += sizeof(*t); \ | |
446 | smbios_tables = g_realloc(smbios_tables, smbios_tables_len); \ | |
447 | t = (struct smbios_type_##tbl_type *)(smbios_tables + t_off); \ | |
448 | \ | |
449 | t->header.type = tbl_type; \ | |
450 | t->header.length = sizeof(*t); \ | |
fb5be2e8 | 451 | t->header.handle = cpu_to_le16(tbl_handle); \ |
c97294ec GS |
452 | } while (0) |
453 | ||
454 | #define SMBIOS_TABLE_SET_STR(tbl_type, field, value) \ | |
455 | do { \ | |
456 | int len = (value != NULL) ? strlen(value) + 1 : 0; \ | |
457 | if (len > 1) { \ | |
458 | smbios_tables = g_realloc(smbios_tables, \ | |
459 | smbios_tables_len + len); \ | |
460 | memcpy(smbios_tables + smbios_tables_len, value, len); \ | |
461 | smbios_tables_len += len; \ | |
462 | /* update pointer post-realloc */ \ | |
463 | t = (struct smbios_type_##tbl_type *)(smbios_tables + t_off); \ | |
464 | t->field = ++str_index; \ | |
465 | } else { \ | |
466 | t->field = 0; \ | |
467 | } \ | |
468 | } while (0) | |
469 | ||
470 | #define SMBIOS_BUILD_TABLE_POST \ | |
471 | do { \ | |
472 | size_t term_cnt, t_size; \ | |
473 | \ | |
474 | /* add '\0' terminator (add two if no strings defined) */ \ | |
475 | term_cnt = (str_index == 0) ? 2 : 1; \ | |
476 | smbios_tables = g_realloc(smbios_tables, \ | |
477 | smbios_tables_len + term_cnt); \ | |
478 | memset(smbios_tables + smbios_tables_len, 0, term_cnt); \ | |
479 | smbios_tables_len += term_cnt; \ | |
480 | \ | |
481 | /* update smbios max. element size */ \ | |
482 | t_size = smbios_tables_len - t_off; \ | |
483 | if (t_size > smbios_table_max) { \ | |
484 | smbios_table_max = t_size; \ | |
485 | } \ | |
486 | \ | |
487 | /* update smbios element count */ \ | |
488 | smbios_table_cnt++; \ | |
489 | } while (0) | |
490 | ||
491 | static void smbios_build_type_0_table(void) | |
492 | { | |
493 | SMBIOS_BUILD_TABLE_PRE(0, 0x000, false); /* optional, leave up to BIOS */ | |
494 | ||
495 | SMBIOS_TABLE_SET_STR(0, vendor_str, type0.vendor); | |
496 | SMBIOS_TABLE_SET_STR(0, bios_version_str, type0.version); | |
497 | ||
fb5be2e8 | 498 | t->bios_starting_address_segment = cpu_to_le16(0xE800); /* from SeaBIOS */ |
c97294ec GS |
499 | |
500 | SMBIOS_TABLE_SET_STR(0, bios_release_date_str, type0.date); | |
501 | ||
502 | t->bios_rom_size = 0; /* hardcoded in SeaBIOS with FIXME comment */ | |
503 | ||
84351843 | 504 | t->bios_characteristics = cpu_to_le64(0x08); /* Not supported */ |
c97294ec | 505 | t->bios_characteristics_extension_bytes[0] = 0; |
84351843 GS |
506 | t->bios_characteristics_extension_bytes[1] = 0x14; /* TCD/SVVP | VM */ |
507 | if (type0.uefi) { | |
508 | t->bios_characteristics_extension_bytes[1] |= 0x08; /* |= UEFI */ | |
509 | } | |
c97294ec GS |
510 | |
511 | if (type0.have_major_minor) { | |
512 | t->system_bios_major_release = type0.major; | |
513 | t->system_bios_minor_release = type0.minor; | |
514 | } else { | |
515 | t->system_bios_major_release = 0; | |
516 | t->system_bios_minor_release = 0; | |
517 | } | |
518 | ||
519 | /* hardcoded in SeaBIOS */ | |
520 | t->embedded_controller_major_release = 0xFF; | |
521 | t->embedded_controller_minor_release = 0xFF; | |
522 | ||
523 | SMBIOS_BUILD_TABLE_POST; | |
524 | } | |
525 | ||
526 | static void smbios_build_type_1_table(void) | |
527 | { | |
528 | SMBIOS_BUILD_TABLE_PRE(1, 0x100, true); /* required */ | |
529 | ||
530 | SMBIOS_TABLE_SET_STR(1, manufacturer_str, type1.manufacturer); | |
531 | SMBIOS_TABLE_SET_STR(1, product_name_str, type1.product); | |
532 | SMBIOS_TABLE_SET_STR(1, version_str, type1.version); | |
533 | SMBIOS_TABLE_SET_STR(1, serial_number_str, type1.serial); | |
534 | if (qemu_uuid_set) { | |
535 | memcpy(t->uuid, qemu_uuid, 16); | |
536 | } else { | |
537 | memset(t->uuid, 0, 16); | |
538 | } | |
539 | t->wake_up_type = 0x06; /* power switch */ | |
540 | SMBIOS_TABLE_SET_STR(1, sku_number_str, type1.sku); | |
541 | SMBIOS_TABLE_SET_STR(1, family_str, type1.family); | |
542 | ||
543 | SMBIOS_BUILD_TABLE_POST; | |
544 | } | |
545 | ||
546 | static void smbios_build_type_2_table(void) | |
547 | { | |
548 | SMBIOS_BUILD_TABLE_PRE(2, 0x200, false); /* optional */ | |
549 | ||
550 | SMBIOS_TABLE_SET_STR(2, manufacturer_str, type2.manufacturer); | |
551 | SMBIOS_TABLE_SET_STR(2, product_str, type2.product); | |
552 | SMBIOS_TABLE_SET_STR(2, version_str, type2.version); | |
553 | SMBIOS_TABLE_SET_STR(2, serial_number_str, type2.serial); | |
554 | SMBIOS_TABLE_SET_STR(2, asset_tag_number_str, type2.asset); | |
555 | t->feature_flags = 0x01; /* Motherboard */ | |
556 | SMBIOS_TABLE_SET_STR(2, location_str, type2.location); | |
fb5be2e8 | 557 | t->chassis_handle = cpu_to_le16(0x300); /* Type 3 (System enclosure) */ |
c97294ec GS |
558 | t->board_type = 0x0A; /* Motherboard */ |
559 | t->contained_element_count = 0; | |
560 | ||
561 | SMBIOS_BUILD_TABLE_POST; | |
562 | } | |
563 | ||
564 | static void smbios_build_type_3_table(void) | |
565 | { | |
566 | SMBIOS_BUILD_TABLE_PRE(3, 0x300, true); /* required */ | |
567 | ||
568 | SMBIOS_TABLE_SET_STR(3, manufacturer_str, type3.manufacturer); | |
569 | t->type = 0x01; /* Other */ | |
570 | SMBIOS_TABLE_SET_STR(3, version_str, type3.version); | |
571 | SMBIOS_TABLE_SET_STR(3, serial_number_str, type3.serial); | |
572 | SMBIOS_TABLE_SET_STR(3, asset_tag_number_str, type3.asset); | |
573 | t->boot_up_state = 0x03; /* Safe */ | |
574 | t->power_supply_state = 0x03; /* Safe */ | |
575 | t->thermal_state = 0x03; /* Safe */ | |
576 | t->security_status = 0x02; /* Unknown */ | |
fb5be2e8 | 577 | t->oem_defined = cpu_to_le32(0); |
c97294ec GS |
578 | t->height = 0; |
579 | t->number_of_power_cords = 0; | |
580 | t->contained_element_count = 0; | |
581 | SMBIOS_TABLE_SET_STR(3, sku_number_str, type3.sku); | |
582 | ||
583 | SMBIOS_BUILD_TABLE_POST; | |
584 | } | |
585 | ||
586 | static void smbios_build_type_4_table(unsigned instance) | |
587 | { | |
588 | char sock_str[128]; | |
589 | ||
590 | SMBIOS_BUILD_TABLE_PRE(4, 0x400 + instance, true); /* required */ | |
591 | ||
592 | snprintf(sock_str, sizeof(sock_str), "%s%2x", type4.sock_pfx, instance); | |
593 | SMBIOS_TABLE_SET_STR(4, socket_designation_str, sock_str); | |
594 | t->processor_type = 0x03; /* CPU */ | |
fb5be2e8 | 595 | t->processor_family = 0x01; /* Other */ |
c97294ec | 596 | SMBIOS_TABLE_SET_STR(4, processor_manufacturer_str, type4.manufacturer); |
fb5be2e8 GS |
597 | t->processor_id[0] = cpu_to_le32(smbios_cpuid_version); |
598 | t->processor_id[1] = cpu_to_le32(smbios_cpuid_features); | |
c97294ec GS |
599 | SMBIOS_TABLE_SET_STR(4, processor_version_str, type4.version); |
600 | t->voltage = 0; | |
fb5be2e8 GS |
601 | t->external_clock = cpu_to_le16(0); /* Unknown */ |
602 | t->max_speed = cpu_to_le16(0); /* Unknown */ | |
603 | t->current_speed = cpu_to_le16(0); /* Unknown */ | |
c97294ec GS |
604 | t->status = 0x41; /* Socket populated, CPU enabled */ |
605 | t->processor_upgrade = 0x01; /* Other */ | |
fb5be2e8 GS |
606 | t->l1_cache_handle = cpu_to_le16(0xFFFF); /* N/A */ |
607 | t->l2_cache_handle = cpu_to_le16(0xFFFF); /* N/A */ | |
608 | t->l3_cache_handle = cpu_to_le16(0xFFFF); /* N/A */ | |
c97294ec GS |
609 | SMBIOS_TABLE_SET_STR(4, serial_number_str, type4.serial); |
610 | SMBIOS_TABLE_SET_STR(4, asset_tag_number_str, type4.asset); | |
611 | SMBIOS_TABLE_SET_STR(4, part_number_str, type4.part); | |
612 | t->core_count = t->core_enabled = smp_cores; | |
613 | t->thread_count = smp_threads; | |
fb5be2e8 GS |
614 | t->processor_characteristics = cpu_to_le16(0x02); /* Unknown */ |
615 | t->processor_family2 = cpu_to_le16(0x01); /* Other */ | |
c97294ec GS |
616 | |
617 | SMBIOS_BUILD_TABLE_POST; | |
618 | smbios_type4_count++; | |
619 | } | |
620 | ||
621 | #define ONE_KB ((ram_addr_t)1 << 10) | |
622 | #define ONE_MB ((ram_addr_t)1 << 20) | |
623 | #define ONE_GB ((ram_addr_t)1 << 30) | |
624 | ||
625 | #define MAX_T16_STD_SZ 0x80000000 /* 2T in Kilobytes */ | |
626 | ||
627 | static void smbios_build_type_16_table(unsigned dimm_cnt) | |
628 | { | |
629 | ram_addr_t size_kb; | |
630 | ||
631 | SMBIOS_BUILD_TABLE_PRE(16, 0x1000, true); /* required */ | |
632 | ||
633 | t->location = 0x01; /* Other */ | |
634 | t->use = 0x03; /* System memory */ | |
635 | t->error_correction = 0x06; /* Multi-bit ECC (for Microsoft, per SeaBIOS) */ | |
636 | size_kb = QEMU_ALIGN_UP(ram_size, ONE_KB) / ONE_KB; | |
637 | if (size_kb < MAX_T16_STD_SZ) { | |
fb5be2e8 GS |
638 | t->maximum_capacity = cpu_to_le32(size_kb); |
639 | t->extended_maximum_capacity = cpu_to_le64(0); | |
c97294ec | 640 | } else { |
fb5be2e8 GS |
641 | t->maximum_capacity = cpu_to_le32(MAX_T16_STD_SZ); |
642 | t->extended_maximum_capacity = cpu_to_le64(ram_size); | |
c97294ec | 643 | } |
fb5be2e8 GS |
644 | t->memory_error_information_handle = cpu_to_le16(0xFFFE); /* Not provided */ |
645 | t->number_of_memory_devices = cpu_to_le16(dimm_cnt); | |
c97294ec GS |
646 | |
647 | SMBIOS_BUILD_TABLE_POST; | |
648 | } | |
649 | ||
650 | #define MAX_T17_STD_SZ 0x7FFF /* (32G - 1M), in Megabytes */ | |
651 | #define MAX_T17_EXT_SZ 0x80000000 /* 2P, in Megabytes */ | |
652 | ||
653 | static void smbios_build_type_17_table(unsigned instance, ram_addr_t size) | |
654 | { | |
655 | char loc_str[128]; | |
656 | ram_addr_t size_mb; | |
657 | ||
658 | SMBIOS_BUILD_TABLE_PRE(17, 0x1100 + instance, true); /* required */ | |
659 | ||
fb5be2e8 GS |
660 | t->physical_memory_array_handle = cpu_to_le16(0x1000); /* Type 16 above */ |
661 | t->memory_error_information_handle = cpu_to_le16(0xFFFE); /* Not provided */ | |
662 | t->total_width = cpu_to_le16(0xFFFF); /* Unknown */ | |
663 | t->data_width = cpu_to_le16(0xFFFF); /* Unknown */ | |
c97294ec GS |
664 | size_mb = QEMU_ALIGN_UP(size, ONE_MB) / ONE_MB; |
665 | if (size_mb < MAX_T17_STD_SZ) { | |
fb5be2e8 GS |
666 | t->size = cpu_to_le16(size_mb); |
667 | t->extended_size = cpu_to_le32(0); | |
c97294ec GS |
668 | } else { |
669 | assert(size_mb < MAX_T17_EXT_SZ); | |
fb5be2e8 GS |
670 | t->size = cpu_to_le16(MAX_T17_STD_SZ); |
671 | t->extended_size = cpu_to_le32(size_mb); | |
c97294ec GS |
672 | } |
673 | t->form_factor = 0x09; /* DIMM */ | |
674 | t->device_set = 0; /* Not in a set */ | |
675 | snprintf(loc_str, sizeof(loc_str), "%s %d", type17.loc_pfx, instance); | |
676 | SMBIOS_TABLE_SET_STR(17, device_locator_str, loc_str); | |
677 | SMBIOS_TABLE_SET_STR(17, bank_locator_str, type17.bank); | |
678 | t->memory_type = 0x07; /* RAM */ | |
fb5be2e8 GS |
679 | t->type_detail = cpu_to_le16(0x02); /* Other */ |
680 | t->speed = cpu_to_le16(0); /* Unknown */ | |
c97294ec GS |
681 | SMBIOS_TABLE_SET_STR(17, manufacturer_str, type17.manufacturer); |
682 | SMBIOS_TABLE_SET_STR(17, serial_number_str, type17.serial); | |
683 | SMBIOS_TABLE_SET_STR(17, asset_tag_number_str, type17.asset); | |
684 | SMBIOS_TABLE_SET_STR(17, part_number_str, type17.part); | |
685 | t->attributes = 0; /* Unknown */ | |
0d73394a GS |
686 | t->configured_clock_speed = cpu_to_le16(0); /* Unknown */ |
687 | t->minimum_voltage = cpu_to_le16(0); /* Unknown */ | |
688 | t->maximum_voltage = cpu_to_le16(0); /* Unknown */ | |
689 | t->configured_voltage = cpu_to_le16(0); /* Unknown */ | |
c97294ec GS |
690 | |
691 | SMBIOS_BUILD_TABLE_POST; | |
692 | } | |
693 | ||
694 | static void smbios_build_type_19_table(unsigned instance, | |
695 | ram_addr_t start, ram_addr_t size) | |
696 | { | |
697 | ram_addr_t end, start_kb, end_kb; | |
698 | ||
699 | SMBIOS_BUILD_TABLE_PRE(19, 0x1300 + instance, true); /* required */ | |
700 | ||
701 | end = start + size - 1; | |
702 | assert(end > start); | |
703 | start_kb = start / ONE_KB; | |
704 | end_kb = end / ONE_KB; | |
705 | if (start_kb < UINT32_MAX && end_kb < UINT32_MAX) { | |
fb5be2e8 GS |
706 | t->starting_address = cpu_to_le32(start_kb); |
707 | t->ending_address = cpu_to_le32(end_kb); | |
708 | t->extended_starting_address = | |
709 | t->extended_ending_address = cpu_to_le64(0); | |
c97294ec | 710 | } else { |
fb5be2e8 GS |
711 | t->starting_address = t->ending_address = cpu_to_le32(UINT32_MAX); |
712 | t->extended_starting_address = cpu_to_le64(start); | |
713 | t->extended_ending_address = cpu_to_le64(end); | |
c97294ec | 714 | } |
fb5be2e8 | 715 | t->memory_array_handle = cpu_to_le16(0x1000); /* Type 16 above */ |
c97294ec GS |
716 | t->partition_width = 1; /* One device per row */ |
717 | ||
718 | SMBIOS_BUILD_TABLE_POST; | |
719 | } | |
720 | ||
721 | static void smbios_build_type_32_table(void) | |
722 | { | |
723 | SMBIOS_BUILD_TABLE_PRE(32, 0x2000, true); /* required */ | |
724 | ||
725 | memset(t->reserved, 0, 6); | |
726 | t->boot_status = 0; /* No errors detected */ | |
727 | ||
728 | SMBIOS_BUILD_TABLE_POST; | |
729 | } | |
730 | ||
731 | static void smbios_build_type_127_table(void) | |
732 | { | |
733 | SMBIOS_BUILD_TABLE_PRE(127, 0x7F00, true); /* required */ | |
734 | SMBIOS_BUILD_TABLE_POST; | |
735 | } | |
736 | ||
737 | void smbios_set_cpuid(uint32_t version, uint32_t features) | |
738 | { | |
739 | smbios_cpuid_version = version; | |
740 | smbios_cpuid_features = features; | |
741 | } | |
742 | ||
cb36acb6 GS |
743 | #define SMBIOS_SET_DEFAULT(field, value) \ |
744 | if (!field) { \ | |
745 | field = value; \ | |
746 | } | |
747 | ||
748 | void smbios_set_defaults(const char *manufacturer, const char *product, | |
c97294ec | 749 | const char *version, bool legacy_mode) |
cb36acb6 | 750 | { |
c97294ec GS |
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) { | |
a10678b0 | 756 | g_free(smbios_tables); |
c97294ec GS |
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 { | |
a10678b0 | 765 | g_free(smbios_entries); |
c97294ec GS |
766 | } |
767 | ||
cb36acb6 GS |
768 | SMBIOS_SET_DEFAULT(type1.manufacturer, manufacturer); |
769 | SMBIOS_SET_DEFAULT(type1.product, product); | |
770 | SMBIOS_SET_DEFAULT(type1.version, version); | |
c97294ec GS |
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: */ | |
fb5be2e8 GS |
797 | ep.structure_table_length = cpu_to_le16(smbios_tables_len); |
798 | ep.max_structure_size = cpu_to_le16(smbios_table_max); | |
799 | ep.number_of_structures = cpu_to_le16(smbios_table_cnt); | |
c97294ec GS |
800 | |
801 | /* BIOS must recalculate: */ | |
802 | ep.checksum = 0; | |
803 | ep.intermediate_checksum = 0; | |
fb5be2e8 | 804 | ep.structure_table_address = cpu_to_le32(0); |
c97294ec GS |
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 | ||
7dfddd7f | 824 | smbios_smp_sockets = DIV_ROUND_UP(smp_cpus, smp_cores * smp_threads); |
c97294ec GS |
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); | |
cb36acb6 GS |
862 | } |
863 | ||
fc3b3295 MA |
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; | |
4f953d2f | 870 | } |
b6f6e3d3 AL |
871 | } |
872 | ||
4f953d2f | 873 | void smbios_entry_add(QemuOpts *opts) |
b6f6e3d3 | 874 | { |
4f953d2f MA |
875 | Error *local_err = NULL; |
876 | const char *val; | |
b6f6e3d3 | 877 | |
fc3b3295 | 878 | assert(!smbios_immutable); |
c97294ec | 879 | |
4f953d2f MA |
880 | val = qemu_opt_get(opts, "file"); |
881 | if (val) { | |
b6f6e3d3 | 882 | struct smbios_structure_header *header; |
4f953d2f | 883 | int size; |
c97294ec | 884 | struct smbios_table *table; /* legacy mode only */ |
4f953d2f MA |
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 | } | |
b6f6e3d3 | 891 | |
4f953d2f | 892 | size = get_image_size(val); |
09c0848e | 893 | if (size == -1 || size < sizeof(struct smbios_structure_header)) { |
4f953d2f | 894 | error_report("Cannot read SMBIOS file %s", val); |
b6f6e3d3 AL |
895 | exit(1); |
896 | } | |
897 | ||
c97294ec GS |
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); | |
b6f6e3d3 | 906 | |
c97294ec | 907 | if (load_image(val, (uint8_t *)header) != size) { |
4f953d2f | 908 | error_report("Failed to load SMBIOS file %s", val); |
b6f6e3d3 AL |
909 | exit(1); |
910 | } | |
911 | ||
2e6e8d7a GS |
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 | ||
09c0848e BK |
919 | if (header->type == 4) { |
920 | smbios_type4_count++; | |
921 | } | |
b6f6e3d3 | 922 | |
c97294ec GS |
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); | |
b6f6e3d3 AL |
947 | smbios_entries_len += sizeof(*table) + size; |
948 | (*(uint16_t *)smbios_entries) = | |
949 | cpu_to_le16(le16_to_cpu(*(uint16_t *)smbios_entries) + 1); | |
c97294ec GS |
950 | /* end: add a copy of the newly loaded blob to legacy smbios_entries */ |
951 | ||
351a6a73 | 952 | return; |
b6f6e3d3 AL |
953 | } |
954 | ||
4f953d2f MA |
955 | val = qemu_opt_get(opts, "type"); |
956 | if (val) { | |
957 | unsigned long type = strtoul(val, NULL, 0); | |
958 | ||
2e6e8d7a GS |
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); | |
fc3b3295 | 969 | |
b6f6e3d3 AL |
970 | switch (type) { |
971 | case 0: | |
4f953d2f MA |
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 | } | |
fc3b3295 MA |
977 | save_opt(&type0.vendor, opts, "vendor"); |
978 | save_opt(&type0.version, opts, "version"); | |
979 | save_opt(&type0.date, opts, "date"); | |
84351843 | 980 | type0.uefi = qemu_opt_get_bool(opts, "uefi", false); |
fc3b3295 MA |
981 | |
982 | val = qemu_opt_get(opts, "release"); | |
983 | if (val) { | |
984 | if (sscanf(val, "%hhu.%hhu", &type0.major, &type0.minor) != 2) { | |
985 | error_report("Invalid release"); | |
986 | exit(1); | |
987 | } | |
988 | type0.have_major_minor = true; | |
989 | } | |
351a6a73 | 990 | return; |
b6f6e3d3 | 991 | case 1: |
4f953d2f MA |
992 | qemu_opts_validate(opts, qemu_smbios_type1_opts, &local_err); |
993 | if (local_err) { | |
994 | error_report("%s", error_get_pretty(local_err)); | |
995 | exit(1); | |
996 | } | |
fc3b3295 MA |
997 | save_opt(&type1.manufacturer, opts, "manufacturer"); |
998 | save_opt(&type1.product, opts, "product"); | |
999 | save_opt(&type1.version, opts, "version"); | |
1000 | save_opt(&type1.serial, opts, "serial"); | |
1001 | save_opt(&type1.sku, opts, "sku"); | |
1002 | save_opt(&type1.family, opts, "family"); | |
1003 | ||
1004 | val = qemu_opt_get(opts, "uuid"); | |
1005 | if (val) { | |
1006 | if (qemu_uuid_parse(val, qemu_uuid) != 0) { | |
1007 | error_report("Invalid UUID"); | |
1008 | exit(1); | |
1009 | } | |
1010 | qemu_uuid_set = true; | |
1011 | } | |
351a6a73 | 1012 | return; |
c97294ec GS |
1013 | case 2: |
1014 | qemu_opts_validate(opts, qemu_smbios_type2_opts, &local_err); | |
1015 | if (local_err) { | |
1016 | error_report("%s", error_get_pretty(local_err)); | |
1017 | exit(1); | |
1018 | } | |
1019 | save_opt(&type2.manufacturer, opts, "manufacturer"); | |
1020 | save_opt(&type2.product, opts, "product"); | |
1021 | save_opt(&type2.version, opts, "version"); | |
1022 | save_opt(&type2.serial, opts, "serial"); | |
1023 | save_opt(&type2.asset, opts, "asset"); | |
1024 | save_opt(&type2.location, opts, "location"); | |
1025 | return; | |
1026 | case 3: | |
1027 | qemu_opts_validate(opts, qemu_smbios_type3_opts, &local_err); | |
1028 | if (local_err) { | |
1029 | error_report("%s", error_get_pretty(local_err)); | |
1030 | exit(1); | |
1031 | } | |
1032 | save_opt(&type3.manufacturer, opts, "manufacturer"); | |
1033 | save_opt(&type3.version, opts, "version"); | |
1034 | save_opt(&type3.serial, opts, "serial"); | |
1035 | save_opt(&type3.asset, opts, "asset"); | |
1036 | save_opt(&type3.sku, opts, "sku"); | |
1037 | return; | |
1038 | case 4: | |
1039 | qemu_opts_validate(opts, qemu_smbios_type4_opts, &local_err); | |
1040 | if (local_err) { | |
1041 | error_report("%s", error_get_pretty(local_err)); | |
1042 | exit(1); | |
1043 | } | |
1044 | save_opt(&type4.sock_pfx, opts, "sock_pfx"); | |
1045 | save_opt(&type4.manufacturer, opts, "manufacturer"); | |
1046 | save_opt(&type4.version, opts, "version"); | |
1047 | save_opt(&type4.serial, opts, "serial"); | |
1048 | save_opt(&type4.asset, opts, "asset"); | |
1049 | save_opt(&type4.part, opts, "part"); | |
1050 | return; | |
1051 | case 17: | |
1052 | qemu_opts_validate(opts, qemu_smbios_type17_opts, &local_err); | |
1053 | if (local_err) { | |
1054 | error_report("%s", error_get_pretty(local_err)); | |
1055 | exit(1); | |
1056 | } | |
1057 | save_opt(&type17.loc_pfx, opts, "loc_pfx"); | |
1058 | save_opt(&type17.bank, opts, "bank"); | |
1059 | save_opt(&type17.manufacturer, opts, "manufacturer"); | |
1060 | save_opt(&type17.serial, opts, "serial"); | |
1061 | save_opt(&type17.asset, opts, "asset"); | |
1062 | save_opt(&type17.part, opts, "part"); | |
1063 | return; | |
b6f6e3d3 | 1064 | default: |
5bb95e41 MA |
1065 | error_report("Don't know how to build fields for SMBIOS type %ld", |
1066 | type); | |
b6f6e3d3 AL |
1067 | exit(1); |
1068 | } | |
1069 | } | |
1070 | ||
5bb95e41 | 1071 | error_report("Must specify type= or file="); |
351a6a73 | 1072 | exit(1); |
b6f6e3d3 | 1073 | } |