2 * ntoskrnl.exe implementation
4 * Copyright (C) 2007 Alexandre Julliard
5 * Copyright (C) 2010 Damjan Jovanovic
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 #include "wine/port.h"
27 #define NONAMELESSUNION
28 #define NONAMELESSSTRUCT
31 #define WIN32_NO_STATUS
37 #include "ddk/ntddk.h"
38 #include "ddk/ntifs.h"
40 #include "wine/unicode.h"
41 #include "wine/server.h"
42 #include "wine/list.h"
43 #include "wine/debug.h"
45 WINE_DEFAULT_DEBUG_CHANNEL(ntoskrnl
);
46 WINE_DECLARE_DEBUG_CHANNEL(relay
);
48 BOOLEAN KdDebuggerEnabled
= FALSE
;
49 ULONG InitSafeBootMode
= 0;
51 extern LONG CALLBACK
vectored_handler( EXCEPTION_POINTERS
*ptrs
);
53 KSYSTEM_TIME KeTickCount
= { 0, 0, 0 };
55 typedef struct _KSERVICE_TABLE_DESCRIPTOR
61 } KSERVICE_TABLE_DESCRIPTOR
, *PKSERVICE_TABLE_DESCRIPTOR
;
63 KSERVICE_TABLE_DESCRIPTOR KeServiceDescriptorTable
[4] = { { 0 } };
65 typedef void (WINAPI
*PCREATE_PROCESS_NOTIFY_ROUTINE
)(HANDLE
,HANDLE
,BOOLEAN
);
66 typedef void (WINAPI
*PCREATE_THREAD_NOTIFY_ROUTINE
)(HANDLE
,HANDLE
,BOOLEAN
);
68 /* tid of the thread running client request */
69 static DWORD request_thread
;
71 /* pid/tid of the client thread */
72 static DWORD client_tid
;
73 static DWORD client_pid
;
76 #define DEFINE_FASTCALL1_ENTRYPOINT( name ) \
77 __ASM_STDCALL_FUNC( name, 4, \
81 "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(4))
82 #define DEFINE_FASTCALL2_ENTRYPOINT( name ) \
83 __ASM_STDCALL_FUNC( name, 8, \
88 "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(8))
89 #define DEFINE_FASTCALL3_ENTRYPOINT( name ) \
90 __ASM_STDCALL_FUNC( name, 12, \
95 "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(12))
98 static inline LPCSTR
debugstr_us( const UNICODE_STRING
*us
)
100 if (!us
) return "<null>";
101 return debugstr_wn( us
->Buffer
, us
->Length
/ sizeof(WCHAR
) );
104 static HANDLE
get_device_manager(void)
106 static HANDLE device_manager
;
107 HANDLE handle
= 0, ret
= device_manager
;
111 SERVER_START_REQ( create_device_manager
)
113 req
->access
= SYNCHRONIZE
;
115 if (!wine_server_call( req
)) handle
= wine_server_ptr_handle( reply
->handle
);
121 ERR( "failed to create the device manager\n" );
124 if (!(ret
= InterlockedCompareExchangePointer( &device_manager
, handle
, 0 )))
127 NtClose( handle
); /* somebody beat us to it */
132 static NTSTATUS
dispatch_irp( DEVICE_OBJECT
*device
, IRP
*irp
)
136 KeQueryTickCount( &count
); /* update the global KeTickCount */
138 device
->CurrentIrp
= irp
;
140 IoCallDriver( device
, irp
);
142 device
->CurrentIrp
= NULL
;
144 return STATUS_SUCCESS
;
147 /* process a create request for a given file */
148 static NTSTATUS
dispatch_create( const irp_params_t
*params
, void *in_buff
, ULONG in_size
,
149 ULONG out_size
, HANDLE irp_handle
)
152 IO_STACK_LOCATION
*irpsp
;
154 DEVICE_OBJECT
*device
= wine_server_get_ptr( params
->create
.device
);
156 if (!(file
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*file
) ))) return STATUS_NO_MEMORY
;
158 TRACE( "device %p -> file %p\n", device
, file
);
160 file
->Type
= 5; /* MSDN */
161 file
->Size
= sizeof(*file
);
162 file
->DeviceObject
= device
;
164 if (!(irp
= IoAllocateIrp( device
->StackSize
, FALSE
)))
166 HeapFree( GetProcessHeap(), 0, file
);
167 return STATUS_NO_MEMORY
;
170 irpsp
= IoGetNextIrpStackLocation( irp
);
171 irpsp
->MajorFunction
= IRP_MJ_CREATE
;
172 irpsp
->DeviceObject
= device
;
173 irpsp
->CompletionRoutine
= NULL
;
174 irpsp
->Parameters
.Create
.SecurityContext
= NULL
; /* FIXME */
175 irpsp
->Parameters
.Create
.Options
= params
->create
.options
;
176 irpsp
->Parameters
.Create
.ShareAccess
= params
->create
.sharing
;
177 irpsp
->Parameters
.Create
.FileAttributes
= 0;
178 irpsp
->Parameters
.Create
.EaLength
= 0;
180 irp
->Tail
.Overlay
.OriginalFileObject
= file
;
181 irp
->RequestorMode
= UserMode
;
182 irp
->AssociatedIrp
.SystemBuffer
= NULL
;
183 irp
->UserBuffer
= NULL
;
184 irp
->UserIosb
= irp_handle
; /* note: we abuse UserIosb to store the server irp handle */
185 irp
->UserEvent
= NULL
;
187 if (device
->DriverObject
->MajorFunction
[IRP_MJ_CREATE
]) return dispatch_irp( device
, irp
);
189 irp
->IoStatus
.u
.Status
= STATUS_SUCCESS
;
190 IoCompleteRequest( irp
, IO_NO_INCREMENT
);
191 return STATUS_SUCCESS
;
194 /* process a close request for a given file */
195 static NTSTATUS
dispatch_close( const irp_params_t
*params
, void *in_buff
, ULONG in_size
,
196 ULONG out_size
, HANDLE irp_handle
)
199 IO_STACK_LOCATION
*irpsp
;
200 DEVICE_OBJECT
*device
;
201 FILE_OBJECT
*file
= wine_server_get_ptr( params
->close
.file
);
203 if (!file
) return STATUS_INVALID_HANDLE
;
205 device
= file
->DeviceObject
;
207 TRACE( "device %p file %p\n", device
, file
);
209 if (!(irp
= IoAllocateIrp( device
->StackSize
, FALSE
)))
211 HeapFree( GetProcessHeap(), 0, file
);
212 return STATUS_NO_MEMORY
;
215 irpsp
= IoGetNextIrpStackLocation( irp
);
216 irpsp
->MajorFunction
= IRP_MJ_CLOSE
;
217 irpsp
->DeviceObject
= device
;
218 irpsp
->CompletionRoutine
= NULL
;
219 irpsp
->Parameters
.Create
.SecurityContext
= NULL
; /* FIXME */
220 irpsp
->Parameters
.Create
.Options
= params
->create
.options
;
221 irpsp
->Parameters
.Create
.ShareAccess
= params
->create
.sharing
;
222 irpsp
->Parameters
.Create
.FileAttributes
= 0;
223 irpsp
->Parameters
.Create
.EaLength
= 0;
225 irp
->Tail
.Overlay
.OriginalFileObject
= file
;
226 irp
->RequestorMode
= UserMode
;
227 irp
->AssociatedIrp
.SystemBuffer
= NULL
;
228 irp
->UserBuffer
= NULL
;
229 irp
->UserIosb
= irp_handle
; /* note: we abuse UserIosb to store the server irp handle */
230 irp
->UserEvent
= NULL
;
232 if (!device
->DriverObject
->MajorFunction
[IRP_MJ_CLOSE
])
234 irp
->IoStatus
.u
.Status
= STATUS_SUCCESS
;
235 IoCompleteRequest( irp
, IO_NO_INCREMENT
);
237 else dispatch_irp( device
, irp
);
239 HeapFree( GetProcessHeap(), 0, file
); /* FIXME: async close processing not supported */
240 return STATUS_SUCCESS
;
243 /* process a read request for a given device */
244 static NTSTATUS
dispatch_read( const irp_params_t
*params
, void *in_buff
, ULONG in_size
,
245 ULONG out_size
, HANDLE irp_handle
)
249 LARGE_INTEGER offset
;
250 IO_STACK_LOCATION
*irpsp
;
251 DEVICE_OBJECT
*device
;
252 FILE_OBJECT
*file
= wine_server_get_ptr( params
->read
.file
);
254 if (!file
) return STATUS_INVALID_HANDLE
;
256 device
= file
->DeviceObject
;
257 if (!device
->DriverObject
->MajorFunction
[IRP_MJ_READ
]) return STATUS_NOT_SUPPORTED
;
259 TRACE( "device %p file %p size %u\n", device
, file
, out_size
);
261 if (!(out_buff
= HeapAlloc( GetProcessHeap(), 0, out_size
))) return STATUS_NO_MEMORY
;
263 offset
.QuadPart
= params
->read
.pos
;
265 /* note: we abuse UserIosb to store the server irp handle */
266 if (!(irp
= IoBuildSynchronousFsdRequest( IRP_MJ_READ
, device
, out_buff
, out_size
,
267 &offset
, NULL
, irp_handle
)))
269 HeapFree( GetProcessHeap(), 0, out_buff
);
270 return STATUS_NO_MEMORY
;
273 irp
->Tail
.Overlay
.OriginalFileObject
= file
;
274 irp
->RequestorMode
= UserMode
;
276 irpsp
= IoGetNextIrpStackLocation( irp
);
277 irpsp
->Parameters
.Read
.Key
= params
->read
.key
;
279 return dispatch_irp( device
, irp
);
282 /* process a write request for a given device */
283 static NTSTATUS
dispatch_write( const irp_params_t
*params
, void *in_buff
, ULONG in_size
,
284 ULONG out_size
, HANDLE irp_handle
)
287 LARGE_INTEGER offset
;
288 IO_STACK_LOCATION
*irpsp
;
289 DEVICE_OBJECT
*device
;
290 FILE_OBJECT
*file
= wine_server_get_ptr( params
->write
.file
);
292 if (!file
) return STATUS_INVALID_HANDLE
;
294 device
= file
->DeviceObject
;
295 if (!device
->DriverObject
->MajorFunction
[IRP_MJ_WRITE
]) return STATUS_NOT_SUPPORTED
;
297 TRACE( "device %p file %p size %u\n", device
, file
, in_size
);
299 offset
.QuadPart
= params
->write
.pos
;
301 /* note: we abuse UserIosb to store the server irp handle */
302 if (!(irp
= IoBuildSynchronousFsdRequest( IRP_MJ_WRITE
, device
, in_buff
, in_size
,
303 &offset
, NULL
, irp_handle
)))
304 return STATUS_NO_MEMORY
;
306 irp
->Tail
.Overlay
.OriginalFileObject
= file
;
307 irp
->RequestorMode
= UserMode
;
309 irpsp
= IoGetNextIrpStackLocation( irp
);
310 irpsp
->Parameters
.Write
.Key
= params
->write
.key
;
312 return dispatch_irp( device
, irp
);
315 /* process a flush request for a given device */
316 static NTSTATUS
dispatch_flush( const irp_params_t
*params
, void *in_buff
, ULONG in_size
,
317 ULONG out_size
, HANDLE irp_handle
)
320 DEVICE_OBJECT
*device
;
321 FILE_OBJECT
*file
= wine_server_get_ptr( params
->flush
.file
);
323 if (!file
) return STATUS_INVALID_HANDLE
;
325 device
= file
->DeviceObject
;
326 if (!device
->DriverObject
->MajorFunction
[IRP_MJ_FLUSH_BUFFERS
]) return STATUS_NOT_SUPPORTED
;
328 TRACE( "device %p file %p\n", device
, file
);
330 /* note: we abuse UserIosb to store the server irp handle */
331 if (!(irp
= IoBuildSynchronousFsdRequest( IRP_MJ_FLUSH_BUFFERS
, device
, in_buff
, in_size
,
332 NULL
, NULL
, irp_handle
)))
333 return STATUS_NO_MEMORY
;
335 irp
->Tail
.Overlay
.OriginalFileObject
= file
;
336 irp
->RequestorMode
= UserMode
;
338 return dispatch_irp( device
, irp
);
341 /* process an ioctl request for a given device */
342 static NTSTATUS
dispatch_ioctl( const irp_params_t
*params
, void *in_buff
, ULONG in_size
,
343 ULONG out_size
, HANDLE irp_handle
)
346 void *out_buff
= NULL
;
347 DEVICE_OBJECT
*device
;
348 FILE_OBJECT
*file
= wine_server_get_ptr( params
->ioctl
.file
);
350 if (!file
) return STATUS_INVALID_HANDLE
;
352 device
= file
->DeviceObject
;
353 if (!device
->DriverObject
->MajorFunction
[IRP_MJ_DEVICE_CONTROL
]) return STATUS_NOT_SUPPORTED
;
355 TRACE( "ioctl %x device %p file %p in_size %u out_size %u\n",
356 params
->ioctl
.code
, device
, file
, in_size
, out_size
);
358 if ((params
->ioctl
.code
& 3) == METHOD_BUFFERED
) out_size
= max( in_size
, out_size
);
362 if (!(out_buff
= HeapAlloc( GetProcessHeap(), 0, out_size
))) return STATUS_NO_MEMORY
;
363 if ((params
->ioctl
.code
& 3) == METHOD_BUFFERED
)
365 memcpy( out_buff
, in_buff
, in_size
);
370 /* note: we abuse UserIosb to store the server handle to the ioctl */
371 irp
= IoBuildDeviceIoControlRequest( params
->ioctl
.code
, device
, in_buff
, in_size
, out_buff
, out_size
,
372 FALSE
, NULL
, irp_handle
);
375 HeapFree( GetProcessHeap(), 0, out_buff
);
376 return STATUS_NO_MEMORY
;
379 irp
->Tail
.Overlay
.OriginalFileObject
= file
;
380 irp
->RequestorMode
= UserMode
;
382 return dispatch_irp( device
, irp
);
385 typedef NTSTATUS (*dispatch_func
)( const irp_params_t
*params
, void *in_buff
, ULONG in_size
,
386 ULONG out_size
, HANDLE irp_handle
);
388 static const dispatch_func dispatch_funcs
[IRP_MJ_MAXIMUM_FUNCTION
+ 1] =
390 dispatch_create
, /* IRP_MJ_CREATE */
391 NULL
, /* IRP_MJ_CREATE_NAMED_PIPE */
392 dispatch_close
, /* IRP_MJ_CLOSE */
393 dispatch_read
, /* IRP_MJ_READ */
394 dispatch_write
, /* IRP_MJ_WRITE */
395 NULL
, /* IRP_MJ_QUERY_INFORMATION */
396 NULL
, /* IRP_MJ_SET_INFORMATION */
397 NULL
, /* IRP_MJ_QUERY_EA */
398 NULL
, /* IRP_MJ_SET_EA */
399 dispatch_flush
, /* IRP_MJ_FLUSH_BUFFERS */
400 NULL
, /* IRP_MJ_QUERY_VOLUME_INFORMATION */
401 NULL
, /* IRP_MJ_SET_VOLUME_INFORMATION */
402 NULL
, /* IRP_MJ_DIRECTORY_CONTROL */
403 NULL
, /* IRP_MJ_FILE_SYSTEM_CONTROL */
404 dispatch_ioctl
, /* IRP_MJ_DEVICE_CONTROL */
405 NULL
, /* IRP_MJ_INTERNAL_DEVICE_CONTROL */
406 NULL
, /* IRP_MJ_SHUTDOWN */
407 NULL
, /* IRP_MJ_LOCK_CONTROL */
408 NULL
, /* IRP_MJ_CLEANUP */
409 NULL
, /* IRP_MJ_CREATE_MAILSLOT */
410 NULL
, /* IRP_MJ_QUERY_SECURITY */
411 NULL
, /* IRP_MJ_SET_SECURITY */
412 NULL
, /* IRP_MJ_POWER */
413 NULL
, /* IRP_MJ_SYSTEM_CONTROL */
414 NULL
, /* IRP_MJ_DEVICE_CHANGE */
415 NULL
, /* IRP_MJ_QUERY_QUOTA */
416 NULL
, /* IRP_MJ_SET_QUOTA */
417 NULL
, /* IRP_MJ_PNP */
421 /***********************************************************************
422 * wine_ntoskrnl_main_loop (Not a Windows API)
424 NTSTATUS CDECL
wine_ntoskrnl_main_loop( HANDLE stop_event
)
426 HANDLE manager
= get_device_manager();
428 NTSTATUS status
= STATUS_SUCCESS
;
429 irp_params_t irp_params
;
431 ULONG in_size
= 4096, out_size
= 0;
434 request_thread
= GetCurrentThreadId();
436 if (!(in_buff
= HeapAlloc( GetProcessHeap(), 0, in_size
)))
438 ERR( "failed to allocate buffer\n" );
439 return STATUS_NO_MEMORY
;
442 handles
[0] = stop_event
;
443 handles
[1] = manager
;
447 SERVER_START_REQ( get_next_device_request
)
449 req
->manager
= wine_server_obj_handle( manager
);
450 req
->prev
= wine_server_obj_handle( irp
);
451 req
->status
= status
;
452 wine_server_set_reply( req
, in_buff
, in_size
);
453 if (!(status
= wine_server_call( req
)))
455 irp
= wine_server_ptr_handle( reply
->next
);
456 irp_params
= reply
->params
;
457 client_tid
= reply
->client_tid
;
458 client_pid
= reply
->client_pid
;
459 in_size
= reply
->in_size
;
460 out_size
= reply
->out_size
;
464 irp
= 0; /* no previous irp */
466 in_size
= reply
->in_size
;
474 if (irp_params
.major
> IRP_MJ_MAXIMUM_FUNCTION
|| !dispatch_funcs
[irp_params
.major
])
476 WARN( "unsupported request %u\n", irp_params
.major
);
477 status
= STATUS_NOT_SUPPORTED
;
480 status
= dispatch_funcs
[irp_params
.major
]( &irp_params
, in_buff
, in_size
, out_size
, irp
);
481 if (status
== STATUS_SUCCESS
) irp
= 0; /* status reported by IoCompleteRequest */
483 case STATUS_BUFFER_OVERFLOW
:
484 HeapFree( GetProcessHeap(), 0, in_buff
);
485 in_buff
= HeapAlloc( GetProcessHeap(), 0, in_size
);
486 /* restart with larger buffer */
491 DWORD ret
= WaitForMultipleObjectsEx( 2, handles
, FALSE
, INFINITE
, TRUE
);
492 if (ret
== WAIT_OBJECT_0
)
494 HeapFree( GetProcessHeap(), 0, in_buff
);
495 return STATUS_SUCCESS
;
497 if (ret
!= WAIT_IO_COMPLETION
) break;
505 /***********************************************************************
506 * IoAcquireCancelSpinLock (NTOSKRNL.EXE.@)
508 void WINAPI
IoAcquireCancelSpinLock(PKIRQL irql
)
510 FIXME("(%p): stub\n", irql
);
514 /***********************************************************************
515 * IoReleaseCancelSpinLock (NTOSKRNL.EXE.@)
517 void WINAPI
IoReleaseCancelSpinLock(PKIRQL irql
)
519 FIXME("(%p): stub\n", irql
);
523 /***********************************************************************
524 * IoAllocateDriverObjectExtension (NTOSKRNL.EXE.@)
526 NTSTATUS WINAPI
IoAllocateDriverObjectExtension( PDRIVER_OBJECT DriverObject
,
527 PVOID ClientIdentificationAddress
,
528 ULONG DriverObjectExtensionSize
,
529 PVOID
*DriverObjectExtension
)
531 FIXME( "stub: %p, %p, %u, %p\n", DriverObject
, ClientIdentificationAddress
,
532 DriverObjectExtensionSize
, DriverObjectExtension
);
533 return STATUS_NOT_IMPLEMENTED
;
537 /***********************************************************************
538 * IoGetDriverObjectExtension (NTOSKRNL.EXE.@)
540 PVOID WINAPI
IoGetDriverObjectExtension( PDRIVER_OBJECT DriverObject
,
541 PVOID ClientIdentificationAddress
)
543 FIXME( "stub: %p, %p\n", DriverObject
, ClientIdentificationAddress
);
548 /***********************************************************************
549 * IoInitializeIrp (NTOSKRNL.EXE.@)
551 void WINAPI
IoInitializeIrp( IRP
*irp
, USHORT size
, CCHAR stack_size
)
553 TRACE( "%p, %u, %d\n", irp
, size
, stack_size
);
555 RtlZeroMemory( irp
, size
);
557 irp
->Type
= IO_TYPE_IRP
;
559 InitializeListHead( &irp
->ThreadListEntry
);
560 irp
->StackCount
= stack_size
;
561 irp
->CurrentLocation
= stack_size
+ 1;
562 irp
->Tail
.Overlay
.s
.u2
.CurrentStackLocation
=
563 (PIO_STACK_LOCATION
)(irp
+ 1) + stack_size
;
567 /***********************************************************************
568 * IoInitializeTimer (NTOSKRNL.EXE.@)
570 NTSTATUS WINAPI
IoInitializeTimer(PDEVICE_OBJECT DeviceObject
,
571 PIO_TIMER_ROUTINE TimerRoutine
,
574 FIXME( "stub: %p, %p, %p\n", DeviceObject
, TimerRoutine
, Context
);
575 return STATUS_NOT_IMPLEMENTED
;
579 /***********************************************************************
580 * IoStartTimer (NTOSKRNL.EXE.@)
582 void WINAPI
IoStartTimer(PDEVICE_OBJECT DeviceObject
)
584 FIXME( "stub: %p\n", DeviceObject
);
588 /***********************************************************************
589 * IoAllocateIrp (NTOSKRNL.EXE.@)
591 PIRP WINAPI
IoAllocateIrp( CCHAR stack_size
, BOOLEAN charge_quota
)
596 TRACE( "%d, %d\n", stack_size
, charge_quota
);
598 size
= sizeof(IRP
) + stack_size
* sizeof(IO_STACK_LOCATION
);
599 irp
= ExAllocatePool( NonPagedPool
, size
);
602 IoInitializeIrp( irp
, size
, stack_size
);
603 irp
->AllocationFlags
= IRP_ALLOCATED_FIXED_SIZE
;
605 irp
->AllocationFlags
|= IRP_LOOKASIDE_ALLOCATION
;
610 /***********************************************************************
611 * IoFreeIrp (NTOSKRNL.EXE.@)
613 void WINAPI
IoFreeIrp( IRP
*irp
)
617 TRACE( "%p\n", irp
);
619 mdl
= irp
->MdlAddress
;
622 MDL
*next
= mdl
->Next
;
631 /***********************************************************************
632 * IoAllocateErrorLogEntry (NTOSKRNL.EXE.@)
634 PVOID WINAPI
IoAllocateErrorLogEntry( PVOID IoObject
, UCHAR EntrySize
)
636 FIXME( "stub: %p, %u\n", IoObject
, EntrySize
);
641 /***********************************************************************
642 * IoAllocateMdl (NTOSKRNL.EXE.@)
644 PMDL WINAPI
IoAllocateMdl( PVOID va
, ULONG length
, BOOLEAN secondary
, BOOLEAN charge_quota
, IRP
*irp
)
647 ULONG_PTR address
= (ULONG_PTR
)va
;
648 ULONG_PTR page_address
;
649 SIZE_T nb_pages
, mdl_size
;
651 TRACE("(%p, %u, %i, %i, %p)\n", va
, length
, secondary
, charge_quota
, irp
);
654 FIXME("Charge quota is not yet supported\n");
656 /* FIXME: We suppose that page size is 4096 */
657 page_address
= address
& ~(4096 - 1);
658 nb_pages
= (((address
+ length
- 1) & ~(4096 - 1)) - page_address
) / 4096 + 1;
660 mdl_size
= sizeof(MDL
) + nb_pages
* sizeof(PVOID
);
662 mdl
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, mdl_size
);
666 mdl
->Size
= mdl_size
;
667 mdl
->Process
= NULL
; /* FIXME: IoGetCurrentProcess */
668 mdl
->StartVa
= (PVOID
)page_address
;
669 mdl
->ByteCount
= length
;
670 mdl
->ByteOffset
= address
- page_address
;
672 if (!irp
) return mdl
;
674 if (secondary
) /* add it at the end */
676 MDL
**pmdl
= &irp
->MdlAddress
;
677 while (*pmdl
) pmdl
= &(*pmdl
)->Next
;
682 mdl
->Next
= irp
->MdlAddress
;
683 irp
->MdlAddress
= mdl
;
689 /***********************************************************************
690 * IoFreeMdl (NTOSKRNL.EXE.@)
692 void WINAPI
IoFreeMdl(PMDL mdl
)
695 HeapFree(GetProcessHeap(), 0, mdl
);
699 /***********************************************************************
700 * IoAllocateWorkItem (NTOSKRNL.EXE.@)
702 PIO_WORKITEM WINAPI
IoAllocateWorkItem( PDEVICE_OBJECT DeviceObject
)
704 FIXME( "stub: %p\n", DeviceObject
);
709 /***********************************************************************
710 * IoAttachDeviceToDeviceStack (NTOSKRNL.EXE.@)
712 PDEVICE_OBJECT WINAPI
IoAttachDeviceToDeviceStack( DEVICE_OBJECT
*source
,
713 DEVICE_OBJECT
*target
)
715 TRACE( "%p, %p\n", source
, target
);
716 target
->AttachedDevice
= source
;
717 source
->StackSize
= target
->StackSize
+ 1;
722 /***********************************************************************
723 * IoBuildDeviceIoControlRequest (NTOSKRNL.EXE.@)
725 PIRP WINAPI
IoBuildDeviceIoControlRequest( ULONG code
, PDEVICE_OBJECT device
,
726 PVOID in_buff
, ULONG in_len
,
727 PVOID out_buff
, ULONG out_len
,
728 BOOLEAN internal
, PKEVENT event
,
729 PIO_STATUS_BLOCK iosb
)
732 PIO_STACK_LOCATION irpsp
;
734 TRACE( "%x, %p, %p, %u, %p, %u, %u, %p, %p\n",
735 code
, device
, in_buff
, in_len
, out_buff
, out_len
, internal
, event
, iosb
);
740 irp
= IoAllocateIrp( device
->StackSize
, FALSE
);
744 irpsp
= IoGetNextIrpStackLocation( irp
);
745 irpsp
->MajorFunction
= internal
? IRP_MJ_INTERNAL_DEVICE_CONTROL
: IRP_MJ_DEVICE_CONTROL
;
746 irpsp
->Parameters
.DeviceIoControl
.IoControlCode
= code
;
747 irpsp
->Parameters
.DeviceIoControl
.InputBufferLength
= in_len
;
748 irpsp
->Parameters
.DeviceIoControl
.OutputBufferLength
= out_len
;
749 irpsp
->DeviceObject
= device
;
750 irpsp
->CompletionRoutine
= NULL
;
754 case METHOD_BUFFERED
:
755 irp
->AssociatedIrp
.SystemBuffer
= in_buff
;
757 case METHOD_IN_DIRECT
:
758 case METHOD_OUT_DIRECT
:
759 irp
->AssociatedIrp
.SystemBuffer
= in_buff
;
760 IoAllocateMdl( out_buff
, out_len
, FALSE
, FALSE
, irp
);
763 irpsp
->Parameters
.DeviceIoControl
.Type3InputBuffer
= in_buff
;
767 irp
->RequestorMode
= KernelMode
;
768 irp
->UserBuffer
= out_buff
;
769 irp
->UserIosb
= iosb
;
770 irp
->UserEvent
= event
;
775 /**********************************************************
776 * IoBuildSynchronousFsdRequest (NTOSKRNL.EXE.@)
778 PIRP WINAPI
IoBuildSynchronousFsdRequest(ULONG majorfunc
, PDEVICE_OBJECT device
,
779 PVOID buffer
, ULONG length
, PLARGE_INTEGER startoffset
,
780 PKEVENT event
, PIO_STATUS_BLOCK iosb
)
783 PIO_STACK_LOCATION irpsp
;
785 TRACE("(%d %p %p %d %p %p %p)\n", majorfunc
, device
, buffer
, length
, startoffset
, event
, iosb
);
787 if (!(irp
= IoAllocateIrp( device
->StackSize
, FALSE
))) return NULL
;
789 irpsp
= IoGetNextIrpStackLocation( irp
);
790 irpsp
->MajorFunction
= majorfunc
;
791 irpsp
->DeviceObject
= device
;
792 irpsp
->CompletionRoutine
= NULL
;
794 irp
->AssociatedIrp
.SystemBuffer
= buffer
;
795 if (device
->Flags
& DO_DIRECT_IO
) IoAllocateMdl( buffer
, length
, FALSE
, FALSE
, irp
);
800 irpsp
->Parameters
.Read
.Length
= length
;
801 irpsp
->Parameters
.Read
.ByteOffset
= *startoffset
;
804 irpsp
->Parameters
.Write
.Length
= length
;
805 irpsp
->Parameters
.Write
.ByteOffset
= *startoffset
;
808 irp
->RequestorMode
= KernelMode
;
809 irp
->UserIosb
= iosb
;
810 irp
->UserEvent
= event
;
811 irp
->UserBuffer
= buffer
;
816 /***********************************************************************
817 * IoCreateDriver (NTOSKRNL.EXE.@)
819 NTSTATUS WINAPI
IoCreateDriver( UNICODE_STRING
*name
, PDRIVER_INITIALIZE init
)
821 DRIVER_OBJECT
*driver
;
822 DRIVER_EXTENSION
*extension
;
825 TRACE("(%s, %p)\n", debugstr_us(name
), init
);
827 if (!(driver
= RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY
,
828 sizeof(*driver
) + sizeof(*extension
) )))
829 return STATUS_NO_MEMORY
;
831 if ((status
= RtlDuplicateUnicodeString( 1, name
, &driver
->DriverName
)))
833 RtlFreeHeap( GetProcessHeap(), 0, driver
);
837 extension
= (DRIVER_EXTENSION
*)(driver
+ 1);
838 driver
->Size
= sizeof(*driver
);
839 driver
->DriverInit
= init
;
840 driver
->DriverExtension
= extension
;
841 extension
->DriverObject
= driver
;
842 extension
->ServiceKeyName
= driver
->DriverName
;
844 status
= driver
->DriverInit( driver
, name
);
848 RtlFreeUnicodeString( &driver
->DriverName
);
849 RtlFreeHeap( GetProcessHeap(), 0, driver
);
855 /***********************************************************************
856 * IoDeleteDriver (NTOSKRNL.EXE.@)
858 void WINAPI
IoDeleteDriver( DRIVER_OBJECT
*driver
)
860 TRACE("(%p)\n", driver
);
862 RtlFreeUnicodeString( &driver
->DriverName
);
863 RtlFreeHeap( GetProcessHeap(), 0, driver
);
867 /***********************************************************************
868 * IoCreateDevice (NTOSKRNL.EXE.@)
870 NTSTATUS WINAPI
IoCreateDevice( DRIVER_OBJECT
*driver
, ULONG ext_size
,
871 UNICODE_STRING
*name
, DEVICE_TYPE type
,
872 ULONG characteristics
, BOOLEAN exclusive
,
873 DEVICE_OBJECT
**ret_device
)
876 DEVICE_OBJECT
*device
;
878 HANDLE manager
= get_device_manager();
880 TRACE( "(%p, %u, %s, %u, %x, %u, %p)\n",
881 driver
, ext_size
, debugstr_us(name
), type
, characteristics
, exclusive
, ret_device
);
883 if (!(device
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*device
) + ext_size
)))
884 return STATUS_NO_MEMORY
;
886 SERVER_START_REQ( create_device
)
891 req
->manager
= wine_server_obj_handle( manager
);
892 req
->user_ptr
= wine_server_client_ptr( device
);
893 if (name
) wine_server_add_data( req
, name
->Buffer
, name
->Length
);
894 if (!(status
= wine_server_call( req
))) handle
= wine_server_ptr_handle( reply
->handle
);
898 if (status
== STATUS_SUCCESS
)
900 device
->DriverObject
= driver
;
901 device
->DeviceExtension
= device
+ 1;
902 device
->DeviceType
= type
;
903 device
->StackSize
= 1;
904 device
->Reserved
= handle
;
906 device
->NextDevice
= driver
->DeviceObject
;
907 driver
->DeviceObject
= device
;
909 *ret_device
= device
;
911 else HeapFree( GetProcessHeap(), 0, device
);
917 /***********************************************************************
918 * IoDeleteDevice (NTOSKRNL.EXE.@)
920 void WINAPI
IoDeleteDevice( DEVICE_OBJECT
*device
)
924 TRACE( "%p\n", device
);
926 SERVER_START_REQ( delete_device
)
928 req
->handle
= wine_server_obj_handle( device
->Reserved
);
929 status
= wine_server_call( req
);
933 if (status
== STATUS_SUCCESS
)
935 DEVICE_OBJECT
**prev
= &device
->DriverObject
->DeviceObject
;
936 while (*prev
&& *prev
!= device
) prev
= &(*prev
)->NextDevice
;
937 if (*prev
) *prev
= (*prev
)->NextDevice
;
938 NtClose( device
->Reserved
);
939 HeapFree( GetProcessHeap(), 0, device
);
944 /***********************************************************************
945 * IoCreateSymbolicLink (NTOSKRNL.EXE.@)
947 NTSTATUS WINAPI
IoCreateSymbolicLink( UNICODE_STRING
*name
, UNICODE_STRING
*target
)
950 OBJECT_ATTRIBUTES attr
;
952 attr
.Length
= sizeof(attr
);
953 attr
.RootDirectory
= 0;
954 attr
.ObjectName
= name
;
955 attr
.Attributes
= OBJ_CASE_INSENSITIVE
| OBJ_OPENIF
;
956 attr
.SecurityDescriptor
= NULL
;
957 attr
.SecurityQualityOfService
= NULL
;
959 TRACE( "%s -> %s\n", debugstr_us(name
), debugstr_us(target
) );
960 /* FIXME: store handle somewhere */
961 return NtCreateSymbolicLinkObject( &handle
, SYMBOLIC_LINK_ALL_ACCESS
, &attr
, target
);
965 /***********************************************************************
966 * IoDeleteSymbolicLink (NTOSKRNL.EXE.@)
968 NTSTATUS WINAPI
IoDeleteSymbolicLink( UNICODE_STRING
*name
)
971 OBJECT_ATTRIBUTES attr
;
974 attr
.Length
= sizeof(attr
);
975 attr
.RootDirectory
= 0;
976 attr
.ObjectName
= name
;
977 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
978 attr
.SecurityDescriptor
= NULL
;
979 attr
.SecurityQualityOfService
= NULL
;
981 if (!(status
= NtOpenSymbolicLinkObject( &handle
, 0, &attr
)))
983 SERVER_START_REQ( unlink_object
)
985 req
->handle
= wine_server_obj_handle( handle
);
986 status
= wine_server_call( req
);
995 /***********************************************************************
996 * IoGetDeviceInterfaces (NTOSKRNL.EXE.@)
998 NTSTATUS WINAPI
IoGetDeviceInterfaces( const GUID
*InterfaceClassGuid
,
999 PDEVICE_OBJECT PhysicalDeviceObject
,
1000 ULONG Flags
, PWSTR
*SymbolicLinkList
)
1002 FIXME( "stub: %s %p %x %p\n", debugstr_guid(InterfaceClassGuid
),
1003 PhysicalDeviceObject
, Flags
, SymbolicLinkList
);
1004 return STATUS_NOT_IMPLEMENTED
;
1008 /***********************************************************************
1009 * IoGetDeviceObjectPointer (NTOSKRNL.EXE.@)
1011 NTSTATUS WINAPI
IoGetDeviceObjectPointer( UNICODE_STRING
*name
, ACCESS_MASK access
, PFILE_OBJECT
*file
, PDEVICE_OBJECT
*device
)
1013 static DEVICE_OBJECT stub_device
;
1014 static DRIVER_OBJECT stub_driver
;
1016 FIXME( "stub: %s %x %p %p\n", debugstr_us(name
), access
, file
, device
);
1018 stub_device
.StackSize
= 0x80; /* minimum value to appease SecuROM 5.x */
1019 stub_device
.DriverObject
= &stub_driver
;
1022 *device
= &stub_device
;
1024 return STATUS_SUCCESS
;
1027 /***********************************************************************
1028 * IoGetAttachedDevice (NTOSKRNL.EXE.@)
1030 PDEVICE_OBJECT WINAPI
IoGetAttachedDevice( PDEVICE_OBJECT device
)
1032 FIXME( "stub: %p\n", device
);
1037 /***********************************************************************
1038 * IoGetDeviceProperty (NTOSKRNL.EXE.@)
1040 NTSTATUS WINAPI
IoGetDeviceProperty( DEVICE_OBJECT
*device
, DEVICE_REGISTRY_PROPERTY device_property
,
1041 ULONG buffer_length
, PVOID property_buffer
, PULONG result_length
)
1043 FIXME( "%p %d %u %p %p: stub\n", device
, device_property
, buffer_length
,
1044 property_buffer
, result_length
);
1045 return STATUS_NOT_IMPLEMENTED
;
1049 /***********************************************************************
1050 * IoCallDriver (NTOSKRNL.EXE.@)
1052 NTSTATUS WINAPI
IoCallDriver( DEVICE_OBJECT
*device
, IRP
*irp
)
1054 PDRIVER_DISPATCH dispatch
;
1055 IO_STACK_LOCATION
*irpsp
;
1058 --irp
->CurrentLocation
;
1059 irpsp
= --irp
->Tail
.Overlay
.s
.u2
.CurrentStackLocation
;
1060 dispatch
= device
->DriverObject
->MajorFunction
[irpsp
->MajorFunction
];
1062 if (TRACE_ON(relay
))
1063 DPRINTF( "%04x:Call driver dispatch %p (device=%p,irp=%p)\n",
1064 GetCurrentThreadId(), dispatch
, device
, irp
);
1066 status
= dispatch( device
, irp
);
1068 if (TRACE_ON(relay
))
1069 DPRINTF( "%04x:Ret driver dispatch %p (device=%p,irp=%p) retval=%08x\n",
1070 GetCurrentThreadId(), dispatch
, device
, irp
, status
);
1076 /***********************************************************************
1077 * IofCallDriver (NTOSKRNL.EXE.@)
1079 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1080 DEFINE_FASTCALL2_ENTRYPOINT( IofCallDriver
)
1081 NTSTATUS WINAPI
__regs_IofCallDriver( DEVICE_OBJECT
*device
, IRP
*irp
)
1083 NTSTATUS WINAPI
IofCallDriver( DEVICE_OBJECT
*device
, IRP
*irp
)
1086 TRACE( "%p %p\n", device
, irp
);
1087 return IoCallDriver( device
, irp
);
1091 /***********************************************************************
1092 * IoGetRelatedDeviceObject (NTOSKRNL.EXE.@)
1094 PDEVICE_OBJECT WINAPI
IoGetRelatedDeviceObject( PFILE_OBJECT obj
)
1096 FIXME( "stub: %p\n", obj
);
1100 static CONFIGURATION_INFORMATION configuration_information
;
1102 /***********************************************************************
1103 * IoGetConfigurationInformation (NTOSKRNL.EXE.@)
1105 PCONFIGURATION_INFORMATION WINAPI
IoGetConfigurationInformation(void)
1107 FIXME( "partial stub\n" );
1108 /* FIXME: return actual devices on system */
1109 return &configuration_information
;
1113 /***********************************************************************
1114 * IoIsWdmVersionAvailable (NTOSKRNL.EXE.@)
1116 NTSTATUS WINAPI
IoIsWdmVersionAvailable(UCHAR MajorVersion
, UCHAR MinorVersion
)
1122 TRACE( "%d, 0x%X\n", MajorVersion
, MinorVersion
);
1124 version
= GetVersion();
1125 major
= LOBYTE(version
);
1126 minor
= HIBYTE(LOWORD(version
));
1128 if (MajorVersion
== 6 && MinorVersion
== 0)
1130 /* Windows Vista, Windows Server 2008, Windows 7 */
1132 else if (MajorVersion
== 1)
1134 if (MinorVersion
== 0x30)
1136 /* Windows server 2003 */
1140 else if (MinorVersion
== 0x20)
1146 else if (MinorVersion
== 0x10)
1152 else if (MinorVersion
== 0x05)
1156 MinorVersion
= 0x5a;
1158 else if (MinorVersion
== 0x00)
1162 MinorVersion
= 0x0a;
1166 FIXME( "unknown major %d minor 0x%X\n", MajorVersion
, MinorVersion
);
1172 FIXME( "unknown major %d minor 0x%X\n", MajorVersion
, MinorVersion
);
1175 return major
> MajorVersion
|| (major
== MajorVersion
&& minor
>= MinorVersion
);
1179 /***********************************************************************
1180 * IoQueryDeviceDescription (NTOSKRNL.EXE.@)
1182 NTSTATUS WINAPI
IoQueryDeviceDescription(PINTERFACE_TYPE itype
, PULONG bus
, PCONFIGURATION_TYPE ctype
,
1183 PULONG cnum
, PCONFIGURATION_TYPE ptype
, PULONG pnum
,
1184 PIO_QUERY_DEVICE_ROUTINE callout
, PVOID context
)
1186 FIXME( "(%p %p %p %p %p %p %p %p)\n", itype
, bus
, ctype
, cnum
, ptype
, pnum
, callout
, context
);
1187 return STATUS_NOT_IMPLEMENTED
;
1191 /***********************************************************************
1192 * IoRegisterDriverReinitialization (NTOSKRNL.EXE.@)
1194 void WINAPI
IoRegisterDriverReinitialization( PDRIVER_OBJECT obj
, PDRIVER_REINITIALIZE reinit
, PVOID context
)
1196 FIXME( "stub: %p %p %p\n", obj
, reinit
, context
);
1200 /***********************************************************************
1201 * IoRegisterShutdownNotification (NTOSKRNL.EXE.@)
1203 NTSTATUS WINAPI
IoRegisterShutdownNotification( PDEVICE_OBJECT obj
)
1205 FIXME( "stub: %p\n", obj
);
1206 return STATUS_SUCCESS
;
1210 /***********************************************************************
1211 * IoUnregisterShutdownNotification (NTOSKRNL.EXE.@)
1213 VOID WINAPI
IoUnregisterShutdownNotification( PDEVICE_OBJECT obj
)
1215 FIXME( "stub: %p\n", obj
);
1219 /***********************************************************************
1220 * IoReportResourceUsage (NTOSKRNL.EXE.@)
1222 NTSTATUS WINAPI
IoReportResourceUsage(PUNICODE_STRING name
, PDRIVER_OBJECT drv_obj
, PCM_RESOURCE_LIST drv_list
,
1223 ULONG drv_size
, PDRIVER_OBJECT dev_obj
, PCM_RESOURCE_LIST dev_list
,
1224 ULONG dev_size
, BOOLEAN overwrite
, PBOOLEAN detected
)
1226 FIXME("(%s %p %p %u %p %p %u %d %p) stub\n", debugstr_w(name
? name
->Buffer
: NULL
),
1227 drv_obj
, drv_list
, drv_size
, dev_obj
, dev_list
, dev_size
, overwrite
, detected
);
1228 return STATUS_NOT_IMPLEMENTED
;
1232 /***********************************************************************
1233 * IoCompleteRequest (NTOSKRNL.EXE.@)
1235 VOID WINAPI
IoCompleteRequest( IRP
*irp
, UCHAR priority_boost
)
1237 IO_STACK_LOCATION
*irpsp
;
1238 PIO_COMPLETION_ROUTINE routine
;
1239 NTSTATUS status
, stat
;
1243 TRACE( "%p %u\n", irp
, priority_boost
);
1245 status
= irp
->IoStatus
.u
.Status
;
1246 while (irp
->CurrentLocation
<= irp
->StackCount
)
1248 irpsp
= irp
->Tail
.Overlay
.s
.u2
.CurrentStackLocation
;
1249 routine
= irpsp
->CompletionRoutine
;
1251 /* FIXME: add SL_INVOKE_ON_CANCEL support */
1254 if ((irpsp
->Control
& SL_INVOKE_ON_SUCCESS
) && STATUS_SUCCESS
== status
)
1256 if ((irpsp
->Control
& SL_INVOKE_ON_ERROR
) && STATUS_SUCCESS
!= status
)
1259 ++irp
->CurrentLocation
;
1260 ++irp
->Tail
.Overlay
.s
.u2
.CurrentStackLocation
;
1263 TRACE( "calling %p( %p, %p, %p )\n", routine
,
1264 irpsp
->DeviceObject
, irp
, irpsp
->Context
);
1265 stat
= routine( irpsp
->DeviceObject
, irp
, irpsp
->Context
);
1266 TRACE( "CompletionRoutine returned %x\n", stat
);
1267 if (STATUS_MORE_PROCESSING_REQUIRED
== stat
)
1272 handle
= (HANDLE
)irp
->UserIosb
;
1275 void *out_buff
= irp
->UserBuffer
;
1276 FILE_OBJECT
*file
= irp
->Tail
.Overlay
.OriginalFileObject
;
1278 SERVER_START_REQ( set_irp_result
)
1280 req
->handle
= wine_server_obj_handle( handle
);
1281 req
->status
= irp
->IoStatus
.u
.Status
;
1282 req
->file_ptr
= wine_server_client_ptr( file
);
1283 if (irp
->IoStatus
.u
.Status
>= 0)
1285 req
->size
= irp
->IoStatus
.Information
;
1286 if (out_buff
) wine_server_add_data( req
, out_buff
, irp
->IoStatus
.Information
);
1288 wine_server_call( req
);
1291 HeapFree( GetProcessHeap(), 0, out_buff
);
1298 /***********************************************************************
1299 * IofCompleteRequest (NTOSKRNL.EXE.@)
1301 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1302 DEFINE_FASTCALL2_ENTRYPOINT( IofCompleteRequest
)
1303 void WINAPI
__regs_IofCompleteRequest( IRP
*irp
, UCHAR priority_boost
)
1305 void WINAPI
IofCompleteRequest( IRP
*irp
, UCHAR priority_boost
)
1308 TRACE( "%p %u\n", irp
, priority_boost
);
1309 IoCompleteRequest( irp
, priority_boost
);
1313 /***********************************************************************
1314 * InterlockedCompareExchange (NTOSKRNL.EXE.@)
1316 #ifdef DEFINE_FASTCALL3_ENTRYPOINT
1317 DEFINE_FASTCALL3_ENTRYPOINT( NTOSKRNL_InterlockedCompareExchange
)
1318 LONG WINAPI
__regs_NTOSKRNL_InterlockedCompareExchange( LONG
volatile *dest
, LONG xchg
, LONG compare
)
1320 LONG WINAPI
NTOSKRNL_InterlockedCompareExchange( LONG
volatile *dest
, LONG xchg
, LONG compare
)
1323 return InterlockedCompareExchange( dest
, xchg
, compare
);
1327 /***********************************************************************
1328 * InterlockedDecrement (NTOSKRNL.EXE.@)
1330 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1331 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedDecrement
)
1332 LONG WINAPI
__regs_NTOSKRNL_InterlockedDecrement( LONG
volatile *dest
)
1334 LONG WINAPI
NTOSKRNL_InterlockedDecrement( LONG
volatile *dest
)
1337 return InterlockedDecrement( dest
);
1341 /***********************************************************************
1342 * InterlockedExchange (NTOSKRNL.EXE.@)
1344 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1345 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchange
)
1346 LONG WINAPI
__regs_NTOSKRNL_InterlockedExchange( LONG
volatile *dest
, LONG val
)
1348 LONG WINAPI
NTOSKRNL_InterlockedExchange( LONG
volatile *dest
, LONG val
)
1351 return InterlockedExchange( dest
, val
);
1355 /***********************************************************************
1356 * InterlockedExchangeAdd (NTOSKRNL.EXE.@)
1358 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1359 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchangeAdd
)
1360 LONG WINAPI
__regs_NTOSKRNL_InterlockedExchangeAdd( LONG
volatile *dest
, LONG incr
)
1362 LONG WINAPI
NTOSKRNL_InterlockedExchangeAdd( LONG
volatile *dest
, LONG incr
)
1365 return InterlockedExchangeAdd( dest
, incr
);
1369 /***********************************************************************
1370 * InterlockedIncrement (NTOSKRNL.EXE.@)
1372 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1373 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedIncrement
)
1374 LONG WINAPI
__regs_NTOSKRNL_InterlockedIncrement( LONG
volatile *dest
)
1376 LONG WINAPI
NTOSKRNL_InterlockedIncrement( LONG
volatile *dest
)
1379 return InterlockedIncrement( dest
);
1383 /***********************************************************************
1384 * ExAllocatePool (NTOSKRNL.EXE.@)
1386 PVOID WINAPI
ExAllocatePool( POOL_TYPE type
, SIZE_T size
)
1388 return ExAllocatePoolWithTag( type
, size
, 0 );
1392 /***********************************************************************
1393 * ExAllocatePoolWithQuota (NTOSKRNL.EXE.@)
1395 PVOID WINAPI
ExAllocatePoolWithQuota( POOL_TYPE type
, SIZE_T size
)
1397 return ExAllocatePoolWithTag( type
, size
, 0 );
1401 /***********************************************************************
1402 * ExAllocatePoolWithTag (NTOSKRNL.EXE.@)
1404 PVOID WINAPI
ExAllocatePoolWithTag( POOL_TYPE type
, SIZE_T size
, ULONG tag
)
1406 /* FIXME: handle page alignment constraints */
1407 void *ret
= HeapAlloc( GetProcessHeap(), 0, size
);
1408 TRACE( "%lu pool %u -> %p\n", size
, type
, ret
);
1413 /***********************************************************************
1414 * ExAllocatePoolWithQuotaTag (NTOSKRNL.EXE.@)
1416 PVOID WINAPI
ExAllocatePoolWithQuotaTag( POOL_TYPE type
, SIZE_T size
, ULONG tag
)
1418 return ExAllocatePoolWithTag( type
, size
, tag
);
1422 /***********************************************************************
1423 * ExCreateCallback (NTOSKRNL.EXE.@)
1425 NTSTATUS WINAPI
ExCreateCallback(PCALLBACK_OBJECT
*obj
, POBJECT_ATTRIBUTES attr
,
1426 BOOLEAN create
, BOOLEAN allow_multiple
)
1428 FIXME("(%p, %p, %u, %u): stub\n", obj
, attr
, create
, allow_multiple
);
1430 return STATUS_NOT_IMPLEMENTED
;
1434 /***********************************************************************
1435 * ExDeleteNPagedLookasideList (NTOSKRNL.EXE.@)
1437 void WINAPI
ExDeleteNPagedLookasideList( PNPAGED_LOOKASIDE_LIST lookaside
)
1439 FIXME("(%p) stub\n", lookaside
);
1443 /***********************************************************************
1444 * ExDeletePagedLookasideList (NTOSKRNL.EXE.@)
1446 void WINAPI
ExDeletePagedLookasideList( PPAGED_LOOKASIDE_LIST lookaside
)
1448 FIXME("(%p) stub\n", lookaside
);
1452 /***********************************************************************
1453 * ExFreePool (NTOSKRNL.EXE.@)
1455 void WINAPI
ExFreePool( void *ptr
)
1457 ExFreePoolWithTag( ptr
, 0 );
1461 /***********************************************************************
1462 * ExFreePoolWithTag (NTOSKRNL.EXE.@)
1464 void WINAPI
ExFreePoolWithTag( void *ptr
, ULONG tag
)
1466 TRACE( "%p\n", ptr
);
1467 HeapFree( GetProcessHeap(), 0, ptr
);
1471 /***********************************************************************
1472 * ExInitializeResourceLite (NTOSKRNL.EXE.@)
1474 NTSTATUS WINAPI
ExInitializeResourceLite(PERESOURCE Resource
)
1476 FIXME( "stub: %p\n", Resource
);
1477 return STATUS_NOT_IMPLEMENTED
;
1481 /***********************************************************************
1482 * ExInitializeNPagedLookasideList (NTOSKRNL.EXE.@)
1484 void WINAPI
ExInitializeNPagedLookasideList(PNPAGED_LOOKASIDE_LIST Lookaside
,
1485 PALLOCATE_FUNCTION Allocate
,
1486 PFREE_FUNCTION Free
,
1492 FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside
, Allocate
, Free
, Flags
, Size
, Tag
, Depth
);
1495 /***********************************************************************
1496 * ExInitializePagedLookasideList (NTOSKRNL.EXE.@)
1498 void WINAPI
ExInitializePagedLookasideList(PPAGED_LOOKASIDE_LIST Lookaside
,
1499 PALLOCATE_FUNCTION Allocate
,
1500 PFREE_FUNCTION Free
,
1506 FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside
, Allocate
, Free
, Flags
, Size
, Tag
, Depth
);
1509 /***********************************************************************
1510 * ExInitializeZone (NTOSKRNL.EXE.@)
1512 NTSTATUS WINAPI
ExInitializeZone(PZONE_HEADER Zone
,
1514 PVOID InitialSegment
,
1515 ULONG InitialSegmentSize
)
1517 FIXME( "stub: %p, %u, %p, %u\n", Zone
, BlockSize
, InitialSegment
, InitialSegmentSize
);
1518 return STATUS_NOT_IMPLEMENTED
;
1521 /***********************************************************************
1522 * FsRtlRegisterUncProvider (NTOSKRNL.EXE.@)
1524 NTSTATUS WINAPI
FsRtlRegisterUncProvider(PHANDLE MupHandle
, PUNICODE_STRING RedirDevName
,
1525 BOOLEAN MailslotsSupported
)
1527 FIXME("(%p %p %d): stub\n", MupHandle
, RedirDevName
, MailslotsSupported
);
1528 return STATUS_NOT_IMPLEMENTED
;
1531 /***********************************************************************
1532 * IoGetCurrentProcess / PsGetCurrentProcess (NTOSKRNL.EXE.@)
1534 PEPROCESS WINAPI
IoGetCurrentProcess(void)
1540 /***********************************************************************
1541 * KeGetCurrentThread / PsGetCurrentThread (NTOSKRNL.EXE.@)
1543 PRKTHREAD WINAPI
KeGetCurrentThread(void)
1549 /***********************************************************************
1550 * KeInitializeEvent (NTOSKRNL.EXE.@)
1552 void WINAPI
KeInitializeEvent( PRKEVENT Event
, EVENT_TYPE Type
, BOOLEAN State
)
1554 FIXME( "stub: %p %d %d\n", Event
, Type
, State
);
1558 /***********************************************************************
1559 * KeInitializeMutex (NTOSKRNL.EXE.@)
1561 void WINAPI
KeInitializeMutex(PRKMUTEX Mutex
, ULONG Level
)
1563 FIXME( "stub: %p, %u\n", Mutex
, Level
);
1567 /***********************************************************************
1568 * KeWaitForMutexObject (NTOSKRNL.EXE.@)
1570 NTSTATUS WINAPI
KeWaitForMutexObject(PRKMUTEX Mutex
, KWAIT_REASON WaitReason
, KPROCESSOR_MODE WaitMode
,
1571 BOOLEAN Alertable
, PLARGE_INTEGER Timeout
)
1573 FIXME( "stub: %p, %d, %d, %d, %p\n", Mutex
, WaitReason
, WaitMode
, Alertable
, Timeout
);
1574 return STATUS_NOT_IMPLEMENTED
;
1578 /***********************************************************************
1579 * KeReleaseMutex (NTOSKRNL.EXE.@)
1581 LONG WINAPI
KeReleaseMutex(PRKMUTEX Mutex
, BOOLEAN Wait
)
1583 FIXME( "stub: %p, %d\n", Mutex
, Wait
);
1584 return STATUS_NOT_IMPLEMENTED
;
1588 /***********************************************************************
1589 * KeInitializeSemaphore (NTOSKRNL.EXE.@)
1591 void WINAPI
KeInitializeSemaphore( PRKSEMAPHORE Semaphore
, LONG Count
, LONG Limit
)
1593 FIXME( "(%p %d %d) stub\n", Semaphore
, Count
, Limit
);
1597 /***********************************************************************
1598 * KeInitializeSpinLock (NTOSKRNL.EXE.@)
1600 void WINAPI
KeInitializeSpinLock( PKSPIN_LOCK SpinLock
)
1602 FIXME( "stub: %p\n", SpinLock
);
1606 /***********************************************************************
1607 * KeInitializeTimerEx (NTOSKRNL.EXE.@)
1609 void WINAPI
KeInitializeTimerEx( PKTIMER Timer
, TIMER_TYPE Type
)
1611 FIXME( "stub: %p %d\n", Timer
, Type
);
1615 /***********************************************************************
1616 * KeInitializeTimer (NTOSKRNL.EXE.@)
1618 void WINAPI
KeInitializeTimer( PKTIMER Timer
)
1620 KeInitializeTimerEx(Timer
, NotificationTimer
);
1623 /***********************************************************************
1624 * KeInsertQueue (NTOSKRNL.EXE.@)
1626 LONG WINAPI
KeInsertQueue(PRKQUEUE Queue
, PLIST_ENTRY Entry
)
1628 FIXME( "stub: %p %p\n", Queue
, Entry
);
1632 /**********************************************************************
1633 * KeQueryActiveProcessors (NTOSKRNL.EXE.@)
1635 * Return the active Processors as bitmask
1638 * active Processors as bitmask
1641 KAFFINITY WINAPI
KeQueryActiveProcessors( void )
1643 DWORD_PTR AffinityMask
;
1645 GetProcessAffinityMask( GetCurrentProcess(), &AffinityMask
, NULL
);
1646 return AffinityMask
;
1650 /**********************************************************************
1651 * KeQueryInterruptTime (NTOSKRNL.EXE.@)
1653 * Return the interrupt time count
1656 ULONGLONG WINAPI
KeQueryInterruptTime( void )
1658 LARGE_INTEGER totaltime
;
1660 KeQueryTickCount(&totaltime
);
1661 return totaltime
.QuadPart
;
1665 /***********************************************************************
1666 * KeQuerySystemTime (NTOSKRNL.EXE.@)
1668 void WINAPI
KeQuerySystemTime( LARGE_INTEGER
*time
)
1670 NtQuerySystemTime( time
);
1674 /***********************************************************************
1675 * KeQueryTickCount (NTOSKRNL.EXE.@)
1677 void WINAPI
KeQueryTickCount( LARGE_INTEGER
*count
)
1679 count
->QuadPart
= NtGetTickCount();
1680 /* update the global variable too */
1681 KeTickCount
.LowPart
= count
->u
.LowPart
;
1682 KeTickCount
.High1Time
= count
->u
.HighPart
;
1683 KeTickCount
.High2Time
= count
->u
.HighPart
;
1687 /***********************************************************************
1688 * KeReleaseSemaphore (NTOSKRNL.EXE.@)
1690 LONG WINAPI
KeReleaseSemaphore( PRKSEMAPHORE Semaphore
, KPRIORITY Increment
,
1691 LONG Adjustment
, BOOLEAN Wait
)
1693 FIXME("(%p %d %d %d) stub\n", Semaphore
, Increment
, Adjustment
, Wait
);
1698 /***********************************************************************
1699 * KeQueryTimeIncrement (NTOSKRNL.EXE.@)
1701 ULONG WINAPI
KeQueryTimeIncrement(void)
1707 /***********************************************************************
1708 * KeResetEvent (NTOSKRNL.EXE.@)
1710 LONG WINAPI
KeResetEvent( PRKEVENT Event
)
1712 FIXME("(%p): stub\n", Event
);
1717 /***********************************************************************
1718 * KeSetEvent (NTOSKRNL.EXE.@)
1720 LONG WINAPI
KeSetEvent( PRKEVENT Event
, KPRIORITY Increment
, BOOLEAN Wait
)
1722 FIXME("(%p, %d, %d): stub\n", Event
, Increment
, Wait
);
1727 /***********************************************************************
1728 * KeSetPriorityThread (NTOSKRNL.EXE.@)
1730 KPRIORITY WINAPI
KeSetPriorityThread( PKTHREAD Thread
, KPRIORITY Priority
)
1732 FIXME("(%p %d)\n", Thread
, Priority
);
1736 /***********************************************************************
1737 * KeSetSystemAffinityThread (NTOSKRNL.EXE.@)
1739 VOID WINAPI
KeSetSystemAffinityThread(KAFFINITY Affinity
)
1741 FIXME("(%lx) stub\n", Affinity
);
1744 /***********************************************************************
1745 * KeWaitForSingleObject (NTOSKRNL.EXE.@)
1747 NTSTATUS WINAPI
KeWaitForSingleObject(PVOID Object
,
1748 KWAIT_REASON WaitReason
,
1749 KPROCESSOR_MODE WaitMode
,
1751 PLARGE_INTEGER Timeout
)
1753 FIXME( "stub: %p, %d, %d, %d, %p\n", Object
, WaitReason
, WaitMode
, Alertable
, Timeout
);
1754 return STATUS_NOT_IMPLEMENTED
;
1757 /***********************************************************************
1758 * IoRegisterFileSystem (NTOSKRNL.EXE.@)
1760 VOID WINAPI
IoRegisterFileSystem(PDEVICE_OBJECT DeviceObject
)
1762 FIXME("(%p): stub\n", DeviceObject
);
1765 /***********************************************************************
1766 * IoUnregisterFileSystem (NTOSKRNL.EXE.@)
1768 VOID WINAPI
IoUnregisterFileSystem(PDEVICE_OBJECT DeviceObject
)
1770 FIXME("(%p): stub\n", DeviceObject
);
1773 /***********************************************************************
1774 * MmAllocateNonCachedMemory (NTOSKRNL.EXE.@)
1776 PVOID WINAPI
MmAllocateNonCachedMemory( SIZE_T size
)
1778 TRACE( "%lu\n", size
);
1779 return VirtualAlloc( NULL
, size
, MEM_RESERVE
|MEM_COMMIT
, PAGE_READWRITE
|PAGE_NOCACHE
);
1782 /***********************************************************************
1783 * MmAllocateContiguousMemory (NTOSKRNL.EXE.@)
1785 PVOID WINAPI
MmAllocateContiguousMemory( SIZE_T size
, PHYSICAL_ADDRESS highest_valid_address
)
1787 FIXME( "%lu, %s stub\n", size
, wine_dbgstr_longlong(highest_valid_address
.QuadPart
) );
1791 /***********************************************************************
1792 * MmAllocateContiguousMemorySpecifyCache (NTOSKRNL.EXE.@)
1794 PVOID WINAPI
MmAllocateContiguousMemorySpecifyCache( SIZE_T size
,
1795 PHYSICAL_ADDRESS lowest_valid_address
,
1796 PHYSICAL_ADDRESS highest_valid_address
,
1797 PHYSICAL_ADDRESS BoundaryAddressMultiple
,
1798 MEMORY_CACHING_TYPE CacheType
)
1804 /***********************************************************************
1805 * MmAllocatePagesForMdl (NTOSKRNL.EXE.@)
1807 PMDL WINAPI
MmAllocatePagesForMdl(PHYSICAL_ADDRESS lowaddress
, PHYSICAL_ADDRESS highaddress
,
1808 PHYSICAL_ADDRESS skipbytes
, SIZE_T size
)
1810 FIXME("%s %s %s %lu: stub\n", wine_dbgstr_longlong(lowaddress
.QuadPart
), wine_dbgstr_longlong(highaddress
.QuadPart
),
1811 wine_dbgstr_longlong(skipbytes
.QuadPart
), size
);
1815 /***********************************************************************
1816 * MmFreeNonCachedMemory (NTOSKRNL.EXE.@)
1818 void WINAPI
MmFreeNonCachedMemory( void *addr
, SIZE_T size
)
1820 TRACE( "%p %lu\n", addr
, size
);
1821 VirtualFree( addr
, 0, MEM_RELEASE
);
1824 /***********************************************************************
1825 * MmIsAddressValid (NTOSKRNL.EXE.@)
1827 * Check if the process can access the virtual address without a pagefault
1830 * VirtualAddress [I] Address to check
1834 * Success: TRUE (Accessing the Address works without a Pagefault)
1837 BOOLEAN WINAPI
MmIsAddressValid(PVOID VirtualAddress
)
1839 TRACE("(%p)\n", VirtualAddress
);
1840 return !IsBadWritePtr(VirtualAddress
, 1);
1843 /***********************************************************************
1844 * MmMapIoSpace (NTOSKRNL.EXE.@)
1846 PVOID WINAPI
MmMapIoSpace( PHYSICAL_ADDRESS PhysicalAddress
, DWORD NumberOfBytes
, DWORD CacheType
)
1848 FIXME( "stub: 0x%08x%08x, %d, %d\n", PhysicalAddress
.u
.HighPart
, PhysicalAddress
.u
.LowPart
, NumberOfBytes
, CacheType
);
1853 /***********************************************************************
1854 * MmLockPagableSectionByHandle (NTOSKRNL.EXE.@)
1856 VOID WINAPI
MmLockPagableSectionByHandle(PVOID ImageSectionHandle
)
1858 FIXME("stub %p\n", ImageSectionHandle
);
1861 /***********************************************************************
1862 * MmMapLockedPagesSpecifyCache (NTOSKRNL.EXE.@)
1864 PVOID WINAPI
MmMapLockedPagesSpecifyCache(PMDLX MemoryDescriptorList
, KPROCESSOR_MODE AccessMode
, MEMORY_CACHING_TYPE CacheType
,
1865 PVOID BaseAddress
, ULONG BugCheckOnFailure
, MM_PAGE_PRIORITY Priority
)
1867 FIXME("(%p, %u, %u, %p, %u, %u): stub\n", MemoryDescriptorList
, AccessMode
, CacheType
, BaseAddress
, BugCheckOnFailure
, Priority
);
1872 /***********************************************************************
1873 * MmUnlockPagableImageSection (NTOSKRNL.EXE.@)
1875 VOID WINAPI
MmUnlockPagableImageSection(PVOID ImageSectionHandle
)
1877 FIXME("stub %p\n", ImageSectionHandle
);
1880 /***********************************************************************
1881 * MmPageEntireDriver (NTOSKRNL.EXE.@)
1883 PVOID WINAPI
MmPageEntireDriver(PVOID AddrInSection
)
1885 TRACE("%p\n", AddrInSection
);
1886 return AddrInSection
;
1890 /***********************************************************************
1891 * MmProbeAndLockPages (NTOSKRNL.EXE.@)
1893 void WINAPI
MmProbeAndLockPages(PMDLX MemoryDescriptorList
, KPROCESSOR_MODE AccessMode
, LOCK_OPERATION Operation
)
1895 FIXME("(%p, %u, %u): stub\n", MemoryDescriptorList
, AccessMode
, Operation
);
1899 /***********************************************************************
1900 * MmResetDriverPaging (NTOSKRNL.EXE.@)
1902 void WINAPI
MmResetDriverPaging(PVOID AddrInSection
)
1904 TRACE("%p\n", AddrInSection
);
1908 /***********************************************************************
1909 * MmUnlockPages (NTOSKRNL.EXE.@)
1911 void WINAPI
MmUnlockPages(PMDLX MemoryDescriptorList
)
1913 FIXME("(%p): stub\n", MemoryDescriptorList
);
1917 /***********************************************************************
1918 * MmUnmapIoSpace (NTOSKRNL.EXE.@)
1920 VOID WINAPI
MmUnmapIoSpace( PVOID BaseAddress
, SIZE_T NumberOfBytes
)
1922 FIXME( "stub: %p, %lu\n", BaseAddress
, NumberOfBytes
);
1925 /***********************************************************************
1926 * ObfReferenceObject (NTOSKRNL.EXE.@)
1928 VOID WINAPI
ObfReferenceObject(PVOID Object
)
1930 FIXME("(%p): stub\n", Object
);
1933 /***********************************************************************
1934 * ObReferenceObjectByHandle (NTOSKRNL.EXE.@)
1936 NTSTATUS WINAPI
ObReferenceObjectByHandle( HANDLE obj
, ACCESS_MASK access
,
1938 KPROCESSOR_MODE mode
, PVOID
* ptr
,
1939 POBJECT_HANDLE_INFORMATION info
)
1941 FIXME( "stub: %p %x %p %d %p %p\n", obj
, access
, type
, mode
, ptr
, info
);
1942 return STATUS_NOT_IMPLEMENTED
;
1945 /***********************************************************************
1946 * ObReferenceObjectByName (NTOSKRNL.EXE.@)
1948 NTSTATUS WINAPI
ObReferenceObjectByName( UNICODE_STRING
*ObjectName
,
1950 ACCESS_STATE
*AccessState
,
1951 ACCESS_MASK DesiredAccess
,
1952 POBJECT_TYPE ObjectType
,
1953 KPROCESSOR_MODE AccessMode
,
1958 return STATUS_NOT_IMPLEMENTED
;
1961 /***********************************************************************
1962 * ObfDereferenceObject (NTOSKRNL.EXE.@)
1964 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1965 DEFINE_FASTCALL1_ENTRYPOINT( ObfDereferenceObject
)
1966 void WINAPI
__regs_ObfDereferenceObject( VOID
*obj
)
1968 void WINAPI
ObfDereferenceObject( VOID
*obj
)
1971 FIXME( "stub: %p\n", obj
);
1975 /***********************************************************************
1976 * PsCreateSystemThread (NTOSKRNL.EXE.@)
1978 NTSTATUS WINAPI
PsCreateSystemThread(PHANDLE ThreadHandle
, ULONG DesiredAccess
,
1979 POBJECT_ATTRIBUTES ObjectAttributes
,
1980 HANDLE ProcessHandle
, PCLIENT_ID ClientId
,
1981 PKSTART_ROUTINE StartRoutine
, PVOID StartContext
)
1983 if (!ProcessHandle
) ProcessHandle
= GetCurrentProcess();
1984 return RtlCreateUserThread(ProcessHandle
, 0, FALSE
, 0, 0,
1985 0, StartRoutine
, StartContext
,
1986 ThreadHandle
, ClientId
);
1989 /***********************************************************************
1990 * PsGetCurrentProcessId (NTOSKRNL.EXE.@)
1992 HANDLE WINAPI
PsGetCurrentProcessId(void)
1994 if (GetCurrentThreadId() == request_thread
)
1995 return UlongToHandle(client_pid
);
1996 return UlongToHandle(GetCurrentProcessId());
2000 /***********************************************************************
2001 * PsGetCurrentThreadId (NTOSKRNL.EXE.@)
2003 HANDLE WINAPI
PsGetCurrentThreadId(void)
2005 if (GetCurrentThreadId() == request_thread
)
2006 return UlongToHandle(client_tid
);
2007 return UlongToHandle(GetCurrentThreadId());
2011 /***********************************************************************
2012 * PsGetVersion (NTOSKRNL.EXE.@)
2014 BOOLEAN WINAPI
PsGetVersion(ULONG
*major
, ULONG
*minor
, ULONG
*build
, UNICODE_STRING
*version
)
2016 RTL_OSVERSIONINFOEXW info
;
2018 info
.dwOSVersionInfoSize
= sizeof(info
);
2019 RtlGetVersion( &info
);
2020 if (major
) *major
= info
.dwMajorVersion
;
2021 if (minor
) *minor
= info
.dwMinorVersion
;
2022 if (build
) *build
= info
.dwBuildNumber
;
2026 #if 0 /* FIXME: GameGuard passes an uninitialized pointer in version->Buffer */
2027 size_t len
= min( strlenW(info
.szCSDVersion
)*sizeof(WCHAR
), version
->MaximumLength
);
2028 memcpy( version
->Buffer
, info
.szCSDVersion
, len
);
2029 if (len
< version
->MaximumLength
) version
->Buffer
[len
/ sizeof(WCHAR
)] = 0;
2030 version
->Length
= len
;
2037 /***********************************************************************
2038 * PsImpersonateClient (NTOSKRNL.EXE.@)
2040 NTSTATUS WINAPI
PsImpersonateClient(PETHREAD Thread
, PACCESS_TOKEN Token
, BOOLEAN CopyOnOpen
,
2041 BOOLEAN EffectiveOnly
, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
2043 FIXME("(%p, %p, %u, %u, %u): stub\n", Thread
, Token
, CopyOnOpen
, EffectiveOnly
, ImpersonationLevel
);
2045 return STATUS_NOT_IMPLEMENTED
;
2049 /***********************************************************************
2050 * PsSetCreateProcessNotifyRoutine (NTOSKRNL.EXE.@)
2052 NTSTATUS WINAPI
PsSetCreateProcessNotifyRoutine( PCREATE_PROCESS_NOTIFY_ROUTINE callback
, BOOLEAN remove
)
2054 FIXME( "stub: %p %d\n", callback
, remove
);
2055 return STATUS_SUCCESS
;
2059 /***********************************************************************
2060 * PsSetCreateThreadNotifyRoutine (NTOSKRNL.EXE.@)
2062 NTSTATUS WINAPI
PsSetCreateThreadNotifyRoutine( PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine
)
2064 FIXME( "stub: %p\n", NotifyRoutine
);
2065 return STATUS_SUCCESS
;
2069 /***********************************************************************
2070 * PsRemoveCreateThreadNotifyRoutine (NTOSKRNL.EXE.@)
2072 NTSTATUS WINAPI
PsRemoveCreateThreadNotifyRoutine( PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine
)
2074 FIXME( "stub: %p\n", NotifyRoutine
);
2075 return STATUS_SUCCESS
;
2079 /***********************************************************************
2080 * PsTerminateSystemThread (NTOSKRNL.EXE.@)
2082 NTSTATUS WINAPI
PsTerminateSystemThread(NTSTATUS ExitStatus
)
2084 FIXME( "stub: %u\n", ExitStatus
);
2085 return STATUS_NOT_IMPLEMENTED
;
2089 /***********************************************************************
2090 * MmGetSystemRoutineAddress (NTOSKRNL.EXE.@)
2092 PVOID WINAPI
MmGetSystemRoutineAddress(PUNICODE_STRING SystemRoutineName
)
2095 STRING routineNameA
;
2098 static const WCHAR ntoskrnlW
[] = {'n','t','o','s','k','r','n','l','.','e','x','e',0};
2099 static const WCHAR halW
[] = {'h','a','l','.','d','l','l',0};
2101 if (!SystemRoutineName
) return NULL
;
2103 if (RtlUnicodeStringToAnsiString( &routineNameA
, SystemRoutineName
, TRUE
) == STATUS_SUCCESS
)
2105 /* We only support functions exported from ntoskrnl.exe or hal.dll */
2106 hMod
= GetModuleHandleW( ntoskrnlW
);
2107 pFunc
= GetProcAddress( hMod
, routineNameA
.Buffer
);
2110 hMod
= GetModuleHandleW( halW
);
2111 if (hMod
) pFunc
= GetProcAddress( hMod
, routineNameA
.Buffer
);
2113 RtlFreeAnsiString( &routineNameA
);
2117 TRACE( "%s -> %p\n", debugstr_us(SystemRoutineName
), pFunc
);
2119 FIXME( "%s not found\n", debugstr_us(SystemRoutineName
) );
2124 /***********************************************************************
2125 * MmQuerySystemSize (NTOSKRNL.EXE.@)
2127 MM_SYSTEMSIZE WINAPI
MmQuerySystemSize(void)
2130 return MmLargeSystem
;
2133 /***********************************************************************
2134 * KeInitializeDpc (NTOSKRNL.EXE.@)
2136 VOID WINAPI
KeInitializeDpc(PRKDPC Dpc
, PKDEFERRED_ROUTINE DeferredRoutine
, PVOID DeferredContext
)
2141 /***********************************************************************
2142 * READ_REGISTER_BUFFER_UCHAR (NTOSKRNL.EXE.@)
2144 VOID WINAPI
READ_REGISTER_BUFFER_UCHAR(PUCHAR Register
, PUCHAR Buffer
, ULONG Count
)
2149 /*****************************************************
2150 * PoSetPowerState (NTOSKRNL.EXE.@)
2152 POWER_STATE WINAPI
PoSetPowerState(PDEVICE_OBJECT DeviceObject
, POWER_STATE_TYPE Type
, POWER_STATE State
)
2154 FIXME("(%p %u %u) stub\n", DeviceObject
, Type
, State
.DeviceState
);
2158 /*****************************************************
2159 * IoWMIRegistrationControl (NTOSKRNL.EXE.@)
2161 NTSTATUS WINAPI
IoWMIRegistrationControl(PDEVICE_OBJECT DeviceObject
, ULONG Action
)
2163 FIXME("(%p %u) stub\n", DeviceObject
, Action
);
2164 return STATUS_SUCCESS
;
2167 /*****************************************************
2168 * PsSetLoadImageNotifyRoutine (NTOSKRNL.EXE.@)
2170 NTSTATUS WINAPI
PsSetLoadImageNotifyRoutine(PLOAD_IMAGE_NOTIFY_ROUTINE routine
)
2172 FIXME("(%p) stub\n", routine
);
2173 return STATUS_SUCCESS
;
2176 /*****************************************************
2177 * PsLookupProcessByProcessId (NTOSKRNL.EXE.@)
2179 NTSTATUS WINAPI
PsLookupProcessByProcessId(HANDLE processid
, PEPROCESS
*process
)
2182 if (!once
++) FIXME("(%p %p) stub\n", processid
, process
);
2183 return STATUS_NOT_IMPLEMENTED
;
2187 /*****************************************************
2188 * IoSetThreadHardErrorMode (NTOSKRNL.EXE.@)
2190 BOOLEAN WINAPI
IoSetThreadHardErrorMode(BOOLEAN EnableHardErrors
)
2197 /*****************************************************
2198 * IoInitializeRemoveLockEx (NTOSKRNL.EXE.@)
2200 VOID WINAPI
IoInitializeRemoveLockEx(PIO_REMOVE_LOCK lock
, ULONG tag
,
2201 ULONG maxmin
, ULONG high
, ULONG size
)
2203 FIXME("(%p %u %u %u %u) stub\n", lock
, tag
, maxmin
, high
, size
);
2207 /*****************************************************
2208 * IoAcquireRemoveLockEx (NTOSKRNL.EXE.@)
2211 NTSTATUS WINAPI
IoAcquireRemoveLockEx(PIO_REMOVE_LOCK lock
, PVOID tag
,
2212 LPCSTR file
, ULONG line
, ULONG lock_size
)
2214 FIXME("(%p, %p, %s, %u, %u): stub\n", lock
, tag
, debugstr_a(file
), line
, lock_size
);
2216 return STATUS_NOT_IMPLEMENTED
;
2220 /*****************************************************
2223 BOOL WINAPI
DllMain( HINSTANCE inst
, DWORD reason
, LPVOID reserved
)
2225 static void *handler
;
2226 LARGE_INTEGER count
;
2230 case DLL_PROCESS_ATTACH
:
2231 DisableThreadLibraryCalls( inst
);
2232 #if defined(__i386__) || defined(__x86_64__)
2233 handler
= RtlAddVectoredExceptionHandler( TRUE
, vectored_handler
);
2235 KeQueryTickCount( &count
); /* initialize the global KeTickCount */
2237 case DLL_PROCESS_DETACH
:
2238 if (reserved
) break;
2239 RtlRemoveVectoredExceptionHandler( handler
);
2245 /*****************************************************
2246 * Ke386IoSetAccessProcess (NTOSKRNL.EXE.@)
2248 BOOLEAN WINAPI
Ke386IoSetAccessProcess(PEPROCESS
*process
, ULONG flag
)
2250 FIXME("(%p %d) stub\n", process
, flag
);
2254 /*****************************************************
2255 * Ke386SetIoAccessMap (NTOSKRNL.EXE.@)
2257 BOOLEAN WINAPI
Ke386SetIoAccessMap(ULONG flag
, PVOID buffer
)
2259 FIXME("(%d %p) stub\n", flag
, buffer
);
2263 /*****************************************************
2264 * IoCreateSynchronizationEvent (NTOSKRNL.EXE.@)
2266 PKEVENT WINAPI
IoCreateSynchronizationEvent(PUNICODE_STRING name
, PHANDLE handle
)
2268 FIXME("(%p %p) stub\n", name
, handle
);
2272 /*****************************************************
2273 * IoStartNextPacket (NTOSKRNL.EXE.@)
2275 VOID WINAPI
IoStartNextPacket(PDEVICE_OBJECT deviceobject
, BOOLEAN cancelable
)
2277 FIXME("(%p %d) stub\n", deviceobject
, cancelable
);
2280 /*****************************************************
2281 * ObQueryNameString (NTOSKRNL.EXE.@)
2283 NTSTATUS WINAPI
ObQueryNameString(PVOID object
, POBJECT_NAME_INFORMATION name
, ULONG maxlength
, PULONG returnlength
)
2285 FIXME("(%p %p %u %p) stub\n", object
, name
, maxlength
, returnlength
);
2286 return STATUS_NOT_IMPLEMENTED
;
2289 /*****************************************************
2290 * IoRegisterPlugPlayNotification (NTOSKRNL.EXE.@)
2292 NTSTATUS WINAPI
IoRegisterPlugPlayNotification(IO_NOTIFICATION_EVENT_CATEGORY category
, ULONG flags
, PVOID data
,
2293 PDRIVER_OBJECT driver
, PDRIVER_NOTIFICATION_CALLBACK_ROUTINE callback
,
2294 PVOID context
, PVOID
*notification
)
2296 FIXME("(%u %u %p %p %p %p %p) stub\n", category
, flags
, data
, driver
, callback
, context
, notification
);
2297 return STATUS_SUCCESS
;
2300 /*****************************************************
2301 * IoCsqInitialize (NTOSKRNL.EXE.@)
2303 NTSTATUS WINAPI
IoCsqInitialize(PIO_CSQ csq
, PIO_CSQ_INSERT_IRP insert_irp
, PIO_CSQ_REMOVE_IRP remove_irp
,
2304 PIO_CSQ_PEEK_NEXT_IRP peek_irp
, PIO_CSQ_ACQUIRE_LOCK acquire_lock
,
2305 PIO_CSQ_RELEASE_LOCK release_lock
, PIO_CSQ_COMPLETE_CANCELED_IRP complete_irp
)
2307 FIXME("(%p %p %p %p %p %p %p) stub\n",
2308 csq
, insert_irp
, remove_irp
, peek_irp
, acquire_lock
, release_lock
, complete_irp
);
2309 return STATUS_SUCCESS
;
2312 /***********************************************************************
2313 * ExAcquireResourceExclusiveLite (NTOSKRNL.EXE.@)
2315 BOOLEAN WINAPI
ExAcquireResourceExclusiveLite( PERESOURCE resource
, BOOLEAN wait
)
2317 FIXME( ":%p %u stub\n", resource
, wait
);
2321 /***********************************************************************
2322 * ExDeleteResourceLite (NTOSKRNL.EXE.@)
2324 NTSTATUS WINAPI
ExDeleteResourceLite(PERESOURCE resource
)
2326 FIXME("(%p): stub\n", resource
);
2327 return STATUS_NOT_IMPLEMENTED
;
2330 /*****************************************************
2331 * ExInterlockedRemoveHeadList (NTOSKRNL.EXE.@)
2333 PLIST_ENTRY WINAPI
ExInterlockedRemoveHeadList(PLIST_ENTRY head
, PKSPIN_LOCK lock
)
2335 FIXME("(%p %p) stub\n", head
, lock
);
2339 /***********************************************************************
2340 * ExfInterlockedRemoveHeadList (NTOSKRNL.EXE.@)
2342 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
2343 DEFINE_FASTCALL2_ENTRYPOINT( ExfInterlockedRemoveHeadList
)
2344 PLIST_ENTRY WINAPI
__regs_ExfInterlockedRemoveHeadList(PLIST_ENTRY head
, PKSPIN_LOCK lock
)
2346 PLIST_ENTRY WINAPI
ExfInterlockedRemoveHeadList(PLIST_ENTRY head
, PKSPIN_LOCK lock
)
2349 FIXME("(%p %p) stub\n", head
, lock
);
2350 return ExInterlockedRemoveHeadList( head
, lock
);
2353 /***********************************************************************
2354 * ExReleaseResourceForThreadLite (NTOSKRNL.EXE.@)
2356 void WINAPI
ExReleaseResourceForThreadLite( PERESOURCE resource
, ERESOURCE_THREAD tid
)
2358 FIXME( "stub: %p %lu\n", resource
, tid
);
2361 /***********************************************************************
2362 * KeEnterCriticalRegion (NTOSKRNL.EXE.@)
2364 void WINAPI
KeEnterCriticalRegion(void)
2369 /***********************************************************************
2370 * KeLeaveCriticalRegion (NTOSKRNL.EXE.@)
2372 void WINAPI
KeLeaveCriticalRegion(void)
2377 /***********************************************************************
2378 * ProbeForRead (NTOSKRNL.EXE.@)
2380 void WINAPI
ProbeForRead(void *address
, SIZE_T length
, ULONG alignment
)
2382 FIXME("(%p %lu %u) stub\n", address
, length
, alignment
);
2385 /***********************************************************************
2386 * ProbeForWrite (NTOSKRNL.EXE.@)
2388 void WINAPI
ProbeForWrite(void *address
, SIZE_T length
, ULONG alignment
)
2390 FIXME("(%p %lu %u) stub\n", address
, length
, alignment
);
2393 /***********************************************************************
2394 * CmRegisterCallback (NTOSKRNL.EXE.@)
2396 NTSTATUS WINAPI
CmRegisterCallback(EX_CALLBACK_FUNCTION
*function
, void *context
, LARGE_INTEGER
*cookie
)
2398 FIXME("(%p %p %p): stub\n", function
, context
, cookie
);
2399 return STATUS_NOT_IMPLEMENTED
;
2402 /***********************************************************************
2403 * CmUnRegisterCallback (NTOSKRNL.EXE.@)
2405 NTSTATUS WINAPI
CmUnRegisterCallback(LARGE_INTEGER cookie
)
2407 FIXME("(%s): stub\n", wine_dbgstr_longlong(cookie
.QuadPart
));
2408 return STATUS_NOT_IMPLEMENTED
;