[rustc.git] / vendor / winapi / src / um / processthreadsapi.rs

// Licensed under the Apache License, Version 2.0
// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
// All files in the project carrying such notice may not be copied, modified, or distributed
// except according to those terms
//! ApiSet Contract for api-ms-win-core-processthreads-l1
use ctypes::{c_int, c_void};
use shared::basetsd::{DWORD_PTR, PSIZE_T, PULONG_PTR, SIZE_T, ULONG_PTR};
use shared::guiddef::LPCGUID;
use shared::minwindef::{
    BOOL, DWORD, LPBYTE, LPCVOID, LPDWORD, LPFILETIME, LPVOID, PBOOL, PDWORD, PULONG, UINT, WORD
};
use um::minwinbase::{LPCONTEXT, LPSECURITY_ATTRIBUTES, LPTHREAD_START_ROUTINE};
use um::winnt::{
    CONTEXT, HANDLE, LPCSTR, LPCWSTR, LPSTR, LPWSTR, PAPCFUNC, PHANDLE, PPROCESSOR_NUMBER,
    PROCESS_MITIGATION_POLICY, PVOID
};
STRUCT!{struct PROCESS_INFORMATION {
    hProcess: HANDLE,
    hThread: HANDLE,
    dwProcessId: DWORD,
    dwThreadId: DWORD,
}}
pub type PPROCESS_INFORMATION = *mut PROCESS_INFORMATION;
pub type LPPROCESS_INFORMATION = *mut PROCESS_INFORMATION;
STRUCT!{struct STARTUPINFOA {
    cb: DWORD,
    lpReserved: LPSTR,
    lpDesktop: LPSTR,
    lpTitle: LPSTR,
    dwX: DWORD,
    dwY: DWORD,
    dwXSize: DWORD,
    dwYSize: DWORD,
    dwXCountChars: DWORD,
    dwYCountChars: DWORD,
    dwFillAttribute: DWORD,
    dwFlags: DWORD,
    wShowWindow: WORD,
    cbReserved2: WORD,
    lpReserved2: LPBYTE,
    hStdInput: HANDLE,
    hStdOutput: HANDLE,
    hStdError: HANDLE,
}}
pub type LPSTARTUPINFOA = *mut STARTUPINFOA;
STRUCT!{struct STARTUPINFOW {
    cb: DWORD,
    lpReserved: LPWSTR,
    lpDesktop: LPWSTR,
    lpTitle: LPWSTR,
    dwX: DWORD,
    dwY: DWORD,
    dwXSize: DWORD,
    dwYSize: DWORD,
    dwXCountChars: DWORD,
    dwYCountChars: DWORD,
    dwFillAttribute: DWORD,
    dwFlags: DWORD,
    wShowWindow: WORD,
    cbReserved2: WORD,
    lpReserved2: LPBYTE,
    hStdInput: HANDLE,
    hStdOutput: HANDLE,
    hStdError: HANDLE,
}}
pub type LPSTARTUPINFOW = *mut STARTUPINFOW;
extern "system" {
    pub fn QueueUserAPC(
        pfnAPC: PAPCFUNC,
        hThread: HANDLE,
        dwData: ULONG_PTR,
    ) -> DWORD;
    pub fn GetProcessTimes(
        hProcess: HANDLE,
        lpCreationTime: LPFILETIME,
        lpExitTime: LPFILETIME,
        lpKernelTime: LPFILETIME,
        lpUserTime: LPFILETIME,
    ) -> BOOL;
    pub fn GetCurrentProcess() -> HANDLE;
    pub fn GetCurrentProcessId() -> DWORD;
    pub fn ExitProcess(
        uExitCode: UINT,
    );
    pub fn TerminateProcess(
        hProcess: HANDLE,
        uExitCode: UINT,
    ) -> BOOL;
    pub fn GetExitCodeProcess(
        hProcess: HANDLE,
        lpExitCode: LPDWORD,
    ) -> BOOL;
    pub fn SwitchToThread() -> BOOL;
    pub fn CreateThread(
        lpThreadAttributes: LPSECURITY_ATTRIBUTES,
        dwStackSize: SIZE_T,
        lpStartAddress: LPTHREAD_START_ROUTINE,
        lpParameter: LPVOID,
        dwCreationFlags: DWORD,
        lpThreadId: LPDWORD,
    ) -> HANDLE;
    pub fn CreateRemoteThread(
        hProcess: HANDLE,
        lpThreadAttributes: LPSECURITY_ATTRIBUTES,
        dwStackSize: SIZE_T,
        lpStartAddress: LPTHREAD_START_ROUTINE,
        lpParameter: LPVOID,
        dwCreationFlags: DWORD,
        lpThreadId: LPDWORD,
    ) -> HANDLE;
    pub fn GetCurrentThread() -> HANDLE;
    pub fn GetCurrentThreadId() -> DWORD;
    pub fn OpenThread(
        dwDesiredAccess: DWORD,
        bInheritHandle: BOOL,
        dwThreadId: DWORD,
    ) -> HANDLE;
    pub fn SetThreadPriority(
        hThread: HANDLE,
        nPriority: c_int,
    ) -> BOOL;
    pub fn SetThreadPriorityBoost(
        hThread: HANDLE,
        bDisablePriorityBoost: BOOL,
    ) -> BOOL;
    pub fn GetThreadPriorityBoost(
        hThread: HANDLE,
        pDisablePriorityBoost: PBOOL,
    ) -> BOOL;
    pub fn GetThreadPriority(
        hThread: HANDLE,
    ) -> c_int;
    pub fn ExitThread(
        dwExitCode: DWORD,
    );
    pub fn TerminateThread(
        hThread: HANDLE,
        dwExitCode: DWORD,
    ) -> BOOL;
    pub fn GetExitCodeThread(
        hThread: HANDLE,
        lpExitCode: LPDWORD,
    ) -> BOOL;
    pub fn SuspendThread(
        hThread: HANDLE,
    ) -> DWORD;
    pub fn ResumeThread(
        hThread: HANDLE,
    ) -> DWORD;
}
pub const TLS_OUT_OF_INDEXES: DWORD = 0xFFFFFFFF;
extern "system" {
    pub fn TlsAlloc() -> DWORD;
    pub fn TlsGetValue(
        dwTlsIndex: DWORD,
    ) -> LPVOID;
    pub fn TlsSetValue(
        dwTlsIndex: DWORD,
        lpTlsValue: LPVOID,
    ) -> BOOL;
    pub fn TlsFree(
        dwTlsIndex: DWORD,
    ) -> BOOL;
    pub fn CreateProcessA(
        lpApplicationName: LPCSTR,
        lpCommandLine: LPSTR,
        lpProcessAttributes: LPSECURITY_ATTRIBUTES,
        lpThreadAttributes: LPSECURITY_ATTRIBUTES,
        bInheritHandles: BOOL,
        dwCreationFlags: DWORD,
        lpEnvironment: LPVOID,
        lpCurrentDirectory: LPCSTR,
        lpStartupInfo: LPSTARTUPINFOA,
        lpProcessInformation: LPPROCESS_INFORMATION,
    ) -> BOOL;
    pub fn CreateProcessW(
        lpApplicationName: LPCWSTR,
        lpCommandLine: LPWSTR,
        lpProcessAttributes: LPSECURITY_ATTRIBUTES,
        lpThreadAttributes: LPSECURITY_ATTRIBUTES,
        bInheritHandles: BOOL,
        dwCreationFlags: DWORD,
        lpEnvironment: LPVOID,
        lpCurrentDirectory: LPCWSTR,
        lpStartupInfo: LPSTARTUPINFOW,
        lpProcessInformation: LPPROCESS_INFORMATION,
    ) -> BOOL;
    pub fn SetProcessShutdownParameters(
        dwLevel: DWORD,
        dwFlags: DWORD,
    ) -> BOOL;
    pub fn GetProcessVersion(
        ProcessId: DWORD,
    ) -> DWORD;
    pub fn GetStartupInfoW(
        lpStartupInfo: LPSTARTUPINFOW,
    );
    pub fn CreateProcessAsUserW(
        hToken: HANDLE,
        lpApplicationName: LPCWSTR,
        lpCommandLine: LPWSTR,
        lpProcessAttributes: LPSECURITY_ATTRIBUTES,
        lpThreadAttributes: LPSECURITY_ATTRIBUTES,
        bInheritHandles: BOOL,
        dwCreationFlags: DWORD,
        lpEnvironment: LPVOID,
        lpCurrentDirectory: LPCWSTR,
        lpStartupInfo: LPSTARTUPINFOW,
        lpProcessInformation: LPPROCESS_INFORMATION,
    ) -> BOOL;
    // pub fn GetCurrentProcessToken();
    // pub fn GetCurrentThreadToken();
    // pub fn GetCurrentThreadEffectiveToken();
    pub fn SetThreadToken(
        Thread: PHANDLE,
        Token: HANDLE,
    ) -> BOOL;
    pub fn OpenProcessToken(
        ProcessHandle: HANDLE,
        DesiredAccess: DWORD,
        TokenHandle: PHANDLE,
    ) -> BOOL;
    pub fn OpenThreadToken(
        ThreadHandle: HANDLE,
        DesiredAccess: DWORD,
        OpenAsSelf: BOOL,
        TokenHandle: PHANDLE,
    ) -> BOOL;
    pub fn SetPriorityClass(
        hProcess: HANDLE,
        dwPriorityClass: DWORD,
    ) -> BOOL;
    pub fn SetThreadStackGuarantee(
        StackSizeInBytes: PULONG,
    ) -> BOOL;
    pub fn GetPriorityClass(
        hProcess: HANDLE,
    ) -> DWORD;
    pub fn ProcessIdToSessionId(
        dwProcessId: DWORD,
        pSessionId: *mut DWORD,
    ) -> BOOL;
    pub fn GetProcessId(
        Process: HANDLE,
    ) -> DWORD;
}
STRUCT!{struct PROC_THREAD_ATTRIBUTE_LIST {
    dummy: *mut c_void,
}}
pub type PPROC_THREAD_ATTRIBUTE_LIST = *mut PROC_THREAD_ATTRIBUTE_LIST;
pub type LPPROC_THREAD_ATTRIBUTE_LIST = *mut PROC_THREAD_ATTRIBUTE_LIST;
extern "system" {
    pub fn GetThreadId(
        Thread: HANDLE,
    ) -> DWORD;
    pub fn FlushProcessWriteBuffers();
    pub fn GetProcessIdOfThread(
        Thread: HANDLE,
    ) -> DWORD;
    pub fn InitializeProcThreadAttributeList(
        lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST,
        dwAttributeCount: DWORD,
        dwFlags: DWORD,
        lpSize: PSIZE_T,
    ) -> BOOL;
    pub fn DeleteProcThreadAttributeList(
        lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST,
    );
    pub fn SetProcessAffinityUpdateMode(
        hProcess: HANDLE,
        dwFlags: DWORD,
    ) -> BOOL;
    pub fn QueryProcessAffinityUpdateMode(
        hProcess: HANDLE,
        lpdwFlags: LPDWORD,
    ) -> BOOL;
    pub fn UpdateProcThreadAttribute(
        lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST,
        dwFlags: DWORD,
        Attribute: DWORD_PTR,
        lpValue: PVOID,
        cbSize: SIZE_T,
        lpPreviousValue: PVOID,
        lpReturnSize: PSIZE_T,
    ) -> BOOL;
    pub fn CreateRemoteThreadEx(
        hProcess: HANDLE,
        lpThreadAttributes: LPSECURITY_ATTRIBUTES,
        dwStackSize: SIZE_T,
        lpStartAddress: LPTHREAD_START_ROUTINE,
        lpParameter: LPVOID,
        dwCreationFlags: DWORD,
        lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST,
        lpThreadId: LPDWORD,
    ) -> HANDLE;
    pub fn GetCurrentThreadStackLimits(
        LowLimit: PULONG_PTR,
        HighLimit: PULONG_PTR,
    );
    pub fn GetThreadContext(
        hThread: HANDLE,
        lpContext: LPCONTEXT,
    ) -> BOOL;
    pub fn SetThreadContext(
        hThread: HANDLE,
        lpContext: *const CONTEXT,
    ) -> BOOL;
    pub fn SetProcessMitigationPolicy(
        MitigationPolicy: PROCESS_MITIGATION_POLICY,
        lpBuffer: PVOID,
        dwLength: SIZE_T,
    ) -> BOOL;
    pub fn GetProcessMitigationPolicy(
        hProcess: HANDLE,
        MitigationPolicy: PROCESS_MITIGATION_POLICY,
        lpBuffer: PVOID,
        dwLength: SIZE_T,
    ) -> BOOL;
    pub fn FlushInstructionCache(
        hProcess: HANDLE,
        lpBaseAddress: LPCVOID,
        dwSize: SIZE_T,
    ) -> BOOL;
    pub fn GetThreadTimes(
        hThread: HANDLE,
        lpCreationTime: LPFILETIME,
        lpExitTime: LPFILETIME,
        lpKernelTime: LPFILETIME,
        lpUserTime: LPFILETIME,
    ) -> BOOL;
    pub fn OpenProcess(
        dwDesiredAccess: DWORD,
        bInheritHandle: BOOL,
        dwProcessId: DWORD,
    ) -> HANDLE;
    pub fn IsProcessorFeaturePresent(
        ProcessorFeature: DWORD,
    ) -> BOOL;
    pub fn GetProcessHandleCount(
        hProcess: HANDLE,
        pdwHandleCount: PDWORD,
    ) -> BOOL;
    pub fn GetCurrentProcessorNumber() -> DWORD;
    pub fn SetThreadIdealProcessorEx(
        hThread: HANDLE,
        lpIdealProcessor: PPROCESSOR_NUMBER,
        lpPreviousIdealProcessor: PPROCESSOR_NUMBER,
    ) -> BOOL;
    pub fn GetThreadIdealProcessorEx(
        hThread: HANDLE,
        lpIdealProcessor: PPROCESSOR_NUMBER,
    ) -> BOOL;
    pub fn GetCurrentProcessorNumberEx(
        ProcNumber: PPROCESSOR_NUMBER,
    );
    pub fn GetProcessPriorityBoost(
        hProcess: HANDLE,
        pDisablePriorityBoost: PBOOL,
    ) -> BOOL;
    pub fn SetProcessPriorityBoost(
        hProcess: HANDLE,
        bDisablePriorityBoost: BOOL,
    ) -> BOOL;
    pub fn GetThreadIOPendingFlag(
        hThread: HANDLE,
        lpIOIsPending: PBOOL,
    ) -> BOOL;
    pub fn GetSystemTimes(
        lpIdleTime: LPFILETIME,
        lpKernelTime: LPFILETIME,
        lpUserTime: LPFILETIME,
    ) -> BOOL;
}
ENUM!{enum THREAD_INFORMATION_CLASS {
    ThreadMemoryPriority,
    ThreadAbsoluteCpuPriority,
    ThreadInformationClassMax,
}}
// MEMORY_PRIORITY_INFORMATION
extern "system" {
    pub fn GetThreadInformation(
        hThread: HANDLE,
        ThreadInformationClass: THREAD_INFORMATION_CLASS,
        ThreadInformation: LPVOID,
        ThreadInformationSize: DWORD,
    ) -> BOOL;
    pub fn SetThreadInformation(
        hThread: HANDLE,
        ThreadInformationClass: THREAD_INFORMATION_CLASS,
        ThreadInformation: LPVOID,
        ThreadInformationSize: DWORD,
    ) -> BOOL;
    pub fn IsProcessCritical(
        hProcess: HANDLE,
        Critical: PBOOL,
    ) -> BOOL;
    pub fn SetProtectedPolicy(
        PolicyGuid: LPCGUID,
        PolicyValue: ULONG_PTR,
        OldPolicyValue: PULONG_PTR,
    ) -> BOOL;
    pub fn QueryProtectedPolicy(
        PolicyGuid: LPCGUID,
        PolicyValue: PULONG_PTR,
    ) -> BOOL;
    pub fn SetThreadIdealProcessor(
        hThread: HANDLE,
        dwIdealProcessor: DWORD,
    ) -> DWORD;
}
ENUM!{enum PROCESS_INFORMATION_CLASS {
    ProcessMemoryPriority,
    ProcessInformationClassMax,
}}
extern "system" {
    pub fn SetProcessInformation(
        hProcess: HANDLE,
        ProcessInformationClass: PROCESS_INFORMATION_CLASS,
        ProcessInformation: LPVOID,
        ProcessInformationSize: DWORD,
    ) -> BOOL;
    pub fn GetProcessInformation(
        hProcess: HANDLE,
        ProcessInformationClass: PROCESS_INFORMATION_CLASS,
        ProcessInformation: LPVOID,
        ProcessInformationSize: DWORD,
    ) -> BOOL;
    // pub fn GetSystemCpuSetInformation();
    // pub fn GetProcessDefaultCpuSets();
    // pub fn SetProcessDefaultCpuSets();
    // pub fn GetThreadSelectedCpuSets();
    // pub fn SetThreadSelectedCpuSets();
    // pub fn CreateProcessAsUserA();
    pub fn GetProcessShutdownParameters(
        lpdwLevel: LPDWORD,
        lpdwFlags: LPDWORD,
    ) -> BOOL;
    // pub fn SetThreadDescription();
    // pub fn GetThreadDescription();
}
Commit	Line	Data
ff7c6d11 XL	1	// Licensed under the Apache License, Version 2.0
	2	// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
	3	// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
	4	// All files in the project carrying such notice may not be copied, modified, or distributed
	5	// except according to those terms
	6	//! ApiSet Contract for api-ms-win-core-processthreads-l1
