1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
|
//
// Copyright 2019 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// system_utils_win32.cpp: Implementation of OS-specific functions for Windows.
#include "common/FastVector.h"
#include "system_utils.h"
#include <array>
// Must be included in this order.
// clang-format off
#include <windows.h>
#include <psapi.h>
// clang-format on
namespace angle
{
bool UnsetEnvironmentVar(const char *variableName)
{
return (SetEnvironmentVariableW(Widen(variableName).c_str(), nullptr) == TRUE);
}
bool SetEnvironmentVar(const char *variableName, const char *value)
{
return (SetEnvironmentVariableW(Widen(variableName).c_str(), Widen(value).c_str()) == TRUE);
}
std::string GetEnvironmentVar(const char *variableName)
{
std::wstring variableNameUtf16 = Widen(variableName);
FastVector<wchar_t, MAX_PATH> value;
DWORD result;
// First get the length of the variable, including the null terminator
result = GetEnvironmentVariableW(variableNameUtf16.c_str(), nullptr, 0);
// Zero means the variable was not found, so return now.
if (result == 0)
{
return std::string();
}
// Now size the vector to fit the data, and read the environment variable.
value.resize(result, 0);
result = GetEnvironmentVariableW(variableNameUtf16.c_str(), value.data(), result);
return Narrow(value.data());
}
void *OpenSystemLibraryWithExtensionAndGetError(const char *libraryName,
SearchType searchType,
std::string *errorOut)
{
char buffer[MAX_PATH];
int ret = snprintf(buffer, MAX_PATH, "%s.%s", libraryName, GetSharedLibraryExtension());
if (ret <= 0 || ret >= MAX_PATH)
{
fprintf(stderr, "Error loading shared library: 0x%x", ret);
return nullptr;
}
HMODULE libraryModule = nullptr;
switch (searchType)
{
case SearchType::ModuleDir:
{
std::string moduleRelativePath = ConcatenatePath(GetModuleDirectory(), libraryName);
if (errorOut)
{
*errorOut = moduleRelativePath;
}
libraryModule = LoadLibraryW(Widen(moduleRelativePath).c_str());
break;
}
case SearchType::SystemDir:
{
if (errorOut)
{
*errorOut = libraryName;
}
libraryModule =
LoadLibraryExW(Widen(libraryName).c_str(), nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
break;
}
case SearchType::AlreadyLoaded:
{
if (errorOut)
{
*errorOut = libraryName;
}
libraryModule = GetModuleHandleW(Widen(libraryName).c_str());
break;
}
}
return reinterpret_cast<void *>(libraryModule);
}
namespace
{
class Win32PageFaultHandler : public PageFaultHandler
{
public:
Win32PageFaultHandler(PageFaultCallback callback) : PageFaultHandler(callback) {}
~Win32PageFaultHandler() override {}
bool enable() override;
bool disable() override;
LONG handle(PEXCEPTION_POINTERS pExceptionInfo);
private:
void *mVectoredExceptionHandler = nullptr;
};
Win32PageFaultHandler *gWin32PageFaultHandler = nullptr;
static LONG CALLBACK VectoredExceptionHandler(PEXCEPTION_POINTERS info)
{
return gWin32PageFaultHandler->handle(info);
}
bool SetMemoryProtection(uintptr_t start, size_t size, DWORD protections)
{
DWORD oldProtect;
BOOL res = VirtualProtect(reinterpret_cast<LPVOID>(start), size, protections, &oldProtect);
if (!res)
{
DWORD lastError = GetLastError();
fprintf(stderr, "VirtualProtect failed: 0x%lx\n", lastError);
return false;
}
return true;
}
LONG Win32PageFaultHandler::handle(PEXCEPTION_POINTERS info)
{
bool found = false;
if (info->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
info->ExceptionRecord->NumberParameters >= 2 &&
info->ExceptionRecord->ExceptionInformation[0] == 1)
{
found = mCallback(static_cast<uintptr_t>(info->ExceptionRecord->ExceptionInformation[1])) ==
PageFaultHandlerRangeType::InRange;
}
if (found)
{
return EXCEPTION_CONTINUE_EXECUTION;
}
else
{
return EXCEPTION_CONTINUE_SEARCH;
}
}
bool Win32PageFaultHandler::disable()
{
if (mVectoredExceptionHandler)
{
ULONG res = RemoveVectoredExceptionHandler(mVectoredExceptionHandler);
mVectoredExceptionHandler = nullptr;
if (res == 0)
{
DWORD lastError = GetLastError();
fprintf(stderr, "RemoveVectoredExceptionHandler failed: 0x%lx\n", lastError);
return false;
}
}
return true;
}
bool Win32PageFaultHandler::enable()
{
if (mVectoredExceptionHandler)
{
return true;
}
PVECTORED_EXCEPTION_HANDLER handler =
reinterpret_cast<PVECTORED_EXCEPTION_HANDLER>(&VectoredExceptionHandler);
mVectoredExceptionHandler = AddVectoredExceptionHandler(1, handler);
if (!mVectoredExceptionHandler)
{
DWORD lastError = GetLastError();
fprintf(stderr, "AddVectoredExceptionHandler failed: 0x%lx\n", lastError);
return false;
}
return true;
}
} // namespace
// Set write protection
bool ProtectMemory(uintptr_t start, size_t size)
{
return SetMemoryProtection(start, size, PAGE_READONLY);
}
// Allow reading and writing
bool UnprotectMemory(uintptr_t start, size_t size)
{
return SetMemoryProtection(start, size, PAGE_READWRITE);
}
size_t GetPageSize()
{
SYSTEM_INFO info;
GetSystemInfo(&info);
return static_cast<size_t>(info.dwPageSize);
}
PageFaultHandler *CreatePageFaultHandler(PageFaultCallback callback)
{
gWin32PageFaultHandler = new Win32PageFaultHandler(callback);
return gWin32PageFaultHandler;
}
uint64_t GetProcessMemoryUsageKB()
{
PROCESS_MEMORY_COUNTERS_EX pmc;
::GetProcessMemoryInfo(::GetCurrentProcess(), reinterpret_cast<PROCESS_MEMORY_COUNTERS *>(&pmc),
sizeof(pmc));
return static_cast<uint64_t>(pmc.PrivateUsage) / 1024ull;
}
} // namespace angle
|
