Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * Copyright (C) 2017 Google, Inc.
       4                 :            :  *     Thiebaud Weksteen <tweek@google.com>
       5                 :            :  */
       6                 :            : 
       7                 :            : #define TPM_MEMREMAP(start, size) early_memremap(start, size)
       8                 :            : #define TPM_MEMUNMAP(start, size) early_memunmap(start, size)
       9                 :            : 
      10                 :            : #include <asm/early_ioremap.h>
      11                 :            : #include <linux/efi.h>
      12                 :            : #include <linux/init.h>
      13                 :            : #include <linux/memblock.h>
      14                 :            : #include <linux/tpm_eventlog.h>
      15                 :            : 
      16                 :            : int efi_tpm_final_log_size;
      17                 :            : EXPORT_SYMBOL(efi_tpm_final_log_size);
      18                 :            : 
      19                 :          0 : static int tpm2_calc_event_log_size(void *data, int count, void *size_info)
      20                 :            : {
      21                 :          0 :         struct tcg_pcr_event2_head *header;
      22                 :          0 :         int event_size, size = 0;
      23                 :            : 
      24         [ #  # ]:          0 :         while (count > 0) {
      25                 :          0 :                 header = data + size;
      26                 :          0 :                 event_size = __calc_tpm2_event_size(header, size_info, true);
      27         [ #  # ]:          0 :                 if (event_size == 0)
      28                 :            :                         return -1;
      29                 :          0 :                 size += event_size;
      30                 :          0 :                 count--;
      31                 :            :         }
      32                 :            : 
      33                 :            :         return size;
      34                 :            : }
      35                 :            : 
      36                 :            : /*
      37                 :            :  * Reserve the memory associated with the TPM Event Log configuration table.
      38                 :            :  */
      39                 :          0 : int __init efi_tpm_eventlog_init(void)
      40                 :            : {
      41                 :          0 :         struct linux_efi_tpm_eventlog *log_tbl;
      42                 :          0 :         struct efi_tcg2_final_events_table *final_tbl;
      43                 :          0 :         int tbl_size;
      44                 :          0 :         int ret = 0;
      45                 :            : 
      46         [ #  # ]:          0 :         if (efi.tpm_log == EFI_INVALID_TABLE_ADDR) {
      47                 :            :                 /*
      48                 :            :                  * We can't calculate the size of the final events without the
      49                 :            :                  * first entry in the TPM log, so bail here.
      50                 :            :                  */
      51                 :            :                 return 0;
      52                 :            :         }
      53                 :            : 
      54                 :          0 :         log_tbl = early_memremap(efi.tpm_log, sizeof(*log_tbl));
      55         [ #  # ]:          0 :         if (!log_tbl) {
      56                 :          0 :                 pr_err("Failed to map TPM Event Log table @ 0x%lx\n",
      57                 :            :                        efi.tpm_log);
      58                 :          0 :                 efi.tpm_log = EFI_INVALID_TABLE_ADDR;
      59                 :          0 :                 return -ENOMEM;
      60                 :            :         }
      61                 :            : 
      62                 :          0 :         tbl_size = sizeof(*log_tbl) + log_tbl->size;
      63                 :          0 :         memblock_reserve(efi.tpm_log, tbl_size);
      64                 :            : 
      65         [ #  # ]:          0 :         if (efi.tpm_final_log == EFI_INVALID_TABLE_ADDR)
      66                 :          0 :                 goto out;
      67                 :            : 
      68                 :          0 :         final_tbl = early_memremap(efi.tpm_final_log, sizeof(*final_tbl));
      69                 :            : 
      70         [ #  # ]:          0 :         if (!final_tbl) {
      71                 :          0 :                 pr_err("Failed to map TPM Final Event Log table @ 0x%lx\n",
      72                 :            :                        efi.tpm_final_log);
      73                 :          0 :                 efi.tpm_final_log = EFI_INVALID_TABLE_ADDR;
      74                 :          0 :                 ret = -ENOMEM;
      75                 :          0 :                 goto out;
      76                 :            :         }
      77                 :            : 
      78                 :          0 :         tbl_size = 0;
      79         [ #  # ]:          0 :         if (final_tbl->nr_events != 0) {
      80                 :          0 :                 void *events = (void *)efi.tpm_final_log
      81                 :            :                                 + sizeof(final_tbl->version)
      82                 :          0 :                                 + sizeof(final_tbl->nr_events);
      83                 :            : 
      84                 :          0 :                 tbl_size = tpm2_calc_event_log_size(events,
      85                 :            :                                                     final_tbl->nr_events,
      86                 :          0 :                                                     log_tbl->log);
      87                 :            :         }
      88                 :            : 
      89         [ #  # ]:          0 :         if (tbl_size < 0) {
      90                 :          0 :                 pr_err(FW_BUG "Failed to parse event in TPM Final Events Log\n");
      91                 :          0 :                 ret = -EINVAL;
      92                 :          0 :                 goto out_calc;
      93                 :            :         }
      94                 :            : 
      95                 :          0 :         memblock_reserve((unsigned long)final_tbl,
      96                 :          0 :                          tbl_size + sizeof(*final_tbl));
      97                 :          0 :         efi_tpm_final_log_size = tbl_size;
      98                 :            : 
      99                 :          0 : out_calc:
     100                 :          0 :         early_memunmap(final_tbl, sizeof(*final_tbl));
     101                 :          0 : out:
     102                 :          0 :         early_memunmap(log_tbl, sizeof(*log_tbl));
     103                 :          0 :         return ret;
     104                 :            : }
     105                 :            :