4 * This file contains the Nt* API functions of NTDLL.DLL.
5 * In the original ntdll.dll they all seem to just call int 0x2e (down to the NTOSKRNL)
7 * Copyright 1996-1998 Marcus Meissner
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
36 #define WIN32_NO_STATUS
37 #include "wine/debug.h"
40 #include "ntdll_misc.h"
41 #include "wine/server.h"
43 #ifdef HAVE_MACH_MACH_H
44 #include <mach/mach.h>
47 WINE_DEFAULT_DEBUG_CHANNEL(ntdll
);
49 static ULONG execute_flags
= MEM_EXECUTE_OPTION_DISABLE
;
55 /******************************************************************************
56 * NtTerminateProcess [NTDLL.@]
58 * Native applications must kill themselves when done
60 NTSTATUS WINAPI
NtTerminateProcess( HANDLE handle
, LONG exit_code
)
64 SERVER_START_REQ( terminate_process
)
66 req
->handle
= wine_server_obj_handle( handle
);
67 req
->exit_code
= exit_code
;
68 ret
= wine_server_call( req
);
69 self
= !ret
&& reply
->self
;
72 if (self
&& handle
) _exit( exit_code
);
76 /******************************************************************************
77 * RtlGetCurrentPeb [NTDLL.@]
80 PEB
* WINAPI
RtlGetCurrentPeb(void)
82 return NtCurrentTeb()->Peb
;
85 /***********************************************************************
86 * __wine_make_process_system (NTDLL.@)
88 * Mark the current process as a system process.
89 * Returns the event that is signaled when all non-system processes have exited.
91 HANDLE CDECL
__wine_make_process_system(void)
94 SERVER_START_REQ( make_process_system
)
96 if (!wine_server_call( req
)) ret
= wine_server_ptr_handle( reply
->event
);
102 static UINT process_error_mode
;
104 #define UNIMPLEMENTED_INFO_CLASS(c) \
106 FIXME("(process=%p) Unimplemented information class: " #c "\n", ProcessHandle); \
107 ret = STATUS_INVALID_INFO_CLASS; \
110 ULONG_PTR
get_system_affinity_mask(void)
112 ULONG num_cpus
= NtCurrentTeb()->Peb
->NumberOfProcessors
;
113 if (num_cpus
>= sizeof(ULONG_PTR
) * 8) return ~(ULONG_PTR
)0;
114 return ((ULONG_PTR
)1 << num_cpus
) - 1;
117 #if defined(HAVE_MACH_MACH_H)
119 static void fill_VM_COUNTERS(VM_COUNTERS
* pvmi
)
121 #if defined(MACH_TASK_BASIC_INFO)
122 struct mach_task_basic_info info
;
123 mach_msg_type_number_t infoCount
= MACH_TASK_BASIC_INFO_COUNT
;
124 if(task_info(mach_task_self(), MACH_TASK_BASIC_INFO
, (task_info_t
)&info
, &infoCount
) == KERN_SUCCESS
)
126 pvmi
->VirtualSize
= info
.resident_size
+ info
.virtual_size
;
127 pvmi
->PagefileUsage
= info
.virtual_size
;
128 pvmi
->WorkingSetSize
= info
.resident_size
;
129 pvmi
->PeakWorkingSetSize
= info
.resident_size_max
;
136 static void fill_VM_COUNTERS(VM_COUNTERS
* pvmi
)
142 f
= fopen("/proc/self/status", "r");
145 while (fgets(line
, sizeof(line
), f
))
147 if (sscanf(line
, "VmPeak: %lu", &value
))
148 pvmi
->PeakVirtualSize
= (ULONG64
)value
* 1024;
149 else if (sscanf(line
, "VmSize: %lu", &value
))
150 pvmi
->VirtualSize
= (ULONG64
)value
* 1024;
151 else if (sscanf(line
, "VmHWM: %lu", &value
))
152 pvmi
->PeakWorkingSetSize
= (ULONG64
)value
* 1024;
153 else if (sscanf(line
, "VmRSS: %lu", &value
))
154 pvmi
->WorkingSetSize
= (ULONG64
)value
* 1024;
155 else if (sscanf(line
, "VmSwap: %lu", &value
))
156 pvmi
->PeakPagefileUsage
= pvmi
->PagefileUsage
= (ULONG64
)value
* 1024;
164 static void fill_VM_COUNTERS(VM_COUNTERS
* pvmi
)
166 /* FIXME : real data */
171 /******************************************************************************
172 * NtQueryInformationProcess [NTDLL.@]
173 * ZwQueryInformationProcess [NTDLL.@]
176 NTSTATUS WINAPI
NtQueryInformationProcess(
177 IN HANDLE ProcessHandle
,
178 IN PROCESSINFOCLASS ProcessInformationClass
,
179 OUT PVOID ProcessInformation
,
180 IN ULONG ProcessInformationLength
,
181 OUT PULONG ReturnLength
)
183 NTSTATUS ret
= STATUS_SUCCESS
;
186 TRACE("(%p,0x%08x,%p,0x%08x,%p)\n",
187 ProcessHandle
,ProcessInformationClass
,
188 ProcessInformation
,ProcessInformationLength
,
191 switch (ProcessInformationClass
)
193 UNIMPLEMENTED_INFO_CLASS(ProcessQuotaLimits
);
194 UNIMPLEMENTED_INFO_CLASS(ProcessBasePriority
);
195 UNIMPLEMENTED_INFO_CLASS(ProcessRaisePriority
);
196 UNIMPLEMENTED_INFO_CLASS(ProcessExceptionPort
);
197 UNIMPLEMENTED_INFO_CLASS(ProcessAccessToken
);
198 UNIMPLEMENTED_INFO_CLASS(ProcessLdtInformation
);
199 UNIMPLEMENTED_INFO_CLASS(ProcessLdtSize
);
200 UNIMPLEMENTED_INFO_CLASS(ProcessIoPortHandlers
);
201 UNIMPLEMENTED_INFO_CLASS(ProcessPooledUsageAndLimits
);
202 UNIMPLEMENTED_INFO_CLASS(ProcessWorkingSetWatch
);
203 UNIMPLEMENTED_INFO_CLASS(ProcessUserModeIOPL
);
204 UNIMPLEMENTED_INFO_CLASS(ProcessEnableAlignmentFaultFixup
);
205 UNIMPLEMENTED_INFO_CLASS(ProcessPriorityClass
);
206 UNIMPLEMENTED_INFO_CLASS(ProcessWx86Information
);
207 UNIMPLEMENTED_INFO_CLASS(ProcessPriorityBoost
);
208 UNIMPLEMENTED_INFO_CLASS(ProcessDeviceMap
);
209 UNIMPLEMENTED_INFO_CLASS(ProcessSessionInformation
);
210 UNIMPLEMENTED_INFO_CLASS(ProcessForegroundInformation
);
211 UNIMPLEMENTED_INFO_CLASS(ProcessLUIDDeviceMapsEnabled
);
212 UNIMPLEMENTED_INFO_CLASS(ProcessBreakOnTermination
);
213 UNIMPLEMENTED_INFO_CLASS(ProcessHandleTracing
);
215 case ProcessBasicInformation
:
217 PROCESS_BASIC_INFORMATION pbi
;
218 const ULONG_PTR affinity_mask
= get_system_affinity_mask();
220 if (ProcessInformationLength
>= sizeof(PROCESS_BASIC_INFORMATION
))
222 if (!ProcessInformation
)
223 ret
= STATUS_ACCESS_VIOLATION
;
224 else if (!ProcessHandle
)
225 ret
= STATUS_INVALID_HANDLE
;
228 SERVER_START_REQ(get_process_info
)
230 req
->handle
= wine_server_obj_handle( ProcessHandle
);
231 if ((ret
= wine_server_call( req
)) == STATUS_SUCCESS
)
233 pbi
.ExitStatus
= reply
->exit_code
;
234 pbi
.PebBaseAddress
= wine_server_get_ptr( reply
->peb
);
235 pbi
.AffinityMask
= reply
->affinity
& affinity_mask
;
236 pbi
.BasePriority
= reply
->priority
;
237 pbi
.UniqueProcessId
= reply
->pid
;
238 pbi
.InheritedFromUniqueProcessId
= reply
->ppid
;
243 memcpy(ProcessInformation
, &pbi
, sizeof(PROCESS_BASIC_INFORMATION
));
245 len
= sizeof(PROCESS_BASIC_INFORMATION
);
248 if (ProcessInformationLength
> sizeof(PROCESS_BASIC_INFORMATION
))
249 ret
= STATUS_INFO_LENGTH_MISMATCH
;
253 len
= sizeof(PROCESS_BASIC_INFORMATION
);
254 ret
= STATUS_INFO_LENGTH_MISMATCH
;
258 case ProcessIoCounters
:
262 if (ProcessInformationLength
>= sizeof(IO_COUNTERS
))
264 if (!ProcessInformation
)
265 ret
= STATUS_ACCESS_VIOLATION
;
266 else if (!ProcessHandle
)
267 ret
= STATUS_INVALID_HANDLE
;
270 /* FIXME : real data */
271 memset(&pii
, 0 , sizeof(IO_COUNTERS
));
273 memcpy(ProcessInformation
, &pii
, sizeof(IO_COUNTERS
));
275 len
= sizeof(IO_COUNTERS
);
278 if (ProcessInformationLength
> sizeof(IO_COUNTERS
))
279 ret
= STATUS_INFO_LENGTH_MISMATCH
;
283 len
= sizeof(IO_COUNTERS
);
284 ret
= STATUS_INFO_LENGTH_MISMATCH
;
288 case ProcessVmCounters
:
292 /* older Windows versions don't have the PrivatePageCount field */
293 if (ProcessInformationLength
>= FIELD_OFFSET(VM_COUNTERS
,PrivatePageCount
))
295 if (!ProcessInformation
)
296 ret
= STATUS_ACCESS_VIOLATION
;
297 else if (!ProcessHandle
)
298 ret
= STATUS_INVALID_HANDLE
;
301 memset(&pvmi
, 0 , sizeof(VM_COUNTERS
));
302 if (ProcessHandle
== GetCurrentProcess())
303 fill_VM_COUNTERS(&pvmi
);
305 FIXME("Need wineserver call to get VM counters for another process\n");
307 len
= ProcessInformationLength
;
308 if (len
!= FIELD_OFFSET(VM_COUNTERS
,PrivatePageCount
)) len
= sizeof(VM_COUNTERS
);
310 memcpy(ProcessInformation
, &pvmi
, min(ProcessInformationLength
,sizeof(VM_COUNTERS
)));
313 if (ProcessInformationLength
!= FIELD_OFFSET(VM_COUNTERS
,PrivatePageCount
) &&
314 ProcessInformationLength
!= sizeof(VM_COUNTERS
))
315 ret
= STATUS_INFO_LENGTH_MISMATCH
;
320 ret
= STATUS_INFO_LENGTH_MISMATCH
;
326 KERNEL_USER_TIMES pti
;
328 if (ProcessInformationLength
>= sizeof(KERNEL_USER_TIMES
))
330 if (!ProcessInformation
)
331 ret
= STATUS_ACCESS_VIOLATION
;
332 else if (!ProcessHandle
)
333 ret
= STATUS_INVALID_HANDLE
;
336 /* FIXME : User- and KernelTime have to be implemented */
337 memset(&pti
, 0, sizeof(KERNEL_USER_TIMES
));
339 SERVER_START_REQ(get_process_info
)
341 req
->handle
= wine_server_obj_handle( ProcessHandle
);
342 if ((ret
= wine_server_call( req
)) == STATUS_SUCCESS
)
344 pti
.CreateTime
.QuadPart
= reply
->start_time
;
345 pti
.ExitTime
.QuadPart
= reply
->end_time
;
350 memcpy(ProcessInformation
, &pti
, sizeof(KERNEL_USER_TIMES
));
351 len
= sizeof(KERNEL_USER_TIMES
);
354 if (ProcessInformationLength
> sizeof(KERNEL_USER_TIMES
))
355 ret
= STATUS_INFO_LENGTH_MISMATCH
;
359 len
= sizeof(KERNEL_USER_TIMES
);
360 ret
= STATUS_INFO_LENGTH_MISMATCH
;
364 case ProcessDebugPort
:
365 len
= sizeof(DWORD_PTR
);
366 if (ProcessInformationLength
== len
)
368 if (!ProcessInformation
)
369 ret
= STATUS_ACCESS_VIOLATION
;
370 else if (!ProcessHandle
)
371 ret
= STATUS_INVALID_HANDLE
;
374 SERVER_START_REQ(get_process_info
)
376 req
->handle
= wine_server_obj_handle( ProcessHandle
);
377 if ((ret
= wine_server_call( req
)) == STATUS_SUCCESS
)
379 *(DWORD_PTR
*)ProcessInformation
= reply
->debugger_present
? ~(DWORD_PTR
)0 : 0;
386 ret
= STATUS_INFO_LENGTH_MISMATCH
;
388 case ProcessDebugFlags
:
390 if (ProcessInformationLength
== len
)
392 if (!ProcessInformation
)
393 ret
= STATUS_ACCESS_VIOLATION
;
394 else if (!ProcessHandle
)
395 ret
= STATUS_INVALID_HANDLE
;
398 SERVER_START_REQ(get_process_info
)
400 req
->handle
= wine_server_obj_handle( ProcessHandle
);
401 if ((ret
= wine_server_call( req
)) == STATUS_SUCCESS
)
403 *(DWORD
*)ProcessInformation
= reply
->debug_children
;
410 ret
= STATUS_INFO_LENGTH_MISMATCH
;
412 case ProcessDefaultHardErrorMode
:
413 len
= sizeof(process_error_mode
);
414 if (ProcessInformationLength
== len
)
415 memcpy(ProcessInformation
, &process_error_mode
, len
);
417 ret
= STATUS_INFO_LENGTH_MISMATCH
;
419 case ProcessDebugObjectHandle
:
420 /* "These are not the debuggers you are looking for." *
421 * set it to 0 aka "no debugger" to satisfy copy protections */
422 len
= sizeof(HANDLE
);
423 if (ProcessInformationLength
== len
)
425 if (!ProcessInformation
)
426 ret
= STATUS_ACCESS_VIOLATION
;
427 else if (!ProcessHandle
)
428 ret
= STATUS_INVALID_HANDLE
;
431 memset(ProcessInformation
, 0, ProcessInformationLength
);
432 ret
= STATUS_PORT_NOT_SET
;
436 ret
= STATUS_INFO_LENGTH_MISMATCH
;
438 case ProcessHandleCount
:
439 if (ProcessInformationLength
>= 4)
441 if (!ProcessInformation
)
442 ret
= STATUS_ACCESS_VIOLATION
;
443 else if (!ProcessHandle
)
444 ret
= STATUS_INVALID_HANDLE
;
447 memset(ProcessInformation
, 0, 4);
451 if (ProcessInformationLength
> 4)
452 ret
= STATUS_INFO_LENGTH_MISMATCH
;
457 ret
= STATUS_INFO_LENGTH_MISMATCH
;
461 case ProcessAffinityMask
:
462 len
= sizeof(ULONG_PTR
);
463 if (ProcessInformationLength
== len
)
465 const ULONG_PTR system_mask
= get_system_affinity_mask();
467 SERVER_START_REQ(get_process_info
)
469 req
->handle
= wine_server_obj_handle( ProcessHandle
);
470 if (!(ret
= wine_server_call( req
)))
471 *(ULONG_PTR
*)ProcessInformation
= reply
->affinity
& system_mask
;
475 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
478 case ProcessWow64Information
:
479 len
= sizeof(ULONG_PTR
);
480 if (ProcessInformationLength
!= len
) ret
= STATUS_INFO_LENGTH_MISMATCH
;
481 else if (!ProcessInformation
) ret
= STATUS_ACCESS_VIOLATION
;
482 else if(!ProcessHandle
) ret
= STATUS_INVALID_HANDLE
;
487 if (ProcessHandle
== GetCurrentProcess()) val
= is_wow64
;
488 else if (server_cpus
& ((1 << CPU_x86_64
) | (1 << CPU_ARM64
)))
490 SERVER_START_REQ( get_process_info
)
492 req
->handle
= wine_server_obj_handle( ProcessHandle
);
493 if (!(ret
= wine_server_call( req
)))
494 val
= (reply
->cpu
!= CPU_x86_64
&& reply
->cpu
!= CPU_ARM64
);
498 *(ULONG_PTR
*)ProcessInformation
= val
;
501 case ProcessImageFileName
:
502 /* FIXME: this will return a DOS path. Windows returns an NT path. Changing this would require also changing kernel32.QueryFullProcessImageName.
503 * The latter may be harder because of the lack of RtlNtPathNameToDosPathName. */
504 SERVER_START_REQ(get_dll_info
)
506 UNICODE_STRING
*image_file_name_str
= ProcessInformation
;
508 req
->handle
= wine_server_obj_handle( ProcessHandle
);
509 req
->base_address
= 0; /* main module */
510 wine_server_set_reply( req
, image_file_name_str
? image_file_name_str
+ 1 : NULL
,
511 ProcessInformationLength
> sizeof(UNICODE_STRING
) ? ProcessInformationLength
- sizeof(UNICODE_STRING
) : 0 );
512 ret
= wine_server_call( req
);
513 if (ret
== STATUS_BUFFER_TOO_SMALL
) ret
= STATUS_INFO_LENGTH_MISMATCH
;
515 len
= sizeof(UNICODE_STRING
) + reply
->filename_len
;
516 if (ret
== STATUS_SUCCESS
)
518 image_file_name_str
->MaximumLength
= image_file_name_str
->Length
= reply
->filename_len
;
519 image_file_name_str
->Buffer
= (PWSTR
)(image_file_name_str
+ 1);
524 case ProcessExecuteFlags
:
526 if (ProcessInformationLength
== len
)
527 *(ULONG
*)ProcessInformation
= execute_flags
;
529 ret
= STATUS_INFO_LENGTH_MISMATCH
;
532 FIXME("(%p,info_class=%d,%p,0x%08x,%p) Unknown information class\n",
533 ProcessHandle
,ProcessInformationClass
,
534 ProcessInformation
,ProcessInformationLength
,
536 ret
= STATUS_INVALID_INFO_CLASS
;
540 if (ReturnLength
) *ReturnLength
= len
;
545 /******************************************************************************
546 * NtSetInformationProcess [NTDLL.@]
547 * ZwSetInformationProcess [NTDLL.@]
549 NTSTATUS WINAPI
NtSetInformationProcess(
550 IN HANDLE ProcessHandle
,
551 IN PROCESSINFOCLASS ProcessInformationClass
,
552 IN PVOID ProcessInformation
,
553 IN ULONG ProcessInformationLength
)
555 NTSTATUS ret
= STATUS_SUCCESS
;
557 switch (ProcessInformationClass
)
559 case ProcessDefaultHardErrorMode
:
560 if (ProcessInformationLength
!= sizeof(UINT
)) return STATUS_INVALID_PARAMETER
;
561 process_error_mode
= *(UINT
*)ProcessInformation
;
563 case ProcessAffinityMask
:
565 const ULONG_PTR system_mask
= get_system_affinity_mask();
567 if (ProcessInformationLength
!= sizeof(DWORD_PTR
)) return STATUS_INVALID_PARAMETER
;
568 if (*(PDWORD_PTR
)ProcessInformation
& ~system_mask
)
569 return STATUS_INVALID_PARAMETER
;
570 if (!*(PDWORD_PTR
)ProcessInformation
)
571 return STATUS_INVALID_PARAMETER
;
572 SERVER_START_REQ( set_process_info
)
574 req
->handle
= wine_server_obj_handle( ProcessHandle
);
575 req
->affinity
= *(PDWORD_PTR
)ProcessInformation
;
576 req
->mask
= SET_PROCESS_INFO_AFFINITY
;
577 ret
= wine_server_call( req
);
582 case ProcessPriorityClass
:
583 if (ProcessInformationLength
!= sizeof(PROCESS_PRIORITY_CLASS
))
584 return STATUS_INVALID_PARAMETER
;
587 PROCESS_PRIORITY_CLASS
* ppc
= ProcessInformation
;
589 SERVER_START_REQ( set_process_info
)
591 req
->handle
= wine_server_obj_handle( ProcessHandle
);
592 /* FIXME Foreground isn't used */
593 req
->priority
= ppc
->PriorityClass
;
594 req
->mask
= SET_PROCESS_INFO_PRIORITY
;
595 ret
= wine_server_call( req
);
601 case ProcessExecuteFlags
:
602 if (ProcessInformationLength
!= sizeof(ULONG
))
603 return STATUS_INVALID_PARAMETER
;
604 else if (execute_flags
& MEM_EXECUTE_OPTION_PERMANENT
)
605 return STATUS_ACCESS_DENIED
;
609 switch (*(ULONG
*)ProcessInformation
& (MEM_EXECUTE_OPTION_ENABLE
|MEM_EXECUTE_OPTION_DISABLE
))
611 case MEM_EXECUTE_OPTION_ENABLE
:
614 case MEM_EXECUTE_OPTION_DISABLE
:
618 return STATUS_INVALID_PARAMETER
;
620 execute_flags
= *(ULONG
*)ProcessInformation
;
621 VIRTUAL_SetForceExec( enable
);
626 FIXME("(%p,0x%08x,%p,0x%08x) stub\n",
627 ProcessHandle
,ProcessInformationClass
,ProcessInformation
,
628 ProcessInformationLength
);
629 ret
= STATUS_NOT_IMPLEMENTED
;
635 /******************************************************************************
636 * NtFlushInstructionCache [NTDLL.@]
637 * ZwFlushInstructionCache [NTDLL.@]
639 NTSTATUS WINAPI
NtFlushInstructionCache(
640 IN HANDLE ProcessHandle
,
641 IN LPCVOID BaseAddress
,
647 #if defined(__x86_64__) || defined(__i386__)
648 TRACE("%p %p %ld - no-op on x86 and x86_64\n", ProcessHandle
, BaseAddress
, Size
);
650 FIXME("%p %p %ld\n", ProcessHandle
, BaseAddress
, Size
);
653 return STATUS_SUCCESS
;
656 /******************************************************************
657 * NtOpenProcess [NTDLL.@]
658 * ZwOpenProcess [NTDLL.@]
660 NTSTATUS WINAPI
NtOpenProcess(PHANDLE handle
, ACCESS_MASK access
,
661 const OBJECT_ATTRIBUTES
* attr
, const CLIENT_ID
* cid
)
665 SERVER_START_REQ( open_process
)
667 req
->pid
= HandleToULong(cid
->UniqueProcess
);
668 req
->access
= access
;
669 req
->attributes
= attr
? attr
->Attributes
: 0;
670 status
= wine_server_call( req
);
671 if (!status
) *handle
= wine_server_ptr_handle( reply
->handle
);
677 /******************************************************************************
681 NTSTATUS WINAPI
NtResumeProcess( HANDLE handle
)
683 FIXME("stub: %p\n", handle
);
684 return STATUS_NOT_IMPLEMENTED
;
687 /******************************************************************************
691 NTSTATUS WINAPI
NtSuspendProcess( HANDLE handle
)
693 FIXME("stub: %p\n", handle
);
694 return STATUS_NOT_IMPLEMENTED
;