247 lines
9.7 KiB
C++
247 lines
9.7 KiB
C++
/* IBM_PROLOG_BEGIN_TAG */
|
|
/* This is an automatically generated prolog. */
|
|
/* */
|
|
/* $Source: src/usr/secureboot/trusted/tpmLogMgr.H $ */
|
|
/* */
|
|
/* OpenPOWER HostBoot Project */
|
|
/* */
|
|
/* Contributors Listed Below - COPYRIGHT 2015,2016 */
|
|
/* [+] International Business Machines Corp. */
|
|
/* */
|
|
/* */
|
|
/* Licensed under the Apache License, Version 2.0 (the "License"); */
|
|
/* you may not use this file except in compliance with the License. */
|
|
/* You may obtain a copy of the License at */
|
|
/* */
|
|
/* http://www.apache.org/licenses/LICENSE-2.0 */
|
|
/* */
|
|
/* Unless required by applicable law or agreed to in writing, software */
|
|
/* distributed under the License is distributed on an "AS IS" BASIS, */
|
|
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or */
|
|
/* implied. See the License for the specific language governing */
|
|
/* permissions and limitations under the License. */
|
|
/* */
|
|
/* IBM_PROLOG_END_TAG */
|
|
/**
|
|
* @file tpmLogMgr.H
|
|
*
|
|
* @brief Trustedboot TPM Event Log Manager
|
|
*
|
|
*/
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
// NOTE: This file is exportable as TSS-Lite for skiboot/PHYP //
|
|
/////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef __TPMLOGMGR_H
|
|
#define __TPMLOGMGR_H
|
|
// -----------------------------------------------
|
|
// Includes
|
|
// -----------------------------------------------
|
|
|
|
#ifdef __HOSTBOOT_MODULE
|
|
#include <sys/sync.h>
|
|
#endif
|
|
#include "trustedboot.H"
|
|
#include "trustedTypes.H"
|
|
|
|
#ifdef __cplusplus
|
|
namespace TRUSTEDBOOT
|
|
{
|
|
#endif
|
|
|
|
/// Event log header algorithms
|
|
struct _TCG_EfiSpecIdEventAlgorithmSize
|
|
{
|
|
uint16_t algorithmId;
|
|
uint16_t digestSize;
|
|
} PACKED;
|
|
typedef struct _TCG_EfiSpecIdEventAlgorithmSize
|
|
TCG_EfiSpecIdEventAlgorithmSize;
|
|
|
|
/// Event log header event data
|
|
struct _TCG_EfiSpecIdEventStruct
|
|
{
|
|
char signature[16];
|
|
uint32_t platformClass;
|
|
uint8_t specVersionMinor;
|
|
uint8_t specVersionMajor;
|
|
uint8_t specErrata;
|
|
uint8_t uintnSize;
|
|
uint32_t numberOfAlgorithms;
|
|
TCG_EfiSpecIdEventAlgorithmSize digestSizes[HASH_COUNT];
|
|
uint8_t vendorInfoSize;
|
|
char vendorInfo[0];
|
|
} PACKED;
|
|
typedef struct _TCG_EfiSpecIdEventStruct TCG_EfiSpecIdEventStruct;
|
|
uint32_t TCG_EfiSpecIdEventStruct_size(TCG_EfiSpecIdEventStruct* val);
|
|
|
|
enum {
|
|
TPMLOG_BUFFER_SIZE = 3584, ///< Size of event log buffer for HB
|
|
TPMLOG_DEVTREE_SIZE = 64*1024, ///< Size to allocate for OPAL
|
|
};
|
|
|
|
struct _TpmLogMgr
|
|
{
|
|
uint32_t logSize; ///< Current byte size of log
|
|
uint32_t logMaxSize; ///< Space allocated for log entries
|
|
uint8_t* newEventPtr; ///< Pointer to location to add new event
|
|
uint8_t* eventLogInMem; ///< Event log allocated from memory
|
|
#ifdef __HOSTBOOT_MODULE
|
|
uint64_t inMemlogBaseAddr; ///< Base address of log for dev tree
|
|
uint64_t devtreeXscomAddr; ///< Devtree Xscom Address
|
|
uint32_t devtreeI2cMasterOffset; ///< Devtree I2c Master Offset
|
|
uint8_t eventLog[TPMLOG_BUFFER_SIZE]; ///< EventLog Buffer
|
|
#endif
|
|
mutex_t logMutex; ///< Log mutex
|
|
};
|
|
typedef struct _TpmLogMgr TpmLogMgr;
|
|
|
|
#ifdef __HOSTBOOT_MODULE
|
|
/**
|
|
* @brief Initialize the log manager
|
|
* @param[in/out] io_logMgr Return a pointer to the log manager
|
|
* @return errlHndl_t NULL if successful, otherwise a pointer to the
|
|
* error log.
|
|
*/
|
|
errlHndl_t TpmLogMgr_initialize(TpmLogMgr * io_logMgr);
|
|
#endif
|
|
|
|
/**
|
|
* @brief Initialize the log manager to use a pre-existing buffer
|
|
* @param[in] val TpmLogMgr structure
|
|
* @param[in] eventLogPtr Pointer to event log to use
|
|
* @param[in] eventLogSize Allocated log buffer size
|
|
* @return errlHndl_t NULL if successful, otherwise a pointer to the
|
|
* error log.
|
|
*/
|
|
errlHndl_t TpmLogMgr_initializeUsingExistingLog(TpmLogMgr* val,
|
|
uint8_t* eventLogPtr,
|
|
uint32_t eventLogSize);
|
|
|
|
/**
|
|
* @brief Add a new event to the log
|
|
* @param[in] val TpmLogMgr structure
|
|
* @param[in] logEvent Event log entry to add
|
|
* @return errlHndl_t NULL if successful, otherwise a pointer to the
|
|
* error log.
|
|
*/
|
|
errlHndl_t TpmLogMgr_addEvent(TpmLogMgr* val, TCG_PCR_EVENT2* logEvent);
|
|
|
|
/**
|
|
* @brief Get current log size in bytes
|
|
* @param[in] val TpmLogMgr structure
|
|
* @return uint32_t Byte size of log
|
|
*/
|
|
uint32_t TpmLogMgr_getLogSize(TpmLogMgr* val);
|
|
|
|
#ifdef __HOSTBOOT_MODULE
|
|
/**
|
|
* @brief Retrieve devtree information
|
|
* @param[in] val TpmLogMgr structure
|
|
* @param[in/out] io_logAddr TPM Log address
|
|
* @param[out] o_allocationSize Total memory allocated for log
|
|
* @param[out] o_xscomAddr Chip Xscom Address
|
|
* @param[out] o_i2cMasterOffset I2c Master Offset
|
|
* @return errlHndl_t NULL if successful, otherwise a pointer to the
|
|
* error log.
|
|
* Function will allocate a new region in memory to store log
|
|
* for passing to opal
|
|
*/
|
|
errlHndl_t TpmLogMgr_getDevtreeInfo(TpmLogMgr* val,
|
|
uint64_t & io_logAddr,
|
|
size_t & o_allocationSize,
|
|
uint64_t & o_xscomAddr,
|
|
uint32_t & o_i2cMasterOffset);
|
|
|
|
/**
|
|
* @brief Store TPM devtree node information
|
|
* @param[in] val TpmLogMgr structure
|
|
* @param[in] i_xscomAddr Chip Xscom Address
|
|
* @param[in] i_i2cMasterOffset i2c Master Offset
|
|
*/
|
|
void TpmLogMgr_setTpmDevtreeInfo(TpmLogMgr* val,
|
|
uint64_t i_xscomAddr,
|
|
uint32_t i_i2cMasterOffset);
|
|
#endif
|
|
|
|
|
|
/**
|
|
* @brief Calculate the log size in bytes by walking the log
|
|
* @param[in] val TpmLogMgr structure
|
|
* @return uint32_t Byte size of log
|
|
*/
|
|
uint32_t TpmLogMgr_calcLogSize(TpmLogMgr* val);
|
|
|
|
/**
|
|
* @brief Get pointer to first event in eventLog past the header event
|
|
* @param[in] val TpmLogMgr structure
|
|
* @return uint8_t First event handle
|
|
* @retval NULL On empty log
|
|
* @retval !NULL First event handle
|
|
*/
|
|
const uint8_t* TpmLogMgr_getFirstEvent(TpmLogMgr* val);
|
|
|
|
/**
|
|
* @brief Get pointer to next event in log and unmarshal log contents
|
|
* into i_eventLog
|
|
*
|
|
* @param[in] i_handle Current event to unmarshal
|
|
* @param[in] i_eventLog EVENT2 structure to populate
|
|
* @param[in] o_err Indicates if an error occurred during
|
|
* LogUnmarshal.
|
|
*
|
|
* @return uint8_t* Pointer to the next event after i_handle
|
|
* @retval NULL When val contains last entry in log
|
|
* @retval !NULL When addition log entries available
|
|
*/
|
|
const uint8_t* TpmLogMgr_getNextEvent(TpmLogMgr* val,
|
|
const uint8_t* i_handle,
|
|
TCG_PCR_EVENT2* i_eventLog,
|
|
bool* o_err);
|
|
|
|
/**
|
|
* @brief Get a TCG_PCR_EVENT2 populated with required data
|
|
*
|
|
* @param[in] i_pcr PCR to write to
|
|
* @param[in] i_algId_1 Algorithm to use
|
|
* @param[in] i_digest_1 Digest value to write to PCR
|
|
* @param[in] i_digestSize_1 Byte size of i_digest array
|
|
* @param[in] i_algId_2 Algorithm to use
|
|
* @param[in] i_digest_2 Digest value to write to PCR, NULL if not used
|
|
* @param[in] i_digestSize_2 Byte size of i_digest array
|
|
* @param[in] i_logType Event type
|
|
* @param[in] i_logMsg Null terminated Log message
|
|
*
|
|
* @return TCG_PCR_EVENT2 PCR event log
|
|
*/
|
|
TCG_PCR_EVENT2 TpmLogMgr_genLogEventPcrExtend(TPM_Pcr i_pcr,
|
|
TPM_Alg_Id i_algId_1,
|
|
const uint8_t* i_digest_1,
|
|
size_t i_digestSize_1,
|
|
TPM_Alg_Id i_algId_2,
|
|
const uint8_t* i_digest_2,
|
|
size_t i_digestSize_2,
|
|
uint32_t i_logType,
|
|
const char* i_logMsg);
|
|
#ifdef __HOSTBOOT_MODULE
|
|
/**
|
|
* @brief Dump contents of log to a trace
|
|
* @param[in] val TpmLogMgr structure
|
|
*/
|
|
void TpmLogMgr_dumpLog(TpmLogMgr* val);
|
|
#endif
|
|
|
|
/**
|
|
* @brief Return a pointer to the start of the log
|
|
* @param[in] val TpmLogMgr structure
|
|
* @return uint8_t* Pointer to the start of the TPM log
|
|
*/
|
|
uint8_t* TpmLogMgr_getLogStartPtr(TpmLogMgr* val);
|
|
|
|
|
|
#ifdef __cplusplus
|
|
} // end TRUSTEDBOOT namespace
|
|
#endif
|
|
|
|
#endif
|