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
, "RssAnon: %lu", &value
))
156 pvmi
->PagefileUsage
+= (ULONG64
)value
* 1024;
157 else if (sscanf(line
, "VmSwap: %lu", &value
))
158 pvmi
->PagefileUsage
+= (ULONG64
)value
* 1024;
160 pvmi
->PeakPagefileUsage
= pvmi
->PagefileUsage
;
167 static void fill_VM_COUNTERS(VM_COUNTERS
* pvmi
)
169 /* FIXME : real data */
174 /******************************************************************************
175 * NtQueryInformationProcess [NTDLL.@]
176 * ZwQueryInformationProcess [NTDLL.@]
179 NTSTATUS WINAPI
NtQueryInformationProcess(
180 IN HANDLE ProcessHandle
,
181 IN PROCESSINFOCLASS ProcessInformationClass
,
182 OUT PVOID ProcessInformation
,
183 IN ULONG ProcessInformationLength
,
184 OUT PULONG ReturnLength
)
186 NTSTATUS ret
= STATUS_SUCCESS
;
189 TRACE("(%p,0x%08x,%p,0x%08x,%p)\n",
190 ProcessHandle
,ProcessInformationClass
,
191 ProcessInformation
,ProcessInformationLength
,
194 switch (ProcessInformationClass
)
196 UNIMPLEMENTED_INFO_CLASS(ProcessQuotaLimits
);
197 UNIMPLEMENTED_INFO_CLASS(ProcessBasePriority
);
198 UNIMPLEMENTED_INFO_CLASS(ProcessRaisePriority
);
199 UNIMPLEMENTED_INFO_CLASS(ProcessExceptionPort
);
200 UNIMPLEMENTED_INFO_CLASS(ProcessAccessToken
);
201 UNIMPLEMENTED_INFO_CLASS(ProcessLdtInformation
);
202 UNIMPLEMENTED_INFO_CLASS(ProcessLdtSize
);
203 UNIMPLEMENTED_INFO_CLASS(ProcessIoPortHandlers
);
204 UNIMPLEMENTED_INFO_CLASS(ProcessPooledUsageAndLimits
);
205 UNIMPLEMENTED_INFO_CLASS(ProcessWorkingSetWatch
);
206 UNIMPLEMENTED_INFO_CLASS(ProcessUserModeIOPL
);
207 UNIMPLEMENTED_INFO_CLASS(ProcessEnableAlignmentFaultFixup
);
208 UNIMPLEMENTED_INFO_CLASS(ProcessWx86Information
);
209 UNIMPLEMENTED_INFO_CLASS(ProcessPriorityBoost
);
210 UNIMPLEMENTED_INFO_CLASS(ProcessDeviceMap
);
211 UNIMPLEMENTED_INFO_CLASS(ProcessSessionInformation
);
212 UNIMPLEMENTED_INFO_CLASS(ProcessForegroundInformation
);
213 UNIMPLEMENTED_INFO_CLASS(ProcessLUIDDeviceMapsEnabled
);
214 UNIMPLEMENTED_INFO_CLASS(ProcessBreakOnTermination
);
215 UNIMPLEMENTED_INFO_CLASS(ProcessHandleTracing
);
217 case ProcessBasicInformation
:
219 PROCESS_BASIC_INFORMATION pbi
;
220 const ULONG_PTR affinity_mask
= get_system_affinity_mask();
222 if (ProcessInformationLength
>= sizeof(PROCESS_BASIC_INFORMATION
))
224 if (!ProcessInformation
)
225 ret
= STATUS_ACCESS_VIOLATION
;
226 else if (!ProcessHandle
)
227 ret
= STATUS_INVALID_HANDLE
;
230 SERVER_START_REQ(get_process_info
)
232 req
->handle
= wine_server_obj_handle( ProcessHandle
);
233 if ((ret
= wine_server_call( req
)) == STATUS_SUCCESS
)
235 pbi
.ExitStatus
= reply
->exit_code
;
236 pbi
.PebBaseAddress
= wine_server_get_ptr( reply
->peb
);
237 pbi
.AffinityMask
= reply
->affinity
& affinity_mask
;
238 pbi
.BasePriority
= reply
->priority
;
239 pbi
.UniqueProcessId
= reply
->pid
;
240 pbi
.InheritedFromUniqueProcessId
= reply
->ppid
;
245 memcpy(ProcessInformation
, &pbi
, sizeof(PROCESS_BASIC_INFORMATION
));
247 len
= sizeof(PROCESS_BASIC_INFORMATION
);
250 if (ProcessInformationLength
> sizeof(PROCESS_BASIC_INFORMATION
))
251 ret
= STATUS_INFO_LENGTH_MISMATCH
;
255 len
= sizeof(PROCESS_BASIC_INFORMATION
);
256 ret
= STATUS_INFO_LENGTH_MISMATCH
;
260 case ProcessIoCounters
:
264 if (ProcessInformationLength
>= sizeof(IO_COUNTERS
))
266 if (!ProcessInformation
)
267 ret
= STATUS_ACCESS_VIOLATION
;
268 else if (!ProcessHandle
)
269 ret
= STATUS_INVALID_HANDLE
;
272 /* FIXME : real data */
273 memset(&pii
, 0 , sizeof(IO_COUNTERS
));
275 memcpy(ProcessInformation
, &pii
, sizeof(IO_COUNTERS
));
277 len
= sizeof(IO_COUNTERS
);
280 if (ProcessInformationLength
> sizeof(IO_COUNTERS
))
281 ret
= STATUS_INFO_LENGTH_MISMATCH
;
285 len
= sizeof(IO_COUNTERS
);
286 ret
= STATUS_INFO_LENGTH_MISMATCH
;
290 case ProcessVmCounters
:
294 /* older Windows versions don't have the PrivatePageCount field */
295 if (ProcessInformationLength
>= FIELD_OFFSET(VM_COUNTERS
,PrivatePageCount
))
297 if (!ProcessInformation
)
298 ret
= STATUS_ACCESS_VIOLATION
;
301 memset(&pvmi
, 0 , sizeof(VM_COUNTERS
));
302 if (ProcessHandle
== GetCurrentProcess())
303 fill_VM_COUNTERS(&pvmi
);
306 SERVER_START_REQ(get_process_vm_counters
)
308 req
->handle
= wine_server_obj_handle( ProcessHandle
);
309 if (!(ret
= wine_server_call( req
)))
311 pvmi
.PeakVirtualSize
= reply
->peak_virtual_size
;
312 pvmi
.VirtualSize
= reply
->virtual_size
;
313 pvmi
.PeakWorkingSetSize
= reply
->peak_working_set_size
;
314 pvmi
.WorkingSetSize
= reply
->working_set_size
;
315 pvmi
.PagefileUsage
= reply
->pagefile_usage
;
316 pvmi
.PeakPagefileUsage
= reply
->peak_pagefile_usage
;
323 len
= ProcessInformationLength
;
324 if (len
!= FIELD_OFFSET(VM_COUNTERS
,PrivatePageCount
)) len
= sizeof(VM_COUNTERS
);
326 memcpy(ProcessInformation
, &pvmi
, min(ProcessInformationLength
,sizeof(VM_COUNTERS
)));
329 if (ProcessInformationLength
!= FIELD_OFFSET(VM_COUNTERS
,PrivatePageCount
) &&
330 ProcessInformationLength
!= sizeof(VM_COUNTERS
))
331 ret
= STATUS_INFO_LENGTH_MISMATCH
;
336 ret
= STATUS_INFO_LENGTH_MISMATCH
;
342 KERNEL_USER_TIMES pti
;
344 if (ProcessInformationLength
>= sizeof(KERNEL_USER_TIMES
))
346 if (!ProcessInformation
)
347 ret
= STATUS_ACCESS_VIOLATION
;
348 else if (!ProcessHandle
)
349 ret
= STATUS_INVALID_HANDLE
;
352 /* FIXME : User- and KernelTime have to be implemented */
353 memset(&pti
, 0, sizeof(KERNEL_USER_TIMES
));
355 SERVER_START_REQ(get_process_info
)
357 req
->handle
= wine_server_obj_handle( ProcessHandle
);
358 if ((ret
= wine_server_call( req
)) == STATUS_SUCCESS
)
360 pti
.CreateTime
.QuadPart
= reply
->start_time
;
361 pti
.ExitTime
.QuadPart
= reply
->end_time
;
366 memcpy(ProcessInformation
, &pti
, sizeof(KERNEL_USER_TIMES
));
367 len
= sizeof(KERNEL_USER_TIMES
);
370 if (ProcessInformationLength
> sizeof(KERNEL_USER_TIMES
))
371 ret
= STATUS_INFO_LENGTH_MISMATCH
;
375 len
= sizeof(KERNEL_USER_TIMES
);
376 ret
= STATUS_INFO_LENGTH_MISMATCH
;
380 case ProcessDebugPort
:
381 len
= sizeof(DWORD_PTR
);
382 if (ProcessInformationLength
== len
)
384 if (!ProcessInformation
)
385 ret
= STATUS_ACCESS_VIOLATION
;
386 else if (!ProcessHandle
)
387 ret
= STATUS_INVALID_HANDLE
;
390 SERVER_START_REQ(get_process_info
)
392 req
->handle
= wine_server_obj_handle( ProcessHandle
);
393 if ((ret
= wine_server_call( req
)) == STATUS_SUCCESS
)
395 *(DWORD_PTR
*)ProcessInformation
= reply
->debugger_present
? ~(DWORD_PTR
)0 : 0;
402 ret
= STATUS_INFO_LENGTH_MISMATCH
;
404 case ProcessDebugFlags
:
406 if (ProcessInformationLength
== len
)
408 if (!ProcessInformation
)
409 ret
= STATUS_ACCESS_VIOLATION
;
410 else if (!ProcessHandle
)
411 ret
= STATUS_INVALID_HANDLE
;
414 SERVER_START_REQ(get_process_info
)
416 req
->handle
= wine_server_obj_handle( ProcessHandle
);
417 if ((ret
= wine_server_call( req
)) == STATUS_SUCCESS
)
419 *(DWORD
*)ProcessInformation
= reply
->debug_children
;
426 ret
= STATUS_INFO_LENGTH_MISMATCH
;
428 case ProcessDefaultHardErrorMode
:
429 len
= sizeof(process_error_mode
);
430 if (ProcessInformationLength
== len
)
431 memcpy(ProcessInformation
, &process_error_mode
, len
);
433 ret
= STATUS_INFO_LENGTH_MISMATCH
;
435 case ProcessDebugObjectHandle
:
436 /* "These are not the debuggers you are looking for." *
437 * set it to 0 aka "no debugger" to satisfy copy protections */
438 len
= sizeof(HANDLE
);
439 if (ProcessInformationLength
== len
)
441 if (!ProcessInformation
)
442 ret
= STATUS_ACCESS_VIOLATION
;
443 else if (!ProcessHandle
)
444 ret
= STATUS_INVALID_HANDLE
;
447 memset(ProcessInformation
, 0, ProcessInformationLength
);
448 ret
= STATUS_PORT_NOT_SET
;
452 ret
= STATUS_INFO_LENGTH_MISMATCH
;
454 case ProcessHandleCount
:
455 if (ProcessInformationLength
>= 4)
457 if (!ProcessInformation
)
458 ret
= STATUS_ACCESS_VIOLATION
;
459 else if (!ProcessHandle
)
460 ret
= STATUS_INVALID_HANDLE
;
463 memset(ProcessInformation
, 0, 4);
467 if (ProcessInformationLength
> 4)
468 ret
= STATUS_INFO_LENGTH_MISMATCH
;
473 ret
= STATUS_INFO_LENGTH_MISMATCH
;
477 case ProcessAffinityMask
:
478 len
= sizeof(ULONG_PTR
);
479 if (ProcessInformationLength
== len
)
481 const ULONG_PTR system_mask
= get_system_affinity_mask();
483 SERVER_START_REQ(get_process_info
)
485 req
->handle
= wine_server_obj_handle( ProcessHandle
);
486 if (!(ret
= wine_server_call( req
)))
487 *(ULONG_PTR
*)ProcessInformation
= reply
->affinity
& system_mask
;
491 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
494 case ProcessWow64Information
:
495 len
= sizeof(ULONG_PTR
);
496 if (ProcessInformationLength
!= len
) ret
= STATUS_INFO_LENGTH_MISMATCH
;
497 else if (!ProcessInformation
) ret
= STATUS_ACCESS_VIOLATION
;
498 else if(!ProcessHandle
) ret
= STATUS_INVALID_HANDLE
;
503 if (ProcessHandle
== GetCurrentProcess()) val
= is_wow64
;
504 else if (server_cpus
& ((1 << CPU_x86_64
) | (1 << CPU_ARM64
)))
506 SERVER_START_REQ( get_process_info
)
508 req
->handle
= wine_server_obj_handle( ProcessHandle
);
509 if (!(ret
= wine_server_call( req
)))
510 val
= (reply
->cpu
!= CPU_x86_64
&& reply
->cpu
!= CPU_ARM64
);
514 *(ULONG_PTR
*)ProcessInformation
= val
;
517 case ProcessImageFileName
:
518 /* FIXME: this will return a DOS path. Windows returns an NT path. Changing this would require also changing kernel32.QueryFullProcessImageName.
519 * The latter may be harder because of the lack of RtlNtPathNameToDosPathName. */
520 SERVER_START_REQ(get_dll_info
)
522 UNICODE_STRING
*image_file_name_str
= ProcessInformation
;
524 req
->handle
= wine_server_obj_handle( ProcessHandle
);
525 req
->base_address
= 0; /* main module */
526 wine_server_set_reply( req
, image_file_name_str
? image_file_name_str
+ 1 : NULL
,
527 ProcessInformationLength
> sizeof(UNICODE_STRING
) ? ProcessInformationLength
- sizeof(UNICODE_STRING
) : 0 );
528 ret
= wine_server_call( req
);
529 if (ret
== STATUS_BUFFER_TOO_SMALL
) ret
= STATUS_INFO_LENGTH_MISMATCH
;
531 len
= sizeof(UNICODE_STRING
) + reply
->filename_len
;
532 if (ret
== STATUS_SUCCESS
)
534 image_file_name_str
->MaximumLength
= image_file_name_str
->Length
= reply
->filename_len
;
535 image_file_name_str
->Buffer
= (PWSTR
)(image_file_name_str
+ 1);
540 case ProcessExecuteFlags
:
542 if (ProcessInformationLength
== len
)
543 *(ULONG
*)ProcessInformation
= execute_flags
;
545 ret
= STATUS_INFO_LENGTH_MISMATCH
;
547 case ProcessPriorityClass
:
548 len
= sizeof(PROCESS_PRIORITY_CLASS
);
549 if (ProcessInformationLength
== len
)
551 if (!ProcessInformation
)
552 ret
= STATUS_ACCESS_VIOLATION
;
553 else if (!ProcessHandle
)
554 ret
= STATUS_INVALID_HANDLE
;
557 PROCESS_PRIORITY_CLASS
*priority
= ProcessInformation
;
559 SERVER_START_REQ(get_process_info
)
561 req
->handle
= wine_server_obj_handle( ProcessHandle
);
562 if ((ret
= wine_server_call( req
)) == STATUS_SUCCESS
)
564 priority
->PriorityClass
= reply
->priority
;
565 /* FIXME: Not yet supported by the wineserver */
566 priority
->Foreground
= FALSE
;
573 ret
= STATUS_INFO_LENGTH_MISMATCH
;
576 FIXME("(%p,info_class=%d,%p,0x%08x,%p) Unknown information class\n",
577 ProcessHandle
,ProcessInformationClass
,
578 ProcessInformation
,ProcessInformationLength
,
580 ret
= STATUS_INVALID_INFO_CLASS
;
584 if (ReturnLength
) *ReturnLength
= len
;
589 /******************************************************************************
590 * NtSetInformationProcess [NTDLL.@]
591 * ZwSetInformationProcess [NTDLL.@]
593 NTSTATUS WINAPI
NtSetInformationProcess(
594 IN HANDLE ProcessHandle
,
595 IN PROCESSINFOCLASS ProcessInformationClass
,
596 IN PVOID ProcessInformation
,
597 IN ULONG ProcessInformationLength
)
599 NTSTATUS ret
= STATUS_SUCCESS
;
601 switch (ProcessInformationClass
)
603 case ProcessDefaultHardErrorMode
:
604 if (ProcessInformationLength
!= sizeof(UINT
)) return STATUS_INVALID_PARAMETER
;
605 process_error_mode
= *(UINT
*)ProcessInformation
;
607 case ProcessAffinityMask
:
609 const ULONG_PTR system_mask
= get_system_affinity_mask();
611 if (ProcessInformationLength
!= sizeof(DWORD_PTR
)) return STATUS_INVALID_PARAMETER
;
612 if (*(PDWORD_PTR
)ProcessInformation
& ~system_mask
)
613 return STATUS_INVALID_PARAMETER
;
614 if (!*(PDWORD_PTR
)ProcessInformation
)
615 return STATUS_INVALID_PARAMETER
;
616 SERVER_START_REQ( set_process_info
)
618 req
->handle
= wine_server_obj_handle( ProcessHandle
);
619 req
->affinity
= *(PDWORD_PTR
)ProcessInformation
;
620 req
->mask
= SET_PROCESS_INFO_AFFINITY
;
621 ret
= wine_server_call( req
);
626 case ProcessPriorityClass
:
627 if (ProcessInformationLength
!= sizeof(PROCESS_PRIORITY_CLASS
))
628 return STATUS_INVALID_PARAMETER
;
631 PROCESS_PRIORITY_CLASS
* ppc
= ProcessInformation
;
633 SERVER_START_REQ( set_process_info
)
635 req
->handle
= wine_server_obj_handle( ProcessHandle
);
636 /* FIXME Foreground isn't used */
637 req
->priority
= ppc
->PriorityClass
;
638 req
->mask
= SET_PROCESS_INFO_PRIORITY
;
639 ret
= wine_server_call( req
);
645 case ProcessExecuteFlags
:
646 if (ProcessInformationLength
!= sizeof(ULONG
))
647 return STATUS_INVALID_PARAMETER
;
648 else if (execute_flags
& MEM_EXECUTE_OPTION_PERMANENT
)
649 return STATUS_ACCESS_DENIED
;
653 switch (*(ULONG
*)ProcessInformation
& (MEM_EXECUTE_OPTION_ENABLE
|MEM_EXECUTE_OPTION_DISABLE
))
655 case MEM_EXECUTE_OPTION_ENABLE
:
658 case MEM_EXECUTE_OPTION_DISABLE
:
662 return STATUS_INVALID_PARAMETER
;
664 execute_flags
= *(ULONG
*)ProcessInformation
;
665 VIRTUAL_SetForceExec( enable
);
670 FIXME("(%p,0x%08x,%p,0x%08x) stub\n",
671 ProcessHandle
,ProcessInformationClass
,ProcessInformation
,
672 ProcessInformationLength
);
673 ret
= STATUS_NOT_IMPLEMENTED
;
679 /******************************************************************************
680 * NtFlushInstructionCache [NTDLL.@]
681 * ZwFlushInstructionCache [NTDLL.@]
683 NTSTATUS WINAPI
NtFlushInstructionCache( HANDLE handle
, const void *addr
, SIZE_T size
)
685 #if defined(__x86_64__) || defined(__i386__)
687 #elif defined(HAVE___CLEAR_CACHE)
688 if (handle
== GetCurrentProcess())
690 __clear_cache( (char *)addr
, (char *)addr
+ size
);
695 if (!once
++) FIXME( "%p %p %ld other process not supported\n", handle
, addr
, size
);
699 if (!once
++) FIXME( "%p %p %ld\n", handle
, addr
, size
);
701 return STATUS_SUCCESS
;
704 /******************************************************************
705 * NtOpenProcess [NTDLL.@]
706 * ZwOpenProcess [NTDLL.@]
708 NTSTATUS WINAPI
NtOpenProcess(PHANDLE handle
, ACCESS_MASK access
,
709 const OBJECT_ATTRIBUTES
* attr
, const CLIENT_ID
* cid
)
713 SERVER_START_REQ( open_process
)
715 req
->pid
= HandleToULong(cid
->UniqueProcess
);
716 req
->access
= access
;
717 req
->attributes
= attr
? attr
->Attributes
: 0;
718 status
= wine_server_call( req
);
719 if (!status
) *handle
= wine_server_ptr_handle( reply
->handle
);
725 /******************************************************************************
729 NTSTATUS WINAPI
NtResumeProcess( HANDLE handle
)
731 FIXME("stub: %p\n", handle
);
732 return STATUS_NOT_IMPLEMENTED
;
735 /******************************************************************************
739 NTSTATUS WINAPI
NtSuspendProcess( HANDLE handle
)
741 FIXME("stub: %p\n", handle
);
742 return STATUS_NOT_IMPLEMENTED
;