1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright (C) 2020, Bachmann electronic GmbH
4 */
5
6#define LOG_CATEGORY	LOGC_BOOT
7
8#include <errno.h>
9#include <smbios.h>
10#include <string.h>
11#include <tables_csum.h>
12#include <linux/kernel.h>
13
14const struct smbios_entry *smbios_entry(u64 address, u32 size)
15{
16	const struct smbios_entry *entry = (struct smbios_entry *)(uintptr_t)address;
17
18	if (!address || !size)
19		return NULL;
20
21	if (memcmp(entry->anchor, "_SM_", 4))
22		return NULL;
23
24	if (table_compute_checksum(entry, entry->length))
25		return NULL;
26
27	return entry;
28}
29
30static u8 *find_next_header(u8 *pos)
31{
32	/* search for _double_ NULL bytes */
33	while (!((*pos == 0) && (*(pos + 1) == 0)))
34		pos++;
35
36	/* step behind the double NULL bytes */
37	pos += 2;
38
39	return pos;
40}
41
42static struct smbios_header *get_next_header(const struct smbios_header *curr)
43{
44	u8 *pos = ((u8 *)curr) + curr->length;
45
46	return (struct smbios_header *)find_next_header(pos);
47}
48
49const struct smbios_header *smbios_header(const struct smbios_entry *entry, int type)
50{
51	const unsigned int num_header = entry->struct_count;
52	const struct smbios_header *header = (struct smbios_header *)((uintptr_t)entry->struct_table_address);
53
54	for (unsigned int i = 0; i < num_header; i++) {
55		if (header->type == type)
56			return header;
57
58		header = get_next_header(header);
59	}
60
61	return NULL;
62}
63
64static char *string_from_smbios_table(const struct smbios_header *header,
65				      int idx)
66{
67	unsigned int i = 1;
68	u8 *pos;
69
70	if (!header)
71		return NULL;
72
73	pos = ((u8 *)header) + header->length;
74
75	while (i < idx) {
76		if (*pos == 0x0)
77			i++;
78
79		pos++;
80	}
81
82	return (char *)pos;
83}
84
85char *smbios_string(const struct smbios_header *header, int index)
86{
87	if (!header)
88		return NULL;
89
90	return string_from_smbios_table(header, index);
91}
92
93int smbios_update_version_full(void *smbios_tab, const char *version)
94{
95	const struct smbios_header *hdr;
96	struct smbios_type0 *bios;
97	uint old_len, len;
98	char *ptr;
99
100	log_info("Updating SMBIOS table at %p\n", smbios_tab);
101	hdr = smbios_header(smbios_tab, SMBIOS_BIOS_INFORMATION);
102	if (!hdr)
103		return log_msg_ret("tab", -ENOENT);
104	bios = (struct smbios_type0 *)hdr;
105	ptr = smbios_string(hdr, bios->bios_ver);
106	if (!ptr)
107		return log_msg_ret("str", -ENOMEDIUM);
108
109	/*
110	 * This string is supposed to have at least enough bytes and is
111	 * padded with spaces. Update it, taking care not to move the
112	 * \0 terminator, so that other strings in the string table
113	 * are not disturbed. See smbios_add_string()
114	 */
115	old_len = strnlen(ptr, SMBIOS_STR_MAX);
116	len = strnlen(version, SMBIOS_STR_MAX);
117	if (len > old_len)
118		return log_ret(-ENOSPC);
119
120	log_debug("Replacing SMBIOS type 0 version string '%s'\n", ptr);
121	memcpy(ptr, version, len);
122#ifdef LOG_DEBUG
123	print_buffer((ulong)ptr, ptr, 1, old_len + 1, 0);
124#endif
125
126	return 0;
127}
128
129struct smbios_filter_param {
130	u32 offset;
131	u32 size;
132	bool is_string;
133};
134
135struct smbios_filter_table {
136	int type;
137	struct smbios_filter_param *params;
138	u32 count;
139};
140
141struct smbios_filter_param smbios_type1_filter_params[] = {
142	{offsetof(struct smbios_type1, serial_number),
143	 FIELD_SIZEOF(struct smbios_type1, serial_number), true},
144	{offsetof(struct smbios_type1, uuid),
145	 FIELD_SIZEOF(struct smbios_type1, uuid), false},
146	{offsetof(struct smbios_type1, wakeup_type),
147	 FIELD_SIZEOF(struct smbios_type1, wakeup_type), false},
148};
149
150struct smbios_filter_param smbios_type2_filter_params[] = {
151	{offsetof(struct smbios_type2, serial_number),
152	 FIELD_SIZEOF(struct smbios_type2, serial_number), true},
153	{offsetof(struct smbios_type2, chassis_location),
154	 FIELD_SIZEOF(struct smbios_type2, chassis_location), false},
155};
156
157struct smbios_filter_param smbios_type3_filter_params[] = {
158	{offsetof(struct smbios_type3, serial_number),
159	 FIELD_SIZEOF(struct smbios_type3, serial_number), true},
160	{offsetof(struct smbios_type3, asset_tag_number),
161	 FIELD_SIZEOF(struct smbios_type3, asset_tag_number), true},
162};
163
164struct smbios_filter_param smbios_type4_filter_params[] = {
165	{offsetof(struct smbios_type4, serial_number),
166	 FIELD_SIZEOF(struct smbios_type4, serial_number), true},
167	{offsetof(struct smbios_type4, asset_tag),
168	 FIELD_SIZEOF(struct smbios_type4, asset_tag), true},
169	{offsetof(struct smbios_type4, part_number),
170	 FIELD_SIZEOF(struct smbios_type4, part_number), true},
171	{offsetof(struct smbios_type4, core_count),
172	 FIELD_SIZEOF(struct smbios_type4, core_count), false},
173	{offsetof(struct smbios_type4, core_enabled),
174	 FIELD_SIZEOF(struct smbios_type4, core_enabled), false},
175	{offsetof(struct smbios_type4, thread_count),
176	 FIELD_SIZEOF(struct smbios_type4, thread_count), false},
177	{offsetof(struct smbios_type4, core_count2),
178	 FIELD_SIZEOF(struct smbios_type4, core_count2), false},
179	{offsetof(struct smbios_type4, core_enabled2),
180	 FIELD_SIZEOF(struct smbios_type4, core_enabled2), false},
181	{offsetof(struct smbios_type4, thread_count2),
182	 FIELD_SIZEOF(struct smbios_type4, thread_count2), false},
183	{offsetof(struct smbios_type4, voltage),
184	 FIELD_SIZEOF(struct smbios_type4, voltage), false},
185};
186
187struct smbios_filter_table smbios_filter_tables[] = {
188	{SMBIOS_SYSTEM_INFORMATION, smbios_type1_filter_params,
189	 ARRAY_SIZE(smbios_type1_filter_params)},
190	{SMBIOS_BOARD_INFORMATION, smbios_type2_filter_params,
191	 ARRAY_SIZE(smbios_type2_filter_params)},
192	{SMBIOS_SYSTEM_ENCLOSURE, smbios_type3_filter_params,
193	 ARRAY_SIZE(smbios_type3_filter_params)},
194	{SMBIOS_PROCESSOR_INFORMATION, smbios_type4_filter_params,
195	 ARRAY_SIZE(smbios_type4_filter_params)},
196};
197
198static void clear_smbios_table(struct smbios_header *header,
199			       struct smbios_filter_param *filter,
200			       u32 count)
201{
202	u32 i;
203	char *str;
204	u8 string_id;
205
206	for (i = 0; i < count; i++) {
207		if (filter[i].is_string) {
208			string_id = *((u8 *)header + filter[i].offset);
209			if (string_id == 0) /* string is empty */
210				continue;
211
212			str = smbios_string(header, string_id);
213			if (!str)
214				continue;
215
216			/* string is cleared to space, keep '\0' terminator */
217			memset(str, ' ', strlen(str));
218
219		} else {
220			memset((void *)((u8 *)header + filter[i].offset),
221			       0, filter[i].size);
222		}
223	}
224}
225
226void smbios_prepare_measurement(const struct smbios3_entry *entry,
227				struct smbios_header *smbios_copy)
228{
229	u32 i, j;
230	void *table_end;
231	struct smbios_header *header;
232
233	table_end = (void *)((u8 *)smbios_copy + entry->table_maximum_size);
234
235	for (i = 0; i < ARRAY_SIZE(smbios_filter_tables); i++) {
236		header = smbios_copy;
237		for (j = 0; (void *)header < table_end; j++) {
238			if (header->type == smbios_filter_tables[i].type)
239				break;
240
241			header = get_next_header(header);
242		}
243		if ((void *)header >= table_end)
244			continue;
245
246		clear_smbios_table(header,
247				   smbios_filter_tables[i].params,
248				   smbios_filter_tables[i].count);
249	}
250}
251