You've already forked UnrealEngineUWP
mirror of
https://github.com/izzy2lost/UnrealEngineUWP.git
synced 2026-03-26 18:15:20 -07:00
6b9f24d192
[OPP-4792] - Crash reports not appearing for launcher on Windows 32-bit OS Implemented platform name substitution strings in exe/symbol search patterns (patterns not using them yet). Simplified pdb cache defines in config to cover more branches per product and remove platforms. Code change to CrashDebugHelper. Engine config change. Updated MDD binaries. #lockdown Nick.Penwarden [CL 2853270 by Chris Wood in Main branch]
883 lines
29 KiB
C++
883 lines
29 KiB
C++
// Copyright 1998-2016 Epic Games, Inc. All Rights Reserved.
|
||
|
||
#include "CrashDebugHelperPrivatePCH.h"
|
||
#include "CrashDebugPDBCache.h"
|
||
|
||
#include "EngineVersion.h"
|
||
#include "ISourceControlModule.h"
|
||
#include "ISourceControlLabel.h"
|
||
#include "ISourceControlRevision.h"
|
||
|
||
#ifndef MINIDUMPDIAGNOSTICS
|
||
#define MINIDUMPDIAGNOSTICS 0
|
||
#endif
|
||
|
||
/*-----------------------------------------------------------------------------
|
||
FCrashDebugHelperConfig
|
||
-----------------------------------------------------------------------------*/
|
||
|
||
/**
|
||
* Holds FullCrashDump properties from the config.
|
||
*
|
||
* PDBCache_0_Branch=UE4-Branch
|
||
* PDBCache_0_ExecutablePathPattern=ue4.net\Builds\UE4-Branch\%ENGINE_VERSION%
|
||
* PDBCache_0_SymbolPathPattern=ue4.net\Builds\UE4-Branch\%ENGINE_VERSION%
|
||
*
|
||
* If PDBCache_0_SymbolPathPattern is missing, the value from PDBCache_0_ExecutablePathPattern will be used
|
||
*/
|
||
struct FPDBCacheConfigEntry
|
||
{
|
||
/** Initialization constructor. */
|
||
FPDBCacheConfigEntry( const FString& InBranch, const FString& InExecutablePathPattern, const FString& InSymbolPathPattern )
|
||
: Branch( InBranch )
|
||
, ExecutablePathPattern( InExecutablePathPattern )
|
||
, SymbolPathPattern( InSymbolPathPattern )
|
||
{}
|
||
|
||
|
||
/** Branch name. */
|
||
const FString Branch;
|
||
|
||
/** Location of the executables */
|
||
const FString ExecutablePathPattern;
|
||
|
||
/** Location of the symbols, usually the same as the executables. */
|
||
const FString SymbolPathPattern;
|
||
};
|
||
|
||
/** Helper struct for reading PDB cache configuration. */
|
||
struct FCrashDebugHelperConfig
|
||
{
|
||
static FCrashDebugHelperConfig& Get()
|
||
{
|
||
static FCrashDebugHelperConfig Instance;
|
||
return Instance;
|
||
}
|
||
|
||
bool IsValid() const
|
||
{
|
||
// We need a least one entry to proceed.
|
||
return PDBCacheConfigEntries.Num() > 0;
|
||
}
|
||
|
||
/** Reads configuration. */
|
||
void ReadFullCrashDumpConfigurations();
|
||
|
||
/** Gets the config for branch. */
|
||
FPDBCacheConfigEntry GetCacheConfigEntryForBranch( const FString& Branch ) const
|
||
{
|
||
const FString BranchFixed = Branch.Replace( TEXT( "/" ), TEXT( "+" ) );
|
||
for (const auto& It : PDBCacheConfigEntries)
|
||
{
|
||
if (BranchFixed.Contains( It.Branch ))
|
||
{
|
||
return It;
|
||
}
|
||
}
|
||
|
||
// Invalid entry.
|
||
return FPDBCacheConfigEntry( Branch, FString(), FString() );
|
||
}
|
||
|
||
protected:
|
||
/** Returns empty string if couldn't read. */
|
||
FString GetKey( const FString& KeyName );
|
||
|
||
/** Configuration for PDB Cache. */
|
||
TArray<FPDBCacheConfigEntry> PDBCacheConfigEntries;
|
||
};
|
||
|
||
void FCrashDebugHelperConfig::ReadFullCrashDumpConfigurations()
|
||
{
|
||
for (int32 NumEntries = 0;; ++NumEntries)
|
||
{
|
||
const FString Branch = GetKey( FString::Printf( TEXT( "PDBCache_%i_Branch" ), NumEntries ) );
|
||
if (Branch.IsEmpty())
|
||
{
|
||
break;
|
||
}
|
||
|
||
const FString ExecutablePathPattern = GetKey( FString::Printf( TEXT( "PDBCache_%i_ExecutablePathPattern" ), NumEntries ) );
|
||
if (ExecutablePathPattern.IsEmpty())
|
||
{
|
||
break;
|
||
}
|
||
|
||
FString SymbolPathPattern = GetKey( FString::Printf( TEXT( "PDBCache_%i_SymbolPathPattern" ), NumEntries ) );
|
||
if (SymbolPathPattern.IsEmpty())
|
||
{
|
||
SymbolPathPattern = ExecutablePathPattern;
|
||
}
|
||
|
||
PDBCacheConfigEntries.Add( FPDBCacheConfigEntry( Branch, ExecutablePathPattern, SymbolPathPattern ) );
|
||
|
||
UE_LOG( LogCrashDebugHelper, Log, TEXT( "PDBCacheConfigEntry: Branch:%s ExecutablePathPattern:%s SymbolPathPattern:%s" ), *Branch, *ExecutablePathPattern, *SymbolPathPattern );
|
||
}
|
||
}
|
||
|
||
FString FCrashDebugHelperConfig::GetKey( const FString& KeyName )
|
||
{
|
||
const FString SectionName = TEXT( "Engine.CrashDebugHelper" );
|
||
|
||
FString Result;
|
||
if (!GConfig->GetString( *SectionName, *KeyName, Result, GEngineIni ))
|
||
{
|
||
return TEXT( "" );
|
||
}
|
||
return Result;
|
||
}
|
||
|
||
/*-----------------------------------------------------------------------------
|
||
ICrashDebugHelper
|
||
-----------------------------------------------------------------------------*/
|
||
|
||
void ICrashDebugHelper::SetDepotIndex( FString& PathToChange )
|
||
{
|
||
FString CmdDepotIndex;
|
||
FParse::Value( FCommandLine::Get(), TEXT( "DepotIndex=" ), CmdDepotIndex );
|
||
// %DEPOT_INDEX% - Index of the depot, when multiple processor are used.
|
||
PathToChange.ReplaceInline( TEXT( "%DEPOT_INDEX%" ), *CmdDepotIndex );
|
||
}
|
||
|
||
bool ICrashDebugHelper::Init()
|
||
{
|
||
bInitialized = true;
|
||
|
||
// Check if we have a valid EngineVersion, if so use it.
|
||
FString CmdEngineVersion;
|
||
const bool bHasEngineVersion = FParse::Value( FCommandLine::Get(), TEXT( "EngineVersion=" ), CmdEngineVersion );
|
||
if( bHasEngineVersion )
|
||
{
|
||
FEngineVersion EngineVersion;
|
||
FEngineVersion::Parse( CmdEngineVersion, EngineVersion );
|
||
|
||
// Clean branch name.
|
||
CrashInfo.DepotName = EngineVersion.GetBranch();
|
||
CrashInfo.BuiltFromCL = (int32)EngineVersion.GetChangelist();
|
||
|
||
CrashInfo.EngineVersion = CmdEngineVersion;
|
||
}
|
||
else
|
||
{
|
||
// Use the current values.
|
||
const FEngineVersion& EngineVersion = FEngineVersion::Current();
|
||
CrashInfo.DepotName = EngineVersion.GetBranch();
|
||
CrashInfo.BuiltFromCL = (int32)EngineVersion.GetChangelist();
|
||
CrashInfo.EngineVersion = EngineVersion.ToString();
|
||
}
|
||
|
||
FString PlatformName;
|
||
const bool bHasPlatformName = FParse::Value(FCommandLine::Get(), TEXT("PlatformName="), PlatformName);
|
||
if (bHasPlatformName)
|
||
{
|
||
CrashInfo.PlatformName = PlatformName;
|
||
}
|
||
else
|
||
{
|
||
// Use the current values.
|
||
CrashInfo.PlatformName = FPlatformProperties::PlatformName();
|
||
}
|
||
|
||
FString PlatformVariantName;
|
||
const bool bHasPlatformVariantName = FParse::Value(FCommandLine::Get(), TEXT("PlatformVariantName="), PlatformVariantName);
|
||
if (bHasPlatformVariantName)
|
||
{
|
||
CrashInfo.PlatformVariantName = PlatformVariantName;
|
||
}
|
||
else
|
||
{
|
||
// Use the basic platform name.
|
||
CrashInfo.PlatformVariantName = CrashInfo.PlatformName;
|
||
}
|
||
|
||
UE_LOG( LogCrashDebugHelper, Log, TEXT( "DepotName: %s" ), *CrashInfo.DepotName );
|
||
UE_LOG( LogCrashDebugHelper, Log, TEXT( "BuiltFromCL: %i" ), CrashInfo.BuiltFromCL );
|
||
UE_LOG( LogCrashDebugHelper, Log, TEXT( "EngineVersion: %s" ), *CrashInfo.EngineVersion );
|
||
|
||
GConfig->GetString( TEXT( "Engine.CrashDebugHelper" ), TEXT( "SourceControlBuildLabelPattern" ), SourceControlBuildLabelPattern, GEngineIni );
|
||
|
||
FCrashDebugHelperConfig::Get().ReadFullCrashDumpConfigurations();
|
||
|
||
const bool bUsePDBCache = FCrashDebugHelperConfig::Get().IsValid();
|
||
UE_CLOG( !bUsePDBCache, LogCrashDebugHelper, Warning, TEXT( "CrashDebugHelperConfig invalid" ) );
|
||
|
||
if (bUsePDBCache)
|
||
{
|
||
FPDBCache::Get().Init();
|
||
}
|
||
else
|
||
{
|
||
UE_LOG( LogCrashDebugHelper, Warning, TEXT( "PDB Cache disabled" ) );
|
||
}
|
||
|
||
|
||
return bInitialized;
|
||
}
|
||
|
||
/**
|
||
* Initialise the source control interface, and ensure we have a valid connection
|
||
*/
|
||
bool ICrashDebugHelper::InitSourceControl(bool bShowLogin)
|
||
{
|
||
// Ensure we are in a valid state to sync
|
||
if (bInitialized == false)
|
||
{
|
||
UE_LOG(LogCrashDebugHelper, Warning, TEXT("InitSourceControl: CrashDebugHelper is not initialized properly."));
|
||
return false;
|
||
}
|
||
|
||
// Initialize the source control if it hasn't already been
|
||
if( !ISourceControlModule::Get().IsEnabled() || !ISourceControlModule::Get().GetProvider().IsAvailable() )
|
||
{
|
||
// make sure our provider is set to Perforce
|
||
ISourceControlModule::Get().SetProvider("Perforce");
|
||
|
||
// Attempt to load in a source control module
|
||
ISourceControlModule::Get().GetProvider().Init();
|
||
|
||
#if !MINIDUMPDIAGNOSTICS
|
||
if ((ISourceControlModule::Get().GetProvider().IsAvailable() == false) || bShowLogin)
|
||
{
|
||
// Unable to connect? Prompt the user for login information
|
||
ISourceControlModule::Get().ShowLoginDialog(FSourceControlLoginClosed(), ELoginWindowMode::Modeless, EOnLoginWindowStartup::PreserveProvider);
|
||
}
|
||
#endif
|
||
// If it's still disabled, none was found, so exit
|
||
if( !ISourceControlModule::Get().IsEnabled() || !ISourceControlModule::Get().GetProvider().IsAvailable() )
|
||
{
|
||
UE_LOG(LogCrashDebugHelper, Warning, TEXT("InitSourceControl: Source control unavailable or disabled."));
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* Shutdown the connection to source control
|
||
*/
|
||
void ICrashDebugHelper::ShutdownSourceControl()
|
||
{
|
||
ISourceControlModule::Get().GetProvider().Close();
|
||
}
|
||
|
||
|
||
bool ICrashDebugHelper::SyncModules()
|
||
{
|
||
// Check source control
|
||
if( !ISourceControlModule::Get().IsEnabled() )
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if( !FPDBCache::Get().UsePDBCache() )
|
||
{
|
||
UE_LOG( LogCrashDebugHelper, Warning, TEXT( "The PDB Cache is disabled, cannot proceed, %s" ), *CrashInfo.EngineVersion );
|
||
return false;
|
||
}
|
||
|
||
// #CrashReport: 2015-02-23 Obsolete, remove after 4.8
|
||
const TCHAR* UESymbols = TEXT( "Rocket/Symbols/" );
|
||
const bool bHasExecutable = !CrashInfo.ExecutablesPath.IsEmpty();
|
||
const bool bHasSymbols = !CrashInfo.SymbolsPath.IsEmpty();
|
||
TArray< TSharedRef<ISourceControlLabel> > Labels = ISourceControlModule::Get().GetProvider().GetLabels( CrashInfo.LabelName );
|
||
|
||
const bool bContainsProductVersion = FPDBCache::Get().ContainsPDBCacheEntry( CrashInfo.EngineVersion );
|
||
if( bHasExecutable && bHasSymbols )
|
||
{
|
||
if( bContainsProductVersion )
|
||
{
|
||
UE_LOG( LogCrashDebugHelper, Warning, TEXT( "Using cached storage: %s" ), *CrashInfo.EngineVersion );
|
||
CrashInfo.PDBCacheEntry = FPDBCache::Get().FindAndTouchPDBCacheEntry( CrashInfo.EngineVersion );
|
||
}
|
||
else
|
||
{
|
||
SCOPE_LOG_TIME_IN_SECONDS( TEXT( "SyncExecutableAndSymbolsFromNetwork" ), nullptr );
|
||
|
||
// Find all executables.
|
||
TArray<FString> NetworkExecutables;
|
||
|
||
// Don't duplicate work.
|
||
if (CrashInfo.ExecutablesPath != CrashInfo.SymbolsPath)
|
||
{
|
||
IFileManager::Get().FindFilesRecursive( NetworkExecutables, *CrashInfo.ExecutablesPath, TEXT( "*.dll" ), true, false, false );
|
||
IFileManager::Get().FindFilesRecursive( NetworkExecutables, *CrashInfo.ExecutablesPath, TEXT( "*.exe" ), true, false, false );
|
||
}
|
||
|
||
// Find all symbols.
|
||
TArray<FString> NetworkSymbols;
|
||
IFileManager::Get().FindFilesRecursive( NetworkSymbols, *CrashInfo.SymbolsPath, TEXT( "*.pdb" ), true, false, false );
|
||
IFileManager::Get().FindFilesRecursive( NetworkSymbols, *CrashInfo.SymbolsPath, TEXT( "*.dll" ), true, false, false );
|
||
IFileManager::Get().FindFilesRecursive( NetworkSymbols, *CrashInfo.SymbolsPath, TEXT( "*.exe" ), true, false, false );
|
||
|
||
// From=Full pathname
|
||
// To=Relative pathname
|
||
TMap<FString, FString> FilesToBeCached;
|
||
|
||
for( const auto& ExecutablePath : NetworkExecutables )
|
||
{
|
||
const FString NetworkRelativePath = ExecutablePath.Replace( *CrashInfo.ExecutablesPath, TEXT( "" ) );
|
||
FilesToBeCached.Add( ExecutablePath, NetworkRelativePath );
|
||
}
|
||
|
||
for( const auto& SymbolPath : NetworkSymbols )
|
||
{
|
||
const FString SymbolRelativePath = SymbolPath.Replace( *CrashInfo.SymbolsPath, TEXT( "" ) );
|
||
FilesToBeCached.Add( SymbolPath, SymbolRelativePath );
|
||
}
|
||
|
||
// Initialize and add a new PDB Cache entry to the database.
|
||
CrashInfo.PDBCacheEntry = FPDBCache::Get().CreateAndAddPDBCacheEntryMixed( CrashInfo.EngineVersion, FilesToBeCached );
|
||
}
|
||
}
|
||
// Get all labels associated with the crash info's label.
|
||
// OBSOLETE PATH
|
||
else if( Labels.Num() >= 1 )
|
||
{
|
||
TSharedRef<ISourceControlLabel> Label = Labels[0];
|
||
TSet<FString> FilesToSync;
|
||
|
||
// Use product version instead of label name to make a distinguish between chosen methods.
|
||
const bool bContainsLabelName = FPDBCache::Get().ContainsPDBCacheEntry( CrashInfo.LabelName );
|
||
|
||
if( bContainsProductVersion )
|
||
{
|
||
UE_LOG( LogCrashDebugHelper, Warning, TEXT( "Using cached storage: %s" ), *CrashInfo.EngineVersion );
|
||
CrashInfo.PDBCacheEntry = FPDBCache::Get().FindAndTouchPDBCacheEntry( CrashInfo.EngineVersion );
|
||
}
|
||
else if( bContainsLabelName )
|
||
{
|
||
UE_LOG( LogCrashDebugHelper, Warning, TEXT( "Using cached storage: %s" ), *CrashInfo.LabelName );
|
||
CrashInfo.PDBCacheEntry = FPDBCache::Get().FindAndTouchPDBCacheEntry( CrashInfo.LabelName );
|
||
}
|
||
else if( bHasExecutable )
|
||
{
|
||
SCOPE_LOG_TIME_IN_SECONDS( TEXT( "SyncModulesAndNetwork" ), nullptr );
|
||
|
||
// Grab information about symbols.
|
||
TArray< TSharedRef<class ISourceControlRevision, ESPMode::ThreadSafe> > PDBSourceControlRevisions;
|
||
const FString PDBsPath = FString::Printf( TEXT( "%s/%s....pdb" ), *CrashInfo.DepotName, UESymbols );
|
||
Label->GetFileRevisions( PDBsPath, PDBSourceControlRevisions );
|
||
|
||
TSet<FString> PDBPaths;
|
||
for( const auto& PDBSrc : PDBSourceControlRevisions )
|
||
{
|
||
PDBPaths.Add( PDBSrc->GetFilename() );
|
||
}
|
||
|
||
// Now, sync symbols.
|
||
for( const auto& PDBPath : PDBPaths )
|
||
{
|
||
if( Label->Sync( PDBPath ) )
|
||
{
|
||
UE_LOG( LogCrashDebugHelper, Warning, TEXT( "Synced PDB: %s" ), *PDBPath );
|
||
}
|
||
}
|
||
|
||
// Find all the executables in the product network path.
|
||
TArray<FString> NetworkExecutables;
|
||
IFileManager::Get().FindFilesRecursive( NetworkExecutables, *CrashInfo.ExecutablesPath, TEXT( "*.dll" ), true, false, false );
|
||
IFileManager::Get().FindFilesRecursive( NetworkExecutables, *CrashInfo.ExecutablesPath, TEXT( "*.exe" ), true, false, false );
|
||
|
||
// From=Full pathname
|
||
// To=Relative pathname
|
||
TMap<FString, FString> FilesToBeCached;
|
||
|
||
// If a symbol matches an executable, add the pair to the list of files that should be cached.
|
||
for( const auto& NetworkExecutableFullpath : NetworkExecutables )
|
||
{
|
||
for( const auto& PDBPath : PDBPaths )
|
||
{
|
||
const FString PDBRelativePath = PDBPath.Replace( *CrashInfo.DepotName, TEXT( "" ) ).Replace( UESymbols, TEXT( "" ) );
|
||
const FString PDBFullpath = FPDBCache::Get().GetDepotRoot() / PDBPath;
|
||
|
||
const FString PDBMatch = PDBRelativePath.Replace( TEXT( "pdb" ), TEXT( "" ) );
|
||
const FString NetworkRelativePath = NetworkExecutableFullpath.Replace( *CrashInfo.ExecutablesPath, TEXT( "" ) );
|
||
const bool bMatch = NetworkExecutableFullpath.Contains( PDBMatch );
|
||
if( bMatch )
|
||
{
|
||
// From -> Where
|
||
FilesToBeCached.Add( NetworkExecutableFullpath, NetworkRelativePath );
|
||
FilesToBeCached.Add( PDBFullpath, PDBRelativePath );
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Initialize and add a new PDB Cache entry to the database.
|
||
CrashInfo.PDBCacheEntry = FPDBCache::Get().CreateAndAddPDBCacheEntryMixed( CrashInfo.EngineVersion, FilesToBeCached );
|
||
}
|
||
else
|
||
{
|
||
TArray<FString> FilesToBeCached;
|
||
|
||
//@TODO: MAC: Excluding labels for Mac since we are only syncing windows binaries here...
|
||
if( Label->GetName().Contains( TEXT( "Mac" ) ) )
|
||
{
|
||
UE_LOG( LogCrashDebugHelper, Log, TEXT( "Skipping Mac label: %s" ), *Label->GetName() );
|
||
}
|
||
else
|
||
{
|
||
// Sync all the dll, exes, and related symbol files
|
||
UE_LOG( LogCrashDebugHelper, Log, TEXT( "Syncing modules with label: %s" ), *Label->GetName() );
|
||
|
||
SCOPE_LOG_TIME_IN_SECONDS( TEXT( "SyncModules" ), nullptr );
|
||
|
||
// Grab all dll and pdb files for the specified label.
|
||
TArray< TSharedRef<class ISourceControlRevision, ESPMode::ThreadSafe> > DLLSourceControlRevisions;
|
||
const FString DLLsPath = FString::Printf( TEXT( "%s/....dll" ), *CrashInfo.DepotName );
|
||
Label->GetFileRevisions( DLLsPath, DLLSourceControlRevisions );
|
||
|
||
TArray< TSharedRef<class ISourceControlRevision, ESPMode::ThreadSafe> > EXESourceControlRevisions;
|
||
const FString EXEsPath = FString::Printf( TEXT( "%s/....exe" ), *CrashInfo.DepotName );
|
||
Label->GetFileRevisions( EXEsPath, EXESourceControlRevisions );
|
||
|
||
TArray< TSharedRef<class ISourceControlRevision, ESPMode::ThreadSafe> > PDBSourceControlRevisions;
|
||
const FString PDBsPath = FString::Printf( TEXT( "%s/....pdb" ), *CrashInfo.DepotName );
|
||
Label->GetFileRevisions( PDBsPath, PDBSourceControlRevisions );
|
||
|
||
TSet<FString> ModulesPaths;
|
||
for( const auto& DLLSrc : DLLSourceControlRevisions )
|
||
{
|
||
ModulesPaths.Add( DLLSrc->GetFilename().Replace( *CrashInfo.DepotName, TEXT( "" ) ) );
|
||
}
|
||
for( const auto& EXESrc : EXESourceControlRevisions )
|
||
{
|
||
ModulesPaths.Add( EXESrc->GetFilename().Replace( *CrashInfo.DepotName, TEXT( "" ) ) );
|
||
}
|
||
|
||
TSet<FString> PDBPaths;
|
||
for( const auto& PDBSrc : PDBSourceControlRevisions )
|
||
{
|
||
PDBPaths.Add( PDBSrc->GetFilename().Replace( *CrashInfo.DepotName, TEXT( "" ) ) );
|
||
}
|
||
|
||
// Iterate through all module and see if we have dll and pdb associated with the module, if so add it to the files to sync.
|
||
for( const auto& ModuleName : CrashInfo.ModuleNames )
|
||
{
|
||
const FString ModuleNamePDB = ModuleName.Replace( TEXT( ".dll" ), TEXT( ".pdb" ) ).Replace( TEXT( ".exe" ), TEXT( ".pdb" ) );
|
||
|
||
for( const auto& ModulePath : ModulesPaths )
|
||
{
|
||
const bool bContainsModule = ModulePath.Contains( ModuleName );
|
||
if( bContainsModule )
|
||
{
|
||
FilesToSync.Add( ModulePath );
|
||
}
|
||
}
|
||
|
||
for( const auto& PDBPath : PDBPaths )
|
||
{
|
||
const bool bContainsPDB = PDBPath.Contains( ModuleNamePDB );
|
||
if( bContainsPDB )
|
||
{
|
||
FilesToSync.Add( PDBPath );
|
||
}
|
||
}
|
||
}
|
||
|
||
// Now, sync all files.
|
||
for( const auto& Filename : FilesToSync )
|
||
{
|
||
const FString DepotPath = CrashInfo.DepotName + Filename;
|
||
if( Label->Sync( DepotPath ) )
|
||
{
|
||
UE_LOG( LogCrashDebugHelper, Warning, TEXT( "Synced binary: %s" ), *DepotPath );
|
||
}
|
||
FilesToBeCached.Add( DepotPath );
|
||
}
|
||
}
|
||
|
||
// Initialize and add a new PDB Cache entry to the database.
|
||
CrashInfo.PDBCacheEntry = FPDBCache::Get().CreateAndAddPDBCacheEntry( CrashInfo.LabelName, CrashInfo.DepotName, FilesToBeCached );
|
||
}
|
||
}
|
||
// OBSOLETE PATH
|
||
else
|
||
{
|
||
UE_LOG( LogCrashDebugHelper, Error, TEXT( "Could not find label: %s"), *CrashInfo.LabelName );
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool ICrashDebugHelper::SyncSourceFile()
|
||
{
|
||
// Check source control
|
||
if( !ISourceControlModule::Get().IsEnabled() )
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// Sync a single source file to requested CL.
|
||
FString DepotPath = CrashInfo.DepotName / CrashInfo.SourceFile + TEXT( "@" ) + TTypeToString<int32>::ToString( CrashInfo.BuiltFromCL );
|
||
ISourceControlModule::Get().GetProvider().Execute(ISourceControlOperation::Create<FSync>(), DepotPath);
|
||
|
||
UE_LOG( LogCrashDebugHelper, Warning, TEXT( "Syncing a single source file: %s"), *DepotPath );
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
bool ICrashDebugHelper::ReadSourceFile( TArray<FString>& OutStrings )
|
||
{
|
||
const bool bUsePDBCache = FPDBCache::Get().UsePDBCache();
|
||
|
||
FString FilePath;
|
||
if (bUsePDBCache)
|
||
{
|
||
// We assume a special folder for syncing all streams and //depot/ is not used in the view mapping.
|
||
/*
|
||
//depot/... //machine/...
|
||
//UE4/... //machine/​​Stream/UE4/...​
|
||
*/
|
||
const TCHAR* DepotDelimiter = TEXT( "//depot/" );
|
||
const bool bIsDepot = CrashInfo.DepotName.Contains( DepotDelimiter );
|
||
|
||
if (bIsDepot)
|
||
{
|
||
FilePath = FPDBCache::Get().GetDepotRoot() / CrashInfo.DepotName.Replace( DepotDelimiter, TEXT( "" ) ) / CrashInfo.SourceFile;
|
||
}
|
||
else
|
||
{
|
||
FilePath = FPDBCache::Get().GetDepotRoot() / TEXT( "Stream" ) / CrashInfo.DepotName / CrashInfo.SourceFile;
|
||
FilePath.ReplaceInline( TEXT( "//" ), TEXT( "/" ) );
|
||
}
|
||
}
|
||
else
|
||
{
|
||
FilePath = FPaths::RootDir() / CrashInfo.SourceFile;
|
||
}
|
||
|
||
FString Line;
|
||
if (FFileHelper::LoadFileToString( Line, *FilePath ))
|
||
{
|
||
Line = Line.Replace( TEXT( "\r" ), TEXT( "" ) );
|
||
Line.ParseIntoArray( OutStrings, TEXT( "\n" ), false );
|
||
UE_LOG( LogCrashDebugHelper, Log, TEXT( "Reading a single source file: %s" ), *FilePath );
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
UE_LOG( LogCrashDebugHelper, Warning, TEXT( "Failed to open source file: %s" ), *FilePath );
|
||
return false;
|
||
}
|
||
}
|
||
|
||
void ICrashDebugHelper::AddSourceToReport()
|
||
{
|
||
if( CrashInfo.SourceFile.Len() > 0 && CrashInfo.SourceLineNumber != 0 )
|
||
{
|
||
TArray<FString> Lines;
|
||
ReadSourceFile( Lines );
|
||
|
||
const uint32 MinLine = FMath::Clamp( CrashInfo.SourceLineNumber - 15, (uint32)1, (uint32)Lines.Num() );
|
||
const uint32 MaxLine = FMath::Clamp( CrashInfo.SourceLineNumber + 15, (uint32)1, (uint32)Lines.Num() );
|
||
|
||
for( uint32 Line = MinLine; Line < MaxLine; Line++ )
|
||
{
|
||
if( Line == CrashInfo.SourceLineNumber - 1 )
|
||
{
|
||
CrashInfo.SourceContext.Add( FString::Printf( TEXT( "%5u ***** %s" ), Line, *Lines[Line] ) );
|
||
}
|
||
else
|
||
{
|
||
CrashInfo.SourceContext.Add( FString::Printf( TEXT( "%5u %s" ), Line, *Lines[Line] ) );
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
bool ICrashDebugHelper::AddAnnotatedSourceToReport()
|
||
{
|
||
// Make sure we have a source file to interrogate
|
||
if( CrashInfo.SourceFile.Len() > 0 && CrashInfo.SourceLineNumber != 0 && !CrashInfo.LabelName.IsEmpty() )
|
||
{
|
||
// Check source control
|
||
if( !ISourceControlModule::Get().IsEnabled() )
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// Ask source control to annotate the file for us
|
||
FString DepotPath = CrashInfo.DepotName / CrashInfo.SourceFile;
|
||
|
||
TArray<FAnnotationLine> Lines;
|
||
SourceControlHelpers::AnnotateFile( ISourceControlModule::Get().GetProvider(), CrashInfo.BuiltFromCL, DepotPath, Lines );
|
||
|
||
uint32 MinLine = FMath::Clamp( CrashInfo.SourceLineNumber - 15, (uint32)1, (uint32)Lines.Num() );
|
||
uint32 MaxLine = FMath::Clamp( CrashInfo.SourceLineNumber + 15, (uint32)1, (uint32)Lines.Num() );
|
||
|
||
// Display a source context in the report, and decorate each line with the last editor of the line
|
||
for( uint32 Line = MinLine; Line < MaxLine; Line++ )
|
||
{
|
||
if( Line == CrashInfo.SourceLineNumber )
|
||
{
|
||
CrashInfo.SourceContext.Add( FString::Printf( TEXT( "%5u ***** %20s: %s" ), Line, *Lines[Line].UserName, *Lines[Line].Line ) );
|
||
}
|
||
else
|
||
{
|
||
CrashInfo.SourceContext.Add( FString::Printf( TEXT( "%5u %20s: %s" ), Line, *Lines[Line].UserName, *Lines[Line].Line ) );
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
void FCrashInfo::Log( FString Line )
|
||
{
|
||
UE_LOG( LogCrashDebugHelper, Warning, TEXT("%s"), *Line );
|
||
Report += Line + LINE_TERMINATOR;
|
||
}
|
||
|
||
|
||
const TCHAR* FCrashInfo::GetProcessorArchitecture( EProcessorArchitecture PA )
|
||
{
|
||
switch( PA )
|
||
{
|
||
case PA_X86:
|
||
return TEXT( "x86" );
|
||
case PA_X64:
|
||
return TEXT( "x64" );
|
||
case PA_ARM:
|
||
return TEXT( "ARM" );
|
||
}
|
||
|
||
return TEXT( "Unknown" );
|
||
}
|
||
|
||
|
||
int64 FCrashInfo::StringSize( const ANSICHAR* Line )
|
||
{
|
||
int64 Size = 0;
|
||
if( Line != nullptr )
|
||
{
|
||
while( *Line++ != 0 )
|
||
{
|
||
Size++;
|
||
}
|
||
}
|
||
return Size;
|
||
}
|
||
|
||
|
||
void FCrashInfo::WriteLine( FArchive* ReportFile, const ANSICHAR* Line )
|
||
{
|
||
if( Line != NULL )
|
||
{
|
||
int64 StringBytes = StringSize( Line );
|
||
ReportFile->Serialize( ( void* )Line, StringBytes );
|
||
}
|
||
|
||
ReportFile->Serialize( TCHAR_TO_UTF8( LINE_TERMINATOR ), FCStringWide::Strlen(LINE_TERMINATOR) );
|
||
}
|
||
|
||
|
||
void FCrashInfo::GenerateReport( const FString& DiagnosticsPath )
|
||
{
|
||
FArchive* ReportFile = IFileManager::Get().CreateFileWriter( *DiagnosticsPath );
|
||
if( ReportFile != NULL )
|
||
{
|
||
FString Line;
|
||
|
||
WriteLine( ReportFile, TCHAR_TO_UTF8( TEXT( "Generating report for minidump" ) ) );
|
||
WriteLine( ReportFile );
|
||
|
||
if ( EngineVersion.Len() > 0 )
|
||
{
|
||
Line = FString::Printf( TEXT( "Application version %s" ), *EngineVersion );
|
||
WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
|
||
}
|
||
else if( Modules.Num() > 0 )
|
||
{
|
||
Line = FString::Printf( TEXT( "Application version %d.%d.%d" ), Modules[0].Major, Modules[0].Minor, Modules[0].Patch );
|
||
WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
|
||
}
|
||
|
||
Line = FString::Printf( TEXT( " ... built from changelist %d" ), BuiltFromCL );
|
||
WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
|
||
if( LabelName.Len() > 0 )
|
||
{
|
||
Line = FString::Printf( TEXT( " ... based on label %s" ), *LabelName );
|
||
WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
|
||
}
|
||
WriteLine( ReportFile );
|
||
|
||
Line = FString::Printf( TEXT( "OS version %d.%d.%d.%d" ), SystemInfo.OSMajor, SystemInfo.OSMinor, SystemInfo.OSBuild, SystemInfo.OSRevision );
|
||
WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
|
||
|
||
Line = FString::Printf( TEXT( "Running %d %s processors" ), SystemInfo.ProcessorCount, GetProcessorArchitecture( SystemInfo.ProcessorArchitecture ) );
|
||
WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
|
||
|
||
Line = FString::Printf( TEXT( "Exception was \"%s\"" ), *Exception.ExceptionString );
|
||
WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
|
||
WriteLine( ReportFile );
|
||
|
||
Line = FString::Printf( TEXT( "Source context from \"%s\"" ), *SourceFile );
|
||
WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
|
||
WriteLine( ReportFile );
|
||
|
||
Line = FString::Printf( TEXT( "<SOURCE START>" ) );
|
||
WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
|
||
for( int32 LineIndex = 0; LineIndex < SourceContext.Num(); LineIndex++ )
|
||
{
|
||
Line = FString::Printf( TEXT( "%s" ), *SourceContext[LineIndex] );
|
||
WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
|
||
}
|
||
Line = FString::Printf( TEXT( "<SOURCE END>" ) );
|
||
WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
|
||
WriteLine( ReportFile );
|
||
|
||
Line = FString::Printf( TEXT( "<CALLSTACK START>" ) );
|
||
WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
|
||
|
||
for( int32 StackIndex = 0; StackIndex < Exception.CallStackString.Num(); StackIndex++ )
|
||
{
|
||
Line = FString::Printf( TEXT( "%s" ), *Exception.CallStackString[StackIndex] );
|
||
WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
|
||
}
|
||
|
||
Line = FString::Printf( TEXT( "<CALLSTACK END>" ) );
|
||
WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
|
||
WriteLine( ReportFile );
|
||
|
||
Line = FString::Printf( TEXT( "%d loaded modules" ), Modules.Num() );
|
||
WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
|
||
|
||
for( int32 ModuleIndex = 0; ModuleIndex < Modules.Num(); ModuleIndex++ )
|
||
{
|
||
FCrashModuleInfo& Module = Modules[ModuleIndex];
|
||
|
||
FString ModuleDirectory = FPaths::GetPath(Module.Name);
|
||
FString ModuleName = FPaths::GetBaseFilename( Module.Name, true ) + FPaths::GetExtension( Module.Name, true );
|
||
|
||
FString ModuleDetail = FString::Printf( TEXT( "%40s" ), *ModuleName );
|
||
FString Version = FString::Printf( TEXT( " (%d.%d.%d.%d)" ), Module.Major, Module.Minor, Module.Patch, Module.Revision );
|
||
ModuleDetail += FString::Printf( TEXT( " %22s" ), *Version );
|
||
ModuleDetail += FString::Printf( TEXT( " 0x%016x 0x%08x" ), Module.BaseOfImage, Module.SizeOfImage );
|
||
ModuleDetail += FString::Printf( TEXT( " %s" ), *ModuleDirectory );
|
||
|
||
WriteLine( ReportFile, TCHAR_TO_UTF8( *ModuleDetail ) );
|
||
}
|
||
|
||
WriteLine( ReportFile );
|
||
|
||
// Write out the processor debugging log
|
||
WriteLine( ReportFile, TCHAR_TO_UTF8( *Report ) );
|
||
|
||
Line = FString::Printf( TEXT( "Report end!" ) );
|
||
WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
|
||
|
||
ReportFile->Close();
|
||
delete ReportFile;
|
||
}
|
||
}
|
||
|
||
void ICrashDebugHelper::FindSymbolsAndBinariesStorage()
|
||
{
|
||
CrashInfo.ExecutablesPath.Empty();
|
||
CrashInfo.SymbolsPath.Empty();
|
||
CrashInfo.LabelName.Empty();
|
||
|
||
if( CrashInfo.BuiltFromCL == FCrashInfo::INVALID_CHANGELIST )
|
||
{
|
||
UE_LOG( LogCrashDebugHelper, Warning, TEXT( "Invalid parameters" ) );
|
||
return;
|
||
}
|
||
|
||
UE_LOG( LogCrashDebugHelper, Log, TEXT( "Engine version: %s" ), *CrashInfo.EngineVersion );
|
||
|
||
const FPDBCacheConfigEntry ConfigEntry = FCrashDebugHelperConfig::Get().GetCacheConfigEntryForBranch( CrashInfo.DepotName );
|
||
FString ExecutablePathPattern = ConfigEntry.ExecutablePathPattern;
|
||
FString SymbolPathPattern = ConfigEntry.SymbolPathPattern;
|
||
|
||
if (!ExecutablePathPattern.IsEmpty() || !SymbolPathPattern.IsEmpty())
|
||
{
|
||
UE_LOG( LogCrashDebugHelper, Log, TEXT( "Using branch: %s" ), *CrashInfo.DepotName );
|
||
}
|
||
else
|
||
{
|
||
UE_LOG( LogCrashDebugHelper, Log, TEXT( "Branch not found: %s" ), *CrashInfo.DepotName );
|
||
return;
|
||
}
|
||
|
||
const FString StrENGINE_VERSION = CrashInfo.EngineVersion;
|
||
const FString StrPLATFORM_NAME = CrashInfo.PlatformName;
|
||
const FString StrPLATFORM_VARIANT = CrashInfo.PlatformVariantName;
|
||
const FString StrOLD_ENGINE_VERSION = FString::Printf( TEXT( "%s-CL-%i" ), *CrashInfo.DepotName.Replace( TEXT( "+" ), TEXT( "/" ) ), CrashInfo.BuiltFromCL )
|
||
.Replace( TEXT("/"), TEXT("+") );
|
||
|
||
const FString TestExecutablesPath = ExecutablePathPattern
|
||
.Replace( TEXT( "%ENGINE_VERSION%" ), *StrENGINE_VERSION )
|
||
.Replace( TEXT( "%PLATFORM_NAME%" ), *StrPLATFORM_NAME )
|
||
.Replace( TEXT( "%PLATFORM_VARIANT%" ), *StrPLATFORM_VARIANT )
|
||
.Replace( TEXT( "%OLD_ENGINE_VERSION%" ), *StrOLD_ENGINE_VERSION );
|
||
|
||
const FString TestSymbolsPath = SymbolPathPattern
|
||
.Replace( TEXT( "%ENGINE_VERSION%" ), *StrENGINE_VERSION )
|
||
.Replace( TEXT( "%PLATFORM_NAME%" ), *StrPLATFORM_NAME )
|
||
.Replace( TEXT( "%PLATFORM_VARIANT%" ), *StrPLATFORM_VARIANT )
|
||
.Replace( TEXT( "%OLD_ENGINE_VERSION%" ), *StrOLD_ENGINE_VERSION );
|
||
|
||
// Try to find the network path by using the pattern supplied via ini.
|
||
// If this step successes, we will grab the executable from the network path instead of P4.
|
||
bool bFoundDirectory = false;
|
||
|
||
bool bHasExecutables = false;
|
||
if (!TestExecutablesPath.IsEmpty())
|
||
{
|
||
bHasExecutables = IFileManager::Get().DirectoryExists(*TestExecutablesPath);
|
||
}
|
||
bool bHasSymbols = false;
|
||
if (!TestSymbolsPath.IsEmpty())
|
||
{
|
||
bHasSymbols = IFileManager::Get().DirectoryExists(*TestSymbolsPath);
|
||
}
|
||
|
||
if( bHasExecutables && bHasSymbols )
|
||
{
|
||
CrashInfo.ExecutablesPath = TestExecutablesPath;
|
||
CrashInfo.SymbolsPath = TestSymbolsPath;
|
||
bFoundDirectory = true;
|
||
UE_LOG( LogCrashDebugHelper, Log, TEXT( "Using path for executables and symbols: %s" ), *CrashInfo.ExecutablesPath );
|
||
}
|
||
else if( bHasExecutables )
|
||
{
|
||
CrashInfo.ExecutablesPath = TestExecutablesPath;
|
||
UE_LOG( LogCrashDebugHelper, Log, TEXT( "Using path for executables: %s" ), *CrashInfo.ExecutablesPath );
|
||
}
|
||
else
|
||
{
|
||
UE_LOG( LogCrashDebugHelper, Log, TEXT( "Path for executables not found: %s" ), *TestExecutablesPath );
|
||
}
|
||
|
||
|
||
// Try to find the label directly in source control by using the pattern supplied via ini.
|
||
if( !bFoundDirectory && !SourceControlBuildLabelPattern.IsEmpty() )
|
||
{
|
||
const FString ChangelistString = FString::Printf( TEXT( "%d" ), CrashInfo.BuiltFromCL );
|
||
const FString LabelWithCL = SourceControlBuildLabelPattern.Replace( TEXT( "%CHANGELISTNUMBER%" ), *ChangelistString, ESearchCase::CaseSensitive );
|
||
UE_LOG( LogCrashDebugHelper, Log, TEXT( "Label matching pattern: %s" ), *LabelWithCL );
|
||
|
||
TArray< TSharedRef<ISourceControlLabel> > Labels = ISourceControlModule::Get().GetProvider().GetLabels( LabelWithCL );
|
||
if( Labels.Num() > 0 )
|
||
{
|
||
const int32 LabelIndex = 0;
|
||
CrashInfo.LabelName = Labels[LabelIndex]->GetName();;
|
||
|
||
// If we found more than one label, warn about it and just use the first one
|
||
if( Labels.Num() > 1 )
|
||
{
|
||
UE_LOG( LogCrashDebugHelper, Warning, TEXT( "More than one build label found, using label: %s" ), *LabelWithCL, *CrashInfo.LabelName );
|
||
}
|
||
else
|
||
{
|
||
UE_LOG( LogCrashDebugHelper, Log, TEXT( "Using label: %s" ), *CrashInfo.LabelName );
|
||
}
|
||
}
|
||
}
|
||
}
|