hsa_status_t MemoryRegion::AssignAgent(void* ptr, size_t size, const core::Agent& agent, hsa_access_permission_t access) const { if (fine_grain()) { return HSA_STATUS_SUCCESS; } if (std::find(agent.regions().begin(), agent.regions().end(), this) == agent.regions().end()) { return HSA_STATUS_ERROR_INVALID_AGENT; } if (IsLocalMemory()) { HSAuint64 u_ptr = reinterpret_cast<HSAuint64>(ptr); if (u_ptr >= GetBaseAddress() && u_ptr < (GetBaseAddress() + GetVirtualSize())) { // TODO: only support agent allocation buffer. // TODO: commented until API to explicitly unpin memory is available. // if (!MakeKfdMemoryResident(ptr, size)) { // return HSA_STATUS_ERROR_OUT_OF_RESOURCES; //} return HSA_STATUS_SUCCESS; } else { return HSA_STATUS_ERROR_OUT_OF_RESOURCES; } } return HSA_STATUS_SUCCESS; }
void FormatDisassembly::_Format(Address const& rAddress, u32 Flags) { auto& rDoc = m_rCore.GetDocument(); m_rPrintData(rAddress); // Header if (rDoc.GetStartAddress() == rAddress) { m_rPrintData(rAddress); _FormatHeader(rAddress, Flags); } // MemoryArea auto pMemArea = rDoc.GetMemoryArea(rAddress); if (pMemArea != nullptr && pMemArea->GetBaseAddress() == rAddress) { _FormatMemoryArea(rAddress, Flags); m_rPrintData.AppendNewLine(); } // XRefs if (rDoc.HasCrossReferenceFrom(rAddress)) { if (Flags & AddSpaceBeforeXref) m_rPrintData.AppendNewLine(); _FormatXref(rAddress, Flags); m_rPrintData.AppendNewLine(); } // Label auto rLbl = rDoc.GetLabelFromAddress(rAddress); if (rLbl.GetType() != Label::Unknown) { _FormatLabel(rAddress, Flags); m_rPrintData.AppendNewLine(); } // Multicell if (rDoc.GetMultiCell(rAddress) != nullptr) { _FormatMultiCell(rAddress, Flags); m_rPrintData.AppendNewLine(); } if (rDoc.GetCell(rAddress) != nullptr) { _FormatCell(rAddress, Flags); m_rPrintData.AppendNewLine(); } }
////////////////////////////////////////////////////////////////////// // WinMain // ------------------------------------------------------------------- // The meat of the application. ////////////////////////////////////////////////////////////////////// int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { DWORD check; DWORD PatchAddress; DWORD DataAddress; DWORD WinProcAddress; char message[128]; char windowname[128]; char dllFullName[256]; int x; int mode; // Sets up NumWindows, and the windolist[] array of HWND's // See EnumWindowsProc() for deatils..... EnumWindows(EnumWindowsProc, 0); if(NumWindows == 0) MessageBox(NULL, "No D2 Windows found!", "Loader Error", MB_ICONERROR); // Loop through all the D2 windows found for(x=0; x<NumWindows; x++) { // Set the HWND for the current window hd.hwnd = windowlist[x]; // Get Diablo II's Process handle GetWindowThreadProcessId(hd.hwnd, &hd.pid); hd.hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, hd.pid); if (!hd.hProcess) { MessageBox(NULL, "Can't get Diablo II's process handle.", "Loader Error!", MB_ICONERROR); return -1;} // Find a good spot to put our code. Look first for the original game. PatchAddress=GetBaseAddress(hd.pid, M_EXEFILE); // WinProcAddress =PatchAddress + 0x4262c0+11; //from spyxx // WinProcAddress =PatchAddress + 0x425EC0+11; //from spyxx, 1.0.5b WinProcAddress =PatchAddress + 0x42a2e0+11; //from spyxx, 1.0.5b if (!PatchAddress) { MessageBox(NULL, "Unable to find a patch location.", "Loader Error!", MB_ICONERROR); return -1;} // PatchAddress += 0x400; // PatchAddress += 0x5FBF04; PatchAddress += 0x1005; char orig_code[10240]; ReadProcessBYTES(hd.hProcess, PatchAddress, orig_code, 1024); DataAddress = PatchAddress+DATA; // Get location of the game's WinProc // WinProcAddress = GetClassLongPtr(hd.hwnd,GCL_WNDPROC); if (!WinProcAddress) { MessageBox(NULL, "Unable to find WinProc entrypoint.", "Loader Error!", MB_ICONERROR); return -1;} // Initialize our data structure sprintf(hd.ModuleName, "%s", "findwin"); hd.LoaderMagic = LOADERMAGIC; hd.CodeLocation = PatchAddress; hd.LoaderVersion = LOADERVERSION; hd.WinProcLocation = WinProcAddress; hd.WinProcPatchsize = 5; HMODULE hModule = GetModuleHandle("Kernel32.dll"); if (!hModule) { MessageBox(NULL, "Unable to get handle of KERNEL32.DLL.", "Loader Error!", MB_ICONERROR); return -1;} // We're getting offsets to kernel functions from this userspace. // They will be the same inside the game, so we won't need to use // functions imported from the game. hd.pLoadLibraryA = (DWORD)GetProcAddress(hModule, "LoadLibraryA"); if (!hd.pLoadLibraryA ) { MessageBox(NULL, "Unable to get address of LoadLibraryA in KERNEL32.DLL.", "Loader Error!", MB_ICONERROR); return -1;} hd.pFreeLibrary = (DWORD)GetProcAddress(hModule, "FreeLibrary"); if (!hd.pFreeLibrary ) { MessageBox(NULL, "Unable to get address of FreeLibrary in KERNEL32.DLL.", "Loader Error!", MB_ICONERROR); return -1;} hd.pGetModuleHandleA = (DWORD)GetProcAddress(hModule, "GetModuleHandleA"); if (!hd.pGetModuleHandleA ) { MessageBox(NULL, "Unable to get address of GetModuleHandleA in KERNEL32.DLL.", "Loader Error!", MB_ICONERROR); return -1;} // Get the first DWORD from DataAddress to see if we're loading or // unloading. Set up the text for the message box ReadProcessBYTES(hd.hProcess, DataAddress, &check, sizeof(DWORD)); if (check != LOADERMAGIC) { mode = 1; // We are loading strcpy(message, "LOAD "); } else { mode = 0; // We are unloading strcpy(message, "UNLOAD "); } GetWindowText(hd.hwnd, windowname, 127); strcat(message, windowname); strcat(message, "?"); // If a single window was found, or if the user chooses to do so, // run the load/unload procedure against the current window if((NumWindows == 1) || (MessageBox(NULL, message, "Loader Question", MB_YESNO)) == IDYES) { // Patch in our code WriteProcessBYTES(hd.hProcess, PatchAddress, &AsmCode, FUNCTLEN(AsmCode)); // Patch in our data WriteProcessBYTES(hd.hProcess, DataAddress, &hd, sizeof(LOADERDATA)); // Patch in full path+filename to server dll GetCurrentDirectory(255, dllFullName); strcat(dllFullName, "\\findwin.dll"); // strcpy(dllFullName, "c:\\bot\\d3\\findwin.dll"); WriteProcessBYTES(hd.hProcess, DataAddress+sizeof(LOADERDATA), dllFullName, strlen(dllFullName)+1); // Now hi-jack WinProc of the game to our code /* char buf[100]; sprintf(buf,"handle: %x, hwnd:%x, pid:%pid",hd.hProcess,hd.hwnd,hd.pid); MessageBox(NULL, buf, "Loader Error!", MB_ICONERROR);*/ Intercept(hd.hProcess, INST_CALL, WinProcAddress, PatchAddress, LEN); // Send WM_APP to toggle load/unload of the dll SendMessage(hd.hwnd, WM_APP,0,0); // Give back WinProc, we don't need it anymore Intercept(hd.hProcess, INST_CALL, PatchAddress, WinProcAddress, LEN); WriteProcessBYTES(hd.hProcess, PatchAddress, orig_code, 1024); // If we're unloading, then clear LOADERMAGIC from the data area if(mode == 0) { check = 0; WriteProcessBYTES(hd.hProcess, DataAddress, &check, sizeof(DWORD)); } } } return 0; }
bool IsCellPresent(TOffset Offset) const { return GetBaseAddress().IsBetween(GetSize(), Offset); }
bool IsCellPresent(Address const& rAddress) const { if (GetBaseAddress().GetBase() != rAddress.GetBase()) return false; return IsCellPresent(rAddress.GetOffset()); }
HRESULT CNktDvModule::ToString(__inout CNktStringW &cStrDest) { if (cStrDest.Format(L"CNktDvModule [Base:%IXh / %s]", GetBaseAddress(), GetFileName()) == FALSE) return E_OUTOFMEMORY; return S_OK; }
hsa_status_t MemoryRegion::GetInfo(hsa_region_info_t attribute, void* value) const { switch (attribute) { case HSA_REGION_INFO_SEGMENT: switch (mem_props_.HeapType) { case HSA_HEAPTYPE_SYSTEM: case HSA_HEAPTYPE_FRAME_BUFFER_PRIVATE: case HSA_HEAPTYPE_FRAME_BUFFER_PUBLIC: *((hsa_region_segment_t*)value) = HSA_REGION_SEGMENT_GLOBAL; break; case HSA_HEAPTYPE_GPU_LDS: *((hsa_region_segment_t*)value) = HSA_REGION_SEGMENT_GROUP; break; default: assert(false && "Memory region should only be global, group"); break; } break; case HSA_REGION_INFO_GLOBAL_FLAGS: switch (mem_props_.HeapType) { case HSA_HEAPTYPE_SYSTEM: *((uint32_t*)value) = (HSA_REGION_GLOBAL_FLAG_KERNARG | HSA_REGION_GLOBAL_FLAG_FINE_GRAINED); break; case HSA_HEAPTYPE_FRAME_BUFFER_PRIVATE: case HSA_HEAPTYPE_FRAME_BUFFER_PUBLIC: *((uint32_t*)value) = HSA_REGION_GLOBAL_FLAG_COARSE_GRAINED; break; default: *((uint32_t*)value) = 0; break; } break; case HSA_REGION_INFO_SIZE: switch (mem_props_.HeapType) { case HSA_HEAPTYPE_FRAME_BUFFER_PRIVATE: case HSA_HEAPTYPE_FRAME_BUFFER_PUBLIC: // TODO: report the actual physical size of local memory until API to // explicitly unpin memory is available. *((size_t*)value) = static_cast<size_t>(GetPhysicalSize()); break; default: *((size_t*)value) = static_cast<size_t>(GetVirtualSize()); break; } break; case HSA_REGION_INFO_ALLOC_MAX_SIZE: switch (mem_props_.HeapType) { case HSA_HEAPTYPE_FRAME_BUFFER_PRIVATE: case HSA_HEAPTYPE_FRAME_BUFFER_PUBLIC: case HSA_HEAPTYPE_SYSTEM: *((size_t*)value) = max_single_alloc_size_; break; default: *((size_t*)value) = 0; } break; case HSA_REGION_INFO_RUNTIME_ALLOC_ALLOWED: switch (mem_props_.HeapType) { case HSA_HEAPTYPE_SYSTEM: case HSA_HEAPTYPE_FRAME_BUFFER_PRIVATE: case HSA_HEAPTYPE_FRAME_BUFFER_PUBLIC: *((bool*)value) = true; break; default: *((bool*)value) = false; break; } break; case HSA_REGION_INFO_RUNTIME_ALLOC_GRANULE: // TODO: remove the hardcoded value. switch (mem_props_.HeapType) { case HSA_HEAPTYPE_SYSTEM: case HSA_HEAPTYPE_FRAME_BUFFER_PRIVATE: case HSA_HEAPTYPE_FRAME_BUFFER_PUBLIC: *((size_t*)value) = kPageSize_; break; default: *((size_t*)value) = 0; break; } break; case HSA_REGION_INFO_RUNTIME_ALLOC_ALIGNMENT: // TODO: remove the hardcoded value. switch (mem_props_.HeapType) { case HSA_HEAPTYPE_SYSTEM: case HSA_HEAPTYPE_FRAME_BUFFER_PRIVATE: case HSA_HEAPTYPE_FRAME_BUFFER_PUBLIC: *((size_t*)value) = kPageSize_; break; default: *((size_t*)value) = 0; break; } break; default: switch ((hsa_amd_region_info_t)attribute) { case HSA_AMD_REGION_INFO_HOST_ACCESSIBLE: *((bool*)value) = (mem_props_.HeapType == HSA_HEAPTYPE_SYSTEM) ? true : false; break; case HSA_AMD_REGION_INFO_BASE: *((void**)value) = reinterpret_cast<void*>(GetBaseAddress()); break; default: return HSA_STATUS_ERROR_INVALID_ARGUMENT; break; } break; } return HSA_STATUS_SUCCESS; }