![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to 0012-load-smbios-entries-and-files-from-qemu.patch CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / pc-bios / bios-pq|
Return to 0012-load-smbios-entries-and-files-from-qemu.patch CVS log | Up to [Qemu by Fabrice Bellard] / qemu / pc-bios / bios-pq |
1.1 root 1: qemu:bios: Load SMBIOS entries and files from qemu (Alex Williamson)
2:
3: Allow SMBIOS fields to be overridden and entries replaced by those
4: read from qemu.
5:
6: Signed-off-by: Alex Williamson <[email protected]>
7: Signed-off-by: Anthony Liguori <[email protected]>
8:
9: diff --git a/bios/rombios32.c b/bios/rombios32.c
10: index 7be4216..1a1ed64 100644
11: --- a/bios/rombios32.c
12: +++ b/bios/rombios32.c
13: @@ -441,7 +441,6 @@ uint32_t cpuid_features;
14: uint32_t cpuid_ext_features;
15: unsigned long ram_size;
16: uint64_t ram_end;
17: -uint8_t bios_uuid[16];
18: #ifdef BX_USE_EBDA_TABLES
19: unsigned long ebda_cur_addr;
20: #endif
21: @@ -471,6 +470,7 @@ void wrmsr_smp(uint32_t index, uint64_t val)
22: #define QEMU_CFG_UUID 0x02
23: #define QEMU_CFG_ARCH_LOCAL 0x8000
24: #define QEMU_CFG_ACPI_TABLES (QEMU_CFG_ARCH_LOCAL + 0)
25: +#define QEMU_CFG_SMBIOS_ENTRIES (QEMU_CFG_ARCH_LOCAL + 1)
26:
27: int qemu_cfg_port;
28:
29: @@ -519,19 +519,17 @@ static int acpi_load_table(int i, uint32_t addr, uint16_t *len)
30: qemu_cfg_read((uint8_t*)addr, *len);
31: return 0;
32: }
33: -#endif
34:
35: -void uuid_probe(void)
36: +static uint16_t smbios_entries(void)
37: {
38: -#ifdef BX_QEMU
39: - if(qemu_cfg_port) {
40: - qemu_cfg_select(QEMU_CFG_UUID);
41: - qemu_cfg_read(bios_uuid, 16);
42: - return;
43: - }
44: -#endif
45: - memset(bios_uuid, 0, 16);
46: + uint16_t cnt;
47: +
48: + qemu_cfg_select(QEMU_CFG_SMBIOS_ENTRIES);
49: + qemu_cfg_read((uint8_t*)&cnt, sizeof(cnt));
50: +
51: + return cnt;
52: }
53: +#endif
54:
55: void cpu_probe(void)
56: {
57: @@ -1963,21 +1961,105 @@ smbios_entry_point_init(void *start,
58: ep->intermediate_checksum = -sum;
59: }
60:
61: +struct smbios_header {
62: + uint16_t length;
63: + uint8_t type;
64: +} __attribute__((__packed__));
65: +
66: +struct smbios_field {
67: + struct smbios_header header;
68: + uint8_t type;
69: + uint16_t offset;
70: + uint8_t data[];
71: +} __attribute__((__packed__));
72: +
73: +struct smbios_table {
74: + struct smbios_header header;
75: + uint8_t data[];
76: +} __attribute__((__packed__));
77: +
78: +#define SMBIOS_FIELD_ENTRY 0
79: +#define SMBIOS_TABLE_ENTRY 1
80: +
81: +static size_t
82: +smbios_load_field(int type, size_t offset, void *addr)
83: +{
84: +#ifdef BX_QEMU
85: + int i;
86: +
87: + for (i = smbios_entries(); i > 0; i--) {
88: + struct smbios_field field;
89: +
90: + qemu_cfg_read((uint8_t *)&field, sizeof(struct smbios_header));
91: + field.header.length -= sizeof(struct smbios_header);
92: +
93: + if (field.header.type != SMBIOS_FIELD_ENTRY) {
94: + while (field.header.length--)
95: + inb(QEMU_CFG_DATA_PORT);
96: + continue;
97: + }
98: +
99: + qemu_cfg_read((uint8_t *)&field.type,
100: + sizeof(field) - sizeof(struct smbios_header));
101: + field.header.length -= sizeof(field) - sizeof(struct smbios_header);
102: +
103: + if (field.type != type || field.offset != offset) {
104: + while (field.header.length--)
105: + inb(QEMU_CFG_DATA_PORT);
106: + continue;
107: + }
108: +
109: + qemu_cfg_read(addr, field.header.length);
110: + return (size_t)field.header.length;
111: + }
112: +#endif
113: + return 0;
114: +}
115: +
116: +#define load_str_field_with_default(type, field, def) do { \
117: + size = smbios_load_field(type, offsetof(struct smbios_type_##type, \
118: + field), end); \
119: + if (size > 0) { \
120: + end += size; \
121: + } else { \
122: + memcpy(end, def, sizeof(def)); \
123: + end += sizeof(def); \
124: + } \
125: + p->field = ++str_index; \
126: +} while (0)
127: +
128: +#define load_str_field_or_skip(type, field) do { \
129: + size = smbios_load_field(type, offsetof(struct smbios_type_##type, \
130: + field), end); \
131: + if (size > 0) { \
132: + end += size; \
133: + p->field = ++str_index; \
134: + } else { \
135: + p->field = 0; \
136: + } \
137: +} while (0)
138: +
139: /* Type 0 -- BIOS Information */
140: #define RELEASE_DATE_STR "01/01/2007"
141: static void *
142: -smbios_type_0_init(void *start)
143: +smbios_init_type_0(void *start)
144: {
145: struct smbios_type_0 *p = (struct smbios_type_0 *)start;
146: + char *end = (char *)start + sizeof(struct smbios_type_0);
147: + size_t size;
148: + int str_index = 0;
149:
150: p->header.type = 0;
151: p->header.length = sizeof(struct smbios_type_0);
152: p->header.handle = 0;
153:
154: - p->vendor_str = 1;
155: - p->bios_version_str = 1;
156: + load_str_field_with_default(0, vendor_str, BX_APPNAME);
157: + load_str_field_with_default(0, bios_version_str, BX_APPNAME);
158: +
159: p->bios_starting_address_segment = 0xe800;
160: - p->bios_release_date_str = 2;
161: +
162: + load_str_field_with_default(0, bios_release_date_str, RELEASE_DATE_STR);
163: +
164: p->bios_rom_size = 0; /* FIXME */
165:
166: memset(p->bios_characteristics, 0, 8);
167: @@ -1985,50 +2067,66 @@ smbios_type_0_init(void *start)
168: p->bios_characteristics_extension_bytes[0] = 0;
169: p->bios_characteristics_extension_bytes[1] = 0;
170:
171: - p->system_bios_major_release = 1;
172: - p->system_bios_minor_release = 0;
173: + if (!smbios_load_field(0, offsetof(struct smbios_type_0,
174: + system_bios_major_release),
175: + &p->system_bios_major_release))
176: + p->system_bios_major_release = 1;
177: +
178: + if (!smbios_load_field(0, offsetof(struct smbios_type_0,
179: + system_bios_minor_release),
180: + &p->system_bios_minor_release))
181: + p->system_bios_minor_release = 0;
182: +
183: p->embedded_controller_major_release = 0xff;
184: p->embedded_controller_minor_release = 0xff;
185:
186: - start += sizeof(struct smbios_type_0);
187: - memcpy((char *)start, BX_APPNAME, sizeof(BX_APPNAME));
188: - start += sizeof(BX_APPNAME);
189: - memcpy((char *)start, RELEASE_DATE_STR, sizeof(RELEASE_DATE_STR));
190: - start += sizeof(RELEASE_DATE_STR);
191: - *((uint8_t *)start) = 0;
192: + *end = 0;
193: + end++;
194:
195: - return start+1;
196: + return end;
197: }
198:
199: /* Type 1 -- System Information */
200: static void *
201: -smbios_type_1_init(void *start)
202: +smbios_init_type_1(void *start)
203: {
204: struct smbios_type_1 *p = (struct smbios_type_1 *)start;
205: + char *end = (char *)start + sizeof(struct smbios_type_1);
206: + size_t size;
207: + int str_index = 0;
208: +
209: p->header.type = 1;
210: p->header.length = sizeof(struct smbios_type_1);
211: p->header.handle = 0x100;
212:
213: - p->manufacturer_str = 0;
214: - p->product_name_str = 0;
215: - p->version_str = 0;
216: - p->serial_number_str = 0;
217: + load_str_field_or_skip(1, manufacturer_str);
218: + load_str_field_or_skip(1, product_name_str);
219: + load_str_field_or_skip(1, version_str);
220: + load_str_field_or_skip(1, serial_number_str);
221:
222: - memcpy(p->uuid, bios_uuid, 16);
223: + size = smbios_load_field(1, offsetof(struct smbios_type_1,
224: + uuid), &p->uuid);
225: + if (size == 0)
226: + memset(p->uuid, 0, 16);
227:
228: p->wake_up_type = 0x06; /* power switch */
229: - p->sku_number_str = 0;
230: - p->family_str = 0;
231:
232: - start += sizeof(struct smbios_type_1);
233: - *((uint16_t *)start) = 0;
234: + load_str_field_or_skip(1, sku_number_str);
235: + load_str_field_or_skip(1, family_str);
236:
237: - return start+2;
238: + *end = 0;
239: + end++;
240: + if (!str_index) {
241: + *end = 0;
242: + end++;
243: + }
244: +
245: + return end;
246: }
247:
248: /* Type 3 -- System Enclosure */
249: static void *
250: -smbios_type_3_init(void *start)
251: +smbios_init_type_3(void *start)
252: {
253: struct smbios_type_3 *p = (struct smbios_type_3 *)start;
254:
255: @@ -2058,7 +2156,7 @@ smbios_type_3_init(void *start)
256:
257: /* Type 4 -- Processor Information */
258: static void *
259: -smbios_type_4_init(void *start, unsigned int cpu_number)
260: +smbios_init_type_4(void *start, unsigned int cpu_number)
261: {
262: struct smbios_type_4 *p = (struct smbios_type_4 *)start;
263:
264: @@ -2098,7 +2196,7 @@ smbios_type_4_init(void *start, unsigned int cpu_number)
265:
266: /* Type 16 -- Physical Memory Array */
267: static void *
268: -smbios_type_16_init(void *start, uint32_t memsize, int nr_mem_devs)
269: +smbios_init_type_16(void *start, uint32_t memsize, int nr_mem_devs)
270: {
271: struct smbios_type_16 *p = (struct smbios_type_16*)start;
272:
273: @@ -2121,7 +2219,7 @@ smbios_type_16_init(void *start, uint32_t memsize, int nr_mem_devs)
274:
275: /* Type 17 -- Memory Device */
276: static void *
277: -smbios_type_17_init(void *start, uint32_t memory_size_mb, int instance)
278: +smbios_init_type_17(void *start, uint32_t memory_size_mb, int instance)
279: {
280: struct smbios_type_17 *p = (struct smbios_type_17 *)start;
281:
282: @@ -2151,7 +2249,7 @@ smbios_type_17_init(void *start, uint32_t memory_size_mb, int instance)
283:
284: /* Type 19 -- Memory Array Mapped Address */
285: static void *
286: -smbios_type_19_init(void *start, uint32_t memory_size_mb, int instance)
287: +smbios_init_type_19(void *start, uint32_t memory_size_mb, int instance)
288: {
289: struct smbios_type_19 *p = (struct smbios_type_19 *)start;
290:
291: @@ -2172,7 +2270,7 @@ smbios_type_19_init(void *start, uint32_t memory_size_mb, int instance)
292:
293: /* Type 20 -- Memory Device Mapped Address */
294: static void *
295: -smbios_type_20_init(void *start, uint32_t memory_size_mb, int instance)
296: +smbios_init_type_20(void *start, uint32_t memory_size_mb, int instance)
297: {
298: struct smbios_type_20 *p = (struct smbios_type_20 *)start;
299:
300: @@ -2196,7 +2294,7 @@ smbios_type_20_init(void *start, uint32_t memory_size_mb, int instance)
301:
302: /* Type 32 -- System Boot Information */
303: static void *
304: -smbios_type_32_init(void *start)
305: +smbios_init_type_32(void *start)
306: {
307: struct smbios_type_32 *p = (struct smbios_type_32 *)start;
308:
309: @@ -2214,7 +2312,7 @@ smbios_type_32_init(void *start)
310:
311: /* Type 127 -- End of Table */
312: static void *
313: -smbios_type_127_init(void *start)
314: +smbios_init_type_127(void *start)
315: {
316: struct smbios_type_127 *p = (struct smbios_type_127 *)start;
317:
318: @@ -2228,6 +2326,78 @@ smbios_type_127_init(void *start)
319: return start + 2;
320: }
321:
322: +static int
323: +smbios_load_external(int type, char **p, unsigned *nr_structs,
324: + unsigned *max_struct_size)
325: +{
326: +#ifdef BX_QEMU
327: + static uint64_t used_bitmap[4] = { 0 };
328: + char *start = *p;
329: + int i;
330: +
331: + /* Check if we've already reported these tables */
332: + if (used_bitmap[(type >> 6) & 0x3] & (1ULL << (type & 0x3f)))
333: + return 1;
334: +
335: + /* Don't introduce spurious end markers */
336: + if (type == 127)
337: + return 0;
338: +
339: + for (i = smbios_entries(); i > 0; i--) {
340: + struct smbios_table table;
341: + struct smbios_structure_header *header = (void *)*p;
342: + int string;
343: +
344: + qemu_cfg_read((uint8_t *)&table, sizeof(struct smbios_header));
345: + table.header.length -= sizeof(struct smbios_header);
346: +
347: + if (table.header.type != SMBIOS_TABLE_ENTRY) {
348: + while (table.header.length--)
349: + inb(QEMU_CFG_DATA_PORT);
350: + continue;
351: + }
352: +
353: + qemu_cfg_read((uint8_t *)*p, sizeof(struct smbios_structure_header));
354: + table.header.length -= sizeof(struct smbios_structure_header);
355: +
356: + if (header->type != type) {
357: + while (table.header.length--)
358: + inb(QEMU_CFG_DATA_PORT);
359: + continue;
360: + }
361: +
362: + *p += sizeof(struct smbios_structure_header);
363: +
364: + /* Entries end with a double NULL char, if there's a string at
365: + * the end (length is greater than formatted length), the string
366: + * terminator provides the first NULL. */
367: + string = header->length < table.header.length +
368: + sizeof(struct smbios_structure_header);
369: +
370: + /* Read the rest and terminate the entry */
371: + qemu_cfg_read((uint8_t *)*p, table.header.length);
372: + *p += table.header.length;
373: + *((uint8_t*)*p) = 0;
374: + (*p)++;
375: + if (!string) {
376: + *((uint8_t*)*p) = 0;
377: + (*p)++;
378: + }
379: +
380: + (*nr_structs)++;
381: + if (*p - (char *)header > *max_struct_size)
382: + *max_struct_size = *p - (char *)header;
383: + }
384: +
385: + /* Mark that we've reported on this type */
386: + used_bitmap[(type >> 6) & 0x3] |= (1ULL << (type & 0x3f));
387: +
388: + return (start != *p);
389: +#else /* !BX_QEMU */
390: + return 0;
391: +#endif
392: +}
393: +
394: void smbios_init(void)
395: {
396: unsigned cpu_num, nr_structs = 0, max_struct_size = 0;
397: @@ -2246,34 +2416,39 @@ void smbios_init(void)
398:
399: p = (char *)start + sizeof(struct smbios_entry_point);
400:
401: -#define add_struct(fn) do{ \
402: - q = (fn); \
403: - nr_structs++; \
404: - if ((q - p) > max_struct_size) \
405: - max_struct_size = q - p; \
406: - p = q; \
407: -}while (0)
408: -
409: - add_struct(smbios_type_0_init(p));
410: - add_struct(smbios_type_1_init(p));
411: - add_struct(smbios_type_3_init(p));
412: +#define add_struct(type, args...) do { \
413: + if (!smbios_load_external(type, &p, &nr_structs, &max_struct_size)) { \
414: + q = smbios_init_type_##type(args); \
415: + nr_structs++; \
416: + if ((q - p) > max_struct_size) \
417: + max_struct_size = q - p; \
418: + p = q; \
419: + } \
420: +} while (0)
421: +
422: + add_struct(0, p);
423: + add_struct(1, p);
424: + add_struct(3, p);
425: for (cpu_num = 1; cpu_num <= smp_cpus; cpu_num++)
426: - add_struct(smbios_type_4_init(p, cpu_num));
427: + add_struct(4, p, cpu_num);
428:
429: /* Each 'memory device' covers up to 16GB of address space. */
430: nr_mem_devs = (memsize + 0x3fff) >> 14;
431: - add_struct(smbios_type_16_init(p, memsize, nr_mem_devs));
432: + add_struct(16, p, memsize, nr_mem_devs);
433: for ( i = 0; i < nr_mem_devs; i++ )
434: {
435: uint32_t dev_memsize = ((i == (nr_mem_devs - 1))
436: ? (((memsize-1) & 0x3fff)+1) : 0x4000);
437: - add_struct(smbios_type_17_init(p, dev_memsize, i));
438: - add_struct(smbios_type_19_init(p, dev_memsize, i));
439: - add_struct(smbios_type_20_init(p, dev_memsize, i));
440: + add_struct(17, p, dev_memsize, i);
441: + add_struct(19, p, dev_memsize, i);
442: + add_struct(20, p, dev_memsize, i);
443: }
444:
445: - add_struct(smbios_type_32_init(p));
446: - add_struct(smbios_type_127_init(p));
447: + add_struct(32, p);
448: + /* Add any remaining provided entries before the end marker */
449: + for (i = 0; i < 256; i++)
450: + smbios_load_external(i, &p, &nr_structs, &max_struct_size);
451: + add_struct(127, p);
452:
453: #undef add_struct
454:
455: @@ -2380,8 +2555,6 @@ void rombios32_init(uint32_t *s3_resume_vector, uint8_t *shutdown_flag)
456:
457: mptable_init();
458:
459: - uuid_probe();
460: -
461: smbios_init();
462:
463: if (acpi_enabled)
464:
465:
466: --
467: To unsubscribe from this list: send the line "unsubscribe kvm" in
468: the body of a message to [email protected]
469: More majordomo info at http://vger.kernel.org/majordomo-info.html
470:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.