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"
39 #include "wine/unicode.h"
40 #include "wine/server.h"
41 #include "wine/list.h"
42 #include "wine/debug.h"
44 WINE_DEFAULT_DEBUG_CHANNEL(ntoskrnl
);
45 WINE_DECLARE_DEBUG_CHANNEL(relay
);
47 BOOLEAN KdDebuggerEnabled
= FALSE
;
48 ULONG InitSafeBootMode
= 0;
50 extern LONG CALLBACK
vectored_handler( EXCEPTION_POINTERS
*ptrs
);
52 KSYSTEM_TIME KeTickCount
= { 0, 0, 0 };
54 typedef struct _KSERVICE_TABLE_DESCRIPTOR
60 } KSERVICE_TABLE_DESCRIPTOR
, *PKSERVICE_TABLE_DESCRIPTOR
;
62 KSERVICE_TABLE_DESCRIPTOR KeServiceDescriptorTable
[4] = { { 0 } };
64 typedef void (WINAPI
*PCREATE_PROCESS_NOTIFY_ROUTINE
)(HANDLE
,HANDLE
,BOOLEAN
);
65 typedef void (WINAPI
*PCREATE_THREAD_NOTIFY_ROUTINE
)(HANDLE
,HANDLE
,BOOLEAN
);
67 /* tid of the thread running client request */
68 static DWORD request_thread
;
70 /* pid/tid of the client thread */
71 static DWORD client_tid
;
72 static DWORD client_pid
;
75 #define DEFINE_FASTCALL1_ENTRYPOINT( name ) \
76 __ASM_STDCALL_FUNC( name, 4, \
80 "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(4))
81 #define DEFINE_FASTCALL2_ENTRYPOINT( name ) \
82 __ASM_STDCALL_FUNC( name, 8, \
87 "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(8))
88 #define DEFINE_FASTCALL3_ENTRYPOINT( name ) \
89 __ASM_STDCALL_FUNC( name, 12, \
94 "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(12))
97 static inline LPCSTR
debugstr_us( const UNICODE_STRING
*us
)
99 if (!us
) return "<null>";
100 return debugstr_wn( us
->Buffer
, us
->Length
/ sizeof(WCHAR
) );
103 static HANDLE
get_device_manager(void)
105 static HANDLE device_manager
;
106 HANDLE handle
= 0, ret
= device_manager
;
110 SERVER_START_REQ( create_device_manager
)
112 req
->access
= SYNCHRONIZE
;
114 if (!wine_server_call( req
)) handle
= wine_server_ptr_handle( reply
->handle
);
120 ERR( "failed to create the device manager\n" );
123 if (!(ret
= InterlockedCompareExchangePointer( &device_manager
, handle
, 0 )))
126 NtClose( handle
); /* somebody beat us to it */
131 /* process an ioctl request for a given device */
132 static NTSTATUS
process_ioctl( DEVICE_OBJECT
*device
, ULONG code
, void *in_buff
,
133 ULONG in_size
, ULONG out_size
, HANDLE ioctl
)
136 void *out_buff
= NULL
;
140 TRACE( "ioctl %x device %p in_size %u out_size %u\n", code
, device
, in_size
, out_size
);
142 /* so we can spot things that we should initialize */
143 memset( &file
, 0x88, sizeof(file
) );
145 if ((code
& 3) == METHOD_BUFFERED
) out_size
= max( in_size
, out_size
);
149 if (!(out_buff
= HeapAlloc( GetProcessHeap(), 0, out_size
))) return STATUS_NO_MEMORY
;
150 if ((code
& 3) == METHOD_BUFFERED
)
152 memcpy( out_buff
, in_buff
, in_size
);
157 /* note: we abuse UserIosb to store the server handle to the ioctl */
158 irp
= IoBuildDeviceIoControlRequest( code
, device
, in_buff
, in_size
, out_buff
, out_size
,
159 FALSE
, NULL
, (IO_STATUS_BLOCK
*)ioctl
);
162 HeapFree( GetProcessHeap(), 0, out_buff
);
163 return STATUS_NO_MEMORY
;
165 irp
->RequestorMode
= UserMode
;
166 irp
->Tail
.Overlay
.OriginalFileObject
= &file
;
168 file
.FsContext
= NULL
;
169 file
.FsContext2
= NULL
;
171 KeQueryTickCount( &count
); /* update the global KeTickCount */
173 device
->CurrentIrp
= irp
;
175 IoCallDriver( device
, irp
);
177 device
->CurrentIrp
= NULL
;
179 return STATUS_SUCCESS
;
183 /***********************************************************************
184 * wine_ntoskrnl_main_loop (Not a Windows API)
186 NTSTATUS CDECL
wine_ntoskrnl_main_loop( HANDLE stop_event
)
188 HANDLE manager
= get_device_manager();
190 NTSTATUS status
= STATUS_SUCCESS
;
191 irp_params_t irp_params
;
193 DEVICE_OBJECT
*device
= NULL
;
194 ULONG in_size
= 4096, out_size
= 0;
197 request_thread
= GetCurrentThreadId();
199 if (!(in_buff
= HeapAlloc( GetProcessHeap(), 0, in_size
)))
201 ERR( "failed to allocate buffer\n" );
202 return STATUS_NO_MEMORY
;
205 handles
[0] = stop_event
;
206 handles
[1] = manager
;
210 SERVER_START_REQ( get_next_device_request
)
212 req
->manager
= wine_server_obj_handle( manager
);
213 req
->prev
= wine_server_obj_handle( irp
);
214 req
->status
= status
;
215 wine_server_set_reply( req
, in_buff
, in_size
);
216 if (!(status
= wine_server_call( req
)))
218 irp
= wine_server_ptr_handle( reply
->next
);
219 device
= wine_server_get_ptr( reply
->user_ptr
);
220 irp_params
= reply
->params
;
221 client_tid
= reply
->client_tid
;
222 client_pid
= reply
->client_pid
;
223 in_size
= reply
->in_size
;
224 out_size
= reply
->out_size
;
228 irp
= 0; /* no previous irp */
230 in_size
= reply
->in_size
;
238 switch (irp_params
.major
)
240 case IRP_MJ_DEVICE_CONTROL
:
241 status
= process_ioctl( device
, irp_params
.ioctl
.code
, in_buff
, in_size
, out_size
, irp
);
244 FIXME( "unsupported request %u\n", irp_params
.major
);
245 status
= STATUS_NOT_SUPPORTED
;
248 if (status
== STATUS_SUCCESS
) irp
= 0; /* status reported by IoCompleteRequest */
250 case STATUS_BUFFER_OVERFLOW
:
251 HeapFree( GetProcessHeap(), 0, in_buff
);
252 in_buff
= HeapAlloc( GetProcessHeap(), 0, in_size
);
253 /* restart with larger buffer */
258 DWORD ret
= WaitForMultipleObjectsEx( 2, handles
, FALSE
, INFINITE
, TRUE
);
259 if (ret
== WAIT_OBJECT_0
)
261 HeapFree( GetProcessHeap(), 0, in_buff
);
262 return STATUS_SUCCESS
;
264 if (ret
!= WAIT_IO_COMPLETION
) break;
272 /***********************************************************************
273 * IoAcquireCancelSpinLock (NTOSKRNL.EXE.@)
275 void WINAPI
IoAcquireCancelSpinLock(PKIRQL irql
)
277 FIXME("(%p): stub\n", irql
);
281 /***********************************************************************
282 * IoReleaseCancelSpinLock (NTOSKRNL.EXE.@)
284 void WINAPI
IoReleaseCancelSpinLock(PKIRQL irql
)
286 FIXME("(%p): stub\n", irql
);
290 /***********************************************************************
291 * IoAllocateDriverObjectExtension (NTOSKRNL.EXE.@)
293 NTSTATUS WINAPI
IoAllocateDriverObjectExtension( PDRIVER_OBJECT DriverObject
,
294 PVOID ClientIdentificationAddress
,
295 ULONG DriverObjectExtensionSize
,
296 PVOID
*DriverObjectExtension
)
298 FIXME( "stub: %p, %p, %u, %p\n", DriverObject
, ClientIdentificationAddress
,
299 DriverObjectExtensionSize
, DriverObjectExtension
);
300 return STATUS_NOT_IMPLEMENTED
;
304 /***********************************************************************
305 * IoGetDriverObjectExtension (NTOSKRNL.EXE.@)
307 PVOID WINAPI
IoGetDriverObjectExtension( PDRIVER_OBJECT DriverObject
,
308 PVOID ClientIdentificationAddress
)
310 FIXME( "stub: %p, %p\n", DriverObject
, ClientIdentificationAddress
);
315 /***********************************************************************
316 * IoInitializeIrp (NTOSKRNL.EXE.@)
318 void WINAPI
IoInitializeIrp( IRP
*irp
, USHORT size
, CCHAR stack_size
)
320 TRACE( "%p, %u, %d\n", irp
, size
, stack_size
);
322 RtlZeroMemory( irp
, size
);
324 irp
->Type
= IO_TYPE_IRP
;
326 InitializeListHead( &irp
->ThreadListEntry
);
327 irp
->StackCount
= stack_size
;
328 irp
->CurrentLocation
= stack_size
+ 1;
329 irp
->Tail
.Overlay
.s
.u2
.CurrentStackLocation
=
330 (PIO_STACK_LOCATION
)(irp
+ 1) + stack_size
;
334 /***********************************************************************
335 * IoInitializeTimer (NTOSKRNL.EXE.@)
337 NTSTATUS WINAPI
IoInitializeTimer(PDEVICE_OBJECT DeviceObject
,
338 PIO_TIMER_ROUTINE TimerRoutine
,
341 FIXME( "stub: %p, %p, %p\n", DeviceObject
, TimerRoutine
, Context
);
342 return STATUS_NOT_IMPLEMENTED
;
346 /***********************************************************************
347 * IoStartTimer (NTOSKRNL.EXE.@)
349 void WINAPI
IoStartTimer(PDEVICE_OBJECT DeviceObject
)
351 FIXME( "stub: %p\n", DeviceObject
);
355 /***********************************************************************
356 * IoAllocateIrp (NTOSKRNL.EXE.@)
358 PIRP WINAPI
IoAllocateIrp( CCHAR stack_size
, BOOLEAN charge_quota
)
363 TRACE( "%d, %d\n", stack_size
, charge_quota
);
365 size
= sizeof(IRP
) + stack_size
* sizeof(IO_STACK_LOCATION
);
366 irp
= ExAllocatePool( NonPagedPool
, size
);
369 IoInitializeIrp( irp
, size
, stack_size
);
370 irp
->AllocationFlags
= IRP_ALLOCATED_FIXED_SIZE
;
372 irp
->AllocationFlags
|= IRP_LOOKASIDE_ALLOCATION
;
377 /***********************************************************************
378 * IoFreeIrp (NTOSKRNL.EXE.@)
380 void WINAPI
IoFreeIrp( IRP
*irp
)
384 TRACE( "%p\n", irp
);
386 mdl
= irp
->MdlAddress
;
389 MDL
*next
= mdl
->Next
;
398 /***********************************************************************
399 * IoAllocateErrorLogEntry (NTOSKRNL.EXE.@)
401 PVOID WINAPI
IoAllocateErrorLogEntry( PVOID IoObject
, UCHAR EntrySize
)
403 FIXME( "stub: %p, %u\n", IoObject
, EntrySize
);
408 /***********************************************************************
409 * IoAllocateMdl (NTOSKRNL.EXE.@)
411 PMDL WINAPI
IoAllocateMdl( PVOID va
, ULONG length
, BOOLEAN secondary
, BOOLEAN charge_quota
, IRP
*irp
)
414 ULONG_PTR address
= (ULONG_PTR
)va
;
415 ULONG_PTR page_address
;
416 SIZE_T nb_pages
, mdl_size
;
418 TRACE("(%p, %u, %i, %i, %p)\n", va
, length
, secondary
, charge_quota
, irp
);
421 FIXME("Charge quota is not yet supported\n");
423 /* FIXME: We suppose that page size is 4096 */
424 page_address
= address
& ~(4096 - 1);
425 nb_pages
= (((address
+ length
- 1) & ~(4096 - 1)) - page_address
) / 4096 + 1;
427 mdl_size
= sizeof(MDL
) + nb_pages
* sizeof(PVOID
);
429 mdl
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, mdl_size
);
433 mdl
->Size
= mdl_size
;
434 mdl
->Process
= NULL
; /* FIXME: IoGetCurrentProcess */
435 mdl
->StartVa
= (PVOID
)page_address
;
436 mdl
->ByteCount
= length
;
437 mdl
->ByteOffset
= address
- page_address
;
439 if (!irp
) return mdl
;
441 if (secondary
) /* add it at the end */
443 MDL
**pmdl
= &irp
->MdlAddress
;
444 while (*pmdl
) pmdl
= &(*pmdl
)->Next
;
449 mdl
->Next
= irp
->MdlAddress
;
450 irp
->MdlAddress
= mdl
;
456 /***********************************************************************
457 * IoFreeMdl (NTOSKRNL.EXE.@)
459 void WINAPI
IoFreeMdl(PMDL mdl
)
462 HeapFree(GetProcessHeap(), 0, mdl
);
466 /***********************************************************************
467 * IoAllocateWorkItem (NTOSKRNL.EXE.@)
469 PIO_WORKITEM WINAPI
IoAllocateWorkItem( PDEVICE_OBJECT DeviceObject
)
471 FIXME( "stub: %p\n", DeviceObject
);
476 /***********************************************************************
477 * IoAttachDeviceToDeviceStack (NTOSKRNL.EXE.@)
479 PDEVICE_OBJECT WINAPI
IoAttachDeviceToDeviceStack( DEVICE_OBJECT
*source
,
480 DEVICE_OBJECT
*target
)
482 TRACE( "%p, %p\n", source
, target
);
483 target
->AttachedDevice
= source
;
484 source
->StackSize
= target
->StackSize
+ 1;
489 /***********************************************************************
490 * IoBuildDeviceIoControlRequest (NTOSKRNL.EXE.@)
492 PIRP WINAPI
IoBuildDeviceIoControlRequest( ULONG code
, PDEVICE_OBJECT device
,
493 PVOID in_buff
, ULONG in_len
,
494 PVOID out_buff
, ULONG out_len
,
495 BOOLEAN internal
, PKEVENT event
,
496 PIO_STATUS_BLOCK iosb
)
499 PIO_STACK_LOCATION irpsp
;
501 TRACE( "%x, %p, %p, %u, %p, %u, %u, %p, %p\n",
502 code
, device
, in_buff
, in_len
, out_buff
, out_len
, internal
, event
, iosb
);
507 irp
= IoAllocateIrp( device
->StackSize
, FALSE
);
511 irpsp
= IoGetNextIrpStackLocation( irp
);
512 irpsp
->MajorFunction
= internal
? IRP_MJ_INTERNAL_DEVICE_CONTROL
: IRP_MJ_DEVICE_CONTROL
;
513 irpsp
->Parameters
.DeviceIoControl
.IoControlCode
= code
;
514 irpsp
->Parameters
.DeviceIoControl
.InputBufferLength
= in_len
;
515 irpsp
->Parameters
.DeviceIoControl
.OutputBufferLength
= out_len
;
516 irpsp
->DeviceObject
= device
;
517 irpsp
->CompletionRoutine
= NULL
;
521 case METHOD_BUFFERED
:
522 irp
->AssociatedIrp
.SystemBuffer
= in_buff
;
524 case METHOD_IN_DIRECT
:
525 case METHOD_OUT_DIRECT
:
526 irp
->AssociatedIrp
.SystemBuffer
= in_buff
;
527 IoAllocateMdl( out_buff
, out_len
, FALSE
, FALSE
, irp
);
530 irpsp
->Parameters
.DeviceIoControl
.Type3InputBuffer
= in_buff
;
534 irp
->RequestorMode
= KernelMode
;
535 irp
->UserBuffer
= out_buff
;
536 irp
->UserIosb
= iosb
;
537 irp
->UserEvent
= event
;
542 /**********************************************************
543 * IoBuildSynchronousFsdRequest (NTOSKRNL.EXE.@)
545 PIRP WINAPI
IoBuildSynchronousFsdRequest(ULONG majorfunc
, PDEVICE_OBJECT device
,
546 PVOID buffer
, ULONG length
, PLARGE_INTEGER startoffset
,
547 PKEVENT event
, PIO_STATUS_BLOCK iosb
)
550 PIO_STACK_LOCATION irpsp
;
552 TRACE("(%d %p %p %d %p %p %p)\n", majorfunc
, device
, buffer
, length
, startoffset
, event
, iosb
);
554 if (!(irp
= IoAllocateIrp( device
->StackSize
, FALSE
))) return NULL
;
556 irpsp
= IoGetNextIrpStackLocation( irp
);
557 irpsp
->MajorFunction
= majorfunc
;
558 irpsp
->DeviceObject
= device
;
559 irpsp
->CompletionRoutine
= NULL
;
561 irp
->AssociatedIrp
.SystemBuffer
= buffer
;
562 if (device
->Flags
& DO_DIRECT_IO
) IoAllocateMdl( buffer
, length
, FALSE
, FALSE
, irp
);
567 irpsp
->Parameters
.Read
.Length
= length
;
568 irpsp
->Parameters
.Read
.ByteOffset
= *startoffset
;
571 irpsp
->Parameters
.Write
.Length
= length
;
572 irpsp
->Parameters
.Write
.ByteOffset
= *startoffset
;
575 irp
->RequestorMode
= KernelMode
;
576 irp
->UserIosb
= iosb
;
577 irp
->UserEvent
= event
;
578 irp
->UserBuffer
= buffer
;
583 /***********************************************************************
584 * IoCreateDriver (NTOSKRNL.EXE.@)
586 NTSTATUS WINAPI
IoCreateDriver( UNICODE_STRING
*name
, PDRIVER_INITIALIZE init
)
588 DRIVER_OBJECT
*driver
;
589 DRIVER_EXTENSION
*extension
;
592 TRACE("(%s, %p)\n", debugstr_us(name
), init
);
594 if (!(driver
= RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY
,
595 sizeof(*driver
) + sizeof(*extension
) )))
596 return STATUS_NO_MEMORY
;
598 if ((status
= RtlDuplicateUnicodeString( 1, name
, &driver
->DriverName
)))
600 RtlFreeHeap( GetProcessHeap(), 0, driver
);
604 extension
= (DRIVER_EXTENSION
*)(driver
+ 1);
605 driver
->Size
= sizeof(*driver
);
606 driver
->DriverInit
= init
;
607 driver
->DriverExtension
= extension
;
608 extension
->DriverObject
= driver
;
609 extension
->ServiceKeyName
= driver
->DriverName
;
611 status
= driver
->DriverInit( driver
, name
);
615 RtlFreeUnicodeString( &driver
->DriverName
);
616 RtlFreeHeap( GetProcessHeap(), 0, driver
);
622 /***********************************************************************
623 * IoDeleteDriver (NTOSKRNL.EXE.@)
625 void WINAPI
IoDeleteDriver( DRIVER_OBJECT
*driver
)
627 TRACE("(%p)\n", driver
);
629 RtlFreeUnicodeString( &driver
->DriverName
);
630 RtlFreeHeap( GetProcessHeap(), 0, driver
);
634 /***********************************************************************
635 * IoCreateDevice (NTOSKRNL.EXE.@)
637 NTSTATUS WINAPI
IoCreateDevice( DRIVER_OBJECT
*driver
, ULONG ext_size
,
638 UNICODE_STRING
*name
, DEVICE_TYPE type
,
639 ULONG characteristics
, BOOLEAN exclusive
,
640 DEVICE_OBJECT
**ret_device
)
643 DEVICE_OBJECT
*device
;
645 HANDLE manager
= get_device_manager();
647 TRACE( "(%p, %u, %s, %u, %x, %u, %p)\n",
648 driver
, ext_size
, debugstr_us(name
), type
, characteristics
, exclusive
, ret_device
);
650 if (!(device
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*device
) + ext_size
)))
651 return STATUS_NO_MEMORY
;
653 SERVER_START_REQ( create_device
)
658 req
->manager
= wine_server_obj_handle( manager
);
659 req
->user_ptr
= wine_server_client_ptr( device
);
660 if (name
) wine_server_add_data( req
, name
->Buffer
, name
->Length
);
661 if (!(status
= wine_server_call( req
))) handle
= wine_server_ptr_handle( reply
->handle
);
665 if (status
== STATUS_SUCCESS
)
667 device
->DriverObject
= driver
;
668 device
->DeviceExtension
= device
+ 1;
669 device
->DeviceType
= type
;
670 device
->StackSize
= 1;
671 device
->Reserved
= handle
;
673 device
->NextDevice
= driver
->DeviceObject
;
674 driver
->DeviceObject
= device
;
676 *ret_device
= device
;
678 else HeapFree( GetProcessHeap(), 0, device
);
684 /***********************************************************************
685 * IoDeleteDevice (NTOSKRNL.EXE.@)
687 void WINAPI
IoDeleteDevice( DEVICE_OBJECT
*device
)
691 TRACE( "%p\n", device
);
693 SERVER_START_REQ( delete_device
)
695 req
->handle
= wine_server_obj_handle( device
->Reserved
);
696 status
= wine_server_call( req
);
700 if (status
== STATUS_SUCCESS
)
702 DEVICE_OBJECT
**prev
= &device
->DriverObject
->DeviceObject
;
703 while (*prev
&& *prev
!= device
) prev
= &(*prev
)->NextDevice
;
704 if (*prev
) *prev
= (*prev
)->NextDevice
;
705 NtClose( device
->Reserved
);
706 HeapFree( GetProcessHeap(), 0, device
);
711 /***********************************************************************
712 * IoCreateSymbolicLink (NTOSKRNL.EXE.@)
714 NTSTATUS WINAPI
IoCreateSymbolicLink( UNICODE_STRING
*name
, UNICODE_STRING
*target
)
717 OBJECT_ATTRIBUTES attr
;
719 attr
.Length
= sizeof(attr
);
720 attr
.RootDirectory
= 0;
721 attr
.ObjectName
= name
;
722 attr
.Attributes
= OBJ_CASE_INSENSITIVE
| OBJ_OPENIF
;
723 attr
.SecurityDescriptor
= NULL
;
724 attr
.SecurityQualityOfService
= NULL
;
726 TRACE( "%s -> %s\n", debugstr_us(name
), debugstr_us(target
) );
727 /* FIXME: store handle somewhere */
728 return NtCreateSymbolicLinkObject( &handle
, SYMBOLIC_LINK_ALL_ACCESS
, &attr
, target
);
732 /***********************************************************************
733 * IoDeleteSymbolicLink (NTOSKRNL.EXE.@)
735 NTSTATUS WINAPI
IoDeleteSymbolicLink( UNICODE_STRING
*name
)
738 OBJECT_ATTRIBUTES attr
;
741 attr
.Length
= sizeof(attr
);
742 attr
.RootDirectory
= 0;
743 attr
.ObjectName
= name
;
744 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
745 attr
.SecurityDescriptor
= NULL
;
746 attr
.SecurityQualityOfService
= NULL
;
748 if (!(status
= NtOpenSymbolicLinkObject( &handle
, 0, &attr
)))
750 SERVER_START_REQ( unlink_object
)
752 req
->handle
= wine_server_obj_handle( handle
);
753 status
= wine_server_call( req
);
762 /***********************************************************************
763 * IoGetDeviceInterfaces (NTOSKRNL.EXE.@)
765 NTSTATUS WINAPI
IoGetDeviceInterfaces( const GUID
*InterfaceClassGuid
,
766 PDEVICE_OBJECT PhysicalDeviceObject
,
767 ULONG Flags
, PWSTR
*SymbolicLinkList
)
769 FIXME( "stub: %s %p %x %p\n", debugstr_guid(InterfaceClassGuid
),
770 PhysicalDeviceObject
, Flags
, SymbolicLinkList
);
771 return STATUS_NOT_IMPLEMENTED
;
775 /***********************************************************************
776 * IoGetDeviceObjectPointer (NTOSKRNL.EXE.@)
778 NTSTATUS WINAPI
IoGetDeviceObjectPointer( UNICODE_STRING
*name
, ACCESS_MASK access
, PFILE_OBJECT
*file
, PDEVICE_OBJECT
*device
)
780 FIXME( "stub: %s %x %p %p\n", debugstr_us(name
), access
, file
, device
);
785 return STATUS_SUCCESS
;
788 /***********************************************************************
789 * IoGetAttachedDevice (NTOSKRNL.EXE.@)
791 PDEVICE_OBJECT WINAPI
IoGetAttachedDevice( PDEVICE_OBJECT device
)
793 FIXME( "stub: %p\n", device
);
798 /***********************************************************************
799 * IoGetDeviceProperty (NTOSKRNL.EXE.@)
801 NTSTATUS WINAPI
IoGetDeviceProperty( DEVICE_OBJECT
*device
, DEVICE_REGISTRY_PROPERTY device_property
,
802 ULONG buffer_length
, PVOID property_buffer
, PULONG result_length
)
804 FIXME( "%p %d %u %p %p: stub\n", device
, device_property
, buffer_length
,
805 property_buffer
, result_length
);
806 return STATUS_NOT_IMPLEMENTED
;
810 /***********************************************************************
811 * IoCallDriver (NTOSKRNL.EXE.@)
813 NTSTATUS WINAPI
IoCallDriver( DEVICE_OBJECT
*device
, IRP
*irp
)
815 PDRIVER_DISPATCH dispatch
;
816 IO_STACK_LOCATION
*irpsp
;
819 --irp
->CurrentLocation
;
820 irpsp
= --irp
->Tail
.Overlay
.s
.u2
.CurrentStackLocation
;
821 dispatch
= device
->DriverObject
->MajorFunction
[irpsp
->MajorFunction
];
824 DPRINTF( "%04x:Call driver dispatch %p (device=%p,irp=%p)\n",
825 GetCurrentThreadId(), dispatch
, device
, irp
);
827 status
= dispatch( device
, irp
);
830 DPRINTF( "%04x:Ret driver dispatch %p (device=%p,irp=%p) retval=%08x\n",
831 GetCurrentThreadId(), dispatch
, device
, irp
, status
);
837 /***********************************************************************
838 * IofCallDriver (NTOSKRNL.EXE.@)
840 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
841 DEFINE_FASTCALL2_ENTRYPOINT( IofCallDriver
)
842 NTSTATUS WINAPI
__regs_IofCallDriver( DEVICE_OBJECT
*device
, IRP
*irp
)
844 NTSTATUS WINAPI
IofCallDriver( DEVICE_OBJECT
*device
, IRP
*irp
)
847 TRACE( "%p %p\n", device
, irp
);
848 return IoCallDriver( device
, irp
);
852 /***********************************************************************
853 * IoGetRelatedDeviceObject (NTOSKRNL.EXE.@)
855 PDEVICE_OBJECT WINAPI
IoGetRelatedDeviceObject( PFILE_OBJECT obj
)
857 FIXME( "stub: %p\n", obj
);
861 static CONFIGURATION_INFORMATION configuration_information
;
863 /***********************************************************************
864 * IoGetConfigurationInformation (NTOSKRNL.EXE.@)
866 PCONFIGURATION_INFORMATION WINAPI
IoGetConfigurationInformation(void)
868 FIXME( "partial stub\n" );
869 /* FIXME: return actual devices on system */
870 return &configuration_information
;
874 /***********************************************************************
875 * IoIsWdmVersionAvailable (NTOSKRNL.EXE.@)
877 NTSTATUS WINAPI
IoIsWdmVersionAvailable(UCHAR MajorVersion
, UCHAR MinorVersion
)
883 TRACE( "%d, 0x%X\n", MajorVersion
, MinorVersion
);
885 version
= GetVersion();
886 major
= LOBYTE(version
);
887 minor
= HIBYTE(LOWORD(version
));
889 if (MajorVersion
== 6 && MinorVersion
== 0)
891 /* Windows Vista, Windows Server 2008, Windows 7 */
893 else if (MajorVersion
== 1)
895 if (MinorVersion
== 0x30)
897 /* Windows server 2003 */
901 else if (MinorVersion
== 0x20)
907 else if (MinorVersion
== 0x10)
913 else if (MinorVersion
== 0x05)
919 else if (MinorVersion
== 0x00)
927 FIXME( "unknown major %d minor 0x%X\n", MajorVersion
, MinorVersion
);
933 FIXME( "unknown major %d minor 0x%X\n", MajorVersion
, MinorVersion
);
936 return major
> MajorVersion
|| (major
== MajorVersion
&& minor
>= MinorVersion
);
940 /***********************************************************************
941 * IoQueryDeviceDescription (NTOSKRNL.EXE.@)
943 NTSTATUS WINAPI
IoQueryDeviceDescription(PINTERFACE_TYPE itype
, PULONG bus
, PCONFIGURATION_TYPE ctype
,
944 PULONG cnum
, PCONFIGURATION_TYPE ptype
, PULONG pnum
,
945 PIO_QUERY_DEVICE_ROUTINE callout
, PVOID context
)
947 FIXME( "(%p %p %p %p %p %p %p %p)\n", itype
, bus
, ctype
, cnum
, ptype
, pnum
, callout
, context
);
948 return STATUS_NOT_IMPLEMENTED
;
952 /***********************************************************************
953 * IoRegisterDriverReinitialization (NTOSKRNL.EXE.@)
955 void WINAPI
IoRegisterDriverReinitialization( PDRIVER_OBJECT obj
, PDRIVER_REINITIALIZE reinit
, PVOID context
)
957 FIXME( "stub: %p %p %p\n", obj
, reinit
, context
);
961 /***********************************************************************
962 * IoRegisterShutdownNotification (NTOSKRNL.EXE.@)
964 NTSTATUS WINAPI
IoRegisterShutdownNotification( PDEVICE_OBJECT obj
)
966 FIXME( "stub: %p\n", obj
);
967 return STATUS_SUCCESS
;
971 /***********************************************************************
972 * IoUnregisterShutdownNotification (NTOSKRNL.EXE.@)
974 VOID WINAPI
IoUnregisterShutdownNotification( PDEVICE_OBJECT obj
)
976 FIXME( "stub: %p\n", obj
);
980 /***********************************************************************
981 * IoReportResourceUsage (NTOSKRNL.EXE.@)
983 NTSTATUS WINAPI
IoReportResourceUsage(PUNICODE_STRING name
, PDRIVER_OBJECT drv_obj
, PCM_RESOURCE_LIST drv_list
,
984 ULONG drv_size
, PDRIVER_OBJECT dev_obj
, PCM_RESOURCE_LIST dev_list
,
985 ULONG dev_size
, BOOLEAN overwrite
, PBOOLEAN detected
)
987 FIXME("(%s %p %p %u %p %p %u %d %p) stub\n", debugstr_w(name
? name
->Buffer
: NULL
),
988 drv_obj
, drv_list
, drv_size
, dev_obj
, dev_list
, dev_size
, overwrite
, detected
);
989 return STATUS_NOT_IMPLEMENTED
;
993 /***********************************************************************
994 * IoCompleteRequest (NTOSKRNL.EXE.@)
996 VOID WINAPI
IoCompleteRequest( IRP
*irp
, UCHAR priority_boost
)
998 IO_STACK_LOCATION
*irpsp
;
999 PIO_COMPLETION_ROUTINE routine
;
1000 NTSTATUS status
, stat
;
1004 TRACE( "%p %u\n", irp
, priority_boost
);
1006 status
= irp
->IoStatus
.u
.Status
;
1007 while (irp
->CurrentLocation
<= irp
->StackCount
)
1009 irpsp
= irp
->Tail
.Overlay
.s
.u2
.CurrentStackLocation
;
1010 routine
= irpsp
->CompletionRoutine
;
1012 /* FIXME: add SL_INVOKE_ON_CANCEL support */
1015 if ((irpsp
->Control
& SL_INVOKE_ON_SUCCESS
) && STATUS_SUCCESS
== status
)
1017 if ((irpsp
->Control
& SL_INVOKE_ON_ERROR
) && STATUS_SUCCESS
!= status
)
1020 ++irp
->CurrentLocation
;
1021 ++irp
->Tail
.Overlay
.s
.u2
.CurrentStackLocation
;
1024 TRACE( "calling %p( %p, %p, %p )\n", routine
,
1025 irpsp
->DeviceObject
, irp
, irpsp
->Context
);
1026 stat
= routine( irpsp
->DeviceObject
, irp
, irpsp
->Context
);
1027 TRACE( "CompletionRoutine returned %x\n", stat
);
1028 if (STATUS_MORE_PROCESSING_REQUIRED
== stat
)
1033 handle
= (HANDLE
)irp
->UserIosb
;
1036 HANDLE manager
= get_device_manager();
1037 void *out_buff
= irp
->UserBuffer
;
1039 SERVER_START_REQ( set_irp_result
)
1041 req
->manager
= wine_server_obj_handle( manager
);
1042 req
->handle
= wine_server_obj_handle( handle
);
1043 req
->status
= irp
->IoStatus
.u
.Status
;
1044 if (irp
->IoStatus
.u
.Status
>= 0)
1046 req
->size
= irp
->IoStatus
.Information
;
1047 if (out_buff
) wine_server_add_data( req
, out_buff
, irp
->IoStatus
.Information
);
1049 wine_server_call( req
);
1052 HeapFree( GetProcessHeap(), 0, out_buff
);
1059 /***********************************************************************
1060 * IofCompleteRequest (NTOSKRNL.EXE.@)
1062 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1063 DEFINE_FASTCALL2_ENTRYPOINT( IofCompleteRequest
)
1064 void WINAPI
__regs_IofCompleteRequest( IRP
*irp
, UCHAR priority_boost
)
1066 void WINAPI
IofCompleteRequest( IRP
*irp
, UCHAR priority_boost
)
1069 TRACE( "%p %u\n", irp
, priority_boost
);
1070 IoCompleteRequest( irp
, priority_boost
);
1074 /***********************************************************************
1075 * InterlockedCompareExchange (NTOSKRNL.EXE.@)
1077 #ifdef DEFINE_FASTCALL3_ENTRYPOINT
1078 DEFINE_FASTCALL3_ENTRYPOINT( NTOSKRNL_InterlockedCompareExchange
)
1079 LONG WINAPI
__regs_NTOSKRNL_InterlockedCompareExchange( LONG
volatile *dest
, LONG xchg
, LONG compare
)
1081 LONG WINAPI
NTOSKRNL_InterlockedCompareExchange( LONG
volatile *dest
, LONG xchg
, LONG compare
)
1084 return InterlockedCompareExchange( dest
, xchg
, compare
);
1088 /***********************************************************************
1089 * InterlockedDecrement (NTOSKRNL.EXE.@)
1091 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1092 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedDecrement
)
1093 LONG WINAPI
__regs_NTOSKRNL_InterlockedDecrement( LONG
volatile *dest
)
1095 LONG WINAPI
NTOSKRNL_InterlockedDecrement( LONG
volatile *dest
)
1098 return InterlockedDecrement( dest
);
1102 /***********************************************************************
1103 * InterlockedExchange (NTOSKRNL.EXE.@)
1105 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1106 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchange
)
1107 LONG WINAPI
__regs_NTOSKRNL_InterlockedExchange( LONG
volatile *dest
, LONG val
)
1109 LONG WINAPI
NTOSKRNL_InterlockedExchange( LONG
volatile *dest
, LONG val
)
1112 return InterlockedExchange( dest
, val
);
1116 /***********************************************************************
1117 * InterlockedExchangeAdd (NTOSKRNL.EXE.@)
1119 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1120 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchangeAdd
)
1121 LONG WINAPI
__regs_NTOSKRNL_InterlockedExchangeAdd( LONG
volatile *dest
, LONG incr
)
1123 LONG WINAPI
NTOSKRNL_InterlockedExchangeAdd( LONG
volatile *dest
, LONG incr
)
1126 return InterlockedExchangeAdd( dest
, incr
);
1130 /***********************************************************************
1131 * InterlockedIncrement (NTOSKRNL.EXE.@)
1133 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1134 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedIncrement
)
1135 LONG WINAPI
__regs_NTOSKRNL_InterlockedIncrement( LONG
volatile *dest
)
1137 LONG WINAPI
NTOSKRNL_InterlockedIncrement( LONG
volatile *dest
)
1140 return InterlockedIncrement( dest
);
1144 /***********************************************************************
1145 * ExAllocatePool (NTOSKRNL.EXE.@)
1147 PVOID WINAPI
ExAllocatePool( POOL_TYPE type
, SIZE_T size
)
1149 return ExAllocatePoolWithTag( type
, size
, 0 );
1153 /***********************************************************************
1154 * ExAllocatePoolWithQuota (NTOSKRNL.EXE.@)
1156 PVOID WINAPI
ExAllocatePoolWithQuota( POOL_TYPE type
, SIZE_T size
)
1158 return ExAllocatePoolWithTag( type
, size
, 0 );
1162 /***********************************************************************
1163 * ExAllocatePoolWithTag (NTOSKRNL.EXE.@)
1165 PVOID WINAPI
ExAllocatePoolWithTag( POOL_TYPE type
, SIZE_T size
, ULONG tag
)
1167 /* FIXME: handle page alignment constraints */
1168 void *ret
= HeapAlloc( GetProcessHeap(), 0, size
);
1169 TRACE( "%lu pool %u -> %p\n", size
, type
, ret
);
1174 /***********************************************************************
1175 * ExAllocatePoolWithQuotaTag (NTOSKRNL.EXE.@)
1177 PVOID WINAPI
ExAllocatePoolWithQuotaTag( POOL_TYPE type
, SIZE_T size
, ULONG tag
)
1179 return ExAllocatePoolWithTag( type
, size
, tag
);
1183 /***********************************************************************
1184 * ExCreateCallback (NTOSKRNL.EXE.@)
1186 NTSTATUS WINAPI
ExCreateCallback(PCALLBACK_OBJECT
*obj
, POBJECT_ATTRIBUTES attr
,
1187 BOOLEAN create
, BOOLEAN allow_multiple
)
1189 FIXME("(%p, %p, %u, %u): stub\n", obj
, attr
, create
, allow_multiple
);
1191 return STATUS_NOT_IMPLEMENTED
;
1195 /***********************************************************************
1196 * ExFreePool (NTOSKRNL.EXE.@)
1198 void WINAPI
ExFreePool( void *ptr
)
1200 ExFreePoolWithTag( ptr
, 0 );
1204 /***********************************************************************
1205 * ExFreePoolWithTag (NTOSKRNL.EXE.@)
1207 void WINAPI
ExFreePoolWithTag( void *ptr
, ULONG tag
)
1209 TRACE( "%p\n", ptr
);
1210 HeapFree( GetProcessHeap(), 0, ptr
);
1214 /***********************************************************************
1215 * ExInitializeResourceLite (NTOSKRNL.EXE.@)
1217 NTSTATUS WINAPI
ExInitializeResourceLite(PERESOURCE Resource
)
1219 FIXME( "stub: %p\n", Resource
);
1220 return STATUS_NOT_IMPLEMENTED
;
1224 /***********************************************************************
1225 * ExInitializeNPagedLookasideList (NTOSKRNL.EXE.@)
1227 void WINAPI
ExInitializeNPagedLookasideList(PNPAGED_LOOKASIDE_LIST Lookaside
,
1228 PALLOCATE_FUNCTION Allocate
,
1229 PFREE_FUNCTION Free
,
1235 FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside
, Allocate
, Free
, Flags
, Size
, Tag
, Depth
);
1238 /***********************************************************************
1239 * ExInitializePagedLookasideList (NTOSKRNL.EXE.@)
1241 void WINAPI
ExInitializePagedLookasideList(PPAGED_LOOKASIDE_LIST Lookaside
,
1242 PALLOCATE_FUNCTION Allocate
,
1243 PFREE_FUNCTION Free
,
1249 FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside
, Allocate
, Free
, Flags
, Size
, Tag
, Depth
);
1252 /***********************************************************************
1253 * ExInitializeZone (NTOSKRNL.EXE.@)
1255 NTSTATUS WINAPI
ExInitializeZone(PZONE_HEADER Zone
,
1257 PVOID InitialSegment
,
1258 ULONG InitialSegmentSize
)
1260 FIXME( "stub: %p, %u, %p, %u\n", Zone
, BlockSize
, InitialSegment
, InitialSegmentSize
);
1261 return STATUS_NOT_IMPLEMENTED
;
1264 /***********************************************************************
1265 * FsRtlRegisterUncProvider (NTOSKRNL.EXE.@)
1267 NTSTATUS WINAPI
FsRtlRegisterUncProvider(PHANDLE MupHandle
, PUNICODE_STRING RedirDevName
,
1268 BOOLEAN MailslotsSupported
)
1270 FIXME("(%p %p %d): stub\n", MupHandle
, RedirDevName
, MailslotsSupported
);
1271 return STATUS_NOT_IMPLEMENTED
;
1274 /***********************************************************************
1275 * IoGetCurrentProcess / PsGetCurrentProcess (NTOSKRNL.EXE.@)
1277 PEPROCESS WINAPI
IoGetCurrentProcess(void)
1283 /***********************************************************************
1284 * KeGetCurrentThread / PsGetCurrentThread (NTOSKRNL.EXE.@)
1286 PRKTHREAD WINAPI
KeGetCurrentThread(void)
1292 /***********************************************************************
1293 * KeInitializeEvent (NTOSKRNL.EXE.@)
1295 void WINAPI
KeInitializeEvent( PRKEVENT Event
, EVENT_TYPE Type
, BOOLEAN State
)
1297 FIXME( "stub: %p %d %d\n", Event
, Type
, State
);
1301 /***********************************************************************
1302 * KeInitializeMutex (NTOSKRNL.EXE.@)
1304 void WINAPI
KeInitializeMutex(PRKMUTEX Mutex
, ULONG Level
)
1306 FIXME( "stub: %p, %u\n", Mutex
, Level
);
1310 /***********************************************************************
1311 * KeWaitForMutexObject (NTOSKRNL.EXE.@)
1313 NTSTATUS WINAPI
KeWaitForMutexObject(PRKMUTEX Mutex
, KWAIT_REASON WaitReason
, KPROCESSOR_MODE WaitMode
,
1314 BOOLEAN Alertable
, PLARGE_INTEGER Timeout
)
1316 FIXME( "stub: %p, %d, %d, %d, %p\n", Mutex
, WaitReason
, WaitMode
, Alertable
, Timeout
);
1317 return STATUS_NOT_IMPLEMENTED
;
1321 /***********************************************************************
1322 * KeReleaseMutex (NTOSKRNL.EXE.@)
1324 LONG WINAPI
KeReleaseMutex(PRKMUTEX Mutex
, BOOLEAN Wait
)
1326 FIXME( "stub: %p, %d\n", Mutex
, Wait
);
1327 return STATUS_NOT_IMPLEMENTED
;
1331 /***********************************************************************
1332 * KeInitializeSemaphore (NTOSKRNL.EXE.@)
1334 void WINAPI
KeInitializeSemaphore( PRKSEMAPHORE Semaphore
, LONG Count
, LONG Limit
)
1336 FIXME( "(%p %d %d) stub\n", Semaphore
, Count
, Limit
);
1340 /***********************************************************************
1341 * KeInitializeSpinLock (NTOSKRNL.EXE.@)
1343 void WINAPI
KeInitializeSpinLock( PKSPIN_LOCK SpinLock
)
1345 FIXME( "stub: %p\n", SpinLock
);
1349 /***********************************************************************
1350 * KeInitializeTimerEx (NTOSKRNL.EXE.@)
1352 void WINAPI
KeInitializeTimerEx( PKTIMER Timer
, TIMER_TYPE Type
)
1354 FIXME( "stub: %p %d\n", Timer
, Type
);
1358 /***********************************************************************
1359 * KeInitializeTimer (NTOSKRNL.EXE.@)
1361 void WINAPI
KeInitializeTimer( PKTIMER Timer
)
1363 KeInitializeTimerEx(Timer
, NotificationTimer
);
1366 /***********************************************************************
1367 * KeInsertQueue (NTOSKRNL.EXE.@)
1369 LONG WINAPI
KeInsertQueue(PRKQUEUE Queue
, PLIST_ENTRY Entry
)
1371 FIXME( "stub: %p %p\n", Queue
, Entry
);
1375 /**********************************************************************
1376 * KeQueryActiveProcessors (NTOSKRNL.EXE.@)
1378 * Return the active Processors as bitmask
1381 * active Processors as bitmask
1384 KAFFINITY WINAPI
KeQueryActiveProcessors( void )
1386 DWORD_PTR AffinityMask
;
1388 GetProcessAffinityMask( GetCurrentProcess(), &AffinityMask
, NULL
);
1389 return AffinityMask
;
1393 /**********************************************************************
1394 * KeQueryInterruptTime (NTOSKRNL.EXE.@)
1396 * Return the interrupt time count
1399 ULONGLONG WINAPI
KeQueryInterruptTime( void )
1401 LARGE_INTEGER totaltime
;
1403 KeQueryTickCount(&totaltime
);
1404 return totaltime
.QuadPart
;
1408 /***********************************************************************
1409 * KeQuerySystemTime (NTOSKRNL.EXE.@)
1411 void WINAPI
KeQuerySystemTime( LARGE_INTEGER
*time
)
1413 NtQuerySystemTime( time
);
1417 /***********************************************************************
1418 * KeQueryTickCount (NTOSKRNL.EXE.@)
1420 void WINAPI
KeQueryTickCount( LARGE_INTEGER
*count
)
1422 count
->QuadPart
= NtGetTickCount();
1423 /* update the global variable too */
1424 KeTickCount
.LowPart
= count
->u
.LowPart
;
1425 KeTickCount
.High1Time
= count
->u
.HighPart
;
1426 KeTickCount
.High2Time
= count
->u
.HighPart
;
1430 /***********************************************************************
1431 * KeReleaseSemaphore (NTOSKRNL.EXE.@)
1433 LONG WINAPI
KeReleaseSemaphore( PRKSEMAPHORE Semaphore
, KPRIORITY Increment
,
1434 LONG Adjustment
, BOOLEAN Wait
)
1436 FIXME("(%p %d %d %d) stub\n", Semaphore
, Increment
, Adjustment
, Wait
);
1441 /***********************************************************************
1442 * KeQueryTimeIncrement (NTOSKRNL.EXE.@)
1444 ULONG WINAPI
KeQueryTimeIncrement(void)
1450 /***********************************************************************
1451 * KeResetEvent (NTOSKRNL.EXE.@)
1453 LONG WINAPI
KeResetEvent( PRKEVENT Event
)
1455 FIXME("(%p): stub\n", Event
);
1460 /***********************************************************************
1461 * KeSetEvent (NTOSKRNL.EXE.@)
1463 LONG WINAPI
KeSetEvent( PRKEVENT Event
, KPRIORITY Increment
, BOOLEAN Wait
)
1465 FIXME("(%p, %d, %d): stub\n", Event
, Increment
, Wait
);
1470 /***********************************************************************
1471 * KeSetPriorityThread (NTOSKRNL.EXE.@)
1473 KPRIORITY WINAPI
KeSetPriorityThread( PKTHREAD Thread
, KPRIORITY Priority
)
1475 FIXME("(%p %d)\n", Thread
, Priority
);
1479 /***********************************************************************
1480 * KeSetSystemAffinityThread (NTOSKRNL.EXE.@)
1482 VOID WINAPI
KeSetSystemAffinityThread(KAFFINITY Affinity
)
1484 FIXME("(%lx) stub\n", Affinity
);
1487 /***********************************************************************
1488 * KeWaitForSingleObject (NTOSKRNL.EXE.@)
1490 NTSTATUS WINAPI
KeWaitForSingleObject(PVOID Object
,
1491 KWAIT_REASON WaitReason
,
1492 KPROCESSOR_MODE WaitMode
,
1494 PLARGE_INTEGER Timeout
)
1496 FIXME( "stub: %p, %d, %d, %d, %p\n", Object
, WaitReason
, WaitMode
, Alertable
, Timeout
);
1497 return STATUS_NOT_IMPLEMENTED
;
1500 /***********************************************************************
1501 * IoRegisterFileSystem (NTOSKRNL.EXE.@)
1503 VOID WINAPI
IoRegisterFileSystem(PDEVICE_OBJECT DeviceObject
)
1505 FIXME("(%p): stub\n", DeviceObject
);
1508 /***********************************************************************
1509 * IoUnregisterFileSystem (NTOSKRNL.EXE.@)
1511 VOID WINAPI
IoUnregisterFileSystem(PDEVICE_OBJECT DeviceObject
)
1513 FIXME("(%p): stub\n", DeviceObject
);
1516 /***********************************************************************
1517 * MmAllocateNonCachedMemory (NTOSKRNL.EXE.@)
1519 PVOID WINAPI
MmAllocateNonCachedMemory( SIZE_T size
)
1521 TRACE( "%lu\n", size
);
1522 return VirtualAlloc( NULL
, size
, MEM_RESERVE
|MEM_COMMIT
, PAGE_READWRITE
|PAGE_NOCACHE
);
1525 /***********************************************************************
1526 * MmAllocateContiguousMemory (NTOSKRNL.EXE.@)
1528 PVOID WINAPI
MmAllocateContiguousMemory( SIZE_T size
, PHYSICAL_ADDRESS highest_valid_address
)
1530 FIXME( "%lu, %s stub\n", size
, wine_dbgstr_longlong(highest_valid_address
.QuadPart
) );
1534 /***********************************************************************
1535 * MmAllocateContiguousMemorySpecifyCache (NTOSKRNL.EXE.@)
1537 PVOID WINAPI
MmAllocateContiguousMemorySpecifyCache( SIZE_T size
,
1538 PHYSICAL_ADDRESS lowest_valid_address
,
1539 PHYSICAL_ADDRESS highest_valid_address
,
1540 PHYSICAL_ADDRESS BoundaryAddressMultiple
,
1541 MEMORY_CACHING_TYPE CacheType
)
1547 /***********************************************************************
1548 * MmAllocatePagesForMdl (NTOSKRNL.EXE.@)
1550 PMDL WINAPI
MmAllocatePagesForMdl(PHYSICAL_ADDRESS lowaddress
, PHYSICAL_ADDRESS highaddress
,
1551 PHYSICAL_ADDRESS skipbytes
, SIZE_T size
)
1553 FIXME("%s %s %s %lu: stub\n", wine_dbgstr_longlong(lowaddress
.QuadPart
), wine_dbgstr_longlong(highaddress
.QuadPart
),
1554 wine_dbgstr_longlong(skipbytes
.QuadPart
), size
);
1558 /***********************************************************************
1559 * MmFreeNonCachedMemory (NTOSKRNL.EXE.@)
1561 void WINAPI
MmFreeNonCachedMemory( void *addr
, SIZE_T size
)
1563 TRACE( "%p %lu\n", addr
, size
);
1564 VirtualFree( addr
, 0, MEM_RELEASE
);
1567 /***********************************************************************
1568 * MmIsAddressValid (NTOSKRNL.EXE.@)
1570 * Check if the process can access the virtual address without a pagefault
1573 * VirtualAddress [I] Address to check
1577 * Success: TRUE (Accessing the Address works without a Pagefault)
1580 BOOLEAN WINAPI
MmIsAddressValid(PVOID VirtualAddress
)
1582 TRACE("(%p)\n", VirtualAddress
);
1583 return !IsBadWritePtr(VirtualAddress
, 1);
1586 /***********************************************************************
1587 * MmMapIoSpace (NTOSKRNL.EXE.@)
1589 PVOID WINAPI
MmMapIoSpace( PHYSICAL_ADDRESS PhysicalAddress
, DWORD NumberOfBytes
, DWORD CacheType
)
1591 FIXME( "stub: 0x%08x%08x, %d, %d\n", PhysicalAddress
.u
.HighPart
, PhysicalAddress
.u
.LowPart
, NumberOfBytes
, CacheType
);
1596 /***********************************************************************
1597 * MmLockPagableSectionByHandle (NTOSKRNL.EXE.@)
1599 VOID WINAPI
MmLockPagableSectionByHandle(PVOID ImageSectionHandle
)
1601 FIXME("stub %p\n", ImageSectionHandle
);
1604 /***********************************************************************
1605 * MmMapLockedPagesSpecifyCache (NTOSKRNL.EXE.@)
1607 PVOID WINAPI
MmMapLockedPagesSpecifyCache(PMDLX MemoryDescriptorList
, KPROCESSOR_MODE AccessMode
, MEMORY_CACHING_TYPE CacheType
,
1608 PVOID BaseAddress
, ULONG BugCheckOnFailure
, MM_PAGE_PRIORITY Priority
)
1610 FIXME("(%p, %u, %u, %p, %u, %u): stub\n", MemoryDescriptorList
, AccessMode
, CacheType
, BaseAddress
, BugCheckOnFailure
, Priority
);
1615 /***********************************************************************
1616 * MmUnlockPagableImageSection (NTOSKRNL.EXE.@)
1618 VOID WINAPI
MmUnlockPagableImageSection(PVOID ImageSectionHandle
)
1620 FIXME("stub %p\n", ImageSectionHandle
);
1623 /***********************************************************************
1624 * MmPageEntireDriver (NTOSKRNL.EXE.@)
1626 PVOID WINAPI
MmPageEntireDriver(PVOID AddrInSection
)
1628 TRACE("%p\n", AddrInSection
);
1629 return AddrInSection
;
1633 /***********************************************************************
1634 * MmProbeAndLockPages (NTOSKRNL.EXE.@)
1636 void WINAPI
MmProbeAndLockPages(PMDLX MemoryDescriptorList
, KPROCESSOR_MODE AccessMode
, LOCK_OPERATION Operation
)
1638 FIXME("(%p, %u, %u): stub\n", MemoryDescriptorList
, AccessMode
, Operation
);
1642 /***********************************************************************
1643 * MmResetDriverPaging (NTOSKRNL.EXE.@)
1645 void WINAPI
MmResetDriverPaging(PVOID AddrInSection
)
1647 TRACE("%p\n", AddrInSection
);
1651 /***********************************************************************
1652 * MmUnlockPages (NTOSKRNL.EXE.@)
1654 void WINAPI
MmUnlockPages(PMDLX MemoryDescriptorList
)
1656 FIXME("(%p): stub\n", MemoryDescriptorList
);
1660 /***********************************************************************
1661 * MmUnmapIoSpace (NTOSKRNL.EXE.@)
1663 VOID WINAPI
MmUnmapIoSpace( PVOID BaseAddress
, SIZE_T NumberOfBytes
)
1665 FIXME( "stub: %p, %lu\n", BaseAddress
, NumberOfBytes
);
1668 /***********************************************************************
1669 * ObfReferenceObject (NTOSKRNL.EXE.@)
1671 VOID WINAPI
ObfReferenceObject(PVOID Object
)
1673 FIXME("(%p): stub\n", Object
);
1676 /***********************************************************************
1677 * ObReferenceObjectByHandle (NTOSKRNL.EXE.@)
1679 NTSTATUS WINAPI
ObReferenceObjectByHandle( HANDLE obj
, ACCESS_MASK access
,
1681 KPROCESSOR_MODE mode
, PVOID
* ptr
,
1682 POBJECT_HANDLE_INFORMATION info
)
1684 FIXME( "stub: %p %x %p %d %p %p\n", obj
, access
, type
, mode
, ptr
, info
);
1685 return STATUS_NOT_IMPLEMENTED
;
1688 /***********************************************************************
1689 * ObReferenceObjectByName (NTOSKRNL.EXE.@)
1691 NTSTATUS WINAPI
ObReferenceObjectByName( UNICODE_STRING
*ObjectName
,
1693 ACCESS_STATE
*AccessState
,
1694 ACCESS_MASK DesiredAccess
,
1695 POBJECT_TYPE ObjectType
,
1696 KPROCESSOR_MODE AccessMode
,
1701 return STATUS_NOT_IMPLEMENTED
;
1704 /***********************************************************************
1705 * ObfDereferenceObject (NTOSKRNL.EXE.@)
1707 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1708 DEFINE_FASTCALL1_ENTRYPOINT( ObfDereferenceObject
)
1709 void WINAPI
__regs_ObfDereferenceObject( VOID
*obj
)
1711 void WINAPI
ObfDereferenceObject( VOID
*obj
)
1714 FIXME( "stub: %p\n", obj
);
1718 /***********************************************************************
1719 * PsCreateSystemThread (NTOSKRNL.EXE.@)
1721 NTSTATUS WINAPI
PsCreateSystemThread(PHANDLE ThreadHandle
, ULONG DesiredAccess
,
1722 POBJECT_ATTRIBUTES ObjectAttributes
,
1723 HANDLE ProcessHandle
, PCLIENT_ID ClientId
,
1724 PKSTART_ROUTINE StartRoutine
, PVOID StartContext
)
1726 if (!ProcessHandle
) ProcessHandle
= GetCurrentProcess();
1727 return RtlCreateUserThread(ProcessHandle
, 0, FALSE
, 0, 0,
1728 0, StartRoutine
, StartContext
,
1729 ThreadHandle
, ClientId
);
1732 /***********************************************************************
1733 * PsGetCurrentProcessId (NTOSKRNL.EXE.@)
1735 HANDLE WINAPI
PsGetCurrentProcessId(void)
1737 if (GetCurrentThreadId() == request_thread
)
1738 return UlongToHandle(client_pid
);
1739 return UlongToHandle(GetCurrentProcessId());
1743 /***********************************************************************
1744 * PsGetCurrentThreadId (NTOSKRNL.EXE.@)
1746 HANDLE WINAPI
PsGetCurrentThreadId(void)
1748 if (GetCurrentThreadId() == request_thread
)
1749 return UlongToHandle(client_tid
);
1750 return UlongToHandle(GetCurrentThreadId());
1754 /***********************************************************************
1755 * PsGetVersion (NTOSKRNL.EXE.@)
1757 BOOLEAN WINAPI
PsGetVersion(ULONG
*major
, ULONG
*minor
, ULONG
*build
, UNICODE_STRING
*version
)
1759 RTL_OSVERSIONINFOEXW info
;
1761 info
.dwOSVersionInfoSize
= sizeof(info
);
1762 RtlGetVersion( &info
);
1763 if (major
) *major
= info
.dwMajorVersion
;
1764 if (minor
) *minor
= info
.dwMinorVersion
;
1765 if (build
) *build
= info
.dwBuildNumber
;
1769 #if 0 /* FIXME: GameGuard passes an uninitialized pointer in version->Buffer */
1770 size_t len
= min( strlenW(info
.szCSDVersion
)*sizeof(WCHAR
), version
->MaximumLength
);
1771 memcpy( version
->Buffer
, info
.szCSDVersion
, len
);
1772 if (len
< version
->MaximumLength
) version
->Buffer
[len
/ sizeof(WCHAR
)] = 0;
1773 version
->Length
= len
;
1780 /***********************************************************************
1781 * PsImpersonateClient (NTOSKRNL.EXE.@)
1783 NTSTATUS WINAPI
PsImpersonateClient(PETHREAD Thread
, PACCESS_TOKEN Token
, BOOLEAN CopyOnOpen
,
1784 BOOLEAN EffectiveOnly
, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
1786 FIXME("(%p, %p, %u, %u, %u): stub\n", Thread
, Token
, CopyOnOpen
, EffectiveOnly
, ImpersonationLevel
);
1788 return STATUS_NOT_IMPLEMENTED
;
1792 /***********************************************************************
1793 * PsSetCreateProcessNotifyRoutine (NTOSKRNL.EXE.@)
1795 NTSTATUS WINAPI
PsSetCreateProcessNotifyRoutine( PCREATE_PROCESS_NOTIFY_ROUTINE callback
, BOOLEAN remove
)
1797 FIXME( "stub: %p %d\n", callback
, remove
);
1798 return STATUS_SUCCESS
;
1802 /***********************************************************************
1803 * PsSetCreateThreadNotifyRoutine (NTOSKRNL.EXE.@)
1805 NTSTATUS WINAPI
PsSetCreateThreadNotifyRoutine( PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine
)
1807 FIXME( "stub: %p\n", NotifyRoutine
);
1808 return STATUS_SUCCESS
;
1812 /***********************************************************************
1813 * PsTerminateSystemThread (NTOSKRNL.EXE.@)
1815 NTSTATUS WINAPI
PsTerminateSystemThread(NTSTATUS ExitStatus
)
1817 FIXME( "stub: %u\n", ExitStatus
);
1818 return STATUS_NOT_IMPLEMENTED
;
1822 /***********************************************************************
1823 * MmGetSystemRoutineAddress (NTOSKRNL.EXE.@)
1825 PVOID WINAPI
MmGetSystemRoutineAddress(PUNICODE_STRING SystemRoutineName
)
1828 STRING routineNameA
;
1831 static const WCHAR ntoskrnlW
[] = {'n','t','o','s','k','r','n','l','.','e','x','e',0};
1832 static const WCHAR halW
[] = {'h','a','l','.','d','l','l',0};
1834 if (!SystemRoutineName
) return NULL
;
1836 if (RtlUnicodeStringToAnsiString( &routineNameA
, SystemRoutineName
, TRUE
) == STATUS_SUCCESS
)
1838 /* We only support functions exported from ntoskrnl.exe or hal.dll */
1839 hMod
= GetModuleHandleW( ntoskrnlW
);
1840 pFunc
= GetProcAddress( hMod
, routineNameA
.Buffer
);
1843 hMod
= GetModuleHandleW( halW
);
1844 if (hMod
) pFunc
= GetProcAddress( hMod
, routineNameA
.Buffer
);
1846 RtlFreeAnsiString( &routineNameA
);
1850 TRACE( "%s -> %p\n", debugstr_us(SystemRoutineName
), pFunc
);
1852 FIXME( "%s not found\n", debugstr_us(SystemRoutineName
) );
1857 /***********************************************************************
1858 * MmQuerySystemSize (NTOSKRNL.EXE.@)
1860 MM_SYSTEMSIZE WINAPI
MmQuerySystemSize(void)
1863 return MmLargeSystem
;
1866 /***********************************************************************
1867 * KeInitializeDpc (NTOSKRNL.EXE.@)
1869 VOID WINAPI
KeInitializeDpc(PRKDPC Dpc
, PKDEFERRED_ROUTINE DeferredRoutine
, PVOID DeferredContext
)
1874 /***********************************************************************
1875 * READ_REGISTER_BUFFER_UCHAR (NTOSKRNL.EXE.@)
1877 VOID WINAPI
READ_REGISTER_BUFFER_UCHAR(PUCHAR Register
, PUCHAR Buffer
, ULONG Count
)
1882 /*****************************************************
1883 * PoSetPowerState (NTOSKRNL.EXE.@)
1885 POWER_STATE WINAPI
PoSetPowerState(PDEVICE_OBJECT DeviceObject
, POWER_STATE_TYPE Type
, POWER_STATE State
)
1887 FIXME("(%p %u %u) stub\n", DeviceObject
, Type
, State
.DeviceState
);
1891 /*****************************************************
1892 * IoWMIRegistrationControl (NTOSKRNL.EXE.@)
1894 NTSTATUS WINAPI
IoWMIRegistrationControl(PDEVICE_OBJECT DeviceObject
, ULONG Action
)
1896 FIXME("(%p %u) stub\n", DeviceObject
, Action
);
1897 return STATUS_SUCCESS
;
1900 /*****************************************************
1901 * PsSetLoadImageNotifyRoutine (NTOSKRNL.EXE.@)
1903 NTSTATUS WINAPI
PsSetLoadImageNotifyRoutine(PLOAD_IMAGE_NOTIFY_ROUTINE routine
)
1905 FIXME("(%p) stub\n", routine
);
1906 return STATUS_SUCCESS
;
1909 /*****************************************************
1910 * PsLookupProcessByProcessId (NTOSKRNL.EXE.@)
1912 NTSTATUS WINAPI
PsLookupProcessByProcessId(HANDLE processid
, PEPROCESS
*process
)
1915 if (!once
++) FIXME("(%p %p) stub\n", processid
, process
);
1916 return STATUS_NOT_IMPLEMENTED
;
1920 /*****************************************************
1921 * IoSetThreadHardErrorMode (NTOSKRNL.EXE.@)
1923 BOOLEAN WINAPI
IoSetThreadHardErrorMode(BOOLEAN EnableHardErrors
)
1930 /*****************************************************
1931 * IoInitializeRemoveLockEx (NTOSKRNL.EXE.@)
1933 VOID WINAPI
IoInitializeRemoveLockEx(PIO_REMOVE_LOCK lock
, ULONG tag
,
1934 ULONG maxmin
, ULONG high
, ULONG size
)
1936 FIXME("(%p %u %u %u %u) stub\n", lock
, tag
, maxmin
, high
, size
);
1940 /*****************************************************
1941 * IoAcquireRemoveLockEx (NTOSKRNL.EXE.@)
1944 NTSTATUS WINAPI
IoAcquireRemoveLockEx(PIO_REMOVE_LOCK lock
, PVOID tag
,
1945 LPCSTR file
, ULONG line
, ULONG lock_size
)
1947 FIXME("(%p, %p, %s, %u, %u): stub\n", lock
, tag
, debugstr_a(file
), line
, lock_size
);
1949 return STATUS_NOT_IMPLEMENTED
;
1953 /*****************************************************
1956 BOOL WINAPI
DllMain( HINSTANCE inst
, DWORD reason
, LPVOID reserved
)
1958 static void *handler
;
1959 LARGE_INTEGER count
;
1963 case DLL_PROCESS_ATTACH
:
1964 DisableThreadLibraryCalls( inst
);
1966 handler
= RtlAddVectoredExceptionHandler( TRUE
, vectored_handler
);
1968 KeQueryTickCount( &count
); /* initialize the global KeTickCount */
1970 case DLL_PROCESS_DETACH
:
1971 if (reserved
) break;
1972 RtlRemoveVectoredExceptionHandler( handler
);
1978 /*****************************************************
1979 * Ke386IoSetAccessProcess (NTOSKRNL.EXE.@)
1981 BOOLEAN WINAPI
Ke386IoSetAccessProcess(PEPROCESS
*process
, ULONG flag
)
1983 FIXME("(%p %d) stub\n", process
, flag
);
1987 /*****************************************************
1988 * Ke386SetIoAccessMap (NTOSKRNL.EXE.@)
1990 BOOLEAN WINAPI
Ke386SetIoAccessMap(ULONG flag
, PVOID buffer
)
1992 FIXME("(%d %p) stub\n", flag
, buffer
);
1996 /*****************************************************
1997 * IoCreateSynchronizationEvent (NTOSKRNL.EXE.@)
1999 PKEVENT WINAPI
IoCreateSynchronizationEvent(PUNICODE_STRING name
, PHANDLE handle
)
2001 FIXME("(%p %p) stub\n", name
, handle
);
2005 /*****************************************************
2006 * IoStartNextPacket (NTOSKRNL.EXE.@)
2008 VOID WINAPI
IoStartNextPacket(PDEVICE_OBJECT deviceobject
, BOOLEAN cancelable
)
2010 FIXME("(%p %d) stub\n", deviceobject
, cancelable
);
2013 /*****************************************************
2014 * ObQueryNameString (NTOSKRNL.EXE.@)
2016 NTSTATUS WINAPI
ObQueryNameString(PVOID object
, POBJECT_NAME_INFORMATION name
, ULONG maxlength
, PULONG returnlength
)
2018 FIXME("(%p %p %u %p) stub\n", object
, name
, maxlength
, returnlength
);
2019 return STATUS_NOT_IMPLEMENTED
;
2022 /*****************************************************
2023 * IoRegisterPlugPlayNotification (NTOSKRNL.EXE.@)
2025 NTSTATUS WINAPI
IoRegisterPlugPlayNotification(IO_NOTIFICATION_EVENT_CATEGORY category
, ULONG flags
, PVOID data
,
2026 PDRIVER_OBJECT driver
, PDRIVER_NOTIFICATION_CALLBACK_ROUTINE callback
,
2027 PVOID context
, PVOID
*notification
)
2029 FIXME("(%u %u %p %p %p %p %p) stub\n", category
, flags
, data
, driver
, callback
, context
, notification
);
2030 return STATUS_SUCCESS
;
2033 /*****************************************************
2034 * IoCsqInitialize (NTOSKRNL.EXE.@)
2036 NTSTATUS WINAPI
IoCsqInitialize(PIO_CSQ csq
, PIO_CSQ_INSERT_IRP insert_irp
, PIO_CSQ_REMOVE_IRP remove_irp
,
2037 PIO_CSQ_PEEK_NEXT_IRP peek_irp
, PIO_CSQ_ACQUIRE_LOCK acquire_lock
,
2038 PIO_CSQ_RELEASE_LOCK release_lock
, PIO_CSQ_COMPLETE_CANCELED_IRP complete_irp
)
2040 FIXME("(%p %p %p %p %p %p %p) stub\n",
2041 csq
, insert_irp
, remove_irp
, peek_irp
, acquire_lock
, release_lock
, complete_irp
);
2042 return STATUS_SUCCESS
;
2045 /*****************************************************
2046 * ExInterlockedRemoveHeadList (NTOSKRNL.EXE.@)
2048 PLIST_ENTRY WINAPI
ExInterlockedRemoveHeadList(PLIST_ENTRY head
, PKSPIN_LOCK lock
)
2050 FIXME("(%p %p) stub\n", head
, lock
);
2054 /***********************************************************************
2055 * ExfInterlockedRemoveHeadList (NTOSKRNL.EXE.@)
2057 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
2058 DEFINE_FASTCALL2_ENTRYPOINT( ExfInterlockedRemoveHeadList
)
2059 PLIST_ENTRY WINAPI
__regs_ExfInterlockedRemoveHeadList(PLIST_ENTRY head
, PKSPIN_LOCK lock
)
2061 PLIST_ENTRY WINAPI
ExfInterlockedRemoveHeadList(PLIST_ENTRY head
, PKSPIN_LOCK lock
)
2064 FIXME("(%p %p) stub\n", head
, lock
);
2065 return ExInterlockedRemoveHeadList( head
, lock
);