!52 [sync] PR-49: backport: Support Loongarch process

From: @openeuler-sync-bot 
Reviewed-by: @liqingqing_1229 
Signed-off-by: @liqingqing_1229

backport-Add-support-for-Loongarch.patch

@@ -0,0 +1,89 @@
+From 1e64387af427ea8b610ea444715822ec7e2c874d Mon Sep 17 00:00:00 2001
+From: Jean Delvare <jdelvare@suse.de>
+Date: Fri, 26 May 2023 17:41:59 +0200
+Subject: [PATCH] dmidecode: Add support for Loongarch
+
+SMBIOS specification version 3.6.0 adds support for the Loongarch
+processor architecture.
+
+Signed-off-by: Jean Delvare <jdelvare@suse.de>
+---
+ dmidecode.c | 28 ++++++++++++++++++++++++++++
+ dmidecode.h |  1 +
+ 2 files changed, 29 insertions(+)
+
+diff --git a/dmidecode.c b/dmidecode.c
+index f5b91d4..8e4ae7b 100644
+--- a/dmidecode.c
++++ b/dmidecode.c
+@@ -58,6 +58,8 @@
+  *    https://trustedcomputinggroup.org/pc-client-platform-tpm-profile-ptp-specification/
+  *  - "RedFish Host Interface Specification" (DMTF DSP0270)
+  *    https://www.dmtf.org/sites/default/files/DSP0270_1.0.1.pdf
++ *  - LoongArch Reference Manual, volume 1
++ *    https://loongson.github.io/LoongArch-Documentation/LoongArch-Vol1-EN.html#_cpucfg
+  */
+ 
+ #include <fcntl.h>
+@@ -988,6 +990,24 @@ static const char *dmi_processor_family(const struct dmi_header *h, u16 ver)
+ 		{ 0x200, "RV32" },
+ 		{ 0x201, "RV64" },
+ 		{ 0x202, "RV128" },
++
++		{ 0x258, "LoongArch" },
++		{ 0x259, "Loongson 1" },
++		{ 0x25A, "Loongson 2" },
++		{ 0x25B, "Loongson 3" },
++		{ 0x25C, "Loongson 2K" },
++		{ 0x25D, "Loongson 3A" },
++		{ 0x25E, "Loongson 3B" },
++		{ 0x25F, "Loongson 3C" },
++		{ 0x260, "Loongson 3D" },
++		{ 0x261, "Loongson 3E" },
++		{ 0x262, "Dual-Core Loongson 2K 2xxx" },
++		{ 0x26C, "Quad-Core Loongson 3A 5xxx" },
++		{ 0x26D, "Multi-Core Loongson 3A 5xxx" },
++		{ 0x26E, "Quad-Core Loongson 3B 5xxx" },
++		{ 0x26F, "Multi-Core Loongson 3B 5xxx" },
++		{ 0x270, "Multi-Core Loongson 3C 5xxx" },
++		{ 0x271, "Multi-Core Loongson 3D 5xxx" },
+ 	};
+ 	/*
+ 	 * Note to developers: when adding entries to this list, check if
+@@ -1106,6 +1126,9 @@ static enum cpuid_type dmi_get_cpuid_type(const struct dmi_header *h)
+ 	      || (type >= 0xB6 && type <= 0xB7) /* AMD */
+ 	      || (type >= 0xE4 && type <= 0xEF)) /* AMD */
+ 		return cpuid_x86_amd;
++	else if ((type >= 0x258 && type <= 0x262) /* Loongarch */
++	      || (type >= 0x26C && type <= 0x271)) /* Loongarch */
++		return cpuid_loongarch;
+ 	else if (type == 0x01 || type == 0x02)
+ 	{
+ 		const char *version = dmi_string(h, data[0x10]);
+@@ -1221,6 +1244,11 @@ void dmi_print_cpuid(void (*print_cb)(const char *name, const char *format, ...)
+ 				 ((eax >> 4) & 0xF) | (((eax >> 8) & 0xF) == 0xF ? (eax >> 12) & 0xF0 : 0),
+ 				 eax & 0xF);
+ 			break;
++
++		case cpuid_loongarch: /* LoongArch Reference Manual, volume 1 */
++			eax = DWORD(p);
++			print_cb(label, "Processor Identity 0x%08x\n", eax);
++			break;
+ 		default:
+ 			return;
+ 	}
+diff --git a/dmidecode.h b/dmidecode.h
+index 318cdc6..04c9c93 100644
+--- a/dmidecode.h
++++ b/dmidecode.h
+@@ -40,6 +40,7 @@ enum cpuid_type
+ 	cpuid_arm_soc_id,
+ 	cpuid_x86_intel,
+ 	cpuid_x86_amd,
++	cpuid_loongarch,
+ };
+ 
+ extern enum cpuid_type cpuid_type;
+-- 
+2.27.0
+

