mirror of
https://github.com/CloverHackyColor/CloverBootloader.git
synced 2024-09-21 02:51:04 +02:00
377 lines
12 KiB
C++
377 lines
12 KiB
C++
/*
|
|
* BootLog.c
|
|
*
|
|
*
|
|
* Created by Slice on 19.08.11.
|
|
* Edited by apianti 2012-09-08
|
|
* Initial idea from Kabyl
|
|
*/
|
|
|
|
|
|
#include <Platform.h> // Only use angled for Platform, else, xcode project won't compile
|
|
//#include <Library/MemLogLib.h>
|
|
#include "../Platform/DataHubCpu.h"
|
|
#include "../Platform/Settings.h"
|
|
#include "../Settings/Self.h"
|
|
#include "../Platform/guid.h"
|
|
|
|
#ifndef DEBUG_ALL
|
|
#define DEBUG_BOOTLOG 0
|
|
#else
|
|
#define DEBUG_BOOTLOG DEBUG_ALL
|
|
#endif
|
|
|
|
#if DEBUG_BOOTLOG == 0
|
|
#define DBG(...)
|
|
#else
|
|
#define DBG(...) DebugLog (DEBUG_BOOTLOG, __VA_ARGS__)
|
|
#endif
|
|
|
|
|
|
//void EFIAPI MemLogCallback(IN INTN DebugMode, IN CHAR8 *LastMessage);
|
|
//
|
|
//
|
|
///** Prints Number of bytes in a row (hex and ascii). Row size is MaxNumber. */
|
|
//void
|
|
//PrintBytesRow(IN UINT8 *Bytes, IN UINTN Number, IN UINTN MaxNumber)
|
|
//{
|
|
// UINTN Index;
|
|
//
|
|
// // print hex vals
|
|
// for (Index = 0; Index < Number; Index++) {
|
|
// DebugLog(1, "%02hhX ", Bytes[Index]);
|
|
// }
|
|
//
|
|
// // pad to MaxNumber if needed
|
|
// for (; Index < MaxNumber; Index++) {
|
|
// DebugLog(1, " ");
|
|
// }
|
|
//
|
|
// DebugLog(1, "| ");
|
|
//
|
|
// // print ASCII
|
|
// for (Index = 0; Index < Number; Index++) {
|
|
// if (Bytes[Index] >= 0x20 && Bytes[Index] <= 0x7e) {
|
|
// DebugLog(1, "%c", (CHAR16)Bytes[Index]);
|
|
// } else {
|
|
// DebugLog(1, "%c", L'.');
|
|
// }
|
|
// }
|
|
//
|
|
// DebugLog(1, "\n");
|
|
//}
|
|
//
|
|
///** Prints series of bytes. */
|
|
//void
|
|
//PrintBytes(IN void *Bytes, IN UINTN Number)
|
|
//{
|
|
// UINTN Index;
|
|
//
|
|
// for (Index = 0; Index < Number; Index += 16) {
|
|
// PrintBytesRow((UINT8*)Bytes + Index, ((Index + 16 < Number) ? 16 : (Number - Index)), 16);
|
|
// }
|
|
//}
|
|
//
|
|
//static XStringW debugLogFileName;
|
|
//static EFI_FILE_PROTOCOL* gLogFile = NULL;
|
|
//// Do not keep a pointer to MemLogBuffer. Because a reallocation, it could become invalid.
|
|
//
|
|
//int g_OpeningLogFile = 0;
|
|
//
|
|
//
|
|
//// Avoid debug looping. TO be able to call DBG from inside function that DBG calls, we need to suspend callback to avoid a loop.
|
|
//// Just instanciante this, the destructor will restore the callback.
|
|
//class SuspendMemLogCallback
|
|
//{
|
|
// MEM_LOG_CALLBACK memlogCallBack_saved = NULL;
|
|
//public:
|
|
// SuspendMemLogCallback() {
|
|
// memlogCallBack_saved = GetMemLogCallback();
|
|
// SetMemLogCallback(NULL);
|
|
// };
|
|
// ~SuspendMemLogCallback() { SetMemLogCallback(memlogCallBack_saved); };
|
|
//};
|
|
//
|
|
//#if DEBUG_BOOTLOG == 0
|
|
//#define DGB_nbCallback(...)
|
|
//#else
|
|
//#define DGB_nbCallback(...) do { SuspendMemLogCallback smc; DBG(__VA_ARGS__); } while (0)
|
|
//#endif
|
|
//
|
|
//void closeDebugLog()
|
|
//{
|
|
//// EFI_STATUS Status;
|
|
//
|
|
// if ( !gLogFile ) return;
|
|
//
|
|
// SuspendMemLogCallback smc;
|
|
//
|
|
// /*Status =*/ gLogFile->Close(gLogFile);
|
|
// gLogFile = NULL;
|
|
// //DGB_nbCallback("closeDebugLog() -> %s\n", efiStrError(Status));
|
|
//}
|
|
//
|
|
///*
|
|
// * Use (or not) self.getCloverDir() to open log file.
|
|
// * Not using self has the advantage of being able to generate a log even after uninitreflib().
|
|
// * The only thing needed is gImageHandle. But because it's a parameter to main entry point, value can't be wrong.
|
|
// * Drawback is that code to find current working directory has to be duplicated.
|
|
// */
|
|
////#define USE_SELF_INSTANCE
|
|
//static UINTN GetDebugLogFile()
|
|
//{
|
|
// EFI_STATUS Status;
|
|
// EFI_FILE_PROTOCOL *LogFile;
|
|
//
|
|
// if ( gLogFile ) return 0;
|
|
//
|
|
// #ifdef USE_SELF_INSTANCE
|
|
// if ( !self.isInitialized() ) return 0;
|
|
// #endif
|
|
//
|
|
// g_OpeningLogFile = 1;
|
|
//
|
|
// EFI_TIME Now;
|
|
// Status = gRT->GetTime(&Now, NULL);
|
|
// if ( EFI_ERROR(Status) ) {
|
|
// DBG("GetTime return %s\n", efiStrError(Status));
|
|
// }
|
|
//
|
|
// #ifdef USE_SELF_INSTANCE
|
|
// const EFI_FILE_PROTOCOL& CloverDir = self.getCloverDir();
|
|
// const XString& efiFileName = self.getCloverEfiFileName();
|
|
// #else
|
|
// XStringW efiFileName;
|
|
// const EFI_FILE_PROTOCOL* CloverDirPtr = Self::getCloverDirAndEfiFileName(gImageHandle, &efiFileName);
|
|
// if ( CloverDirPtr == NULL ) return 0;
|
|
// const EFI_FILE_PROTOCOL& CloverDir = *CloverDirPtr;
|
|
// #endif
|
|
//
|
|
// if ( debugLogFileName.isEmpty() )
|
|
// {
|
|
// debugLogFileName = S8Printf("misc\\%04d-%02d-%02d_%02d-%02d_%ls.log", Now.Year, Now.Month, Now.Day, Now.Hour, Now.Minute, efiFileName.wc_str());
|
|
// Status = CloverDir.Open(&CloverDir, &LogFile, debugLogFileName.wc_str(), EFI_FILE_MODE_READ, 0);
|
|
// if ( !EFI_ERROR(Status) ) LogFile->Close(LogFile); // DO NOT modify Status here.
|
|
// INTN i=1;
|
|
// while ( Status != EFI_NOT_FOUND && (i < MAX_INTN) ) {
|
|
// debugLogFileName = S8Printf("misc\\%04d-%02d-%02d_%02d-%02d_%ls(%lld).log", Now.Year, Now.Month, Now.Day, Now.Hour, Now.Minute, efiFileName.wc_str(), i);
|
|
// Status = CloverDir.Open(&CloverDir, &LogFile, debugLogFileName.wc_str(), EFI_FILE_MODE_READ, 0);
|
|
// if ( !EFI_ERROR(Status) ) LogFile->Close(LogFile); // DO NOT modify Status here.
|
|
// }
|
|
// if ( Status != EFI_NOT_FOUND ) {
|
|
// DBG("Cannot find a free debug log file name\n"); // I can't imagine that to happen...
|
|
// debugLogFileName.setEmpty(); // To allow to retry at the next call
|
|
// g_OpeningLogFile = 0;
|
|
// return 0;
|
|
// }
|
|
// Status = CloverDir.Open(&CloverDir, &LogFile, debugLogFileName.wc_str(), EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE, 0);
|
|
// gLogFile = LogFile;
|
|
// g_OpeningLogFile = 0;
|
|
// return 0;
|
|
// }else{
|
|
// Status = CloverDir.Open(&CloverDir, &LogFile, debugLogFileName.wc_str(), EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE, 0);
|
|
// g_OpeningLogFile = 0;
|
|
//
|
|
////// Jief : Instead of EfiLibFileInfo, let's use SetPosition to get the size.
|
|
//// if (!EFI_ERROR(Status)) {
|
|
//// EFI_FILE_INFO *Info = EfiLibFileInfo(LogFile);
|
|
//// if (Info) {
|
|
//// Status = LogFile->SetPosition(LogFile, Info->FileSize);
|
|
//// if ( EFI_ERROR(Status) ) {
|
|
//// DBG("SaveMessageToDebugLogFile SetPosition error %s\n", efiStrError(Status));
|
|
//// }
|
|
//// }
|
|
//// }
|
|
//
|
|
// if (!EFI_ERROR(Status)) {
|
|
// Status = LogFile->SetPosition(LogFile, 0xFFFFFFFFFFFFFFFFULL);
|
|
// if ( EFI_ERROR (Status) ) {
|
|
// DGB_nbCallback("GetDebugLogFile() -> Cannot set log position to 0xFFFFFFFFFFFFFFFFULL : %s\n", efiStrError(Status));
|
|
// LogFile->Close(LogFile);
|
|
// }else{
|
|
// UINTN size;
|
|
// Status = LogFile->GetPosition(LogFile, &size);
|
|
// if ( EFI_ERROR (Status) ) {
|
|
// DGB_nbCallback("GetDebugLogFile() -> Cannot get log position : %s\n", efiStrError(Status));
|
|
// LogFile->Close(LogFile);
|
|
// }else{
|
|
// //DGB_nbCallback("GetDebugLogFile() -> opened. log position = %lld (lwo %lld)\n", size, lastWrittenOffset);
|
|
// gLogFile = LogFile;
|
|
// return size;
|
|
// }
|
|
// }
|
|
// }
|
|
// return 0;
|
|
// }
|
|
//}
|
|
//
|
|
//VOID SaveMessageToDebugLogFile(IN CHAR8 *LastMessage)
|
|
//{
|
|
// EFI_STATUS Status;
|
|
//
|
|
// UINTN lastWrittenOffset = GetDebugLogFile();
|
|
//
|
|
// if ( gLogFile == NULL ) return;
|
|
//
|
|
// // Write out this message
|
|
// const char* lastWrittenPointer = GetMemLogBuffer() + lastWrittenOffset;
|
|
// UINTN TextLen = strlen(lastWrittenPointer);
|
|
// UINTN TextLen2 = TextLen;
|
|
//
|
|
// Status = gLogFile->Write(gLogFile, &TextLen2, lastWrittenPointer);
|
|
// lastWrittenOffset += TextLen2;
|
|
// if ( EFI_ERROR(Status) ) {
|
|
// DGB_nbCallback("SaveMessageToDebugLogFile write error %s\n", efiStrError(Status));
|
|
// closeDebugLog();
|
|
// }else{
|
|
// if ( TextLen2 != TextLen ) {
|
|
// DGB_nbCallback("SaveMessageToDebugLogFile TextLen2(%lld) != TextLen(%lld)\n", TextLen2, TextLen);
|
|
// closeDebugLog();
|
|
// }else{
|
|
// // Not all Firmware implements Flush. So we have to close everytime to force flush. Let's Close() instead of Flush()
|
|
// // Is there a performance difference ? Is it worth to create a setting ? Probably not...
|
|
//// Status = LogFile->Flush(LogFile);
|
|
//// if ( EFI_ERROR(Status) ) {
|
|
//// DGB_nbCallback("SaveMessageToDebugLogFile Cannot flush error %s\n", efiStrError(Status));
|
|
//// closeDebugLog();
|
|
//// }
|
|
// }
|
|
// }
|
|
// // Not all Firmware implements Flush. So we have to close every time to force flush.
|
|
// closeDebugLog();
|
|
//}
|
|
//
|
|
//void EFIAPI MemLogCallback(IN INTN DebugMode, IN CHAR8 *LastMessage)
|
|
//{
|
|
// // Print message to console
|
|
// if (DebugMode >= 2) {
|
|
// printf("%s", LastMessage);
|
|
// }
|
|
//
|
|
// if ((DebugMode >= 1) && gSettings.Boot.DebugLog) {
|
|
// SuspendMemLogCallback smc;
|
|
// SaveMessageToDebugLogFile(LastMessage);
|
|
// }
|
|
//}
|
|
//
|
|
//// Changed MsgLog(...) it now calls this function
|
|
//// with DebugMode == 0. - apianti
|
|
//// DebugMode==0 Prints to msg log, only output to log on SaveBooterLog
|
|
//// DebugMode==1 Prints to msg log and DEBUG_LOG
|
|
//// DebugMode==2 Prints to msg log, DEBUG_LOG and display console
|
|
//void EFIAPI DebugLog(IN INTN DebugMode, IN CONST CHAR8 *FormatString, ...)
|
|
//{
|
|
// VA_LIST Marker;
|
|
// //UINTN offset = 0;
|
|
//
|
|
// // Make sure the buffer is intact for writing
|
|
// if (FormatString == NULL || DebugMode < 0) {
|
|
// return;
|
|
// }
|
|
//
|
|
// // Print message to log buffer
|
|
// VA_START(Marker, FormatString);
|
|
// MemLogfVA(true, DebugMode, FormatString, Marker);
|
|
// VA_END(Marker);
|
|
//}
|
|
void EFIAPI DebugLog(IN INTN DebugMode, IN CONST CHAR8 *FormatString, ...)
|
|
{
|
|
// if ( !gEnableCloverLog ) return;
|
|
|
|
VA_LIST Marker;
|
|
// Make sure the buffer is intact for writing
|
|
if (FormatString == NULL || DebugMode < 0) {
|
|
return;
|
|
}
|
|
|
|
// Print message to log buffer
|
|
VA_START(Marker, FormatString);
|
|
#if __WCHAR_MAX__ < 0xffff
|
|
#else
|
|
vprintf(FormatString, Marker);
|
|
#endif
|
|
VA_END(Marker);
|
|
}
|
|
//
|
|
//void InitBooterLog(void)
|
|
//{
|
|
// SetMemLogCallback(MemLogCallback);
|
|
//}
|
|
//
|
|
//
|
|
//EFI_STATUS SetupBooterLog(XBool AllowGrownSize)
|
|
//{
|
|
// EFI_STATUS Status = EFI_SUCCESS;
|
|
// CHAR8 *MemLogBuffer;
|
|
// UINTN MemLogLen;
|
|
//
|
|
// MemLogBuffer = GetMemLogBuffer();
|
|
// MemLogLen = GetMemLogLen();
|
|
//
|
|
// if (MemLogBuffer == NULL || MemLogLen == 0) {
|
|
// return EFI_NOT_FOUND;
|
|
// }
|
|
//
|
|
// if (MemLogLen > MEM_LOG_INITIAL_SIZE && !AllowGrownSize) {
|
|
// CHAR8 PrevChar = MemLogBuffer[MEM_LOG_INITIAL_SIZE-1];
|
|
// MemLogBuffer[MEM_LOG_INITIAL_SIZE-1] = '\0';
|
|
// Status = LogDataHub(gEfiMiscSubClassGuid, L"boot-log", MemLogBuffer, MEM_LOG_INITIAL_SIZE);
|
|
// MemLogBuffer[MEM_LOG_INITIAL_SIZE-1] = PrevChar;
|
|
// } else {
|
|
// Status = LogDataHub(gEfiMiscSubClassGuid, L"boot-log", MemLogBuffer, (UINT32)MemLogLen);
|
|
// }
|
|
//
|
|
// return Status;
|
|
//}
|
|
//
|
|
//// Made msgbuf and msgCursor private to this source
|
|
//// so we need a different way of saving the msg log - apianti
|
|
//EFI_STATUS SaveBooterLog(const EFI_FILE* BaseDir OPTIONAL, IN CONST CHAR16 *FileName)
|
|
//{
|
|
// CHAR8 *MemLogBuffer;
|
|
// UINTN MemLogLen;
|
|
//
|
|
// MemLogBuffer = GetMemLogBuffer();
|
|
// MemLogLen = GetMemLogLen();
|
|
//
|
|
// if (MemLogBuffer == NULL || MemLogLen == 0) {
|
|
// return EFI_NOT_FOUND;
|
|
// }
|
|
//
|
|
// return egSaveFile(BaseDir, FileName, (UINT8*)MemLogBuffer, MemLogLen);
|
|
//}
|
|
//
|
|
//void DbgHeader(CONST CHAR8 *str)
|
|
//{
|
|
// CHAR8 strLog[50];
|
|
// INTN len;
|
|
// UINTN end = snprintf(strLog, 50, "=== [ %s ] ", str);
|
|
// len = 50 - end;
|
|
//
|
|
// SetMem(&strLog[end], len , '=');
|
|
// strLog[49] = '\0';
|
|
// DebugLog (1, "%s\n", strLog);
|
|
//}
|
|
//
|
|
//
|
|
//
|
|
///*
|
|
// * Redirection of OpenCore log to Clover Log.
|
|
// */
|
|
//
|
|
///*
|
|
// * This function is called from OpenCore when there is a DEBUG ((expression))
|
|
// * Mapping from DEBUG to DebugLogForOC is made in OpenCoreFromClover.h
|
|
// */
|
|
//void EFIAPI DebugLogForOC(IN INTN DebugLevel, IN CONST CHAR8 *FormatString, ...)
|
|
//{
|
|
// VA_LIST Marker;
|
|
//
|
|
// if (FormatString == NULL ) return;
|
|
//
|
|
// // Print message to log buffer
|
|
// VA_START(Marker, FormatString);
|
|
// MemLogVA(true, 1, FormatString, Marker);
|
|
// VA_END(Marker);
|
|
//}
|