/** ****************************************************************************** * Xenia : Xbox 360 Emulator Research Project * ****************************************************************************** * Copyright 2013 Ben Vanik. All rights reserved. * * Released under the BSD license - see LICENSE in the root for more details. * ****************************************************************************** */ #include "xenia/kernel/xboxkrnl_module.h" #include #include #include "xenia/base/clock.h" #include "xenia/base/logging.h" #include "xenia/base/math.h" #include "xenia/emulator.h" #include "xenia/kernel/kernel_state.h" #include "xenia/kernel/xboxkrnl_private.h" #include "xenia/kernel/objects/xuser_module.h" namespace xe { namespace kernel { XboxkrnlModule::XboxkrnlModule(Emulator* emulator, KernelState* kernel_state) : XKernelModule(kernel_state, "xe:\\xboxkrnl.exe"), timestamp_timer_(nullptr) { RegisterExportTable(export_resolver_); // Register all exported functions. xboxkrnl::RegisterAudioExports(export_resolver_, kernel_state_); xboxkrnl::RegisterAudioXmaExports(export_resolver_, kernel_state_); xboxkrnl::RegisterCryptExports(export_resolver_, kernel_state_); xboxkrnl::RegisterDebugExports(export_resolver_, kernel_state_); xboxkrnl::RegisterErrorExports(export_resolver_, kernel_state_); xboxkrnl::RegisterHalExports(export_resolver_, kernel_state_); xboxkrnl::RegisterIoExports(export_resolver_, kernel_state_); xboxkrnl::RegisterMemoryExports(export_resolver_, kernel_state_); xboxkrnl::RegisterMiscExports(export_resolver_, kernel_state_); xboxkrnl::RegisterModuleExports(export_resolver_, kernel_state_); xboxkrnl::RegisterObExports(export_resolver_, kernel_state_); xboxkrnl::RegisterRtlExports(export_resolver_, kernel_state_); xboxkrnl::RegisterStringExports(export_resolver_, kernel_state_); xboxkrnl::RegisterThreadingExports(export_resolver_, kernel_state_); xboxkrnl::RegisterUsbcamExports(export_resolver_, kernel_state_); xboxkrnl::RegisterVideoExports(export_resolver_, kernel_state_); // KeDebugMonitorData (?*) // Set to a valid value when a remote debugger is attached. // Offset 0x18 is a 4b pointer to a handler function that seems to take two // arguments. If we wanted to see what would happen we could fake that. uint32_t pKeDebugMonitorData = memory_->SystemHeapAlloc(256); auto lpKeDebugMonitorData = memory_->TranslateVirtual(pKeDebugMonitorData); export_resolver_->SetVariableMapping( "xboxkrnl.exe", ordinals::KeDebugMonitorData, pKeDebugMonitorData); xe::store_and_swap(lpKeDebugMonitorData, 0); // KeCertMonitorData (?*) // Always set to zero, ignored. uint32_t pKeCertMonitorData = memory_->SystemHeapAlloc(4); auto lpKeCertMonitorData = memory_->TranslateVirtual(pKeCertMonitorData); export_resolver_->SetVariableMapping( "xboxkrnl.exe", ordinals::KeCertMonitorData, pKeCertMonitorData); xe::store_and_swap(lpKeCertMonitorData, 0); // XboxHardwareInfo (XboxHardwareInfo_t, 16b) // flags cpu# ? ? ? ? ? ? // 0x00000000, 0x06, 0x00, 0x00, 0x00, 0x00000000, 0x0000, 0x0000 // Games seem to check if bit 26 (0x20) is set, which at least for xbox1 // was whether an HDD was present. Not sure what the other flags are. // // aomega08 says the value is 0x02000817, bit 27: debug mode on. // When that is set, though, allocs crash in weird ways. uint32_t pXboxHardwareInfo = memory_->SystemHeapAlloc(16); auto lpXboxHardwareInfo = memory_->TranslateVirtual(pXboxHardwareInfo); export_resolver_->SetVariableMapping( "xboxkrnl.exe", ordinals::XboxHardwareInfo, pXboxHardwareInfo); xe::store_and_swap(lpXboxHardwareInfo + 0, 0); // flags xe::store_and_swap(lpXboxHardwareInfo + 4, 0x06); // cpu count // Remaining 11b are zeroes? // XexExecutableModuleHandle (?**) // Games try to dereference this to get a pointer to some module struct. // So far it seems like it's just in loader code, and only used to look up // the XexHeaderBase for use by RtlImageXexHeaderField. // We fake it so that the address passed to that looks legit. // 0x80100FFC <- pointer to structure // 0x80101000 <- our module structure // 0x80101058 <- pointer to xex header // 0x80101100 <- xex header base uint32_t ppXexExecutableModuleHandle = memory_->SystemHeapAlloc(4); export_resolver_->SetVariableMapping("xboxkrnl.exe", ordinals::XexExecutableModuleHandle, ppXexExecutableModuleHandle); // ExLoadedCommandLine (char*) // The name of the xex. Not sure this is ever really used on real devices. // Perhaps it's how swap disc/etc data is sent? // Always set to "default.xex" (with quotes) for now. uint32_t pExLoadedCommandLine = memory_->SystemHeapAlloc(1024); auto lpExLoadedCommandLine = memory_->TranslateVirtual(pExLoadedCommandLine); export_resolver_->SetVariableMapping( "xboxkrnl.exe", ordinals::ExLoadedCommandLine, pExLoadedCommandLine); char command_line[] = "\"default.xex\""; std::memcpy(lpExLoadedCommandLine, command_line, xe::countof(command_line) + 1); // XboxKrnlVersion (8b) // Kernel version, looks like 2b.2b.2b.2b. // I've only seen games check >=, so we just fake something here. uint32_t pXboxKrnlVersion = memory_->SystemHeapAlloc(8); auto lpXboxKrnlVersion = memory_->TranslateVirtual(pXboxKrnlVersion); export_resolver_->SetVariableMapping( "xboxkrnl.exe", ordinals::XboxKrnlVersion, pXboxKrnlVersion); xe::store_and_swap(lpXboxKrnlVersion + 0, 2); xe::store_and_swap(lpXboxKrnlVersion + 2, 0xFFFF); xe::store_and_swap(lpXboxKrnlVersion + 4, 0xFFFF); xe::store_and_swap(lpXboxKrnlVersion + 6, 0x80); xe::store_and_swap(lpXboxKrnlVersion + 7, 0x00); // KeTimeStampBundle (ad) // This must be updated during execution, at 1ms intevals. // We setup a system timer here to do that. uint32_t pKeTimeStampBundle = memory_->SystemHeapAlloc(24); auto lpKeTimeStampBundle = memory_->TranslateVirtual(pKeTimeStampBundle); export_resolver_->SetVariableMapping( "xboxkrnl.exe", ordinals::KeTimeStampBundle, pKeTimeStampBundle); xe::store_and_swap(lpKeTimeStampBundle + 0, 0); xe::store_and_swap(lpKeTimeStampBundle + 8, 0); xe::store_and_swap(lpKeTimeStampBundle + 16, Clock::QueryGuestUptimeMillis()); xe::store_and_swap(lpKeTimeStampBundle + 20, 0); timestamp_timer_ = xe::threading::HighResolutionTimer::CreateRepeating( std::chrono::milliseconds(1), [lpKeTimeStampBundle]() { xe::store_and_swap(lpKeTimeStampBundle + 16, Clock::QueryGuestUptimeMillis()); }); } std::vector xboxkrnl_exports(4096); xe::cpu::Export* RegisterExport_xboxkrnl(xe::cpu::Export* export_entry) { assert_true(export_entry->ordinal < xboxkrnl_exports.size()); xboxkrnl_exports[export_entry->ordinal] = export_entry; return export_entry; } void XboxkrnlModule::RegisterExportTable( xe::cpu::ExportResolver* export_resolver) { assert_not_null(export_resolver); // Build the export table used for resolution. #include "xenia/kernel/util/export_table_pre.inc" static xe::cpu::Export xboxkrnl_export_table[] = { #include "xenia/kernel/xboxkrnl_table.inc" }; #include "xenia/kernel/util/export_table_post.inc" for (size_t i = 0; i < xe::countof(xboxkrnl_export_table); ++i) { auto& export_entry = xboxkrnl_export_table[i]; assert_true(export_entry.ordinal < xboxkrnl_exports.size()); if (!xboxkrnl_exports[export_entry.ordinal]) { xboxkrnl_exports[export_entry.ordinal] = &export_entry; } } export_resolver->RegisterTable("xboxkrnl.exe", &xboxkrnl_exports); } XboxkrnlModule::~XboxkrnlModule() = default; int XboxkrnlModule::LaunchModule(const char* path) { // Create and register the module. We keep it local to this function and // dispose it on exit. auto module = kernel_state_->LoadUserModule(path); if (!module) { XELOGE("Failed to load user module %s.", path); return 2; } // Set as the main module, while running. kernel_state_->SetExecutableModule(module); // Launch the module. // NOTE: this won't return until the module exits. X_STATUS result_code = module->Launch(0); // Main thread exited. Terminate the title. kernel_state_->TerminateTitle(); kernel_state_->SetExecutableModule(NULL); if (XFAILED(result_code)) { XELOGE("Failed to launch module %s: %.8X", path, result_code); return 2; } return 0; } } // namespace kernel } // namespace xe