2 * Copyright (C) 2005, 2012 IBM Corporation
5 * Kent Yoder <key@linux.vnet.ibm.com>
6 * Seiji Munetoh <munetoh@jp.ibm.com>
7 * Stefan Berger <stefanb@us.ibm.com>
8 * Reiner Sailer <sailer@watson.ibm.com>
9 * Kylene Hall <kjhall@us.ibm.com>
11 * Maintained by: <tpmdd-devel@lists.sourceforge.net>
13 * Access to the eventlog created by a system's firmware / BIOS
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License
17 * as published by the Free Software Foundation; either version
18 * 2 of the License, or (at your option) any later version.
22 #include <linux/seq_file.h>
24 #include <linux/security.h>
25 #include <linux/module.h>
26 #include <linux/slab.h>
29 #include "tpm_eventlog.h"
32 static const char* tcpa_event_type_strings[] = {
43 "Platform Config Flags",
53 static const char* tcpa_pc_event_id_strings[] = {
64 "Option ROM microcode ",
71 /* returns pointer to start of pos. entry of tcg log */
72 static void *tpm_bios_measurements_start(struct seq_file *m, loff_t *pos)
75 struct tpm_bios_log *log = m->private;
76 void *addr = log->bios_event_log;
77 void *limit = log->bios_event_log_end;
78 struct tcpa_event *event;
79 u32 converted_event_size;
80 u32 converted_event_type;
83 /* read over *pos measurements */
84 for (i = 0; i < *pos; i++) {
87 converted_event_size =
88 do_endian_conversion(event->event_size);
89 converted_event_type =
90 do_endian_conversion(event->event_type);
92 if ((addr + sizeof(struct tcpa_event)) < limit) {
93 if ((converted_event_type == 0) &&
94 (converted_event_size == 0))
96 addr += (sizeof(struct tcpa_event) +
97 converted_event_size);
101 /* now check if current entry is valid */
102 if ((addr + sizeof(struct tcpa_event)) >= limit)
107 converted_event_size = do_endian_conversion(event->event_size);
108 converted_event_type = do_endian_conversion(event->event_type);
110 if (((converted_event_type == 0) && (converted_event_size == 0))
111 || ((addr + sizeof(struct tcpa_event) + converted_event_size)
118 static void *tpm_bios_measurements_next(struct seq_file *m, void *v,
121 struct tcpa_event *event = v;
122 struct tpm_bios_log *log = m->private;
123 void *limit = log->bios_event_log_end;
124 u32 converted_event_size;
125 u32 converted_event_type;
127 converted_event_size = do_endian_conversion(event->event_size);
129 v += sizeof(struct tcpa_event) + converted_event_size;
131 /* now check if current entry is valid */
132 if ((v + sizeof(struct tcpa_event)) >= limit)
137 converted_event_size = do_endian_conversion(event->event_size);
138 converted_event_type = do_endian_conversion(event->event_type);
140 if (((converted_event_type == 0) && (converted_event_size == 0)) ||
141 ((v + sizeof(struct tcpa_event) + converted_event_size) >= limit))
148 static void tpm_bios_measurements_stop(struct seq_file *m, void *v)
152 static int get_event_name(char *dest, struct tcpa_event *event,
153 unsigned char * event_entry)
155 const char *name = "";
156 /* 41 so there is room for 40 data and 1 nul */
158 int i, n_len = 0, d_len = 0;
159 struct tcpa_pc_event *pc_event;
161 switch (do_endian_conversion(event->event_type)) {
169 case PLATFORM_CONFIG_FLAGS:
170 case TABLE_OF_DEVICES:
173 case IPL_PARTITION_DATA:
177 name = tcpa_event_type_strings[do_endian_conversion
178 (event->event_type)];
179 n_len = strlen(name);
184 do_endian_conversion(event->event_size)) {
186 n_len = do_endian_conversion(event->event_size);
190 pc_event = (struct tcpa_pc_event *)event_entry;
192 /* ToDo Row data -> Base64 */
194 switch (do_endian_conversion(pc_event->event_id)) {
199 case OPTION_ROM_EXEC:
200 case OPTION_ROM_CONFIG:
202 name = tcpa_pc_event_id_strings[do_endian_conversion
203 (pc_event->event_id)];
204 n_len = strlen(name);
209 case OPTION_ROM_MICROCODE:
210 case S_CRTM_CONTENTS:
212 name = tcpa_pc_event_id_strings[do_endian_conversion
213 (pc_event->event_id)];
214 n_len = strlen(name);
215 for (i = 0; i < 20; i++)
216 d_len += sprintf(&data[2*i], "%02x",
217 pc_event->event_data[i]);
226 return snprintf(dest, MAX_TEXT_EVENT, "[%.*s%.*s]",
227 n_len, name, d_len, data);
231 static int tpm_binary_bios_measurements_show(struct seq_file *m, void *v)
233 struct tcpa_event *event = v;
234 struct tcpa_event temp_event;
238 memcpy(&temp_event, event, sizeof(struct tcpa_event));
240 /* convert raw integers for endianness */
241 temp_event.pcr_index = do_endian_conversion(event->pcr_index);
242 temp_event.event_type = do_endian_conversion(event->event_type);
243 temp_event.event_size = do_endian_conversion(event->event_size);
245 tempPtr = (char *)&temp_event;
247 for (i = 0; i < sizeof(struct tcpa_event) + temp_event.event_size; i++)
248 seq_putc(m, tempPtr[i]);
254 static int tpm_bios_measurements_release(struct inode *inode,
257 struct seq_file *seq = file->private_data;
258 struct tpm_bios_log *log = seq->private;
261 kfree(log->bios_event_log);
265 return seq_release(inode, file);
268 static int tpm_ascii_bios_measurements_show(struct seq_file *m, void *v)
272 struct tcpa_event *event = v;
273 unsigned char *event_entry =
274 (unsigned char *)(v + sizeof(struct tcpa_event));
276 eventname = kmalloc(MAX_TEXT_EVENT, GFP_KERNEL);
278 printk(KERN_ERR "%s: ERROR - No Memory for event name\n ",
284 seq_printf(m, "%2d ", do_endian_conversion(event->pcr_index));
287 seq_printf(m, "%20phN", event->pcr_value);
289 /* 3rd: event type identifier */
290 seq_printf(m, " %02x", do_endian_conversion(event->event_type));
292 len += get_event_name(eventname, event, event_entry);
294 /* 4th: eventname <= max + \'0' delimiter */
295 seq_printf(m, " %s\n", eventname);
301 static const struct seq_operations tpm_ascii_b_measurments_seqops = {
302 .start = tpm_bios_measurements_start,
303 .next = tpm_bios_measurements_next,
304 .stop = tpm_bios_measurements_stop,
305 .show = tpm_ascii_bios_measurements_show,
308 static const struct seq_operations tpm_binary_b_measurments_seqops = {
309 .start = tpm_bios_measurements_start,
310 .next = tpm_bios_measurements_next,
311 .stop = tpm_bios_measurements_stop,
312 .show = tpm_binary_bios_measurements_show,
315 static int tpm_ascii_bios_measurements_open(struct inode *inode,
319 struct tpm_bios_log *log;
320 struct seq_file *seq;
322 log = kzalloc(sizeof(struct tpm_bios_log), GFP_KERNEL);
326 if ((err = read_log(log)))
329 /* now register seq file */
330 err = seq_open(file, &tpm_ascii_b_measurments_seqops);
332 seq = file->private_data;
341 kfree(log->bios_event_log);
346 static const struct file_operations tpm_ascii_bios_measurements_ops = {
347 .open = tpm_ascii_bios_measurements_open,
350 .release = tpm_bios_measurements_release,
353 static int tpm_binary_bios_measurements_open(struct inode *inode,
357 struct tpm_bios_log *log;
358 struct seq_file *seq;
360 log = kzalloc(sizeof(struct tpm_bios_log), GFP_KERNEL);
364 if ((err = read_log(log)))
367 /* now register seq file */
368 err = seq_open(file, &tpm_binary_b_measurments_seqops);
370 seq = file->private_data;
379 kfree(log->bios_event_log);
384 static const struct file_operations tpm_binary_bios_measurements_ops = {
385 .open = tpm_binary_bios_measurements_open,
388 .release = tpm_bios_measurements_release,
391 static int is_bad(void *p)
395 if (IS_ERR(p) && (PTR_ERR(p) != -ENODEV))
400 struct dentry **tpm_bios_log_setup(char *name)
402 struct dentry **ret = NULL, *tpm_dir, *bin_file, *ascii_file;
404 tpm_dir = securityfs_create_dir(name, NULL);
409 securityfs_create_file("binary_bios_measurements",
410 S_IRUSR | S_IRGRP, tpm_dir, NULL,
411 &tpm_binary_bios_measurements_ops);
412 if (is_bad(bin_file))
416 securityfs_create_file("ascii_bios_measurements",
417 S_IRUSR | S_IRGRP, tpm_dir, NULL,
418 &tpm_ascii_bios_measurements_ops);
419 if (is_bad(ascii_file))
422 ret = kmalloc(3 * sizeof(struct dentry *), GFP_KERNEL);
433 securityfs_remove(ascii_file);
435 securityfs_remove(bin_file);
437 securityfs_remove(tpm_dir);
442 void tpm_bios_log_teardown(struct dentry **lst)
446 for (i = 0; i < 3; i++)
447 securityfs_remove(lst[i]);