Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2005 IBM Corporation |
| 3 | * |
| 4 | * Authors: |
| 5 | * Seiji Munetoh <munetoh@jp.ibm.com> |
| 6 | * Stefan Berger <stefanb@us.ibm.com> |
| 7 | * Reiner Sailer <sailer@watson.ibm.com> |
| 8 | * Kylene Hall <kjhall@us.ibm.com> |
| 9 | * |
| 10 | * Access to the eventlog extended by the TCG BIOS of PC platform |
| 11 | * |
| 12 | * This program is free software; you can redistribute it and/or |
| 13 | * modify it under the terms of the GNU General Public License |
| 14 | * as published by the Free Software Foundation; either version |
| 15 | * 2 of the License, or (at your option) any later version. |
| 16 | * |
| 17 | */ |
| 18 | |
| 19 | #include <linux/seq_file.h> |
| 20 | #include <linux/fs.h> |
| 21 | #include <linux/security.h> |
| 22 | #include <linux/module.h> |
| 23 | #include <acpi/acpi.h> |
| 24 | #include <acpi/actypes.h> |
| 25 | #include <acpi/actbl.h> |
| 26 | #include "tpm.h" |
| 27 | |
| 28 | #define TCG_EVENT_NAME_LEN_MAX 255 |
| 29 | #define MAX_TEXT_EVENT 1000 /* Max event string length */ |
| 30 | #define ACPI_TCPA_SIG "TCPA" /* 0x41504354 /'TCPA' */ |
| 31 | |
Kylene Jo Hall | 8b006db | 2006-04-22 02:39:07 -0700 | [diff] [blame] | 32 | enum bios_platform_class { |
| 33 | BIOS_CLIENT = 0x00, |
| 34 | BIOS_SERVER = 0x01, |
| 35 | }; |
| 36 | |
Kylene Jo Hall | d09cf7d | 2006-01-08 01:03:48 -0800 | [diff] [blame] | 37 | struct tpm_bios_log { |
| 38 | void *bios_event_log; |
| 39 | void *bios_event_log_end; |
| 40 | }; |
| 41 | |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 42 | struct acpi_tcpa { |
| 43 | struct acpi_table_header hdr; |
Kylene Jo Hall | 8b006db | 2006-04-22 02:39:07 -0700 | [diff] [blame] | 44 | u16 platform_class; |
| 45 | union { |
| 46 | struct client_hdr { |
| 47 | u32 log_max_len __attribute__ ((packed)); |
| 48 | u64 log_start_addr __attribute__ ((packed)); |
| 49 | } client; |
| 50 | struct server_hdr { |
| 51 | u16 reserved; |
| 52 | u64 log_max_len __attribute__ ((packed)); |
| 53 | u64 log_start_addr __attribute__ ((packed)); |
| 54 | } server; |
| 55 | }; |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 56 | }; |
| 57 | |
| 58 | struct tcpa_event { |
| 59 | u32 pcr_index; |
| 60 | u32 event_type; |
| 61 | u8 pcr_value[20]; /* SHA1 */ |
| 62 | u32 event_size; |
| 63 | u8 event_data[0]; |
| 64 | }; |
| 65 | |
| 66 | enum tcpa_event_types { |
| 67 | PREBOOT = 0, |
| 68 | POST_CODE, |
| 69 | UNUSED, |
| 70 | NO_ACTION, |
| 71 | SEPARATOR, |
| 72 | ACTION, |
| 73 | EVENT_TAG, |
| 74 | SCRTM_CONTENTS, |
| 75 | SCRTM_VERSION, |
| 76 | CPU_MICROCODE, |
| 77 | PLATFORM_CONFIG_FLAGS, |
| 78 | TABLE_OF_DEVICES, |
| 79 | COMPACT_HASH, |
| 80 | IPL, |
| 81 | IPL_PARTITION_DATA, |
| 82 | NONHOST_CODE, |
| 83 | NONHOST_CONFIG, |
| 84 | NONHOST_INFO, |
| 85 | }; |
| 86 | |
| 87 | static const char* tcpa_event_type_strings[] = { |
| 88 | "PREBOOT", |
| 89 | "POST CODE", |
| 90 | "", |
| 91 | "NO ACTION", |
| 92 | "SEPARATOR", |
| 93 | "ACTION", |
| 94 | "EVENT TAG", |
| 95 | "S-CRTM Contents", |
| 96 | "S-CRTM Version", |
| 97 | "CPU Microcode", |
| 98 | "Platform Config Flags", |
| 99 | "Table of Devices", |
| 100 | "Compact Hash", |
| 101 | "IPL", |
| 102 | "IPL Partition Data", |
| 103 | "Non-Host Code", |
| 104 | "Non-Host Config", |
| 105 | "Non-Host Info" |
| 106 | }; |
| 107 | |
Seiji Munetoh | de66a69 | 2006-05-30 21:25:47 -0700 | [diff] [blame] | 108 | struct tcpa_pc_event { |
| 109 | u32 event_id; |
| 110 | u32 event_size; |
| 111 | u8 event_data[0]; |
| 112 | }; |
| 113 | |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 114 | enum tcpa_pc_event_ids { |
| 115 | SMBIOS = 1, |
| 116 | BIS_CERT, |
| 117 | POST_BIOS_ROM, |
| 118 | ESCD, |
| 119 | CMOS, |
| 120 | NVRAM, |
| 121 | OPTION_ROM_EXEC, |
| 122 | OPTION_ROM_CONFIG, |
Seiji Munetoh | de66a69 | 2006-05-30 21:25:47 -0700 | [diff] [blame] | 123 | OPTION_ROM_MICROCODE = 10, |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 124 | S_CRTM_VERSION, |
| 125 | S_CRTM_CONTENTS, |
| 126 | POST_CONTENTS, |
Seiji Munetoh | de66a69 | 2006-05-30 21:25:47 -0700 | [diff] [blame] | 127 | HOST_TABLE_OF_DEVICES, |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 128 | }; |
| 129 | |
| 130 | static const char* tcpa_pc_event_id_strings[] = { |
Seiji Munetoh | de66a69 | 2006-05-30 21:25:47 -0700 | [diff] [blame] | 131 | "", |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 132 | "SMBIOS", |
| 133 | "BIS Certificate", |
| 134 | "POST BIOS ", |
| 135 | "ESCD ", |
| 136 | "CMOS", |
| 137 | "NVRAM", |
| 138 | "Option ROM", |
| 139 | "Option ROM config", |
Seiji Munetoh | de66a69 | 2006-05-30 21:25:47 -0700 | [diff] [blame] | 140 | "", |
| 141 | "Option ROM microcode ", |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 142 | "S-CRTM Version", |
Seiji Munetoh | de66a69 | 2006-05-30 21:25:47 -0700 | [diff] [blame] | 143 | "S-CRTM Contents ", |
| 144 | "POST Contents ", |
| 145 | "Table of Devices", |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 146 | }; |
| 147 | |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 148 | /* returns pointer to start of pos. entry of tcg log */ |
| 149 | static void *tpm_bios_measurements_start(struct seq_file *m, loff_t *pos) |
| 150 | { |
| 151 | loff_t i; |
Kylene Jo Hall | d09cf7d | 2006-01-08 01:03:48 -0800 | [diff] [blame] | 152 | struct tpm_bios_log *log = m->private; |
| 153 | void *addr = log->bios_event_log; |
| 154 | void *limit = log->bios_event_log_end; |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 155 | struct tcpa_event *event; |
| 156 | |
| 157 | /* read over *pos measurements */ |
| 158 | for (i = 0; i < *pos; i++) { |
| 159 | event = addr; |
| 160 | |
Kylene Jo Hall | d09cf7d | 2006-01-08 01:03:48 -0800 | [diff] [blame] | 161 | if ((addr + sizeof(struct tcpa_event)) < limit) { |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 162 | if (event->event_type == 0 && event->event_size == 0) |
| 163 | return NULL; |
Kylene Jo Hall | d09cf7d | 2006-01-08 01:03:48 -0800 | [diff] [blame] | 164 | addr += sizeof(struct tcpa_event) + event->event_size; |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 165 | } |
| 166 | } |
| 167 | |
| 168 | /* now check if current entry is valid */ |
Kylene Jo Hall | d09cf7d | 2006-01-08 01:03:48 -0800 | [diff] [blame] | 169 | if ((addr + sizeof(struct tcpa_event)) >= limit) |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 170 | return NULL; |
| 171 | |
| 172 | event = addr; |
| 173 | |
| 174 | if ((event->event_type == 0 && event->event_size == 0) || |
Kylene Jo Hall | d09cf7d | 2006-01-08 01:03:48 -0800 | [diff] [blame] | 175 | ((addr + sizeof(struct tcpa_event) + event->event_size) >= limit)) |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 176 | return NULL; |
| 177 | |
| 178 | return addr; |
| 179 | } |
| 180 | |
| 181 | static void *tpm_bios_measurements_next(struct seq_file *m, void *v, |
| 182 | loff_t *pos) |
| 183 | { |
| 184 | struct tcpa_event *event = v; |
Kylene Jo Hall | d09cf7d | 2006-01-08 01:03:48 -0800 | [diff] [blame] | 185 | struct tpm_bios_log *log = m->private; |
| 186 | void *limit = log->bios_event_log_end; |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 187 | |
| 188 | v += sizeof(struct tcpa_event) + event->event_size; |
| 189 | |
| 190 | /* now check if current entry is valid */ |
Kylene Jo Hall | d09cf7d | 2006-01-08 01:03:48 -0800 | [diff] [blame] | 191 | if ((v + sizeof(struct tcpa_event)) >= limit) |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 192 | return NULL; |
| 193 | |
| 194 | event = v; |
| 195 | |
| 196 | if (event->event_type == 0 && event->event_size == 0) |
| 197 | return NULL; |
| 198 | |
| 199 | if ((event->event_type == 0 && event->event_size == 0) || |
Kylene Jo Hall | d09cf7d | 2006-01-08 01:03:48 -0800 | [diff] [blame] | 200 | ((v + sizeof(struct tcpa_event) + event->event_size) >= limit)) |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 201 | return NULL; |
| 202 | |
| 203 | (*pos)++; |
| 204 | return v; |
| 205 | } |
| 206 | |
| 207 | static void tpm_bios_measurements_stop(struct seq_file *m, void *v) |
| 208 | { |
| 209 | } |
| 210 | |
| 211 | static int get_event_name(char *dest, struct tcpa_event *event, |
| 212 | unsigned char * event_entry) |
| 213 | { |
| 214 | const char *name = ""; |
| 215 | char data[40] = ""; |
| 216 | int i, n_len = 0, d_len = 0; |
Seiji Munetoh | de66a69 | 2006-05-30 21:25:47 -0700 | [diff] [blame] | 217 | struct tcpa_pc_event *pc_event; |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 218 | |
| 219 | switch(event->event_type) { |
| 220 | case PREBOOT: |
| 221 | case POST_CODE: |
| 222 | case UNUSED: |
| 223 | case NO_ACTION: |
| 224 | case SCRTM_CONTENTS: |
| 225 | case SCRTM_VERSION: |
| 226 | case CPU_MICROCODE: |
| 227 | case PLATFORM_CONFIG_FLAGS: |
| 228 | case TABLE_OF_DEVICES: |
| 229 | case COMPACT_HASH: |
| 230 | case IPL: |
| 231 | case IPL_PARTITION_DATA: |
| 232 | case NONHOST_CODE: |
| 233 | case NONHOST_CONFIG: |
| 234 | case NONHOST_INFO: |
| 235 | name = tcpa_event_type_strings[event->event_type]; |
| 236 | n_len = strlen(name); |
| 237 | break; |
| 238 | case SEPARATOR: |
| 239 | case ACTION: |
| 240 | if (MAX_TEXT_EVENT > event->event_size) { |
| 241 | name = event_entry; |
| 242 | n_len = event->event_size; |
| 243 | } |
| 244 | break; |
| 245 | case EVENT_TAG: |
Seiji Munetoh | de66a69 | 2006-05-30 21:25:47 -0700 | [diff] [blame] | 246 | pc_event = (struct tcpa_pc_event *)event_entry; |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 247 | |
| 248 | /* ToDo Row data -> Base64 */ |
| 249 | |
Seiji Munetoh | de66a69 | 2006-05-30 21:25:47 -0700 | [diff] [blame] | 250 | switch (pc_event->event_id) { |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 251 | case SMBIOS: |
| 252 | case BIS_CERT: |
| 253 | case CMOS: |
| 254 | case NVRAM: |
| 255 | case OPTION_ROM_EXEC: |
| 256 | case OPTION_ROM_CONFIG: |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 257 | case S_CRTM_VERSION: |
Seiji Munetoh | de66a69 | 2006-05-30 21:25:47 -0700 | [diff] [blame] | 258 | name = tcpa_pc_event_id_strings[pc_event->event_id]; |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 259 | n_len = strlen(name); |
| 260 | break; |
Seiji Munetoh | de66a69 | 2006-05-30 21:25:47 -0700 | [diff] [blame] | 261 | /* hash data */ |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 262 | case POST_BIOS_ROM: |
| 263 | case ESCD: |
Seiji Munetoh | de66a69 | 2006-05-30 21:25:47 -0700 | [diff] [blame] | 264 | case OPTION_ROM_MICROCODE: |
| 265 | case S_CRTM_CONTENTS: |
| 266 | case POST_CONTENTS: |
| 267 | name = tcpa_pc_event_id_strings[pc_event->event_id]; |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 268 | n_len = strlen(name); |
| 269 | for (i = 0; i < 20; i++) |
Seiji Munetoh | de66a69 | 2006-05-30 21:25:47 -0700 | [diff] [blame] | 270 | d_len += sprintf(&data[2*i], "%02x", |
| 271 | pc_event->event_data[i]); |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 272 | break; |
| 273 | default: |
| 274 | break; |
| 275 | } |
| 276 | default: |
| 277 | break; |
| 278 | } |
| 279 | |
| 280 | return snprintf(dest, MAX_TEXT_EVENT, "[%.*s%.*s]", |
| 281 | n_len, name, d_len, data); |
| 282 | |
| 283 | } |
| 284 | |
| 285 | static int tpm_binary_bios_measurements_show(struct seq_file *m, void *v) |
| 286 | { |
Seiji Munetoh | 44d7aff | 2006-05-30 21:25:52 -0700 | [diff] [blame] | 287 | struct tcpa_event *event = v; |
| 288 | char *data = v; |
| 289 | int i; |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 290 | |
Seiji Munetoh | 44d7aff | 2006-05-30 21:25:52 -0700 | [diff] [blame] | 291 | for (i = 0; i < sizeof(struct tcpa_event) + event->event_size; i++) |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 292 | seq_putc(m, data[i]); |
| 293 | |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 294 | return 0; |
| 295 | } |
| 296 | |
| 297 | static int tpm_bios_measurements_release(struct inode *inode, |
| 298 | struct file *file) |
| 299 | { |
Kylene Jo Hall | d09cf7d | 2006-01-08 01:03:48 -0800 | [diff] [blame] | 300 | struct seq_file *seq = file->private_data; |
| 301 | struct tpm_bios_log *log = seq->private; |
| 302 | |
| 303 | if (log) { |
| 304 | kfree(log->bios_event_log); |
| 305 | kfree(log); |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 306 | } |
Kylene Jo Hall | d09cf7d | 2006-01-08 01:03:48 -0800 | [diff] [blame] | 307 | |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 308 | return seq_release(inode, file); |
| 309 | } |
| 310 | |
| 311 | static int tpm_ascii_bios_measurements_show(struct seq_file *m, void *v) |
| 312 | { |
| 313 | int len = 0; |
| 314 | int i; |
| 315 | char *eventname; |
| 316 | struct tcpa_event *event = v; |
| 317 | unsigned char *event_entry = |
| 318 | (unsigned char *) (v + sizeof(struct tcpa_event)); |
| 319 | |
| 320 | eventname = kmalloc(MAX_TEXT_EVENT, GFP_KERNEL); |
| 321 | if (!eventname) { |
| 322 | printk(KERN_ERR "%s: ERROR - No Memory for event name\n ", |
| 323 | __func__); |
| 324 | return -EFAULT; |
| 325 | } |
| 326 | |
| 327 | seq_printf(m, "%2d ", event->pcr_index); |
| 328 | |
| 329 | /* 2nd: SHA1 */ |
| 330 | for (i = 0; i < 20; i++) |
| 331 | seq_printf(m, "%02x", event->pcr_value[i]); |
| 332 | |
| 333 | /* 3rd: event type identifier */ |
| 334 | seq_printf(m, " %02x", event->event_type); |
| 335 | |
| 336 | len += get_event_name(eventname, event, event_entry); |
| 337 | |
| 338 | /* 4th: eventname <= max + \'0' delimiter */ |
| 339 | seq_printf(m, " %s\n", eventname); |
| 340 | |
Kylene Jo Hall | 59e89f3 | 2006-04-22 02:36:35 -0700 | [diff] [blame] | 341 | kfree(eventname); |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 342 | return 0; |
| 343 | } |
| 344 | |
| 345 | static struct seq_operations tpm_ascii_b_measurments_seqops = { |
| 346 | .start = tpm_bios_measurements_start, |
| 347 | .next = tpm_bios_measurements_next, |
| 348 | .stop = tpm_bios_measurements_stop, |
| 349 | .show = tpm_ascii_bios_measurements_show, |
| 350 | }; |
| 351 | |
| 352 | static struct seq_operations tpm_binary_b_measurments_seqops = { |
| 353 | .start = tpm_bios_measurements_start, |
| 354 | .next = tpm_bios_measurements_next, |
| 355 | .stop = tpm_bios_measurements_stop, |
| 356 | .show = tpm_binary_bios_measurements_show, |
| 357 | }; |
| 358 | |
| 359 | /* read binary bios log */ |
Kylene Jo Hall | d09cf7d | 2006-01-08 01:03:48 -0800 | [diff] [blame] | 360 | static int read_log(struct tpm_bios_log *log) |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 361 | { |
| 362 | struct acpi_tcpa *buff; |
| 363 | acpi_status status; |
Kylene Jo Hall | 10296cb | 2006-02-01 03:05:04 -0800 | [diff] [blame] | 364 | struct acpi_table_header *virt; |
Kylene Jo Hall | 8b006db | 2006-04-22 02:39:07 -0700 | [diff] [blame] | 365 | u64 len, start; |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 366 | |
Kylene Jo Hall | d09cf7d | 2006-01-08 01:03:48 -0800 | [diff] [blame] | 367 | if (log->bios_event_log != NULL) { |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 368 | printk(KERN_ERR |
| 369 | "%s: ERROR - Eventlog already initialized\n", |
| 370 | __func__); |
| 371 | return -EFAULT; |
| 372 | } |
| 373 | |
| 374 | /* Find TCPA entry in RSDT (ACPI_LOGICAL_ADDRESSING) */ |
| 375 | status = acpi_get_firmware_table(ACPI_TCPA_SIG, 1, |
| 376 | ACPI_LOGICAL_ADDRESSING, |
| 377 | (struct acpi_table_header **) |
| 378 | &buff); |
| 379 | |
| 380 | if (ACPI_FAILURE(status)) { |
| 381 | printk(KERN_ERR "%s: ERROR - Could not get TCPA table\n", |
| 382 | __func__); |
| 383 | return -EIO; |
| 384 | } |
| 385 | |
Kylene Jo Hall | 8b006db | 2006-04-22 02:39:07 -0700 | [diff] [blame] | 386 | switch(buff->platform_class) { |
| 387 | case BIOS_SERVER: |
| 388 | len = buff->server.log_max_len; |
| 389 | start = buff->server.log_start_addr; |
| 390 | break; |
| 391 | case BIOS_CLIENT: |
| 392 | default: |
| 393 | len = buff->client.log_max_len; |
| 394 | start = buff->client.log_start_addr; |
| 395 | break; |
| 396 | } |
| 397 | if (!len) { |
Kylene Jo Hall | d09cf7d | 2006-01-08 01:03:48 -0800 | [diff] [blame] | 398 | printk(KERN_ERR "%s: ERROR - TCPA log area empty\n", __func__); |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 399 | return -EIO; |
| 400 | } |
| 401 | |
| 402 | /* malloc EventLog space */ |
Kylene Jo Hall | 8b006db | 2006-04-22 02:39:07 -0700 | [diff] [blame] | 403 | log->bios_event_log = kmalloc(len, GFP_KERNEL); |
Kylene Jo Hall | d09cf7d | 2006-01-08 01:03:48 -0800 | [diff] [blame] | 404 | if (!log->bios_event_log) { |
Kylene Jo Hall | 8b006db | 2006-04-22 02:39:07 -0700 | [diff] [blame] | 405 | printk("%s: ERROR - Not enough Memory for BIOS measurements\n", |
| 406 | __func__); |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 407 | return -ENOMEM; |
| 408 | } |
| 409 | |
Kylene Jo Hall | 8b006db | 2006-04-22 02:39:07 -0700 | [diff] [blame] | 410 | log->bios_event_log_end = log->bios_event_log + len; |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 411 | |
Kylene Jo Hall | 8b006db | 2006-04-22 02:39:07 -0700 | [diff] [blame] | 412 | acpi_os_map_memory(start, len, (void *) &virt); |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 413 | |
Kylene Jo Hall | 8b006db | 2006-04-22 02:39:07 -0700 | [diff] [blame] | 414 | memcpy(log->bios_event_log, virt, len); |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 415 | |
Kylene Jo Hall | 8b006db | 2006-04-22 02:39:07 -0700 | [diff] [blame] | 416 | acpi_os_unmap_memory(virt, len); |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 417 | return 0; |
| 418 | } |
| 419 | |
| 420 | static int tpm_ascii_bios_measurements_open(struct inode *inode, |
| 421 | struct file *file) |
| 422 | { |
| 423 | int err; |
Kylene Jo Hall | d09cf7d | 2006-01-08 01:03:48 -0800 | [diff] [blame] | 424 | struct tpm_bios_log *log; |
| 425 | struct seq_file *seq; |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 426 | |
Kylene Jo Hall | d09cf7d | 2006-01-08 01:03:48 -0800 | [diff] [blame] | 427 | log = kzalloc(sizeof(struct tpm_bios_log), GFP_KERNEL); |
| 428 | if (!log) |
| 429 | return -ENOMEM; |
| 430 | |
| 431 | if ((err = read_log(log))) |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 432 | return err; |
| 433 | |
| 434 | /* now register seq file */ |
Kylene Jo Hall | d09cf7d | 2006-01-08 01:03:48 -0800 | [diff] [blame] | 435 | err = seq_open(file, &tpm_ascii_b_measurments_seqops); |
| 436 | if (!err) { |
| 437 | seq = file->private_data; |
| 438 | seq->private = log; |
| 439 | } else { |
| 440 | kfree(log->bios_event_log); |
| 441 | kfree(log); |
| 442 | } |
| 443 | return err; |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 444 | } |
| 445 | |
| 446 | struct file_operations tpm_ascii_bios_measurements_ops = { |
| 447 | .open = tpm_ascii_bios_measurements_open, |
| 448 | .read = seq_read, |
| 449 | .llseek = seq_lseek, |
| 450 | .release = tpm_bios_measurements_release, |
| 451 | }; |
| 452 | |
| 453 | static int tpm_binary_bios_measurements_open(struct inode *inode, |
| 454 | struct file *file) |
| 455 | { |
| 456 | int err; |
Kylene Jo Hall | d09cf7d | 2006-01-08 01:03:48 -0800 | [diff] [blame] | 457 | struct tpm_bios_log *log; |
| 458 | struct seq_file *seq; |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 459 | |
Kylene Jo Hall | d09cf7d | 2006-01-08 01:03:48 -0800 | [diff] [blame] | 460 | log = kzalloc(sizeof(struct tpm_bios_log), GFP_KERNEL); |
| 461 | if (!log) |
| 462 | return -ENOMEM; |
| 463 | |
| 464 | if ((err = read_log(log))) |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 465 | return err; |
| 466 | |
| 467 | /* now register seq file */ |
Kylene Jo Hall | d09cf7d | 2006-01-08 01:03:48 -0800 | [diff] [blame] | 468 | err = seq_open(file, &tpm_binary_b_measurments_seqops); |
| 469 | if (!err) { |
| 470 | seq = file->private_data; |
| 471 | seq->private = log; |
| 472 | } else { |
| 473 | kfree(log->bios_event_log); |
| 474 | kfree(log); |
| 475 | } |
| 476 | return err; |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 477 | } |
| 478 | |
| 479 | struct file_operations tpm_binary_bios_measurements_ops = { |
| 480 | .open = tpm_binary_bios_measurements_open, |
| 481 | .read = seq_read, |
| 482 | .llseek = seq_lseek, |
| 483 | .release = tpm_bios_measurements_release, |
| 484 | }; |
| 485 | |
Andrew Morton | ca4a031f | 2006-02-01 03:05:01 -0800 | [diff] [blame] | 486 | static int is_bad(void *p) |
| 487 | { |
| 488 | if (!p) |
| 489 | return 1; |
| 490 | if (IS_ERR(p) && (PTR_ERR(p) != -ENODEV)) |
| 491 | return 1; |
| 492 | return 0; |
| 493 | } |
| 494 | |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 495 | struct dentry **tpm_bios_log_setup(char *name) |
| 496 | { |
| 497 | struct dentry **ret = NULL, *tpm_dir, *bin_file, *ascii_file; |
| 498 | |
| 499 | tpm_dir = securityfs_create_dir(name, NULL); |
Andrew Morton | ca4a031f | 2006-02-01 03:05:01 -0800 | [diff] [blame] | 500 | if (is_bad(tpm_dir)) |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 501 | goto out; |
| 502 | |
| 503 | bin_file = |
| 504 | securityfs_create_file("binary_bios_measurements", |
| 505 | S_IRUSR | S_IRGRP, tpm_dir, NULL, |
| 506 | &tpm_binary_bios_measurements_ops); |
Andrew Morton | ca4a031f | 2006-02-01 03:05:01 -0800 | [diff] [blame] | 507 | if (is_bad(bin_file)) |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 508 | goto out_tpm; |
| 509 | |
| 510 | ascii_file = |
| 511 | securityfs_create_file("ascii_bios_measurements", |
| 512 | S_IRUSR | S_IRGRP, tpm_dir, NULL, |
| 513 | &tpm_ascii_bios_measurements_ops); |
Andrew Morton | ca4a031f | 2006-02-01 03:05:01 -0800 | [diff] [blame] | 514 | if (is_bad(ascii_file)) |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 515 | goto out_bin; |
| 516 | |
| 517 | ret = kmalloc(3 * sizeof(struct dentry *), GFP_KERNEL); |
| 518 | if (!ret) |
| 519 | goto out_ascii; |
| 520 | |
| 521 | ret[0] = ascii_file; |
| 522 | ret[1] = bin_file; |
| 523 | ret[2] = tpm_dir; |
| 524 | |
| 525 | return ret; |
| 526 | |
| 527 | out_ascii: |
| 528 | securityfs_remove(ascii_file); |
| 529 | out_bin: |
| 530 | securityfs_remove(bin_file); |
| 531 | out_tpm: |
| 532 | securityfs_remove(tpm_dir); |
| 533 | out: |
| 534 | return NULL; |
| 535 | } |
| 536 | EXPORT_SYMBOL_GPL(tpm_bios_log_setup); |
| 537 | |
| 538 | void tpm_bios_log_teardown(struct dentry **lst) |
| 539 | { |
| 540 | int i; |
| 541 | |
| 542 | for (i = 0; i < 3; i++) |
| 543 | securityfs_remove(lst[i]); |
| 544 | } |
| 545 | EXPORT_SYMBOL_GPL(tpm_bios_log_teardown); |
Kylene Jo Hall | 7bcee5b | 2006-02-01 03:05:03 -0800 | [diff] [blame] | 546 | MODULE_LICENSE("GPL"); |