This source file includes following definitions.
- __calc_tpm2_event_size
1
2
3 #ifndef __LINUX_TPM_EVENTLOG_H__
4 #define __LINUX_TPM_EVENTLOG_H__
5
6 #include <linux/tpm.h>
7
8 #define TCG_EVENT_NAME_LEN_MAX 255
9 #define MAX_TEXT_EVENT 1000
10 #define ACPI_TCPA_SIG "TCPA"
11
12 #define EFI_TCG2_EVENT_LOG_FORMAT_TCG_1_2 0x1
13 #define EFI_TCG2_EVENT_LOG_FORMAT_TCG_2 0x2
14
15 #ifdef CONFIG_PPC64
16 #define do_endian_conversion(x) be32_to_cpu(x)
17 #else
18 #define do_endian_conversion(x) x
19 #endif
20
21 enum bios_platform_class {
22 BIOS_CLIENT = 0x00,
23 BIOS_SERVER = 0x01,
24 };
25
26 struct tcpa_event {
27 u32 pcr_index;
28 u32 event_type;
29 u8 pcr_value[20];
30 u32 event_size;
31 u8 event_data[0];
32 };
33
34 enum tcpa_event_types {
35 PREBOOT = 0,
36 POST_CODE,
37 UNUSED,
38 NO_ACTION,
39 SEPARATOR,
40 ACTION,
41 EVENT_TAG,
42 SCRTM_CONTENTS,
43 SCRTM_VERSION,
44 CPU_MICROCODE,
45 PLATFORM_CONFIG_FLAGS,
46 TABLE_OF_DEVICES,
47 COMPACT_HASH,
48 IPL,
49 IPL_PARTITION_DATA,
50 NONHOST_CODE,
51 NONHOST_CONFIG,
52 NONHOST_INFO,
53 };
54
55 struct tcpa_pc_event {
56 u32 event_id;
57 u32 event_size;
58 u8 event_data[0];
59 };
60
61 enum tcpa_pc_event_ids {
62 SMBIOS = 1,
63 BIS_CERT,
64 POST_BIOS_ROM,
65 ESCD,
66 CMOS,
67 NVRAM,
68 OPTION_ROM_EXEC,
69 OPTION_ROM_CONFIG,
70 OPTION_ROM_MICROCODE = 10,
71 S_CRTM_VERSION,
72 S_CRTM_CONTENTS,
73 POST_CONTENTS,
74 HOST_TABLE_OF_DEVICES,
75 };
76
77
78
79 struct tcg_efi_specid_event_algs {
80 u16 alg_id;
81 u16 digest_size;
82 } __packed;
83
84 struct tcg_efi_specid_event_head {
85 u8 signature[16];
86 u32 platform_class;
87 u8 spec_version_minor;
88 u8 spec_version_major;
89 u8 spec_errata;
90 u8 uintnsize;
91 u32 num_algs;
92 struct tcg_efi_specid_event_algs digest_sizes[];
93 } __packed;
94
95 struct tcg_pcr_event {
96 u32 pcr_idx;
97 u32 event_type;
98 u8 digest[20];
99 u32 event_size;
100 u8 event[0];
101 } __packed;
102
103 struct tcg_event_field {
104 u32 event_size;
105 u8 event[0];
106 } __packed;
107
108 struct tcg_pcr_event2_head {
109 u32 pcr_idx;
110 u32 event_type;
111 u32 count;
112 struct tpm_digest digests[];
113 } __packed;
114
115 struct tcg_algorithm_size {
116 u16 algorithm_id;
117 u16 algorithm_size;
118 };
119
120 struct tcg_algorithm_info {
121 u8 signature[16];
122 u32 platform_class;
123 u8 spec_version_minor;
124 u8 spec_version_major;
125 u8 spec_errata;
126 u8 uintn_size;
127 u32 number_of_algorithms;
128 struct tcg_algorithm_size digest_sizes[];
129 };
130
131 #ifndef TPM_MEMREMAP
132 #define TPM_MEMREMAP(start, size) NULL
133 #endif
134
135 #ifndef TPM_MEMUNMAP
136 #define TPM_MEMUNMAP(start, size) do{} while(0)
137 #endif
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158 static inline int __calc_tpm2_event_size(struct tcg_pcr_event2_head *event,
159 struct tcg_pcr_event *event_header,
160 bool do_mapping)
161 {
162 struct tcg_efi_specid_event_head *efispecid;
163 struct tcg_event_field *event_field;
164 void *mapping = NULL;
165 int mapping_size;
166 void *marker;
167 void *marker_start;
168 u32 halg_size;
169 size_t size;
170 u16 halg;
171 int i;
172 int j;
173 u32 count, event_type;
174
175 marker = event;
176 marker_start = marker;
177 marker = marker + sizeof(event->pcr_idx) + sizeof(event->event_type)
178 + sizeof(event->count);
179
180
181 if (do_mapping) {
182 mapping_size = marker - marker_start;
183 mapping = TPM_MEMREMAP((unsigned long)marker_start,
184 mapping_size);
185 if (!mapping) {
186 size = 0;
187 goto out;
188 }
189 } else {
190 mapping = marker_start;
191 }
192
193 event = (struct tcg_pcr_event2_head *)mapping;
194
195
196
197
198 count = READ_ONCE(event->count);
199 event_type = READ_ONCE(event->event_type);
200
201 efispecid = (struct tcg_efi_specid_event_head *)event_header->event;
202
203
204 if (count > efispecid->num_algs) {
205 size = 0;
206 goto out;
207 }
208
209 for (i = 0; i < count; i++) {
210 halg_size = sizeof(event->digests[i].alg_id);
211
212
213 if (do_mapping) {
214 TPM_MEMUNMAP(mapping, mapping_size);
215 mapping_size = halg_size;
216 mapping = TPM_MEMREMAP((unsigned long)marker,
217 mapping_size);
218 if (!mapping) {
219 size = 0;
220 goto out;
221 }
222 } else {
223 mapping = marker;
224 }
225
226 memcpy(&halg, mapping, halg_size);
227 marker = marker + halg_size;
228
229 for (j = 0; j < efispecid->num_algs; j++) {
230 if (halg == efispecid->digest_sizes[j].alg_id) {
231 marker +=
232 efispecid->digest_sizes[j].digest_size;
233 break;
234 }
235 }
236
237 if (j == efispecid->num_algs) {
238 size = 0;
239 goto out;
240 }
241 }
242
243
244
245
246
247 if (do_mapping) {
248 TPM_MEMUNMAP(mapping, mapping_size);
249 mapping_size += sizeof(event_field->event_size);
250 mapping = TPM_MEMREMAP((unsigned long)marker,
251 mapping_size);
252 if (!mapping) {
253 size = 0;
254 goto out;
255 }
256 } else {
257 mapping = marker;
258 }
259
260 event_field = (struct tcg_event_field *)mapping;
261
262 marker = marker + sizeof(event_field->event_size)
263 + event_field->event_size;
264 size = marker - marker_start;
265
266 if (event_type == 0 && event_field->event_size == 0)
267 size = 0;
268
269 out:
270 if (do_mapping)
271 TPM_MEMUNMAP(mapping, mapping_size);
272 return size;
273 }
274
275 #endif