ADDRESS IntelCoffFile::GetMainEntryPoint()
{
printf("IntelCoffFile::GetMainEntryPoint called\n");
// There is no such thing, but we need to deliver one since the first entry point might
// be zero and this is skipped when returned by GetEntryPoint().
// return NO_ADDRESS;
return GetEntryPoint();
}
static void PrepareData(LPBYTE pImage, LPBYTE pInjectPos, PVOID* ppEntry, PVOID* ppParam)
{
LPBYTE pRelocTbl = pImage + RVA_RELOC_TABEL;
DWORD dwRelocOffset = (DWORD)pInjectPos - _pinh->OptionalHeader.ImageBase;
RelocImage(pImage, pRelocTbl, dwRelocOffset);
PTHREADPARAM param = (PTHREADPARAM)pRelocTbl;
HMODULE hKernel32 = GetModuleHandle(_T("kernel32.dll"));
param->fnGetProcAddr = (FxGetProcAddr)GetProcAddress(hKernel32, "GetProcAddress");
param->fnLoadLibrary = (FxLoadLibrary)GetProcAddress(hKernel32, "LoadLibraryA");
param->pImageBase = pInjectPos;
*ppEntry = pInjectPos + GetEntryPoint(pImage);
*ppParam = pInjectPos + RVA_RELOC_TABEL;
}
void CodeGenWorkItem::OnRemoveFromJitQueue(NativeCodeGenerator* generator)
{
// This is called from within the lock
this->isInJitQueue = false;
this->entryPointInfo->SetCodeGenPending();
functionBody->GetScriptContext()->GetThreadContext()->UnregisterCodeGenRecyclableData(this->recyclableData);
this->recyclableData = nullptr;
if(IS_JS_ETW(EventEnabledJSCRIPT_FUNCTION_JIT_DEQUEUED()))
{
WCHAR displayNameBuffer[256];
WCHAR* displayName = displayNameBuffer;
size_t sizeInChars = this->GetDisplayName(displayName, 256);
if(sizeInChars > 256)
{
displayName = HeapNewArray(WCHAR, sizeInChars);
this->GetDisplayName(displayName, 256);
}
JS_ETW(EventWriteJSCRIPT_FUNCTION_JIT_DEQUEUED(
this->GetFunctionNumber(),
displayName,
this->GetScriptContext(),
this->GetInterpretedCount()));
if(displayName != displayNameBuffer)
{
HeapDeleteArray(sizeInChars, displayName);
}
}
if(this->Type() == JsLoopBodyWorkItemType)
{
// Go ahead and delete it and let it re-queue if more interpreting of the loop happens
auto loopBodyWorkItem = static_cast<JsLoopBodyCodeGen*>(this);
loopBodyWorkItem->loopHeader->ResetInterpreterCount();
loopBodyWorkItem->GetEntryPoint()->Reset();
HeapDelete(loopBodyWorkItem);
}
else
{
Assert(GetJitMode() == ExecutionMode::FullJit); // simple JIT work items are not removed from the queue
GetFunctionBody()->OnFullJitDequeued(static_cast<Js::FunctionEntryPointInfo *>(GetEntryPoint()));
// Add it back to the list of available functions to be jitted
generator->AddWorkItem(this);
}
}
static PyObject *pepy_parsed_get_entry_point(PyObject *self, PyObject *args) {
VA entrypoint;
PyObject *ret;
if (!GetEntryPoint(((pepy_parsed *) self)->pe, entrypoint))
Py_RETURN_NONE;
ret = PyLong_FromLongLong(entrypoint);
if (!ret) {
PyErr_SetString(pepy_error, "Unable to create return object.");
return NULL;
}
return ret;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : bNearest -
// Output : int
//-----------------------------------------------------------------------------
int CAI_PassengerBehaviorZombie::FindEntrySequence( bool bNearest /*= false*/ )
{
// Get a list of all our animations
const PassengerSeatAnims_t *pEntryAnims = m_hVehicle->GetServerVehicle()->NPC_GetPassengerSeatAnims( GetOuter(), PASSENGER_SEAT_ENTRY );
if ( pEntryAnims == NULL )
return -1;
Vector vecStartPos;
const CPassengerSeatTransition *pTransition;
float flBestCost = FLT_MAX;
float flCost;
int nBestSequence = -1;
int nSequence = -1;
// Test each animation (sorted by priority) for the best match
for ( int i = 0; i < pEntryAnims->Count(); i++ )
{
// Find the activity for this animation name
pTransition = &pEntryAnims->Element(i);
nSequence = GetOuter()->LookupSequence( STRING( pTransition->GetAnimationName() ) );
Assert( nSequence != -1 );
if ( nSequence == -1 )
continue;
// Test this entry for validity
GetEntryPoint( nSequence, &vecStartPos );
// Evaluate the cost
flCost = GetEntryPointCost( vecStartPos );
if ( flCost < flBestCost )
{
nBestSequence = nSequence;
flBestCost = flCost;
continue;
}
}
return nBestSequence;
}
void CodeGenWorkItem::FinalizeNativeCode(Func *func)
{
NativeCodeData * data = func->GetNativeCodeDataAllocator()->Finalize();
NativeCodeData * transferData = func->GetTransferDataAllocator()->Finalize();
CodeGenNumberChunk * numberChunks = func->GetNumberAllocator()->Finalize();
this->functionBody->RecordNativeBaseAddress((BYTE *)GetCodeAddress(), GetCodeSize(), data, transferData, numberChunks, GetEntryPoint(), GetLoopNumber());
func->GetEmitBufferManager()->CompletePreviousAllocation(this->GetAllocation());
}
//--------------------------------------------------------------------------
// patches the entry point of the main thread to go into infinite loop
// dll is injected when this loop is reached,
// after which the old entry point data is restored
int PatchEntryPoint(HANDLE proc, HANDLE thread, char *dllName)
{
DWORD entryPoint;
DWORD oldProtect1,oldProtect2;
unsigned char oldHeader[2];
unsigned char newHeader[2];
CONTEXT context;
entryPoint = GetEntryPoint(proc);
if (!entryPoint)
{
printf("Error getting entry point\n");
return 0;
}
// make entry point writeable
VirtualProtectEx(proc, (LPVOID)entryPoint, 2, PAGE_EXECUTE_READWRITE, &oldProtect1);
//store 2 bytes from entry point
if (!ReadProcessMemory(proc, (LPCVOID)(entryPoint),oldHeader, 2, NULL))
{
printf("Error reading data from entry point");
return 0;
}
// JMP -2
newHeader[0] = 0xEB;
newHeader[1] = 0xFE;
// patch entry point to go into infinite loop
if (!WriteProcessMemory(proc, (LPVOID)(entryPoint),newHeader, 2, NULL))
{
printf("Error writing to entry point");
return 0;
}
ResumeThread(thread);
// wait until entry point is reached
while (true)
{
Sleep(100);
context.ContextFlags = CONTEXT_CONTROL;
GetThreadContext(thread, &context);
if (context.Eip == entryPoint)
break;
}
InjectDLL(proc, dllName);
SuspendThread(thread);
// return original code to entry point
if (!WriteProcessMemory(proc, (LPVOID)(entryPoint),oldHeader, 2, NULL))
{
printf("Error writing to entry point");
return 0;
}
// restore protection
VirtualProtectEx(proc, (LPVOID)entryPoint, 2, oldProtect1, &oldProtect2);
return 1;
}
bool VoxRaytracer::GetExitPoint(const HLine3f line, Vector4f &pt) const
{
HLine3f out = line;
out.direction() *= -1;
return GetEntryPoint(out,pt);
}
EFI_STATUS efi_main(EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
{
InitializeLib(ImageHandle, SystemTable);
CallConstructors();
EFI_STATUS Status;
const char16_t* searchdir = u"\\EFI\\ChaiOS\\";
if (Status = SetWorkingDirectory(searchdir))
printf(u"Error setting working directory: %s\r\n", getError(Status));
CHAIOS_BOOT_FILES* bootfile = nullptr;
while (bootfile = iterateBootFiles(bootfile))
{
if (bootfile->loadLocation != nullptr)
continue; //Support in-memory images
EFI_FILE* file = OpenFile(bootfile->fileName, "r");
if (!file)
{
printf(u"Error: could not open %s: %s\r\n", bootfile->fileName, getError(getErrno()));
}
UINT64 fileSize = GetFileSize(file);
VOID* bootfilebuf = kmalloc(fileSize+1);
UINTN read = ReadFile(bootfilebuf, 1, fileSize, file);
if (read < fileSize)
printf(u"Read %d bytes, failed\r\n", read);
else
printf(u"Successfully read %d bytes\r\n", read);
//Boot file is now loaded into memory
CloseFile(file);
bootfile->loadLocation = bootfilebuf;
bootfile->fileSize = fileSize;
if (bootfile->bootType == CHAIOS_BOOT_CONFIGURATION)
{
//We need to parse this now. INI format
((char*)bootfilebuf)[fileSize] = '\0';
ini_parse_string((const char*)bootfilebuf, &bootini_handler, nullptr);
}
}
//size_t value = GetIntegerInput(u"Enter scrolling lines configuration: ");
//set_scrolllines(value);
UINT32 AutoMode = IterateGraphicsMode(&match_config_resoultion);
EFI_GRAPHICS_OUTPUT_MODE_INFORMATION* info; UINTN SizeOfInfo;
if (AutoMode == UINT32_MAX)
{
if (!EFI_ERROR(GetGraphicsModeInfo(AutoMode, &info, &SizeOfInfo)))
{
IterateGraphicsMode(&print_graphics_mode);
size_t value = GetIntegerInput(u"Enter boot graphics mode: ");
SetGraphicsMode(value);
AutoMode = value;
}
}
else
{
SetGraphicsMode(AutoMode);
}
if (!EFI_ERROR(GetGraphicsModeInfo(AutoMode, &info, &SizeOfInfo)))
{
printf(u"Graphics mode %d: %dx%d\r\n", AutoMode, info->HorizontalResolution, info->VerticalResolution);
}
puts(u"ChaiOS 0.09 UEFI Loader\r\n");
int majorver = SystemTable->Hdr.Revision / (1 << 16);
int minorver = SystemTable->Hdr.Revision % (1 << 16);
printf(u"Firmware Vendor: %s, version: %d (UEFI:%d.%d)\r\n", SystemTable->FirmwareVendor, SystemTable->FirmwareRevision, majorver, minorver);
//Read ACPI configuration tables
//startup_acpi(SystemTable);
//startup_multiprocessor();
const size_t EARLY_PAGE_STACK_SIZE = 1024*1024;
EFI_PHYSICAL_ADDRESS earlyPhypageStack = 0;
if (EFI_ERROR(SystemTable->BootServices->AllocatePages(AllocateAnyPages, EfiLoaderData, EARLY_PAGE_STACK_SIZE / EFI_PAGE_SIZE, &earlyPhypageStack)))
{
puts(u"Could not allocate page stack\r\n");
return EFI_OUT_OF_RESOURCES;
}
SystemTable->BootServices->SetWatchdogTimer(0, 0, 0, nullptr);
PrepareExitBootServices();
EfiMemoryMap map;
map.MemMapSize = map.MapKey = map.DescriptorSize = map.DescriptorVersion = 0;
SystemTable->BootServices->GetMemoryMap(&map.MemMapSize, nullptr, &map.MapKey, &map.DescriptorSize, &map.DescriptorVersion);
//Give a nice bit of room to spare (memory map can change)
map.MemMapSize += 16 * map.DescriptorSize;
map.memmap = (EFI_MEMORY_DESCRIPTOR*)kmalloc(map.MemMapSize); //Allocate a nice buffer
SystemTable->BootServices->GetMemoryMap(&map.MemMapSize, map.memmap, &map.MapKey, &map.DescriptorSize, &map.DescriptorVersion);
printf(u"EFI Memory Map: Descriptor size %d\n", map.DescriptorSize);
#if 0
//Dump the UEFI memory map to a file for testing
EFI_FILE* file = OpenFile(u"efimap.dat", "w");
if (!file)
{
printf(u"Error: could not open %s: %s\r\n", u"efimap.dat", getError(getErrno()));
}
WriteFile(map.memmap, 1, map.MemMapSize, file);
CloseFile(file);
#endif
if (EFI_ERROR(Status = SystemTable->BootServices->ExitBootServices(ImageHandle, map.MapKey)))
{
printf(u"Failed to exit boot services: %s\r\n", getError(Status));
UINTN index;
SystemTable->BootServices->WaitForEvent(1, &SystemTable->ConIn->WaitForKey, &index);
return EFI_SUCCESS;
}
//We need to take control of the hardware now. Setup basic memory management
setLiballocAllocator(nullptr, nullptr);
InitializePmmngr(map, (void*)earlyPhypageStack, EARLY_PAGE_STACK_SIZE);
puts(u"Physical memory manager intialized\n");
arch_initialize_paging();
puts(u"Paging initialized\n");
setLiballocAllocator(&arch_allocate_pages, &arch_free_pages);
//Now load the OS!
bootfile = nullptr;
kimage_entry kentry = nullptr;
KLOAD_HANDLE kernel = NULL;
while (bootfile = iterateBootFiles(bootfile))
{
printf(u"Boot file: %s @ %x, length %d, type %d\n", bootfile->fileName, bootfile->loadLocation, bootfile->fileSize, bootfile->bootType);
if (!bootfile->loadLocation)
continue;
if (bootfile->bootType == CHAIOS_DLL)
{
KLOAD_HANDLE dll = LoadImage(bootfile->loadLocation, bootfile->fileName);
if (GetProcAddress(dll, "memcpy"))
{
set_memcpy((memcpy_proc)GetProcAddress(dll, "memcpy"));
}
}
else if (bootfile->bootType == CHAIOS_KERNEL)
{
kernel = LoadImage(bootfile->loadLocation, bootfile->fileName);
kentry = GetEntryPoint(kernel);
}
}
size_t kstacksize = GetStackSize(kernel);
if (!paging_map(stackaddr, PADDR_T_MAX, kstacksize, PAGE_ATTRIBUTE_WRITABLE))
{
puts(u"Error: could not allocate kernel stack\n");
while (1);
}
KERNEL_BOOT_INFO bootinfo;
fill_pmmngr_info(bootinfo.pmmngr_info);
fill_arch_paging_info(bootinfo.paging_info);
fill_modloader_info(bootinfo.modloader_info);
get_framebuffer_info(bootinfo.fbinfo);
populate_kterm_info(bootinfo.kterm_status);
bootinfo.efi_system_table = SystemTable;
bootinfo.memory_map = ↦
bootinfo.loaded_files = &bootfiles;
bootinfo.boottype = CHAIOS_BOOT_TYPE_UEFI;
bootinfo.printf_proc = &printf;
bootinfo.puts_proc = &puts;
printf(u"Success: Kernel entry point at %x, stack at %x, length %x\n", kentry, stackaddr, kstacksize);
call_kernel(&bootinfo, kentry, stackaddr, kstacksize);
puts(u"Kernel returned");
while (1);
}
NTSTATUS CreateInitialProcess( THREAD **t, UNICODE_STRING& us )
{
BYTE *pstack;
const unsigned int stack_size = 0x100 * PAGE_SIZE;
PROCESS *p = NULL;
CONTEXT ctx;
INITIAL_TEB init_teb;
CLIENT_ID id;
OBJECT *section = NULL;
CFILE *file = 0;
int r;
r = OpenFile( file, us );
if (r < STATUS_SUCCESS)
return r;
/* load the executable and ntdll */
r = CreateSection( §ion, file, 0, SEC_IMAGE, PAGE_EXECUTE_READWRITE );
Release( file );
if (r < STATUS_SUCCESS)
return r;
/* create the initial process */
r = CreateProcess( &p, section );
Release( section );
section = NULL;
if (r < STATUS_SUCCESS)
return r;
PPEB ppeb = (PPEB) p->PebSection->GetKernelAddress();
p->CreateExePPB( &ppeb->ProcessParameters, us );
/* map the stack */
pstack = NULL;
r = p->Vm->AllocateVirtualMemory( &pstack, 0, stack_size, MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE );
if (r < STATUS_SUCCESS)
return r;
/* TEB initialization data.
StackBase > StackLimit because stack grows downward */
memset( &init_teb, 0, sizeof init_teb );
init_teb.AllocatedStackBase = pstack;
init_teb.StackBase = (BYTE*)init_teb.AllocatedStackBase + stack_size;
init_teb.StackLimit = (BYTE*)init_teb.AllocatedStackBase + PAGE_SIZE;
/* initialize the first thread's context */
p->Vm->InitContext( ctx );
ctx.Eip = (DWORD) GetEntryPoint( p );
ctx.Esp = (DWORD) pstack + stack_size - 8;
TRACE("entry point = %08lx\n", ctx.Eip);
/* when starting nt processes, make the PEB the first arg of NtProcessStartup */
r = p->Vm->CopyToUser( (BYTE*) ctx.Esp + 4, &p->PebBaseAddress, sizeof p->PebBaseAddress );
if (r == STATUS_SUCCESS)
r = CreateThread( t, p, &id, &ctx, &init_teb, FALSE );
Release( p );
return r;
}
void KVVAMOSReconGeoNavigator::ParticleEntersNewVolume(KVNucleus* nuc)
{
// Overrides method in KVGeoNavigator base class.
// Every time a particle enters a new volume, we check the material to see
// if it is known (i.e. contained in the range table fRangeTable).
// If so, then we calculate the step through the material (STEP) of the nucleus
// and the distance (DPATH in cm) between the intersection point at the focal plane
// and the point at the entrance of the volume if it is the first active volume of a detector.
// DPATH has the sign + if the volume is behind the focal plane or - if it
// is at the front of it.
//
KVVAMOSReconNuc* rnuc = (KVVAMOSReconNuc*)nuc;
// stop the propagation if the current volume is the stopping detector
// of the nucleus but after the process of this volume
if (rnuc->GetStoppingDetector()) {
TGeoVolume* stopVol = (TGeoVolume*)((KVVAMOSDetector*)rnuc->GetStoppingDetector())->GetActiveVolumes()->Last();
if (GetCurrentVolume() == stopVol) SetStopPropagation();
}
if (fDoNothing) return;
TGeoMaterial* material = GetCurrentVolume()->GetMaterial();
KVIonRangeTableMaterial* irmat = 0;
// skip the process if the current material is unkown
if ((irmat = fRangeTable->GetMaterial(material))) {
KVString dname;
Bool_t multi;
TString absorber_name;
Bool_t is_active = kFALSE;
if (GetCurrentDetectorNameAndVolume(dname, multi)) {
is_active = kTRUE;
if (multi) {
absorber_name.Form("%s/%s", dname.Data(), GetCurrentNode()->GetName());
is_active = absorber_name.Contains("ACTIVE_");
} else absorber_name = dname;
} else
absorber_name = irmat->GetName();
// Coordinates of the vector between the intersection point at the
// focal plane and the point at the entrance of the current detector
Double_t X = GetEntryPoint().X() - fOrigine.X();
Double_t Y = GetEntryPoint().Y() - fOrigine.Y();
Double_t Z = GetEntryPoint().Z() - fOrigine.Z();
// Norm of this vector. The signe gives an infomation about the detector position
// (1: behind; -1: in front of) with respect to the focal plane.
Double_t Delta = TMath::Sign(1., Z) * TMath::Sqrt(X * X + Y * Y + Z * Z);
if ((fCalib & kECalib) || (fCalib & kTCalib)) {
if (fE > 1e-3) {
// velocity before material
Double_t Vi = nuc->GetVelocity().Mag();
// energy lost in the material
Double_t DE = irmat->GetLinearDeltaEOfIon(
nuc->GetZ(), nuc->GetA(), fE, GetStepSize(), 0.,
material->GetTemperature(),
material->GetPressure());
fE -= DE;
nuc->SetEnergy(fE);
//set flag to say that particle has been slowed down
nuc->SetIsDetected();
// velocity after material
Double_t Vf = nuc->GetVelocity().Mag();
if (fCalib & kTCalib) {
//from current start point to the entrance point
fTOF += (Delta - fStartPath) / Vi;
fStartPath = Delta;
//nuc->GetParameters()->SetValue(Form("TOF:%s",absorber_name.Data()), fTOF);
if (is_active) nuc->GetParameters()->SetValue(Form("TOF:%s", dname.Data()), fTOF);
else if ((fCalib & kFullTCalib) == kFullTCalib) nuc->GetParameters()->SetValue(Form("TOF:%s", absorber_name.Data()), fTOF);
// from the entrance to the exit of the material
Double_t step = GetStepSize();
fTOF += CalculateLinearDeltaT(Vi, Vf, step);
fStartPath += step;
}
if (fCalib & kECalib) {
if (is_active) nuc->GetParameters()->SetValue(Form("DE:%s", dname.Data()), DE);
else if ((fCalib & kFullECalib) == kFullECalib) nuc->GetParameters()->SetValue(Form("DE:%s", absorber_name.Data()), DE);
}
}
}
if (is_active) nuc->GetParameters()->SetValue(Form("DPATH:%s", dname.Data()), Delta);
else if ((fCalib & kFullTCalib) == kFullTCalib) nuc->GetParameters()->SetValue(Form("DPATH:%s", absorber_name.Data()), Delta);
nuc->GetParameters()->SetValue(Form("STEP:%s", absorber_name.Data()), GetStepSize());
}
}
