2006-01-08 16:03:15 +07:00
|
|
|
/*
|
2012-07-11 22:08:12 +07:00
|
|
|
* Copyright (C) 2005, 2012 IBM Corporation
|
2006-01-08 16:03:15 +07:00
|
|
|
*
|
|
|
|
* Authors:
|
2012-07-11 22:08:12 +07:00
|
|
|
* Kent Yoder <key@linux.vnet.ibm.com>
|
2006-01-08 16:03:15 +07:00
|
|
|
* Seiji Munetoh <munetoh@jp.ibm.com>
|
|
|
|
* Stefan Berger <stefanb@us.ibm.com>
|
|
|
|
* Reiner Sailer <sailer@watson.ibm.com>
|
|
|
|
* Kylene Hall <kjhall@us.ibm.com>
|
2016-10-19 07:49:39 +07:00
|
|
|
* Nayna Jain <nayna@linux.vnet.ibm.com>
|
2006-01-08 16:03:15 +07:00
|
|
|
*
|
2007-08-23 04:01:04 +07:00
|
|
|
* Maintained by: <tpmdd-devel@lists.sourceforge.net>
|
|
|
|
*
|
2016-11-14 17:00:52 +07:00
|
|
|
* Access to the event log created by a system's firmware / BIOS
|
2006-01-08 16:03:15 +07:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/security.h>
|
|
|
|
#include <linux/module.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 15:04:11 +07:00
|
|
|
#include <linux/slab.h>
|
2006-01-08 16:03:15 +07:00
|
|
|
|
2012-07-11 22:08:12 +07:00
|
|
|
#include "tpm.h"
|
|
|
|
#include "tpm_eventlog.h"
|
2006-01-08 16:03:15 +07:00
|
|
|
|
|
|
|
|
|
|
|
static const char* tcpa_event_type_strings[] = {
|
|
|
|
"PREBOOT",
|
|
|
|
"POST CODE",
|
|
|
|
"",
|
|
|
|
"NO ACTION",
|
|
|
|
"SEPARATOR",
|
|
|
|
"ACTION",
|
|
|
|
"EVENT TAG",
|
|
|
|
"S-CRTM Contents",
|
|
|
|
"S-CRTM Version",
|
|
|
|
"CPU Microcode",
|
|
|
|
"Platform Config Flags",
|
|
|
|
"Table of Devices",
|
|
|
|
"Compact Hash",
|
|
|
|
"IPL",
|
|
|
|
"IPL Partition Data",
|
|
|
|
"Non-Host Code",
|
|
|
|
"Non-Host Config",
|
|
|
|
"Non-Host Info"
|
|
|
|
};
|
|
|
|
|
|
|
|
static const char* tcpa_pc_event_id_strings[] = {
|
2006-05-31 11:25:47 +07:00
|
|
|
"",
|
2006-01-08 16:03:15 +07:00
|
|
|
"SMBIOS",
|
|
|
|
"BIS Certificate",
|
|
|
|
"POST BIOS ",
|
|
|
|
"ESCD ",
|
|
|
|
"CMOS",
|
|
|
|
"NVRAM",
|
|
|
|
"Option ROM",
|
|
|
|
"Option ROM config",
|
2006-05-31 11:25:47 +07:00
|
|
|
"",
|
|
|
|
"Option ROM microcode ",
|
2006-01-08 16:03:15 +07:00
|
|
|
"S-CRTM Version",
|
2006-05-31 11:25:47 +07:00
|
|
|
"S-CRTM Contents ",
|
|
|
|
"POST Contents ",
|
|
|
|
"Table of Devices",
|
2006-01-08 16:03:15 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
/* returns pointer to start of pos. entry of tcg log */
|
|
|
|
static void *tpm_bios_measurements_start(struct seq_file *m, loff_t *pos)
|
|
|
|
{
|
|
|
|
loff_t i;
|
2016-11-14 17:00:52 +07:00
|
|
|
struct tpm_chip *chip = m->private;
|
|
|
|
struct tpm_bios_log *log = &chip->log;
|
2006-01-08 16:03:48 +07:00
|
|
|
void *addr = log->bios_event_log;
|
|
|
|
void *limit = log->bios_event_log_end;
|
2006-01-08 16:03:15 +07:00
|
|
|
struct tcpa_event *event;
|
2015-06-18 05:17:08 +07:00
|
|
|
u32 converted_event_size;
|
|
|
|
u32 converted_event_type;
|
|
|
|
|
2006-01-08 16:03:15 +07:00
|
|
|
|
|
|
|
/* read over *pos measurements */
|
|
|
|
for (i = 0; i < *pos; i++) {
|
|
|
|
event = addr;
|
|
|
|
|
2015-06-18 05:17:08 +07:00
|
|
|
converted_event_size =
|
|
|
|
do_endian_conversion(event->event_size);
|
|
|
|
converted_event_type =
|
|
|
|
do_endian_conversion(event->event_type);
|
|
|
|
|
2006-01-08 16:03:48 +07:00
|
|
|
if ((addr + sizeof(struct tcpa_event)) < limit) {
|
2015-06-18 05:17:08 +07:00
|
|
|
if ((converted_event_type == 0) &&
|
|
|
|
(converted_event_size == 0))
|
2006-01-08 16:03:15 +07:00
|
|
|
return NULL;
|
2015-06-18 05:17:08 +07:00
|
|
|
addr += (sizeof(struct tcpa_event) +
|
|
|
|
converted_event_size);
|
2006-01-08 16:03:15 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* now check if current entry is valid */
|
2006-01-08 16:03:48 +07:00
|
|
|
if ((addr + sizeof(struct tcpa_event)) >= limit)
|
2006-01-08 16:03:15 +07:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
event = addr;
|
|
|
|
|
2015-06-18 05:17:08 +07:00
|
|
|
converted_event_size = do_endian_conversion(event->event_size);
|
|
|
|
converted_event_type = do_endian_conversion(event->event_type);
|
|
|
|
|
|
|
|
if (((converted_event_type == 0) && (converted_event_size == 0))
|
|
|
|
|| ((addr + sizeof(struct tcpa_event) + converted_event_size)
|
|
|
|
>= limit))
|
2006-01-08 16:03:15 +07:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *tpm_bios_measurements_next(struct seq_file *m, void *v,
|
|
|
|
loff_t *pos)
|
|
|
|
{
|
|
|
|
struct tcpa_event *event = v;
|
2016-11-14 17:00:52 +07:00
|
|
|
struct tpm_chip *chip = m->private;
|
|
|
|
struct tpm_bios_log *log = &chip->log;
|
2006-01-08 16:03:48 +07:00
|
|
|
void *limit = log->bios_event_log_end;
|
2015-06-18 05:17:08 +07:00
|
|
|
u32 converted_event_size;
|
|
|
|
u32 converted_event_type;
|
2006-01-08 16:03:15 +07:00
|
|
|
|
2015-06-18 05:17:08 +07:00
|
|
|
converted_event_size = do_endian_conversion(event->event_size);
|
|
|
|
|
|
|
|
v += sizeof(struct tcpa_event) + converted_event_size;
|
2006-01-08 16:03:15 +07:00
|
|
|
|
|
|
|
/* now check if current entry is valid */
|
2006-01-08 16:03:48 +07:00
|
|
|
if ((v + sizeof(struct tcpa_event)) >= limit)
|
2006-01-08 16:03:15 +07:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
event = v;
|
|
|
|
|
2015-06-18 05:17:08 +07:00
|
|
|
converted_event_size = do_endian_conversion(event->event_size);
|
|
|
|
converted_event_type = do_endian_conversion(event->event_type);
|
2006-01-08 16:03:15 +07:00
|
|
|
|
2015-06-18 05:17:08 +07:00
|
|
|
if (((converted_event_type == 0) && (converted_event_size == 0)) ||
|
|
|
|
((v + sizeof(struct tcpa_event) + converted_event_size) >= limit))
|
2006-01-08 16:03:15 +07:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
(*pos)++;
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tpm_bios_measurements_stop(struct seq_file *m, void *v)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static int get_event_name(char *dest, struct tcpa_event *event,
|
|
|
|
unsigned char * event_entry)
|
|
|
|
{
|
|
|
|
const char *name = "";
|
2009-05-13 23:50:40 +07:00
|
|
|
/* 41 so there is room for 40 data and 1 nul */
|
|
|
|
char data[41] = "";
|
2006-01-08 16:03:15 +07:00
|
|
|
int i, n_len = 0, d_len = 0;
|
2006-05-31 11:25:47 +07:00
|
|
|
struct tcpa_pc_event *pc_event;
|
2006-01-08 16:03:15 +07:00
|
|
|
|
2015-06-18 05:17:08 +07:00
|
|
|
switch (do_endian_conversion(event->event_type)) {
|
2006-01-08 16:03:15 +07:00
|
|
|
case PREBOOT:
|
|
|
|
case POST_CODE:
|
|
|
|
case UNUSED:
|
|
|
|
case NO_ACTION:
|
|
|
|
case SCRTM_CONTENTS:
|
|
|
|
case SCRTM_VERSION:
|
|
|
|
case CPU_MICROCODE:
|
|
|
|
case PLATFORM_CONFIG_FLAGS:
|
|
|
|
case TABLE_OF_DEVICES:
|
|
|
|
case COMPACT_HASH:
|
|
|
|
case IPL:
|
|
|
|
case IPL_PARTITION_DATA:
|
|
|
|
case NONHOST_CODE:
|
|
|
|
case NONHOST_CONFIG:
|
|
|
|
case NONHOST_INFO:
|
2015-06-18 05:17:08 +07:00
|
|
|
name = tcpa_event_type_strings[do_endian_conversion
|
|
|
|
(event->event_type)];
|
2006-01-08 16:03:15 +07:00
|
|
|
n_len = strlen(name);
|
|
|
|
break;
|
|
|
|
case SEPARATOR:
|
|
|
|
case ACTION:
|
2015-06-18 05:17:08 +07:00
|
|
|
if (MAX_TEXT_EVENT >
|
|
|
|
do_endian_conversion(event->event_size)) {
|
2006-01-08 16:03:15 +07:00
|
|
|
name = event_entry;
|
2015-06-18 05:17:08 +07:00
|
|
|
n_len = do_endian_conversion(event->event_size);
|
2006-01-08 16:03:15 +07:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case EVENT_TAG:
|
2006-05-31 11:25:47 +07:00
|
|
|
pc_event = (struct tcpa_pc_event *)event_entry;
|
2006-01-08 16:03:15 +07:00
|
|
|
|
|
|
|
/* ToDo Row data -> Base64 */
|
|
|
|
|
2015-06-18 05:17:08 +07:00
|
|
|
switch (do_endian_conversion(pc_event->event_id)) {
|
2006-01-08 16:03:15 +07:00
|
|
|
case SMBIOS:
|
|
|
|
case BIS_CERT:
|
|
|
|
case CMOS:
|
|
|
|
case NVRAM:
|
|
|
|
case OPTION_ROM_EXEC:
|
|
|
|
case OPTION_ROM_CONFIG:
|
|
|
|
case S_CRTM_VERSION:
|
2015-06-18 05:17:08 +07:00
|
|
|
name = tcpa_pc_event_id_strings[do_endian_conversion
|
|
|
|
(pc_event->event_id)];
|
2006-01-08 16:03:15 +07:00
|
|
|
n_len = strlen(name);
|
|
|
|
break;
|
2006-05-31 11:25:47 +07:00
|
|
|
/* hash data */
|
2006-01-08 16:03:15 +07:00
|
|
|
case POST_BIOS_ROM:
|
|
|
|
case ESCD:
|
2006-05-31 11:25:47 +07:00
|
|
|
case OPTION_ROM_MICROCODE:
|
|
|
|
case S_CRTM_CONTENTS:
|
|
|
|
case POST_CONTENTS:
|
2015-06-18 05:17:08 +07:00
|
|
|
name = tcpa_pc_event_id_strings[do_endian_conversion
|
|
|
|
(pc_event->event_id)];
|
2006-01-08 16:03:15 +07:00
|
|
|
n_len = strlen(name);
|
|
|
|
for (i = 0; i < 20; i++)
|
2006-05-31 11:25:47 +07:00
|
|
|
d_len += sprintf(&data[2*i], "%02x",
|
|
|
|
pc_event->event_data[i]);
|
2006-01-08 16:03:15 +07:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return snprintf(dest, MAX_TEXT_EVENT, "[%.*s%.*s]",
|
|
|
|
n_len, name, d_len, data);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tpm_binary_bios_measurements_show(struct seq_file *m, void *v)
|
|
|
|
{
|
2006-05-31 11:25:52 +07:00
|
|
|
struct tcpa_event *event = v;
|
2015-06-18 05:17:08 +07:00
|
|
|
struct tcpa_event temp_event;
|
2016-02-06 21:44:42 +07:00
|
|
|
char *temp_ptr;
|
2006-05-31 11:25:52 +07:00
|
|
|
int i;
|
2006-01-08 16:03:15 +07:00
|
|
|
|
2015-06-18 05:17:08 +07:00
|
|
|
memcpy(&temp_event, event, sizeof(struct tcpa_event));
|
|
|
|
|
|
|
|
/* convert raw integers for endianness */
|
|
|
|
temp_event.pcr_index = do_endian_conversion(event->pcr_index);
|
|
|
|
temp_event.event_type = do_endian_conversion(event->event_type);
|
|
|
|
temp_event.event_size = do_endian_conversion(event->event_size);
|
|
|
|
|
2016-02-06 21:44:42 +07:00
|
|
|
temp_ptr = (char *) &temp_event;
|
2015-06-18 05:17:08 +07:00
|
|
|
|
2016-02-06 21:44:42 +07:00
|
|
|
for (i = 0; i < (sizeof(struct tcpa_event) - 1) ; i++)
|
|
|
|
seq_putc(m, temp_ptr[i]);
|
|
|
|
|
|
|
|
temp_ptr = (char *) v;
|
|
|
|
|
|
|
|
for (i = (sizeof(struct tcpa_event) - 1);
|
|
|
|
i < (sizeof(struct tcpa_event) + temp_event.event_size); i++)
|
|
|
|
seq_putc(m, temp_ptr[i]);
|
2006-01-08 16:03:15 +07:00
|
|
|
|
|
|
|
return 0;
|
2015-06-18 05:17:08 +07:00
|
|
|
|
2006-01-08 16:03:15 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int tpm_bios_measurements_release(struct inode *inode,
|
|
|
|
struct file *file)
|
|
|
|
{
|
2016-11-14 17:00:52 +07:00
|
|
|
struct seq_file *seq = (struct seq_file *)file->private_data;
|
|
|
|
struct tpm_chip *chip = (struct tpm_chip *)seq->private;
|
2006-01-08 16:03:48 +07:00
|
|
|
|
2016-11-14 17:00:52 +07:00
|
|
|
put_device(&chip->dev);
|
2006-01-08 16:03:48 +07:00
|
|
|
|
2006-01-08 16:03:15 +07:00
|
|
|
return seq_release(inode, file);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tpm_ascii_bios_measurements_show(struct seq_file *m, void *v)
|
|
|
|
{
|
|
|
|
int len = 0;
|
|
|
|
char *eventname;
|
|
|
|
struct tcpa_event *event = v;
|
|
|
|
unsigned char *event_entry =
|
2015-06-18 05:17:08 +07:00
|
|
|
(unsigned char *)(v + sizeof(struct tcpa_event));
|
2006-01-08 16:03:15 +07:00
|
|
|
|
|
|
|
eventname = kmalloc(MAX_TEXT_EVENT, GFP_KERNEL);
|
|
|
|
if (!eventname) {
|
|
|
|
printk(KERN_ERR "%s: ERROR - No Memory for event name\n ",
|
|
|
|
__func__);
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
|
2015-06-18 05:17:08 +07:00
|
|
|
/* 1st: PCR */
|
|
|
|
seq_printf(m, "%2d ", do_endian_conversion(event->pcr_index));
|
2006-01-08 16:03:15 +07:00
|
|
|
|
|
|
|
/* 2nd: SHA1 */
|
2014-07-09 19:34:41 +07:00
|
|
|
seq_printf(m, "%20phN", event->pcr_value);
|
2006-01-08 16:03:15 +07:00
|
|
|
|
|
|
|
/* 3rd: event type identifier */
|
2015-06-18 05:17:08 +07:00
|
|
|
seq_printf(m, " %02x", do_endian_conversion(event->event_type));
|
2006-01-08 16:03:15 +07:00
|
|
|
|
|
|
|
len += get_event_name(eventname, event, event_entry);
|
|
|
|
|
|
|
|
/* 4th: eventname <= max + \'0' delimiter */
|
|
|
|
seq_printf(m, " %s\n", eventname);
|
|
|
|
|
2006-04-22 16:36:35 +07:00
|
|
|
kfree(eventname);
|
2006-01-08 16:03:15 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-10-19 07:49:39 +07:00
|
|
|
static const struct seq_operations tpm_ascii_b_measurements_seqops = {
|
2006-01-08 16:03:15 +07:00
|
|
|
.start = tpm_bios_measurements_start,
|
|
|
|
.next = tpm_bios_measurements_next,
|
|
|
|
.stop = tpm_bios_measurements_stop,
|
|
|
|
.show = tpm_ascii_bios_measurements_show,
|
|
|
|
};
|
|
|
|
|
2016-10-19 07:49:39 +07:00
|
|
|
static const struct seq_operations tpm_binary_b_measurements_seqops = {
|
2006-01-08 16:03:15 +07:00
|
|
|
.start = tpm_bios_measurements_start,
|
|
|
|
.next = tpm_bios_measurements_next,
|
|
|
|
.stop = tpm_bios_measurements_stop,
|
|
|
|
.show = tpm_binary_bios_measurements_show,
|
|
|
|
};
|
|
|
|
|
2016-10-19 07:49:39 +07:00
|
|
|
static int tpm_bios_measurements_open(struct inode *inode,
|
2006-01-08 16:03:15 +07:00
|
|
|
struct file *file)
|
|
|
|
{
|
|
|
|
int err;
|
2006-01-08 16:03:48 +07:00
|
|
|
struct seq_file *seq;
|
2016-11-14 17:00:52 +07:00
|
|
|
struct tpm_chip_seqops *chip_seqops;
|
|
|
|
const struct seq_operations *seqops;
|
|
|
|
struct tpm_chip *chip;
|
|
|
|
|
|
|
|
inode_lock(inode);
|
|
|
|
if (!inode->i_private) {
|
|
|
|
inode_unlock(inode);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
chip_seqops = (struct tpm_chip_seqops *)inode->i_private;
|
|
|
|
seqops = chip_seqops->seqops;
|
|
|
|
chip = chip_seqops->chip;
|
|
|
|
get_device(&chip->dev);
|
|
|
|
inode_unlock(inode);
|
2006-01-08 16:03:15 +07:00
|
|
|
|
|
|
|
/* now register seq file */
|
2016-10-19 07:49:39 +07:00
|
|
|
err = seq_open(file, seqops);
|
2006-01-08 16:03:48 +07:00
|
|
|
if (!err) {
|
|
|
|
seq = file->private_data;
|
2016-11-14 17:00:52 +07:00
|
|
|
seq->private = chip;
|
2006-01-08 16:03:48 +07:00
|
|
|
}
|
2007-07-20 14:31:48 +07:00
|
|
|
|
2006-01-08 16:03:48 +07:00
|
|
|
return err;
|
2006-01-08 16:03:15 +07:00
|
|
|
}
|
|
|
|
|
2016-10-19 07:49:39 +07:00
|
|
|
static const struct file_operations tpm_bios_measurements_ops = {
|
2016-11-14 17:00:53 +07:00
|
|
|
.owner = THIS_MODULE,
|
2016-10-19 07:49:39 +07:00
|
|
|
.open = tpm_bios_measurements_open,
|
2006-01-08 16:03:15 +07:00
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = tpm_bios_measurements_release,
|
|
|
|
};
|
|
|
|
|
2016-11-14 17:00:54 +07:00
|
|
|
static int tpm_read_log(struct tpm_chip *chip)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
if (chip->log.bios_event_log != NULL) {
|
|
|
|
dev_dbg(&chip->dev,
|
|
|
|
"%s: ERROR - event log already initialized\n",
|
|
|
|
__func__);
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = tpm_read_log_acpi(chip);
|
2016-11-20 01:18:28 +07:00
|
|
|
if (rc != -ENODEV)
|
2016-11-14 17:00:54 +07:00
|
|
|
return rc;
|
|
|
|
|
2016-11-20 01:18:28 +07:00
|
|
|
return tpm_read_log_of(chip);
|
2016-11-14 17:00:54 +07:00
|
|
|
}
|
|
|
|
|
2016-11-20 01:18:28 +07:00
|
|
|
/*
|
|
|
|
* tpm_bios_log_setup() - Read the event log from the firmware
|
|
|
|
* @chip: TPM chip to use.
|
|
|
|
*
|
|
|
|
* If an event log is found then the securityfs files are setup to
|
|
|
|
* export it to userspace, otherwise nothing is done.
|
|
|
|
*
|
2016-11-22 23:58:56 +07:00
|
|
|
* Returns -ENODEV if the firmware has no event log or securityfs is not
|
|
|
|
* supported.
|
2016-11-20 01:18:28 +07:00
|
|
|
*/
|
2016-11-14 17:00:50 +07:00
|
|
|
int tpm_bios_log_setup(struct tpm_chip *chip)
|
2006-02-01 18:05:01 +07:00
|
|
|
{
|
2016-11-14 17:00:50 +07:00
|
|
|
const char *name = dev_name(&chip->dev);
|
|
|
|
unsigned int cnt;
|
2016-11-14 17:00:52 +07:00
|
|
|
int rc = 0;
|
2016-11-14 17:00:50 +07:00
|
|
|
|
2016-11-14 17:00:51 +07:00
|
|
|
if (chip->flags & TPM_CHIP_FLAG_TPM2)
|
|
|
|
return 0;
|
|
|
|
|
2016-11-14 17:00:54 +07:00
|
|
|
rc = tpm_read_log(chip);
|
2016-11-20 01:18:28 +07:00
|
|
|
if (rc)
|
|
|
|
return rc;
|
2016-11-14 17:00:52 +07:00
|
|
|
|
2016-11-14 17:00:50 +07:00
|
|
|
cnt = 0;
|
|
|
|
chip->bios_dir[cnt] = securityfs_create_dir(name, NULL);
|
|
|
|
/* NOTE: securityfs_create_dir can return ENODEV if securityfs is
|
|
|
|
* compiled out. The caller should ignore the ENODEV return code.
|
|
|
|
*/
|
|
|
|
if (IS_ERR(chip->bios_dir[cnt]))
|
|
|
|
goto err;
|
|
|
|
cnt++;
|
|
|
|
|
2016-11-14 17:00:52 +07:00
|
|
|
chip->bin_log_seqops.chip = chip;
|
|
|
|
chip->bin_log_seqops.seqops = &tpm_binary_b_measurements_seqops;
|
|
|
|
|
2016-11-14 17:00:50 +07:00
|
|
|
chip->bios_dir[cnt] =
|
2006-01-08 16:03:15 +07:00
|
|
|
securityfs_create_file("binary_bios_measurements",
|
2016-11-14 17:00:50 +07:00
|
|
|
0440, chip->bios_dir[0],
|
2016-11-14 17:00:52 +07:00
|
|
|
(void *)&chip->bin_log_seqops,
|
2016-10-19 07:49:39 +07:00
|
|
|
&tpm_bios_measurements_ops);
|
2016-11-14 17:00:50 +07:00
|
|
|
if (IS_ERR(chip->bios_dir[cnt]))
|
|
|
|
goto err;
|
|
|
|
cnt++;
|
2006-01-08 16:03:15 +07:00
|
|
|
|
2016-11-14 17:00:52 +07:00
|
|
|
chip->ascii_log_seqops.chip = chip;
|
|
|
|
chip->ascii_log_seqops.seqops = &tpm_ascii_b_measurements_seqops;
|
|
|
|
|
2016-11-14 17:00:50 +07:00
|
|
|
chip->bios_dir[cnt] =
|
2006-01-08 16:03:15 +07:00
|
|
|
securityfs_create_file("ascii_bios_measurements",
|
2016-11-14 17:00:50 +07:00
|
|
|
0440, chip->bios_dir[0],
|
2016-11-14 17:00:52 +07:00
|
|
|
(void *)&chip->ascii_log_seqops,
|
2016-10-19 07:49:39 +07:00
|
|
|
&tpm_bios_measurements_ops);
|
2016-11-14 17:00:50 +07:00
|
|
|
if (IS_ERR(chip->bios_dir[cnt]))
|
|
|
|
goto err;
|
|
|
|
cnt++;
|
2006-01-08 16:03:15 +07:00
|
|
|
|
2016-11-14 17:00:50 +07:00
|
|
|
return 0;
|
2006-01-08 16:03:15 +07:00
|
|
|
|
2016-11-14 17:00:50 +07:00
|
|
|
err:
|
2016-11-22 23:58:56 +07:00
|
|
|
rc = PTR_ERR(chip->bios_dir[cnt]);
|
2016-11-14 17:00:50 +07:00
|
|
|
chip->bios_dir[cnt] = NULL;
|
|
|
|
tpm_bios_log_teardown(chip);
|
2016-11-22 23:58:56 +07:00
|
|
|
return rc;
|
2006-01-08 16:03:15 +07:00
|
|
|
}
|
|
|
|
|
2016-11-14 17:00:50 +07:00
|
|
|
void tpm_bios_log_teardown(struct tpm_chip *chip)
|
2006-01-08 16:03:15 +07:00
|
|
|
{
|
|
|
|
int i;
|
2016-11-14 17:00:52 +07:00
|
|
|
struct inode *inode;
|
2006-01-08 16:03:15 +07:00
|
|
|
|
2016-11-14 17:00:52 +07:00
|
|
|
/* securityfs_remove currently doesn't take care of handling sync
|
|
|
|
* between removal and opening of pseudo files. To handle this, a
|
|
|
|
* workaround is added by making i_private = NULL here during removal
|
|
|
|
* and to check it during open(), both within inode_lock()/unlock().
|
|
|
|
* This design ensures that open() either safely gets kref or fails.
|
|
|
|
*/
|
|
|
|
for (i = (TPM_NUM_EVENT_LOG_FILES - 1); i >= 0; i--) {
|
2016-11-16 20:56:13 +07:00
|
|
|
if (chip->bios_dir[i]) {
|
|
|
|
inode = d_inode(chip->bios_dir[i]);
|
|
|
|
inode_lock(inode);
|
|
|
|
inode->i_private = NULL;
|
|
|
|
inode_unlock(inode);
|
|
|
|
securityfs_remove(chip->bios_dir[i]);
|
|
|
|
}
|
2016-11-14 17:00:52 +07:00
|
|
|
}
|
2006-01-08 16:03:15 +07:00
|
|
|
}
|