dmidecode-Do-not-let-dump-bin-overwrite-an-existing-.patch

@@ -0,0 +1,75 @@
+From 6ca381c1247c81f74e1ca4e7706f70bdda72e6f2 Mon Sep 17 00:00:00 2001
+From: Jean Delvare <jdelvare@suse.de>
+Date: Mon, 20 Feb 2023 14:53:31 +0100
+Subject: [PATCH] dmidecode: Do not let --dump-bin overwrite an existing file
+
+Make sure that the file passed to option --dump-bin does not already
+exist. In practice, it is rather unlikely that an honest user would
+want to overwrite an existing dump file, while this possibility
+could be used by a rogue user to corrupt a system file.
+
+Signed-off-by: Jean Delvare <jdelvare@suse.de>
+Reviewed-by: Jerry Hoemann <jerry.hoemann@hpe.com>
+---
+ dmidecode.c     | 14 ++++++++++++--
+ man/dmidecode.8 |  3 ++-
+ 2 files changed, 14 insertions(+), 3 deletions(-)
+
+diff --git a/dmidecode.c b/dmidecode.c
+index 6e7be63..82efa2d 100644
+--- a/dmidecode.c
++++ b/dmidecode.c
+@@ -60,6 +60,7 @@
+  *    https://www.dmtf.org/sites/default/files/DSP0270_1.0.1.pdf
+  */
+ 
++#include <fcntl.h>
+ #include <stdio.h>
+ #include <string.h>
+ #include <strings.h>
+@@ -5412,13 +5413,22 @@ static void dmi_table_string(const struct dmi_header *h, const u8 *data, u16 ver
+ static int dmi_table_dump(const u8 *ep, u32 ep_len, const u8 *table,
+ 			  u32 table_len)
+ {
++	int fd;
+ 	FILE *f;
+ 
+-	f = fopen(opt.dumpfile, "wb");
++	fd = open(opt.dumpfile, O_WRONLY|O_CREAT|O_EXCL, 0666);
++	if (fd == -1)
++	{
++		fprintf(stderr, "%s: ", opt.dumpfile);
++		perror("open");
++		return -1;
++	}
++
++	f = fdopen(fd, "wb");
+ 	if (!f)
+ 	{
+ 		fprintf(stderr, "%s: ", opt.dumpfile);
+-		perror("fopen");
++		perror("fdopen");
+ 		return -1;
+ 	}
+ 
+diff --git a/man/dmidecode.8 b/man/dmidecode.8
+index 62aa304..83affc2 100644
+--- a/man/dmidecode.8
++++ b/man/dmidecode.8
+@@ -1,4 +1,4 @@
+-.TH DMIDECODE 8 "January 2019" "dmidecode"
++.TH DMIDECODE 8 "February 2023" "dmidecode"
+ .\"
+ .SH NAME
+ dmidecode \- \s-1DMI\s0 table decoder
+@@ -164,6 +164,7 @@ hexadecimal and \s-1ASCII\s0. This option is mainly useful for debugging.
+ Do not decode the entries, instead dump the DMI data to a file in binary
+ form. The generated file is suitable to pass to \fB--from-dump\fP
+ later.
++\fIFILE\fP must not exist.
+ .TP
+ .BR "  " "  " "--from-dump \fIFILE\fP"
+ Read the DMI data from a binary file previously generated using
+-- 
+2.28.1
+

dmidecode-Split-table-fetching-from-decoding.patch

@@ -0,0 +1,231 @@
+From 39b2dd7b6ab719b920e96ed832cfb4bdd664e808 Mon Sep 17 00:00:00 2001
+From: Jean Delvare <jdelvare@suse.de>
+Date: Mon, 20 Feb 2023 14:53:21 +0100
+Subject: [PATCH] dmidecode: Split table fetching from decoding
+
+Clean up function dmi_table so that it does only one thing:
+* dmi_table() is renamed to dmi_table_get(). It now retrieves the
+  DMI table, but does not process it any longer.
+* Decoding or dumping the table is now done in smbios3_decode(),
+  smbios_decode() and legacy_decode().
+No functional change.
+
+A side effect of this change is that writing the header and body of
+dump files is now done in a single location. This is required to
+further consolidate the writing of dump files.
+
+Signed-off-by: Jean Delvare <jdelvare@suse.de>
+Reviewed-by: Jerry Hoemann <jerry.hoemann@hpe.com>
+---
+ dmidecode.c | 86 ++++++++++++++++++++++++++++++++++++++---------------
+ 1 file changed, 62 insertions(+), 24 deletions(-)
+
+diff --git a/dmidecode.c b/dmidecode.c
+index e2fc882..0ab04da 100644
+--- a/dmidecode.c
++++ b/dmidecode.c
+@@ -5567,8 +5567,9 @@ static void dmi_table_decode(u8 *buf, u32 len, u16 num, u16 ver, u32 flags)
+ 	}
+ }
+ 
+-static void dmi_table(off_t base, u32 len, u16 num, u32 ver, const char *devmem,
+-		      u32 flags)
++/* Allocates a buffer for the table, must be freed by the caller */
++static u8 *dmi_table_get(off_t base, u32 *len, u16 num, u32 ver,
++			 const char *devmem, u32 flags)
+ {
+ 	u8 *buf;
+ 
+@@ -5587,7 +5588,7 @@ static void dmi_table(off_t base, u32 len, u16 num, u32 ver, const char *devmem,
+ 		{
+ 			if (num)
+ 				pr_info("%u structures occupying %u bytes.",
+-					num, len);
++					num, *len);
+ 			if (!(opt.flags & FLAG_FROM_DUMP))
+ 				pr_info("Table at 0x%08llX.",
+ 					(unsigned long long)base);
+@@ -5605,19 +5606,19 @@ static void dmi_table(off_t base, u32 len, u16 num, u32 ver, const char *devmem,
+ 		 * would be the result of the kernel truncating the table on
+ 		 * parse error.
+ 		 */
+-		size_t size = len;
++		size_t size = *len;
+ 		buf = read_file(flags & FLAG_NO_FILE_OFFSET ? 0 : base,
+ 			&size, devmem);
+-		if (!(opt.flags & FLAG_QUIET) && num && size != (size_t)len)
++		if (!(opt.flags & FLAG_QUIET) && num && size != (size_t)*len)
+ 		{
+ 			fprintf(stderr, "Wrong DMI structures length: %u bytes "
+ 				"announced, only %lu bytes available.\n",
+-				len, (unsigned long)size);
++				*len, (unsigned long)size);
+ 		}
+-		len = size;
++		*len = size;
+ 	}
+ 	else
+-		buf = mem_chunk(base, len, devmem);
++		buf = mem_chunk(base, *len, devmem);
+ 
+ 	if (buf == NULL)
+ 	{
+@@ -5627,15 +5628,9 @@ static void dmi_table(off_t base, u32 len, u16 num, u32 ver, const char *devmem,
+ 			fprintf(stderr,
+ 				"Try compiling dmidecode with -DUSE_MMAP.\n");
+ #endif
+-		return;
+ 	}
+ 
+-	if (opt.flags & FLAG_DUMP_BIN)
+-		dmi_table_dump(buf, len);
+-	else
+-		dmi_table_decode(buf, len, num, ver >> 8, flags);
+-
+-	free(buf);
++	return buf;
+ }
+ 
+ 
+@@ -5670,8 +5665,9 @@ static void overwrite_smbios3_address(u8 *buf)
+ 
+ static int smbios3_decode(u8 *buf, const char *devmem, u32 flags)
+ {
+-	u32 ver;
++	u32 ver, len;
+ 	u64 offset;
++	u8 *table;
+ 
+ 	/* Don't let checksum run beyond the buffer */
+ 	if (buf[0x06] > 0x20)
+@@ -5698,8 +5694,12 @@ static int smbios3_decode(u8 *buf, const char *devmem, u32 flags)
+ 		return 0;
+ 	}
+ 
+-	dmi_table(((off_t)offset.h << 32) | offset.l,
+-		  DWORD(buf + 0x0C), 0, ver, devmem, flags | FLAG_STOP_AT_EOT);
++	/* Maximum length, may get trimmed */
++	len = DWORD(buf + 0x0C);
++	table = dmi_table_get(((off_t)offset.h << 32) | offset.l, &len, 0, ver,
++			      devmem, flags | FLAG_STOP_AT_EOT);
++	if (table == NULL)
++		return 1;
+ 
+ 	if (opt.flags & FLAG_DUMP_BIN)
+ 	{
+@@ -5708,11 +5708,19 @@ static int smbios3_decode(u8 *buf, const char *devmem, u32 flags)
+ 		memcpy(crafted, buf, 32);
+ 		overwrite_smbios3_address(crafted);
+ 
++		dmi_table_dump(table, len);
+ 		if (!(opt.flags & FLAG_QUIET))
+ 			pr_comment("Writing %d bytes to %s.", crafted[0x06],
+ 				   opt.dumpfile);
+ 		write_dump(0, crafted[0x06], crafted, opt.dumpfile, 1);
+ 	}
++	else
++	{
++		dmi_table_decode(table, len, 0, ver >> 8,
++				 flags | FLAG_STOP_AT_EOT);
++	}
++
++	free(table);
+ 
+ 	return 1;
+ }
+@@ -5742,7 +5750,9 @@ static void dmi_fixup_version(u16 *ver)
+ 
+ static int smbios_decode(u8 *buf, const char *devmem, u32 flags)
+ {
+-	u16 ver;
++	u16 ver, num;
++	u32 len;
++	u8 *table;
+ 
+ 	/* Don't let checksum run beyond the buffer */
+ 	if (buf[0x05] > 0x20)
+@@ -5770,8 +5780,13 @@ static int smbios_decode(u8 *buf, const char *devmem, u32 flags)
+ 		pr_info("SMBIOS %u.%u present.",
+ 			ver >> 8, ver & 0xFF);
+ 
+-	dmi_table(DWORD(buf + 0x18), WORD(buf + 0x16), WORD(buf + 0x1C),
+-		ver << 8, devmem, flags);
++	/* Maximum length, may get trimmed */
++	len = WORD(buf + 0x16);
++	num = WORD(buf + 0x1C);
++	table = dmi_table_get(DWORD(buf + 0x18), &len, num, ver << 8,
++			      devmem, flags);
++	if (table == NULL)
++		return 1;
+ 
+ 	if (opt.flags & FLAG_DUMP_BIN)
+ 	{
+@@ -5780,27 +5795,43 @@ static int smbios_decode(u8 *buf, const char *devmem, u32 flags)
+ 		memcpy(crafted, buf, 32);
+ 		overwrite_dmi_address(crafted + 0x10);
+ 
++		dmi_table_dump(table, len);
+ 		if (!(opt.flags & FLAG_QUIET))
+ 			pr_comment("Writing %d bytes to %s.", crafted[0x05],
+ 				   opt.dumpfile);
+ 		write_dump(0, crafted[0x05], crafted, opt.dumpfile, 1);
+ 	}
++	else
++	{
++		dmi_table_decode(table, len, num, ver, flags);
++	}
++
++	free(table);
+ 
+ 	return 1;
+ }
+ 
+ static int legacy_decode(u8 *buf, const char *devmem, u32 flags)
+ {
++	u16 ver, num;
++	u32 len;
++	u8 *table;
++
+ 	if (!checksum(buf, 0x0F))
+ 		return 0;
+ 
++	ver = ((buf[0x0E] & 0xF0) << 4) + (buf[0x0E] & 0x0F);
+ 	if (!(opt.flags & FLAG_QUIET))
+ 		pr_info("Legacy DMI %u.%u present.",
+ 			buf[0x0E] >> 4, buf[0x0E] & 0x0F);
+ 
+-	dmi_table(DWORD(buf + 0x08), WORD(buf + 0x06), WORD(buf + 0x0C),
+-		((buf[0x0E] & 0xF0) << 12) + ((buf[0x0E] & 0x0F) << 8),
+-		devmem, flags);
++	/* Maximum length, may get trimmed */
++	len = WORD(buf + 0x06);
++	num = WORD(buf + 0x0C);
++	table = dmi_table_get(DWORD(buf + 0x08), &len, num, ver << 8,
++			      devmem, flags);
++	if (table == NULL)
++		return 1;
+ 
+ 	if (opt.flags & FLAG_DUMP_BIN)
+ 	{
+@@ -5809,11 +5840,18 @@ static int legacy_decode(u8 *buf, const char *devmem, u32 flags)
+ 		memcpy(crafted, buf, 16);
+ 		overwrite_dmi_address(crafted);
+ 
++		dmi_table_dump(table, len);
+ 		if (!(opt.flags & FLAG_QUIET))
+ 			pr_comment("Writing %d bytes to %s.", 0x0F,
+ 				   opt.dumpfile);
+ 		write_dump(0, 0x0F, crafted, opt.dumpfile, 1);
+ 	}
++	else
++	{
++		dmi_table_decode(table, len, num, ver, flags);
++	}
++
++	free(table);
+ 
+ 	return 1;
+ }
+-- 
+2.28.0.windows.1
+