ff7c6d11 XL	7	use ctypes::{c_int, c_void};
	8	use shared::basetsd::{DWORD_PTR, PSIZE_T, PULONG_PTR, SIZE_T, ULONG_PTR};
	9	use shared::guiddef::LPCGUID;
	10	use shared::minwindef::{
	11	BOOL, DWORD, LPBYTE, LPCVOID, LPDWORD, LPFILETIME, LPVOID, PBOOL, PDWORD, PULONG, UINT, WORD
	12	};
	13	use um::minwinbase::{LPCONTEXT, LPSECURITY_ATTRIBUTES, LPTHREAD_START_ROUTINE};
	14	use um::winnt::{
	15	CONTEXT, HANDLE, LPCSTR, LPCWSTR, LPSTR, LPWSTR, PAPCFUNC, PHANDLE, PPROCESSOR_NUMBER,
	16	PROCESS_MITIGATION_POLICY, PVOID
	17	};
ff7c6d11 XL	18	STRUCT!{struct PROCESS_INFORMATION {
	19	hProcess: HANDLE,
	20	hThread: HANDLE,
	21	dwProcessId: DWORD,
	22	dwThreadId: DWORD,
	23	}}
	24	pub type PPROCESS_INFORMATION = *mut PROCESS_INFORMATION;
	25	pub type LPPROCESS_INFORMATION = *mut PROCESS_INFORMATION;
	26	STRUCT!{struct STARTUPINFOA {
	27	cb: DWORD,
	28	lpReserved: LPSTR,
	29	lpDesktop: LPSTR,
	30	lpTitle: LPSTR,
	31	dwX: DWORD,
	32	dwY: DWORD,
	33	dwXSize: DWORD,
	34	dwYSize: DWORD,
	35	dwXCountChars: DWORD,
	36	dwYCountChars: DWORD,
	37	dwFillAttribute: DWORD,
	38	dwFlags: DWORD,
	39	wShowWindow: WORD,
	40	cbReserved2: WORD,
	41	lpReserved2: LPBYTE,
	42	hStdInput: HANDLE,
	43	hStdOutput: HANDLE,
	44	hStdError: HANDLE,
	45	}}
	46	pub type LPSTARTUPINFOA = *mut STARTUPINFOA;
	47	STRUCT!{struct STARTUPINFOW {
	48	cb: DWORD,
	49	lpReserved: LPWSTR,
	50	lpDesktop: LPWSTR,
	51	lpTitle: LPWSTR,
	52	dwX: DWORD,
	53	dwY: DWORD,
	54	dwXSize: DWORD,
	55	dwYSize: DWORD,
	56	dwXCountChars: DWORD,
	57	dwYCountChars: DWORD,
	58	dwFillAttribute: DWORD,
	59	dwFlags: DWORD,
	60	wShowWindow: WORD,
	61	cbReserved2: WORD,
	62	lpReserved2: LPBYTE,
	63	hStdInput: HANDLE,
	64	hStdOutput: HANDLE,
	65	hStdError: HANDLE,
	66	}}
	67	pub type LPSTARTUPINFOW = *mut STARTUPINFOW;
	68	extern "system" {
	69	pub fn QueueUserAPC(
	70	pfnAPC: PAPCFUNC,
	71	hThread: HANDLE,
	72	dwData: ULONG_PTR,
	73	) -> DWORD;
	74	pub fn GetProcessTimes(
	75	hProcess: HANDLE,
	76	lpCreationTime: LPFILETIME,
	77	lpExitTime: LPFILETIME,
	78	lpKernelTime: LPFILETIME,
	79	lpUserTime: LPFILETIME,
	80	) -> BOOL;
	81	pub fn GetCurrentProcess() -> HANDLE;
82	pub fn GetCurrentProcessId() -> DWORD;
83	pub fn ExitProcess(
84	uExitCode: UINT,
85	);
86	pub fn TerminateProcess(
87	hProcess: HANDLE,
88	uExitCode: UINT,
89	) -> BOOL;
90	pub fn GetExitCodeProcess(
91	hProcess: HANDLE,
92	lpExitCode: LPDWORD,
93	) -> BOOL;
94	pub fn SwitchToThread() -> BOOL;
95	pub fn CreateThread(
96	lpThreadAttributes: LPSECURITY_ATTRIBUTES,
97	dwStackSize: SIZE_T,
98	lpStartAddress: LPTHREAD_START_ROUTINE,
99	lpParameter: LPVOID,
100	dwCreationFlags: DWORD,
101	lpThreadId: LPDWORD,
102	) -> HANDLE;
103	pub fn CreateRemoteThread(
104	hProcess: HANDLE,
105	lpThreadAttributes: LPSECURITY_ATTRIBUTES,
106	dwStackSize: SIZE_T,
107	lpStartAddress: LPTHREAD_START_ROUTINE,
108	lpParameter: LPVOID,
109	dwCreationFlags: DWORD,
110	lpThreadId: LPDWORD,
111	) -> HANDLE;
112	pub fn GetCurrentThread() -> HANDLE;
113	pub fn GetCurrentThreadId() -> DWORD;
114	pub fn OpenThread(
115	dwDesiredAccess: DWORD,
116	bInheritHandle: BOOL,
117	dwThreadId: DWORD,
118	) -> HANDLE;
119	pub fn SetThreadPriority(
120	hThread: HANDLE,
121	nPriority: c_int,
122	) -> BOOL;
123	pub fn SetThreadPriorityBoost(
124	hThread: HANDLE,
125	bDisablePriorityBoost: BOOL,
126	) -> BOOL;
127	pub fn GetThreadPriorityBoost(
128	hThread: HANDLE,
129	pDisablePriorityBoost: PBOOL,
130	) -> BOOL;
131	pub fn GetThreadPriority(
132	hThread: HANDLE,
133	) -> c_int;
134	pub fn ExitThread(
135	dwExitCode: DWORD,
136	);
137	pub fn TerminateThread(
138	hThread: HANDLE,
139	dwExitCode: DWORD,
140	) -> BOOL;
141	pub fn GetExitCodeThread(
142	hThread: HANDLE,
143	lpExitCode: LPDWORD,
144	) -> BOOL;
145	pub fn SuspendThread(
146	hThread: HANDLE,
147	) -> DWORD;
148	pub fn ResumeThread(
149	hThread: HANDLE,
150	) -> DWORD;
151	}
152	pub const TLS_OUT_OF_INDEXES: DWORD = 0xFFFFFFFF;
153	extern "system" {
154	pub fn TlsAlloc() -> DWORD;
155	pub fn TlsGetValue(
156	dwTlsIndex: DWORD,
157	) -> LPVOID;
158	pub fn TlsSetValue(
159	dwTlsIndex: DWORD,
160	lpTlsValue: LPVOID,
161	) -> BOOL;
162	pub fn TlsFree(
163	dwTlsIndex: DWORD,
164	) -> BOOL;
165	pub fn CreateProcessA(
166	lpApplicationName: LPCSTR,
167	lpCommandLine: LPSTR,
168	lpProcessAttributes: LPSECURITY_ATTRIBUTES,
169	lpThreadAttributes: LPSECURITY_ATTRIBUTES,
170	bInheritHandles: BOOL,
171	dwCreationFlags: DWORD,
172	lpEnvironment: LPVOID,
173	lpCurrentDirectory: LPCSTR,
174	lpStartupInfo: LPSTARTUPINFOA,
175	lpProcessInformation: LPPROCESS_INFORMATION,
176	) -> BOOL;
177	pub fn CreateProcessW(
178	lpApplicationName: LPCWSTR,
179	lpCommandLine: LPWSTR,
180	lpProcessAttributes: LPSECURITY_ATTRIBUTES,
181	lpThreadAttributes: LPSECURITY_ATTRIBUTES,
182	bInheritHandles: BOOL,
183	dwCreationFlags: DWORD,
184	lpEnvironment: LPVOID,
185	lpCurrentDirectory: LPCWSTR,
186	lpStartupInfo: LPSTARTUPINFOW,
187	lpProcessInformation: LPPROCESS_INFORMATION,
188	) -> BOOL;
189	pub fn SetProcessShutdownParameters(
190	dwLevel: DWORD,
191	dwFlags: DWORD,
192	) -> BOOL;
193	pub fn GetProcessVersion(
194	ProcessId: DWORD,
195	) -> DWORD;
196	pub fn GetStartupInfoW(
197	lpStartupInfo: LPSTARTUPINFOW,
198	);
8faf50e0 XL	199	pub fn CreateProcessAsUserW(
	200	hToken: HANDLE,
	201	lpApplicationName: LPCWSTR,
	202	lpCommandLine: LPWSTR,
	203	lpProcessAttributes: LPSECURITY_ATTRIBUTES,
	204	lpThreadAttributes: LPSECURITY_ATTRIBUTES,
	205	bInheritHandles: BOOL,
	206	dwCreationFlags: DWORD,
	207	lpEnvironment: LPVOID,
	208	lpCurrentDirectory: LPCWSTR,
	209	lpStartupInfo: LPSTARTUPINFOW,
	210	lpProcessInformation: LPPROCESS_INFORMATION,
	211	) -> BOOL;
ff7c6d11 XL	212	// pub fn GetCurrentProcessToken();
	213	// pub fn GetCurrentThreadToken();
	214	// pub fn GetCurrentThreadEffectiveToken();
8faf50e0 XL	215	pub fn SetThreadToken(
	216	Thread: PHANDLE,
	217	Token: HANDLE,
	218	) -> BOOL;
ff7c6d11 XL	219	pub fn OpenProcessToken(
	220	ProcessHandle: HANDLE,
	221	DesiredAccess: DWORD,
	222	TokenHandle: PHANDLE,
	223	) -> BOOL;
8faf50e0 XL	224	pub fn OpenThreadToken(
	225	ThreadHandle: HANDLE,
	226	DesiredAccess: DWORD,
	227	OpenAsSelf: BOOL,
	228	TokenHandle: PHANDLE,
	229	) -> BOOL;
ff7c6d11 XL	230	pub fn SetPriorityClass(
	231	hProcess: HANDLE,
	232	dwPriorityClass: DWORD,
	233	) -> BOOL;
	234	pub fn SetThreadStackGuarantee(
	235	StackSizeInBytes: PULONG,
	236	) -> BOOL;
	237	pub fn GetPriorityClass(
	238	hProcess: HANDLE,
	239	) -> DWORD;
	240	pub fn ProcessIdToSessionId(
	241	dwProcessId: DWORD,
	242	pSessionId: *mut DWORD,
	243	) -> BOOL;
	244	pub fn GetProcessId(
	245	Process: HANDLE,
	246	) -> DWORD;
	247	}
	248	STRUCT!{struct PROC_THREAD_ATTRIBUTE_LIST {
	249	dummy: *mut c_void,
	250	}}
	251	pub type PPROC_THREAD_ATTRIBUTE_LIST = *mut PROC_THREAD_ATTRIBUTE_LIST;
	252	pub type LPPROC_THREAD_ATTRIBUTE_LIST = *mut PROC_THREAD_ATTRIBUTE_LIST;
	253	extern "system" {
	254	pub fn GetThreadId(
	255	Thread: HANDLE,
	256	) -> DWORD;
	257	pub fn FlushProcessWriteBuffers();
	258	pub fn GetProcessIdOfThread(
	259	Thread: HANDLE,
	260	) -> DWORD;
	261	pub fn InitializeProcThreadAttributeList(
	262	lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST,
	263	dwAttributeCount: DWORD,
	264	dwFlags: DWORD,
	265	lpSize: PSIZE_T,
	266	) -> BOOL;
	267	pub fn DeleteProcThreadAttributeList(
	268	lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST,
	269	);
	270	pub fn SetProcessAffinityUpdateMode(
	271	hProcess: HANDLE,
	272	dwFlags: DWORD,
	273	) -> BOOL;
	274	pub fn QueryProcessAffinityUpdateMode(
	275	hProcess: HANDLE,
	276	lpdwFlags: LPDWORD,
	277	) -> BOOL;
	278	pub fn UpdateProcThreadAttribute(
	279	lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST,
	280	dwFlags: DWORD,
	281	Attribute: DWORD_PTR,
	282	lpValue: PVOID,
	283	cbSize: SIZE_T,
	284	lpPreviousValue: PVOID,
	285	lpReturnSize: PSIZE_T,
	286	) -> BOOL;
	287	pub fn CreateRemoteThreadEx(
	288	hProcess: HANDLE,
	289	lpThreadAttributes: LPSECURITY_ATTRIBUTES,
	290	dwStackSize: SIZE_T,
	291	lpStartAddress: LPTHREAD_START_ROUTINE,
	292	lpParameter: LPVOID,
	293	dwCreationFlags: DWORD,
294	lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST,
295	lpThreadId: LPDWORD,
296	) -> HANDLE;
297	pub fn GetCurrentThreadStackLimits(
298	LowLimit: PULONG_PTR,
299	HighLimit: PULONG_PTR,
300	);
301	pub fn GetThreadContext(
302	hThread: HANDLE,
303	lpContext: LPCONTEXT,
304	) -> BOOL;
305	pub fn SetThreadContext(
306	hThread: HANDLE,
307	lpContext: *const CONTEXT,
308	) -> BOOL;
309	pub fn SetProcessMitigationPolicy(
310	MitigationPolicy: PROCESS_MITIGATION_POLICY,
311	lpBuffer: PVOID,
312	dwLength: SIZE_T,
313	) -> BOOL;
314	pub fn GetProcessMitigationPolicy(
315	hProcess: HANDLE,
316	MitigationPolicy: PROCESS_MITIGATION_POLICY,
317	lpBuffer: PVOID,
318	dwLength: SIZE_T,
319	) -> BOOL;
320	pub fn FlushInstructionCache(
321	hProcess: HANDLE,
322	lpBaseAddress: LPCVOID,
323	dwSize: SIZE_T,
324	) -> BOOL;
325	pub fn GetThreadTimes(
326	hThread: HANDLE,
327	lpCreationTime: LPFILETIME,
328	lpExitTime: LPFILETIME,
329	lpKernelTime: LPFILETIME,
330	lpUserTime: LPFILETIME,
331	) -> BOOL;
332	pub fn OpenProcess(
333	dwDesiredAccess: DWORD,
334	bInheritHandle: BOOL,
335	dwProcessId: DWORD,
336	) -> HANDLE;
337	pub fn IsProcessorFeaturePresent(
338	ProcessorFeature: DWORD,
339	) -> BOOL;
340	pub fn GetProcessHandleCount(
341	hProcess: HANDLE,
342	pdwHandleCount: PDWORD,
343	) -> BOOL;
344	pub fn GetCurrentProcessorNumber() -> DWORD;
345	pub fn SetThreadIdealProcessorEx(
346	hThread: HANDLE,
347	lpIdealProcessor: PPROCESSOR_NUMBER,
348	lpPreviousIdealProcessor: PPROCESSOR_NUMBER,
349	) -> BOOL;
350	pub fn GetThreadIdealProcessorEx(
351	hThread: HANDLE,
352	lpIdealProcessor: PPROCESSOR_NUMBER,
353	) -> BOOL;
354	pub fn GetCurrentProcessorNumberEx(
355	ProcNumber: PPROCESSOR_NUMBER,
356	);
357	pub fn GetProcessPriorityBoost(
358	hProcess: HANDLE,
359	pDisablePriorityBoost: PBOOL,
360	) -> BOOL;
361	pub fn SetProcessPriorityBoost(
362	hProcess: HANDLE,
363	bDisablePriorityBoost: BOOL,
364	) -> BOOL;
365	pub fn GetThreadIOPendingFlag(
366	hThread: HANDLE,
367	lpIOIsPending: PBOOL,
368	) -> BOOL;
369	pub fn GetSystemTimes(
370	lpIdleTime: LPFILETIME,
371	lpKernelTime: LPFILETIME,
372	lpUserTime: LPFILETIME,
373	) -> BOOL;
374	}
375	ENUM!{enum THREAD_INFORMATION_CLASS {
376	ThreadMemoryPriority,
377	ThreadAbsoluteCpuPriority,
378	ThreadInformationClassMax,
379	}}
380	// MEMORY_PRIORITY_INFORMATION
381	extern "system" {
382	pub fn GetThreadInformation(
383	hThread: HANDLE,
384	ThreadInformationClass: THREAD_INFORMATION_CLASS,
385	ThreadInformation: LPVOID,
386	ThreadInformationSize: DWORD,
387	) -> BOOL;
388	pub fn SetThreadInformation(
389	hThread: HANDLE,
390	ThreadInformationClass: THREAD_INFORMATION_CLASS,
391	ThreadInformation: LPVOID,
392	ThreadInformationSize: DWORD,
0bf4aa26	393	) -> BOOL;
ff7c6d11 XL	394	pub fn IsProcessCritical(
	395	hProcess: HANDLE,
	396	Critical: PBOOL,
	397	) -> BOOL;
	398	pub fn SetProtectedPolicy(
	399	PolicyGuid: LPCGUID,
	400	PolicyValue: ULONG_PTR,
	401	OldPolicyValue: PULONG_PTR,
	402	) -> BOOL;
	403	pub fn QueryProtectedPolicy(
	404	PolicyGuid: LPCGUID,
	405	PolicyValue: PULONG_PTR,
	406	) -> BOOL;
	407	pub fn SetThreadIdealProcessor(
	408	hThread: HANDLE,
	409	dwIdealProcessor: DWORD,
	410	) -> DWORD;
	411	}
	412	ENUM!{enum PROCESS_INFORMATION_CLASS {
	413	ProcessMemoryPriority,
	414	ProcessInformationClassMax,
	415	}}
	416	extern "system" {
	417	pub fn SetProcessInformation(
	418	hProcess: HANDLE,
	419	ProcessInformationClass: PROCESS_INFORMATION_CLASS,
	420	ProcessInformation: LPVOID,
	421	ProcessInformationSize: DWORD,
	422	) -> BOOL;
	423	pub fn GetProcessInformation(
	424	hProcess: HANDLE,
	425	ProcessInformationClass: PROCESS_INFORMATION_CLASS,
	426	ProcessInformation: LPVOID,
	427	ProcessInformationSize: DWORD,
	428	) -> BOOL;
	429	// pub fn GetSystemCpuSetInformation();
	430	// pub fn GetProcessDefaultCpuSets();
	431	// pub fn SetProcessDefaultCpuSets();
	432	// pub fn GetThreadSelectedCpuSets();
	433	// pub fn SetThreadSelectedCpuSets();
	434	// pub fn CreateProcessAsUserA();
	435	pub fn GetProcessShutdownParameters(
	436	lpdwLevel: LPDWORD,
	437	lpdwFlags: LPDWORD,
	438	) -> BOOL;
	439	// pub fn SetThreadDescription();
	440	// pub fn GetThreadDescription();
	441	}