Contributors: 14
Author |
Tokens |
Token Proportion |
Commits |
Commit Proportion |
Nayna Jain |
457 |
71.07% |
2 |
9.09% |
Kylene Jo Hall |
139 |
21.62% |
3 |
13.64% |
Gustavo A. R. Silva |
12 |
1.87% |
1 |
4.55% |
Vasily Averin |
6 |
0.93% |
1 |
4.55% |
Linus Torvalds (pre-git) |
5 |
0.78% |
3 |
13.64% |
Thiébaud Weksteen |
5 |
0.78% |
3 |
13.64% |
Roberto Sassu |
4 |
0.62% |
1 |
4.55% |
Matthew Garrett |
4 |
0.62% |
2 |
9.09% |
Jeff Garzik |
3 |
0.47% |
1 |
4.55% |
Hon Ching (Vicky) Lo |
3 |
0.47% |
1 |
4.55% |
Thomas Gleixner |
2 |
0.31% |
1 |
4.55% |
Yue haibing |
1 |
0.16% |
1 |
4.55% |
Petr Vandrovec |
1 |
0.16% |
1 |
4.55% |
Linus Torvalds |
1 |
0.16% |
1 |
4.55% |
Total |
643 |
|
22 |
|
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Copyright (C) 2016 IBM Corporation
*
* Authors:
* Nayna Jain <nayna@linux.vnet.ibm.com>
*
* Access to TPM 2.0 event log as written by Firmware.
* It assumes that writer of event log has followed TCG Specification
* for Family "2.0" and written the event data in little endian.
* With that, it doesn't need any endian conversion for structure
* content.
*/
#include <linux/seq_file.h>
#include <linux/fs.h>
#include <linux/security.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/tpm_eventlog.h>
#include "../tpm.h"
#include "common.h"
/*
* calc_tpm2_event_size() - calculate the event size, where event
* is an entry in the TPM 2.0 event log. The event is of type Crypto
* Agile Log Entry Format as defined in TCG EFI Protocol Specification
* Family "2.0".
* @event: event whose size is to be calculated.
* @event_header: the first event in the event log.
*
* Returns size of the event. If it is an invalid event, returns 0.
*/
static size_t calc_tpm2_event_size(struct tcg_pcr_event2_head *event,
struct tcg_pcr_event *event_header)
{
return __calc_tpm2_event_size(event, event_header, false);
}
static void *tpm2_bios_measurements_start(struct seq_file *m, loff_t *pos)
{
struct tpm_chip *chip = m->private;
struct tpm_bios_log *log = &chip->log;
void *addr = log->bios_event_log;
void *limit = log->bios_event_log_end;
struct tcg_pcr_event *event_header;
struct tcg_pcr_event2_head *event;
size_t size;
int i;
event_header = addr;
size = struct_size(event_header, event, event_header->event_size);
if (*pos == 0) {
if (addr + size < limit) {
if ((event_header->event_type == 0) &&
(event_header->event_size == 0))
return NULL;
return SEQ_START_TOKEN;
}
}
if (*pos > 0) {
addr += size;
event = addr;
size = calc_tpm2_event_size(event, event_header);
if ((addr + size >= limit) || (size == 0))
return NULL;
}
for (i = 0; i < (*pos - 1); i++) {
event = addr;
size = calc_tpm2_event_size(event, event_header);
if ((addr + size >= limit) || (size == 0))
return NULL;
addr += size;
}
return addr;
}
static void *tpm2_bios_measurements_next(struct seq_file *m, void *v,
loff_t *pos)
{
struct tcg_pcr_event *event_header;
struct tcg_pcr_event2_head *event;
struct tpm_chip *chip = m->private;
struct tpm_bios_log *log = &chip->log;
void *limit = log->bios_event_log_end;
size_t event_size;
void *marker;
(*pos)++;
event_header = log->bios_event_log;
if (v == SEQ_START_TOKEN) {
event_size = struct_size(event_header, event,
event_header->event_size);
marker = event_header;
} else {
event = v;
event_size = calc_tpm2_event_size(event, event_header);
if (event_size == 0)
return NULL;
marker = event;
}
marker = marker + event_size;
if (marker >= limit)
return NULL;
v = marker;
event = v;
event_size = calc_tpm2_event_size(event, event_header);
if (((v + event_size) >= limit) || (event_size == 0))
return NULL;
return v;
}
static void tpm2_bios_measurements_stop(struct seq_file *m, void *v)
{
}
static int tpm2_binary_bios_measurements_show(struct seq_file *m, void *v)
{
struct tpm_chip *chip = m->private;
struct tpm_bios_log *log = &chip->log;
struct tcg_pcr_event *event_header = log->bios_event_log;
struct tcg_pcr_event2_head *event = v;
void *temp_ptr;
size_t size;
if (v == SEQ_START_TOKEN) {
size = struct_size(event_header, event,
event_header->event_size);
temp_ptr = event_header;
if (size > 0)
seq_write(m, temp_ptr, size);
} else {
size = calc_tpm2_event_size(event, event_header);
temp_ptr = event;
if (size > 0)
seq_write(m, temp_ptr, size);
}
return 0;
}
const struct seq_operations tpm2_binary_b_measurements_seqops = {
.start = tpm2_bios_measurements_start,
.next = tpm2_bios_measurements_next,
.stop = tpm2_bios_measurements_stop,
.show = tpm2_binary_bios_measurements_show,
};