dmidecode-Write-the-whole-dump-file-at-once.patch

@@ -0,0 +1,191 @@
+From d8cfbc808f387e87091c25e7d5b8c2bb348bb206 Mon Sep 17 00:00:00 2001
+From: Jean Delvare <jdelvare@suse.de>
+Date: Mon, 20 Feb 2023 14:53:25 +0100
+Subject: [PATCH] dmidecode: Write the whole dump file at once
+
+When option --dump-bin is used, write the whole dump file at once,
+instead of opening and closing the file separately for the table
+and then for the entry point.
+
+As the file writing function is no longer generic, it gets moved
+from util.c to dmidecode.c.
+
+One minor functional change resulting from the new implementation is
+that the entry point is written first now, so the messages printed
+are swapped.
+
+Signed-off-by: Jean Delvare <jdelvare@suse.de>
+Reviewed-by: Jerry Hoemann <jerry.hoemann@hpe.com>
+---
+ dmidecode.c | 69 +++++++++++++++++++++++++++++++++++++++--------------
+ util.c      | 40 -------------------------------
+ util.h      |  1 -
+ 3 files changed, 51 insertions(+), 59 deletions(-)
+
+diff --git a/dmidecode.c b/dmidecode.c
+index 0ab04da..6e7be63 100644
+--- a/dmidecode.c
++++ b/dmidecode.c
+@@ -5409,11 +5409,56 @@ static void dmi_table_string(const struct dmi_header *h, const u8 *data, u16 ver
+ 	}
+ }
+ 
+-static void dmi_table_dump(const u8 *buf, u32 len)
++static int dmi_table_dump(const u8 *ep, u32 ep_len, const u8 *table,
++			  u32 table_len)
+ {
++	FILE *f;
++
++	f = fopen(opt.dumpfile, "wb");
++	if (!f)
++	{
++		fprintf(stderr, "%s: ", opt.dumpfile);
++		perror("fopen");
++		return -1;
++	}
++
++	if (!(opt.flags & FLAG_QUIET))
++		pr_comment("Writing %d bytes to %s.", ep_len, opt.dumpfile);
++	if (fwrite(ep, ep_len, 1, f) != 1)
++	{
++		fprintf(stderr, "%s: ", opt.dumpfile);
++		perror("fwrite");
++		goto err_close;
++	}
++
++	if (fseek(f, 32, SEEK_SET) != 0)
++	{
++		fprintf(stderr, "%s: ", opt.dumpfile);
++		perror("fseek");
++		goto err_close;
++	}
++
+ 	if (!(opt.flags & FLAG_QUIET))
+-		pr_comment("Writing %d bytes to %s.", len, opt.dumpfile);
+-	write_dump(32, len, buf, opt.dumpfile, 0);
++		pr_comment("Writing %d bytes to %s.", table_len, opt.dumpfile);
++	if (fwrite(table, table_len, 1, f) != 1)
++	{
++		fprintf(stderr, "%s: ", opt.dumpfile);
++		perror("fwrite");
++		goto err_close;
++	}
++
++	if (fclose(f))
++	{
++		fprintf(stderr, "%s: ", opt.dumpfile);
++		perror("fclose");
++		return -1;
++	}
++
++	return 0;
++
++err_close:
++	fclose(f);
++	return -1;
+ }
+ 
+ static void dmi_table_decode(u8 *buf, u32 len, u16 num, u16 ver, u32 flags)
+@@ -5708,11 +5753,7 @@ static int smbios3_decode(u8 *buf, const char *devmem, u32 flags)
+ 		memcpy(crafted, buf, 32);
+ 		overwrite_smbios3_address(crafted);
+ 
+-		dmi_table_dump(table, len);
+-		if (!(opt.flags & FLAG_QUIET))
+-			pr_comment("Writing %d bytes to %s.", crafted[0x06],
+-				   opt.dumpfile);
+-		write_dump(0, crafted[0x06], crafted, opt.dumpfile, 1);
++		dmi_table_dump(crafted, crafted[0x06], table, len);
+ 	}
+ 	else
+ 	{
+@@ -5795,11 +5836,7 @@ static int smbios_decode(u8 *buf, const char *devmem, u32 flags)
+ 		memcpy(crafted, buf, 32);
+ 		overwrite_dmi_address(crafted + 0x10);
+ 
+-		dmi_table_dump(table, len);
+-		if (!(opt.flags & FLAG_QUIET))
+-			pr_comment("Writing %d bytes to %s.", crafted[0x05],
+-				   opt.dumpfile);
+-		write_dump(0, crafted[0x05], crafted, opt.dumpfile, 1);
++		dmi_table_dump(crafted, crafted[0x05], table, len);
+ 	}
+ 	else
+ 	{
+@@ -5840,11 +5877,7 @@ static int legacy_decode(u8 *buf, const char *devmem, u32 flags)
+ 		memcpy(crafted, buf, 16);
+ 		overwrite_dmi_address(crafted);
+ 
+-		dmi_table_dump(table, len);
+-		if (!(opt.flags & FLAG_QUIET))
+-			pr_comment("Writing %d bytes to %s.", 0x0F,
+-				   opt.dumpfile);
+-		write_dump(0, 0x0F, crafted, opt.dumpfile, 1);
++		dmi_table_dump(crafted, 0x0F, table, len);
+ 	}
+ 	else
+ 	{
+diff --git a/util.c b/util.c
+index 04aaadd..1547096 100644
+--- a/util.c
++++ b/util.c
+@@ -259,46 +259,6 @@ void *mem_chunk(off_t base, size_t len, const char *devmem)
+ 	return p;
+ }
+ 
+-int write_dump(size_t base, size_t len, const void *data, const char *dumpfile, int add)
+-{
+-	FILE *f;
+-
+-	f = fopen(dumpfile, add ? "r+b" : "wb");
+-	if (!f)
+-	{
+-		fprintf(stderr, "%s: ", dumpfile);
+-		perror("fopen");
+-		return -1;
+-	}
+-
+-	if (fseek(f, base, SEEK_SET) != 0)
+-	{
+-		fprintf(stderr, "%s: ", dumpfile);
+-		perror("fseek");
+-		goto err_close;
+-	}
+-
+-	if (fwrite(data, len, 1, f) != 1)
+-	{
+-		fprintf(stderr, "%s: ", dumpfile);
+-		perror("fwrite");
+-		goto err_close;
+-	}
+-
+-	if (fclose(f))
+-	{
+-		fprintf(stderr, "%s: ", dumpfile);
+-		perror("fclose");
+-		return -1;
+-	}
+-
+-	return 0;
+-
+-err_close:
+-	fclose(f);
+-	return -1;
+-}
+-
+ /* Returns end - start + 1, assuming start < end */
+ u64 u64_range(u64 start, u64 end)
+ {
+diff --git a/util.h b/util.h
+index 3094cf8..ef24eb9 100644
+--- a/util.h
++++ b/util.h
+@@ -27,5 +27,4 @@
+ int checksum(const u8 *buf, size_t len);
+ void *read_file(off_t base, size_t *len, const char *filename);
+ void *mem_chunk(off_t base, size_t len, const char *devmem);
+-int write_dump(size_t base, size_t len, const void *data, const char *dumpfile, int add);
+ u64 u64_range(u64 start, u64 end);
+-- 
+2.28.1
+

dmidecode.spec

@@ -1,6 +1,6 @@
 Name:	 dmidecode
 Version: 3.4
-Release: 1
+Release: 6
 Epoch:   1
 Summary: DMI data report tool
 
@@ -9,10 +9,15 @@ URL:	 https://www.nongnu.org/dmidecode/
 Source0: http://download.savannah.gnu.org/releases/dmidecode/%{name}-%{version}.tar.xz
 
 Patch6000: bugfix-compat_uuid.patch
+Patch6001: dmidecode-Split-table-fetching-from-decoding.patch
+Patch6002: dmidecode-Write-the-whole-dump-file-at-once.patch
+Patch6003: dmidecode-Do-not-let-dump-bin-overwrite-an-existing-.patch
+Patch6004: dmioem-Fix-segmentation-fault-in-dmi_hp_240_attr.patch
+Patch6005: backport-Add-support-for-Loongarch.patch
 
 BuildRequires: make gcc xz
 
-ExclusiveArch:  %{ix86} x86_64 ia64 aarch64 amd64 sw_64
+ExclusiveArch:  %{ix86} x86_64 ia64 aarch64 amd64 sw_64 loongarch64 ppc64le
 
 %description
 Dmidecode reports information about your system's hardware as described
@@ -50,7 +55,25 @@ make %{?_smp_mflags} CFLAGS="%{__global_cflags}" LDFLAGS="%{__global_ldflags}"
 %{_mandir}/man8/*.8.gz
 
 %changelog
-* Wed Nov 9 2022 fanrui<fary.fanrui@huawe.com> - 1:3.4-1
+* Thu Sep 12 2024 liyunqing <liyunqing@kylinos.cn> - 1:3.4-6
+- Type:backport
+- ID:NA
+- SUG:NA
+- DESC: Add support for Loongarch processor architecture
+
+* Tue Jan 20 2024 Yuanfeng Chen <yuanfeng.chen@shingroup.cn> - 1:3.4-5
+- init support for arch ppc64le
+
+* Thu Dec 14 2023 lvgenggeng <lvgenggeng@uniontech.com> - 1:3.4-4
+- backport: Fix segmentation fault in dmi_hp_240_attr()
+
+* Tue Apr 18 2023 Cunshu Ni <nicunshu@huawei.com> - 1:3.4-3
+- fix CVE-2023-30630
+
+* Mon Nov 14 2022 Wenlong Zhang <zhangwenlong@loongson.cn> - 1:3.4-2
+- add loongarch support for dmidecode
+
+* Wed Nov 9 2022 fanrui<fary.fanrui@huawei.com> - 1:3.4-1
 - Update to 3.4
 
 * Thu Nov 3 2022 wuzx<wuzx1226@qq.com> - 1:3.3-4

dmioem-Fix-segmentation-fault-in-dmi_hp_240_attr.patch

@@ -0,0 +1,46 @@
+From c3357b532941a8df387618e692e522cc7a43b3e8 Mon Sep 17 00:00:00 2001
+From: Jean Delvare <jdelvare@suse.de>
+Date: Fri, 9 Sep 2022 11:46:53 +0200
+Subject: [PATCH 1/1] dmioem: Fix segmentation fault in dmi_hp_240_attr()
+
+pr_attr() does not accept a NULL format string. glibc can deal with
+it, but FreeBSD's libc chokes on it.
+
+Display the attributes as a list instead. Pack the attribute name and
+status into a single formatted string that can be passed to
+pr_list_item(). That's arguably a hack, but it's cheap, non-intrusive,
+and works nicely in the end.
+
+Bug reported by Scott Benesh (Microchip).
+
+Signed-off-by: Jean Delvare <jdelvare@suse.de>
+Fixes: a4b31b2bc537 ("dmioem: Present HPE type 240 attributes in a nicer way")
+Cc: Jerry Hoemann <jerry.hoemann@hpe.com>
+---
+ dmioem.c | 5 +++--
+ 1 file changed, 3 insertions(+), 2 deletions(-)
+
+diff --git a/dmioem.c b/dmioem.c
+index 0c73771..2c24bfb 100644
+--- a/dmioem.c
++++ b/dmioem.c
+@@ -198,13 +198,14 @@ static void dmi_hp_240_attr(u64 defined, u64 set)
+ 	};
+ 	unsigned int i;
+ 
+-	pr_attr("Attributes Defined/Set", NULL);
++	pr_list_start("Attributes Defined/Set", NULL);
+ 	for (i = 0; i < ARRAY_SIZE(attributes); i++)
+ 	{
+ 		if (!(defined.l & (1UL << i)))
+ 			continue;
+-		pr_subattr(attributes[i], "%s", set.l & (1UL << i) ? "Yes" : "No");
++		pr_list_item("%s: %s", attributes[i], set.l & (1UL << i) ? "Yes" : "No");
+ 	}
++	pr_list_end();
+ }
+ 
+ static void dmi_hp_203_assoc_hndl(const char *fname, u16 num)
+-- 
+2.20.1
+