From 59820aacf5f9bcfde98753fde79ca2c779d755aa Mon Sep 17 00:00:00 2001
From: Mark Salter <msalter@redhat.com>
Date: Tue, 24 Feb 2015 23:42:05 -0500
Subject: [PATCH] Support SMBIOS 3.0 64-bit header

The SMBIOS 64-bit header adds suport for a 64-bit base address for the
SMBIOS tables. This patch adds code to parse deal with older 32-bit
headers and well as the 64-bit header. It also fixes 32-bit address
assumptions in a number of places.

Signed-off-by: Mark Salter <msalter@redhat.com>
---
 dmidecode.c | 143 +++++++++++++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 112 insertions(+), 31 deletions(-)

diff --git a/dmidecode.c b/dmidecode.c
index fee3af1..6865cd7 100644
--- a/dmidecode.c
+++ b/dmidecode.c
@@ -4277,7 +4277,10 @@ static u16 get_smbios_version(unsigned char *smbios)
 {
	u16 ver;

-	ver = (smbios[0x06] << 8) + smbios[0x07];
+	if (!memcmp(smbios, "_SM3_", 5))
+		ver = (smbios[0x07] << 8) + smbios[0x08];
+	else
+		ver = (smbios[0x06] << 8) + smbios[0x07];

	/* Some BIOS report weird SMBIOS version, fix that up */
	switch (ver) {
@@ -4348,7 +4351,33 @@ static void dmi_table_dump(u8 *buf, u16 len)
	write_dump(32, len, buf, opt.dumpfile, 0);
 }

-static void dmi_table(u32 base, u8 *buf, u16 len, u16 num, u16 ver)
+static u16 dmi_table_count(u8 *buf, u16 len)
+{
+	u8 *data;
+	u16 i = 0;
+
+	data = buf;
+	while (data+4 <= buf + len) /* 4 is the length of an SMBIOS structure header */
+	{
+		struct dmi_header h;
+
+		++i;
+
+		to_dmi_header(&h, data);
+
+		if (h.length < 4)
+			break;
+
+		/* look for the next handle */
+		data += h.length;
+		while (data - buf + 1 < len && (data[0] != 0 || data[1] != 0))
+			data++;
+		data += 2;
+	}
+	return i;
+}
+
+static void dmi_table(u64 base, u8 *buf, u16 len, u16 num, u16 ver)
 {
	u8 *data;
	int i = 0;
@@ -4372,8 +4401,13 @@ static void dmi_table(u32 base, u8 *buf, u16 len, u16 num, u16 ver)
		{
			printf("%u structures occupying %u bytes.\n",
				num, len);
-			if (!(opt.flags & FLAG_FROM_DUMP))
-				printf("Table at 0x%08X.\n", base);
+			if (!(opt.flags & FLAG_FROM_DUMP)) {
+				if (base.h)
+					printf("Table at 0x%08X%08X.\n",
+					       base.h, base.l);
+				else
+					printf("Table at 0x%08X.\n", base.l);
+			}
		}
		printf("\n");
	}
@@ -4460,15 +4494,19 @@ static void dmi_table(u32 base, u8 *buf, u16 len, u16 num, u16 ver)
 /*
  * Build a crafted entry point with table address hard-coded to 32,
  * as this is where we will put it in the output file. We adjust the
- * DMI checksum appropriately. The SMBIOS checksum needs no adjustment.
+ * checksum appropriately.
  */
-static void overwrite_dmi_address(u8 *buf)
+static void overwrite_address(u8 *cksum, u8 *addr, int addr_len)
 {
-	buf[0x05] += buf[0x08] + buf[0x09] + buf[0x0A] + buf[0x0B] - 32;
-	buf[0x08] = 32;
-	buf[0x09] = 0;
-	buf[0x0A] = 0;
-	buf[0x0B] = 0;
+	int i;
+
+	*cksum += addr[0] - 32;
+	addr[0] = 32;
+
+	for (i = 1; i < addr_len; ++i) {
+		*cksum += addr[i];
+		addr[i] = 0;
+	}
 }

 /**
@@ -4478,36 +4516,51 @@ static void overwrite_dmi_address(u8 *buf)
 static void smbios_in_dumpfile(unsigned char *smbios)
 {
	u8 crafted[32];
+	u8 len;

	memcpy(crafted, smbios, 32);
-	overwrite_dmi_address(crafted + 0x10);
+	if (!memcmp(smbios, "_SM3_", 5)) {
+		overwrite_address(crafted + 0x05, crafted + 0x10, 8);
+		len = crafted[0x06];
+	} else {
+		overwrite_address(crafted + 0x15, crafted + 0x18, 4);
+		len = crafted[0x05];
+	}

	if (!(opt.flags & FLAG_QUIET))
		printf("# Writing %d bytes to %s.\n", crafted[0x05],
		       opt.dumpfile);

-	write_dump(0, crafted[0x05], crafted, opt.dumpfile, 1);
+	write_dump(0, len, crafted, opt.dumpfile, 1);
 }

 static int smbios_decode(u8 *buf, const char *devmem)
 {
	u16 ver;
-	u16 len;
-	u32 base;
+	u16 len, num;
+	u64 base;
	u8 *dmibuf;

-	if (!checksum(buf, buf[0x05])
-	 || memcmp(buf + 0x10, "_DMI_", 5) != 0
-	 || !checksum(buf + 0x10, 0x0F))
-		return 0;
+	if (!memcmp(buf, "_SM3_", 5)) {
+		if (!checksum(buf, buf[0x06]))
+			return 0;
+		base = QWORD(buf + 0x10);
+		len = WORD(buf + 0x0C);
+	} else {
+		if (!checksum(buf, buf[0x05])
+		    || memcmp(buf + 0x10, "_DMI_", 5) != 0
+		    || !checksum(buf + 0x10, 0x0F))
+			return 0;
+		base.h = 0;
+		base.l = DWORD(buf + 0x18);
+		len = WORD(buf + 0x16);
+	}

	ver = get_smbios_version(buf);
-
-	base = DWORD(buf + 0x18);
-	len = WORD(buf + 0x16);
-	dmibuf = mem_chunk(base, len, devmem);
+	dmibuf = mem_chunk(base.l, len, devmem);
	if (!dmibuf) {
		fprintf(stderr, "Table is unreachable, sorry."
+
 #ifndef USE_MMAP
			" Try compiling dmidecode with -DUSE_MMAP."
 #endif
@@ -4515,7 +4568,13 @@ static int smbios_decode(u8 *buf, const char *devmem)
		return 0;
	}

-	dmi_table(base, dmibuf, len, WORD(buf + 0x1C), ver);
+	/* version 3 64-bit header doesn't have number of tables */
+	if (!memcmp(buf, "_SM3_", 5))
+		num = dmi_table_count(dmibuf, len);
+	else
+		num = WORD(buf + 0x1C);
+
+	dmi_table(base, dmibuf, len, num, ver);

	free(dmibuf);

@@ -4529,6 +4588,7 @@ static void dmifs_smbios_decode(void)
 {
	u16 ver;
	u8 *smbios;
+	u64 base;
	struct dmi_table *dt;

	dt = dmi_get_table();
@@ -4538,8 +4598,28 @@ static void dmifs_smbios_decode(void)
	smbios = dt->smbios;

	ver = get_smbios_version(dt->smbios);
-	dmi_table(DWORD(smbios + 0x18), dmi_get_raw_data(dt->dmi_list),
-		  WORD(smbios + 0x16), WORD(smbios + 0x1C), ver);
+
+	if (!memcmp(smbios, "_SM3_", 5)) {
+		base = QWORD(smbios + 0x10);
+		dmi_table(base, dmi_get_raw_data(dt->dmi_list),
+			  dt->dmi_size, dt->dmi_count, ver);
+		if (opt.flags & FLAG_DUMP_BIN) {
+			/*
+			 * Table length in SMBIOS 3.0 header is a maximum size.
+			 * Make it exact to avoid warnings/errors when decoding
+			 * from file we are dumping.
+			 */
+			dt->smbios[0x05] += dt->smbios[0x0c] + dt->smbios[0x0d];
+			dt->smbios[0x0c] = dt->dmi_size;
+			dt->smbios[0x0d] = dt->dmi_size >> 8;
+			dt->smbios[0x05] -= dt->smbios[0x0c] + dt->smbios[0x0d];
+		}
+	} else {
+		base.h = 0;
+		base.l = DWORD(smbios + 0x18);
+		dmi_table(base, dmi_get_raw_data(dt->dmi_list),
+			  WORD(smbios + 0x16), WORD(smbios + 0x1C), ver);
+	}

	if (opt.flags & FLAG_DUMP_BIN)
		smbios_in_dumpfile(dt->smbios);
@@ -4550,7 +4630,7 @@ static void dmifs_smbios_decode(void)
 static int legacy_decode(u8 *buf, const char *devmem)
 {
	u16 len;
-	u32 base;
+	u64 base;
	u8 *dmibuf;

	if (!checksum(buf, 0x0F))
@@ -4561,8 +4641,9 @@ static int legacy_decode(u8 *buf, const char *devmem)
			buf[0x0E] >> 4, buf[0x0E] & 0x0F);

	len = WORD(buf + 0x06);
-	base = DWORD(buf + 0x08);
-	dmibuf = mem_chunk(base, len, devmem);
+	base.h = 0;
+	base.l = DWORD(buf + 0x08);
+	dmibuf = mem_chunk(base.l, len, devmem);
	if (!dmibuf) {
		fprintf(stderr, "Table is unreachable, sorry."
 #ifndef USE_MMAP
@@ -4582,7 +4663,7 @@ static int legacy_decode(u8 *buf, const char *devmem)
		u8 crafted[16];

		memcpy(crafted, buf, 16);
-		overwrite_dmi_address(crafted);
+		overwrite_address(crafted + 0x05, crafted + 0x08, 4);

		printf("# Writing %d bytes to %s.\n", 0x0F, opt.dumpfile);
		write_dump(0, 0x0F, crafted, opt.dumpfile, 1);
@@ -4689,7 +4770,7 @@ int main(int argc, char * const argv[])
			goto exit_free;
		}

-		if (memcmp(buf, "_SM_", 4) == 0)
+		if (memcmp(buf, "_SM_", 4) == 0 || memcmp(buf, "_SM3_", 5) == 0)
		{
			if (smbios_decode(buf, opt.dumpfile))
				found++;
--
1.8.3.1