2 * ntoskrnl.exe implementation
4 * Copyright (C) 2007 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #include "wine/port.h"
26 #define NONAMELESSUNION
27 #define NONAMELESSSTRUCT
30 #define WIN32_NO_STATUS
34 #include "ddk/ntddk.h"
35 #include "wine/unicode.h"
36 #include "wine/server.h"
37 #include "wine/list.h"
38 #include "wine/debug.h"
40 WINE_DEFAULT_DEBUG_CHANNEL(ntoskrnl
);
41 WINE_DECLARE_DEBUG_CHANNEL(relay
);
44 KSYSTEM_TIME KeTickCount
= { 0, 0, 0 };
46 typedef struct _KSERVICE_TABLE_DESCRIPTOR
52 } KSERVICE_TABLE_DESCRIPTOR
, *PKSERVICE_TABLE_DESCRIPTOR
;
54 KSERVICE_TABLE_DESCRIPTOR KeServiceDescriptorTable
[4] = { { 0 } };
56 typedef void (WINAPI
*PCREATE_PROCESS_NOTIFY_ROUTINE
)(HANDLE
,HANDLE
,BOOLEAN
);
57 typedef void (WINAPI
*PCREATE_THREAD_NOTIFY_ROUTINE
)(HANDLE
,HANDLE
,BOOLEAN
);
59 static struct list Irps
= LIST_INIT(Irps
);
68 #define DEFINE_FASTCALL1_ENTRYPOINT( name ) \
69 __ASM_STDCALL_FUNC( name, 4, \
73 "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(4))
74 #define DEFINE_FASTCALL2_ENTRYPOINT( name ) \
75 __ASM_STDCALL_FUNC( name, 8, \
80 "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(8))
81 #define DEFINE_FASTCALL3_ENTRYPOINT( name ) \
82 __ASM_STDCALL_FUNC( name, 12, \
87 "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(12))
90 static inline LPCSTR
debugstr_us( const UNICODE_STRING
*us
)
92 if (!us
) return "<null>";
93 return debugstr_wn( us
->Buffer
, us
->Length
/ sizeof(WCHAR
) );
96 static HANDLE
get_device_manager(void)
98 static HANDLE device_manager
;
99 HANDLE handle
= 0, ret
= device_manager
;
103 SERVER_START_REQ( create_device_manager
)
105 req
->access
= SYNCHRONIZE
;
107 if (!wine_server_call( req
)) handle
= wine_server_ptr_handle( reply
->handle
);
113 ERR( "failed to create the device manager\n" );
116 if (!(ret
= InterlockedCompareExchangePointer( &device_manager
, handle
, 0 )))
119 NtClose( handle
); /* somebody beat us to it */
124 /* exception handler for emulation of privileged instructions */
125 static LONG CALLBACK
vectored_handler( EXCEPTION_POINTERS
*ptrs
)
127 EXCEPTION_RECORD
*record
= ptrs
->ExceptionRecord
;
129 if (record
->ExceptionCode
== EXCEPTION_ACCESS_VIOLATION
||
130 record
->ExceptionCode
== EXCEPTION_PRIV_INSTRUCTION
)
133 CONTEXT
*context
= ptrs
->ContextRecord
;
134 extern DWORD
__wine_emulate_instruction( EXCEPTION_RECORD
*rec
, CONTEXT
*context
);
136 if (__wine_emulate_instruction( record
, context
) == ExceptionContinueExecution
)
137 return EXCEPTION_CONTINUE_EXECUTION
;
139 FIXME( "Privileged instruction emulation not implemented on this CPU\n" );
142 return EXCEPTION_CONTINUE_SEARCH
;
145 /* process an ioctl request for a given device */
146 static NTSTATUS
process_ioctl( DEVICE_OBJECT
*device
, ULONG code
, void *in_buff
, ULONG in_size
,
147 void *out_buff
, ULONG
*out_size
)
151 IO_STACK_LOCATION irpsp
;
152 PDRIVER_DISPATCH dispatch
= device
->DriverObject
->MajorFunction
[IRP_MJ_DEVICE_CONTROL
];
156 TRACE( "ioctl %x device %p in_size %u out_size %u\n", code
, device
, in_size
, *out_size
);
158 /* so we can spot things that we should initialize */
159 memset( &irp
, 0x55, sizeof(irp
) );
160 memset( &irpsp
, 0x66, sizeof(irpsp
) );
161 memset( &mdl
, 0x77, sizeof(mdl
) );
163 irp
.RequestorMode
= UserMode
;
164 irp
.AssociatedIrp
.SystemBuffer
= in_buff
;
165 irp
.UserBuffer
= out_buff
;
166 irp
.MdlAddress
= &mdl
;
167 irp
.Tail
.Overlay
.s
.u
.CurrentStackLocation
= &irpsp
;
170 irpsp
.MajorFunction
= IRP_MJ_DEVICE_CONTROL
;
171 irpsp
.Parameters
.DeviceIoControl
.OutputBufferLength
= *out_size
;
172 irpsp
.Parameters
.DeviceIoControl
.InputBufferLength
= in_size
;
173 irpsp
.Parameters
.DeviceIoControl
.IoControlCode
= code
;
174 irpsp
.Parameters
.DeviceIoControl
.Type3InputBuffer
= in_buff
;
175 irpsp
.DeviceObject
= device
;
176 irpsp
.CompletionRoutine
= NULL
;
180 mdl
.StartVa
= out_buff
;
181 mdl
.ByteCount
= *out_size
;
184 device
->CurrentIrp
= &irp
;
186 KeQueryTickCount( &count
); /* update the global KeTickCount */
189 DPRINTF( "%04x:Call driver dispatch %p (device=%p,irp=%p)\n",
190 GetCurrentThreadId(), dispatch
, device
, &irp
);
192 status
= dispatch( device
, &irp
);
195 DPRINTF( "%04x:Ret driver dispatch %p (device=%p,irp=%p) retval=%08x\n",
196 GetCurrentThreadId(), dispatch
, device
, &irp
, status
);
198 *out_size
= (irp
.IoStatus
.u
.Status
>= 0) ? irp
.IoStatus
.Information
: 0;
199 return irp
.IoStatus
.u
.Status
;
203 /***********************************************************************
204 * wine_ntoskrnl_main_loop (Not a Windows API)
206 NTSTATUS CDECL
wine_ntoskrnl_main_loop( HANDLE stop_event
)
208 HANDLE manager
= get_device_manager();
209 obj_handle_t ioctl
= 0;
210 NTSTATUS status
= STATUS_SUCCESS
;
212 void *in_buff
, *out_buff
= NULL
;
213 DEVICE_OBJECT
*device
= NULL
;
214 ULONG in_size
= 4096, out_size
= 0;
217 if (!(in_buff
= HeapAlloc( GetProcessHeap(), 0, in_size
)))
219 ERR( "failed to allocate buffer\n" );
220 return STATUS_NO_MEMORY
;
223 handles
[0] = stop_event
;
224 handles
[1] = manager
;
228 SERVER_START_REQ( get_next_device_request
)
230 req
->manager
= wine_server_obj_handle( manager
);
232 req
->status
= status
;
233 wine_server_add_data( req
, out_buff
, out_size
);
234 wine_server_set_reply( req
, in_buff
, in_size
);
235 if (!(status
= wine_server_call( req
)))
239 device
= wine_server_get_ptr( reply
->user_ptr
);
240 in_size
= reply
->in_size
;
241 out_size
= reply
->out_size
;
245 ioctl
= 0; /* no previous ioctl */
247 in_size
= reply
->in_size
;
255 HeapFree( GetProcessHeap(), 0, out_buff
);
256 if (out_size
) out_buff
= HeapAlloc( GetProcessHeap(), 0, out_size
);
257 else out_buff
= NULL
;
258 status
= process_ioctl( device
, code
, in_buff
, in_size
, out_buff
, &out_size
);
260 case STATUS_BUFFER_OVERFLOW
:
261 HeapFree( GetProcessHeap(), 0, in_buff
);
262 in_buff
= HeapAlloc( GetProcessHeap(), 0, in_size
);
263 /* restart with larger buffer */
266 if (WaitForMultipleObjects( 2, handles
, FALSE
, INFINITE
) == WAIT_OBJECT_0
)
268 HeapFree( GetProcessHeap(), 0, in_buff
);
269 HeapFree( GetProcessHeap(), 0, out_buff
);
270 return STATUS_SUCCESS
;
278 /***********************************************************************
279 * IoAllocateDriverObjectExtension (NTOSKRNL.EXE.@)
281 NTSTATUS WINAPI
IoAllocateDriverObjectExtension( PDRIVER_OBJECT DriverObject
,
282 PVOID ClientIdentificationAddress
,
283 ULONG DriverObjectExtensionSize
,
284 PVOID
*DriverObjectExtension
)
286 FIXME( "stub: %p, %p, %u, %p\n", DriverObject
, ClientIdentificationAddress
,
287 DriverObjectExtensionSize
, DriverObjectExtension
);
288 return STATUS_NOT_IMPLEMENTED
;
292 /***********************************************************************
293 * IoGetDriverObjectExtension (NTOSKRNL.EXE.@)
295 PVOID WINAPI
IoGetDriverObjectExtension( PDRIVER_OBJECT DriverObject
,
296 PVOID ClientIdentificationAddress
)
298 FIXME( "stub: %p, %p\n", DriverObject
, ClientIdentificationAddress
);
303 /***********************************************************************
304 * IoInitializeIrp (NTOSKRNL.EXE.@)
306 void WINAPI
IoInitializeIrp( IRP
*irp
, USHORT size
, CCHAR stack_size
)
308 TRACE( "%p, %u, %d\n", irp
, size
, stack_size
);
310 RtlZeroMemory( irp
, size
);
312 irp
->Type
= IO_TYPE_IRP
;
314 InitializeListHead( &irp
->ThreadListEntry
);
315 irp
->StackCount
= stack_size
;
316 irp
->CurrentLocation
= stack_size
+ 1;
317 irp
->Tail
.Overlay
.s
.u
.CurrentStackLocation
=
318 (PIO_STACK_LOCATION
)(irp
+ 1) + stack_size
;
322 /***********************************************************************
323 * IoInitializeTimer (NTOSKRNL.EXE.@)
325 NTSTATUS WINAPI
IoInitializeTimer(PDEVICE_OBJECT DeviceObject
,
326 PIO_TIMER_ROUTINE TimerRoutine
,
329 FIXME( "stub: %p, %p, %p\n", DeviceObject
, TimerRoutine
, Context
);
330 return STATUS_NOT_IMPLEMENTED
;
334 /***********************************************************************
335 * IoStartTimer (NTOSKRNL.EXE.@)
337 void WINAPI
IoStartTimer(PDEVICE_OBJECT DeviceObject
)
339 FIXME( "stub: %p\n", DeviceObject
);
343 /***********************************************************************
344 * IoAllocateIrp (NTOSKRNL.EXE.@)
346 PIRP WINAPI
IoAllocateIrp( CCHAR stack_size
, BOOLEAN charge_quota
)
351 TRACE( "%d, %d\n", stack_size
, charge_quota
);
353 size
= sizeof(IRP
) + stack_size
* sizeof(IO_STACK_LOCATION
);
354 irp
= ExAllocatePool( NonPagedPool
, size
);
357 IoInitializeIrp( irp
, size
, stack_size
);
358 irp
->AllocationFlags
= IRP_ALLOCATED_FIXED_SIZE
;
360 irp
->AllocationFlags
|= IRP_LOOKASIDE_ALLOCATION
;
365 /***********************************************************************
366 * IoFreeIrp (NTOSKRNL.EXE.@)
368 void WINAPI
IoFreeIrp( IRP
*irp
)
370 TRACE( "%p\n", irp
);
376 /***********************************************************************
377 * IoAllocateMdl (NTOSKRNL.EXE.@)
379 PMDL WINAPI
IoAllocateMdl( PVOID VirtualAddress
, ULONG Length
, BOOLEAN SecondaryBuffer
, BOOLEAN ChargeQuota
, PIRP Irp
)
381 FIXME( "stub: %p, %u, %i, %i, %p\n", VirtualAddress
, Length
, SecondaryBuffer
, ChargeQuota
, Irp
);
386 /***********************************************************************
387 * IoAllocateWorkItem (NTOSKRNL.EXE.@)
389 PIO_WORKITEM WINAPI
IoAllocateWorkItem( PDEVICE_OBJECT DeviceObject
)
391 FIXME( "stub: %p\n", DeviceObject
);
396 /***********************************************************************
397 * IoAttachDeviceToDeviceStack (NTOSKRNL.EXE.@)
399 PDEVICE_OBJECT WINAPI
IoAttachDeviceToDeviceStack( DEVICE_OBJECT
*source
,
400 DEVICE_OBJECT
*target
)
402 TRACE( "%p, %p\n", source
, target
);
403 target
->AttachedDevice
= source
;
404 source
->StackSize
= target
->StackSize
+ 1;
409 /***********************************************************************
410 * IoBuildDeviceIoControlRequest (NTOSKRNL.EXE.@)
412 PIRP WINAPI
IoBuildDeviceIoControlRequest( ULONG IoControlCode
,
413 PDEVICE_OBJECT DeviceObject
,
415 ULONG InputBufferLength
,
417 ULONG OutputBufferLength
,
418 BOOLEAN InternalDeviceIoControl
,
420 PIO_STATUS_BLOCK IoStatusBlock
)
423 PIO_STACK_LOCATION irpsp
;
424 struct IrpInstance
*instance
;
426 TRACE( "%x, %p, %p, %u, %p, %u, %u, %p, %p\n",
427 IoControlCode
, DeviceObject
, InputBuffer
, InputBufferLength
,
428 OutputBuffer
, OutputBufferLength
, InternalDeviceIoControl
,
429 Event
, IoStatusBlock
);
431 if (DeviceObject
== NULL
)
434 irp
= IoAllocateIrp( DeviceObject
->StackSize
, FALSE
);
438 instance
= HeapAlloc( GetProcessHeap(), 0, sizeof(struct IrpInstance
) );
439 if (instance
== NULL
)
445 list_add_tail( &Irps
, &instance
->entry
);
447 irpsp
= irp
->Tail
.Overlay
.s
.u
.CurrentStackLocation
- 1;
448 irpsp
->MajorFunction
= InternalDeviceIoControl
?
449 IRP_MJ_INTERNAL_DEVICE_CONTROL
: IRP_MJ_DEVICE_CONTROL
;
450 irpsp
->Parameters
.DeviceIoControl
.IoControlCode
= IoControlCode
;
451 irp
->UserIosb
= IoStatusBlock
;
452 irp
->UserEvent
= Event
;
458 /***********************************************************************
459 * IoCreateDriver (NTOSKRNL.EXE.@)
461 NTSTATUS WINAPI
IoCreateDriver( UNICODE_STRING
*name
, PDRIVER_INITIALIZE init
)
463 DRIVER_OBJECT
*driver
;
464 DRIVER_EXTENSION
*extension
;
467 if (!(driver
= RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY
,
468 sizeof(*driver
) + sizeof(*extension
) )))
469 return STATUS_NO_MEMORY
;
471 if ((status
= RtlDuplicateUnicodeString( 1, name
, &driver
->DriverName
)))
473 RtlFreeHeap( GetProcessHeap(), 0, driver
);
477 extension
= (DRIVER_EXTENSION
*)(driver
+ 1);
478 driver
->Size
= sizeof(*driver
);
479 driver
->DriverInit
= init
;
480 driver
->DriverExtension
= extension
;
481 extension
->DriverObject
= driver
;
482 extension
->ServiceKeyName
= driver
->DriverName
;
484 status
= driver
->DriverInit( driver
, name
);
488 RtlFreeUnicodeString( &driver
->DriverName
);
489 RtlFreeHeap( GetProcessHeap(), 0, driver
);
495 /***********************************************************************
496 * IoDeleteDriver (NTOSKRNL.EXE.@)
498 void WINAPI
IoDeleteDriver( DRIVER_OBJECT
*driver
)
500 RtlFreeUnicodeString( &driver
->DriverName
);
501 RtlFreeHeap( GetProcessHeap(), 0, driver
);
505 /***********************************************************************
506 * IoCreateDevice (NTOSKRNL.EXE.@)
508 NTSTATUS WINAPI
IoCreateDevice( DRIVER_OBJECT
*driver
, ULONG ext_size
,
509 UNICODE_STRING
*name
, DEVICE_TYPE type
,
510 ULONG characteristics
, BOOLEAN exclusive
,
511 DEVICE_OBJECT
**ret_device
)
514 DEVICE_OBJECT
*device
;
516 HANDLE manager
= get_device_manager();
518 TRACE( "(%p, %u, %s, %u, %x, %u, %p)\n",
519 driver
, ext_size
, debugstr_us(name
), type
, characteristics
, exclusive
, ret_device
);
521 if (!(device
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*device
) + ext_size
)))
522 return STATUS_NO_MEMORY
;
524 SERVER_START_REQ( create_device
)
529 req
->manager
= wine_server_obj_handle( manager
);
530 req
->user_ptr
= wine_server_client_ptr( device
);
531 if (name
) wine_server_add_data( req
, name
->Buffer
, name
->Length
);
532 if (!(status
= wine_server_call( req
))) handle
= wine_server_ptr_handle( reply
->handle
);
536 if (status
== STATUS_SUCCESS
)
538 device
->DriverObject
= driver
;
539 device
->DeviceExtension
= device
+ 1;
540 device
->DeviceType
= type
;
541 device
->StackSize
= 1;
542 device
->Reserved
= handle
;
544 device
->NextDevice
= driver
->DeviceObject
;
545 driver
->DeviceObject
= device
;
547 *ret_device
= device
;
549 else HeapFree( GetProcessHeap(), 0, device
);
555 /***********************************************************************
556 * IoDeleteDevice (NTOSKRNL.EXE.@)
558 void WINAPI
IoDeleteDevice( DEVICE_OBJECT
*device
)
562 TRACE( "%p\n", device
);
564 SERVER_START_REQ( delete_device
)
566 req
->handle
= wine_server_obj_handle( device
->Reserved
);
567 status
= wine_server_call( req
);
571 if (status
== STATUS_SUCCESS
)
573 DEVICE_OBJECT
**prev
= &device
->DriverObject
->DeviceObject
;
574 while (*prev
&& *prev
!= device
) prev
= &(*prev
)->NextDevice
;
575 if (*prev
) *prev
= (*prev
)->NextDevice
;
576 NtClose( device
->Reserved
);
577 HeapFree( GetProcessHeap(), 0, device
);
582 /***********************************************************************
583 * IoCreateSymbolicLink (NTOSKRNL.EXE.@)
585 NTSTATUS WINAPI
IoCreateSymbolicLink( UNICODE_STRING
*name
, UNICODE_STRING
*target
)
588 OBJECT_ATTRIBUTES attr
;
590 attr
.Length
= sizeof(attr
);
591 attr
.RootDirectory
= 0;
592 attr
.ObjectName
= name
;
593 attr
.Attributes
= OBJ_CASE_INSENSITIVE
| OBJ_OPENIF
;
594 attr
.SecurityDescriptor
= NULL
;
595 attr
.SecurityQualityOfService
= NULL
;
597 TRACE( "%s -> %s\n", debugstr_us(name
), debugstr_us(target
) );
598 /* FIXME: store handle somewhere */
599 return NtCreateSymbolicLinkObject( &handle
, SYMBOLIC_LINK_ALL_ACCESS
, &attr
, target
);
603 /***********************************************************************
604 * IoDeleteSymbolicLink (NTOSKRNL.EXE.@)
606 NTSTATUS WINAPI
IoDeleteSymbolicLink( UNICODE_STRING
*name
)
609 OBJECT_ATTRIBUTES attr
;
612 attr
.Length
= sizeof(attr
);
613 attr
.RootDirectory
= 0;
614 attr
.ObjectName
= name
;
615 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
616 attr
.SecurityDescriptor
= NULL
;
617 attr
.SecurityQualityOfService
= NULL
;
619 if (!(status
= NtOpenSymbolicLinkObject( &handle
, 0, &attr
)))
621 SERVER_START_REQ( unlink_object
)
623 req
->handle
= wine_server_obj_handle( handle
);
624 status
= wine_server_call( req
);
633 /***********************************************************************
634 * IoGetDeviceObjectPointer (NTOSKRNL.EXE.@)
636 NTSTATUS WINAPI
IoGetDeviceObjectPointer( UNICODE_STRING
*name
, ACCESS_MASK access
, PFILE_OBJECT
*file
, PDEVICE_OBJECT
*device
)
638 FIXME( "stub: %s %x %p %p\n", debugstr_us(name
), access
, file
, device
);
639 return STATUS_NOT_IMPLEMENTED
;
643 /***********************************************************************
644 * IofCallDriver (NTOSKRNL.EXE.@)
646 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
647 DEFINE_FASTCALL2_ENTRYPOINT( IofCallDriver
)
648 NTSTATUS WINAPI
__regs_IofCallDriver( DEVICE_OBJECT
*device
, IRP
*irp
)
650 NTSTATUS WINAPI
IofCallDriver( DEVICE_OBJECT
*device
, IRP
*irp
)
653 PDRIVER_DISPATCH dispatch
;
654 IO_STACK_LOCATION
*irpsp
;
657 TRACE( "%p %p\n", device
, irp
);
659 --irp
->CurrentLocation
;
660 irpsp
= --irp
->Tail
.Overlay
.s
.u
.CurrentStackLocation
;
661 dispatch
= device
->DriverObject
->MajorFunction
[irpsp
->MajorFunction
];
662 status
= dispatch( device
, irp
);
668 /***********************************************************************
669 * IoGetRelatedDeviceObject (NTOSKRNL.EXE.@)
671 PDEVICE_OBJECT WINAPI
IoGetRelatedDeviceObject( PFILE_OBJECT obj
)
673 FIXME( "stub: %p\n", obj
);
677 static CONFIGURATION_INFORMATION configuration_information
;
679 /***********************************************************************
680 * IoGetConfigurationInformation (NTOSKRNL.EXE.@)
682 PCONFIGURATION_INFORMATION WINAPI
IoGetConfigurationInformation(void)
684 FIXME( "partial stub\n" );
685 /* FIXME: return actual devices on system */
686 return &configuration_information
;
690 /***********************************************************************
691 * IoRegisterDriverReinitialization (NTOSKRNL.EXE.@)
693 void WINAPI
IoRegisterDriverReinitialization( PDRIVER_OBJECT obj
, PDRIVER_REINITIALIZE reinit
, PVOID context
)
695 FIXME( "stub: %p %p %p\n", obj
, reinit
, context
);
699 /***********************************************************************
700 * IoRegisterShutdownNotification (NTOSKRNL.EXE.@)
702 NTSTATUS WINAPI
IoRegisterShutdownNotification( PDEVICE_OBJECT obj
)
704 FIXME( "stub: %p\n", obj
);
705 return STATUS_SUCCESS
;
709 /***********************************************************************
710 * IofCompleteRequest (NTOSKRNL.EXE.@)
712 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
713 DEFINE_FASTCALL2_ENTRYPOINT( IofCompleteRequest
)
714 void WINAPI
__regs_IofCompleteRequest( IRP
*irp
, UCHAR priority_boost
)
716 void WINAPI
IofCompleteRequest( IRP
*irp
, UCHAR priority_boost
)
719 IO_STACK_LOCATION
*irpsp
;
720 PIO_COMPLETION_ROUTINE routine
;
721 IO_STATUS_BLOCK
*iosb
;
722 struct IrpInstance
*instance
;
723 NTSTATUS status
, stat
;
726 TRACE( "%p %u\n", irp
, priority_boost
);
728 iosb
= irp
->UserIosb
;
729 status
= irp
->IoStatus
.u
.Status
;
730 while (irp
->CurrentLocation
<= irp
->StackCount
)
732 irpsp
= irp
->Tail
.Overlay
.s
.u
.CurrentStackLocation
;
733 routine
= irpsp
->CompletionRoutine
;
735 /* FIXME: add SL_INVOKE_ON_CANCEL support */
738 if ((irpsp
->Control
& SL_INVOKE_ON_SUCCESS
) && STATUS_SUCCESS
== status
)
740 if ((irpsp
->Control
& SL_INVOKE_ON_ERROR
) && STATUS_SUCCESS
!= status
)
743 ++irp
->CurrentLocation
;
744 ++irp
->Tail
.Overlay
.s
.u
.CurrentStackLocation
;
747 TRACE( "calling %p( %p, %p, %p )\n", routine
,
748 irpsp
->DeviceObject
, irp
, irpsp
->Context
);
749 stat
= routine( irpsp
->DeviceObject
, irp
, irpsp
->Context
);
750 TRACE( "CompletionRoutine returned %x\n", stat
);
751 if (STATUS_MORE_PROCESSING_REQUIRED
== stat
)
755 if (iosb
&& STATUS_SUCCESS
== status
)
757 iosb
->u
.Status
= irp
->IoStatus
.u
.Status
;
758 iosb
->Information
= irp
->IoStatus
.Information
;
760 LIST_FOR_EACH_ENTRY( instance
, &Irps
, struct IrpInstance
, entry
)
762 if (instance
->irp
== irp
)
764 list_remove( &instance
->entry
);
765 HeapFree( GetProcessHeap(), 0, instance
);
773 /***********************************************************************
774 * InterlockedCompareExchange (NTOSKRNL.EXE.@)
776 #ifdef DEFINE_FASTCALL3_ENTRYPOINT
777 DEFINE_FASTCALL3_ENTRYPOINT( NTOSKRNL_InterlockedCompareExchange
)
778 LONG WINAPI
__regs_NTOSKRNL_InterlockedCompareExchange( LONG
volatile *dest
, LONG xchg
, LONG compare
)
780 LONG WINAPI
NTOSKRNL_InterlockedCompareExchange( LONG
volatile *dest
, LONG xchg
, LONG compare
)
783 return InterlockedCompareExchange( dest
, xchg
, compare
);
787 /***********************************************************************
788 * InterlockedDecrement (NTOSKRNL.EXE.@)
790 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
791 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedDecrement
)
792 LONG WINAPI
__regs_NTOSKRNL_InterlockedDecrement( LONG
volatile *dest
)
794 LONG WINAPI
NTOSKRNL_InterlockedDecrement( LONG
volatile *dest
)
797 return InterlockedDecrement( dest
);
801 /***********************************************************************
802 * InterlockedExchange (NTOSKRNL.EXE.@)
804 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
805 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchange
)
806 LONG WINAPI
__regs_NTOSKRNL_InterlockedExchange( LONG
volatile *dest
, LONG val
)
808 LONG WINAPI
NTOSKRNL_InterlockedExchange( LONG
volatile *dest
, LONG val
)
811 return InterlockedExchange( dest
, val
);
815 /***********************************************************************
816 * InterlockedExchangeAdd (NTOSKRNL.EXE.@)
818 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
819 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchangeAdd
)
820 LONG WINAPI
__regs_NTOSKRNL_InterlockedExchangeAdd( LONG
volatile *dest
, LONG incr
)
822 LONG WINAPI
NTOSKRNL_InterlockedExchangeAdd( LONG
volatile *dest
, LONG incr
)
825 return InterlockedExchangeAdd( dest
, incr
);
829 /***********************************************************************
830 * InterlockedIncrement (NTOSKRNL.EXE.@)
832 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
833 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedIncrement
)
834 LONG WINAPI
__regs_NTOSKRNL_InterlockedIncrement( LONG
volatile *dest
)
836 LONG WINAPI
NTOSKRNL_InterlockedIncrement( LONG
volatile *dest
)
839 return InterlockedIncrement( dest
);
843 /***********************************************************************
844 * ExAllocatePool (NTOSKRNL.EXE.@)
846 PVOID WINAPI
ExAllocatePool( POOL_TYPE type
, SIZE_T size
)
848 return ExAllocatePoolWithTag( type
, size
, 0 );
852 /***********************************************************************
853 * ExAllocatePoolWithQuota (NTOSKRNL.EXE.@)
855 PVOID WINAPI
ExAllocatePoolWithQuota( POOL_TYPE type
, SIZE_T size
)
857 return ExAllocatePoolWithTag( type
, size
, 0 );
861 /***********************************************************************
862 * ExAllocatePoolWithTag (NTOSKRNL.EXE.@)
864 PVOID WINAPI
ExAllocatePoolWithTag( POOL_TYPE type
, SIZE_T size
, ULONG tag
)
866 /* FIXME: handle page alignment constraints */
867 void *ret
= HeapAlloc( GetProcessHeap(), 0, size
);
868 TRACE( "%lu pool %u -> %p\n", size
, type
, ret
);
873 /***********************************************************************
874 * ExAllocatePoolWithQuotaTag (NTOSKRNL.EXE.@)
876 PVOID WINAPI
ExAllocatePoolWithQuotaTag( POOL_TYPE type
, SIZE_T size
, ULONG tag
)
878 return ExAllocatePoolWithTag( type
, size
, tag
);
882 /***********************************************************************
883 * ExFreePool (NTOSKRNL.EXE.@)
885 void WINAPI
ExFreePool( void *ptr
)
887 ExFreePoolWithTag( ptr
, 0 );
891 /***********************************************************************
892 * ExFreePoolWithTag (NTOSKRNL.EXE.@)
894 void WINAPI
ExFreePoolWithTag( void *ptr
, ULONG tag
)
896 TRACE( "%p\n", ptr
);
897 HeapFree( GetProcessHeap(), 0, ptr
);
901 /***********************************************************************
902 * ExInitializeResourceLite (NTOSKRNL.EXE.@)
904 NTSTATUS WINAPI
ExInitializeResourceLite(PERESOURCE Resource
)
906 FIXME( "stub: %p\n", Resource
);
907 return STATUS_NOT_IMPLEMENTED
;
911 /***********************************************************************
912 * ExInitializeZone (NTOSKRNL.EXE.@)
914 NTSTATUS WINAPI
ExInitializeZone(PZONE_HEADER Zone
,
916 PVOID InitialSegment
,
917 ULONG InitialSegmentSize
)
919 FIXME( "stub: %p, %u, %p, %u\n", Zone
, BlockSize
, InitialSegment
, InitialSegmentSize
);
920 return STATUS_NOT_IMPLEMENTED
;
924 /***********************************************************************
925 * KeInitializeEvent (NTOSKRNL.EXE.@)
927 void WINAPI
KeInitializeEvent( PRKEVENT Event
, EVENT_TYPE Type
, BOOLEAN State
)
929 FIXME( "stub: %p %d %d\n", Event
, Type
, State
);
933 /***********************************************************************
934 * KeInitializeMutex (NTOSKRNL.EXE.@)
936 void WINAPI
KeInitializeMutex(PRKMUTEX Mutex
, ULONG Level
)
938 FIXME( "stub: %p, %u\n", Mutex
, Level
);
942 /***********************************************************************
943 * KeInitializeSpinLock (NTOSKRNL.EXE.@)
945 void WINAPI
KeInitializeSpinLock( PKSPIN_LOCK SpinLock
)
947 FIXME( "stub: %p\n", SpinLock
);
951 /***********************************************************************
952 * KeInitializeTimerEx (NTOSKRNL.EXE.@)
954 void WINAPI
KeInitializeTimerEx( PKTIMER Timer
, TIMER_TYPE Type
)
956 FIXME( "stub: %p %d\n", Timer
, Type
);
960 /***********************************************************************
961 * KeInitializeTimer (NTOSKRNL.EXE.@)
963 void WINAPI
KeInitializeTimer( PKTIMER Timer
)
965 KeInitializeTimerEx(Timer
, NotificationTimer
);
969 /**********************************************************************
970 * KeQueryActiveProcessors (NTOSKRNL.EXE.@)
972 * Return the active Processors as bitmask
975 * active Processors as bitmask
978 KAFFINITY WINAPI
KeQueryActiveProcessors( void )
980 DWORD_PTR AffinityMask
;
982 GetProcessAffinityMask( GetCurrentProcess(), &AffinityMask
, NULL
);
987 /**********************************************************************
988 * KeQueryInterruptTime (NTOSKRNL.EXE.@)
990 * Return the interrupt time count
993 ULONGLONG WINAPI
KeQueryInterruptTime( void )
995 LARGE_INTEGER totaltime
;
997 KeQueryTickCount(&totaltime
);
998 return totaltime
.QuadPart
;
1002 /***********************************************************************
1003 * KeQuerySystemTime (NTOSKRNL.EXE.@)
1005 void WINAPI
KeQuerySystemTime( LARGE_INTEGER
*time
)
1007 NtQuerySystemTime( time
);
1011 /***********************************************************************
1012 * KeQueryTickCount (NTOSKRNL.EXE.@)
1014 void WINAPI
KeQueryTickCount( LARGE_INTEGER
*count
)
1016 count
->QuadPart
= NtGetTickCount();
1017 /* update the global variable too */
1018 KeTickCount
.LowPart
= count
->u
.LowPart
;
1019 KeTickCount
.High1Time
= count
->u
.HighPart
;
1020 KeTickCount
.High2Time
= count
->u
.HighPart
;
1024 /***********************************************************************
1025 * KeQueryTimeIncrement (NTOSKRNL.EXE.@)
1027 ULONG WINAPI
KeQueryTimeIncrement(void)
1033 /***********************************************************************
1034 * KeWaitForSingleObject (NTOSKRNL.EXE.@)
1036 NTSTATUS WINAPI
KeWaitForSingleObject(PVOID Object
,
1037 KWAIT_REASON WaitReason
,
1038 KPROCESSOR_MODE WaitMode
,
1040 PLARGE_INTEGER Timeout
)
1042 FIXME( "stub: %p, %d, %d, %d, %p\n", Object
, WaitReason
, WaitMode
, Alertable
, Timeout
);
1043 return STATUS_NOT_IMPLEMENTED
;
1047 /***********************************************************************
1048 * MmAllocateNonCachedMemory (NTOSKRNL.EXE.@)
1050 PVOID WINAPI
MmAllocateNonCachedMemory( SIZE_T size
)
1052 TRACE( "%lu\n", size
);
1053 return VirtualAlloc( NULL
, size
, MEM_RESERVE
|MEM_COMMIT
, PAGE_READWRITE
|PAGE_NOCACHE
);
1057 /***********************************************************************
1058 * MmFreeNonCachedMemory (NTOSKRNL.EXE.@)
1060 void WINAPI
MmFreeNonCachedMemory( void *addr
, SIZE_T size
)
1062 TRACE( "%p %lu\n", addr
, size
);
1063 VirtualFree( addr
, 0, MEM_RELEASE
);
1066 /***********************************************************************
1067 * MmIsAddressValid (NTOSKRNL.EXE.@)
1069 * Check if the process can access the virtual address without a pagefault
1072 * VirtualAddress [I] Address to check
1076 * Success: TRUE (Accessing the Address works without a Pagefault)
1079 BOOLEAN WINAPI
MmIsAddressValid(PVOID VirtualAddress
)
1081 TRACE("(%p)\n", VirtualAddress
);
1082 return !IsBadWritePtr(VirtualAddress
, 1);
1085 /***********************************************************************
1086 * MmPageEntireDriver (NTOSKRNL.EXE.@)
1088 PVOID WINAPI
MmPageEntireDriver(PVOID AddrInSection
)
1090 TRACE("%p\n", AddrInSection
);
1091 return AddrInSection
;
1094 /***********************************************************************
1095 * MmResetDriverPaging (NTOSKRNL.EXE.@)
1097 void WINAPI
MmResetDriverPaging(PVOID AddrInSection
)
1099 TRACE("%p\n", AddrInSection
);
1103 /***********************************************************************
1104 * ObReferenceObjectByHandle (NTOSKRNL.EXE.@)
1106 NTSTATUS WINAPI
ObReferenceObjectByHandle( HANDLE obj
, ACCESS_MASK access
,
1108 KPROCESSOR_MODE mode
, PVOID
* ptr
,
1109 POBJECT_HANDLE_INFORMATION info
)
1111 FIXME( "stub: %p %x %p %d %p %p\n", obj
, access
, type
, mode
, ptr
, info
);
1112 return STATUS_NOT_IMPLEMENTED
;
1116 /***********************************************************************
1117 * ObfDereferenceObject (NTOSKRNL.EXE.@)
1119 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1120 DEFINE_FASTCALL1_ENTRYPOINT( ObfDereferenceObject
)
1121 void WINAPI
__regs_ObfDereferenceObject( VOID
*obj
)
1123 void WINAPI
ObfDereferenceObject( VOID
*obj
)
1126 FIXME( "stub: %p\n", obj
);
1130 /***********************************************************************
1131 * PsCreateSystemThread (NTOSKRNL.EXE.@)
1133 NTSTATUS WINAPI
PsCreateSystemThread(PHANDLE ThreadHandle
, ULONG DesiredAccess
,
1134 POBJECT_ATTRIBUTES ObjectAttributes
,
1135 HANDLE ProcessHandle
, PCLIENT_ID ClientId
,
1136 PKSTART_ROUTINE StartRoutine
, PVOID StartContext
)
1138 if (!ProcessHandle
) ProcessHandle
= GetCurrentProcess();
1139 return RtlCreateUserThread(ProcessHandle
, 0, FALSE
, 0, 0,
1140 0, StartRoutine
, StartContext
,
1141 ThreadHandle
, ClientId
);
1144 /***********************************************************************
1145 * PsGetCurrentProcessId (NTOSKRNL.EXE.@)
1147 HANDLE WINAPI
PsGetCurrentProcessId(void)
1149 return UlongToHandle(GetCurrentProcessId()); /* FIXME: not quite right... */
1153 /***********************************************************************
1154 * PsGetCurrentThreadId (NTOSKRNL.EXE.@)
1156 HANDLE WINAPI
PsGetCurrentThreadId(void)
1158 return UlongToHandle(GetCurrentThreadId()); /* FIXME: not quite right... */
1162 /***********************************************************************
1163 * PsGetVersion (NTOSKRNL.EXE.@)
1165 BOOLEAN WINAPI
PsGetVersion(ULONG
*major
, ULONG
*minor
, ULONG
*build
, UNICODE_STRING
*version
)
1167 RTL_OSVERSIONINFOEXW info
;
1169 RtlGetVersion( &info
);
1170 if (major
) *major
= info
.dwMajorVersion
;
1171 if (minor
) *minor
= info
.dwMinorVersion
;
1172 if (build
) *build
= info
.dwBuildNumber
;
1176 #if 0 /* FIXME: GameGuard passes an uninitialized pointer in version->Buffer */
1177 size_t len
= min( strlenW(info
.szCSDVersion
)*sizeof(WCHAR
), version
->MaximumLength
);
1178 memcpy( version
->Buffer
, info
.szCSDVersion
, len
);
1179 if (len
< version
->MaximumLength
) version
->Buffer
[len
/ sizeof(WCHAR
)] = 0;
1180 version
->Length
= len
;
1187 /***********************************************************************
1188 * PsSetCreateProcessNotifyRoutine (NTOSKRNL.EXE.@)
1190 NTSTATUS WINAPI
PsSetCreateProcessNotifyRoutine( PCREATE_PROCESS_NOTIFY_ROUTINE callback
, BOOLEAN remove
)
1192 FIXME( "stub: %p %d\n", callback
, remove
);
1193 return STATUS_SUCCESS
;
1197 /***********************************************************************
1198 * PsSetCreateThreadNotifyRoutine (NTOSKRNL.EXE.@)
1200 NTSTATUS WINAPI
PsSetCreateThreadNotifyRoutine( PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine
)
1202 FIXME( "stub: %p\n", NotifyRoutine
);
1203 return STATUS_SUCCESS
;
1207 /***********************************************************************
1208 * PsTerminateSystemThread (NTOSKRNL.EXE.@)
1210 NTSTATUS WINAPI
PsTerminateSystemThread(NTSTATUS ExitStatus
)
1212 FIXME( "stub: %u\n", ExitStatus
);
1213 return STATUS_NOT_IMPLEMENTED
;
1217 /***********************************************************************
1218 * MmGetSystemRoutineAddress (NTOSKRNL.EXE.@)
1220 PVOID WINAPI
MmGetSystemRoutineAddress(PUNICODE_STRING SystemRoutineName
)
1223 STRING routineNameA
;
1226 static const WCHAR ntoskrnlW
[] = {'n','t','o','s','k','r','n','l','.','e','x','e',0};
1227 static const WCHAR halW
[] = {'h','a','l','.','d','l','l',0};
1229 if (!SystemRoutineName
) return NULL
;
1231 if (RtlUnicodeStringToAnsiString( &routineNameA
, SystemRoutineName
, TRUE
) == STATUS_SUCCESS
)
1233 /* We only support functions exported from ntoskrnl.exe or hal.dll */
1234 hMod
= GetModuleHandleW( ntoskrnlW
);
1235 pFunc
= GetProcAddress( hMod
, routineNameA
.Buffer
);
1238 hMod
= GetModuleHandleW( halW
);
1239 if (hMod
) pFunc
= GetProcAddress( hMod
, routineNameA
.Buffer
);
1241 RtlFreeAnsiString( &routineNameA
);
1244 TRACE( "%s -> %p\n", debugstr_us(SystemRoutineName
), pFunc
);
1249 /***********************************************************************
1250 * MmQuerySystemSize (NTOSKRNL.EXE.@)
1252 MM_SYSTEMSIZE WINAPI
MmQuerySystemSize(void)
1255 return MmLargeSystem
;
1259 /*****************************************************
1262 BOOL WINAPI
DllMain( HINSTANCE inst
, DWORD reason
, LPVOID reserved
)
1264 static void *handler
;
1265 LARGE_INTEGER count
;
1269 case DLL_PROCESS_ATTACH
:
1270 DisableThreadLibraryCalls( inst
);
1271 handler
= RtlAddVectoredExceptionHandler( TRUE
, vectored_handler
);
1272 KeQueryTickCount( &count
); /* initialize the global KeTickCount */
1274 case DLL_PROCESS_DETACH
:
1275 RtlRemoveVectoredExceptionHandler( handler
);